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