public void MetricAggregatorCalculatesSumCorrectly()
{
// Arrange
double[] testValues = { 4.45, 8, 29.21, 78.43, 0 };
var sentTelemetry = new List <ITelemetry>();
var sentSamples = new List <MetricSample>();
var client = this.InitializeTelemetryClient(sentTelemetry, sentSamples);
using (MetricManager manager = new MetricManager(client))
{
Metric metric = manager.CreateMetric("Test Metric");
// Act
for (int i = 0; i < testValues.Length; i++)
{
metric.Track(testValues[i]);
}
}
// Assert
double sentSampleSum = sentTelemetry.Sum(
(telemetry) => {
var metric = telemetry as MetricTelemetry;
return(metric == null ? 0 : metric.Sum);
});
Assert.Equal(testValues.Sum(), sentSampleSum);
}
public void AggregatedMetricTelemetryIntervalDurationPropertyIsPositiveInteger()
{
// Arrange
var sentTelemetry = new List <ITelemetry>();
var client = this.InitializeTelemetryClient(sentTelemetry);
using (MetricManager manager = new MetricManager(client))
{
Metric metric = manager.CreateMetric("Test Metric");
// Act
metric.Track(42);
}
// Assert
var aggregatedMetric = (MetricTelemetry)sentTelemetry.Single();
Assert.Equal("Test Metric", aggregatedMetric.Name);
Assert.Equal(1, aggregatedMetric.Count);
Assert.Equal(1, aggregatedMetric.Properties.Count);
Assert.True(aggregatedMetric.Properties.ContainsKey("IntervalDurationMs"));
Assert.True(long.Parse(aggregatedMetric.Properties["IntervalDurationMs"]) > 0);
}
public void CanCreateMetricWithASetOfDimensions()
{
// Arrange
var sentTelemetry = new List <ITelemetry>();
var client = this.InitializeTelemetryClient(sentTelemetry);
var dimensions = new Dictionary <string, string> {
{ "Dim1", "Value1" },
{ "Dim2", "Value2" }
};
using (MetricManager manager = new MetricManager(client))
{
// Act
Metric metric = manager.CreateMetric("Test Metric", dimensions);
metric.Track(42);
}
// Assert
var aggregatedMetric = (MetricTelemetry)sentTelemetry.Single();
Assert.Equal("Test Metric", aggregatedMetric.Name);
Assert.Equal(1, aggregatedMetric.Count);
Assert.Equal(42, aggregatedMetric.Sum);
// note: interval duration property is auto-generated
Assert.Equal(3, aggregatedMetric.Properties.Count);
Assert.Equal("Value1", aggregatedMetric.Properties["Dim1"]);
Assert.Equal("Value2", aggregatedMetric.Properties["Dim2"]);
}
public void CanCreateMetricHavingNoDimensions()
{
// Arrange
var sentTelemetry = new List <ITelemetry>();
var client = this.InitializeTelemetryClient(sentTelemetry);
using (MetricManager manager = new MetricManager(client))
{
// Act
Metric metric = manager.CreateMetric("Test Metric");
metric.Track(42);
}
// Assert (single metric aggregation exists in the output)
var aggregatedMetric = (MetricTelemetry)sentTelemetry.Single();
Assert.AreEqual("Test Metric", aggregatedMetric.Name);
Assert.AreEqual(1, aggregatedMetric.Count);
Assert.AreEqual(42, aggregatedMetric.Sum);
// note: interval duration property is auto-generated
Assert.AreEqual(1, aggregatedMetric.Properties.Count);
}
public void MetricInvokesMetricProcessorsForEachValueTracked()
{
// Arrange
var sentTelemetry = new List <ITelemetry>();
var sentSamples = new List <MetricSample>();
var client = this.InitializeTelemetryClient(sentTelemetry, sentSamples);
var dimensions = new Dictionary <string, string> {
{ "Dim1", "Value1" },
{ "Dim2", "Value2" }
};
using (MetricManager manager = new MetricManager(client))
{
Metric metric = manager.CreateMetric("Test Metric", dimensions);
// Act
metric.Track(42);
}
// Assert
var sample = (MetricSample)sentSamples.Single();
Assert.Equal("Test Metric", sample.Name);
Assert.Equal(42, sample.Value);
Assert.Equal("Value1", sample.Dimensions["Dim1"]);
Assert.Equal("Value2", sample.Dimensions["Dim2"]);
}
public void CanCreateMetricExplicitlySettingDimensionsToNull()
{
// Arrange
var sentTelemetry = new List <ITelemetry>();
var client = this.InitializeTelemetryClient(sentTelemetry);
using (MetricManager manager = new MetricManager(client))
{
// Act
Metric metric = manager.CreateMetric("Test Metric", null);
metric.Track(42);
}
// Assert
var aggregatedMetric = (MetricTelemetry)sentTelemetry.Single();
Assert.Equal("Test Metric", aggregatedMetric.Name);
Assert.Equal(1, aggregatedMetric.Count);
Assert.Equal(42, aggregatedMetric.Sum);
// note: interval duration property is auto-generated
Assert.Equal(1, aggregatedMetric.Properties.Count);
}
public void CanDisposeMetricManagerMultipleTimes()
{
MetricManager manager = null;
using (manager = new MetricManager()) { }
Assert.DoesNotThrow(() => { manager.Dispose(); });
}
public void MetricEqualsItself()
{
using (var manager = new MetricManager())
{
Metric metric = manager.CreateMetric("My metric");
Assert.True(metric.Equals(metric));
}
}
public void MetricsAreEqualIfDimensionsSetToNothingImplicitlyAndExplicitlyAsEmptySet()
{
using (var manager = new MetricManager())
{
Metric metric = manager.CreateMetric("My metric", new Dictionary <string, string>());
Metric other = manager.CreateMetric("My metric");
Assert.True(metric.Equals(other));
}
}
public void MetricsAreEqualForTheSameMetricNameWithoutDimensions()
{
using (var manager = new MetricManager())
{
Metric metric = manager.CreateMetric("My metric");
Metric other = manager.CreateMetric("My metric");
Assert.True(metric.Equals(other));
}
}
public void MetricNotEqualsOtherObject()
{
using (var manager = new MetricManager())
{
Metric metric = manager.CreateMetric("My metric");
var other = new object();
Assert.False(metric.Equals(other));
}
}
public void MetricNeverEqualsNull()
{
using (var manager = new MetricManager())
{
Metric metric = manager.CreateMetric("My metric");
object other = null;
Assert.False(metric.Equals(other));
}
}
public void MetricsAreEqualIfDimensionsSetToNothingImplicitlyAndExplicitly()
{
using (var manager = new MetricManager())
{
Metric metric = manager.CreateMetric("My metric", null);
Metric other = manager.CreateMetric("My metric");
Assert.IsTrue(metric.Equals(other));
}
}
public void MetricNameIsAccentSensitive()
{
using (var manager = new MetricManager())
{
Metric metric = manager.CreateMetric("My metric");
Metric other = manager.CreateMetric("My métric");
Assert.False(metric.Equals(other));
}
}
/// <summary>
/// Disposes this telemetry extractor.
/// </summary>
public void Dispose()
{
IDisposable metricMgr = this.metricManager;
if (metricMgr != null)
{
// benign race
metricMgr.Dispose();
this.metricManager = null;
}
}
/// <summary>
/// This class implements the <see cref="ITelemetryModule"/> interface by defining this method.
/// It will be called by the infrastructure when the telemetry pipeline is being built.
/// This will ensure that the extractor is initialized using the same <see cref="TelemetryConfiguration"/> as the rest of the pipeline.
/// Specifically, this will also ensure that the <see cref="Microsoft.ApplicationInsights.Extensibility.MetricManager"/> and its
/// respective <see cref="TelemetryClient"/> used internally for sending extracted metrics use the same configuration.
/// </summary>
/// <param name="configuration">The telemetric configuration to be used by this extractor.</param>
public void Initialize(TelemetryConfiguration configuration)
{
TelemetryClient telemetryClient = (configuration == null)
? new TelemetryClient()
: new TelemetryClient(configuration);
if (!string.IsNullOrWhiteSpace(MetricTerms.Autocollection.Moniker.Key))
{
telemetryClient.Context.Properties[MetricTerms.Autocollection.Moniker.Key] = MetricTerms.Autocollection.Moniker.Value;
}
this.metricManager = new MetricManager(telemetryClient);
this.InitializeExtractors();
}
/// <summary>
/// Calls all participating extractors to initialize themselves.
/// </summary>
private void InitializeExtractors()
{
MetricManager thisMetricManager = this.metricManager;
foreach (ExtractorWithInfo participant in this.extractors)
{
try
{
participant.Extractor.InitializeExtractor(thisMetricManager);
}
catch (Exception ex)
{
CoreEventSource.Log.LogError("Error in " + participant.Info + ": " + ex.ToString());
}
}
}
public void MetricAggregatorCalculatesStandardDeviationCorrectly()
{
// Arrange
double[] testValues = { 1, 2, 3, 4, 5 };
var sentTelemetry = new List <ITelemetry>();
var sentSamples = new List <MetricSample>();
var client = this.InitializeTelemetryClient(sentTelemetry, sentSamples);
using (MetricManager manager = new MetricManager(client))
{
Metric metric = manager.CreateMetric("Test Metric");
// Act
for (int i = 0; i < testValues.Length; i++)
{
metric.Track(testValues[i]);
}
}
// Assert
double sumOfSquares = sentTelemetry.Sum(
(telemetry) => {
var metric = telemetry as MetricTelemetry;
return
(metric == null
? 0
: Math.Pow(metric.StandardDeviation.Value, 2) * metric.Count.Value + Math.Pow(metric.Sum, 2) / metric.Count.Value);
});
int count = sentTelemetry.Sum(
(telemetry) => {
var metric = telemetry as MetricTelemetry;
return(metric == null ? 0 : metric.Count.Value);
});
double sum = sentTelemetry.Sum(
(telemetry) => {
var metric = telemetry as MetricTelemetry;
return(metric == null ? 0 : metric.Sum);
});
double stddev = Math.Sqrt(sumOfSquares / count - Math.Pow(sum / count, 2));
Assert.Equal(testValues.StdDev(), stddev);
}
/// <summary>
/// Initializes a new instance of the <see cref="Metric"/> class.
/// </summary>
/// <param name="manager">Aggregator manager handling this instance.</param>
/// <param name="name">Metric name.</param>
/// <param name="dimensions">Metric dimensions.</param>
internal Metric(
MetricManager manager,
string name,
IDictionary <string, string> dimensions = null)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
this.manager = manager;
this.Name = name;
this.Dimensions = dimensions;
this.aggregatorId = Metric.GetAggregatorId(name, dimensions);
this.hashCode = this.aggregatorId.GetHashCode();
}
public void EqualMetricsAreCombinedIntoSignleAggregatedStatsStructure()
{
// Arrange
var sentTelemetry = new List <ITelemetry>();
var client = this.InitializeTelemetryClient(sentTelemetry);
Metric metric1 = null;
Metric metric2 = null;
using (MetricManager manager = new MetricManager(client))
{
// note: on first go aggregators may be different because manager may
// snapshot after first got created but before the second
for (int i = 0; i < 2; i++)
{
metric1 = manager.CreateMetric("Test Metric");
metric2 = manager.CreateMetric("Test Metric");
// Act
metric1.Track(10);
metric2.Track(5);
manager.Flush();
if (sentTelemetry.Count == 1)
{
break;
}
else
{
sentTelemetry.Clear();
}
}
}
// Assert
Assert.Equal(1, sentTelemetry.Count);
var aggregatedMetric = (MetricTelemetry)sentTelemetry.Single();
Assert.Equal(2, aggregatedMetric.Count);
Assert.Equal(15, aggregatedMetric.Sum);
}
public void DimensionValuesAreAccentSensitive()
{
using (var manager = new MetricManager())
{
var dimensionSet1 = new Dictionary <string, string>()
{
{ "Dim1", "Value1" }
};
var dimensionSet2 = new Dictionary <string, string>()
{
{ "Dim1", "Válue1" }
};
Metric metric = manager.CreateMetric("My metric", dimensionSet1);
Metric other = manager.CreateMetric("My metric", dimensionSet2);
Assert.False(metric.Equals(other));
}
}
public void DimensionsAreOrderInsensitive()
{
using (var manager = new MetricManager())
{
var dimensionSet1 = new Dictionary <string, string>()
{
{ "Dim1", "Value1" },
{ "Dim2", "Value2" },
};
var dimensionSet2 = new Dictionary <string, string>()
{
{ "Dim2", "Value2" },
{ "Dim1", "Value1" },
};
Metric metric = manager.CreateMetric("My metric", dimensionSet1);
Metric other = manager.CreateMetric("My metric", dimensionSet2);
Assert.True(metric.Equals(other));
}
}
public void DisposingManagerCreatesAggregatedMetricTelemetry()
{
// Arrange
var sentTelemetry = new List <ITelemetry>();
var client = this.InitializeTelemetryClient(sentTelemetry);
using (MetricManager manager = new MetricManager(client))
{
Metric metric = manager.CreateMetric("Test Metric");
metric.Track(42);
// Act
manager.Dispose();
// Assert
Assert.Equal(1, sentTelemetry.Count);
var aggregatedMetric = (MetricTelemetry)sentTelemetry.Single();
Assert.NotNull(aggregatedMetric);
}
}
internal MetricManager GetMetricManager(bool createIfNotExists)
{
MetricManager manager = this.metricManager;
if (manager == null && createIfNotExists)
{
var pipelineAdapter = new ApplicationInsightsTelemetryPipeline(this);
MetricManager newManager = new MetricManager(pipelineAdapter);
MetricManager prevManager = Interlocked.CompareExchange(ref this.metricManager, newManager, null);
if (prevManager == null)
{
manager = newManager;
}
else
{
// We just created a new manager that we are not using. Stop is before discarding.
Task fireAndForget = newManager.StopDefaultAggregationCycleAsync();
manager = prevManager;
}
}
return(manager);
}