Fix MaxExternalSpansPerTest cap bypass when Activity.Parent chain is …

…broken

When libraries like Npgsql use async connection pooling, Activity.Parent
may be null/broken by the time OnActivityStopped fires, causing
FindTestCaseAncestor to return null and external spans to bypass the cap.

Three-layer fix:
1. Register test case span IDs on ActivityStarted (before children stop)
2. Fallback in FindTestCaseAncestor to check ParentSpanId against known
   test case span IDs when Activity.Parent walk fails
3. Per-trace cap as ultimate safety net for completely broken chains

Agent-Logs-Url: https://github.com/thomhurst/TUnit/sessions/1c7f9e0c-eca2-4452-a1b9-b94f99ac238c

Co-authored-by: thomhurst <30480171+thomhurst@users.noreply.github.com>

TUnit.Engine/Reporters/Html/ActivityCollector.cs

@@ -15,6 +15,12 @@ internal sealed class ActivityCollector : IDisposable
     private readonly ConcurrentDictionary<string, ConcurrentQueue<SpanData>> _spansByTrace = new();
     // Track external span count per test case (keyed by test case span ID)
     private readonly ConcurrentDictionary<string, int> _externalSpanCountsByTest = new();
+    // Fallback: per-trace cap for external spans whose parent chain is broken
+    // (e.g. Npgsql async pooling where Activity.Parent is null but traceId is correct)
+    private readonly ConcurrentDictionary<string, int> _externalSpanCountsByTrace = new();
+    // Known test case span IDs, populated at activity start time so they're available
+    // before child spans stop (children stop before parents in Activity ordering).
+    private readonly ConcurrentDictionary<string, byte> _testCaseSpanIds = new();
     // Fast-path cache of trace IDs that should be collected. Subsumes TraceRegistry lookups
     // so that subsequent activities on the same trace avoid cross-class dictionary checks.
     private readonly ConcurrentDictionary<string, byte> _knownTraceIds = new(StringComparer.OrdinalIgnoreCase);
@@ -31,6 +37,7 @@ public void Start()
             ShouldListenTo = static _ => true,
             Sample = SampleActivity,
             SampleUsingParentId = SampleActivityUsingParentId,
+            ActivityStarted = OnActivityStarted,
             ActivityStopped = OnActivityStopped
         };
 
@@ -141,8 +148,20 @@ public SpanData[] GetAllSpans()
         return lookup;
     }
 
-    private static string? FindTestCaseAncestor(Activity activity)
+    private void OnActivityStarted(Activity activity)
     {
+        // Register test case span IDs early so they're available for child span lookups.
+        // Children stop before parents in Activity ordering, so we need this pre-registered.
+        if (IsTUnitSource(activity.Source.Name) &&
+            activity.GetTagItem("tunit.test.node_uid") is not null)
+        {
+            _testCaseSpanIds.TryAdd(activity.SpanId.ToString(), 0);
+        }
+    }
+
+    private string? FindTestCaseAncestor(Activity activity)
+    {
+        // First: walk in-memory parent chain (works when parent Activity is alive)
         var current = activity.Parent;
         while (current is not null)
         {
@@ -155,6 +174,18 @@ public SpanData[] GetAllSpans()
             current = current.Parent;
         }
 
+        // Fallback: check if ParentSpanId is a known test case span.
+        // This handles broken Activity.Parent chains (e.g. Npgsql async pooling)
+        // where the W3C ParentSpanId is still correct.
+        if (activity.ParentSpanId != default)
+        {
+            var parentSpanId = activity.ParentSpanId.ToString();
+            if (_testCaseSpanIds.ContainsKey(parentSpanId))
+            {
+                return parentSpanId;
+            }
+        }
+
         return null;
     }
 
@@ -217,7 +248,16 @@ private void OnActivityStopped(Activity activity)
                     return;
                 }
             }
-            // External spans not under any test (e.g., fixture/infrastructure setup) are uncapped
+            else
+            {
+                // Fallback cap by trace ID to prevent unbounded growth for spans
+                // with broken parent chains (e.g., Npgsql async connection pooling).
+                var count = _externalSpanCountsByTrace.AddOrUpdate(traceId, 1, (_, c) => c + 1);
+                if (count > MaxExternalSpansPerTest)
+                {
+                    return;
+                }
+            }
         }
 
         var queue = _spansByTrace.GetOrAdd(traceId, _ => new ConcurrentQueue<SpanData>());