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);
}