// @PublicExposureCandidate
internal void ResetAggregation(DateTimeOffset periodStart)
{
periodStart = Util.RoundDownToSecond(periodStart);
if (this.requiresPersistentAggregator)
{
IMetricSeriesAggregator aggregator = this.aggregatorPersistent;
aggregator?.Reset(periodStart);
}
else
{
{
IMetricSeriesAggregator aggregator = UnwrapAggregator(this.aggregatorDefault);
aggregator?.Reset(periodStart);
}
{
IMetricSeriesAggregator aggregator = UnwrapAggregator(this.aggregatorQuickPulse);
aggregator?.Reset(periodStart);
}
{
IMetricSeriesAggregator aggregator = UnwrapAggregator(this.aggregatorCustom);
aggregator?.Reset(periodStart);
}
}
}
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");
}
}
private static bool AddAggregator(IMetricSeriesAggregator aggregator, AggregatorCollection aggregatorCollection)
{
if (aggregatorCollection == null)
{
return(false);
}
IMetricSeriesFilter seriesFilter = aggregatorCollection.Filter;
IMetricValueFilter valueFilter = null;
if (seriesFilter != null && !seriesFilter.WillConsume(aggregator.DataSeries, out valueFilter))
{
return(false);
}
aggregator.Reset(aggregatorCollection.PeriodStart, valueFilter);
aggregatorCollection.Aggregators.Add(aggregator);
return(true);
}
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}]");
}
}
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);
}
private static bool AddAggregator(IMetricSeriesAggregator aggregator, AggregatorCollection aggregatorCollection)
{
if (aggregatorCollection == null)
{
return(false);
}
IMetricSeriesFilter seriesFilter = aggregatorCollection.Filter;
IMetricValueFilter valueFilter;
if (false == Util.FilterWillConsume(seriesFilter, aggregator.DataSeries, out valueFilter))
{
return(false);
}
// @ToDo
// @PublicExposureCandidate
// aggregator.Reset(aggregatorCollection.PeriodStart, valueFilter);
aggregator.Reset(aggregatorCollection.PeriodStart);
aggregatorCollection.Aggregators.Add(aggregator);
return(true);
}
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);
}
