fix(aspnetcore): fall back to Activity.Current (#5572)

Keep traceparent and baggage propagation working when the
synthetic TUnit.AspNetCore.Http span is not created.

Also align the ASP.NET Core and OpenTelemetry docs with the
current root-per-test trace model and CreateClient() guidance.

Author: thomhurst

.github/pr-assets/5572/jaeger-search-ui.png

@@ -71,6 +71,7 @@
     <PackageVersion Include="OpenTelemetry.Exporter.OpenTelemetryProtocol" Version="1.15.2" />
     <PackageVersion Include="OpenTelemetry.Extensions.Hosting" Version="1.15.2" />
     <PackageVersion Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.15.1" />
+    <PackageVersion Include="OpenTelemetry.Instrumentation.Http" Version="1.15.0" />
     <PackageVersion Include="NUnit" Version="4.5.1" />
     <PackageVersion Include="NUnit.Analyzers" Version="4.12.0" />
     <PackageVersion Include="NUnit3TestAdapter" Version="6.2.0" />

.github/pr-assets/5572/jaeger-trace-demo-search.png

@@ -16,33 +16,42 @@ internal sealed class ActivityPropagationHandler : DelegatingHandler
     // cleaned up on process exit. Not disposed explicitly because multiple handler
     // instances share this source across concurrent tests.
     private static readonly ActivitySource HttpActivitySource = new("TUnit.AspNetCore.Http");
+    private readonly Func<HttpRequestMessage, Activity?> _startActivity;
+
+    public ActivityPropagationHandler()
+    {
+        _startActivity = StartHttpActivity;
+    }
+
+    internal ActivityPropagationHandler(Func<HttpRequestMessage, Activity?> startActivity)
+    {
+        _startActivity = startActivity;
+    }
 
     protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
     {
-        var path = request.RequestUri?.AbsolutePath ?? request.RequestUri?.ToString() ?? "unknown";
-        using var activity = HttpActivitySource.StartActivity(
-            $"HTTP {request.Method} {path}",
-            ActivityKind.Client);
+        var ambientActivity = Activity.Current;
+        using var activity = _startActivity(request);
 
         if (activity is not null)
         {
             activity.SetTag("http.request.method", request.Method.Method);
             activity.SetTag("url.full", request.RequestUri?.ToString());
             activity.SetTag("server.address", request.RequestUri?.Host);
 
-            // Inject trace context headers (traceparent + tracestate) so the server
-            // creates child activities under the same trace
-            DistributedContextPropagator.Current.Inject(activity, request.Headers,
-                static (headers, key, value) =>
-                {
-                    if (headers is HttpRequestHeaders h)
-                    {
-                        h.Remove(key);
-                        h.TryAddWithoutValidation(key, value);
-                    }
-                });
+            // WebApplicationFactory bypasses DiagnosticsHandler, so when we synthesize
+            // a client span we also need to flow the ambient baggage onto it explicitly.
+            // Child Activities do not reliably surface parent baggage across all target
+            // frameworks, but correlation relies on the test's baggage being propagated.
+            CopyBaggage(ambientActivity, activity);
         }
 
+        // Propagate the current distributed trace even when the helper span is not
+        // created (for example, when no listener is attached to TUnit.AspNetCore.Http).
+        var propagationActivity = activity ?? ambientActivity;
+        InjectTraceContext(propagationActivity, request.Headers);
+        InjectBaggage(propagationActivity, request.Headers);
+
         var response = await base.SendAsync(request, cancellationToken);
 
         if (activity is not null)
@@ -56,4 +65,66 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
 
         return response;
     }
+
+    private static Activity? StartHttpActivity(HttpRequestMessage request)
+    {
+        var path = request.RequestUri?.AbsolutePath ?? request.RequestUri?.ToString() ?? "unknown";
+        return HttpActivitySource.StartActivity(
+            $"HTTP {request.Method} {path}",
+            ActivityKind.Client);
+    }
+
+    private static void InjectTraceContext(Activity? activity, HttpRequestHeaders headers)
+    {
+        if (activity is null)
+        {
+            return;
+        }
+
+        // Inject trace context headers (traceparent + tracestate) so the server
+        // creates child activities under the same trace. Respect pre-existing headers
+        // so callers who explicitly set their own context win.
+        DistributedContextPropagator.Current.Inject(activity, headers,
+            static (targetHeaders, key, value) =>
+            {
+                if (targetHeaders is HttpRequestHeaders h && key is not null && !h.Contains(key))
+                {
+                    h.TryAddWithoutValidation(key, value);
+                }
+            });
+    }
+
+    private static void CopyBaggage(Activity? source, Activity destination)
+    {
+        if (source is null || ReferenceEquals(source, destination))
+        {
+            return;
+        }
+
+        foreach (var (key, value) in source.Baggage)
+        {
+            if (key is null || destination.GetBaggageItem(key) is not null)
+            {
+                continue;
+            }
+
+            destination.SetBaggage(key, value);
+        }
+    }
+
+    private static void InjectBaggage(Activity? activity, HttpRequestHeaders headers)
+    {
+        // If a propagator already emitted W3C baggage (e.g. OTel SDK's BaggagePropagator),
+        // preserve it; otherwise emit our own so LegacyPropagator-based stacks still
+        // propagate test correlation baggage.
+        if (activity is null || headers.Contains("baggage"))
+        {
+            return;
+        }
+
+        if (TUnit.Core.TUnitActivitySource.TryBuildBaggageHeader(activity) is { } baggage)
+        {
+            headers.TryAddWithoutValidation("baggage", baggage);
+        }
+    }
 }

.github/pr-assets/5572/jaeger-trace-demo-waterfall.png

@@ -10,6 +10,7 @@
 
   <ItemGroup>
     <InternalsVisibleTo Include="TUnit.AspNetCore" />
+    <InternalsVisibleTo Include="TUnit.AspNetCore.Tests" />
   </ItemGroup>
 
   <ItemGroup>

.github/pr-assets/5572/jaeger-trace-ui.png

@@ -0,0 +1,113 @@
+using System.Diagnostics;
+using TUnit.Assertions;
+using TUnit.Assertions.Extensions;
+using TUnit.Core;
+
+namespace TUnit.AspNetCore.Tests;
+
+public class ActivityPropagationHandlerTests
+{
+    [Test]
+    public async Task SendAsync_InjectsTraceContext_WhenHelperSpanIsCreated()
+    {
+        Activity.Current = null;
+        using var listenerScope = new ActivityListenerScope();
+        using var activity = new Activity("test-root").Start();
+        activity.SetBaggage(TUnitActivitySource.TagTestId, "my-test-context-id");
+
+        var captured = new CaptureHandler();
+        var handler = CreateHandler();
+        handler.InnerHandler = captured;
+        using var client = new HttpClient(handler);
+
+        await client.GetAsync("http://localhost/test");
+
+        var traceparent = captured.LastRequest!.Headers.GetValues("traceparent").First();
+        var parts = traceparent.Split('-');
+        var baggageHeader = captured.LastRequest.Headers.GetValues("baggage").First();
+
+        await Assert.That(parts[1]).IsEqualTo(activity.TraceId.ToString());
+        await Assert.That(parts[2]).IsNotEqualTo(activity.SpanId.ToString());
+        await Assert.That(baggageHeader).Contains(TUnitActivitySource.TagTestId);
+        await Assert.That(baggageHeader).Contains("my-test-context-id");
+    }
+
+    [Test]
+    public async Task SendAsync_FallsBackToActivityCurrent_WhenHelperSpanIsNotCreated()
+    {
+        Activity.Current = null;
+        using var activity = new Activity("test-root").Start();
+        activity.SetBaggage(TUnitActivitySource.TagTestId, "my-test-context-id");
+
+        var captured = new CaptureHandler();
+        var handler = CreateHandler(static _ => null);
+        handler.InnerHandler = captured;
+        using var client = new HttpClient(handler);
+
+        await client.GetAsync("http://localhost/test");
+
+        var traceparent = captured.LastRequest!.Headers.GetValues("traceparent").First();
+        var parts = traceparent.Split('-');
+        var baggageHeader = captured.LastRequest.Headers.GetValues("baggage").First();
+
+        await Assert.That(parts[1]).IsEqualTo(activity.TraceId.ToString());
+        await Assert.That(parts[2]).IsEqualTo(activity.SpanId.ToString());
+        await Assert.That(baggageHeader).Contains(TUnitActivitySource.TagTestId);
+        await Assert.That(baggageHeader).Contains("my-test-context-id");
+    }
+
+    [Test]
+    public async Task SendAsync_DoesNotInjectTraceContext_WhenNoAmbientActivityExists()
+    {
+        Activity.Current = null;
+
+        var captured = new CaptureHandler();
+        var handler = CreateHandler(static _ => null);
+        handler.InnerHandler = captured;
+        using var client = new HttpClient(handler);
+
+        await client.GetAsync("http://localhost/test");
+
+        await Assert.That(captured.LastRequest!.Headers.Contains("traceparent")).IsFalse();
+        await Assert.That(captured.LastRequest.Headers.Contains("baggage")).IsFalse();
+    }
+
+    private static DelegatingHandler CreateHandler(Func<HttpRequestMessage, Activity?>? startActivity = null)
+    {
+        return startActivity is null
+            ? new ActivityPropagationHandler()
+            : new ActivityPropagationHandler(startActivity);
+    }
+
+    private sealed class ActivityListenerScope : IDisposable
+    {
+        private readonly ActivityListener _listener = new()
+        {
+            ShouldListenTo = static source => source.Name == "TUnit.AspNetCore.Http",
+            Sample = static (ref ActivityCreationOptions<ActivityContext> _) =>
+                ActivitySamplingResult.AllDataAndRecorded
+        };
+
+        public ActivityListenerScope()
+        {
+            ActivitySource.AddActivityListener(_listener);
+        }
+
+        public void Dispose()
+        {
+            _listener.Dispose();
+        }
+    }
+
+    private sealed class CaptureHandler : HttpMessageHandler
+    {
+        public HttpRequestMessage? LastRequest { get; private set; }
+
+        protected override Task<HttpResponseMessage> SendAsync(
+            HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            LastRequest = request;
+            return Task.FromResult(new HttpResponseMessage(System.Net.HttpStatusCode.OK));
+        }
+    }
+}