Merge pull request #30 from bmermet/aspnetcorebase

Asp.Net Core Integration

Author: Emanuele Palazzetti

src/Datadog.Trace.AspNetCore.Tests/Datadog.Trace.AspNetCore.Tests.csproj

@@ -0,0 +1,31 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <AdditionalFiles Include="..\stylecop.json" Link="stylecop.json" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Diagnostics" Version="2.0.1" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc" Version="2.0.2" />
+    <PackageReference Include="Microsoft.AspNetCore.Server.Kestrel" Version="2.0.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
+    <PackageReference Include="System.Reactive" Version="3.1.1" />
+    <PackageReference Include="xunit" Version="2.3.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.3.1" />
+    <PackageReference Include="StyleCop.Analyzers" Version="1.0.2" />
+    <DotNetCliToolReference Include="dotnet-xunit" Version="2.3.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Datadog.Trace.AspNetCore\Datadog.Trace.AspNetCore.csproj" />
+    <ProjectReference Include="..\Datadog.Trace\Datadog.Trace.csproj" />
+  </ItemGroup>
+
+</Project>

src/Datadog.Trace.AspNetCore.Tests/EndRequestWaiter.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using Microsoft.Extensions.DiagnosticAdapter;
+
+namespace Datadog.Trace.AspNetCore.Tests
+{
+    public class EndRequestWaiter : IDisposable
+    {
+        private readonly ManualResetEvent _resetEvent = new ManualResetEvent(false);
+        private readonly List<IDisposable> _subscriptions = new List<IDisposable>();
+
+        public EndRequestWaiter()
+        {
+            DiagnosticListener.AllListeners.Subscribe(x =>
+            {
+                if (x.Name == "Microsoft.AspNetCore")
+                {
+                    _subscriptions.Add(x.SubscribeWithAdapter(this));
+                }
+            });
+        }
+
+        [DiagnosticName("Microsoft.AspNetCore.Hosting.EndRequest")]
+        public void OnHttpRequestInStop()
+        {
+            _resetEvent.Set();
+        }
+
+        [DiagnosticName("Microsoft.AspNetCore.Hosting.UnhandledException")]
+        public void OnUnhandledException()
+        {
+            _resetEvent.Set();
+        }
+
+        public void Wait()
+        {
+            _resetEvent.WaitOne();
+        }
+
+        public void Dispose()
+        {
+            foreach (var subscription in _subscriptions)
+            {
+                subscription.Dispose();
+            }
+        }
+    }
+}

src/Datadog.Trace.AspNetCore.Tests/FunctionalTests.cs

@@ -0,0 +1,242 @@
+using System;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Datadog.Trace.AspNetCore.Tests
+{
+    public class FunctionalTests : IDisposable
+    {
+        private const string MethodTag = "http.method";
+        private const string UrlTag = "http.url";
+        private const string StatusCodeTag = "http.status_code";
+        private const string ErrorMsgTag = "error.msg";
+        private const string ErrorTypeTag = "error.type";
+        private const string ErrorStackTag = "error.stack";
+
+        private const string Content = "Hello World!";
+        private const string DefaultServiceName = "testhost";
+
+        private readonly IWebHost _host;
+        private readonly HttpClient _client;
+        private readonly MockWriter _writer;
+        private readonly Tracer _tracer;
+        private readonly EndRequestWaiter _waiter;
+
+        public FunctionalTests()
+        {
+            _writer = new MockWriter();
+            _tracer = new Tracer(_writer);
+            _waiter = new EndRequestWaiter();
+            _host = new WebHostBuilder()
+                .UseUrls("http://localhost:5050")
+                .UseKestrel()
+                .ConfigureServices(s => s.AddDatadogTrace(_tracer)
+                                         .AddMvc())
+                .Configure(app => app
+                .Map("/error", HandleError)
+                .Map("/child", HandleWithChild)
+                .UseMvcWithDefaultRoute()
+                .Run(HandleNormal))
+                .Build();
+            _host.Start();
+            _client = new HttpClient() { BaseAddress = new Uri("http://localhost:5050") };
+        }
+
+        public void Dispose()
+        {
+            _host.Dispose();
+            _waiter.Dispose();
+        }
+
+        [Fact]
+        public async void OkResponse()
+        {
+            var response = await _client.GetAsync("/");
+            var content = await response.Content.ReadAsStringAsync();
+            _waiter.Wait();
+
+            Assert.Equal(Content, content);
+            var span = _writer.Traces.Single().Single();
+            Assert.Equal("GET", span.Tags[MethodTag]);
+            Assert.Equal("/", span.Tags[UrlTag]);
+            Assert.Equal("200", span.Tags[StatusCodeTag]);
+            Assert.Equal("GET 200", span.ResourceName);
+            Assert.Equal(DefaultServiceName, span.ServiceName);
+        }
+
+        [Fact]
+        public async void OkResponseOverrideServiceName()
+        {
+            const string serviceNameOverride = "Blublu";
+            _host.Dispose();
+            using (var host = new WebHostBuilder()
+                .UseUrls("http://localhost:5050")
+                .UseKestrel()
+                .ConfigureServices(s => s.AddDatadogTrace(_tracer, serviceNameOverride))
+                .Configure(app => app
+                    .UseDeveloperExceptionPage()
+                    .Run(HandleNormal))
+                .Build())
+            {
+                host.Start();
+                var response = await _client.GetAsync("/");
+                var content = await response.Content.ReadAsStringAsync();
+                _waiter.Wait();
+
+                Assert.Equal(Content, content);
+                var span = _writer.Traces.Single().Single();
+                Assert.Equal("GET", span.Tags[MethodTag]);
+                Assert.Equal("/", span.Tags[UrlTag]);
+                Assert.Equal("200", span.Tags[StatusCodeTag]);
+                Assert.Equal("GET 200", span.ResourceName);
+                Assert.Equal(serviceNameOverride, span.ServiceName);
+            }
+        }
+
+        [Fact]
+        public async void OkResponseWithChildSpan()
+        {
+            var response = await _client.GetAsync("/child");
+            var content = await response.Content.ReadAsStringAsync();
+            _waiter.Wait();
+
+            Assert.Equal(Content, content);
+            var trace = _writer.Traces.Single();
+            Assert.Equal(2, trace.Count);
+            var root = trace[0];
+            Assert.Equal("GET", root.Tags[MethodTag]);
+            Assert.Equal("/child", root.Tags[UrlTag]);
+            Assert.Equal("200", root.Tags[StatusCodeTag]);
+            Assert.Equal("GET 200", root.ResourceName);
+            Assert.Equal(DefaultServiceName, root.ServiceName);
+            var child = trace[1];
+            Assert.Equal("Child", child.OperationName);
+            Assert.Equal(root.Context, child.Context.Parent);
+        }
+
+        [Fact]
+        public async void Error()
+        {
+            var response = await _client.GetAsync("/error");
+            _waiter.Wait();
+
+            var span = _writer.Traces.Single().Single();
+            Assert.Equal("GET", span.Tags[MethodTag]);
+            Assert.Equal("/error", span.Tags[UrlTag]);
+            Assert.Equal("500", span.Tags[StatusCodeTag]);
+            Assert.True(span.Error);
+            Assert.Equal(typeof(InvalidOperationException).ToString(), span.GetTag(ErrorTypeTag));
+            Assert.Equal("Invalid", span.GetTag(ErrorMsgTag));
+            Assert.False(string.IsNullOrEmpty(span.GetTag(ErrorStackTag)));
+            Assert.Equal("GET 500", span.ResourceName);
+            Assert.Equal(DefaultServiceName, span.ServiceName);
+        }
+
+        [Fact]
+        public async void MvcOkResponse()
+        {
+            var response = await _client.GetAsync("/Test");
+            var content = await response.Content.ReadAsStringAsync();
+            _waiter.Wait();
+
+            Assert.Equal("ActionContent", content);
+            var span = _writer.Traces.Single().Single();
+            Assert.Equal("GET", span.Tags[MethodTag]);
+            Assert.Equal("/Test", span.Tags[UrlTag]);
+            Assert.Equal("200", span.Tags[StatusCodeTag]);
+            Assert.Equal("Test.Index", span.ResourceName);
+            Assert.Equal(DefaultServiceName, span.ServiceName);
+        }
+
+        [Fact]
+        public async void DeveloperExceptionPage()
+        {
+            _host.Dispose();
+            using (var host = new WebHostBuilder()
+                .UseUrls("http://localhost:5050")
+                .UseKestrel()
+                .ConfigureServices(s => s.AddDatadogTrace(_tracer))
+                .Configure(app => app
+                    .UseDeveloperExceptionPage()
+                    .Map("/error", HandleError))
+                .Build())
+            {
+                host.Start();
+                var response = await _client.GetAsync("/error");
+                _waiter.Wait();
+
+                var span = _writer.Traces.Single().Single();
+                Assert.Equal("GET", span.Tags[MethodTag]);
+                Assert.Equal("/error", span.Tags[UrlTag]);
+                Assert.Equal("500", span.Tags[StatusCodeTag]);
+                Assert.True(span.Error);
+                Assert.Equal(typeof(InvalidOperationException).ToString(), span.GetTag(ErrorTypeTag));
+                Assert.Equal("Invalid", span.GetTag(ErrorMsgTag));
+                Assert.False(string.IsNullOrEmpty(span.GetTag(ErrorStackTag)));
+                Assert.Equal("GET 500", span.ResourceName);
+                Assert.Equal(DefaultServiceName, span.ServiceName);
+            }
+        }
+
+        [Fact]
+        public async void ExceptionHandler()
+        {
+            _host.Dispose();
+            using (var host = new WebHostBuilder()
+                .UseUrls("http://localhost:5050")
+                .UseKestrel()
+                .ConfigureServices(s => s.AddDatadogTrace(_tracer))
+                .Configure(app => app
+                    .UseExceptionHandler("/index")
+                    .Map("/error", HandleError)
+                    .Run(HandleNormal))
+                .Build())
+            {
+                host.Start();
+                var response = await _client.GetAsync("/error");
+                _waiter.Wait();
+
+                var span = _writer.Traces.Single().Single();
+                Assert.Equal("GET", span.Tags[MethodTag]);
+                Assert.Equal("/error", span.Tags[UrlTag]);
+                Assert.Equal("500", span.Tags[StatusCodeTag]);
+                Assert.True(span.Error);
+                Assert.Equal(typeof(InvalidOperationException).ToString(), span.GetTag(ErrorTypeTag));
+                Assert.Equal("Invalid", span.GetTag(ErrorMsgTag));
+                Assert.False(string.IsNullOrEmpty(span.GetTag(ErrorStackTag)));
+                Assert.Equal("GET 500", span.ResourceName);
+                Assert.Equal(DefaultServiceName, span.ServiceName);
+            }
+        }
+
+        private static async Task HandleNormal(HttpContext context)
+        {
+                await context.Response.WriteAsync(Content);
+        }
+
+        private static void HandleError(IApplicationBuilder app)
+        {
+            app.Run(context =>
+            {
+                throw new InvalidOperationException("Invalid");
+            });
+        }
+
+        private void HandleWithChild(IApplicationBuilder app)
+        {
+            app.Run(async context =>
+            {
+                using (_tracer.StartActive("Child"))
+                {
+                    await context.Response.WriteAsync(Content);
+                }
+            });
+        }
+    }
+}

src/Datadog.Trace.AspNetCore.Tests/GlobalSuppressions.cs

@@ -0,0 +1,12 @@
+// This file is used by Code Analysis to maintain SuppressMessage
+// attributes that are applied to this project.
+// Project-level suppressions either have no target or are given
+// a specific target and scoped to a namespace, type, member, etc.
+
+using System.Diagnostics.CodeAnalysis;
+
+[assembly: SuppressMessage("StyleCop.CSharp.NamingRules", "SA1309:FieldNamesMustNotBeginWithUnderscore", Justification = "Reviewed.")]
+[assembly: SuppressMessage("StyleCop.CSharp.DocumentationRules", "SA1633:File must have header", Justification = "Reviewed.")]
+[assembly: SuppressMessage("StyleCop.CSharp.DocumentationRules", "SA1652:Enable XML documentation output", Justification = "Reviewed.")]
+[assembly: SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1101:Prefix local calls with this", Justification = "Reviewed.")]
+[assembly: SuppressMessage("StyleCop.CSharp.OrderingRules", "SA1200:UsingDirectivesMustBePlacedWithinNamespace", Justification = "Reviewed.")]

src/Datadog.Trace.AspNetCore.Tests/MockWriter.cs

@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Datadog.Trace.AspNetCore.Tests
+{
+    public class MockWriter : IAgentWriter
+    {
+        public MockWriter()
+        {
+            Traces = new List<List<Span>>();
+        }
+
+        public List<List<Span>> Traces { get; set; }
+
+        public Task FlushAndCloseAsync()
+        {
+            return Task.FromResult(true);
+        }
+
+        public void WriteServiceInfo(ServiceInfo serviceInfo)
+        {
+        }
+
+        public void WriteTrace(List<Span> trace)
+        {
+            Traces.Add(trace);
+        }
+    }
+}

src/Datadog.Trace.AspNetCore.Tests/TestController.cs

@@ -0,0 +1,18 @@
+using System;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Datadog.Trace.AspNetCore.Tests.Controllers
+{
+    public class TestController : Controller
+    {
+        public string Index(int id)
+        {
+            return "ActionContent";
+        }
+
+        public string Error()
+        {
+            throw new InvalidOperationException("Invalid");
+        }
+    }
+}