public void TestMixedTelemetryItemsReceived()
        {
            using (var server = new InProcessServer(assemblyName))
            {
                var httpClient = new HttpClient();
                var task = httpClient.GetAsync(server.BaseHost + "/Mixed");
                task.Wait(TestTimeoutMs);

                var request = server.BackChannel.Buffer.OfType<RequestTelemetry>().Single();
                var eventTelemetry = server.BackChannel.Buffer.OfType<EventTelemetry>().Single();
                var metricTelemetry = server.BackChannel.Buffer.OfType<MetricTelemetry>().Single();
                var traceTelemetry = server.BackChannel.Buffer.OfType<TraceTelemetry>().Single();

            #if NET451
                var dependencyTelemetry = server.BackChannel.Buffer.OfType<DependencyTelemetry>().Single();
                Assert.NotNull(dependencyTelemetry);
            #endif

                Assert.True(server.BackChannel.Buffer.Count >= 4);
                Assert.NotNull(request);
                Assert.NotNull(eventTelemetry);
                Assert.NotNull(metricTelemetry);
                Assert.NotNull(traceTelemetry);
            }
        }
        public void TestBasicExceptionPropertiesAfterRequestingControllerThatThrows()
        {
            using (var server = new InProcessServer(assemblyName))
            {
                var expectedExceptionTelemetry = new ExceptionTelemetry();
                expectedExceptionTelemetry.HandledAt = ExceptionHandledAt.Platform;
                expectedExceptionTelemetry.Exception = new InvalidOperationException();

                this.ValidateBasicException(server, "/api/exception", expectedExceptionTelemetry);
            }
        }
        public void TestBasicDependencyPropertiesAfterRequestingBasicPage()
        {
            using (var server = new InProcessServer(assemblyName))
            {
                const string RequestPath = "/api/values";

                var expectedDependencyTelemetry = new DependencyTelemetry();
                expectedDependencyTelemetry.Name = server.BaseHost + RequestPath;
                expectedDependencyTelemetry.ResultCode = "200";
                expectedDependencyTelemetry.Success = true;
                this.ValidateBasicDependency(server, RequestPath, expectedDependencyTelemetry);
            }
        }
        public void ValidateBasicException(InProcessServer server, string requestPath, ExceptionTelemetry expected)
        {
            DateTimeOffset testStart = DateTimeOffset.Now;
            var httpClient = new HttpClient();
            var task = httpClient.GetAsync(server.BaseHost + requestPath);
            task.Wait(TestTimeoutMs);
            var result = task.Result;

            var actual = server.BackChannel.Buffer.OfType<ExceptionTelemetry>().Single();

            Assert.Equal(expected.Exception.GetType(), actual.Exception.GetType());
            Assert.NotEmpty(actual.Exception.StackTrace);
            Assert.Equal(actual.HandledAt, actual.HandledAt);
            Assert.NotEmpty(actual.Context.Operation.Name);
            Assert.NotEmpty(actual.Context.Operation.Id);
        }
        public void TestBasicRequestPropertiesAfterRequestingWebApiShimRoute()
        {
            using (var server = new InProcessServer(assemblyName))
            {
                const string RequestPath = "/api/values/1";

                var expectedRequestTelemetry = new RequestTelemetry();
                expectedRequestTelemetry.HttpMethod = "GET";
                expectedRequestTelemetry.Name = "GET Values/Get [id]";
                expectedRequestTelemetry.ResponseCode = "200";
                expectedRequestTelemetry.Success = true;
                expectedRequestTelemetry.Url = new System.Uri(server.BaseHost + RequestPath);

                this.ValidateBasicRequest(server, RequestPath, expectedRequestTelemetry);
            }
        }
        public void TestBasicRequestPropertiesAfterRequestingControllerThatThrows()
        {
            using (var server = new InProcessServer(assemblyName))
            {
                const string RequestPath = "/Home/Exception";

                var expectedRequestTelemetry = new RequestTelemetry();
                expectedRequestTelemetry.HttpMethod = "GET";

                expectedRequestTelemetry.Name = "GET Home/Exception";
                expectedRequestTelemetry.ResponseCode = "500";
                expectedRequestTelemetry.Success = false;
                expectedRequestTelemetry.Url = new System.Uri(server.BaseHost + RequestPath);
                this.ValidateBasicRequest(server, "/Home/Exception", expectedRequestTelemetry);
            }
        }
        public void TestIfPerformanceCountersAreCollected()
        {
            using (var server = new InProcessServer(assemblyName))
            {
                const string RequestPath = "/";
                var httpClient = new HttpClient();
                var task = httpClient.GetAsync(server.BaseHost + RequestPath);
                task.Wait(TestTimeoutMs);
                var result = task.Result;
                Thread.Sleep(70000);
                var actual = server.BackChannel.Buffer.OfType<PerformanceCounterTelemetry>().Distinct();

                Assert.True(actual.Count() > 0);

            }
        }
        public void ValidateBasicDependency(InProcessServer server, string requestPath, DependencyTelemetry expected)
        {
            DateTimeOffset testStart = DateTimeOffset.Now;
            var timer = Stopwatch.StartNew();
            var httpClient = new HttpClient();
            var task = httpClient.GetAsync(server.BaseHost + requestPath);
            task.Wait(TestTimeoutMs);
            var result = task.Result;

            var actual = server.BackChannel.Buffer.OfType<DependencyTelemetry>().Single();
            timer.Stop();

            Assert.Equal(expected.Name, actual.Name);
            Assert.Equal(expected.Success, actual.Success);
            Assert.Equal(expected.ResultCode, actual.ResultCode);
        }
        public void TestBasicRequestPropertiesAfterRequestingActionWithParameter()
        {
            using (var server = new InProcessServer(assemblyName))
            {
                const string RequestPath = "/Home/About/5";

                var expectedRequestTelemetry = new RequestTelemetry();
                expectedRequestTelemetry.HttpMethod = "GET";
                expectedRequestTelemetry.Name = "GET Home/About [id]";
                expectedRequestTelemetry.ResponseCode = "200";
                expectedRequestTelemetry.Success = true;
                expectedRequestTelemetry.Url = new System.Uri(server.BaseHost + RequestPath);

                this.ValidateBasicRequest(server, RequestPath, expectedRequestTelemetry);
            }
        }
        public void TestBasicRequestPropertiesAfterRequestingNotExistingController()
        {
            using (var server = new InProcessServer(assemblyName))
            {
                const string RequestPath = "/api/notexistingcontroller";

                var expectedRequestTelemetry = new RequestTelemetry();
                expectedRequestTelemetry.HttpMethod = "GET";
                expectedRequestTelemetry.Name = "GET /api/notexistingcontroller";
                expectedRequestTelemetry.ResponseCode = "404";
                expectedRequestTelemetry.Success = false;
                expectedRequestTelemetry.Url = new System.Uri(server.BaseHost + RequestPath);

                this.ValidateBasicRequest(server, RequestPath, expectedRequestTelemetry);
            }
        }
        public void TestBasicRequestPropertiesAfterRequestingControllerThatThrows()
        {
            using (var server = new InProcessServer(assemblyName))
            {
                const string RequestPath = "/Home/Exception";

                var expectedRequestTelemetry = new RequestTelemetry();
                expectedRequestTelemetry.HttpMethod = "GET";

                // Request name is tracked incorretly in case of errors right now, tracked by https://github.com/Microsoft/ApplicationInsights-aspnet5/issues/91
                expectedRequestTelemetry.Name = "GET Home/Error";
                expectedRequestTelemetry.ResponseCode = "500";
                expectedRequestTelemetry.Success = false;
                expectedRequestTelemetry.Url = new System.Uri(server.BaseHost + RequestPath);
                this.ValidateBasicRequest(server, "/Home/Exception", expectedRequestTelemetry);
            }
        }
        public void TestBasicRequestPropertiesAfterRequestingControllerThatThrows()
        {
            using (var server = new InProcessServer(assemblyName))
            {
                const string RequestPath = "/api/exception";

                var expectedRequestTelemetry = new RequestTelemetry();
                expectedRequestTelemetry.HttpMethod = "GET";
                expectedRequestTelemetry.Name = "GET Exception/Get";
                //TODO: default template of Web API applicaiton doesn't have error handling middleware 
                //that will set appropriate status code
                expectedRequestTelemetry.ResponseCode = "200";
                expectedRequestTelemetry.Success = false;
                expectedRequestTelemetry.Url = new System.Uri(server.BaseHost + RequestPath);

                this.ValidateBasicRequest(server, RequestPath, expectedRequestTelemetry);
            }
        }
        public void ValidateBasicRequest(InProcessServer server, string requestPath, RequestTelemetry expected)
        {
            DateTimeOffset testStart = DateTimeOffset.Now;
            var timer = Stopwatch.StartNew();
            var httpClient = new HttpClient();
            var task = httpClient.GetAsync(server.BaseHost + requestPath);
            task.Wait(TestTimeoutMs);
            var result = task.Result;

            var actual = server.BackChannel.Buffer.OfType<RequestTelemetry>().Single();

            timer.Stop();
            Assert.Equal(expected.ResponseCode, actual.ResponseCode);
            Assert.Equal(expected.Name, actual.Name);
            Assert.Equal(expected.Success, actual.Success);
            Assert.Equal(expected.Url, actual.Url);
            Assert.InRange<DateTimeOffset>(actual.Timestamp, testStart, DateTimeOffset.Now);
            Assert.True(actual.Duration < timer.Elapsed, "duration");
            Assert.Equal(expected.HttpMethod, actual.HttpMethod);
        }
        public void TestMixedTelemetryItemsReceived()
        {
            using (var server = new InProcessServer(assemblyName))
            {
                var httpClient = new HttpClient();
                var task = httpClient.GetAsync(server.BaseHost + "/Home/Contact");
                task.Wait(TestTimeoutMs);

                var request = server.BackChannel.Buffer.OfType<RequestTelemetry>().Single();
                var eventTelemetry = server.BackChannel.Buffer.OfType<EventTelemetry>().Single();
                var metricTelemetry = server.BackChannel.Buffer.OfType<MetricTelemetry>().Single();
                var traceTelemetry = server.BackChannel.Buffer.OfType<TraceTelemetry>().Single();

                Assert.Equal(4, server.BackChannel.Buffer.Count);
                Assert.NotNull(request);
                Assert.NotNull(eventTelemetry);
                Assert.NotNull(metricTelemetry);
                Assert.NotNull(traceTelemetry);
            }
        }
Esempio n. 15
0
        public void ValidatePerformanceCountersAreCollected(string assemblyName, Func <IWebHostBuilder, IWebHostBuilder> configureHost = null)
        {
            using (var server = new InProcessServer(assemblyName, configureHost))
            {
                // Reconfigure the PerformanceCollectorModule timer.
                Type perfModuleType = typeof(PerformanceCollectorModule);
                PerformanceCollectorModule perfModule = (PerformanceCollectorModule)server.ApplicationServices.GetServices <ITelemetryModule>().FirstOrDefault(m => m.GetType() == perfModuleType);
                FieldInfo timerField = perfModuleType.GetField("timer", BindingFlags.NonPublic | BindingFlags.Instance);
                var       timer      = timerField.GetValue(perfModule);
                timerField.FieldType.InvokeMember("ScheduleNextTick", BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance, null, timer, new object[] { TimeSpan.FromMilliseconds(10) });

                DateTime timeout = DateTime.UtcNow.AddMilliseconds(TestTimeoutMs);
                int      numberOfCountersSent = 0;
                do
                {
                    Thread.Sleep(1000);
                    numberOfCountersSent += server.BackChannel.Buffer.OfType <MetricTelemetry>().Distinct().Count();
                } while (numberOfCountersSent == 0 && DateTime.UtcNow < timeout);

                Assert.True(numberOfCountersSent > 0);
            }
        }
Esempio n. 16
0
        public void ValidateBasicException(InProcessServer server, string requestPath, ExceptionTelemetry expected)
        {
            var httpClientHandler = new HttpClientHandler();

            httpClientHandler.UseDefaultCredentials = true;

            Task <HttpResponseMessage> task;

            using (var httpClient = new HttpClient(httpClientHandler, true))
            {
                task = httpClient.GetAsync(server.BaseHost + requestPath);
                task.Wait(TestTimeoutMs);
            }
            var result = task.Result;

            server.Dispose();
            var actual = server.BackChannel.Buffer.OfType <ExceptionTelemetry>().Single();

            Assert.Equal(expected.Exception.GetType(), actual.Exception.GetType());
            Assert.NotEmpty(actual.Exception.StackTrace);
            Assert.NotEmpty(actual.Context.Operation.Name);
            Assert.NotEmpty(actual.Context.Operation.Id);
        }
Esempio n. 17
0
        public TelemetryItem <RequestData> ValidateRequestWithHeaders(InProcessServer server, string requestPath, Dictionary <string, string> requestHeaders, RequestTelemetry expected, bool expectRequestContextInResponse = true)
        {
            // Subtract 50 milliseconds to hack around strange behavior on build server where the RequestTelemetry.Timestamp is somehow sometimes earlier than now by a few milliseconds.
            expected.Timestamp = DateTimeOffset.Now.Subtract(TimeSpan.FromMilliseconds(50));
            Stopwatch timer = Stopwatch.StartNew();

            var response = this.ExecuteRequest(server.BaseHost + requestPath, requestHeaders);

            var actual = server.Listener.ReceiveItemsOfType <TelemetryItem <RequestData> >(1, TestListenerTimeoutInMs);

            timer.Stop();

            this.DebugTelemetryItems(actual);
            this.output.WriteLine("Response headers: " + string.Join(",", response.Headers.Select(kvp => $"{kvp.Key} = {kvp.Value.First()}")));

            var item = actual.OfType <TelemetryItem <RequestData> >().FirstOrDefault();

            Assert.NotNull(item);
            var data = ((TelemetryItem <RequestData>)item).data.baseData;

            Assert.Equal(expected.ResponseCode, data.responseCode);
            Assert.Equal(expected.Name, data.name);
            Assert.Equal(expected.Success, data.success);
            Assert.Equal(expected.Url, new Uri(data.url));
            Assert.Equal(expectRequestContextInResponse, response.Headers.Contains("Request-Context"));
            if (expectRequestContextInResponse)
            {
                Assert.True(response.Headers.TryGetValues("Request-Context", out var appIds));
                Assert.Equal($"appId={InProcessServer.AppId}", appIds.Single());
            }

            output.WriteLine("actual.Duration: " + data.duration);
            output.WriteLine("timer.Elapsed: " + timer.Elapsed);
            Assert.True(TimeSpan.Parse(data.duration) < timer.Elapsed.Add(TimeSpan.FromMilliseconds(20)), "duration");

            return(item);
        }
Esempio n. 18
0
        public void ValidateBasicDependency(string assemblyName, string requestPath)
        {
            using (InProcessServer server = new InProcessServer(assemblyName))
            {
                DependencyTelemetry expected = new DependencyTelemetry();
                expected.Name       = server.BaseHost + requestPath;
                expected.ResultCode = "200";
                expected.Success    = true;

                DateTimeOffset testStart  = DateTimeOffset.Now;
                var            timer      = Stopwatch.StartNew();
                var            httpClient = new HttpClient();
                var            task       = httpClient.GetAsync(server.BaseHost + requestPath);
                task.Wait(TestTimeoutMs);
                var result = task.Result;

                var actual = server.BackChannel.Buffer.OfType <DependencyTelemetry>().Single();
                timer.Stop();

                Assert.Equal(expected.Name, actual.Name);
                Assert.Equal(expected.Success, actual.Success);
                Assert.Equal(expected.ResultCode, actual.ResultCode);
            }
        }
        public void ValidatePerformanceCountersAreCollected(string assemblyName)
        {
            using (var server = new InProcessServer(assemblyName))
            {
                // Reconfigure the PerformanceCollectorModule timer.
                Type perfModuleType = typeof(PerformanceCollectorModule);
                PerformanceCollectorModule perfModule = (PerformanceCollectorModule)server.ApplicationServices.GetServices<ITelemetryModule>().FirstOrDefault(m => m.GetType() == perfModuleType);
                FieldInfo timerField = perfModuleType.GetField("timer", BindingFlags.NonPublic | BindingFlags.Instance);
                var timer = timerField.GetValue(perfModule);
                timerField.FieldType.InvokeMember("ScheduleNextTick", BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance, null, timer, new object[] { TimeSpan.FromMilliseconds(10) });

                DateTime timeout = DateTime.Now.AddSeconds(10);
                int numberOfCountersSent = 0;
                do
                {
                    Thread.Sleep(1000);
                    numberOfCountersSent = server.BackChannel.Buffer.OfType<PerformanceCounterTelemetry>().Distinct().Count();
                } while (numberOfCountersSent == 0 && DateTime.Now < timeout);

                Assert.True(numberOfCountersSent > 0);
            }
        }
Esempio n. 20
0
 public TelemetryItem <RequestData> ValidateBasicRequest(InProcessServer server, string requestPath, RequestTelemetry expected, bool expectRequestContextInResponse = true)
 {
     return(ValidateRequestWithHeaders(server, requestPath, null, expected, expectRequestContextInResponse));
 }
Esempio n. 21
0
        public (TelemetryItem <RequestData>, TelemetryItem <RemoteDependencyData>) ValidateBasicDependency(InProcessServer server, string requestPath, DependencyTelemetry expected)
        {
            var response = this.ExecuteRequest(server.BaseHost + requestPath);

            var actual = server.Listener.ReceiveItems(TestListenerTimeoutInMs);

            this.DebugTelemetryItems(actual);

            var dependencyTelemetry = actual.OfType <TelemetryItem <RemoteDependencyData> >().FirstOrDefault();

            Assert.NotNull(dependencyTelemetry);
            var dependencyData = ((TelemetryItem <RemoteDependencyData>)dependencyTelemetry).data.baseData;

            Assert.Equal(expected.Data, dependencyData.data);
            Assert.Equal(expected.ResultCode, dependencyData.resultCode);
            Assert.Equal(expected.Success, dependencyData.success);

            var requestTelemetry = actual.OfType <TelemetryItem <RequestData> >().FirstOrDefault();

            Assert.NotNull(requestTelemetry);

            Assert.Equal(requestTelemetry.tags["ai.operation.id"], dependencyTelemetry.tags["ai.operation.id"]);
            Assert.Contains(dependencyTelemetry.data.baseData.id, requestTelemetry.tags["ai.operation.parentId"]);

            return(requestTelemetry, dependencyTelemetry);
        }