public void GetCurrentAggregateUnsafe_Measurement() { IMetricSeriesConfiguration seriesConfig = new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: false); const string aggregationKindMoniker = "Microsoft.Azure.Measurement"; // Do not start this test in the last 10 secs or first 2 secs of a minute, to make sure the timings below are likely to work out. while (DateTimeOffset.Now.Second >= 49 || DateTimeOffset.Now.Second < 3) { Thread.Sleep(TimeSpan.FromMilliseconds(500)); } DateTimeOffset startTS = DateTimeOffset.Now; var aggregateCollector = new MemoryMetricTelemetryPipeline(); var manager = new MetricManager(aggregateCollector); MetricSeries series = manager.CreateNewSeries("ns", "Foo Bar", seriesConfig); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(); Assert.IsNull(aggregate); } series.TrackValue(0.4); series.TrackValue(2); series.TrackValue(-2); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 3, sum: 0.4, max: 2, min: -2, stdDev: 1.64384373412506, aggKindMoniker: aggregationKindMoniker); // The following might break sometimes! // There is a little chance that second boundary is crossed between test TS and the aggregation timestamps are snapped. // rerun the test if it happens. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); } series.TrackValue(0.17); series.TrackValue(0.32); series.TrackValue(-0.15); series.TrackValue(1.07); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 7, sum: 1.81, max: 2, min: -2, stdDev: 1.13330652229191, aggKindMoniker: aggregationKindMoniker); // The following might break sometimes! // There is a little chance that second boundary is crossed between test TS and the aggregation timestamps are snapped. // rerun the test if it happens. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); } Thread.Sleep(1500); DateTimeOffset flushTS = DateTimeOffset.Now; manager.Flush(); { Assert.IsFalse(seriesConfig.RequiresPersistentAggregation); MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(); Assert.IsNull(aggregate); } series.TrackValue(0); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(); Assert.IsFalse(seriesConfig.RequiresPersistentAggregation); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 1, sum: 0, max: 0, min: 0, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // The following might break sometimes! // There is a little chance that second boundary is crossed between test TS and the aggregation timestamps are snapped. // rerun the test if it happens. Assert.AreEqual( new DateTimeOffset(flushTS.Year, flushTS.Month, flushTS.Day, flushTS.Hour, flushTS.Minute, flushTS.Second, 0, flushTS.Offset), aggregate.AggregationPeriodStart); } Util.CompleteDefaultAggregationCycle(manager); }
public MeasurementAggregator(MetricSeriesConfigurationForMeasurement configuration, MetricSeries dataSeries, MetricAggregationCycleKind aggregationCycleKind) : base(MetricValuesBufferFactory, configuration, dataSeries, aggregationCycleKind) { Util.ValidateNotNull(configuration, nameof(configuration)); this.restrictToUInt32Values = configuration.RestrictToUInt32Values; this.ResetAggregate(); }
/// <summary>@ToDo: Complete documentation before stable release. {287}</summary> /// <param name="dataSeries">@ToDo: Complete documentation before stable release. {864}</param> /// <param name="aggregationCycleKind">@ToDo: Complete documentation before stable release. {203}</param> /// <returns>@ToDo: Complete documentation before stable release. {983}</returns> public IMetricSeriesAggregator CreateNewAggregator(MetricSeries dataSeries, MetricAggregationCycleKind aggregationCycleKind) { IMetricSeriesAggregator aggregator = new MeasurementAggregator(this, dataSeries, aggregationCycleKind); return(aggregator); }
public SimpleNumberSeriesAggregatorBase(IMetricSeriesConfiguration configuration, MetricSeries dataSeries, MetricAggregationCycleKind aggregationCycleKind) : base(configuration, dataSeries, aggregationCycleKind) { }
public void Flush() { { var metricsCollector = new MemoryMetricTelemetryPipeline(); var manager = new MetricManager(metricsCollector); manager.Flush(); Assert.AreEqual(0, metricsCollector.Count); Util.CompleteDefaultAggregationCycle(manager); } { var metricsCollector = new MemoryMetricTelemetryPipeline(); var manager = new MetricManager(metricsCollector); IMetricSeriesConfiguration measurementConfig = new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false); IMetricSeriesConfiguration accumulatorConfig = new AccumulatorMetricSeriesConfiguration(restrictToUInt32Values: false); MetricSeries series1 = manager.CreateNewSeries("Measurement 1", measurementConfig); MetricSeries series2 = manager.CreateNewSeries("Measurement 2", measurementConfig); MetricSeries series3 = manager.CreateNewSeries("Accumulator 1", accumulatorConfig); series1.TrackValue(1); series1.TrackValue(1); series1.TrackValue(1); series2.TrackValue(-1); series2.TrackValue(-1); series2.TrackValue(-1); series3.TrackValue(-2); series3.TrackValue(1); series3.TrackValue(1); manager.Flush(); Assert.AreEqual(3, metricsCollector.Count); Assert.AreEqual(1, metricsCollector.Where((item) => item.MetricId.Equals("Measurement 1")).Count()); Assert.AreEqual(3, (metricsCollector.First((item) => item.MetricId.Equals("Measurement 1"))).AggregateData["Count"]); Assert.AreEqual(3.0, (metricsCollector.First((item) => item.MetricId.Equals("Measurement 1"))).AggregateData["Sum"]); Assert.AreEqual(1, metricsCollector.Where((item) => item.MetricId.Equals("Measurement 2")).Count()); Assert.AreEqual(3, (metricsCollector.First((item) => item.MetricId.Equals("Measurement 2"))).AggregateData["Count"]); Assert.AreEqual(-3.0, (metricsCollector.First((item) => item.MetricId.Equals("Measurement 2"))).AggregateData["Sum"]); Assert.AreEqual(1, metricsCollector.Where((item) => item.MetricId.Equals("Accumulator 1")).Count()); Assert.AreEqual(0.0, (metricsCollector.First((item) => item.MetricId.Equals("Accumulator 1"))).AggregateData["Sum"]); metricsCollector.Clear(); Assert.AreEqual(0, metricsCollector.Count); manager.Flush(); Assert.AreEqual(1, metricsCollector.Count); Assert.AreEqual(1, metricsCollector.Where((item) => item.MetricId.Equals("Accumulator 1")).Count()); Assert.AreEqual(0.0, (metricsCollector.First((item) => item.MetricId.Equals("Accumulator 1"))).AggregateData["Sum"]); Util.CompleteDefaultAggregationCycle(manager); } }
/// <summary> /// </summary> /// <param name="dataSeries"></param> /// <param name="aggregationCycleKind"></param> /// <returns></returns> public IMetricSeriesAggregator CreateNewAggregator(MetricSeries dataSeries, MetricAggregationCycleKind aggregationCycleKind) { IMetricSeriesAggregator aggregator = new NaiveDistinctCountMetricSeriesAggregator(this, dataSeries, aggregationCycleKind); return(aggregator); }
public SimpleDoubleDataSeriesAggregator(IMetricSeriesConfiguration configuration, MetricSeries dataSeries, MetricAggregationCycleKind aggregationCycleKind) : base(configuration, dataSeries, aggregationCycleKind) { Util.ValidateNotNull(configuration, nameof(configuration)); SimpleMetricSeriesConfiguration simpleSeriesConfig = configuration as SimpleMetricSeriesConfiguration; if (simpleSeriesConfig == null) { throw new ArgumentException( $"{nameof(SimpleDoubleDataSeriesAggregator)} expects a configuration of type {nameof(SimpleMetricSeriesConfiguration)}," + $" however the specified configuration is {configuration?.GetType()?.FullName ?? Util.NullString}.", nameof(configuration)); } if (true == simpleSeriesConfig.RestrictToUInt32Values) { throw new ArgumentException( $"{nameof(SimpleDoubleDataSeriesAggregator)} expects a configuration of type {nameof(SimpleMetricSeriesConfiguration)}" + $" where 'RestrictToUInt32Values' is FALSE, however it is True.", nameof(configuration)); } }
public void StopAggregators() { DateTimeOffset dto = new DateTimeOffset(2017, 10, 2, 17, 5, 0, TimeSpan.FromHours(-7)); var aggregationManager = new MetricAggregationManager(); var measurementMetric = new MetricSeries( aggregationManager, new MetricIdentifier("Measurement Metric"), null, new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: false)); var accumulatorMetric = new MetricSeries( aggregationManager, new MetricIdentifier("Accumulator Metric"), null, new MetricSeriesConfigurationForTestingAccumulatorBehavior()); // Cannot stop default: Assert.ThrowsException <ArgumentException>(() => aggregationManager.StopAggregators(MetricAggregationCycleKind.Default, dto)); // Stop cycles that never started: AggregationPeriodSummary customPeriod = aggregationManager.StopAggregators(MetricAggregationCycleKind.Custom, dto); Assert.IsNotNull(customPeriod); Assert.IsNotNull(customPeriod.NonpersistentAggregates); Assert.IsNotNull(customPeriod.PersistentAggregates); Assert.AreEqual(0, customPeriod.NonpersistentAggregates.Count); Assert.AreEqual(0, customPeriod.PersistentAggregates.Count); AggregationPeriodSummary quickpulsePeriod = aggregationManager.StopAggregators(MetricAggregationCycleKind.QuickPulse, dto); Assert.IsNotNull(quickpulsePeriod); Assert.IsNotNull(quickpulsePeriod.NonpersistentAggregates); Assert.IsNotNull(quickpulsePeriod.PersistentAggregates); Assert.AreEqual(0, quickpulsePeriod.NonpersistentAggregates.Count); Assert.AreEqual(0, quickpulsePeriod.PersistentAggregates.Count); // Track a value. Stop cycles that never started again. Observe that persistent cycle was active by default: measurementMetric.TrackValue(1); accumulatorMetric.TrackValue(2); customPeriod = aggregationManager.StopAggregators(MetricAggregationCycleKind.Custom, dto); Assert.IsNotNull(customPeriod); Assert.IsNotNull(customPeriod.NonpersistentAggregates); Assert.IsNotNull(customPeriod.PersistentAggregates); Assert.AreEqual(0, customPeriod.NonpersistentAggregates.Count); Assert.AreEqual(1, customPeriod.PersistentAggregates.Count); Assert.AreEqual("Accumulator Metric", customPeriod.PersistentAggregates[0].MetricId); Assert.AreEqual(2.0, customPeriod.PersistentAggregates[0].Data["Sum"]); quickpulsePeriod = aggregationManager.StopAggregators(MetricAggregationCycleKind.QuickPulse, dto); Assert.IsNotNull(quickpulsePeriod); Assert.IsNotNull(quickpulsePeriod.NonpersistentAggregates); Assert.IsNotNull(quickpulsePeriod.PersistentAggregates); Assert.AreEqual(0, quickpulsePeriod.NonpersistentAggregates.Count); Assert.AreEqual(1, quickpulsePeriod.PersistentAggregates.Count); Assert.AreEqual("Accumulator Metric", quickpulsePeriod.PersistentAggregates[0].MetricId); Assert.AreEqual(2.0, quickpulsePeriod.PersistentAggregates[0].Data["Sum"]); // Now start cycles, track values and stop them again. Observe that values were tracked: aggregationManager.StartOrCycleAggregators(MetricAggregationCycleKind.Custom, dto, futureFilter: null); aggregationManager.StartOrCycleAggregators(MetricAggregationCycleKind.QuickPulse, dto, futureFilter: null); measurementMetric.TrackValue(3); accumulatorMetric.TrackValue(4); customPeriod = aggregationManager.StopAggregators(MetricAggregationCycleKind.Custom, dto); Assert.IsNotNull(customPeriod); Assert.IsNotNull(customPeriod.NonpersistentAggregates); Assert.IsNotNull(customPeriod.PersistentAggregates); Assert.AreEqual(1, customPeriod.NonpersistentAggregates.Count); Assert.AreEqual("Measurement Metric", customPeriod.NonpersistentAggregates[0].MetricId); Assert.AreEqual(1, customPeriod.NonpersistentAggregates[0].Data["Count"]); Assert.AreEqual(3.0, customPeriod.NonpersistentAggregates[0].Data["Sum"]); Assert.AreEqual(1, customPeriod.PersistentAggregates.Count); Assert.AreEqual("Accumulator Metric", customPeriod.PersistentAggregates[0].MetricId); Assert.AreEqual(6.0, customPeriod.PersistentAggregates[0].Data["Sum"]); quickpulsePeriod = aggregationManager.StopAggregators(MetricAggregationCycleKind.QuickPulse, dto); Assert.IsNotNull(quickpulsePeriod); Assert.IsNotNull(quickpulsePeriod.NonpersistentAggregates); Assert.IsNotNull(quickpulsePeriod.PersistentAggregates); Assert.AreEqual(1, quickpulsePeriod.NonpersistentAggregates.Count); Assert.AreEqual("Measurement Metric", quickpulsePeriod.NonpersistentAggregates[0].MetricId); Assert.AreEqual(1, quickpulsePeriod.NonpersistentAggregates[0].Data["Count"]); Assert.AreEqual(3.0, quickpulsePeriod.NonpersistentAggregates[0].Data["Sum"]); Assert.AreEqual(1, quickpulsePeriod.PersistentAggregates.Count); Assert.AreEqual("Accumulator Metric", quickpulsePeriod.PersistentAggregates[0].MetricId); Assert.AreEqual(6.0, quickpulsePeriod.PersistentAggregates[0].Data["Sum"]); measurementMetric.TrackValue(5); accumulatorMetric.TrackValue(6); quickpulsePeriod = aggregationManager.StopAggregators(MetricAggregationCycleKind.Custom, dto); Assert.IsNotNull(quickpulsePeriod); Assert.IsNotNull(quickpulsePeriod.NonpersistentAggregates); Assert.IsNotNull(quickpulsePeriod.PersistentAggregates); Assert.AreEqual(0, quickpulsePeriod.NonpersistentAggregates.Count); Assert.AreEqual(1, customPeriod.PersistentAggregates.Count); Assert.AreEqual("Accumulator Metric", customPeriod.PersistentAggregates[0].MetricId); Assert.AreEqual(6.0, customPeriod.PersistentAggregates[0].Data["Sum"]); quickpulsePeriod = aggregationManager.StopAggregators(MetricAggregationCycleKind.QuickPulse, dto); Assert.IsNotNull(quickpulsePeriod); Assert.IsNotNull(quickpulsePeriod.NonpersistentAggregates); Assert.IsNotNull(quickpulsePeriod.PersistentAggregates); Assert.AreEqual(0, quickpulsePeriod.NonpersistentAggregates.Count); Assert.AreEqual(1, quickpulsePeriod.PersistentAggregates.Count); Assert.AreEqual("Accumulator Metric", quickpulsePeriod.PersistentAggregates[0].MetricId); Assert.AreEqual(12.0, quickpulsePeriod.PersistentAggregates[0].Data["Sum"]); }
public bool WillConsume(MetricSeries dataSeries, out IMetricValueFilter valueFilter) { valueFilter = null; return(false); }
private static void StartOrCycleAggregatorsTest(MetricAggregationCycleKind cycleKind, bool supportsSettingFilters) { DateTimeOffset dto = new DateTimeOffset(2017, 10, 2, 17, 5, 0, TimeSpan.FromHours(-7)); var aggregationManager = new MetricAggregationManager(); var measurementMetric = new MetricSeries( aggregationManager, new MetricIdentifier("Measurement Metric"), null, new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: false)); var accumulatorMetric = new MetricSeries( aggregationManager, new MetricIdentifier("Accumulator Metric"), null, new MetricSeriesConfigurationForTestingAccumulatorBehavior()); // Cycle once, get nothing: AggregationPeriodSummary period = aggregationManager.StartOrCycleAggregators(cycleKind, dto, futureFilter: null); Assert.IsNotNull(period); Assert.IsNotNull(period.NonpersistentAggregates); Assert.IsNotNull(period.PersistentAggregates); Assert.AreEqual(0, period.NonpersistentAggregates.Count); Assert.AreEqual(0, period.PersistentAggregates.Count); // Record something, cycle, check for it: measurementMetric.TrackValue(1); accumulatorMetric.TrackValue(2); period = aggregationManager.StartOrCycleAggregators(cycleKind, dto, futureFilter: null); Assert.IsNotNull(period); Assert.IsNotNull(period.NonpersistentAggregates); Assert.IsNotNull(period.PersistentAggregates); Assert.AreEqual(1, period.NonpersistentAggregates.Count); Assert.AreEqual(1, period.PersistentAggregates.Count); Assert.IsNotNull(period.NonpersistentAggregates[0]); Assert.IsNotNull(period.PersistentAggregates[0]); Assert.AreEqual("Measurement Metric", period.NonpersistentAggregates[0].MetricId); Assert.AreEqual(1, period.NonpersistentAggregates[0].Data["Count"]); Assert.AreEqual(1.0, period.NonpersistentAggregates[0].Data["Sum"]); Assert.AreEqual("Accumulator Metric", period.PersistentAggregates[0].MetricId); Assert.AreEqual(2.0, period.PersistentAggregates[0].Data["Sum"]); // Now we should be empty again for non-persistent. Persistent stays: period = aggregationManager.StartOrCycleAggregators(cycleKind, dto, futureFilter: null); Assert.IsNotNull(period); Assert.IsNotNull(period.NonpersistentAggregates); Assert.IsNotNull(period.PersistentAggregates); Assert.AreEqual(0, period.NonpersistentAggregates.Count); Assert.AreEqual(1, period.PersistentAggregates.Count); Assert.IsNotNull(period.PersistentAggregates[0]); Assert.AreEqual("Accumulator Metric", period.PersistentAggregates[0].MetricId); Assert.AreEqual(2.0, period.PersistentAggregates[0].Data["Sum"]); // Now set a deny filter. Track. Expect to get nothng. // Note: for persistent, values tracked under Deny filter should persist for the future, for non-persistent they are just discarded. if (false == supportsSettingFilters) { Assert.ThrowsException <ArgumentException>(() => aggregationManager.StartOrCycleAggregators( cycleKind, dto, futureFilter: new AcceptAllFilter())); } else { period = aggregationManager.StartOrCycleAggregators(cycleKind, dto, futureFilter: new DenyAllFilter()); Assert.IsNotNull(period); Assert.IsNotNull(period.NonpersistentAggregates); Assert.IsNotNull(period.PersistentAggregates); measurementMetric.TrackValue(3); accumulatorMetric.TrackValue(4); period = aggregationManager.StartOrCycleAggregators(cycleKind, dto, futureFilter: null); Assert.IsNotNull(period); Assert.IsNotNull(period.NonpersistentAggregates); Assert.IsNotNull(period.PersistentAggregates); Assert.AreEqual(0, period.NonpersistentAggregates.Count); Assert.AreEqual(0, period.PersistentAggregates.Count); period = aggregationManager.StartOrCycleAggregators(cycleKind, dto, futureFilter: null); Assert.IsNotNull(period); Assert.IsNotNull(period.NonpersistentAggregates); Assert.IsNotNull(period.PersistentAggregates); Assert.AreEqual(0, period.NonpersistentAggregates.Count); Assert.AreEqual(1, period.PersistentAggregates.Count); Assert.IsNotNull(period.PersistentAggregates[0]); Assert.AreEqual("Accumulator Metric", period.PersistentAggregates[0].MetricId); Assert.AreEqual(6.0, period.PersistentAggregates[0].Data["Sum"]); // Validate that deny filter was removed: measurementMetric.TrackValue(5); accumulatorMetric.TrackValue(6); period = aggregationManager.StartOrCycleAggregators(cycleKind, dto, futureFilter: null); Assert.IsNotNull(period); Assert.IsNotNull(period.NonpersistentAggregates); Assert.IsNotNull(period.PersistentAggregates); Assert.AreEqual(1, period.NonpersistentAggregates.Count); Assert.AreEqual(1, period.PersistentAggregates.Count); Assert.IsNotNull(period.PersistentAggregates[0]); Assert.IsNotNull(period.NonpersistentAggregates[0]); Assert.AreEqual("Accumulator Metric", period.PersistentAggregates[0].MetricId); Assert.AreEqual(12.0, period.PersistentAggregates[0].Data["Sum"]); Assert.AreEqual("Measurement Metric", period.NonpersistentAggregates[0].MetricId); Assert.AreEqual(5.0, period.NonpersistentAggregates[0].Data["Sum"]); } }
public void GetCurrentAggregateUnsafe_MetricAggregationCycleKind_DateTimeOffset_Accumulator() { IMetricSeriesConfiguration seriesConfig = new MetricSeriesConfigurationForAccumulator(restrictToUInt32Values: false); const string aggregationKindMoniker = "Microsoft.Azure.Accumulator"; // Do not start this test in the last 10 secs or first 2 secs of a minute, to make sure the timings below are likely to work out. while (DateTimeOffset.Now.Second >= 49 || DateTimeOffset.Now.Second < 3) { Thread.Sleep(TimeSpan.FromMilliseconds(500)); } DateTimeOffset startTS = DateTimeOffset.Now; var aggregateCollector = new MemoryMetricTelemetryPipeline(); var manager = new MetricManager(aggregateCollector); MetricSeries series = manager.CreateNewSeries("Foo Bar", seriesConfig); DateTimeOffset stepTS = startTS.AddMinutes(2); DateTimeOffset stepTSRounded = new DateTimeOffset(stepTS.Year, stepTS.Month, stepTS.Day, stepTS.Hour, stepTS.Minute, stepTS.Second, 0, stepTS.Offset); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Default, stepTS); Assert.IsNull(aggregate); aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Custom, stepTS); Assert.IsNull(aggregate); aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.QuickPulse, stepTS); Assert.IsNull(aggregate); } series.TrackValue(0.4); series.TrackValue(2); series.TrackValue(-2); stepTS = stepTS.AddMinutes(2); stepTSRounded = new DateTimeOffset(stepTS.Year, stepTS.Month, stepTS.Day, stepTS.Hour, stepTS.Minute, stepTS.Second, 0, stepTS.Offset); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Default, stepTS); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 0, sum: 0.4, max: 2.4, min: 0.4, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); { Assert.IsTrue(seriesConfig.RequiresPersistentAggregation); aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Custom, stepTS); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 0, sum: 0.4, max: 2.4, min: 0.4, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.QuickPulse, stepTS); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 0, sum: 0.4, max: 2.4, min: 0.4, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); } } DateTimeOffset customCycleStartTS = stepTS.AddMinutes(1); manager.StartOrCycleAggregators(MetricAggregationCycleKind.Custom, customCycleStartTS, futureFilter: null); series.TrackValue(0.17); series.TrackValue(0.32); series.TrackValue(-0.15); series.TrackValue(1.07); stepTS = stepTS.AddMinutes(2); stepTSRounded = new DateTimeOffset(stepTS.Year, stepTS.Month, stepTS.Day, stepTS.Hour, stepTS.Minute, stepTS.Second, 0, stepTS.Offset); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Default, stepTS); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 0, sum: 1.81, max: 2.4, min: 0.4, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Custom, stepTS); { Assert.IsTrue(seriesConfig.RequiresPersistentAggregation); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 0, sum: 1.81, max: 2.4, min: 0.4, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); } aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.QuickPulse, stepTS); { Assert.IsTrue(seriesConfig.RequiresPersistentAggregation); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 0, sum: 1.81, max: 2.4, min: 0.4, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); } } Thread.Sleep(1500); DateTimeOffset flushTS = DateTimeOffset.Now; manager.Flush(); DateTimeOffset quickPulseCycleStartTS = stepTS.AddMinutes(1); manager.StartOrCycleAggregators(MetricAggregationCycleKind.QuickPulse, quickPulseCycleStartTS, futureFilter: null); stepTS = stepTS.AddMinutes(2); stepTSRounded = new DateTimeOffset(stepTS.Year, stepTS.Month, stepTS.Day, stepTS.Hour, stepTS.Minute, stepTS.Second, 0, stepTS.Offset); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Default, stepTS); { Assert.IsTrue(seriesConfig.RequiresPersistentAggregation); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 0, sum: 1.81, max: 2.4, min: 0.4, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); } aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Custom, stepTS); { Assert.IsTrue(seriesConfig.RequiresPersistentAggregation); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 0, sum: 1.81, max: 2.4, min: 0.4, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); } aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.QuickPulse, stepTS); { Assert.IsTrue(seriesConfig.RequiresPersistentAggregation); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 0, sum: 1.81, max: 2.4, min: 0.4, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); } } series.TrackValue(0); series.TrackValue(-10); stepTS = stepTS.AddMinutes(2); stepTSRounded = new DateTimeOffset(stepTS.Year, stepTS.Month, stepTS.Day, stepTS.Hour, stepTS.Minute, stepTS.Second, 0, stepTS.Offset); manager.StopAggregators(MetricAggregationCycleKind.Custom, stepTS); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Default, stepTS); { Assert.IsTrue(seriesConfig.RequiresPersistentAggregation); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 0, sum: -8.19, max: 2.4, min: -8.19, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); } aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Custom, stepTS); if (seriesConfig.RequiresPersistentAggregation) { Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 0, sum: -8.19, max: 2.4, min: -8.19, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); } else { Assert.IsNull(aggregate); } aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.QuickPulse, stepTS); { Assert.IsTrue(seriesConfig.RequiresPersistentAggregation); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 0, sum: -8.19, max: 2.4, min: -8.19, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); } } Util.CompleteDefaultAggregationCycle(manager); }
public void GetCurrentAggregateUnsafe_MetricAggregationCycleKind_DateTimeOffset_Measurement() { IMetricSeriesConfiguration seriesConfig = new MetricSeriesConfigurationForMeasurement(restrictToUInt32Values: false); const string aggregationKindMoniker = "Microsoft.Azure.Measurement"; // Do not start this test in the last 10 secs or first 2 secs of a minute, to make sure the timings below are likely to work out. while (DateTimeOffset.Now.Second >= 49 || DateTimeOffset.Now.Second < 3) { Thread.Sleep(TimeSpan.FromMilliseconds(500)); } DateTimeOffset startTS = DateTimeOffset.Now; var aggregateCollector = new MemoryMetricTelemetryPipeline(); var manager = new MetricManager(aggregateCollector); MetricSeries series = manager.CreateNewSeries("Foo Bar", seriesConfig); DateTimeOffset stepTS = startTS.AddMinutes(2); DateTimeOffset stepTSRounded = new DateTimeOffset(stepTS.Year, stepTS.Month, stepTS.Day, stepTS.Hour, stepTS.Minute, stepTS.Second, 0, stepTS.Offset); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Default, stepTS); Assert.IsNull(aggregate); aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Custom, stepTS); Assert.IsNull(aggregate); aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.QuickPulse, stepTS); Assert.IsNull(aggregate); } series.TrackValue(0.4); series.TrackValue(2); series.TrackValue(-2); stepTS = stepTS.AddMinutes(2); stepTSRounded = new DateTimeOffset(stepTS.Year, stepTS.Month, stepTS.Day, stepTS.Hour, stepTS.Minute, stepTS.Second, 0, stepTS.Offset); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Default, stepTS); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 3, sum: 0.4, max: 2, min: -2, stdDev: 1.64384373412506, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); { Assert.IsFalse(seriesConfig.RequiresPersistentAggregation); aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Custom, stepTS); Assert.IsNull(aggregate); aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.QuickPulse, stepTS); Assert.IsNull(aggregate); } } DateTimeOffset customCycleStartTS = stepTS.AddMinutes(1); manager.StartOrCycleAggregators(MetricAggregationCycleKind.Custom, customCycleStartTS, futureFilter: null); series.TrackValue(0.17); series.TrackValue(0.32); series.TrackValue(-0.15); series.TrackValue(1.07); stepTS = stepTS.AddMinutes(2); stepTSRounded = new DateTimeOffset(stepTS.Year, stepTS.Month, stepTS.Day, stepTS.Hour, stepTS.Minute, stepTS.Second, 0, stepTS.Offset); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Default, stepTS); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 7, sum: 1.81, max: 2, min: -2, stdDev: 1.13330652229191, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(startTS.Year, startTS.Month, startTS.Day, startTS.Hour, startTS.Minute, startTS.Second, 0, startTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Custom, stepTS); { Assert.IsFalse(seriesConfig.RequiresPersistentAggregation); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 4, sum: 1.41, max: 1.07, min: -0.15, stdDev: 0.447681527427702, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(customCycleStartTS.Year, customCycleStartTS.Month, customCycleStartTS.Day, customCycleStartTS.Hour, customCycleStartTS.Minute, customCycleStartTS.Second, 0, customCycleStartTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); } aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.QuickPulse, stepTS); { Assert.IsFalse(seriesConfig.RequiresPersistentAggregation); Assert.IsNull(aggregate); } } Thread.Sleep(1500); DateTimeOffset flushTS = DateTimeOffset.Now; manager.Flush(); DateTimeOffset quickPulseCycleStartTS = stepTS.AddMinutes(1); manager.StartOrCycleAggregators(MetricAggregationCycleKind.QuickPulse, quickPulseCycleStartTS, futureFilter: null); stepTS = stepTS.AddMinutes(2); stepTSRounded = new DateTimeOffset(stepTS.Year, stepTS.Month, stepTS.Day, stepTS.Hour, stepTS.Minute, stepTS.Second, 0, stepTS.Offset); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Default, stepTS); { Assert.IsFalse(seriesConfig.RequiresPersistentAggregation); Assert.IsNull(aggregate); } aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Custom, stepTS); { Assert.IsFalse(seriesConfig.RequiresPersistentAggregation); // Custom was not cycled by Flush. Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 4, sum: 1.41, max: 1.07, min: -0.15, stdDev: 0.447681527427702, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(customCycleStartTS.Year, customCycleStartTS.Month, customCycleStartTS.Day, customCycleStartTS.Hour, customCycleStartTS.Minute, customCycleStartTS.Second, 0, customCycleStartTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); manager.StartOrCycleAggregators(MetricAggregationCycleKind.Custom, flushTS, null); aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Custom, stepTS); Assert.IsNull(aggregate); } aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.QuickPulse, stepTS); { Assert.IsFalse(seriesConfig.RequiresPersistentAggregation); // We started QP cycle now, but we did not write values since then. Assert.IsNull(aggregate); } } series.TrackValue(0); stepTS = stepTS.AddMinutes(2); stepTSRounded = new DateTimeOffset(stepTS.Year, stepTS.Month, stepTS.Day, stepTS.Hour, stepTS.Minute, stepTS.Second, 0, stepTS.Offset); manager.StopAggregators(MetricAggregationCycleKind.Custom, stepTS); { MetricAggregate aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Default, stepTS); { Assert.IsFalse(seriesConfig.RequiresPersistentAggregation); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 1, sum: 0, max: 0, min: 0, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(flushTS.Year, flushTS.Month, flushTS.Day, flushTS.Hour, flushTS.Minute, flushTS.Second, 0, flushTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); } aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.Custom, stepTS); { Assert.IsFalse(seriesConfig.RequiresPersistentAggregation); Assert.IsNull(aggregate); } aggregate = series.GetCurrentAggregateUnsafe(MetricAggregationCycleKind.QuickPulse, stepTS); { Assert.IsFalse(seriesConfig.RequiresPersistentAggregation); Util.ValidateNumericAggregateValues(aggregate, name: "Foo Bar", count: 1, sum: 0, max: 0, min: 0, stdDev: 0, aggKindMoniker: aggregationKindMoniker); // This might break: Second boundary might be crossed between snapping test and the aggregation timestamps. Try re-running. Assert.AreEqual( new DateTimeOffset(quickPulseCycleStartTS.Year, quickPulseCycleStartTS.Month, quickPulseCycleStartTS.Day, quickPulseCycleStartTS.Hour, quickPulseCycleStartTS.Minute, quickPulseCycleStartTS.Second, 0, quickPulseCycleStartTS.Offset), aggregate.AggregationPeriodStart); Assert.AreEqual( (stepTSRounded - aggregate.AggregationPeriodStart).TotalMilliseconds, aggregate.AggregationPeriodDuration.TotalMilliseconds); } } Util.CompleteDefaultAggregationCycle(manager); }
public AccumulatorAggregator(MetricSeriesConfigurationForAccumulator configuration, MetricSeries dataSeries, MetricAggregationCycleKind aggregationCycleKind) : base(MetricValuesBufferFactory, configuration, dataSeries, aggregationCycleKind) { Util.ValidateNotNull(configuration, nameof(configuration)); _restrictToUInt32Values = configuration.RestrictToUInt32Values; ResetAggregate(); }
public static void GetDataSeries(IMetricSeriesAggregator aggregatorForConcreteSeries, IMetricSeriesAggregator aggregatorForNullSeries, MetricSeries series) { Assert.IsNotNull(aggregatorForConcreteSeries.DataSeries); Assert.AreSame(series, aggregatorForConcreteSeries.DataSeries); Assert.IsNull(aggregatorForNullSeries.DataSeries); }