public static void TryRecycle_PersistentAggregator(IMetricSeriesAggregator accumulatorAggregator)
{
var startTS = new DateTimeOffset(2017, 9, 25, 17, 0, 0, TimeSpan.FromHours(-8));
var endTS = new DateTimeOffset(2017, 9, 25, 17, 1, 0, TimeSpan.FromHours(-8));
long periodStringDef = (long)(endTS - default(DateTimeOffset)).TotalMilliseconds;
long periodStringStart = (long)(endTS - startTS).TotalMilliseconds;
{
accumulatorAggregator.TrackValue(10);
MetricAggregate aggregate = accumulatorAggregator.CreateAggregateUnsafe(endTS);
TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "null", count: 0, sum: 10.0, max: 10.0, min: 10.0, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodStringDef, aggKindMoniker: "Microsoft.Azure.Accumulator");
accumulatorAggregator.Reset(startTS, valueFilter: null);
accumulatorAggregator.TrackValue(0);
accumulatorAggregator.TrackValue(10);
accumulatorAggregator.TrackValue(20);
aggregate = accumulatorAggregator.CreateAggregateUnsafe(endTS);
TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "null", count: 0, sum: 30.0, max: 30.0, min: 0.0, stdDev: 0, timestamp: startTS, periodMs: periodStringStart, aggKindMoniker: "Microsoft.Azure.Accumulator");
bool canRecycle = accumulatorAggregator.TryRecycle();
Assert.IsFalse(canRecycle);
aggregate = accumulatorAggregator.CreateAggregateUnsafe(endTS);
TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "null", count: 2, sum: 30.0, max: 30.0, min: 0.0, stdDev: 5.0, timestamp: startTS, periodMs: periodStringStart, aggKindMoniker: "Microsoft.Azure.Accumulator");
}
}
public static void CompleteAggregation_NonpersistentAggregator(IMetricSeriesAggregator measurementAggregator)
{
var startTS = new DateTimeOffset(2017, 9, 25, 17, 0, 0, TimeSpan.FromHours(-8));
var endTS = new DateTimeOffset(2017, 9, 25, 17, 1, 0, TimeSpan.FromHours(-8));
long periodString = (long)(endTS - startTS).TotalMilliseconds;
int filterInvocationsCount = 0;
measurementAggregator.Reset(startTS, valueFilter: new CustomDoubleValueFilter((s, v) => { filterInvocationsCount++; return(true); }));
Assert.AreEqual(0, filterInvocationsCount);
measurementAggregator.TrackValue(1);
measurementAggregator.TrackValue("2");
MetricAggregate aggregate = measurementAggregator.CompleteAggregation(endTS);
TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "Cows Sold", count: 2, sum: 3, max: 2, min: 1, stdDev: 0.5, timestamp: startTS, periodMs: periodString, aggKindMoniker: "Microsoft.Azure.SimpleStatistics");
Assert.AreEqual(2, filterInvocationsCount);
measurementAggregator.TrackValue("3");
measurementAggregator.TrackValue(4);
aggregate = measurementAggregator.CompleteAggregation(endTS);
//// In earlier versions we used to reject further values after Complete Aggregation was called. However, that complication is not really necesary.
//TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "Cows Sold", count: 2, sum: 3, max: 2, min: 1, stdDev: 0.5, timestamp: startTS, periodMs: periodString, aggKindMoniker: "Microsoft.Azure.SimpleStatistics");
//Assert.AreEqual(2, filterInvocationsCount);
//aggregate = measurementAggregator.CreateAggregateUnsafe(endTS);
//TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "Cows Sold", count: 2, sum: 3, max: 2, min: 1, stdDev: 0.5, timestamp: startTS, periodMs: periodString, aggKindMoniker: "Microsoft.Azure.SimpleStatistics");
TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "Cows Sold", count: 4, sum: 10, max: 4, min: 1, stdDev: 1.11803398874989, timestamp: startTS, periodMs: periodString, aggKindMoniker: "Microsoft.Azure.SimpleStatistics");
Assert.AreEqual(4, filterInvocationsCount);
aggregate = measurementAggregator.CreateAggregateUnsafe(endTS);
TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "Cows Sold", count: 4, sum: 10, max: 4, min: 1, stdDev: 1.11803398874989, timestamp: startTS, periodMs: periodString, aggKindMoniker: "Microsoft.Azure.SimpleStatistics");
}
public static void CreateAggregateUnsafe(
IMetricSeriesAggregator aggregator,
MetricSeries metric,
IEnumerable <KeyValuePair <string, string> > expectedDimensionNamesValues)
{
var startTS = new DateTimeOffset(2017, 9, 25, 17, 0, 0, TimeSpan.FromHours(-8));
var endTS = new DateTimeOffset(2017, 9, 25, 17, 1, 0, TimeSpan.FromHours(-8));
aggregator.Reset(startTS, valueFilter: null);
aggregator.TrackValue(42);
aggregator.TrackValue(43);
MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS);
Assert.IsNotNull(aggregate);
Assert.AreEqual("Cows Sold", aggregate.MetricId, "aggregate.MetricId mismatch");
Assert.AreEqual(2, aggregate.AggregateData["Count"], "aggregate.AggregateData[Count] mismatch");
Assert.AreEqual(85, (double)aggregate.AggregateData["Sum"], TestUtil.Util.MaxAllowedPrecisionError, "aggregate.AggregateData[Sum] mismatch");
Assert.AreEqual(43, (double)aggregate.AggregateData["Max"], TestUtil.Util.MaxAllowedPrecisionError, "aggregate.AggregateData[Max] mismatch");
Assert.AreEqual(42, (double)aggregate.AggregateData["Min"], TestUtil.Util.MaxAllowedPrecisionError, "aggregate.AggregateData[Min] mismatch");
Assert.AreEqual(0.5, (double)aggregate.AggregateData["StdDev"], TestUtil.Util.MaxAllowedPrecisionError, "aggregate.AggregateData[StdDev] mismatch");
Assert.AreEqual(startTS, aggregate.AggregationPeriodStart, "aggregate.AggregationPeriodStart mismatch");
Assert.AreEqual(
(endTS - startTS).TotalMilliseconds,
aggregate.AggregationPeriodDuration.TotalMilliseconds,
"aggregate.AggregationPeriodDuration mismatch");
Assert.AreEqual(expectedDimensionNamesValues.Count(), aggregate.Dimensions.Count);
foreach (KeyValuePair <string, string> dimNameValue in expectedDimensionNamesValues)
{
Assert.IsTrue(aggregate.Dimensions.ContainsKey(dimNameValue.Key), $"missing aggregate.Dimensions[{dimNameValue.Key}]");
Assert.AreEqual(dimNameValue.Value, aggregate.Dimensions[dimNameValue.Key], $"wrong aggregate.Dimensions[{dimNameValue.Key}]");
}
}
private static void TrackValue(IMetricSeriesAggregator aggregator, object metricValue, ref List <Exception> errors)
{
if (aggregator != null)
{
try
{
aggregator.TrackValue(metricValue);
}
catch (Exception ex)
{
(errors = errors ?? new List <Exception>()).Add(ex);
}
}
}
private static async Task TrackValueConcurrentWorker(IMetricSeriesAggregator aggregator)
{
await Task.Delay(3);
int currentWorkersAtStart = Interlocked.Increment(ref s_trackValueConcurrentWorker_Current);
try
{
int maxWorkers = Volatile.Read(ref s_trackValueConcurrentWorker_Max);
while (currentWorkersAtStart > maxWorkers)
{
int prevMaxWorkers = Interlocked.CompareExchange(ref s_trackValueConcurrentWorker_Max, currentWorkersAtStart, maxWorkers);
if (prevMaxWorkers == maxWorkers)
{
break;
}
else
{
maxWorkers = Volatile.Read(ref s_trackValueConcurrentWorker_Max);
}
}
for (int i = 0; i < 500; i++)
{
for (int v = 0; v <= 300000; v += 3000)
{
aggregator.TrackValue(v);
//Thread.Yield();
await Task.Delay(0);
}
await Task.Delay(1);
}
}
finally
{
Interlocked.Decrement(ref s_trackValueConcurrentWorker_Current);
}
}
public static void CompleteAggregation_PersistentAggregator(IMetricSeriesAggregator accumulatorAggregator)
{
var startTS = new DateTimeOffset(2017, 9, 25, 17, 0, 0, TimeSpan.FromHours(-8));
var endTS = new DateTimeOffset(2017, 9, 25, 17, 1, 0, TimeSpan.FromHours(-8));
long periodString = (long)(endTS - startTS).TotalMilliseconds;
int filterInvocationsCount = 0;
accumulatorAggregator.Reset(startTS, valueFilter: new CustomDoubleValueFilter((s, v) => { filterInvocationsCount++; return(true); }));
Assert.AreEqual(0, filterInvocationsCount);
accumulatorAggregator.TrackValue(1);
accumulatorAggregator.TrackValue("2");
MetricAggregate aggregate = accumulatorAggregator.CompleteAggregation(endTS);
TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "Cows Sold", count: 0, sum: 3, max: 3, min: 1, stdDev: 0, timestamp: startTS, periodMs: periodString, aggKindMoniker: "Microsoft.Azure.Accumulator");
Assert.AreEqual(2, filterInvocationsCount);
accumulatorAggregator.TrackValue("3");
accumulatorAggregator.TrackValue(4);
aggregate = accumulatorAggregator.CompleteAggregation(endTS);
TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "Cows Sold", count: 0, sum: 10, max: 10, min: 1, stdDev: 0, timestamp: startTS, periodMs: periodString, aggKindMoniker: "Microsoft.Azure.Accumulator");
Assert.AreEqual(4, filterInvocationsCount);
aggregate = accumulatorAggregator.CreateAggregateUnsafe(endTS);
TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "Cows Sold", count: 0, sum: 10, max: 10, min: 1, stdDev: 0, timestamp: startTS, periodMs: periodString, aggKindMoniker: "Microsoft.Azure.Accumulator");
accumulatorAggregator.TrackValue(-18);
accumulatorAggregator.TrackValue(2);
aggregate = accumulatorAggregator.CompleteAggregation(endTS);
TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "Cows Sold", count: 0, sum: -6, max: 10, min: -8, stdDev: 0, timestamp: startTS, periodMs: periodString, aggKindMoniker: "Microsoft.Azure.Accumulator");
Assert.AreEqual(6, filterInvocationsCount);
}
public static void Reset_PersistentAggregator(IMetricSeriesAggregator aggregator, string aggregateKindMoniker)
{
Assert.AreEqual(MetricAggregateKinds.Accumulator.Moniker, aggregateKindMoniker);
var startTS = new DateTimeOffset(2017, 9, 25, 17, 0, 0, TimeSpan.FromHours(-8));
var endTS = new DateTimeOffset(2017, 9, 25, 17, 1, 0, TimeSpan.FromHours(-8));
long periodStringDef = (long)(endTS - default(DateTimeOffset)).TotalMilliseconds;
long periodStringStart = (long)(endTS - startTS).TotalMilliseconds;
int filterInvocationsCount = 0;
MetricAggregate aggregate = aggregator.CreateAggregateUnsafe(endTS);
Assert.IsNull(aggregate);
aggregator.Reset(startTS, valueFilter: null);
aggregate = aggregator.CreateAggregateUnsafe(endTS);
Assert.IsNull(aggregate);
aggregator.TrackValue(10);
aggregator.TrackValue(20);
aggregate = aggregator.CreateAggregateUnsafe(endTS);
TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "null", count: 0, sum: 30.0, max: 30, min: 10.0, stdDev: 5.0, timestamp: startTS, periodMs: periodStringStart, aggKindMoniker: aggregateKindMoniker);
Assert.AreEqual(0, filterInvocationsCount);
aggregator.Reset(default(DateTimeOffset), valueFilter: new CustomDoubleValueFilter((s, v) => { filterInvocationsCount++; return(true); }));
aggregate = aggregator.CreateAggregateUnsafe(endTS);
Assert.IsNull(aggregate);
aggregator.TrackValue(100);
aggregator.TrackValue(200);
aggregate = aggregator.CreateAggregateUnsafe(endTS);
TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "null", count: 0, sum: 300, max: 300, min: 100, stdDev: 0, timestamp: default(DateTimeOffset), periodMs: periodStringDef, aggKindMoniker: aggregateKindMoniker);
Assert.AreEqual(2, filterInvocationsCount);
aggregator.Reset(startTS, valueFilter: new CustomDoubleValueFilter((s, v) => { filterInvocationsCount++; return(false); }));
aggregate = aggregator.CreateAggregateUnsafe(endTS);
Assert.IsNull(aggregate);
aggregator.TrackValue(100);
aggregator.TrackValue(200);
aggregate = aggregator.CreateAggregateUnsafe(endTS);
Assert.IsNull(aggregate);
Assert.AreEqual(4, filterInvocationsCount);
aggregator.Reset(startTS, valueFilter: new CustomDoubleValueFilter((s, v) => { filterInvocationsCount++; return(true); }));
aggregate = aggregator.CreateAggregateUnsafe(endTS);
Assert.IsNull(aggregate);
aggregator.TrackValue(100);
aggregator.TrackValue(-200);
aggregate = aggregator.CreateAggregateUnsafe(endTS);
TestUtil.Util.ValidateNumericAggregateValues(aggregate, name: "null", count: 0, sum: -100, max: 100, min: -100, stdDev: 0, timestamp: startTS, periodMs: periodStringStart, aggKindMoniker: aggregateKindMoniker);
Assert.AreEqual(6, filterInvocationsCount);
}
