public void FirstChanceExceptionStatisticsTelemetryCallMultipleMethods() { using (var module = new FirstChanceExceptionStatisticsTelemetryModule()) { module.Initialize(this.configuration); for (int i = 0; i < 200; i++) { try { this.Method1(); } catch { } try { throw new Exception("New exception from Method1"); } catch { } } } // There should be three unique TrackExceptions and three Metrics Assert.Equal(6, this.items.Count); }
public void FirstChanceExceptionStatisticsTelemetryModuleDoNotCauseStackOverflow() { this.configuration.TelemetryInitializers.Add(new StubTelemetryInitializer() { OnInitialize = (item) => { throw new Exception("this exception may cause stack overflow as will be thrown during the processing of another exception"); } }); using (var module = new FirstChanceExceptionStatisticsTelemetryModule()) { module.Initialize(this.configuration); try { // FirstChanceExceptionStatisticsTelemetryModule will process this exception throw new Exception("test"); } catch (Exception exc) { // make sure it is the same exception as was initially thrown Assert.Equal("test", exc.Message); } } }
public void FirstChanceExceptionStatisticsTelemetryModuleDoNotThrowOnNullException() { EventHandler<FirstChanceExceptionEventArgs> handler = null; using (var module = new FirstChanceExceptionStatisticsTelemetryModule( h => handler = h, _ => { })) { module.Initialize(this.configuration); handler.Invoke(null, new FirstChanceExceptionEventArgs(null)); } }
public void FirstChanceExceptionStatisticsTelemetryModuleDoNotThrowOnNullException() { EventHandler <FirstChanceExceptionEventArgs> handler = null; using (var module = new FirstChanceExceptionStatisticsTelemetryModule( h => handler = h, _ => { })) { module.Initialize(this.configuration); handler.Invoke(null, new FirstChanceExceptionEventArgs(null)); } }
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 FirstChanceExceptionStatisticsTelemetryModuleWasTrackedReturnsFalseForAggExcWithNotTrackedInnerExceptions() { using (var module = new FirstChanceExceptionStatisticsTelemetryModule()) { module.Initialize(this.configuration); var exception = new Exception(); var aggExc = new AggregateException(exception); Assert.False(module.WasExceptionTracked(aggExc)); } }
public void DisposeCallsUnregister() { EventHandler<FirstChanceExceptionEventArgs> handler = null; using (var module = new FirstChanceExceptionStatisticsTelemetryModule( _ => { }, h => handler = h)) { module.Initialize(this.configuration); } Assert.NotNull(handler); }
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 ModuleConstructorCallsRegister() { EventHandler <FirstChanceExceptionEventArgs> handler = null; using (var module = new FirstChanceExceptionStatisticsTelemetryModule( h => handler = h, _ => { })) { module.Initialize(this.configuration); } Assert.NotNull(handler); }
public void DisposeCallsUnregister() { EventHandler <FirstChanceExceptionEventArgs> handler = null; using (var module = new FirstChanceExceptionStatisticsTelemetryModule( _ => { }, h => handler = h)) { module.Initialize(this.configuration); } Assert.NotNull(handler); }
public void FirstChanceExceptionStatisticsTelemetryModuleDoNotIncrementOnRethrow() { var metrics = new List <KeyValuePair <Metric, double> >(); this.configuration.MetricProcessors.Add(new StubMetricProcessor() { OnTrack = (m, v) => { metrics.Add(new KeyValuePair <Metric, double>(m, v)); } }); using (var module = new FirstChanceExceptionStatisticsTelemetryModule()) { module.Initialize(this.configuration); 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(2, metrics.Count); Assert.Equal("Exceptions Thrown", metrics[0].Key.Name); Assert.Equal(1, metrics[0].Value, 15); Assert.Equal(0, metrics[1].Value, 15); Assert.Equal(2, this.items.Count); Assert.Equal(1, ((MetricTelemetry)this.items[0]).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); Assert.Equal(1, Math.Max(((MetricTelemetry)this.items[0]).Sum, ((MetricTelemetry)this.items[1]).Sum), 15); }
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 FirstChanceExceptionStatisticsTelemetryModuleWasTrackedReturnsTrueForTheSameException() { using (var module = new FirstChanceExceptionStatisticsTelemetryModule()) { module.Initialize(this.configuration); var exception = new Exception(); Assert.False(module.WasExceptionTracked(exception)); Assert.True(module.WasExceptionTracked(exception)); Assert.True(module.WasExceptionTracked(exception)); Assert.True(module.WasExceptionTracked(exception)); } }
public void FirstChanceExceptionStatisticsTelemetryModuleWasTrackedReturnsFalseForInnerExceptionTwoLevelsUp() { using (var module = new FirstChanceExceptionStatisticsTelemetryModule()) { module.Initialize(this.configuration); var exception = new Exception(); Assert.False(module.WasExceptionTracked(exception)); var wrapper1 = new Exception("wrapper 1", exception); var wrapper2 = new Exception("wrapper 2", wrapper1); Assert.False(module.WasExceptionTracked(wrapper2)); } }
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 FirstChanceExceptionStatisticsTelemetryModuleUsesOperationNameAsDimension() { var metrics = new List <KeyValuePair <Metric, double> >(); this.configuration.MetricProcessors.Add(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 = "operationName"; } }); using (var module = new FirstChanceExceptionStatisticsTelemetryModule()) { module.Initialize(this.configuration); 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(1, metrics.Count); Assert.Equal("Exceptions Thrown", metrics[0].Key.Name); var dims = metrics[0].Key.Dimensions; Assert.Equal(3, dims.Count); Assert.True(dims.Contains(new KeyValuePair <string, string>("operation", "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 FirstChanceExceptionStatisticsTelemetryModuleTracksMetricWithTypeAndMethodOnException() { var metrics = new List <KeyValuePair <Metric, double> >(); this.configuration.MetricProcessors.Add(new StubMetricProcessor() { OnTrack = (m, v) => { metrics.Add(new KeyValuePair <Metric, double>(m, v)); } }); using (var module = new FirstChanceExceptionStatisticsTelemetryModule()) { module.Initialize(this.configuration); 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(2, dims.Count); Assert.True(dims.Contains(new KeyValuePair <string, string>("type", typeof(Exception).FullName))); string value; Assert.True(dims.TryGetValue("method", out value)); Assert.True(value.StartsWith(typeof(FirstChanceExceptionStatisticsTelemetryModuleTest).FullName + "." + nameof(this.FirstChanceExceptionStatisticsTelemetryModuleTracksMetricWithTypeAndMethodOnException), StringComparison.Ordinal)); }
public void FirstChanceExceptionStatisticsTelemetryModuleDoNotCauseStackOverflow() { this.configuration.TelemetryInitializers.Add(new StubTelemetryInitializer() { OnInitialize = (item) => { throw new Exception("this exception may cause stack overflow"); } }); using (var module = new FirstChanceExceptionStatisticsTelemetryModule()) { module.Initialize(this.configuration); try { throw new Exception("test"); } catch (Exception exc) { Assert.Equal("test", exc.Message); } } }
public void FirstChanceExceptionStatisticsTelemetryModuleDoNotCauseStackOverflow() { this.configuration.TelemetryInitializers.Add(new StubTelemetryInitializer() { OnInitialize = (item) => { throw new Exception("this exception may cause stack overflow"); } }); using (var module = new FirstChanceExceptionStatisticsTelemetryModule()) { module.Initialize(this.configuration); try { throw new Exception("test"); } catch (Exception exc) { Assert.Equal("test", exc.Message); } } }
public void FirstChanceExceptionStatisticsTelemetryModuleTracksMetricWithTypeAndMethodOnException() { var metrics = new List <KeyValuePair <Metric, double> >(); this.configuration.MetricProcessors.Add(new StubMetricProcessor() { OnTrack = (m, v) => { metrics.Add(new KeyValuePair <Metric, double>(m, v)); } }); using (var module = new FirstChanceExceptionStatisticsTelemetryModule()) { module.Initialize(this.configuration); try { throw new Exception("test"); } catch (Exception exc) { 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(2, dims.Count); Assert.True(dims.Contains(new KeyValuePair <string, string>("type", typeof(Exception).FullName))); Assert.True(dims.Contains(new KeyValuePair <string, string>("method", typeof(FirstChanceExceptionStatisticsTelemetryModuleTest).FullName + ".FirstChanceExceptionStatisticsTelemetryModuleTracksMetricWithTypeAndMethodOnException"))); }
public void FirstChanceExceptionStatisticsTelemetryModuleUsesOperationNameAsDimension() { var metrics = new List<KeyValuePair<Metric, double>>(); this.configuration.MetricProcessors.Add(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 = "operationName"; } }); using (var module = new FirstChanceExceptionStatisticsTelemetryModule()) { module.Initialize(this.configuration); try { throw new Exception("test"); } catch (Exception exc) { 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(3, dims.Count); Assert.True(dims.Contains(new KeyValuePair<string, string>("operation", "operationName"))); }
public void ModuleConstructorCallsRegister() { EventHandler<FirstChanceExceptionEventArgs> handler = null; using (var module = new FirstChanceExceptionStatisticsTelemetryModule( h => handler = h, _ => { })) { module.Initialize(this.configuration); } Assert.NotNull(handler); }
public void FirstChanceExceptionStatisticsTelemetryModuleTracksMetricWithTypeAndMethodOnException() { var metrics = new List<KeyValuePair<Metric, double>>(); this.configuration.MetricProcessors.Add(new StubMetricProcessor() { OnTrack = (m, v) => { metrics.Add(new KeyValuePair<Metric, double>(m, v)); } }); using (var module = new FirstChanceExceptionStatisticsTelemetryModule()) { module.Initialize(this.configuration); try { throw new Exception("test"); } catch (Exception exc) { 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(2, dims.Count); Assert.True(dims.Contains(new KeyValuePair<string, string>("type", typeof(Exception).FullName))); Assert.True(dims.Contains(new KeyValuePair<string, string>("method", typeof(FirstChanceExceptionStatisticsTelemetryModuleTest).FullName + ".FirstChanceExceptionStatisticsTelemetryModuleTracksMetricWithTypeAndMethodOnException"))); }
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); }