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