Abaranch/request name

src/ApplicationInsights.AspNet/ActiveConfigurationManager.cs

@@ -6,6 +6,7 @@
     using Microsoft.AspNet.Hosting;
     using Microsoft.Framework.ConfigurationModel;
     using System;
+    using Microsoft.Framework.DependencyInjection;
 
     public static class ActiveConfigurationManager
     {
@@ -48,7 +49,7 @@ public static void AddTelemetryInitializers(TelemetryConfiguration aiConfig, ISe
                 return;
             }
 
-            var httpAccessor = serviceProvider.GetService(typeof(IHttpContextAccessor)) as IHttpContextAccessor;
+            var httpAccessor = serviceProvider.GetService<IHttpContextAccessor>();
 
             aiConfig.TelemetryInitializers.Add(new ClientIpHeaderTelemetryInitializer(httpAccessor));
             aiConfig.TelemetryInitializers.Add(new UserAgentTelemetryInitializer(httpAccessor));

src/ApplicationInsights.AspNet/ApplicationInsightsExtensions.cs

@@ -47,6 +47,8 @@ public static void AddApplicationInsightsTelemetry(this IServiceCollection servi
                 rt.Context.InstrumentationKey = svcs.GetService<TelemetryClient>().Context.InstrumentationKey;
                 return rt;
             });
+
+            //services.AddScoped<RouteContext>
         }
 
         public static HtmlString ApplicationInsightsJavaScriptSnippet(this IHtmlHelper helper, string instrumentationKey)

src/ApplicationInsights.AspNet/ApplicationInsightsRequestMiddleware.cs

@@ -53,7 +53,8 @@ public async Task Invoke(HttpContext httpContext)
                     telemetry.Duration = sw.Elapsed;
                     telemetry.ResponseCode = httpContext.Response.StatusCode.ToString();
                     telemetry.Success = httpContext.Response.StatusCode < 400;
-
+                    telemetry.HttpMethod = httpContext.Request.Method;
+
                     this.telemetryClient.TrackRequest(telemetry);
                 }
             }

src/ApplicationInsights.AspNet/TelemetryInitializers/OperationNameTelemetryInitializer.cs

@@ -1,10 +1,14 @@
 namespace Microsoft.ApplicationInsights.AspNet.TelemetryInitializers
 {
-    using System;
     using Microsoft.ApplicationInsights.Channel;
     using Microsoft.ApplicationInsights.DataContracts;
-    using Microsoft.AspNet.Http;
     using Microsoft.AspNet.Hosting;
+    using Microsoft.AspNet.Http;
+    using Microsoft.AspNet.Mvc;
+    using Microsoft.AspNet.Mvc.Routing;
+    using Microsoft.Framework.DependencyInjection;
+    using System;
+    using System.Linq;
 
     public class OperationNameTelemetryInitializer : TelemetryInitializerBase
     {
@@ -15,7 +19,14 @@ protected override void OnInitializeTelemetry(HttpContext platformContext, Reque
         {
             if (string.IsNullOrEmpty(telemetry.Context.Operation.Name))
             {
-                var name = platformContext.Request.Method + " " + platformContext.Request.Path.Value; // Test potential dangerous request;
+                string name = this.GetNameFromRouteContext(platformContext.RequestServices);                
+
+                if (string.IsNullOrEmpty(name))
+                {
+                    name = platformContext.Request.Path.Value;
+                }
+
+                name = platformContext.Request.Method + " " + name; 
 
                 var telemetryType = telemetry as RequestTelemetry;
                 if (telemetryType != null && string.IsNullOrEmpty(telemetryType.Name))
@@ -26,5 +37,59 @@ protected override void OnInitializeTelemetry(HttpContext platformContext, Reque
                 telemetry.Context.Operation.Name = name;
             }
         }
+
+        private string GetNameFromRouteContext(IServiceProvider requestServices)
+        {
+            string name = null;
+
+            if (requestServices != null)
+            {
+                var actionContextAccessor = requestServices.GetService<IScopedInstance<ActionContext>>();
+
+                if (actionContextAccessor != null && actionContextAccessor.Value != null &&
+                    actionContextAccessor.Value.RouteData != null && actionContextAccessor.Value.RouteData.Values.Count > 0)
+                {
+                    var routeValues = actionContextAccessor.Value.RouteData.Values;
+
+                    object controller;
+                    routeValues.TryGetValue("controller", out controller);
+                    string controllerString = (controller == null) ? string.Empty : controller.ToString();
+
+                    if (!string.IsNullOrEmpty(controllerString))
+                    {
+                        name = controllerString;
+
+                        object action;
+                        routeValues.TryGetValue("action", out action);
+                        string actionString = (action == null) ? string.Empty : action.ToString();
+
+                        if (!string.IsNullOrEmpty(actionString))
+                        {
+                            name += "/" + actionString;
+                        }
+
+                        if (routeValues.Keys.Count > 2)
+                        {
+                            // Add parameters
+                            var sortedKeys = routeValues.Keys
+                                .Where(key => 
+                                    !string.Equals(key, "controller", StringComparison.OrdinalIgnoreCase) && 
+                                    !string.Equals(key, "action", StringComparison.OrdinalIgnoreCase) &&
+                                    !string.Equals(key, AttributeRouting.RouteGroupKey, StringComparison.OrdinalIgnoreCase))
+                                .OrderBy(key => key, StringComparer.OrdinalIgnoreCase)
+                                .ToArray();
+
+                            if (sortedKeys.Length > 0)
+                            {
+                                string arguments = string.Join(@"/", sortedKeys);
+                                name += " [" + arguments + "]";
+                            }
+                        }
+                    }
+                }
+            }
+
+            return name;
+        }
     }
 }

test/FunctionalTestUtils/InProcessServer.cs

@@ -6,14 +6,14 @@
     using Microsoft.Framework.DependencyInjection.Fallback;
     using System;
 
-    public class InProcessServer
+    public class InProcessServer : IDisposable
     {
+        private IDisposable hostingEngine;
         private string url = "http://localhost:" + (new Random(239).Next(5000, 8000)).ToString();
-        private string assemblyName = "ConsoleTest";
-
-        public InProcessServer(string currentAssemblyName)
+
+        public InProcessServer(string assemblyName)
         {
-            this.assemblyName = currentAssemblyName;
+            this.Start(assemblyName);
         }
 
         public string BaseHost
@@ -24,7 +24,7 @@ public string BaseHost
             }
         }
 
-        public IDisposable Start()
+        private void Start(string assemblyName)
         {
             var customConfig = new NameValueConfigurationSource();
             customConfig.Set("server.urls", this.BaseHost);
@@ -39,7 +39,7 @@ public IDisposable Start()
                 Services = services,
                 Configuration = config,
                 ServerName = "Microsoft.AspNet.Server.WebListener",
-                ApplicationName = this.assemblyName,
+                ApplicationName = assemblyName,
                 EnvironmentName = "Production"
             };
 
@@ -49,7 +49,15 @@ public IDisposable Start()
                 throw new Exception("TODO: IHostingEngine service not available exception");
             }
 
-            return hostingEngine.Start(context);
+            this.hostingEngine = hostingEngine.Start(context);
+        }
+
+        public void Dispose()
+        {
+            if (this.hostingEngine != null)
+            {
+                this.hostingEngine.Dispose();
+            }
         }
     }
 }

test/FunctionalTestUtils/Tests/RequestTelemetryTestsBase.cs

@@ -0,0 +1,35 @@
+using Microsoft.ApplicationInsights.Channel;
+using Microsoft.ApplicationInsights.DataContracts;
+using System;
+using System.Net;
+using Xunit;
+
+namespace FunctionalTestUtils.Tests
+{
+    public abstract class RequestTelemetryTestsBase : TelemetryTestsBase
+    {
+        public RequestTelemetryTestsBase(string assemblyName) : base(assemblyName)
+        { }
+
+        public void ValidateBasicRequest(string requestPath, RequestTelemetry expected)
+        {
+            DateTimeOffset testStart = DateTimeOffset.Now;
+            var task = this.HttpClient.GetAsync(this.Server.BaseHost + requestPath);
+            task.Wait(TestTimeoutMs);
+            var result = task.Result;
+
+            Assert.Equal(1, this.Buffer.Count);
+            ITelemetry telemetry = this.Buffer[0];
+            Assert.IsAssignableFrom(typeof(RequestTelemetry), telemetry);
+            var actual = (RequestTelemetry)telemetry;
+
+            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 < (DateTimeOffset.Now - testStart), "duration");
+            Assert.Equal(expected.HttpMethod, actual.HttpMethod);
+        }
+    }
+}

test/FunctionalTestUtils/Tests/TelemetryTestsBase.cs

@@ -0,0 +1,60 @@
+namespace FunctionalTestUtils.Tests
+{
+    using Microsoft.ApplicationInsights.Channel;
+    using System;
+    using System.Collections.Generic;
+    using System.Net.Http;
+
+    public abstract class TelemetryTestsBase : IDisposable
+    {
+        protected const int TestTimeoutMs = 5000;
+
+        private InProcessServer server;
+        private IList<ITelemetry> buffer = new List<ITelemetry>();
+        private HttpClient client = new HttpClient();
+
+        public TelemetryTestsBase(string assemblyName)
+        {
+            this.server = new InProcessServer(assemblyName);
+            BackTelemetryChannelExtensions.InitializeFunctionalTestTelemetryChannel(buffer);
+            BackTelemetryChannelExtensions.AddFunctionalTestTelemetryChannel(null);
+        }
+
+        public IList<ITelemetry> Buffer
+        {
+            get
+            {
+                return this.buffer;
+            }
+        }
+
+        public InProcessServer Server
+        {
+            get
+            {
+                return this.server;
+            }
+        }
+
+        public HttpClient HttpClient
+        {
+            get
+            {
+                return this.client;
+            }
+        }
+
+        public void Dispose()
+        {
+            if (this.server != null)
+            {
+                this.server.Dispose();
+            }
+
+            if (this.client != null)
+            {
+                this.client.Dispose();
+            }
+        }
+    }
+}

test/SampleWebAppIntegration/Controllers/HomeController.cs

@@ -26,9 +26,9 @@ public IActionResult Index()
             return View();
         }
 
-        public IActionResult About()
+        public IActionResult About(int index)
         {
-            ViewBag.Message = "Your application description page.";
+            ViewBag.Message = "Your application description page # " + index;
 
             return View();
         }

test/SampleWebAppIntegration/FunctionalTest/RequestTelemetryTests.cs

@@ -0,0 +1,69 @@
+namespace SampleWebAppIntegration.FunctionalTest
+{
+    using FunctionalTestUtils.Tests;
+    using Microsoft.ApplicationInsights.DataContracts;
+    using System.Linq;
+    using Xunit;
+
+    public class RequestTelemetryTests : RequestTelemetryTestsBase
+    {
+        public RequestTelemetryTests() : base("SampleWebAppIntegration")
+        { }
+
+        [Fact]
+        public void TestBasicRequestPropertiesAfterRequestingHomeController()
+        {
+            var expectedRequestTelemetry = new RequestTelemetry();
+            expectedRequestTelemetry.HttpMethod = "GET";
+            expectedRequestTelemetry.Name = "GET Home/Index";
+            expectedRequestTelemetry.ResponseCode = "200";
+            expectedRequestTelemetry.Success = true;
+            // expectedRequestTelemetry.Url ???
+
+            this.ValidateBasicRequest("/", expectedRequestTelemetry);
+        }
+
+        [Fact]
+        public void TestBasicRequestPropertiesAfterRequestingActionWithParameter()
+        {
+            var expectedRequestTelemetry = new RequestTelemetry();
+            expectedRequestTelemetry.HttpMethod = "GET";
+            expectedRequestTelemetry.Name = "GET Home/About [id]";
+            expectedRequestTelemetry.ResponseCode = "200";
+            expectedRequestTelemetry.Success = true;
+            // expectedRequestTelemetry.Url ???
+
+            this.ValidateBasicRequest("/Home/About/5", expectedRequestTelemetry);
+        }
+
+        [Fact]
+        public void TestBasicRequestPropertiesAfterRequestingNotExistingController()
+        {
+            var expectedRequestTelemetry = new RequestTelemetry();
+            expectedRequestTelemetry.HttpMethod = "GET";
+            expectedRequestTelemetry.Name = "GET /not/existing/controller";
+            expectedRequestTelemetry.ResponseCode = "404";
+            expectedRequestTelemetry.Success = false;
+
+            this.ValidateBasicRequest("/not/existing/controller", expectedRequestTelemetry);
+        }
+
+        [Fact]
+        public void TestMixedTelemetryItemsReceived()
+        {
+            var task = this.HttpClient.GetAsync(this.Server.BaseHost + "/home/contact");
+            task.Wait(TestTimeoutMs);
+
+            var request = this.Buffer.OfType<RequestTelemetry>().Single();
+            var eventTelemetry = this.Buffer.OfType<EventTelemetry>().Single();
+            var metricTelemetry = this.Buffer.OfType<MetricTelemetry>().Single();
+            var traceTelemetry = this.Buffer.OfType<TraceTelemetry>().Single();
+
+            Assert.Equal(4, this.Buffer.Count);
+            Assert.NotNull(request);
+            Assert.NotNull(eventTelemetry);
+            Assert.NotNull(metricTelemetry);
+            Assert.NotNull(traceTelemetry);
+        }
+    }
+}