private static void Metrics_SpecifiedPipeline(TelemetryConfiguration telemetryPipeline) { telemetryPipeline.InstrumentationKey = Guid.NewGuid().ToString("D"); MetricManager manager1 = telemetryPipeline.Metrics(); Assert.IsNotNull(manager1); MetricManager manager2 = telemetryPipeline.Metrics(); Assert.IsNotNull(manager2); Assert.AreEqual(manager1, manager2); Assert.AreSame(manager1, manager2); Assert.IsTrue(Object.ReferenceEquals(manager1, manager2)); StubTelemetryChannel telemetryCollector = new StubTelemetryChannel(); telemetryPipeline.TelemetryChannel = telemetryCollector; Assert.AreSame(telemetryCollector, telemetryPipeline.TelemetryChannel); //CollectingTelemetryInitializer telemetryCollector = new CollectingTelemetryInitializer(); //defaultTelemetryPipeline.TelemetryInitializers.Add(coll); IMetricSeriesConfiguration seriesConfig = new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false); manager1.CreateNewSeries("Metric A", seriesConfig).TrackValue(42); manager1.CreateNewSeries("Metric A", seriesConfig).TrackValue("18"); manager2.CreateNewSeries("Metric A", seriesConfig).TrackValue(10000); manager2.CreateNewSeries("Metric B", seriesConfig).TrackValue(-0.001); manager1.Flush(); Assert.AreEqual(4, telemetryCollector.TelemetryItems.Count); Assert.IsInstanceOfType(telemetryCollector.TelemetryItems[0], typeof(MetricTelemetry)); Assert.AreEqual("Metric B", ((MetricTelemetry)telemetryCollector.TelemetryItems[0]).Name); Assert.AreEqual(1, ((MetricTelemetry)telemetryCollector.TelemetryItems[0]).Count); Assert.AreEqual(-0.001, ((MetricTelemetry)telemetryCollector.TelemetryItems[0]).Sum); Assert.IsInstanceOfType(telemetryCollector.TelemetryItems[1], typeof(MetricTelemetry)); Assert.AreEqual("Metric A", ((MetricTelemetry)telemetryCollector.TelemetryItems[1]).Name); Assert.AreEqual(1, ((MetricTelemetry)telemetryCollector.TelemetryItems[1]).Count); Assert.AreEqual(10000, ((MetricTelemetry)telemetryCollector.TelemetryItems[1]).Sum); Assert.IsInstanceOfType(telemetryCollector.TelemetryItems[2], typeof(MetricTelemetry)); Assert.AreEqual("Metric A", ((MetricTelemetry)telemetryCollector.TelemetryItems[2]).Name); Assert.AreEqual(1, ((MetricTelemetry)telemetryCollector.TelemetryItems[2]).Count); Assert.AreEqual(18, ((MetricTelemetry)telemetryCollector.TelemetryItems[2]).Sum); Assert.IsInstanceOfType(telemetryCollector.TelemetryItems[3], typeof(MetricTelemetry)); Assert.AreEqual("Metric A", ((MetricTelemetry)telemetryCollector.TelemetryItems[3]).Name); Assert.AreEqual(1, ((MetricTelemetry)telemetryCollector.TelemetryItems[3]).Count); Assert.AreEqual(42, ((MetricTelemetry)telemetryCollector.TelemetryItems[3]).Sum); }
public void GetConfiguration() { TelemetryConfiguration pipeline = Util.CreateAITelemetryConfig(); TelemetryClient client = new TelemetryClient(pipeline); { Metric metric = client.GetMetric("CowsSold"); Assert.AreEqual(MetricConfigurations.Measurement, metric.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement, metric.GetConfiguration()); } { Metric metric = client.GetMetric("PigsSold", MetricConfigurations.Accumulator); Assert.AreEqual(MetricConfigurations.Accumulator, metric.GetConfiguration()); Assert.AreSame(MetricConfigurations.Accumulator, metric.GetConfiguration()); } { Metric metric = client.GetMetric("HorsesSold", MetricConfigurations.Measurement); Assert.AreEqual(MetricConfigurations.Measurement, metric.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement, metric.GetConfiguration()); } { IMetricConfiguration config = new SimpleMetricConfiguration(10, 5, new SimpleMetricSeriesConfiguration(false)); Metric metric = client.GetMetric("ChickensSold", config); Assert.AreEqual(config, metric.GetConfiguration()); Assert.AreSame(config, metric.GetConfiguration()); } Util.CompleteDefaultAggregationCycle(pipeline.Metrics()); pipeline.Dispose(); }
public void Metrics_DefaultPipeline() { TelemetryConfiguration defaultTelemetryPipeline = TelemetryConfiguration.Active; using (defaultTelemetryPipeline) { Metrics_SpecifiedPipeline(defaultTelemetryPipeline); Util.CompleteDefaultAggregationCycle(defaultTelemetryPipeline.Metrics()); } }
public void RecordNormalMetric() { TelemetryConfiguration telemetryPipeline = TelemetryConfiguration.Active; using (telemetryPipeline) { RecordNormalMetric(telemetryPipeline); Util.CompleteDefaultAggregationCycle(telemetryPipeline.Metrics()); } }
/// <summary> /// </summary> /// <param name="telemetryClient"></param> /// <param name="aggregationScope"></param> /// <returns></returns> public static MetricManager Metrics(this TelemetryClient telemetryClient, MetricAggregationScope aggregationScope) { Util.ValidateNotNull(telemetryClient, nameof(telemetryClient)); switch (aggregationScope) { case MetricAggregationScope.TelemetryConfiguration: TelemetryConfiguration pipeline = Util.GetTelemetryConfiguration(telemetryClient); return(pipeline.Metrics()); case MetricAggregationScope.TelemetryClient: MetricManager manager = GetOrCreateMetricManager(telemetryClient); return(manager); default: throw new ArgumentException($"Invalid value of {nameof(aggregationScope)} ({aggregationScope}). Only the following values are supported:" + $" ['{nameof(MetricAggregationScope)}.{MetricAggregationScope.TelemetryClient.ToString()}'," + $" '{nameof(MetricAggregationScope)}.{MetricAggregationScope.TelemetryConfiguration.ToString()}']."); } }
public void Metrics_CustomPipeline() { ; using (TelemetryConfiguration defaultTelemetryPipeline = TelemetryConfiguration.Active) using (TelemetryConfiguration customTelemetryPipeline1 = Util.CreateAITelemetryConfig()) using (TelemetryConfiguration customTelemetryPipeline2 = Util.CreateAITelemetryConfig()) { Assert.IsFalse(Object.ReferenceEquals(defaultTelemetryPipeline, customTelemetryPipeline1)); Assert.IsFalse(Object.ReferenceEquals(defaultTelemetryPipeline, customTelemetryPipeline2)); Assert.IsFalse(Object.ReferenceEquals(customTelemetryPipeline1, customTelemetryPipeline2)); MetricManager managerDef = defaultTelemetryPipeline.Metrics(); MetricManager managerCust1 = customTelemetryPipeline1.Metrics(); MetricManager managerCust2 = customTelemetryPipeline2.Metrics(); Assert.IsNotNull(managerDef); Assert.IsNotNull(managerCust1); Assert.IsNotNull(managerCust2); Assert.AreNotEqual(managerDef, managerCust1); Assert.AreNotEqual(managerDef, managerCust2); Assert.AreNotEqual(managerCust1, managerCust2); Assert.AreNotSame(managerDef, managerCust1); Assert.AreNotSame(managerDef, managerCust2); Assert.AreNotSame(managerCust1, managerCust2); Assert.IsFalse(Object.ReferenceEquals(managerDef, managerCust1)); Assert.IsFalse(Object.ReferenceEquals(managerDef, managerCust2)); Assert.IsFalse(Object.ReferenceEquals(managerCust1, managerCust2)); Metrics_SpecifiedPipeline(customTelemetryPipeline1); Metrics_SpecifiedPipeline(customTelemetryPipeline2); Util.CompleteDefaultAggregationCycle(managerDef); Util.CompleteDefaultAggregationCycle(managerCust1); Util.CompleteDefaultAggregationCycle(managerCust2); } }
public void Metrics() { TelemetryConfiguration telemetryPipeline1 = Util.CreateAITelemetryConfig(); TelemetryConfiguration telemetryPipeline2 = Util.CreateAITelemetryConfig(); TelemetryClient client1 = new TelemetryClient(telemetryPipeline1); TelemetryClient client2 = new TelemetryClient(telemetryPipeline1); MetricManager managerP11 = telemetryPipeline1.Metrics(); MetricManager managerP12 = telemetryPipeline1.Metrics(); MetricManager managerP21 = telemetryPipeline2.Metrics(); MetricManager managerP22 = telemetryPipeline2.Metrics(); MetricManager managerCp11 = client1.Metrics(MetricAggregationScope.TelemetryConfiguration); MetricManager managerCp12 = client1.Metrics(MetricAggregationScope.TelemetryConfiguration); MetricManager managerCp21 = client2.Metrics(MetricAggregationScope.TelemetryConfiguration); MetricManager managerCp22 = client2.Metrics(MetricAggregationScope.TelemetryConfiguration); MetricManager managerCc11 = client1.Metrics(MetricAggregationScope.TelemetryClient); MetricManager managerCc12 = client1.Metrics(MetricAggregationScope.TelemetryClient); MetricManager managerCc21 = client2.Metrics(MetricAggregationScope.TelemetryClient); MetricManager managerCc22 = client2.Metrics(MetricAggregationScope.TelemetryClient); Assert.IsNotNull(managerP11); Assert.IsNotNull(managerP12); Assert.IsNotNull(managerP21); Assert.IsNotNull(managerP22); Assert.IsNotNull(managerCp11); Assert.IsNotNull(managerCp12); Assert.IsNotNull(managerCp21); Assert.IsNotNull(managerCp22); Assert.IsNotNull(managerCc11); Assert.IsNotNull(managerCc12); Assert.IsNotNull(managerCc21); Assert.IsNotNull(managerCc22); Assert.AreSame(managerP11, managerP12); Assert.AreSame(managerP21, managerP22); Assert.AreNotSame(managerP11, managerP21); Assert.AreSame(managerP11, managerCp11); Assert.AreSame(managerP11, managerCp12); Assert.AreSame(managerP11, managerCp21); Assert.AreSame(managerP11, managerCp22); Assert.AreSame(managerCc11, managerCc12); Assert.AreSame(managerCc21, managerCc22); Assert.AreNotSame(managerCc11, managerCc21); Assert.AreNotSame(managerP11, managerCc11); Assert.AreNotSame(managerP11, managerCc21); Assert.AreNotSame(managerP21, managerCc11); Assert.AreNotSame(managerP21, managerCc21); Util.CompleteDefaultAggregationCycle( managerP11, managerP21, managerCc11, managerCc21); telemetryPipeline1.Dispose(); telemetryPipeline2.Dispose(); }
public void GetMetric_RespectsAggregationScope() { IList <ITelemetry> sentTelemetry1, sentTelemetry2; TelemetryConfiguration telemetryPipeline1 = Util.CreateAITelemetryConfig(out sentTelemetry1); TelemetryConfiguration telemetryPipeline2 = Util.CreateAITelemetryConfig(out sentTelemetry2); TelemetryClient client11 = new TelemetryClient(telemetryPipeline1); TelemetryClient client12 = new TelemetryClient(telemetryPipeline1); TelemetryClient client21 = new TelemetryClient(telemetryPipeline2); Metric metricA111 = client11.GetMetric("Metric A", "Dim1", MetricConfigurations.Measurement, MetricAggregationScope.TelemetryConfiguration); metricA111.TrackValue(101); metricA111.TrackValue(102); metricA111.TryTrackValue(111, "Val"); metricA111.TryTrackValue(112, "Val"); Metric metricA112 = client11.GetMetric("Metric A", "Dim1", MetricConfigurations.Measurement); metricA112.TrackValue(103); metricA112.TrackValue(104); metricA112.TryTrackValue(113, "Val"); metricA112.TryTrackValue(114, "Val"); Metric metricA113 = client11.GetMetric("Metric A", "Dim1"); metricA113.TrackValue(105); metricA113.TrackValue(106); metricA113.TryTrackValue(115, "Val"); metricA113.TryTrackValue(116, "Val"); Assert.AreSame(metricA111, metricA112); Assert.AreSame(metricA111, metricA113); Assert.AreSame(metricA112, metricA113); MetricSeries series1, series2; Assert.IsTrue(metricA111.TryGetDataSeries(out series1)); Assert.IsTrue(metricA112.TryGetDataSeries(out series2)); Assert.AreSame(series1, series2); Assert.IsTrue(metricA113.TryGetDataSeries(out series2)); Assert.AreSame(series1, series2); Assert.IsTrue(metricA112.TryGetDataSeries(out series1)); Assert.AreSame(series1, series2); Assert.IsTrue(metricA111.TryGetDataSeries(out series1, "Val")); Assert.IsTrue(metricA112.TryGetDataSeries(out series2, "Val")); Assert.AreSame(series1, series2); Assert.IsTrue(metricA113.TryGetDataSeries(out series2, "Val")); Assert.AreSame(series1, series2); Assert.IsTrue(metricA112.TryGetDataSeries(out series1, "Val")); Assert.AreSame(series1, series2); Metric metricA121 = client12.GetMetric("Metric A", "Dim1", MetricConfigurations.Measurement, MetricAggregationScope.TelemetryConfiguration); metricA121.TrackValue(107); metricA121.TrackValue(108); metricA121.TryTrackValue(117, "Val"); metricA121.TryTrackValue(118, "Val"); Assert.AreSame(metricA111, metricA121); Metric metricA211 = client21.GetMetric("Metric A", "Dim1", MetricConfigurations.Measurement, MetricAggregationScope.TelemetryConfiguration); metricA211.TrackValue(201); metricA211.TrackValue(202); metricA211.TryTrackValue(211, "Val"); metricA211.TryTrackValue(212, "Val"); Assert.AreNotSame(metricA111, metricA211); Metric metricA11c1 = client11.GetMetric("Metric A", "Dim1", MetricConfigurations.Measurement, MetricAggregationScope.TelemetryClient); metricA11c1.TrackValue(301); metricA11c1.TrackValue(302); metricA11c1.TryTrackValue(311, "Val"); metricA11c1.TryTrackValue(312, "Val"); Metric metricA11c2 = client11.GetMetric("Metric A", "Dim1", MetricConfigurations.Measurement, MetricAggregationScope.TelemetryClient); metricA11c2.TrackValue(303); metricA11c2.TrackValue(304); metricA11c2.TryTrackValue(313, "Val"); metricA11c2.TryTrackValue(314, "Val"); Assert.AreNotSame(metricA111, metricA11c1); Assert.AreSame(metricA11c1, metricA11c2); Assert.IsTrue(metricA11c1.TryGetDataSeries(out series1)); Assert.IsTrue(metricA11c1.TryGetDataSeries(out series2)); Assert.AreSame(series1, series2); Assert.IsTrue(metricA11c1.TryGetDataSeries(out series1, "Val")); Assert.IsTrue(metricA11c1.TryGetDataSeries(out series2, "Val")); Assert.AreSame(series1, series2); Metric metricA12c1 = client12.GetMetric("Metric A", "Dim1", MetricConfigurations.Measurement, MetricAggregationScope.TelemetryClient); metricA12c1.TrackValue(305); metricA12c1.TrackValue(306); metricA12c1.TryTrackValue(315, "Val"); metricA12c1.TryTrackValue(316, "Val"); Assert.AreNotSame(metricA11c1, metricA12c1); client11.Metrics(MetricAggregationScope.TelemetryClient).Flush(); client12.Metrics(MetricAggregationScope.TelemetryClient).Flush(); client21.Metrics(MetricAggregationScope.TelemetryClient).Flush(); telemetryPipeline1.Metrics().Flush(); telemetryPipeline2.Metrics().Flush(); Assert.AreEqual(6, sentTelemetry1.Count); Assert.AreEqual(2, sentTelemetry2.Count); MetricTelemetry[] orderedTelemetry = sentTelemetry1 .OrderByDescending((t) => ((MetricTelemetry)t).Count * 10000 + ((MetricTelemetry)t).Sum) .Select((t) => (MetricTelemetry)t) .ToArray(); Util.ValidateNumericAggregateValues(orderedTelemetry[0], "Metric A", 8, 916, 118, 111, 2.29128784747792); Assert.AreEqual(2, orderedTelemetry[0].Context.Properties.Count); Assert.IsTrue(orderedTelemetry[0].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Assert.AreEqual("Val", orderedTelemetry[0].Context.Properties["Dim1"]); Util.ValidateNumericAggregateValues(orderedTelemetry[1], "Metric A", 8, 836, 108, 101, 2.29128784747792); Assert.AreEqual(1, orderedTelemetry[1].Context.Properties.Count); Assert.IsTrue(orderedTelemetry[1].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Util.ValidateNumericAggregateValues(orderedTelemetry[2], "Metric A", 4, 1250, 314, 311, 1.11803398874989); Assert.AreEqual(2, orderedTelemetry[2].Context.Properties.Count); Assert.IsTrue(orderedTelemetry[2].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Assert.AreEqual("Val", orderedTelemetry[2].Context.Properties["Dim1"]); Util.ValidateNumericAggregateValues(orderedTelemetry[3], "Metric A", 4, 1210, 304, 301, 1.11803398874989); Assert.AreEqual(1, orderedTelemetry[3].Context.Properties.Count); Assert.IsTrue(orderedTelemetry[3].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Util.ValidateNumericAggregateValues(orderedTelemetry[4], "Metric A", 2, 631, 316, 315, 0.5); Assert.AreEqual(2, orderedTelemetry[4].Context.Properties.Count); Assert.IsTrue(orderedTelemetry[4].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Assert.AreEqual("Val", orderedTelemetry[4].Context.Properties["Dim1"]); Util.ValidateNumericAggregateValues(orderedTelemetry[5], "Metric A", 2, 611, 306, 305, 0.5); Assert.AreEqual(1, orderedTelemetry[5].Context.Properties.Count); Assert.IsTrue(orderedTelemetry[5].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); orderedTelemetry = sentTelemetry2 .OrderByDescending((t) => ((MetricTelemetry)t).Count * 10000 + ((MetricTelemetry)t).Sum) .Select((t) => (MetricTelemetry)t) .ToArray(); Util.ValidateNumericAggregateValues(orderedTelemetry[0], "Metric A", 2, 423, 212, 211, 0.5); Assert.AreEqual(2, orderedTelemetry[0].Context.Properties.Count); Assert.IsTrue(orderedTelemetry[0].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Assert.AreEqual("Val", orderedTelemetry[0].Context.Properties["Dim1"]); Util.ValidateNumericAggregateValues(orderedTelemetry[1], "Metric A", 2, 403, 202, 201, 0.5); Assert.AreEqual(1, orderedTelemetry[1].Context.Properties.Count); Assert.IsTrue(orderedTelemetry[1].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Metric metricB21c1 = client21.GetMetric("Metric B", MetricConfigurations.Measurement, MetricAggregationScope.TelemetryClient); TelemetryClient client22 = new TelemetryClient(telemetryPipeline2); TelemetryClient client23 = new TelemetryClient(telemetryPipeline2); Assert.AreNotSame(metricB21c1, client22.GetMetric("Metric B", MetricConfigurations.Measurement, MetricAggregationScope.TelemetryClient)); Assert.AreSame(metricB21c1, client21.GetMetric("Metric B", MetricConfigurations.Measurement, MetricAggregationScope.TelemetryClient)); Assert.ThrowsException <ArgumentException>(() => client21.GetMetric("Metric B", MetricConfigurations.Accumulator, MetricAggregationScope.TelemetryClient)); Assert.IsNotNull(client23.GetMetric("Metric B", MetricConfigurations.Accumulator, MetricAggregationScope.TelemetryClient)); Metric metricB211 = client21.GetMetric("Metric B", MetricConfigurations.Measurement, MetricAggregationScope.TelemetryConfiguration); TelemetryClient client24 = new TelemetryClient(telemetryPipeline2); TelemetryClient client25 = new TelemetryClient(telemetryPipeline2); Assert.AreSame(metricB211, client24.GetMetric("Metric B", MetricConfigurations.Measurement, MetricAggregationScope.TelemetryConfiguration)); Assert.AreSame(metricB211, client21.GetMetric("Metric B", MetricConfigurations.Measurement, MetricAggregationScope.TelemetryConfiguration)); Assert.ThrowsException <ArgumentException>(() => client21.GetMetric("Metric B", MetricConfigurations.Accumulator, MetricAggregationScope.TelemetryConfiguration)); Assert.ThrowsException <ArgumentException>(() => client25.GetMetric("Metric B", MetricConfigurations.Accumulator, MetricAggregationScope.TelemetryConfiguration)); Assert.ThrowsException <ArgumentException>(() => client11.GetMetric("Metric C", MetricConfigurations.Accumulator, (MetricAggregationScope)42)); Util.CompleteDefaultAggregationCycle( client11.Metrics(MetricAggregationScope.TelemetryClient), client12.Metrics(MetricAggregationScope.TelemetryClient), client21.Metrics(MetricAggregationScope.TelemetryClient), client22.Metrics(MetricAggregationScope.TelemetryClient), client23.Metrics(MetricAggregationScope.TelemetryClient), client24.Metrics(MetricAggregationScope.TelemetryClient), client25.Metrics(MetricAggregationScope.TelemetryClient), telemetryPipeline2.Metrics(), telemetryPipeline1.Metrics()); telemetryPipeline1.Dispose(); telemetryPipeline2.Dispose(); }
public void GetMetric_DetectsMetricConfigurationConflicts() { IList <ITelemetry> sentTelemetry; TelemetryConfiguration telemetryPipeline = Util.CreateAITelemetryConfig(out sentTelemetry); TelemetryClient client = new TelemetryClient(telemetryPipeline); { Metric m1 = client.GetMetric("M01"); Assert.IsNotNull(m1); Metric m2 = client.GetMetric("M01"); Assert.AreSame(m1, m2); m2 = client.GetMetric("M01 "); Assert.AreSame(m1, m2); m2 = client.GetMetric("M01", MetricConfigurations.Measurement); Assert.AreSame(m1, m2); m2 = client.GetMetric("M01", metricConfiguration: null); Assert.AreSame(m1, m2); Assert.ThrowsException <ArgumentException>(() => client.GetMetric("M01", MetricConfigurations.Accumulator)); IMetricConfiguration config1 = new SimpleMetricConfiguration(10, 10, new SimpleMetricSeriesConfiguration(false)); IMetricConfiguration config2 = new SimpleMetricConfiguration(10, 10, new SimpleMetricSeriesConfiguration(false)); Assert.AreEqual(config1, config2); Assert.AreNotSame(config1, config2); m1 = client.GetMetric("M02", config1); Assert.IsNotNull(m1); m2 = client.GetMetric("M02", config2); Assert.AreSame(m1, m2); m2 = client.GetMetric("M02", metricConfiguration: null); Assert.AreSame(m1, m2); config2 = new SimpleMetricConfiguration(10, 101, new SimpleMetricSeriesConfiguration(false)); Assert.AreNotEqual(config1, config2); Assert.AreNotSame(config1, config2); Assert.ThrowsException <ArgumentException>(() => client.GetMetric("M02", config2)); Assert.ThrowsException <ArgumentException>(() => client.GetMetric("M02 ", config2)); } { Metric m1 = client.GetMetric("M11", "Dim1"); Assert.IsNotNull(m1); Metric m2 = client.GetMetric("M11", "Dim1"); Assert.AreSame(m1, m2); m2 = client.GetMetric(" M11", "Dim1"); Assert.AreSame(m1, m2); m2 = client.GetMetric("M11", " Dim1"); Assert.AreSame(m1, m2); m2 = client.GetMetric(" M11", " Dim1", MetricConfigurations.Measurement); Assert.AreSame(m1, m2); m2 = client.GetMetric("M11", "Dim1", metricConfiguration: null); Assert.AreSame(m1, m2); Assert.ThrowsException <ArgumentException>(() => client.GetMetric("M11", "Dim1 ", MetricConfigurations.Accumulator)); IMetricConfiguration config1 = new SimpleMetricConfiguration(10, 10, new SimpleMetricSeriesConfiguration(false)); IMetricConfiguration config2 = new SimpleMetricConfiguration(10, 10, new SimpleMetricSeriesConfiguration(false)); Assert.AreEqual(config1, config2); Assert.AreNotSame(config1, config2); m1 = client.GetMetric("M12 ", "Dim1", config1); Assert.IsNotNull(m1); m2 = client.GetMetric("M12", "Dim1 ", config2); Assert.AreSame(m1, m2); m2 = client.GetMetric("M12", "Dim1", metricConfiguration: null); Assert.AreSame(m1, m2); config2 = new SimpleMetricConfiguration(10, 101, new SimpleMetricSeriesConfiguration(false)); Assert.AreNotEqual(config1, config2); Assert.AreNotSame(config1, config2); Assert.ThrowsException <ArgumentException>(() => client.GetMetric("M12", "Dim1", config2)); Assert.ThrowsException <ArgumentException>(() => client.GetMetric("M12 ", "Dim1", config2)); } { Metric m1 = client.GetMetric("M21", "Dim1", "Dim2"); Assert.IsNotNull(m1); Metric m2 = client.GetMetric("M21", "Dim1", "Dim2"); Assert.AreSame(m1, m2); m2 = client.GetMetric(" M21", "Dim1", "Dim2"); Assert.AreSame(m1, m2); m2 = client.GetMetric("M21", " Dim1", "Dim2"); Assert.AreSame(m1, m2); m2 = client.GetMetric("M21", "Dim1", " Dim2"); Assert.AreSame(m1, m2); m2 = client.GetMetric(" M21", " Dim1", "Dim2", MetricConfigurations.Measurement); Assert.AreSame(m1, m2); m2 = client.GetMetric("M21", "Dim1", "Dim2 ", metricConfiguration: null); Assert.AreSame(m1, m2); Assert.ThrowsException <ArgumentException>(() => client.GetMetric("M21", "Dim1 ", "Dim2", MetricConfigurations.Accumulator)); IMetricConfiguration config1 = new SimpleMetricConfiguration(10, 10, new SimpleMetricSeriesConfiguration(false)); IMetricConfiguration config2 = new SimpleMetricConfiguration(10, 10, new SimpleMetricSeriesConfiguration(false)); Assert.AreEqual(config1, config2); Assert.AreNotSame(config1, config2); m1 = client.GetMetric("M22 ", "Dim1", "Dim2 ", config1); Assert.IsNotNull(m1); m2 = client.GetMetric("M22", "Dim1 ", "Dim2", config2); Assert.AreSame(m1, m2); m2 = client.GetMetric("M22", "Dim1", "Dim2", metricConfiguration: null); Assert.AreSame(m1, m2); config2 = new SimpleMetricConfiguration(10, 101, new SimpleMetricSeriesConfiguration(false)); Assert.AreNotEqual(config1, config2); Assert.AreNotSame(config1, config2); Assert.ThrowsException <ArgumentException>(() => client.GetMetric("M22", "Dim1", "Dim2", config2)); Assert.ThrowsException <ArgumentException>(() => client.GetMetric("M22 ", "Dim1", "Dim2", config2)); } { Metric m0 = client.GetMetric("Xxx"); Metric m1 = client.GetMetric("Xxx", "Dim1"); Metric m2 = client.GetMetric("Xxx", "Dim1", "Dim2"); Assert.IsNotNull(m0); Assert.IsNotNull(m1); Assert.IsNotNull(m2); Assert.AreNotSame(m0, m1); Assert.AreNotSame(m0, m2); Assert.AreNotSame(m1, m2); Assert.AreSame(m0.GetConfiguration(), m1.GetConfiguration()); Assert.AreSame(m0.GetConfiguration(), m2.GetConfiguration()); Assert.AreSame(m1.GetConfiguration(), m2.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement, m0.GetConfiguration()); } Util.CompleteDefaultAggregationCycle(telemetryPipeline.Metrics()); telemetryPipeline.Dispose(); }
public void GetMetric_SendsData() { IList <ITelemetry> sentTelemetry; TelemetryConfiguration telemetryPipeline = Util.CreateAITelemetryConfig(out sentTelemetry); TelemetryClient client = new TelemetryClient(telemetryPipeline); { Metric metric = client.GetMetric("CowsSold"); Assert.IsNotNull(metric); Assert.AreEqual(0, metric.DimensionsCount); Assert.AreEqual("CowsSold", metric.MetricId); Assert.AreEqual(MetricConfigurations.Measurement, metric.GetConfiguration()); metric.TrackValue(0.5); metric.TrackValue(0.6); Assert.ThrowsException <InvalidOperationException>(() => metric.TryTrackValue(1.5, "A")); Assert.ThrowsException <InvalidOperationException>(() => metric.TryTrackValue(2.5, "A", "X")); telemetryPipeline.Metrics().Flush(); Assert.AreEqual(1, sentTelemetry.Count); Util.ValidateNumericAggregateValues(sentTelemetry[0], "CowsSold", 2, 1.1, 0.6, 0.5, 0.05); Assert.AreEqual(1, sentTelemetry[0].Context.Properties.Count); Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); sentTelemetry.Clear(); metric.TrackValue(0.7); metric.TrackValue(0.8); telemetryPipeline.Metrics().Flush(); Assert.AreEqual(1, sentTelemetry.Count); Util.ValidateNumericAggregateValues(sentTelemetry[0], "CowsSold", 2, 1.5, 0.8, 0.7, 0.05); Assert.AreEqual(1, sentTelemetry[0].Context.Properties.Count); Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); sentTelemetry.Clear(); } { Metric metric = client.GetMetric("CowsSold", "Color", MetricConfigurations.Accumulator); Assert.IsNotNull(metric); Assert.AreEqual(1, metric.DimensionsCount); Assert.AreEqual("CowsSold", metric.MetricId); Assert.AreEqual(MetricConfigurations.Accumulator, metric.GetConfiguration()); metric.TryTrackValue(0.5, "Purple"); metric.TryTrackValue(0.6, "Purple"); Assert.ThrowsException <InvalidOperationException>(() => metric.TryTrackValue(2.5, "A", "X")); telemetryPipeline.Metrics().Flush(); Assert.AreEqual(1, sentTelemetry.Count); Util.ValidateNumericAggregateValues(sentTelemetry[0], "CowsSold", 1, 1.1, 1.1, 0.5, null); Assert.AreEqual(2, sentTelemetry[0].Context.Properties.Count); Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Assert.AreEqual("Purple", sentTelemetry[0].Context.Properties["Color"]); sentTelemetry.Clear(); metric.TryTrackValue(0.7, "Purple"); metric.TryTrackValue(0.8, "Purple"); telemetryPipeline.Metrics().Flush(); Assert.AreEqual(1, sentTelemetry.Count); Util.ValidateNumericAggregateValues(sentTelemetry[0], "CowsSold", 1, 2.6, 2.6, 0.5, null); Assert.AreEqual(2, sentTelemetry[0].Context.Properties.Count); Assert.IsTrue(sentTelemetry[0].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Assert.AreEqual("Purple", sentTelemetry[0].Context.Properties["Color"]); sentTelemetry.Clear(); } { Metric metric = client.GetMetric("CowsSold", "Color", "Size", MetricConfigurations.Accumulator); Assert.IsNotNull(metric); Assert.AreEqual(2, metric.DimensionsCount); Assert.AreEqual("CowsSold", metric.MetricId); Assert.AreEqual(MetricConfigurations.Accumulator, metric.GetConfiguration()); metric.TryTrackValue(0.5, "Purple", "Large"); metric.TryTrackValue(0.6, "Purple", "Large"); telemetryPipeline.Metrics().Flush(); Assert.AreEqual(2, sentTelemetry.Count); MetricTelemetry[] orderedTelemetry = sentTelemetry .OrderByDescending((t) => ((MetricTelemetry)t).Count * 10000 + ((MetricTelemetry)t).Sum) .Select((t) => (MetricTelemetry)t) .ToArray(); // This one is from the prev section: Util.ValidateNumericAggregateValues(orderedTelemetry[0], "CowsSold", 1, 2.6, 2.6, 0.5, null); Assert.AreEqual(2, orderedTelemetry[0].Context.Properties.Count); Assert.IsTrue(orderedTelemetry[0].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Assert.AreEqual("Purple", orderedTelemetry[0].Context.Properties["Color"]); Util.ValidateNumericAggregateValues(orderedTelemetry[1], "CowsSold", 1, 1.1, 1.1, 0.5, null); Assert.AreEqual(3, orderedTelemetry[1].Context.Properties.Count); Assert.IsTrue(orderedTelemetry[1].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Assert.AreEqual("Purple", orderedTelemetry[1].Context.Properties["Color"]); Assert.AreEqual("Large", orderedTelemetry[1].Context.Properties["Size"]); sentTelemetry.Clear(); metric.TryTrackValue(0.7, "Purple", "Large"); metric.TryTrackValue(0.8, "Purple", "Small"); telemetryPipeline.Metrics().Flush(); Assert.AreEqual(3, sentTelemetry.Count); orderedTelemetry = sentTelemetry .OrderByDescending((t) => ((MetricTelemetry)t).Count * 10000 + ((MetricTelemetry)t).Sum) .Select((t) => (MetricTelemetry)t) .ToArray(); // This one is from the prev section: Util.ValidateNumericAggregateValues(orderedTelemetry[0], "CowsSold", 1, 2.6, 2.6, 0.5, null); Assert.AreEqual(2, orderedTelemetry[0].Context.Properties.Count); Assert.IsTrue(orderedTelemetry[0].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Assert.AreEqual("Purple", orderedTelemetry[0].Context.Properties["Color"]); Util.ValidateNumericAggregateValues(orderedTelemetry[1], "CowsSold", 1, 1.8, 1.8, 0.5, null); Assert.AreEqual(3, orderedTelemetry[1].Context.Properties.Count); Assert.IsTrue(orderedTelemetry[1].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Assert.AreEqual("Purple", orderedTelemetry[1].Context.Properties["Color"]); Assert.AreEqual("Large", orderedTelemetry[1].Context.Properties["Size"]); Util.ValidateNumericAggregateValues(orderedTelemetry[2], "CowsSold", 1, 0.8, 0.8, 0.8, null); Assert.AreEqual(3, orderedTelemetry[2].Context.Properties.Count); Assert.IsTrue(orderedTelemetry[2].Context.Properties.ContainsKey(Util.AggregationIntervalMonikerPropertyKey)); Assert.AreEqual("Purple", orderedTelemetry[2].Context.Properties["Color"]); Assert.AreEqual("Small", orderedTelemetry[2].Context.Properties["Size"]); sentTelemetry.Clear(); } Util.CompleteDefaultAggregationCycle(telemetryPipeline.Metrics()); telemetryPipeline.Dispose(); }
public void GetMetric_RespectsMetricConfiguration() { IList <ITelemetry> sentTelemetry; TelemetryConfiguration telemetryPipeline = Util.CreateAITelemetryConfig(out sentTelemetry); TelemetryClient client = new TelemetryClient(telemetryPipeline); { Metric metric = client.GetMetric("M1"); Assert.IsNotNull(metric); Assert.AreEqual(0, metric.DimensionsCount); Assert.AreEqual("M1", metric.MetricId); Assert.AreEqual(MetricConfigurations.Measurement, metric.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement, metric.GetConfiguration()); MetricSeries series; Assert.IsTrue(metric.TryGetDataSeries(out series)); Assert.AreEqual(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); } { Metric metric = client.GetMetric("M2", MetricConfigurations.Measurement); Assert.IsNotNull(metric); Assert.AreEqual(0, metric.DimensionsCount); Assert.AreEqual("M2", metric.MetricId); Assert.AreEqual(MetricConfigurations.Measurement, metric.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement, metric.GetConfiguration()); MetricSeries series; Assert.IsTrue(metric.TryGetDataSeries(out series)); Assert.AreEqual(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); } { Metric metric = client.GetMetric("M3", MetricConfigurations.Accumulator); Assert.IsNotNull(metric); Assert.AreEqual(0, metric.DimensionsCount); Assert.AreEqual("M3", metric.MetricId); Assert.AreEqual(MetricConfigurations.Accumulator, metric.GetConfiguration()); Assert.AreSame(MetricConfigurations.Accumulator, metric.GetConfiguration()); MetricSeries series; Assert.IsTrue(metric.TryGetDataSeries(out series)); Assert.AreEqual(MetricConfigurations.Accumulator.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Accumulator.SeriesConfig, series.GetConfiguration()); } { IMetricConfiguration config = new SimpleMetricConfiguration(10, 10, new SimpleMetricSeriesConfiguration(true)); Metric metric = client.GetMetric("M4", config); Assert.IsNotNull(metric); Assert.AreEqual(0, metric.DimensionsCount); Assert.AreEqual("M4", metric.MetricId); Assert.AreEqual(config, metric.GetConfiguration()); Assert.AreSame(config, metric.GetConfiguration()); MetricSeries series; Assert.IsTrue(metric.TryGetDataSeries(out series)); Assert.AreEqual(new SimpleMetricSeriesConfiguration(true), series.GetConfiguration()); Assert.AreNotSame(new SimpleMetricSeriesConfiguration(true), series.GetConfiguration()); } { Metric metric = client.GetMetric("M5", "Dim1"); Assert.IsNotNull(metric); Assert.AreEqual(1, metric.DimensionsCount); Assert.AreEqual("Dim1", metric.GetDimensionName(1)); Assert.AreEqual("M5", metric.MetricId); Assert.AreEqual(MetricConfigurations.Measurement, metric.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement, metric.GetConfiguration()); MetricSeries series; Assert.IsTrue(metric.TryGetDataSeries(out series)); Assert.AreEqual(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.IsTrue(metric.TryGetDataSeries(out series, "Dim1Val")); Assert.AreEqual(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); } { Metric metric = client.GetMetric("M6", "Dim1", MetricConfigurations.Measurement); Assert.IsNotNull(metric); Assert.AreEqual(1, metric.DimensionsCount); Assert.AreEqual("Dim1", metric.GetDimensionName(1)); Assert.AreEqual("M6", metric.MetricId); Assert.AreEqual(MetricConfigurations.Measurement, metric.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement, metric.GetConfiguration()); MetricSeries series; Assert.IsTrue(metric.TryGetDataSeries(out series)); Assert.AreEqual(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.IsTrue(metric.TryGetDataSeries(out series, "Dim1Val")); Assert.AreEqual(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); } { Metric metric = client.GetMetric("M7", "Dim1", MetricConfigurations.Accumulator); Assert.IsNotNull(metric); Assert.AreEqual(1, metric.DimensionsCount); Assert.AreEqual("Dim1", metric.GetDimensionName(1)); Assert.AreEqual("M7", metric.MetricId); Assert.AreEqual(MetricConfigurations.Accumulator, metric.GetConfiguration()); Assert.AreSame(MetricConfigurations.Accumulator, metric.GetConfiguration()); MetricSeries series; Assert.IsTrue(metric.TryGetDataSeries(out series)); Assert.AreEqual(MetricConfigurations.Accumulator.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Accumulator.SeriesConfig, series.GetConfiguration()); Assert.IsTrue(metric.TryGetDataSeries(out series, "Dim1Val")); Assert.AreEqual(MetricConfigurations.Accumulator.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Accumulator.SeriesConfig, series.GetConfiguration()); } { IMetricConfiguration config = new SimpleMetricConfiguration(10, 10, new SimpleMetricSeriesConfiguration(true)); Metric metric = client.GetMetric("M8", "Dim1", config); Assert.IsNotNull(metric); Assert.AreEqual(1, metric.DimensionsCount); Assert.AreEqual("Dim1", metric.GetDimensionName(1)); Assert.AreEqual("M8", metric.MetricId); Assert.AreEqual(config, metric.GetConfiguration()); Assert.AreSame(config, metric.GetConfiguration()); MetricSeries series; Assert.IsTrue(metric.TryGetDataSeries(out series)); Assert.AreEqual(config.SeriesConfig, series.GetConfiguration()); Assert.AreSame(config.SeriesConfig, series.GetConfiguration()); Assert.IsTrue(metric.TryGetDataSeries(out series, "Dim1Val")); Assert.AreEqual(new SimpleMetricSeriesConfiguration(true), series.GetConfiguration()); Assert.AreNotSame(new SimpleMetricSeriesConfiguration(true), series.GetConfiguration()); } { Metric metric = client.GetMetric("M9", "Dim1", "Dim2"); Assert.IsNotNull(metric); Assert.AreEqual(2, metric.DimensionsCount); Assert.AreEqual("Dim1", metric.GetDimensionName(1)); Assert.AreEqual("Dim2", metric.GetDimensionName(2)); Assert.AreEqual("M9", metric.MetricId); Assert.AreEqual(MetricConfigurations.Measurement, metric.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement, metric.GetConfiguration()); MetricSeries series; Assert.IsTrue(metric.TryGetDataSeries(out series)); Assert.AreEqual(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.IsTrue(metric.TryGetDataSeries(out series, "Dim1Val", "Dim2val")); Assert.AreEqual(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); } { Metric metric = client.GetMetric("M10", "Dim1", "Dim2", MetricConfigurations.Measurement); Assert.IsNotNull(metric); Assert.AreEqual(2, metric.DimensionsCount); Assert.AreEqual("Dim1", metric.GetDimensionName(1)); Assert.AreEqual("Dim2", metric.GetDimensionName(2)); Assert.AreEqual("M10", metric.MetricId); Assert.AreEqual(MetricConfigurations.Measurement, metric.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement, metric.GetConfiguration()); MetricSeries series; Assert.IsTrue(metric.TryGetDataSeries(out series)); Assert.AreEqual(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.IsTrue(metric.TryGetDataSeries(out series, "Dim1Val", "Dim2val")); Assert.AreEqual(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Measurement.SeriesConfig, series.GetConfiguration()); } { Metric metric = client.GetMetric("M11", "Dim1", "Dim2", MetricConfigurations.Accumulator); Assert.IsNotNull(metric); Assert.AreEqual(2, metric.DimensionsCount); Assert.AreEqual("Dim1", metric.GetDimensionName(1)); Assert.AreEqual("Dim2", metric.GetDimensionName(2)); Assert.AreEqual("M11", metric.MetricId); Assert.AreEqual(MetricConfigurations.Accumulator, metric.GetConfiguration()); Assert.AreSame(MetricConfigurations.Accumulator, metric.GetConfiguration()); MetricSeries series; Assert.IsTrue(metric.TryGetDataSeries(out series)); Assert.AreEqual(MetricConfigurations.Accumulator.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Accumulator.SeriesConfig, series.GetConfiguration()); Assert.IsTrue(metric.TryGetDataSeries(out series, "Dim1Val", "Dim2val")); Assert.AreEqual(MetricConfigurations.Accumulator.SeriesConfig, series.GetConfiguration()); Assert.AreSame(MetricConfigurations.Accumulator.SeriesConfig, series.GetConfiguration()); } { IMetricConfiguration config = new SimpleMetricConfiguration(10, 10, new SimpleMetricSeriesConfiguration(true)); Metric metric = client.GetMetric("M12", "Dim1", "Dim2", config); Assert.IsNotNull(metric); Assert.AreEqual(2, metric.DimensionsCount); Assert.AreEqual("Dim1", metric.GetDimensionName(1)); Assert.AreEqual("Dim2", metric.GetDimensionName(2)); Assert.AreEqual("M12", metric.MetricId); Assert.AreEqual(config, metric.GetConfiguration()); Assert.AreSame(config, metric.GetConfiguration()); MetricSeries series; Assert.IsTrue(metric.TryGetDataSeries(out series)); Assert.AreEqual(config.SeriesConfig, series.GetConfiguration()); Assert.AreSame(config.SeriesConfig, series.GetConfiguration()); Assert.IsTrue(metric.TryGetDataSeries(out series, "Dim1Val", "Dim2val")); Assert.AreEqual(new SimpleMetricSeriesConfiguration(true), series.GetConfiguration()); Assert.AreNotSame(new SimpleMetricSeriesConfiguration(true), series.GetConfiguration()); Assert.AreSame(config.SeriesConfig, series.GetConfiguration()); } Util.CompleteDefaultAggregationCycle(telemetryPipeline.Metrics()); }
private void RecordNormalMetric(TelemetryConfiguration telemetryPipeline) { MetricSeries durationMeric = telemetryPipeline.Metrics().CreateNewSeries( "Item Add duration", new SimpleMetricSeriesConfiguration(restrictToUInt32Values: false)); MockContainerDataStructure dataStructure = new MockContainerDataStructure((c) => TimeSpan.FromSeconds(c)); DateTimeOffset experimentStart = new DateTimeOffset(2017, 9, 14, 0, 0, 0, TimeSpan.Zero); // Stop the default minute-ly cycle so that it does not interfere with our virtual time debugging: Task fireAndForget = telemetryPipeline.Metrics().StopDefaultAggregationCycleAsync(); telemetryPipeline.Metrics().StartOrCycleAggregators(CycleKind.Custom, experimentStart, futureFilter: null); const int ExperimentLengthSecs = 60 * 10; const int IntervalLengthSecs = 60; int totalSecs = 0; int intervalSecs = 0; int itemsThisTime = 0; const int maxItemsAtATime = 4; int operationsCount = 0; while (totalSecs < ExperimentLengthSecs) { itemsThisTime = (itemsThisTime + 1) % maxItemsAtATime; int addItemCount = 1 + (itemsThisTime + 1) % maxItemsAtATime; int removeItemCount = 1 + itemsThisTime % maxItemsAtATime; Trace.WriteLine($"{totalSecs})"); Trace.WriteLine(addItemCount); Trace.WriteLine(removeItemCount); Trace.WriteLine(""); TimeSpan duration; dataStructure.AddItems(addItemCount, out duration); operationsCount++; int durationSecs = (int)duration.TotalSeconds; durationMeric.TrackValue(durationSecs); totalSecs += durationSecs; intervalSecs += durationSecs; dataStructure.RemoveItems(removeItemCount, out duration); operationsCount++; durationSecs = (int)duration.TotalSeconds; durationMeric.TrackValue(durationSecs); totalSecs += durationSecs; intervalSecs += durationSecs; if (intervalSecs >= IntervalLengthSecs) { AggregationPeriodSummary aggregatedMetrics = telemetryPipeline.Metrics().StartOrCycleAggregators( CycleKind.Custom, experimentStart.AddSeconds(totalSecs), futureFilter: null); Assert.IsNotNull(aggregatedMetrics); IReadOnlyList <MetricAggregate> aggregates = aggregatedMetrics.NonpersistentAggregates; Assert.IsNotNull(aggregates); Assert.AreEqual(1, aggregates.Count); MetricAggregate aggregate = aggregates[0]; Assert.IsNotNull(aggregates); Assert.AreEqual(1.0, aggregate.AggregateData["Min"]); Assert.AreEqual(4.0, aggregate.AggregateData["Max"]); Assert.AreEqual(operationsCount, aggregate.AggregateData["Count"]); Assert.AreEqual("Item Add duration", aggregate.MetricId); Assert.IsNotNull(aggregate.Dimensions); Assert.AreEqual(0, aggregate.Dimensions.Count); Assert.AreEqual((double)intervalSecs, aggregate.AggregateData["Sum"]); Assert.AreEqual(experimentStart.AddSeconds(totalSecs - intervalSecs), aggregate.AggregationPeriodStart); intervalSecs %= IntervalLengthSecs; operationsCount = 0; Assert.AreEqual(0, intervalSecs, "For the above to work, the number of wirtual secs must exactly fit into IntervalLengthSecs."); } } { AggregationPeriodSummary aggregatedMetrics = telemetryPipeline.Metrics().StartOrCycleAggregators( CycleKind.Custom, experimentStart.AddSeconds(totalSecs), futureFilter: null); Assert.IsNotNull(aggregatedMetrics); IReadOnlyList <MetricAggregate> aggregates = aggregatedMetrics.NonpersistentAggregates; Assert.IsNotNull(aggregates); Assert.AreEqual(0, aggregates.Count); } { durationMeric.TrackValue("7"); durationMeric.TrackValue("8"); durationMeric.TrackValue("9.0"); totalSecs += 24; } { AggregationPeriodSummary aggregatedMetrics = telemetryPipeline.Metrics().StopAggregators( CycleKind.Custom, experimentStart.AddSeconds(totalSecs)); Assert.IsNotNull(aggregatedMetrics); IReadOnlyList <MetricAggregate> aggregates = aggregatedMetrics.NonpersistentAggregates; Assert.IsNotNull(aggregates); MetricAggregate aggregate = aggregates[0]; Assert.IsNotNull(aggregates); Assert.AreEqual(7.0, aggregate.AggregateData["Min"]); Assert.AreEqual(9.0, aggregate.AggregateData["Max"]); Assert.AreEqual(3, aggregate.AggregateData["Count"]); Assert.AreEqual("Item Add duration", aggregate.MetricId); Assert.IsNotNull(aggregate.Dimensions); Assert.AreEqual(0, aggregate.Dimensions.Count); Assert.AreEqual(24.0, aggregate.AggregateData["Sum"]); Assert.AreEqual(experimentStart.AddSeconds(totalSecs - 24), aggregate.AggregationPeriodStart); } }