public VocabTermTests(ITestOutputHelper output) { this.output = output; _listener = new DiagnosticListener("Testing"); _listener.Subscribe(new ConsoleLogger(this.output)); JsonStreamingParser.DiagSource = _listener; }
public async Task Should_start_activity_and_set_appropriate_headers() { // Generate an id we can use for the request id header (in the correct format) var diagnosticListener = new DiagnosticListener("DummySource"); Activity started = null; diagnosticListener.Subscribe(new CallbackDiagnosticListener(pair => { if (pair.Key == $"{ActivityNames.OutgoingPhysicalMessage}.Start") { started = Activity.Current; } })); var context = new TestableOutgoingPhysicalMessageContext(); var behavior = new OutgoingPhysicalMessageDiagnostics(diagnosticListener); var activity = new Activity("Outer") { TraceStateString = "TraceStateValue", }; activity.AddBaggage("Key1", "Value1"); activity.AddBaggage("Key2", "Value2"); activity.Start(); await behavior.Invoke(context, () => Task.CompletedTask); activity.Stop(); started.ShouldNotBeNull(); started.ParentId.ShouldBe(activity.Id); context.Headers.ShouldContain(kvp => kvp.Key == "traceparent" && kvp.Value == started.Id); context.Headers.ShouldContain(kvp => kvp.Key == "tracestate" && kvp.Value == activity.TraceStateString); context.Headers.ShouldContain(kvp => kvp.Key == "Correlation-Context" && kvp.Value == "Key2=Value2,Key1=Value1"); }
public void ActivityStopDoesNotFireIfNoListenerAttachedForStart() { // Arrange var diagnosticListener = new DiagnosticListener("DummySource"); var logger = new LoggerWithScopes(isEnabled: true); var hostingApplication = CreateApplication(out var features, diagnosticListener: diagnosticListener, logger: logger); var startFired = false; var stopFired = false; diagnosticListener.Subscribe(new CallbackDiagnosticListener(pair => { // This should not fire if (pair.Key == "Microsoft.AspNetCore.Hosting.HttpRequestIn.Start") { startFired = true; } // This should not fire if (pair.Key == "Microsoft.AspNetCore.Hosting.HttpRequestIn.Stop") { stopFired = true; } }), (s, o, arg3) => { // The events are off return(false); }); // Act var context = hostingApplication.CreateContext(features); hostingApplication.DisposeContext(context, exception: null); Assert.False(startFired); Assert.False(stopFired); Assert.Null(Activity.Current); }
public void InitializeSetsTelemetryOperationNameToControllerAndActionAndParameterFromActionContext() { var actionContext = new ActionContext(); actionContext.RouteData = new RouteData(); actionContext.RouteData.Values.Add("controller", "account"); actionContext.RouteData.Values.Add("action", "login"); actionContext.RouteData.Values.Add("parameter", "myName"); var contextAccessor = HttpContextAccessorHelper.CreateHttpContextAccessor(new RequestTelemetry(), actionContext); var telemetryListener = new DiagnosticListener(TestListenerName); var initializer = new MvcDiagnosticsListener(); telemetryListener.Subscribe(initializer); telemetryListener.Write("Microsoft.AspNetCore.Mvc.BeforeAction", new { httpContext = contextAccessor.HttpContext, routeData = actionContext.RouteData }); var telemetry = contextAccessor.HttpContext.Features.Get <RequestTelemetry>(); Assert.Equal("GET account/login [parameter]", telemetry.Name); }
public async Task Should_not_fire_activity_start_stop_when_no_listener_attached() { var diagnosticListener = new DiagnosticListener("DummySource"); var context = new TestableIncomingLogicalMessageContext(); var processedFired = false; diagnosticListener.Subscribe(new CallbackDiagnosticListener(pair => { // This should not fire if (pair.Key == $"{ActivityNames.IncomingLogicalMessage}.Processed") { processedFired = true; } }), (s, o, arg3) => false); var behavior = new IncomingLogicalMessageDiagnostics(diagnosticListener); await behavior.Invoke(context, () => Task.CompletedTask); processedFired.ShouldBeFalse(); }
public void InitializeDoesNotIncludeRouteGroupKeyInParametersList() { var actionContext = new ActionContext(); actionContext.RouteData = new RouteData(); actionContext.RouteData.Values.Add("controller", "account"); actionContext.RouteData.Values.Add("action", "login"); actionContext.RouteData.Values.Add(TreeRouter.RouteGroupKey, "RouteGroupKey"); var contextAccessor = HttpContextAccessorHelper.CreateHttpContextAccessor(new RequestTelemetry(), actionContext); var telemetryListener = new DiagnosticListener(TestListenerName); using (var listener = CreateHostingListener(false)) { telemetryListener.Subscribe(listener); telemetryListener.Write("Microsoft.AspNetCore.Mvc.BeforeAction", new { httpContext = contextAccessor.HttpContext, routeData = actionContext.RouteData }); } var telemetry = contextAccessor.HttpContext.Features.Get <RequestTelemetry>(); Assert.Equal("GET account/login", telemetry.Name); }
public void ActivityIsAvailableDuringUnhandledExceptionCall() { var diagnosticListener = new DiagnosticListener("DummySource"); var hostingApplication = CreateApplication(out var features, diagnosticListener: diagnosticListener); bool endCalled = false; diagnosticListener.Subscribe(new CallbackDiagnosticListener(pair => { if (pair.Key == "Microsoft.AspNetCore.Hosting.UnhandledException") { endCalled = true; Assert.NotNull(Activity.Current); Assert.Equal("Microsoft.AspNetCore.Hosting.HttpRequestIn", Activity.Current.OperationName); } })); var context = hostingApplication.CreateContext(features); hostingApplication.DisposeContext(context, new Exception()); Assert.True(endCalled); }
public void ActivityIsCreatedAndLogged() { var diagnosticListener = new DiagnosticListener("DummySource"); var hostingApplication = CreateApplication(out var features, diagnosticListener: diagnosticListener); bool startCalled = false; diagnosticListener.Subscribe(new CallbackDiagnosticListener(pair => { if (pair.Key == "Microsoft.AspNetCore.Hosting.HttpRequestIn.Start") { startCalled = true; Assert.NotNull(pair.Value); Assert.NotNull(Activity.Current); Assert.Equal("Microsoft.AspNetCore.Hosting.HttpRequestIn", Activity.Current.OperationName); AssertProperty <HttpContext>(pair.Value, "HttpContext"); } })); hostingApplication.CreateContext(features); Assert.NotNull(Activity.Current); Assert.True(startCalled); }
public void DiagnosticSourceStartStop() { using (DiagnosticListener listener = new DiagnosticListener("Testing")) { DiagnosticSource source = listener; var observer = new TestObserver(); using (listener.Subscribe(observer)) { var arguments = new { args = "arguments" }; var activity = new Activity("activity"); // Test Activity.Stop source.StartActivity(activity, arguments); Assert.Equal(activity.OperationName + ".Start", observer.EventName); Assert.Equal(arguments, observer.EventObject); Assert.NotNull(observer.Activity); Assert.True(DateTime.UtcNow - new TimeSpan(0, 1, 0) <= observer.Activity.StartTimeUtc); Assert.True(observer.Activity.StartTimeUtc <= DateTime.UtcNow); Assert.True(observer.Activity.Duration == TimeSpan.Zero); observer.Reset(); // Test Activity.Stop source.StopActivity(activity, arguments); Assert.Equal(activity.OperationName + ".Stop", observer.EventName); Assert.Equal(arguments, observer.EventObject); // Confirm that duration is set. Assert.NotNull(observer.Activity); Assert.True(TimeSpan.Zero < observer.Activity.Duration); Assert.True(observer.Activity.StartTimeUtc + observer.Activity.Duration < DateTime.UtcNow); } } }
public void BasicIsEnabled() { using (DiagnosticListener listener = new DiagnosticListener("TestingBasicIsEnabled")) { DiagnosticSource source = listener; var result = new List <KeyValuePair <string, object> >(); bool seenUninteresting = false; bool seenStructPayload = false; Predicate <string> predicate = delegate(string name) { if (name == "Uninteresting") { seenUninteresting = true; } if (name == "StructPayload") { seenStructPayload = true; } return(name == "StructPayload"); }; // Assert.False(listener.IsEnabled()); Since other things might turn on all DiagnosticSources, we can't ever test that it is not enabled. using (listener.Subscribe(new ObserverToList <TelemData>(result), predicate)) { Assert.False(source.IsEnabled("Uninteresting")); Assert.False(source.IsEnabled("Uninteresting", "arg1", "arg2")); Assert.True(source.IsEnabled("StructPayload")); Assert.True(source.IsEnabled("StructPayload", "arg1", "arg2")); Assert.True(seenUninteresting); Assert.True(seenStructPayload); Assert.True(listener.IsEnabled()); } } }
public void ParseCompleteSwagger() { DiagnosticListener listener = new DiagnosticListener("Testing"); JsonStreamingParser.DiagSource = listener; listener.Subscribe(new ConsoleLogger(this.output)); Vocabulary vocab = OpenApiVocab.Create(); var stream = typeof(ParsingTests).Assembly .GetManifestResourceStream(typeof(ParsingTests), "forecast.io.swagger.json"); var swaggerDoc = new OpenApiDocument(); JsonStreamingParser.ParseStream(stream, swaggerDoc, vocab); Assert.Equal("2.0", swaggerDoc.Version); Assert.Equal(1, swaggerDoc.Schemes.Count); Assert.Equal("https", swaggerDoc.Schemes.First()); Assert.True(swaggerDoc.Paths.Count > 0); Assert.False(String.IsNullOrEmpty(swaggerDoc.Info.Description)); Assert.False(String.IsNullOrEmpty(swaggerDoc.Info.Title)); Assert.True(String.IsNullOrEmpty(swaggerDoc.Info.Version)); }
public void ActivityIsStoppedDuringUnhandledExceptionCall() { var diagnosticSource = new DiagnosticListener("DummySource"); var hostingApplication = CreateApplication(out var features, diagnosticSource: diagnosticSource); bool endCalled = false; diagnosticSource.Subscribe(new CallbackDiagnosticListener(pair => { if (pair.Key == "Microsoft.AspNetCore.Hosting.HttpRequestIn.Stop") { endCalled = true; Assert.NotNull(Activity.Current); Assert.True(Activity.Current.Duration > TimeSpan.Zero); Assert.Equal("Microsoft.AspNetCore.Hosting.HttpRequestIn", Activity.Current.OperationName); AssertProperty <HttpContext>(pair.Value, "HttpContext"); } })); var context = hostingApplication.CreateContext(features); hostingApplication.DisposeContext(context, new Exception()); Assert.True(endCalled); }
protected override IDisposable Subscribe(DiagnosticListener listener, IDiagnosticProcessor target) { var adapter = new DiagnosticSourceAdapter(target, _loggerFactory); return(listener.Subscribe(adapter, adapter.IsEnabled)); }
public void MultiSubscriber() { using (DiagnosticListener listener = new DiagnosticListener("TestingMultiSubscriber")) { DiagnosticSource source = listener; var subscriber1Result = new List <KeyValuePair <string, object> >(); Predicate <string> subscriber1Predicate = name => (name == "DataForSubscriber1"); var subscriber1Observer = new ObserverToList <TelemData>(subscriber1Result); var subscriber2Result = new List <KeyValuePair <string, object> >(); Predicate <string> subscriber2Predicate = name => (name == "DataForSubscriber2"); var subscriber2Observer = new ObserverToList <TelemData>(subscriber2Result); // Get two subscribers going. using (var subscription1 = listener.Subscribe(subscriber1Observer, subscriber1Predicate)) { using (var subscription2 = listener.Subscribe(subscriber2Observer, subscriber2Predicate)) { // Things that neither subscribe to get filtered out. if (listener.IsEnabled("DataToFilterOut")) { listener.Write("DataToFilterOut", -1); } Assert.Equal(0, subscriber1Result.Count); Assert.Equal(0, subscriber2Result.Count); /****************************************************/ // If a Source does not use the IsEnabled, then every subscriber gets it. subscriber1Result.Clear(); subscriber2Result.Clear(); listener.Write("UnfilteredData", 3); Assert.Equal(1, subscriber1Result.Count); Assert.Equal("UnfilteredData", subscriber1Result[0].Key); Assert.Equal(3, (int)subscriber1Result[0].Value); Assert.Equal(1, subscriber2Result.Count); Assert.Equal("UnfilteredData", subscriber2Result[0].Key); Assert.Equal(3, (int)subscriber2Result[0].Value); /****************************************************/ // Filters not filter out everything, they are just a performance optimization. // Here you actually get more than you want even though you use a filter subscriber1Result.Clear(); subscriber2Result.Clear(); if (listener.IsEnabled("DataForSubscriber1")) { listener.Write("DataForSubscriber1", 1); } Assert.Equal(1, subscriber1Result.Count); Assert.Equal("DataForSubscriber1", subscriber1Result[0].Key); Assert.Equal(1, (int)subscriber1Result[0].Value); // Subscriber 2 happens to get it Assert.Equal(1, subscriber2Result.Count); Assert.Equal("DataForSubscriber1", subscriber2Result[0].Key); Assert.Equal(1, (int)subscriber2Result[0].Value); /****************************************************/ subscriber1Result.Clear(); subscriber2Result.Clear(); if (listener.IsEnabled("DataForSubscriber2")) { listener.Write("DataForSubscriber2", 2); } // Subscriber 1 happens to get it Assert.Equal(1, subscriber1Result.Count); Assert.Equal("DataForSubscriber2", subscriber1Result[0].Key); Assert.Equal(2, (int)subscriber1Result[0].Value); Assert.Equal(1, subscriber2Result.Count); Assert.Equal("DataForSubscriber2", subscriber2Result[0].Key); Assert.Equal(2, (int)subscriber2Result[0].Value); } // subscriber2 drops out /*********************************************************************/ /* Only Subscriber 1 is left */ /*********************************************************************/ // Things that neither subscribe to get filtered out. subscriber1Result.Clear(); subscriber2Result.Clear(); if (listener.IsEnabled("DataToFilterOut")) { listener.Write("DataToFilterOut", -1); } Assert.Equal(0, subscriber1Result.Count); Assert.Equal(0, subscriber2Result.Count); /****************************************************/ // If a Source does not use the IsEnabled, then every subscriber gets it. subscriber1Result.Clear(); listener.Write("UnfilteredData", 3); Assert.Equal(1, subscriber1Result.Count); Assert.Equal("UnfilteredData", subscriber1Result[0].Key); Assert.Equal(3, (int)subscriber1Result[0].Value); // Subscriber 2 has dropped out. Assert.Equal(0, subscriber2Result.Count); /****************************************************/ // Filters not filter out everything, they are just a performance optimization. // Here you actually get more than you want even though you use a filter subscriber1Result.Clear(); if (listener.IsEnabled("DataForSubscriber1")) { listener.Write("DataForSubscriber1", 1); } Assert.Equal(1, subscriber1Result.Count); Assert.Equal("DataForSubscriber1", subscriber1Result[0].Key); Assert.Equal(1, (int)subscriber1Result[0].Value); // Subscriber 2 has dropped out. Assert.Equal(0, subscriber2Result.Count); /****************************************************/ subscriber1Result.Clear(); if (listener.IsEnabled("DataForSubscriber2")) { listener.Write("DataForSubscriber2", 2); } // Subscriber 1 filters Assert.Equal(0, subscriber1Result.Count); // Subscriber 2 has dropped out Assert.Equal(0, subscriber2Result.Count); } // subscriber1 drops out /*********************************************************************/ /* No Subscribers are left */ /*********************************************************************/ // Things that neither subscribe to get filtered out. subscriber1Result.Clear(); subscriber2Result.Clear(); if (listener.IsEnabled("DataToFilterOut")) { listener.Write("DataToFilterOut", -1); } Assert.Equal(0, subscriber1Result.Count); Assert.Equal(0, subscriber2Result.Count); /****************************************************/ // If a Source does not use the IsEnabled, then every subscriber gets it. listener.Write("UnfilteredData", 3); // No one subscribing Assert.Equal(0, subscriber1Result.Count); Assert.Equal(0, subscriber2Result.Count); /****************************************************/ // Filters not filter out everything, they are just a performance optimization. // Here you actually get more than you want even though you use a filter if (listener.IsEnabled("DataForSubscriber1")) { listener.Write("DataForSubscriber1", 1); } // No one subscribing Assert.Equal(0, subscriber1Result.Count); Assert.Equal(0, subscriber2Result.Count); /****************************************************/ if (listener.IsEnabled("DataForSubscriber2")) { listener.Write("DataForSubscriber2", 2); } // No one subscribing Assert.Equal(0, subscriber1Result.Count); Assert.Equal(0, subscriber2Result.Count); } }
public Task StartAsync(CancellationToken cancellationToken) { _diagnosticubscription = _diagnosticListener.Subscribe(this); return(Task.CompletedTask); }
public void OnNext(DiagnosticListener value) { _listenersSubscriptions.Add(value.Subscribe(this)); }
public ActivityRequestTracer(ILoggerFactory loggerFactory, ClusterOptions options) { _loggerFactory = loggerFactory; _diagnosticListener = new DiagnosticListener(RequestTracing.SourceName); _diagnosticListener.Subscribe(new ThresholdActivityObserver(loggerFactory, options.ThresholdOptions ?? new ThresholdOptions())); }
public DiagnosticsActivity_Specs() { _store = new List <KeyValuePair <string, object> >(); _listener = new DiagnosticListener(GetType().FullName); _listener.Subscribe(new TestListener(_store)); }
public BadRequestEventListener(DiagnosticListener diagnosticListener, Action <KeyValuePair <string, object> > callback) { _subscription = diagnosticListener.Subscribe(this, IsEnabled); _callback = callback; }
public static IDisposable SubscribeWithAdapter(this DiagnosticListener diagnostic, object target, Predicate <string> isEnabled) { var adapter = new DiagnosticSourceAdapter(target); return(diagnostic.Subscribe(adapter, isEnabled)); }