Round #718

Build a typed HttpClient with a DelegatingHandler stack that injects IHttpContextAccessor's current trace ID into outgoing headers.

To build a typed `HttpClient` with a `DelegatingHandler` stack that injects `IHttpContextAccessor`'s current trace ID into outgoing headers, you can follow these steps. This example assumes you are working within an ASP.NET Core application where `IHttpContextAccessor` is available for accessing the current HTTP context. First, ensure you have the necessary NuGet packages installed in your project. You will need `Microsoft.Extensions.Http` for `IHttpClientFactory` and `Microsoft.AspNetCore.Http` for `IHttpContextAccessor`. ### Step 1: Create a Custom Delegating Handler Create a custom `DelegatingHandler` that will inject the trace ID into the outgoing request headers. This handler will access the current HTTP context via `IHttpContextAccessor`. ```csharp using Microsoft.AspNetCore.Http; using System; using System.Net.Http; using System.Threading; using System.Threading.Tasks; public class TraceIdDelegatingHandler : DelegatingHandler { private readonly IHttpContextAccessor _httpContextAccessor; public TraceIdDelegatingHandler(IHttpContextAccessor httpContextAccessor) { _httpContextAccessor = httpContextAccessor; } protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { var httpContext = _httpContextAccessor.HttpContext; if (httpContext != null) { var traceId = httpContext.TraceIdentifier; request.Headers.Add("X-Trace-Id", traceId); } return await base.SendAsync(request, cancellationToken); } } ``` ### Step 2: Register Services in Startup.cs In the `Startup.cs` file, within the `ConfigureServices` method, you need to register `IHttpContextAccessor`, `IHttpClientFactory`, and your custom `DelegatingHandler`. Also, configure the typed `HttpClient` with the custom handler. ```csharp using Microsoft.Extensions.DependencyInjection; public void ConfigureServices(IServiceCollection services) { services.AddControllers(); // Register IHttpContextAccessor services.AddHttpContextAccessor(); // Register the custom DelegatingHandler services.AddTransient<TraceIdDelegatingHandler>(); // Configure a typed HttpClient with the custom handler services.AddHttpClient("MyTypedClient") .AddHttpMessageHandler<TraceIdDelegatingHandler>(); } ``` ### Step 3: Use the Typed HttpClient Now, you can inject and use the typed `HttpClient` in your services or controllers. The `HttpClient` instance will automatically include the custom `DelegatingHandler` that injects the trace ID into outgoing request headers. ```csharp using Microsoft.Extensions.Http; using System.Net.Http; using System.Threading.Tasks; public class MyService { private readonly IHttpClientFactory _httpClientFactory; public MyService(IHttpClientFactory httpClientFactory) { _httpClientFactory = httpClientFactory; } public async Task DoSomethingAsync() { var client = _httpClientFactory.CreateClient("MyTypedClient"); var response = await client.GetAsync("https://example.com/api/resource"); // Process the response } } ``` This setup ensures that every outgoing request made through the named client ("MyTypedClient") will include the current trace ID in its headers, allowing for better tracing and logging across services.

Here's an implementation of a typed `HttpClient` with a `DelegatingHandler` stack that injects the current trace ID from `IHttpContextAccessor` into outgoing headers. ```csharp using Microsoft.AspNetCore.Http; using Microsoft.Extensions.Logging; using System; using System.Net.Http; using System.Threading; using System.Threading.Tasks; public class TraceIdDelegatingHandler : DelegatingHandler { private readonly IHttpContextAccessor _httpContextAccessor; private readonly ILogger<TraceIdDelegatingHandler> _logger; public TraceIdDelegatingHandler(IHttpContextAccessor httpContextAccessor, ILogger<TraceIdDelegatingHandler> logger) { _httpContextAccessor = httpContextAccessor; _logger = logger; } protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) { var httpContext = _httpContextAccessor.HttpContext; if (httpContext != null) { var traceId = httpContext.TraceIdentifier; request.Headers.Add("X-Trace-Id", traceId); _logger.LogInformation($"Added trace ID {traceId} to outgoing request"); } return await base.SendAsync(request, cancellationToken); } } public class TypedHttpClient : IHttpClientFactory { private readonly IHttpClientFactory _httpClientFactory; private readonly IHttpContextAccessor _httpContextAccessor; private readonly ILogger<TypedHttpClient> _logger; public TypedHttpClient(IHttpClientFactory httpClientFactory, IHttpContextAccessor httpContextAccessor, ILogger<TypedHttpClient> logger) { _httpClientFactory = httpClientFactory; _httpContextAccessor = httpContextAccessor; _logger = logger; } public HttpClient CreateClient(string name) { var httpClient = _httpClientFactory.CreateClient(name); var handler = new TraceIdDelegatingHandler(_httpContextAccessor, _logger); httpClient = new HttpClient(handler); return httpClient; } } public class Startup { public void ConfigureServices(IServiceCollection services) { services.AddHttpClient("MyTypedClient") .AddHttpMessageHandler<TraceIdDelegatingHandler>(); services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>(); services.AddSingleton<ILogger<TypedHttpClient>, Logger<TypedHttpClient>>(); services.AddSingleton<IHttpClientFactory, TypedHttpClient>(); } } ``` In this code: * We define a `TraceIdDelegatingHandler` class that inherits from `DelegatingHandler`. This handler injects the current trace ID from `IHttpContextAccessor` into outgoing headers. * We create a `TypedHttpClient` class that implements `IHttpClientFactory`. This class uses the `IHttpClientFactory` to create an instance of `HttpClient` and then wraps it with the `TraceIdDelegatingHandler`. * In the `Startup` class, we configure the services to use the `TypedHttpClient` and add the `TraceIdDelegatingHandler` to the HTTP client pipeline. With this implementation, when you use the `TypedHttpClient` to create an instance of `HttpClient`, it will automatically inject the current trace ID into outgoing headers. **Example usage:** ```csharp public class MyController : Controller { private readonly IHttpClientFactory _httpClientFactory; public MyController(IHttpClientFactory httpClientFactory) { _httpClientFactory = httpClientFactory; } public async Task<IActionResult> Index() { var httpClient = _httpClientFactory.CreateClient("MyTypedClient"); var response = await httpClient.GetAsync("https://example.com"); return Ok(response); } } ``` In this example, when the `Index` action is called, it creates an instance of `HttpClient` using the `TypedHttpClient` and uses it to make a GET request to `https://example.com`. The `TraceIdDelegatingHandler` will automatically inject the current trace ID into the outgoing request headers.