HeaderPropagation: propagate incoming request headers to outgoing HTTP requests

eng/ProjectReferences.props

@@ -73,6 +73,7 @@
     <ProjectReferenceProvider Include="Microsoft.AspNetCore.Diagnostics.Abstractions" ProjectPath="$(RepositoryRoot)src\Middleware\Diagnostics.Abstractions\src\Microsoft.AspNetCore.Diagnostics.Abstractions.csproj" RefProjectPath="$(RepositoryRoot)src\Middleware\Diagnostics.Abstractions\ref\Microsoft.AspNetCore.Diagnostics.Abstractions.csproj" />
     <ProjectReferenceProvider Include="Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore" ProjectPath="$(RepositoryRoot)src\Middleware\Diagnostics.EntityFrameworkCore\src\Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.csproj" RefProjectPath="$(RepositoryRoot)src\Middleware\Diagnostics.EntityFrameworkCore\ref\Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore.csproj" />
     <ProjectReferenceProvider Include="Microsoft.AspNetCore.Diagnostics" ProjectPath="$(RepositoryRoot)src\Middleware\Diagnostics\src\Microsoft.AspNetCore.Diagnostics.csproj" RefProjectPath="$(RepositoryRoot)src\Middleware\Diagnostics\ref\Microsoft.AspNetCore.Diagnostics.csproj" />
+    <ProjectReferenceProvider Include="Microsoft.AspNetCore.HeaderPropagation" ProjectPath="$(RepositoryRoot)src\Middleware\HeaderPropagation\src\Microsoft.AspNetCore.HeaderPropagation.csproj" RefProjectPath="$(RepositoryRoot)src\Middleware\HeaderPropagation\ref\Microsoft.AspNetCore.HeaderPropagation.csproj" />
     <ProjectReferenceProvider Include="Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore" ProjectPath="$(RepositoryRoot)src\Middleware\HealthChecks.EntityFrameworkCore\src\Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore.csproj" RefProjectPath="$(RepositoryRoot)src\Middleware\HealthChecks.EntityFrameworkCore\ref\Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore.csproj" />
     <ProjectReferenceProvider Include="Microsoft.AspNetCore.Diagnostics.HealthChecks" ProjectPath="$(RepositoryRoot)src\Middleware\HealthChecks\src\Microsoft.AspNetCore.Diagnostics.HealthChecks.csproj" RefProjectPath="$(RepositoryRoot)src\Middleware\HealthChecks\ref\Microsoft.AspNetCore.Diagnostics.HealthChecks.csproj" />
     <ProjectReferenceProvider Include="Microsoft.AspNetCore.HostFiltering" ProjectPath="$(RepositoryRoot)src\Middleware\HostFiltering\src\Microsoft.AspNetCore.HostFiltering.csproj" RefProjectPath="$(RepositoryRoot)src\Middleware\HostFiltering\ref\Microsoft.AspNetCore.HostFiltering.csproj" />

eng/SharedFramework.Local.props

@@ -56,6 +56,7 @@
     <AspNetCoreAppReference Include="Microsoft.AspNetCore.Cors" />
     <AspNetCoreAppReference Include="Microsoft.AspNetCore.Diagnostics.Abstractions" />
     <AspNetCoreAppReference Include="Microsoft.AspNetCore.Diagnostics" />
+    <AspNetCoreAppReference Include="Microsoft.AspNetCore.HeaderPropagation" />
     <AspNetCoreAppReference Include="Microsoft.AspNetCore.Diagnostics.HealthChecks" />
     <AspNetCoreAppReference Include="Microsoft.AspNetCore.HostFiltering" />
     <AspNetCoreAppReference Include="Microsoft.AspNetCore.HttpOverrides" />

src/Middleware/HeaderPropagation/src/DependencyInjection/HeaderPropagationExtensions.cs

@@ -0,0 +1,38 @@
+using System;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.AspNetCore.HeaderPropagation
+{
+    public static class HeaderPropagationExtensions
+    {
+        public static IServiceCollection AddHeaderPropagation(this IServiceCollection services, Action<HeaderPropagationOptions> configure)
+        {
+            services.TryAddSingleton<HeaderPropagationState>();
+            services.Configure(configure);
+
+            return services;
+        }
+
+        public static IHttpClientBuilder AddHeaderPropagation(this IHttpClientBuilder builder)
+        {
+            builder.Services.TryAddSingleton<HeaderPropagationState>();
+            builder.Services.TryAddTransient<HeaderPropagationMessageHandler>();
+
+            builder.AddHttpMessageHandler(services =>
+            {
+                var state = services.GetRequiredService<HeaderPropagationState>();
+                return new HeaderPropagationMessageHandler(services.GetRequiredService<IOptions<HeaderPropagationOptions>>(), state);
+            });
+
+            return builder;
+        }
+
+        public static IApplicationBuilder UseHeaderPropagation(this IApplicationBuilder builder)
+        {
+            return builder.UseMiddleware<HeaderPropagationMiddleware>();
+        }
+    }
+}

src/Middleware/HeaderPropagation/src/HeaderPropagationEntry.cs

@@ -0,0 +1,15 @@
+using System;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.AspNetCore.HeaderPropagation
+{
+    public class HeaderPropagationEntry
+    {
+        public string InputName { get; set; }
+        public string OutputName { get; set; }
+        public StringValues DefaultValues { get; set; }
+        public Func<HttpContext, StringValues> DefaultValuesGenerator { get; set; }
+        public bool AlwaysAdd { get; set; }
+    }
+}

src/Middleware/HeaderPropagation/src/HeaderPropagationMessageHandler.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.AspNetCore.HeaderPropagation
+{
+    public class HeaderPropagationMessageHandler : DelegatingHandler
+    {
+        private readonly HeaderPropagationState _state;
+        private readonly HeaderPropagationOptions _options;
+
+        public HeaderPropagationMessageHandler(IOptions<HeaderPropagationOptions> options, HeaderPropagationState state)
+        {
+            if (options == null)
+            {
+                throw new ArgumentNullException(nameof(options));
+            }
+
+            _options = options.Value;
+
+            _state = state ?? throw new ArgumentNullException(nameof(state));
+        }
+
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
+            CancellationToken cancellationToken)
+        {
+            foreach (var header in _options.Headers)
+            {
+                if (_state.Headers.TryGetValue(header.OutputName, out var values) &&
+                    !StringValues.IsNullOrEmpty(values) &&
+                    (header.AlwaysAdd || !request.Headers.Contains(header.OutputName)))
+                {
+                    request.Headers.TryAddWithoutValidation(header.OutputName, (string[]) values);
+                }
+            }
+
+            return base.SendAsync(request, cancellationToken);
+        }
+    }
+}

src/Middleware/HeaderPropagation/src/HeaderPropagationMiddleware.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.AspNetCore.HeaderPropagation
+{
+    public class HeaderPropagationMiddleware
+    {
+        private readonly RequestDelegate _next;
+        private readonly HeaderPropagationOptions _options;
+        private readonly HeaderPropagationState _state;
+
+        public HeaderPropagationMiddleware(RequestDelegate next, IOptions<HeaderPropagationOptions> options, HeaderPropagationState state)
+        {
+            _next = next ?? throw new ArgumentNullException(nameof(next));
+
+            if (options == null)
+            {
+                throw new ArgumentNullException(nameof(options));
+            }
+            _options = options.Value;
+
+            _state = state ?? throw new ArgumentNullException(nameof(state));
+        }
+
+        public Task Invoke(HttpContext context)
+        {
+            if (context != null)
+            {
+                foreach (var header in _options.Headers)
+                {
+                    if (!context.Request.Headers.TryGetValue(header.InputName, out var values)
+                        || StringValues.IsNullOrEmpty(values))
+                    {
+                        if (header.DefaultValuesGenerator != null)
+                        {
+                            values = header.DefaultValuesGenerator(context);
+                            if (StringValues.IsNullOrEmpty(values)) continue;
+                        }
+                        else if (!StringValues.IsNullOrEmpty(header.DefaultValues))
+                        {
+                            values = header.DefaultValues;
+                        }
+                        else
+                        {
+                            continue;
+                        }
+                    }
+
+                    var outputName = !string.IsNullOrEmpty(header.OutputName) ? header.OutputName : header.InputName;
+                    _state.Headers.TryAdd(outputName, values);
+                }
+            }
+
+            return _next.Invoke(context);
+        }
+    }
+}

src/Middleware/HeaderPropagation/src/HeaderPropagationOptions.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace Microsoft.AspNetCore.HeaderPropagation
+{
+    public class HeaderPropagationOptions
+    {
+        public IList<HeaderPropagationEntry> Headers { get; set; } = new List<HeaderPropagationEntry>();
+    }
+}

src/Middleware/HeaderPropagation/src/HeaderPropagationState.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using System.Threading;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.AspNetCore.HeaderPropagation
+{
+    public class HeaderPropagationState
+    {
+        private static AsyncLocal<Dictionary<string, StringValues>> _headers { get; } = new AsyncLocal<Dictionary<string, StringValues>>();
+
+        public Dictionary<string, StringValues> Headers
+        {
+            get
+            {
+                return _headers.Value ?? (_headers.Value = new Dictionary<string, StringValues>());
+            }
+        }
+    }
+}

src/Middleware/HeaderPropagation/src/Microsoft.AspNetCore.HeaderPropagation.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Description>ASP.NET Core middleware to propagate HTTP headers from the incoming request to the outgoing HTTP Client requests</Description>
+    <TargetFramework>netcoreapp3.0</TargetFramework>
+    <IsAspNetCoreApp>true</IsAspNetCoreApp>
+    <NoWarn>$(NoWarn);CS1591</NoWarn>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <PackageTags>aspnetcore;httpclient</PackageTags>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <InternalsVisibleTo Include="Microsoft.AspNetCore.HeaderPropagation.Tests" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Reference Include="Microsoft.AspNetCore.Http" />
+    <Reference Include="Microsoft.Extensions.Http" />
+    <Reference Include="Microsoft.Extensions.DependencyInjection" />
+  </ItemGroup>
+
+</Project>

src/Middleware/HeaderPropagation/test/HeaderPropagationIntegrationTest.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Microsoft.AspNetCore.HeaderPropagation.Tests
+{
+    public class HeaderPropagationIntegrationTest
+    {
+        [Fact]
+        public async Task HeaderInRequest_AddCorrectValue()
+        {
+            // Arrange
+            var handler = new SimpleHandler();
+            var builder = CreateBuilder(c =>
+                c.Headers.Add(new HeaderPropagationEntry
+                {
+                    InputName = "in",
+                    OutputName = "out",
+                }),
+                handler);
+            var server = new TestServer(builder);
+            var client = server.CreateClient();
+
+            var request = new HttpRequestMessage();
+            request.Headers.Add("in", "test");
+
+            // Act
+            var response = await client.SendAsync(request);
+
+            // Assert
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            Assert.True(handler.Headers.Contains("out"));
+            Assert.Equal(new[] { "test" }, handler.Headers.GetValues("out"));
+        }
+
+        private IWebHostBuilder CreateBuilder(Action<HeaderPropagationOptions> configure, HttpMessageHandler primaryHandler)
+        {
+            return new WebHostBuilder()
+                .Configure(app =>
+                {
+                    app.UseHeaderPropagation();
+                    app.Map("", x => x.UseMiddleware<SimpleMiddleware>());
+                })
+                .ConfigureServices(services =>
+                {
+                    services.AddHttpClient("example.com", c => c.BaseAddress = new Uri("http://example.com"))
+                        .ConfigureHttpMessageHandlerBuilder(b =>
+                        {
+                            b.PrimaryHandler = primaryHandler;
+                        })
+                        .AddHeaderPropagation();
+                    services.AddHeaderPropagation(configure);
+                });
+        }
+
+        private class SimpleHandler : DelegatingHandler
+        {
+            public HttpHeaders Headers { get; private set; }
+
+            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+            {
+                Headers = request.Headers;
+                return Task.FromResult(new HttpResponseMessage());
+            }
+        }
+
+        private class SimpleMiddleware
+        {
+            private readonly RequestDelegate _next;
+            private readonly IHttpClientFactory _httpClientFactory;
+
+            public SimpleMiddleware(RequestDelegate next, IHttpClientFactory httpClientFactory)
+            {
+                _next = next;
+                _httpClientFactory = httpClientFactory;
+            }
+
+            public Task InvokeAsync(HttpContext _)
+            {
+                var client = _httpClientFactory.CreateClient("example.com");
+                return client.GetAsync("");
+            }
+        }
+    }
+}