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"); } }
// @PublicExposureCandidate internal MetricAggregate GetCurrentAggregateUnsafe(MetricAggregationCycleKind aggregationCycleKind, DateTimeOffset dateTime) { IMetricSeriesAggregator aggregator = null; if (this.requiresPersistentAggregator) { aggregator = this.aggregatorPersistent; } else { switch (aggregationCycleKind) { case CycleKind.Default: aggregator = UnwrapAggregator(this.aggregatorDefault); break; case CycleKind.QuickPulse: aggregator = UnwrapAggregator(this.aggregatorQuickPulse); break; case CycleKind.Custom: aggregator = UnwrapAggregator(this.aggregatorCustom); break; default: throw new ArgumentException(Invariant($"Unexpected value of {nameof(aggregationCycleKind)}: {aggregationCycleKind}.")); } } dateTime = Util.RoundDownToSecond(dateTime); MetricAggregate aggregate = aggregator?.CreateAggregateUnsafe(dateTime); return(aggregate); }
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); }
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); }