feat: cross-process test log correlation via OTLP receiver

TUnit.Aspire/AspireFixture.cs

@@ -27,6 +27,8 @@ public class AspireFixture<TAppHost> : IAsyncInitializer, IAsyncDisposable
     where TAppHost : class
 {
     private DistributedApplication? _app;
+    private Telemetry.OtlpReceiver? _otlpReceiver;
+    private HttpMessageHandler? _httpHandler;
 
     /// <summary>
     /// The running Aspire distributed application.
@@ -37,12 +39,35 @@ public class AspireFixture<TAppHost> : IAsyncInitializer, IAsyncDisposable
 
     /// <summary>
     /// Creates an <see cref="HttpClient"/> for the named resource.
+    /// When <see cref="EnableTelemetryCollection"/> is <c>true</c>, the returned client
+    /// automatically propagates W3C <c>traceparent</c> and <c>baggage</c> headers
+    /// (including <c>tunit.test.id</c>) to the SUT for cross-process correlation.
+    /// Otherwise, delegates to Aspire's default <c>CreateHttpClient</c>.
     /// </summary>
     /// <param name="resourceName">The name of the resource to connect to.</param>
     /// <param name="endpointName">Optional endpoint name if the resource exposes multiple endpoints.</param>
     /// <returns>An <see cref="HttpClient"/> configured to connect to the resource.</returns>
     public HttpClient CreateHttpClient(string resourceName, string? endpointName = null)
-        => App.CreateHttpClient(resourceName, endpointName);
+    {
+        if (!EnableTelemetryCollection)
+        {
+            return App.CreateHttpClient(resourceName, endpointName);
+        }
+
+        _httpHandler ??= new Http.TUnitBaggagePropagationHandler
+        {
+            InnerHandler = new SocketsHttpHandler
+            {
+                // Match Aspire's CreateHttpClient behavior: trust dev certs for HTTPS resources
+                SslOptions = { RemoteCertificateValidationCallback = (_, _, _, _) => true },
+            },
+        };
+
+        return new HttpClient(_httpHandler, disposeHandler: false)
+        {
+            BaseAddress = App.GetEndpoint(resourceName, endpointName),
+        };
+    }
 
     /// <summary>
     /// Gets the connection string for the named resource.
@@ -140,6 +165,19 @@ protected virtual void ConfigureAppHost(DistributedApplicationOptions options, H
     /// <param name="builder">The distributed application testing builder.</param>
     protected virtual void ConfigureBuilder(IDistributedApplicationTestingBuilder builder) { }
 
+    /// <summary>
+    /// When <c>true</c>, starts an OTLP receiver that collects telemetry from SUT resources
+    /// and routes correlated logs to the originating test's output. SUT resources must have
+    /// OpenTelemetry configured (e.g., via Aspire's standard ServiceDefaults) — no TUnit-specific
+    /// code is needed in the SUT.
+    /// </summary>
+    /// <remarks>
+    /// The receiver overrides <c>OTEL_EXPORTER_OTLP_ENDPOINT</c> on project resources. If the
+    /// Aspire dashboard is enabled, received telemetry is forwarded to the dashboard's original
+    /// OTLP endpoint so both TUnit and the dashboard receive data.
+    /// </remarks>
+    protected virtual bool EnableTelemetryCollection => false;
+
     /// <summary>
     /// Resource wait timeout. Default: 60 seconds.
     /// </summary>
@@ -211,9 +249,24 @@ public virtual async Task InitializeAsync()
     {
         var sw = Stopwatch.StartNew();
 
+        // Start OTLP receiver before building the app so we can inject the endpoint
+        if (EnableTelemetryCollection)
+        {
+            LogProgress("Starting OTLP telemetry receiver...");
+            StartOtlpReceiver();
+            LogProgress($"OTLP receiver listening on port {_otlpReceiver!.Port}");
+        }
+
         LogProgress($"Creating distributed application builder for {typeof(TAppHost).Name}...");
         var builder = await DistributedApplicationTestingBuilder.CreateAsync<TAppHost>(Args, ConfigureAppHost);
         ConfigureBuilder(builder);
+
+        // Configure OTLP endpoint on project resources AFTER user's ConfigureBuilder
+        if (_otlpReceiver is not null)
+        {
+            ConfigureOtlpEndpoints(builder);
+        }
+
         LogProgress($"Builder created in {sw.Elapsed.TotalSeconds:0.0}s");
 
         LogProgress("Building application...");
@@ -295,9 +348,51 @@ public virtual async ValueTask DisposeAsync()
             LogProgress("Application disposed.");
         }
 
+        if (_otlpReceiver is not null)
+        {
+            await _otlpReceiver.DisposeAsync();
+            _otlpReceiver = null;
+        }
+
+        _httpHandler?.Dispose();
+        _httpHandler = null;
+
         GC.SuppressFinalize(this);
     }
 
+    // --- OTLP Telemetry ---
+
+    private const string DashboardOtlpEndpointEnvVar = "DOTNET_DASHBOARD_OTLP_ENDPOINT_URL";
+    private const string OtelExporterEndpointEnvVar = "OTEL_EXPORTER_OTLP_ENDPOINT";
+    private const string OtelExporterProtocolEnvVar = "OTEL_EXPORTER_OTLP_PROTOCOL";
+
+    private void StartOtlpReceiver()
+    {
+        // Check if there's an existing upstream OTLP endpoint (e.g., Aspire dashboard)
+        // that we should forward to after processing.
+        var upstreamEndpoint = Environment.GetEnvironmentVariable(DashboardOtlpEndpointEnvVar);
+        _otlpReceiver = new Telemetry.OtlpReceiver(upstreamEndpoint);
+        _otlpReceiver.Start();
+    }
+
+    private void ConfigureOtlpEndpoints(IDistributedApplicationTestingBuilder builder)
+    {
+        var otlpEndpoint = $"http://127.0.0.1:{_otlpReceiver!.Port}";
+
+        foreach (var resource in builder.Resources)
+        {
+            if (resource is ProjectResource projectResource)
+            {
+                projectResource.Annotations.Add(
+                    new EnvironmentCallbackAnnotation(context =>
+                    {
+                        context.EnvironmentVariables[OtelExporterEndpointEnvVar] = otlpEndpoint;
+                        context.EnvironmentVariables[OtelExporterProtocolEnvVar] = "http/protobuf";
+                    }));
+            }
+        }
+    }
+
     /// <summary>
     /// Monitors resource notification events during startup, logging state transitions
     /// in real time. This provides immediate visibility into issues like health check

TUnit.Aspire/Http/TUnitBaggagePropagationHandler.cs

@@ -0,0 +1,70 @@
+using System.Diagnostics;
+
+namespace TUnit.Aspire.Http;
+
+/// <summary>
+/// DelegatingHandler that propagates <c>traceparent</c>, <c>tracestate</c>, and
+/// <c>baggage</c> W3C headers from <see cref="Activity.Current"/> onto outgoing
+/// HTTP requests. .NET's <c>DiagnosticsHandler</c> (which injects <c>traceparent</c>)
+/// is only present in the <see cref="HttpClient"/> pipeline when using
+/// <c>IHttpClientFactory</c> — it is NOT wired in when constructing
+/// <c>new HttpClient(handler)</c> directly. This handler fills that gap so that both
+/// trace context and <c>tunit.test.id</c> baggage reach the SUT process.
+/// </summary>
+internal sealed class TUnitBaggagePropagationHandler : DelegatingHandler
+{
+    protected override Task<HttpResponseMessage> SendAsync(
+        HttpRequestMessage request, CancellationToken cancellationToken)
+    {
+        if (Activity.Current is { } activity)
+        {
+            // Inject traceparent and tracestate via the default propagator.
+            // This is necessary because DiagnosticsHandler is not in the pipeline
+            // when HttpClient is constructed with an explicit handler.
+            DistributedContextPropagator.Current.Inject(
+                activity,
+                request,
+                static (carrier, key, value) =>
+                {
+                    if (carrier is HttpRequestMessage req)
+                    {
+                        req.Headers.TryAddWithoutValidation(key, value);
+                    }
+                });
+
+            // Inject baggage header if the propagator hasn't already done so.
+            // When OTel SDK is configured with BaggagePropagator, the Inject call
+            // above may have already added a baggage header — avoid duplicates.
+            if (!request.Headers.Contains("baggage"))
+            {
+                var first = true;
+                var sb = new System.Text.StringBuilder();
+
+                foreach (var (key, value) in activity.Baggage)
+                {
+                    if (key is null)
+                    {
+                        continue;
+                    }
+
+                    if (!first)
+                    {
+                        sb.Append(',');
+                    }
+
+                    sb.Append(Uri.EscapeDataString(key));
+                    sb.Append('=');
+                    sb.Append(Uri.EscapeDataString(value ?? string.Empty));
+                    first = false;
+                }
+
+                if (!first)
+                {
+                    request.Headers.TryAddWithoutValidation("baggage", sb.ToString());
+                }
+            }
+        }
+
+        return base.SendAsync(request, cancellationToken);
+    }
+}

TUnit.Aspire/TUnit.Aspire.csproj

@@ -6,6 +6,11 @@
     <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
   </PropertyGroup>
 
+  <!-- Aspire is server-side only — remove browser platform support from Library.props -->
+  <ItemGroup>
+    <SupportedPlatform Remove="browser" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\TUnit\TUnit.csproj" />
   </ItemGroup>