public void DoubleDisposeOfListener()
        {
            var listener        = new DiagnosticListener("TestingDoubleDisposeOfListener");
            int completionCount = 0;

            IDisposable subscription = listener.Subscribe(MakeObserver <KeyValuePair <string, object> >(_ => { }, () => completionCount++));

            listener.Dispose();
            listener.Dispose();

            subscription.Dispose();
            subscription.Dispose();

            Assert.Equal(1, completionCount);
        }
        public void GetHeaders_ReturnsExpected()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs     = new TraceObserver(listener, option);
            HttpContext   context = CreateRequest();

            var result = obs.GetHeaders(100, context.Request.Headers);

            Assert.NotNull(result);
            Assert.True(result.ContainsKey("header1"));
            Assert.True(result.ContainsKey("header2"));
            Assert.True(result.ContainsKey("status"));
            var header1Val = result["header1"] as string;

            Assert.Equal("header1Value", header1Val);
            var header2Val = result["header2"] as string;

            Assert.Equal("header2Value", header2Val);
            var statusVal = result["status"] as string;

            Assert.Equal("100", statusVal);
            listener.Dispose();
        }
        public void GetTraces_ReturnsTraces()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs = new TraceObserver(listener, option);

            for (int i = 0; i < 200; i++)
            {
                long start   = Stopwatch.GetTimestamp();
                var  context = CreateRequest();

                KeyValuePair <string, object> begin = new KeyValuePair <string, object>(TraceObserver.BEGIN_REQUEST,
                                                                                        new { httpContext = context, timestamp = start });
                obs.OnNext(begin);

                KeyValuePair <string, object> end = new KeyValuePair <string, object>(TraceObserver.END_REQUEST,
                                                                                      new { httpContext = context, timestamp = start + 100000 });
                obs.OnNext(end);
            }
            Assert.Equal(0, obs._pending.Count);
            Assert.Equal(option.Capacity, obs._queue.Count);
            List <Trace> traces = obs.GetTraces();

            Assert.Equal(option.Capacity, traces.Count);
            Assert.Equal(option.Capacity, obs._queue.Count);

            listener.Dispose();
        }
        public void AddTraceActuator_AddsCorrectServices()
        {
            ServiceCollection services = new ServiceCollection();
            var appSettings            = new Dictionary <string, string>()
            {
                ["management:endpoints:enabled"]       = "false",
                ["management:endpoints:path"]          = "/cloudfoundryapplication",
                ["management:endpoints:trace:enabled"] = "false",
            };
            ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();

            configurationBuilder.AddInMemoryCollection(appSettings);
            var config   = configurationBuilder.Build();
            var listener = new DiagnosticListener("Test");

            services.AddSingleton(listener);

            services.AddTraceActuator(config);

            var serviceProvider = services.BuildServiceProvider();
            var options         = serviceProvider.GetService <ITraceOptions>();

            Assert.NotNull(options);
            var repo = serviceProvider.GetService <ITraceRepository>();

            Assert.NotNull(repo);
            var ep = serviceProvider.GetService <TraceEndpoint>();

            Assert.NotNull(ep);
            listener.Dispose();
        }
        public void Completed()
        {
            var result       = new List <KeyValuePair <string, object> >();
            var observer     = new ObserverToList <TelemData>(result);
            var listener     = new DiagnosticListener("TestingCompleted");
            var subscription = listener.Subscribe(observer);

            listener.Write("IntPayload", 5);
            Assert.Equal(1, result.Count);
            Assert.Equal("IntPayload", result[0].Key);
            Assert.Equal(5, result[0].Value);
            Assert.False(observer.Completed);

            // The listener dies
            listener.Dispose();
            Assert.True(observer.Completed);

            // confirm that we can unsubscribe without crashing
            subscription.Dispose();

            // If we resubscribe after dispose, but it does not do anything.
            subscription = listener.Subscribe(observer);

            listener.Write("IntPayload", 5);
            Assert.Equal(1, result.Count);
        }
        public void MakeTrace_ReturnsExpected()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs     = new TraceObserver(listener, option);
            HttpContext   context = CreateRequest();
            Trace         result  = obs.MakeTrace(context, 10000000, 20000000);

            Assert.NotNull(result);
            Assert.NotNull(result.Info);
            Assert.NotEqual(0, result.TimeStamp);
            Assert.True(result.Info.ContainsKey("method"));
            Assert.True(result.Info.ContainsKey("path"));
            Assert.True(result.Info.ContainsKey("headers"));
            Assert.True(result.Info.ContainsKey("timeTaken"));
            Assert.Equal("GET", result.Info["method"]);
            Assert.Equal("/myPath", result.Info["path"]);
            var headers = result.Info["headers"] as Dictionary <string, object>;

            Assert.NotNull(headers);
            Assert.True(headers.ContainsKey("request"));
            Assert.True(headers.ContainsKey("response"));
            var timeTaken = result.Info["timeTaken"] as string;

            Assert.NotNull(timeTaken);
            var expected = ((20000000 - 10000000) / obs.ticksPerMilli).ToString();

            Assert.Equal(expected, timeTaken);
            listener.Dispose();
        }
        public void GetRequestUri_ReturnsExpected()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs     = new TraceObserver(listener, option);
            HttpContext   context = CreateRequest();
            var           result  = obs.GetRequestUri(context.Request);

            Assert.Equal("http://localhost:1111/myPath", result);
            listener.Dispose();
        }
        public void GetRemoteAddress_NoConnection_ReturnsExpected()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs     = new TraceObserver(listener, option);
            HttpContext   context = CreateRequest();
            var           result  = obs.GetRemoteAddress(context);

            Assert.Null(result);
            listener.Dispose();
        }
        public void GetUserPrincipal_NotAuthenticated_ReturnsExpected()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs     = new TraceObserver(listener, option);
            HttpContext   context = CreateRequest();
            var           result  = obs.GetUserPrincipal(context);

            Assert.Null(result);
            listener.Dispose();
        }
示例#10
0
        public void GetProperties_NoProperties_ReturnsExpected()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs       = new TraceObserver(listener, option);
            long          timeStamp = -1;

            obs.GetProperties(new { foo = "bar" }, out HttpContext context, out timeStamp);
            Assert.Equal(0, timeStamp);
            Assert.Null(context);
            listener.Dispose();
        }
示例#11
0
        public void GetTimeTaken_ReturnsExpected()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs      = new TraceObserver(listener, option);
            HttpContext   context  = CreateRequest();
            var           result   = obs.GetTimeTaken(10000000);
            var           expected = (10000000 / obs.ticksPerMilli).ToString();

            Assert.Equal(expected, result);

            listener.Dispose();
        }
示例#12
0
        public void OnNext_IgnoresUnRecognizedEvents()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs = new TraceObserver(listener, option);

            KeyValuePair <string, object> ignore = new KeyValuePair <string, object>("foobar", null);

            obs.OnNext(ignore);
            Assert.Equal(0, obs._pending.Count);
            Assert.Equal(0, obs._queue.Count);
            listener.Dispose();
        }
示例#13
0
        public void GetUserPrincipal_Authenticated_ReturnsExpected()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs     = new TraceObserver(listener, option);
            HttpContext   context = CreateRequest();

            context.User = new ClaimsPrincipal(new MyIdentity());
            var result = obs.GetUserPrincipal(context);

            Assert.Equal("MyTestName", result);
            listener.Dispose();
        }
        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    _cancellationTokenSource.Dispose();
                    _pollingTask.Dispose();
                    _diagnostics.Dispose();
                }

                _disposed = true;
            }
        }
示例#15
0
        public void GetProperties_WithProperties_ReturnsExpected()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs             = new TraceObserver(listener, option);
            long          timeStamp       = -1;
            long          expectedTime    = Stopwatch.GetTimestamp();
            var           expectedContext = CreateRequest();

            obs.GetProperties(new { httpContext = expectedContext, timestamp = expectedTime }, out HttpContext context, out timeStamp);
            Assert.Equal(expectedTime, timeStamp);
            Assert.True(object.ReferenceEquals(expectedContext, context));

            listener.Dispose();
        }
示例#16
0
        public void OnNext_RemovesPending_AddsToQueue()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs     = new TraceObserver(listener, option);
            long          start   = Stopwatch.GetTimestamp();
            var           context = CreateRequest();

            KeyValuePair <string, object> begin = new KeyValuePair <string, object>(TraceObserver.BEGIN_REQUEST,
                                                                                    new { httpContext = context, timestamp = start });

            obs.OnNext(begin);

            KeyValuePair <string, object> end = new KeyValuePair <string, object>(TraceObserver.END_REQUEST,
                                                                                  new { httpContext = context, timestamp = start + 100000 });

            obs.OnNext(end);

            Assert.Equal(0, obs._pending.Count);
            Assert.Equal(1, obs._queue.Count);

            Trace result = null;

            Assert.True(obs._queue.TryPeek(out result));
            Assert.NotNull(result.Info);
            Assert.NotEqual(0, result.TimeStamp);
            Assert.True(result.Info.ContainsKey("method"));
            Assert.True(result.Info.ContainsKey("path"));
            Assert.True(result.Info.ContainsKey("headers"));
            Assert.True(result.Info.ContainsKey("timeTaken"));
            Assert.Equal("GET", result.Info["method"]);
            Assert.Equal("/myPath", result.Info["path"]);
            var headers = result.Info["headers"] as Dictionary <string, object>;

            Assert.NotNull(headers);
            Assert.True(headers.ContainsKey("request"));
            Assert.True(headers.ContainsKey("response"));
            var timeTaken = result.Info["timeTaken"] as string;

            Assert.NotNull(timeTaken);
            var expected = ((100000) / obs.ticksPerMilli).ToString();

            Assert.Equal(expected, timeTaken);

            listener.Dispose();
        }
示例#17
0
        public void Constructor_ThrowsOnNulls()
        {
            // Arrange
            DiagnosticListener listener  = null;
            DiagnosticListener listener2 = new DiagnosticListener("test");
            ITraceOptions      options   = null;

            // Act and Assert
            var ex = Assert.Throws <ArgumentNullException>(() => new TraceObserver(listener, options));

            Assert.Contains(nameof(listener), ex.Message);
            var ex2 = Assert.Throws <ArgumentNullException>(() => new TraceObserver(listener2, options));

            Assert.Contains(nameof(options), ex2.Message);

            listener2.Dispose();
        }
示例#18
0
        public async void HandleTraceRequestAsync_ReturnsExpected()
        {
            var opts = new TraceOptions();
            DiagnosticListener listener = new DiagnosticListener("test");

            TraceObserver obs     = new TraceObserver(listener, opts);
            var           ep      = new TestTraceEndpoint(opts, obs);
            var           middle  = new TraceEndpointMiddleware(null, ep);
            var           context = CreateRequest("GET", "/trace");
            await middle.HandleTraceRequestAsync(context);

            context.Response.Body.Seek(0, SeekOrigin.Begin);
            StreamReader rdr  = new StreamReader(context.Response.Body);
            string       json = await rdr.ReadToEndAsync();

            Assert.Equal("[]", json);
            listener.Dispose();
        }
        public void AddTraceActuator_AddsCorrectServices()
        {
            ServiceCollection services = new ServiceCollection();
            var    appsettings         = @"
{
    'management': {
        'endpoints': {
            'enabled': false,
            'sensitive': false,
            'path': '/cloudfoundryapplication',
            'trace' : {
                'enabled': true,
                'sensitive': false
            }
        }
    }
}";
            var    path      = TestHelpers.CreateTempFile(appsettings);
            string directory = Path.GetDirectoryName(path);
            string fileName  = Path.GetFileName(path);
            ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();

            configurationBuilder.SetBasePath(directory);

            configurationBuilder.AddJsonFile(fileName);
            var config   = configurationBuilder.Build();
            var listener = new DiagnosticListener("Test");

            services.AddSingleton(listener);

            services.AddTraceActuator(config);

            var serviceProvider = services.BuildServiceProvider();
            var options         = serviceProvider.GetService <ITraceOptions>();

            Assert.NotNull(options);
            var repo = serviceProvider.GetService <ITraceRepository>();

            Assert.NotNull(repo);
            var ep = serviceProvider.GetService <TraceEndpoint>();

            Assert.NotNull(ep);
            listener.Dispose();
        }
示例#20
0
        public void IsTraceRequest_ReturnsExpected()
        {
            var opts = new TraceOptions();
            DiagnosticListener listener = new DiagnosticListener("test");

            TraceObserver obs     = new TraceObserver(listener, opts);
            var           ep      = new TraceEndpoint(opts, obs);
            var           middle  = new TraceEndpointMiddleware(null, ep);
            var           context = CreateRequest("GET", "/trace");

            Assert.True(middle.IsTraceRequest(context));
            var context2 = CreateRequest("PUT", "/trace");

            Assert.False(middle.IsTraceRequest(context2));
            var context3 = CreateRequest("GET", "/badpath");

            Assert.False(middle.IsTraceRequest(context3));
            listener.Dispose();
        }
        public void Subscribe_Listener_StopActivity_AddsToQueue()
        {
            DiagnosticListener listener = new DiagnosticListener("Microsoft.AspNetCore");
            var option = new TraceEndpointOptions();

            TraceDiagnosticObserver obs = new TraceDiagnosticObserver(option);

            obs.Subscribe(listener);

            var      context      = CreateRequest();
            string   activityName = "Microsoft.AspNetCore.Hosting.HttpRequestIn";
            Activity current      = new Activity(activityName);

            listener.StartActivity(current, new { HttpContext = context });

            Thread.Sleep(1000);

            listener.StopActivity(current, new { HttpContext = context });

            Assert.Single(obs._queue);

            Assert.True(obs._queue.TryPeek(out TraceResult result));
            Assert.NotNull(result.Info);
            Assert.NotEqual(0, result.TimeStamp);
            Assert.True(result.Info.ContainsKey("method"));
            Assert.True(result.Info.ContainsKey("path"));
            Assert.True(result.Info.ContainsKey("headers"));
            Assert.True(result.Info.ContainsKey("timeTaken"));
            Assert.Equal("GET", result.Info["method"]);
            Assert.Equal("/myPath", result.Info["path"]);
            var headers = result.Info["headers"] as Dictionary <string, object>;

            Assert.NotNull(headers);
            Assert.True(headers.ContainsKey("request"));
            Assert.True(headers.ContainsKey("response"));
            var timeTaken = result.Info["timeTaken"] as string;

            Assert.NotNull(timeTaken);
            Assert.StartsWith("10", timeTaken);

            obs.Dispose();
            listener.Dispose();
        }
示例#22
0
        public void GetSessionId_WithSession_ReturnsExpected()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs     = new TraceObserver(listener, option);
            HttpContext   context = CreateRequest();

            var             session     = new TestSession();
            ISessionFeature sessFeature = new SessionFeature();

            sessFeature.Session = session;
            context.Features.Set <ISessionFeature>(sessFeature);

            var result = obs.GetSessionId(context);

            Assert.Equal("TestSessionId", result);
            listener.Dispose();
        }
示例#23
0
        public void GetRequestParameters_ReturnsExpected()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs     = new TraceObserver(listener, option);
            HttpContext   context = CreateRequest();
            var           result  = obs.GetRequestParameters(context.Request);

            Assert.NotNull(result);
            Assert.True(result.ContainsKey("foo"));
            Assert.True(result.ContainsKey("bar"));
            var fooVal = result["foo"];

            Assert.Equal(1, fooVal.Length);
            Assert.Equal("bar", fooVal[0]);
            var barVal = result["bar"];

            Assert.Equal(1, barVal.Length);
            Assert.Equal("foo", barVal[0]);
            listener.Dispose();
        }
示例#24
0
        public void OnNext_AddsToPending()
        {
            DiagnosticListener listener = new DiagnosticListener("test");
            TraceOptions       option   = new TraceOptions();

            TraceObserver obs             = new TraceObserver(listener, option);
            long          expectedTime    = Stopwatch.GetTimestamp();
            var           expectedContext = CreateRequest();

            KeyValuePair <string, object> begin = new KeyValuePair <string, object>(TraceObserver.BEGIN_REQUEST,
                                                                                    new { httpContext = expectedContext, timestamp = expectedTime });

            obs.OnNext(begin);

            Assert.Equal(1, obs._pending.Count);
            Assert.True(obs._pending.ContainsKey(expectedContext.TraceIdentifier));
            var pending = obs._pending[expectedContext.TraceIdentifier];

            Assert.Equal(expectedTime, pending.StartTime);

            Assert.Equal(0, obs._queue.Count);
            listener.Dispose();
        }
示例#25
0
        public void GetTraces_ReturnsTraces()
        {
            var listener = new DiagnosticListener("test");
            var option   = new TraceEndpointOptions();

            var obs     = new TraceDiagnosticObserver(option);
            var current = new Activity("Microsoft.AspNetCore.Hosting.HttpRequestIn");

            current.Start();

            for (var i = 0; i < 200; i++)
            {
                var context = CreateRequest();
                obs.ProcessEvent("Microsoft.AspNetCore.Hosting.HttpRequestIn.Stop", new { HttpContext = context });
            }

            Assert.Equal(option.Capacity, obs._queue.Count);
            var traces = obs.GetTraces();

            Assert.Equal(option.Capacity, traces.Count);
            Assert.Equal(option.Capacity, obs._queue.Count);

            listener.Dispose();
        }