public void CreateAggregateUnsafe() { var aggregationManager = new MetricAggregationManager(); var seriesConfig = new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true); IEnumerable <KeyValuePair <string, string> > setDimensionNamesValues = new KeyValuePair <string, string>[] { new KeyValuePair <string, string>("Dim 1", "DV1"), new KeyValuePair <string, string>("Dim 2", "DV2"), new KeyValuePair <string, string>("Dim 3", "DV3"), new KeyValuePair <string, string>("Dim 2", "DV2a") }; IEnumerable <KeyValuePair <string, string> > expectedDimensionNamesValues = new KeyValuePair <string, string>[] { new KeyValuePair <string, string>("Dim 1", "DV1"), new KeyValuePair <string, string>("Dim 2", "DV2a"), new KeyValuePair <string, string>("Dim 3", "DV3") }; var metric = new MetricSeries( aggregationManager, new MetricIdentifier(String.Empty, "Cows Sold", expectedDimensionNamesValues.Select(nv => nv.Key).ToArray()), setDimensionNamesValues, seriesConfig); var aggregator = new MeasurementAggregator( (MetricSeriesConfigurationForMeasurement)metric.GetConfiguration(), metric, CycleKind.Custom); CommonSimpleDataSeriesAggregatorTests.CreateAggregateUnsafe(aggregator, metric, expectedDimensionNamesValues); }
public void TryRecycle() { var measurementAggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); CommonSimpleDataSeriesAggregatorTests.TryRecycle_NonpersistentAggregator(measurementAggregator); }
public void Reset() { { var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); CommonSimpleDataSeriesAggregatorTests.Reset_NonersistentAggregator(aggregator, aggregateKindMoniker: "Microsoft.Azure.Measurement"); } }
public void Ctor() { Assert.ThrowsException <ArgumentNullException>(() => new MeasurementAggregator(configuration: null, dataSeries: null, aggregationCycleKind: CycleKind.Custom)); { var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); Assert.IsNotNull(aggregator); } }
public void CompleteAggregation() { var aggregationManager = new MetricAggregationManager(); var mesurementConfig = new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true); var measurementMetric = new MetricSeries(aggregationManager, new MetricIdentifier("Cows Sold"), null, mesurementConfig); var measurementAggregator = new MeasurementAggregator( (MetricSeriesConfigurationForMeasurement)measurementMetric.GetConfiguration(), measurementMetric, CycleKind.Custom); CommonSimpleDataSeriesAggregatorTests.CompleteAggregation_NonpersistentAggregator(measurementAggregator); }
public void TryRecycle() { var measurementAggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); var accumulatorAggregator = new MetricSeriesConfigurationForTestingAccumulatorBehavior.Aggregator( new MetricSeriesConfigurationForTestingAccumulatorBehavior(), dataSeries: null, aggregationCycleKind: CycleKind.Custom); CommonSimpleDataSeriesAggregatorTests.TryRecycle_NonpersistentAggregator(measurementAggregator); CommonSimpleDataSeriesAggregatorTests.TryRecycle_PersistentAggregator(accumulatorAggregator); }
public void GetDataSeries() { var aggregationManager = new MetricAggregationManager(); var seriesConfig = new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true); var metric = new MetricSeries(aggregationManager, new MetricIdentifier("Cows Sold"), null, seriesConfig); var aggregatorForConcreteSeries = new MeasurementAggregator( (MetricSeriesConfigurationForMeasurement)metric.GetConfiguration(), dataSeries: metric, aggregationCycleKind: CycleKind.Custom); var aggregatorForNullSeries = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); CommonSimpleDataSeriesAggregatorTests.GetDataSeries(aggregatorForConcreteSeries, aggregatorForNullSeries, metric); }
public void Reset() { { var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); CommonSimpleDataSeriesAggregatorTests.Reset_NonpersistentAggregator(aggregator, aggregateKindMoniker: "Microsoft.Azure.Measurement"); } { var aggregator = new MetricSeriesConfigurationForTestingAccumulatorBehavior.Aggregator( new MetricSeriesConfigurationForTestingAccumulatorBehavior(), dataSeries: null, aggregationCycleKind: CycleKind.Custom); CommonSimpleDataSeriesAggregatorTests.Reset_PersistentAggregator(aggregator, aggregateKindMoniker: "Microsoft.Azure.AccumulatorForTesting"); } }
public void Reset() { { var aggregator = new MeasurementAggregator( new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); CommonSimpleDataSeriesAggregatorTests.Reset_NonersistentAggregator(aggregator, aggregateKindMoniker: "Microsoft.Azure.SimpleStatistics"); } { var aggregator = new AccumulatorAggregator( new AccumulatorMetricSeriesConfiguration(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); CommonSimpleDataSeriesAggregatorTests.Reset_PersistentAggregator(aggregator, aggregateKindMoniker: "Microsoft.Azure.Accumulator"); } }
public void TrackValueConcurrently() { var endTS = new DateTimeOffset(2017, 9, 25, 17, 1, 0, TimeSpan.FromHours(-8)); long periodMillis = (long)(endTS - default(DateTimeOffset)).TotalMilliseconds; var aggregator = new MeasurementAggregator( //var aggregator = new SimpleUInt32DataSeriesAggregator( new SimpleMetricSeriesConfiguration(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); List <Task> parallelTasks = new List <Task>(); s_trackValueConcurrentWorker_Current = 0; s_trackValueConcurrentWorker_Max = 0; for (int i = 0; i < 100; i++) { Task t = Task.Run(() => TrackValueConcurrentWorker(aggregator)); parallelTasks.Add(t); } Task.WaitAll(parallelTasks.ToArray()); Assert.AreEqual(0, s_trackValueConcurrentWorker_Current); Assert.IsTrue( 90 <= s_trackValueConcurrentWorker_Max, "The local machine has timing characteristics resuling in not enough concurrency. Try re-running or tweaking delays." + $" (s_trackValueConcurrentWorker_Max = {s_trackValueConcurrentWorker_Max})"); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); #if DEBUG Trace.WriteLine($"s_countBufferWaitSpinEvents: {MetricSeriesAggregatorBase<double>.s_countBufferWaitSpinEvents}"); Trace.WriteLine($"s_countBufferWaitSpinCycles: {MetricSeriesAggregatorBase<double>.s_countBufferWaitSpinCycles}"); Trace.WriteLine($"s_timeBufferWaitSpinMillis: {TimeSpan.FromMilliseconds(MetricSeriesAggregatorBase<double>.s_timeBufferWaitSpinMillis)}"); Trace.WriteLine($"s_countBufferFlushes: {MetricSeriesAggregatorBase<double>.s_countBufferFlushes}"); Trace.WriteLine($"s_countNewBufferObjectsCreated: {MetricSeriesAggregatorBase<double>.s_countNewBufferObjectsCreated}"); #endif ValidateNumericAggregateValues(aggregate, name: "null", count: 5050000, sum: 757500000000, max: 300000, min: 0, stdDev: 87464.2784226795, timestamp: default(DateTimeOffset), periodMs: periodMillis); }
public void CompleteAggregation() { var aggregationManager = new MetricAggregationManager(); var mesurementConfig = new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: false); var measurementMetric = new MetricSeries(aggregationManager, new MetricIdentifier("Animal Metrics", "Cows Sold"), null, mesurementConfig); var measurementAggregator = new MeasurementAggregator( (MetricSeriesConfigurationForMeasurement)measurementMetric.GetConfiguration(), measurementMetric, CycleKind.Custom); var accumulatorConfig = new MetricSeriesConfigurationForTestingAccumulatorBehavior(); var accumulatorMetric = new MetricSeries(aggregationManager, new MetricIdentifier("Animal Metrics", "Cows Sold"), null, accumulatorConfig); var accumulatorAggregator = new MetricSeriesConfigurationForTestingAccumulatorBehavior.Aggregator( (MetricSeriesConfigurationForTestingAccumulatorBehavior)accumulatorMetric.GetConfiguration(), accumulatorMetric, CycleKind.Custom); CommonSimpleDataSeriesAggregatorTests.CompleteAggregation_NonpersistentAggregator(measurementAggregator); CommonSimpleDataSeriesAggregatorTests.CompleteAggregation_PersistentAggregator(accumulatorAggregator); }
public void CreateAggregateUnsafe() { var aggregationManager = new MetricAggregationManager(); var seriesConfig = new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false); IEnumerable <KeyValuePair <string, string> > setDimensionNamesValues = new KeyValuePair <string, string>[] { new KeyValuePair <string, string>("Dim 1", "DV1"), new KeyValuePair <string, string>("Dim 2", "DV2"), new KeyValuePair <string, string>("Dim 3", "DV3"), new KeyValuePair <string, string>("Dim 2", "DV2a") }; IEnumerable <KeyValuePair <string, string> > expectedDimensionNamesValues = new KeyValuePair <string, string>[] { new KeyValuePair <string, string>("Dim 1", "DV1"), new KeyValuePair <string, string>("Dim 2", "DV2a"), new KeyValuePair <string, string>("Dim 3", "DV3") }; var metric = new MetricSeries(aggregationManager, "Cows Sold", setDimensionNamesValues, seriesConfig); var aggregator = new MeasurementAggregator( (SimpleMetricSeriesConfiguration)metric.GetConfiguration(), metric, CycleKind.Custom); CommonSimpleDataSeriesAggregatorTests.CreateAggregateUnsafe(aggregator, metric, expectedDimensionNamesValues); }
public void CompleteAggregation() { var aggregationManager = new MetricAggregationManager(); var mesurementConfig = new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false); var measurementMetric = new MetricSeries(aggregationManager, "Cows Sold", null, mesurementConfig); var measurementAggregator = new MeasurementAggregator( (SimpleMetricSeriesConfiguration)measurementMetric.GetConfiguration(), measurementMetric, CycleKind.Custom); var accumulatorConfig = new AccumulatorMetricSeriesConfiguration(restrictToUInt32Values: false); var accumulatorMetric = new MetricSeries(aggregationManager, "Cows Sold", null, accumulatorConfig); var accumulatorAggregator = new AccumulatorAggregator( (AccumulatorMetricSeriesConfiguration)accumulatorMetric.GetConfiguration(), accumulatorMetric, CycleKind.Custom); CommonSimpleDataSeriesAggregatorTests.CompleteAggregation_NonpersistentAggregator(measurementAggregator); CommonSimpleDataSeriesAggregatorTests.CompleteAggregation_PersistentAggregator(accumulatorAggregator); }
/// <summary>Creates a new aggregator capable of aggregating according to this configurations.</summary> /// <param name="dataSeries">Metric data tie series to be aggregated.</param> /// <param name="aggregationCycleKind">The kind of th aggregtion cycle.</param> /// <returns>A new metric aggregator.</returns> public IMetricSeriesAggregator CreateNewAggregator(MetricSeries dataSeries, MetricAggregationCycleKind aggregationCycleKind) { IMetricSeriesAggregator aggregator = new MeasurementAggregator(this, dataSeries, aggregationCycleKind); return(aggregator); }
public void TrackValueObject() { var endTS = new DateTimeOffset(2017, 9, 25, 17, 1, 0, TimeSpan.FromHours(-8)); long periodMillis = (long)(endTS - default(DateTimeOffset)).TotalMilliseconds; var aggregator = new MeasurementAggregator( new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); aggregator.TrackValue(null); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((object)(Boolean)true)); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 0, sum: 0.0, max: 0.0, min: 0.0, stdDev: 0.0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue((object)(SByte)(0 - 1)); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 1, sum: -1, max: -1, min: -1, stdDev: 0.0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue((object)(Byte)2); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 2, sum: 1, max: 2, min: -1, stdDev: 1.5, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue((object)(Int16)(0 - 3)); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 3, sum: -2, max: 2, min: -3, stdDev: 2.05480466765633, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue((object)(UInt16)4); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 4, sum: 2, max: 4, min: -3, stdDev: 2.69258240356725, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue((object)(Int32)(0 - 5)); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 5, sum: -3, max: 4, min: -5, stdDev: 3.26190128606002, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue((object)(UInt32)6); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 6, sum: 3, max: 6, min: -5, stdDev: 3.86221007541882, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue((object)(Int64)(0 - 7)); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 7, sum: -4, max: 6, min: -7, stdDev: 4.43547848464572, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue((object)(UInt64)8); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 8, sum: 4, max: 8, min: -7, stdDev: 5.02493781056044, timestamp: default(DateTimeOffset), periodMs: periodMillis); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((object)(IntPtr)0xFF)); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((object)(UIntPtr)0xFF)); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((object)(Char)'x')); aggregator.TrackValue((object)(Single)(0f - 9.0f)); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 9, sum: -5, max: 8, min: -9, stdDev: 5.59982363037962000, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue((object)(Double)10.0); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 10, sum: 5, max: 10, min: -9, stdDev: 6.18465843842649000, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue("-11"); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 11, sum: -6, max: 10, min: -11, stdDev: 6.76036088821026, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue("12.00"); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 12, sum: 6, max: 12, min: -11, stdDev: 7.34279692397023, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue("-1.300E+01"); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 13, sum: -7, max: 12, min: -13, stdDev: 7.91896831484996, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(" +14. "); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 14, sum: 7, max: 14, min: -13, stdDev: 8.5, timestamp: default(DateTimeOffset), periodMs: periodMillis); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue("fifteen")); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue("")); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue("foo-bar")); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 14, sum: 7, max: 14, min: -13, stdDev: 8.5, timestamp: default(DateTimeOffset), periodMs: periodMillis); }
public void TrackValueDouble() { var endTS = new DateTimeOffset(2017, 9, 25, 17, 1, 0, TimeSpan.FromHours(-8)); long periodMillis = (long)(endTS - default(DateTimeOffset)).TotalMilliseconds; { // Empty aggregator: var aggregator = new MeasurementAggregator( new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 0, sum: 0.0, max: 0.0, min: 0.0, stdDev: 0.0, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Zero value: var aggregator = new MeasurementAggregator( new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); aggregator.TrackValue(0); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 1, sum: 0.0, max: 0.0, min: 0.0, stdDev: 0.0, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Non zero value: var aggregator = new MeasurementAggregator( new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); aggregator.TrackValue(-42); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 1, sum: -42.0, max: -42.0, min: -42.0, stdDev: 0.0, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Two values: var aggregator = new MeasurementAggregator( new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); aggregator.TrackValue(-42); aggregator.TrackValue(18); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 2, sum: -24.0, max: 18.0, min: -42.0, stdDev: 30.0, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // 3 values: var aggregator = new MeasurementAggregator( new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); aggregator.TrackValue(1800000); aggregator.TrackValue(0); aggregator.TrackValue(-4200000); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 3, sum: -2400000.0, max: 1800000.0, min: -4200000.0, stdDev: 2513961.018, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // NaNs: var aggregator = new MeasurementAggregator( new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); aggregator.TrackValue(Double.NaN); aggregator.TrackValue(1); aggregator.TrackValue(Double.NaN); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 1, sum: 1, max: 1, min: 1, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Infinity: var aggregator = new MeasurementAggregator( new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 0, sum: 0, max: 0, min: 0, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(1); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 1, sum: 1, max: 1, min: 1, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(0.5); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 2, sum: 1.5, max: 1, min: 0.5, stdDev: 0.25, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(Double.PositiveInfinity); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 3, sum: Double.MaxValue, max: Double.MaxValue, min: 0.5, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(Int32.MinValue); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 4, sum: Double.MaxValue, max: Double.MaxValue, min: Int32.MinValue, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(Double.PositiveInfinity); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 5, sum: Double.MaxValue, max: Double.MaxValue, min: Int32.MinValue, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(Double.NegativeInfinity); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 6, sum: 0.0, max: Double.MaxValue, min: -Double.MaxValue, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(11); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 7, sum: 0.0, max: Double.MaxValue, min: -Double.MaxValue, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Very large numbers: var aggregator = new MeasurementAggregator( new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 0, sum: 0, max: 0, min: 0, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(Math.Exp(300)); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 1, sum: Math.Exp(300), max: Math.Exp(300), min: Math.Exp(300), stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(-2 * Math.Exp(300)); double minus2exp200 = -2 * Math.Exp(300); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 2, sum: -Math.Exp(300), max: Math.Exp(300), min: minus2exp200, stdDev: 2.91363959286188000E+130, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(Math.Exp(300)); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 3, sum: 0, max: Math.Exp(300), min: minus2exp200, stdDev: 2.74700575206167000E+130, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(Math.Exp(700)); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 4, sum: Math.Exp(700), max: Math.Exp(700), min: minus2exp200, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(Double.MaxValue); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 5, sum: Double.MaxValue, max: Double.MaxValue, min: minus2exp200, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(Double.MaxValue); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 6, sum: Double.MaxValue, max: Double.MaxValue, min: minus2exp200, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(11); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 7, sum: Double.MaxValue, max: Double.MaxValue, min: minus2exp200, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(-Double.MaxValue); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 8, sum: Double.MaxValue, max: Double.MaxValue, min: -Double.MaxValue, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(-Double.PositiveInfinity); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 9, sum: 0, max: Double.MaxValue, min: -Double.MaxValue, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Large number of small values: var aggregator = new MeasurementAggregator( new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); for (int i = 0; i < 100000; i++) { for (double v = 0; v <= 1.0 || Math.Abs(1.0 - v) < TestUtil.Util.MaxAllowedPrecisionError; v += 0.01) { aggregator.TrackValue(v); } } MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 10100000, sum: 5050000, max: 1, min: 0, stdDev: 0.29154759474226500, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Large number of large values: var aggregator = new MeasurementAggregator( new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); for (int i = 0; i < 100000; i++) { for (double v = 0; v <= 300000.0 || Math.Abs(300000.0 - v) < TestUtil.Util.MaxAllowedPrecisionError; v += 3000) { aggregator.TrackValue(v); } } MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 10100000, sum: 1515000000000, max: 300000, min: 0, stdDev: 87464.2784226795, timestamp: default(DateTimeOffset), periodMs: periodMillis); } }
public void TrackValueDouble() { var endTS = new DateTimeOffset(2017, 9, 25, 17, 1, 0, TimeSpan.FromHours(-8)); long periodMillis = (long)(endTS - default(DateTimeOffset)).TotalMilliseconds; { // Empty aggregator: var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 0, sum: 0.0, max: 0.0, min: 0.0, stdDev: 0.0, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Zero value: var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); aggregator.TrackValue(0); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 1, sum: 0.0, max: 0.0, min: 0.0, stdDev: 0.0, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Values out of range: var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue(-1)); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue(Int32.MinValue)); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue(Int64.MinValue)); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue(0.1)); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue(0.9)); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((float)50.01)); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue(50.99)); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue(((long)UInt32.MaxValue) + (long)1)); aggregator.TrackValue(Double.NaN); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue(Double.PositiveInfinity)); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue(Double.NegativeInfinity)); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue(Double.MaxValue)); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 0, sum: 0, max: 0, min: 0, stdDev: 0.0, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // A single value: var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: false), dataSeries: null, aggregationCycleKind: CycleKind.Custom); aggregator.TrackValue(42); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 1, sum: 42.0, max: 42.0, min: 42.0, stdDev: 0.0, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Two values: var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); aggregator.TrackValue(42); aggregator.TrackValue(19); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 2, sum: 61.0, max: 42.0, min: 19.0, stdDev: 11.5, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // 3 values: var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); aggregator.TrackValue(1800000); aggregator.TrackValue(0); aggregator.TrackValue(4200000); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 3, sum: 6000000, max: 4200000.0, min: 0, stdDev: 1720465.05340853, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Rounded values: var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); aggregator.TrackValue(1); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 1, sum: 1, max: 1, min: 1, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(-0.0000001); aggregator.TrackValue(0.00000001); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 3, sum: 1, max: 1, min: 0, stdDev: 0.471404520791032, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(100.0000001); aggregator.TrackValue(99.9999999); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 5, sum: 201, max: 100, min: 0, stdDev: 48.8278608992858, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(((double)Int32.MaxValue) - 0.0000001); aggregator.TrackValue(((double)Int32.MaxValue) + 0.0000001); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 7, sum: 4294967495, max: 2147483647, min: 0, stdDev: 970134205.051638, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(((double)UInt32.MaxValue) - 0.0000001); aggregator.TrackValue(((double)UInt32.MaxValue) + 0.0000001); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 9, sum: 12884902085, max: 4294967295, min: 0, stdDev: 1753413037.5015, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Very large numbers: var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 0, sum: 0, max: 0, min: 0, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); aggregator.TrackValue(UInt32.MaxValue - 10000); aggregator.TrackValue(UInt32.MaxValue - 1000); aggregator.TrackValue(UInt32.MaxValue - 100); aggregator.TrackValue(UInt32.MaxValue); aggregate = aggregator.CreateAggregateUnsafe(endTS); // ToDo!! // We need a more numerically stable value for the calculation of StdDev / variance. // For example, in this case, the expected value is 4189.49579305195, but we get 4189.4343293576, which is close, but still quite a bit off. // Since StdDev is utilized rarely, we leave this for later and put the actual outcome into the test expectation to catch breaks in the future. ValidateNumericAggregateValues(aggregate, name: "null", count: 4, sum: 17179858080, max: 4294967295, min: 4294957295, stdDev: 4189.4343293576, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Large number of small values: var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); for (int i = 0; i < 100000; i++) { for (int v = 0; v <= 100; v++) { aggregator.TrackValue(v); } } MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 10100000, sum: 505000000, max: 100, min: 0, stdDev: 29.1547594742265, timestamp: default(DateTimeOffset), periodMs: periodMillis); } { // Large number of large values: var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); for (int i = 0; i < 100000; i++) { for (int v = 0; v <= 300000; v += 3000) { aggregator.TrackValue(v); } } MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 10100000, sum: 1515000000000, max: 300000, min: 0, stdDev: 87464.2784226795, timestamp: default(DateTimeOffset), periodMs: periodMillis); } }
public void TrackValueObject() { var endTS = new DateTimeOffset(2017, 9, 25, 17, 1, 0, TimeSpan.FromHours(-8)); long periodMillis = (long)(endTS - default(DateTimeOffset)).TotalMilliseconds; var aggregator = new MeasurementAggregator( new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: true), dataSeries: null, aggregationCycleKind: CycleKind.Custom); aggregator.TrackValue(null); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((object)(Boolean)true)); MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 0, sum: 0.0, max: 0.0, min: 0.0, stdDev: 0.0, timestamp: default(DateTimeOffset), periodMs: periodMillis); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((object)(SByte)(0 - 1))); aggregator.TrackValue((object)(Byte)2); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 1, sum: 2, max: 2, min: 2, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodMillis); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((object)(Int16)(0 - 3))); aggregator.TrackValue((object)(UInt16)4); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 2, sum: 6, max: 4, min: 2, stdDev: 1, timestamp: default(DateTimeOffset), periodMs: periodMillis); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((object)(Int32)(0 - 5))); aggregator.TrackValue((object)(UInt32)6); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 3, sum: 12, max: 6, min: 2, stdDev: 1.63299316185545, timestamp: default(DateTimeOffset), periodMs: periodMillis); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((object)(Int64)(0 - 7))); aggregator.TrackValue((object)(UInt64)8); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 4, sum: 20, max: 8, min: 2, stdDev: 2.23606797749979, timestamp: default(DateTimeOffset), periodMs: periodMillis); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((object)(IntPtr)0xFF)); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((object)(UIntPtr)0xFF)); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((object)(Char)'x')); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue((object)(Single)(0f - 9.0f))); aggregator.TrackValue((object)(Double)10.0); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 5, sum: 30, max: 10, min: 2, stdDev: 2.82842712474619, timestamp: default(DateTimeOffset), periodMs: periodMillis); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue("-11")); aggregator.TrackValue("12"); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 6, sum: 42, max: 12, min: 2, stdDev: 3.41565025531987, timestamp: default(DateTimeOffset), periodMs: periodMillis); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue("-1.300E+01")); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue("13.5")); aggregator.TrackValue(" +14 "); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 7, sum: 56, max: 14, min: 2, stdDev: 4, timestamp: default(DateTimeOffset), periodMs: periodMillis); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue("fifteen")); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue("")); Assert.ThrowsException <ArgumentException>(() => aggregator.TrackValue("foo-bar")); aggregate = aggregator.CreateAggregateUnsafe(endTS); ValidateNumericAggregateValues(aggregate, name: "null", count: 7, sum: 56, max: 14, min: 2, stdDev: 4, timestamp: default(DateTimeOffset), periodMs: periodMillis); }