wip

samples/OcelotOpenTracing/OcelotOpenTracing.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk.Worker">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Jaeger" Version="0.3.7" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="3.1.3" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Ocelot.Tracing.OpenTracing\Ocelot.Tracing.OpenTracing.csproj" />
+    <ProjectReference Include="..\..\src\Ocelot\Ocelot.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Content Update="appsettings.Development.json">
+      <ExcludeFromSingleFile>true</ExcludeFromSingleFile>
+    </Content>
+    <Content Update="appsettings.json">
+      <ExcludeFromSingleFile>true</ExcludeFromSingleFile>
+    </Content>
+    <Content Update="ocelot.json">
+      <ExcludeFromSingleFile>true</ExcludeFromSingleFile>
+    </Content>
+  </ItemGroup>
+
+</Project>

samples/OcelotOpenTracing/Program.cs

@@ -0,0 +1,67 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Hosting;
+using System.IO;
+using Ocelot.DependencyInjection;
+using Ocelot.Middleware;
+using Microsoft.Extensions.Logging;
+using Ocelot.Tracing.OpenTracing;
+using Jaeger;
+using Microsoft.Extensions.DependencyInjection;
+using OpenTracing;
+using OpenTracing.Util;
+
+namespace OcelotOpenTracing
+{
+    internal static class Program
+    {
+        private static void Main(string[] args)
+        {
+
+            Host.CreateDefaultBuilder()
+                .ConfigureWebHostDefaults(webBuilder =>
+                {
+                    webBuilder
+                        .UseContentRoot(Directory.GetCurrentDirectory())
+                        .UseKestrel()
+                        .ConfigureAppConfiguration((hostingContext, config) =>
+                        {
+                            config
+                                .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
+                                .AddJsonFile("appsettings.json", optional: false, reloadOnChange: false)
+                                .AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json",
+                                    optional: true, reloadOnChange: false)
+                                .AddJsonFile("ocelot.json", optional: false, reloadOnChange: true)
+                                .AddEnvironmentVariables();
+                        })
+                        .ConfigureServices((context, services) =>
+                        {
+                            services
+                                .AddOcelot()
+                                .AddOpenTracing();
+
+                            services.AddSingleton<ITracer>(sp =>
+                            {
+                                var loggerFactory = sp.GetService<ILoggerFactory>();
+                                Configuration config = new Configuration(context.HostingEnvironment.ApplicationName, loggerFactory);
+
+                                var tracer = config.GetTracer();
+                                GlobalTracer.Register(tracer);
+                                return tracer;
+                            });
+
+                        })
+                        .ConfigureLogging(logging =>
+                        {
+                            logging.AddConsole();
+                        })
+                        .Configure(app =>
+                        {
+                            app.UseOcelot().Wait();
+                        });
+                })
+                .Build()
+                .Run();
+        }
+    }
+}

samples/OcelotOpenTracing/appsettings.Development.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  }
+}

samples/OcelotOpenTracing/appsettings.json

@@ -0,0 +1,10 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft": "Warning",
+      "Microsoft.Hosting.Lifetime": "Information"
+    }
+  },
+  "AllowedHosts": "*"
+}

samples/OcelotOpenTracing/ocelot.json

@@ -0,0 +1,24 @@
+{
+  "ReRoutes": [
+    {
+      "HttpHandlerOptions": {
+        "UseTracing": true
+      },
+      "DownstreamPathTemplate": "/todos/{id}",
+      "DownstreamScheme": "https",
+      "DownstreamHostAndPorts": [
+        {
+          "Host": "jsonplaceholder.typicode.com",
+          "Port": 443
+        }
+      ],
+      "UpstreamPathTemplate": "/posts/{id}",
+      "UpstreamHttpMethod": [
+        "Get"
+      ]
+    }
+  ],
+  "GlobalConfiguration": {
+    "BaseUrl": "https://localhost:5000"
+  }
+}

src/Ocelot.Tracing.OpenTracing/Ocelot.Tracing.OpenTracing.csproj

@@ -0,0 +1,21 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <Version>0.0.0-dev</Version>
+    <Authors>Kjell-Åke Gafvelin</Authors>
+    <Description>This package provides OpenTracing support to Ocelot.</Description>
+    <PackageProjectUrl>https://github.com/ThreeMammals/Ocelot</PackageProjectUrl>
+    <PackageTags>API Gateway;.NET core; OpenTracing</PackageTags>
+    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="OpenTracing" Version="0.12.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Ocelot\Ocelot.csproj" />
+  </ItemGroup>
+
+</Project>

src/Ocelot.Tracing.OpenTracing/OcelotBuilderExtensions.cs

@@ -0,0 +1,17 @@
+using Microsoft.Extensions.DependencyInjection;
+using Ocelot.DependencyInjection;
+using Ocelot.Logging;
+using System;
+
+namespace Ocelot.Tracing.OpenTracing
+{
+    public static class OcelotBuilderExtensions
+    {
+        public static IOcelotBuilder AddOpenTracing(this IOcelotBuilder builder)
+        {
+            builder.Services.AddSingleton<ITracer, OpenTracingTracer>();
+            
+            return builder;
+        }
+    }
+}

src/Ocelot.Tracing.OpenTracing/OpenTracingTracer.cs

@@ -0,0 +1,71 @@
+using Microsoft.AspNetCore.Http;
+using OpenTracing;
+using OpenTracing.Propagation;
+using OpenTracing.Tag;
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Ocelot.Tracing.OpenTracing
+{
+    class OpenTracingTracer : Logging.ITracer
+    {
+        private readonly ITracer tracer;
+
+        public OpenTracingTracer(ITracer tracer)
+        {
+            this.tracer = tracer ?? throw new ArgumentNullException(nameof(tracer));
+        }
+
+        public void Event(HttpContext httpContext, string @event)
+        {
+        }
+
+        public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken,
+            Action<string> addTraceIdToRepo, Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> baseSendAsync)
+        {
+            using (IScope scope = this.tracer.BuildSpan(request.RequestUri.AbsoluteUri).StartActive(finishSpanOnDispose: true))
+            {
+                var span = scope.Span;
+
+                span.SetTag(Tags.SpanKind, Tags.SpanKindClient)
+                    .SetTag(Tags.HttpMethod, request.Method.Method)
+                    .SetTag(Tags.HttpUrl, request.RequestUri.OriginalString);
+
+                addTraceIdToRepo(span.Context.SpanId);
+
+                var headers = new Dictionary<string, string>();
+
+                this.tracer.Inject(span.Context, BuiltinFormats.HttpHeaders, new TextMapInjectAdapter(headers));
+
+                foreach (var item in headers)
+                {
+                    request.Headers.Add(item.Key, item.Value);
+                }
+
+                try
+                {
+                    var response = await baseSendAsync(request, cancellationToken);
+
+                    span.SetTag(Tags.HttpStatus, (int)response.StatusCode);
+
+                    return response;
+                }
+                catch (HttpRequestException ex)
+                {
+                    Tags.Error.Set(scope.Span, true);
+
+                    span.Log(new Dictionary<string, object>(3)
+                        {
+                            { LogFields.Event, Tags.Error.Key },
+                            { LogFields.ErrorKind, ex.GetType().Name },
+                            { LogFields.ErrorObject, ex }
+                        });
+                    throw;
+                }
+            }
+        }
+    }
+}

test/Ocelot.AcceptanceTests/OpenTracingTests.cs

@@ -0,0 +1,511 @@
+namespace Ocelot.AcceptanceTests
+{
+    using Butterfly.Client.AspNetCore;
+    using Ocelot.Configuration.File;
+    using Microsoft.AspNetCore.Builder;
+    using Microsoft.AspNetCore.Hosting;
+    using Microsoft.AspNetCore.Http;
+    using OpenTracing;
+    using OpenTracing.Propagation;
+    using OpenTracing.Tag;
+    using Rafty.Infrastructure;
+    using Shouldly;
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Net;
+    using TestStack.BDDfy;
+    using Xunit;
+    using Xunit.Abstractions;
+
+    public class OpenTracingTests : IDisposable
+    {
+        private IWebHost _serviceOneBuilder;
+        private IWebHost _serviceTwoBuilder;
+        private IWebHost _fakeOpenTracing;
+        private readonly Steps _steps;
+        private string _downstreamPathOne;
+        private string _downstreamPathTwo;
+        private readonly ITestOutputHelper _output;
+
+        public OpenTracingTests(ITestOutputHelper output)
+        {
+            _output = output;
+            _steps = new Steps();
+        }
+
+        [Fact]
+        public void should_forward_tracing_information_from_ocelot_and_downstream_services()
+        {
+            int port1 = RandomPortFinder.GetRandomPort();
+            int port2 = RandomPortFinder.GetRandomPort();
+            var configuration = new FileConfiguration()
+            {
+                ReRoutes = new List<FileReRoute>()
+                    {
+                        new FileReRoute()
+                        {
+                            DownstreamPathTemplate = "/api/values",
+                            DownstreamScheme = "http",
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = port1,
+                                }
+                            },
+                            UpstreamPathTemplate = "/api001/values",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                            HttpHandlerOptions = new FileHttpHandlerOptions
+                            {
+                                UseTracing = true
+                            }
+                        },
+                        new FileReRoute()
+                        {
+                            DownstreamPathTemplate = "/api/values",
+                            DownstreamScheme = "http",
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort()
+                                {
+                                    Host = "localhost",
+                                    Port = port2,
+                                }
+                            },
+                            UpstreamPathTemplate = "/api002/values",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                            HttpHandlerOptions = new FileHttpHandlerOptions
+                            {
+                                UseTracing = true
+                            }
+                        }
+                    }
+            };
+            
+            var tracingPort = RandomPortFinder.GetRandomPort();
+            var tracingUrl = $"http://localhost:{tracingPort}";
+
+            var fakeTracer = new FakeTracer();
+
+            this.Given(_ => GivenFakeOpenTracing(tracingUrl))
+                .And(_ => GivenServiceOneIsRunning($"http://localhost:{port1}", "/api/values", 200, "Hello from Laura", tracingUrl))
+                .And(_ => GivenServiceTwoIsRunning($"http://localhost:{port2}", "/api/values", 200, "Hello from Tom", tracingUrl))
+                .And(_ => _steps.GivenThereIsAConfiguration(configuration))
+                .And(_ => _steps.GivenOcelotIsRunningUsingOpenTracing(fakeTracer))
+                .When(_ => _steps.WhenIGetUrlOnTheApiGateway("/api001/values"))
+                .Then(_ => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .And(_ => _steps.ThenTheResponseBodyShouldBe("Hello from Laura"))
+                .When(_ => _steps.WhenIGetUrlOnTheApiGateway("/api002/values"))
+                .Then(_ => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .And(_ => _steps.ThenTheResponseBodyShouldBe("Hello from Tom"))
+                .BDDfy();
+
+            var commandOnAllStateMachines = Wait.WaitFor(10000).Until(() => fakeTracer.BuildSpanCalled >= 2);
+
+            _output.WriteLine($"fakeTracer.BuildSpanCalled is {fakeTracer.BuildSpanCalled}");
+
+            commandOnAllStateMachines.ShouldBeTrue();
+        }
+
+        [Fact]
+        public void should_return_tracing_header()
+        {
+            int port = RandomPortFinder.GetRandomPort();
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/api/values",
+                            DownstreamScheme = "http",
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = port,
+                                }
+                            },
+                            UpstreamPathTemplate = "/api001/values",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                            HttpHandlerOptions = new FileHttpHandlerOptions
+                            {
+                                UseTracing = true
+                            },
+                            DownstreamHeaderTransform = new Dictionary<string, string>()
+                            {
+                                {"Trace-Id", "{TraceId}"},
+                                {"Tom", "Laura"}
+                            }
+                        }
+                    }
+            };
+
+            var butterflyPort = RandomPortFinder.GetRandomPort();
+            var butterflyUrl = $"http://localhost:{butterflyPort}";
+
+            var fakeTracer = new FakeTracer();
+
+            this.Given(x => GivenFakeOpenTracing(butterflyUrl))
+                .And(x => GivenServiceOneIsRunning($"http://localhost:{port}", "/api/values", 200, "Hello from Laura", butterflyUrl))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunningUsingOpenTracing(fakeTracer))
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/api001/values"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .And(x => _steps.ThenTheResponseBodyShouldBe("Hello from Laura"))
+                .And(x => _steps.ThenTheTraceHeaderIsSet("Trace-Id"))
+                .And(x => _steps.ThenTheResponseHeaderIs("Tom", "Laura"))
+                .BDDfy();
+        }
+
+        private void GivenServiceOneIsRunning(string baseUrl, string basePath, int statusCode, string responseBody, string butterflyUrl)
+        {
+            _serviceOneBuilder = new WebHostBuilder()
+                .UseUrls(baseUrl)
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseIISIntegration()
+                .ConfigureServices(services =>
+                {
+                    services.AddButterfly(option =>
+                    {
+                        option.CollectorUrl = butterflyUrl;
+                        option.Service = "Service One";
+                        option.IgnoredRoutesRegexPatterns = new string[0];
+                    });
+                })
+                .Configure(app =>
+                {
+                    app.UsePathBase(basePath);
+                    app.Run(async context =>
+                    {
+                        _downstreamPathOne = !string.IsNullOrEmpty(context.Request.PathBase.Value) ? context.Request.PathBase.Value : context.Request.Path.Value;
+
+                        if (_downstreamPathOne != basePath)
+                        {
+                            context.Response.StatusCode = statusCode;
+                            await context.Response.WriteAsync("downstream path didnt match base path");
+                        }
+                        else
+                        {
+                            context.Response.StatusCode = statusCode;
+                            await context.Response.WriteAsync(responseBody);
+                        }
+                    });
+                })
+                .Build();
+
+            _serviceOneBuilder.Start();
+        }
+
+        private void GivenFakeOpenTracing(string baseUrl)
+        {
+            _fakeOpenTracing = new WebHostBuilder()
+                .UseUrls(baseUrl)
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseIISIntegration()
+                .Configure(app =>
+                {
+                    app.Run(async context =>
+                    {
+                        await context.Response.WriteAsync("OK...");
+                    });
+                })
+                .Build();
+
+            _fakeOpenTracing.Start();
+        }
+
+        private void GivenServiceTwoIsRunning(string baseUrl, string basePath, int statusCode, string responseBody, string butterflyUrl)
+        {
+            _serviceTwoBuilder = new WebHostBuilder()
+                .UseUrls(baseUrl)
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseIISIntegration()
+                .ConfigureServices(services =>
+                {
+                    services.AddButterfly(option =>
+                    {
+                        option.CollectorUrl = butterflyUrl;
+                        option.Service = "Service Two";
+                        option.IgnoredRoutesRegexPatterns = new string[0];
+                    });
+                })
+                .Configure(app =>
+                {
+                    app.UsePathBase(basePath);
+                    app.Run(async context =>
+                    {
+                        _downstreamPathTwo = !string.IsNullOrEmpty(context.Request.PathBase.Value) ? context.Request.PathBase.Value : context.Request.Path.Value;
+
+                        if (_downstreamPathTwo != basePath)
+                        {
+                            context.Response.StatusCode = statusCode;
+                            await context.Response.WriteAsync("downstream path didnt match base path");
+                        }
+                        else
+                        {
+                            context.Response.StatusCode = statusCode;
+                            await context.Response.WriteAsync(responseBody);
+                        }
+                    });
+                })
+                .Build();
+
+            _serviceTwoBuilder.Start();
+        }
+
+        public void Dispose()
+        {
+            _serviceOneBuilder?.Dispose();
+            _serviceTwoBuilder?.Dispose();
+            _fakeOpenTracing?.Dispose();
+            _steps.Dispose();
+        }
+    }
+
+    internal class FakeTracer : ITracer
+    {
+        public IScopeManager ScopeManager => throw new NotImplementedException();
+
+        public ISpan ActiveSpan => throw new NotImplementedException();
+
+        public ISpanBuilder BuildSpan(string operationName)
+        {
+            this.BuildSpanCalled++;
+
+            return new FakeSpanBuilder();
+        }
+
+        public int BuildSpanCalled { get; set; }
+
+        public ISpanContext Extract<TCarrier>(IFormat<TCarrier> format, TCarrier carrier)
+        {
+            this.ExtractCalled++;
+
+            return null;
+        }
+
+        public int ExtractCalled { get; set; }
+
+        public void Inject<TCarrier>(ISpanContext spanContext, IFormat<TCarrier> format, TCarrier carrier)
+        {
+            this.InjectCalled++;
+        }
+
+        public int InjectCalled { get; set; }
+    }
+
+    internal class FakeSpanBuilder : ISpanBuilder
+    {
+        public ISpanBuilder AddReference(string referenceType, ISpanContext referencedContext)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpanBuilder AsChildOf(ISpanContext parent)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpanBuilder AsChildOf(ISpan parent)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpanBuilder IgnoreActiveSpan()
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpan Start()
+        {
+            throw new NotImplementedException();
+        }
+
+        public IScope StartActive()
+        {
+            throw new NotImplementedException();
+        }
+
+        public IScope StartActive(bool finishSpanOnDispose)
+        {
+            return new FakeScope(finishSpanOnDispose);
+        }
+
+        public ISpanBuilder WithStartTimestamp(DateTimeOffset timestamp)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpanBuilder WithTag(string key, string value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpanBuilder WithTag(string key, bool value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpanBuilder WithTag(string key, int value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpanBuilder WithTag(string key, double value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpanBuilder WithTag(BooleanTag tag, bool value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpanBuilder WithTag(IntOrStringTag tag, string value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpanBuilder WithTag(IntTag tag, int value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpanBuilder WithTag(StringTag tag, string value)
+        {
+            throw new NotImplementedException();
+        }
+    }
+
+    internal class FakeScope : IScope
+    {
+        private readonly bool finishSpanOnDispose;
+
+        public FakeScope(bool finishSpanOnDispose)
+        {
+            this.finishSpanOnDispose = finishSpanOnDispose;
+        }
+
+        public ISpan Span { get; } = new FakeSpan();
+
+        public void Dispose()
+        {
+            if (this.finishSpanOnDispose)
+            {
+                this.Span.Finish();
+            }
+        }
+    }
+
+    internal class FakeSpan : ISpan
+    {
+        public ISpanContext Context => new FakeSpanContext();
+
+        public void Finish()
+        {
+        }
+
+        public void Finish(DateTimeOffset finishTimestamp)
+        {
+            throw new NotImplementedException();
+        }
+
+        public string GetBaggageItem(string key)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpan Log(IEnumerable<KeyValuePair<string, object>> fields)
+        {
+            return this;
+        }
+
+        public ISpan Log(DateTimeOffset timestamp, IEnumerable<KeyValuePair<string, object>> fields)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpan Log(string @event)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpan Log(DateTimeOffset timestamp, string @event)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpan SetBaggageItem(string key, string value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpan SetOperationName(string operationName)
+        {
+            throw new NotImplementedException();
+        }
+
+        public ISpan SetTag(string key, string value)
+        {
+            return this;
+        }
+
+        public ISpan SetTag(string key, bool value)
+        {
+            return this;
+        }
+
+        public ISpan SetTag(string key, int value)
+        {
+            return this;
+        }
+
+        public ISpan SetTag(string key, double value)
+        {
+            return this;
+        }
+
+        public ISpan SetTag(BooleanTag tag, bool value)
+        {
+            return this;
+        }
+
+        public ISpan SetTag(IntOrStringTag tag, string value)
+        {
+            return this;
+        }
+
+        public ISpan SetTag(IntTag tag, int value)
+        {
+            return this;
+        }
+
+        public ISpan SetTag(StringTag tag, string value)
+        {
+            return this;
+        }
+    }
+
+    internal class FakeSpanContext : ISpanContext
+    {
+        public static string FakeTraceId = "FakeTraceId";
+
+        public static string FakeSpanId = "FakeSpanId";
+
+        public string TraceId => FakeTraceId;
+
+        public string SpanId => FakeSpanId;
+
+        public IEnumerable<KeyValuePair<string, string>> GetBaggageItems()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}