public void FirstChanceExceptionStatisticsTelemetryModuleUsesSetsInternalOperationName()
{
var metrics = new List <KeyValuePair <Metric, double> >();
StubMetricProcessor stub = new StubMetricProcessor()
{
OnTrack = (m, v) =>
{
metrics.Add(new KeyValuePair <Metric, double>(m, v));
}
};
this.configuration.TelemetryInitializers.Add(new StubTelemetryInitializer()
{
OnInitialize = (item) =>
{
item.Context.Operation.Name = TestOperationName;
}
});
using (var module = new FirstChanceExceptionStatisticsTelemetryModule())
{
module.Initialize(this.configuration);
module.MetricManager.MetricProcessors.Add(stub);
SdkInternalOperationsMonitor.Enter();
try
{
try
{
// FirstChanceExceptionStatisticsTelemetryModule will process this exception
throw new Exception("test");
}
catch (Exception exc)
{
// code to prevent profiler optimizations
Assert.Equal("test", exc.Message);
}
}
finally
{
SdkInternalOperationsMonitor.Exit();
}
}
Assert.Equal(1, metrics.Count);
Assert.Equal("Exceptions thrown", metrics[0].Key.Name);
var dims = metrics[0].Key.Dimensions;
Assert.Equal(2, dims.Count);
Assert.True(dims.Contains(new KeyValuePair <string, string>(FirstChanceExceptionStatisticsTelemetryModule.OperationNameTag, "AI (Internal)")));
}
public void FirstChanceExceptionStatisticsTelemetryModuleDoNotIncrementOnRethrow()
{
var metrics = new List <KeyValuePair <Metric, double> >();
StubMetricProcessor stub = new StubMetricProcessor()
{
OnTrack = (m, v) =>
{
metrics.Add(new KeyValuePair <Metric, double>(m, v));
}
};
using (var module = new FirstChanceExceptionStatisticsTelemetryModule())
{
module.Initialize(this.configuration);
module.MetricManager.MetricProcessors.Add(stub);
try
{
try
{
// FirstChanceExceptionStatisticsTelemetryModule will process this exception
throw new Exception("test");
}
catch (Exception ex)
{
// this assert is neede to avoid code optimization
Assert.Equal("test", ex.Message);
throw;
}
}
catch (Exception exc)
{
Assert.Equal("test", exc.Message);
}
}
Assert.Equal(1, metrics.Count);
Assert.Equal("Exceptions thrown", metrics[0].Key.Name);
Assert.Equal(1, metrics[0].Value, 15);
Assert.Equal(2, this.items.Count);
ITelemetry[] testItems = this.items.ToArray();
foreach (ITelemetry i in testItems)
{
if (i is MetricTelemetry)
{
Assert.Equal(1, ((MetricTelemetry)i).Count);
}
}
}
public void FirstChanceExceptionStatisticsTelemetryModuleWillDimCapAfterCacheTimeout()
{
var metrics = new List <KeyValuePair <Metric, double> >();
StubMetricProcessor stub = new StubMetricProcessor()
{
OnTrack = (m, v) =>
{
metrics.Add(new KeyValuePair <Metric, double>(m, v));
}
};
int operationId = 0;
this.configuration.TelemetryInitializers.Add(new StubTelemetryInitializer()
{
OnInitialize = (item) =>
{
item.Context.Operation.Name = "operationName " + (operationId++);
}
});
using (var module = new FirstChanceExceptionStatisticsTelemetryModule())
{
module.Initialize(this.configuration);
module.MetricManager.MetricProcessors.Add(stub);
module.DimCapTimeout = DateTime.UtcNow.Ticks - 1;
for (int i = 0; i < 200; i++)
{
if (i == 101)
{
module.DimCapTimeout = DateTime.UtcNow.Ticks - 1;
}
try
{
// FirstChanceExceptionStatisticsTelemetryModule will process this exception
throw new Exception("test");
}
catch (Exception exc)
{
// code to prevent profiler optimizations
Assert.Equal("test", exc.Message);
}
}
}
Assert.Equal(200, metrics.Count);
Assert.Equal(400, this.items.Count);
}
public void FirstChanceExceptionStatisticsTelemetryModuleDoNotIncrementOnRethrow()
{
var metrics = new List <KeyValuePair <Metric, double> >();
StubMetricProcessor stub = new StubMetricProcessor()
{
OnTrack = (m, v) =>
{
metrics.Add(new KeyValuePair <Metric, double>(m, v));
}
};
using (var module = new FirstChanceExceptionStatisticsTelemetryModule())
{
module.Initialize(this.configuration);
module.MetricManager.MetricProcessors.Add(stub);
try
{
try
{
// FirstChanceExceptionStatisticsTelemetryModule will process this exception
throw new Exception("test");
}
catch (Exception ex)
{
// this assert is neede to avoid code optimization
Assert.Equal("test", ex.Message);
throw;
}
}
catch (Exception exc)
{
Assert.Equal("test", exc.Message);
}
}
Assert.Equal(1, metrics.Count);
Assert.Equal("Exceptions thrown", metrics[0].Key.Name);
Assert.Equal(1, metrics[0].Value, 15);
Assert.Equal(2, this.items.Count);
Assert.Equal(1, ((MetricTelemetry)this.items[1]).Count);
// One of them should be 0 as re-thorwn, another - one
// Assert.Equal(0, Math.Min(((MetricTelemetry)this.items[0]).Sum, ((MetricTelemetry)this.items[1]).Sum), 15);
}
public void FirstChanceExceptionStatisticsTelemetryModuleMarksOperationAsInternal()
{
var metrics = new List <KeyValuePair <Metric, double> >();
StubMetricProcessor stub = new StubMetricProcessor()
{
OnTrack = (m, v) =>
{
metrics.Add(new KeyValuePair <Metric, double>(m, v));
}
};
using (var module = new FirstChanceExceptionStatisticsTelemetryModule())
{
module.Initialize(this.configuration);
module.MetricManager.MetricProcessors.Add(stub);
try
{
SdkInternalOperationsMonitor.Enter();
// FirstChanceExceptionStatisticsTelemetryModule will process this exception
throw new Exception("test");
}
catch (Exception exc)
{
// code to prevent profiler optimizations
Assert.Equal("test", exc.Message);
}
finally
{
SdkInternalOperationsMonitor.Exit();
}
}
Assert.Equal(1, metrics.Count);
Assert.Equal("Exceptions thrown", metrics[0].Key.Name);
var dims = metrics[0].Key.Dimensions;
Assert.Equal(2, dims.Count);
string operationName;
Assert.True(dims.TryGetValue(FirstChanceExceptionStatisticsTelemetryModule.OperationNameTag, out operationName));
Assert.Equal("AI (Internal)", operationName);
}
public void FirstChanceExceptionStatisticsTelemetryModuleWillNotDimCapTheSameOperationName()
{
var metrics = new List <KeyValuePair <Metric, double> >();
StubMetricProcessor stub = new StubMetricProcessor()
{
OnTrack = (m, v) =>
{
metrics.Add(new KeyValuePair <Metric, double>(m, v));
}
};
this.configuration.TelemetryInitializers.Add(new StubTelemetryInitializer()
{
OnInitialize = (item) =>
{
item.Context.Operation.Name = TestOperationName;
}
});
using (var module = new FirstChanceExceptionStatisticsTelemetryModule())
{
module.Initialize(this.configuration);
module.MetricManager.MetricProcessors.Add(stub);
for (int i = 0; i < 200; i++)
{
try
{
// FirstChanceExceptionStatisticsTelemetryModule will process this exception
throw new Exception("test");
}
catch (Exception exc)
{
// code to prevent profiler optimizations
Assert.Equal("test", exc.Message);
}
}
}
Assert.Equal(200, metrics.Count);
Assert.Equal(2, this.items.Count);
}
public void FirstChanceExceptionStatisticsTelemetryModuleTracksMetricWithTypeAndMethodOnException()
{
var metrics = new List <KeyValuePair <Metric, double> >();
StubMetricProcessor stub = new StubMetricProcessor()
{
OnTrack = (m, v) =>
{
metrics.Add(new KeyValuePair <Metric, double>(m, v));
}
};
using (var module = new FirstChanceExceptionStatisticsTelemetryModule())
{
module.Initialize(this.configuration);
module.MetricManager.MetricProcessors.Add(stub);
try
{
// FirstChanceExceptionStatisticsTelemetryModule will process this exception
throw new Exception("test");
}
catch (Exception exc)
{
// code to prevent compiler optimizations
Assert.Equal("test", exc.Message);
}
}
Assert.Equal(1, metrics.Count);
Assert.Equal("Exceptions thrown", metrics[0].Key.Name);
var dims = metrics[0].Key.Dimensions;
Assert.Equal(1, dims.Count);
Assert.True(dims["problemId"].StartsWith(typeof(Exception).FullName, StringComparison.Ordinal));
int nameStart = dims["problemId"].IndexOf(" at ", StringComparison.OrdinalIgnoreCase) + 4;
Assert.True(dims["problemId"].Substring(nameStart).StartsWith(typeof(FirstChanceExceptionStatisticsTelemetryModuleTest).FullName + "." + nameof(this.FirstChanceExceptionStatisticsTelemetryModuleTracksMetricWithTypeAndMethodOnException), StringComparison.Ordinal));
}
public void FirstChanceExceptionStatisticsTelemetryModuleThrowFromTaskAsync()
{
var metrics = new List <KeyValuePair <Metric, double> >();
StubMetricProcessor stub = new StubMetricProcessor()
{
OnTrack = (m, v) =>
{
metrics.Add(new KeyValuePair <Metric, double>(m, v));
}
};
using (var module = new FirstChanceExceptionStatisticsTelemetryModule())
{
module.Initialize(this.configuration);
module.MetricManager.MetricProcessors.Add(stub);
for (int i = 0; i < 10; i++)
{
try
{
Task <int> task1 = Task <int> .Factory.StartNew(() => this.Method5(0));
Task <int> task2 = Task <int> .Factory.StartNew(() => this.Method4(0));
try
{
task1.Wait();
}
catch (Exception)
{
throw;
}
try
{
task2.Wait();
}
catch (Exception)
{
throw;
}
}
catch (Exception)
{
}
}
}
Assert.Equal(30, metrics.Count);
Assert.Equal("Exceptions thrown", metrics[0].Key.Name);
Assert.Equal(1, metrics[0].Value, 15);
Assert.Equal("Exceptions thrown", metrics[1].Key.Name);
Assert.Equal(1, metrics[1].Value, 15);
Assert.Equal("Exceptions thrown", metrics[2].Key.Name);
Assert.Equal(1, metrics[2].Value, 15);
// There should be 3 telemetry items and 3 metric items
Assert.Equal(6, this.items.Count);
}
public void FirstChanceExceptionStatisticsTelemetryExceptionsAreThrottled()
{
var metrics = new List <KeyValuePair <Metric, double> >();
StubMetricProcessor stub = new StubMetricProcessor()
{
OnTrack = (m, v) =>
{
metrics.Add(new KeyValuePair <Metric, double>(m, v));
}
};
this.configuration.TelemetryInitializers.Add(new StubTelemetryInitializer()
{
OnInitialize = (item) =>
{
item.Context.Operation.Name = TestOperationName;
}
});
using (var module = new FirstChanceExceptionStatisticsTelemetryModule())
{
module.Initialize(this.configuration);
module.MetricManager.MetricProcessors.Add(stub);
module.TargetMovingAverage = 50;
for (int i = 0; i < 200; i++)
{
try
{
// FirstChanceExceptionStatisticsTelemetryModule will process this exception
throw new Exception("test");
}
catch (Exception exc)
{
// code to prevent profiler optimizations
Assert.Equal("test", exc.Message);
}
}
}
int countProcessed = 0;
int countThrottled = 0;
foreach (KeyValuePair <Metric, double> items in metrics)
{
if (items.Key.Dimensions.Count == 1)
{
countThrottled++;
}
else
{
countProcessed++;
}
}
// The test starts with the current moving average being 0. With the setting of the
// weight for the new sample being .3 and the target moving average being 50 (as
// set in the test), this means 50 / .3 = 166 becomes the throttle limit for this window.
Assert.Equal(166, countProcessed);
Assert.Equal(34, countThrottled);
}
