test: release HTTP keep-alive span retainers, raise baseline to 10

The dominant span retainer on HTTP-server suites is Node's per-connection
keep-alive/headers `Timeout`: under AsyncContextFrame its callback closes over
the `{ ...store, span }` frame active when the request ran and stays in the
active-timer list, reachable from the still-open `Server`, until it fires. That
pinned a fixed handful of finished spans at teardown on every express, fastify,
koa, connect, and AppSec/IAST suite, so each raised its own baseline for benign
non-scaling residue.

Release it at the source: at agent teardown, before forcing GC, call
`closeIdleConnections()` on every live server (Node >=18.2; drops only sockets
with no in-flight request). The default baseline moves 3 -> 10 to absorb the
recency-bounded residue that survives. 10 is an absolute cap, not a per-request
allowance, so a #9227-style leak still retains one span per request and blows
past it by orders of magnitude — the margin costs no detection power.

Refs: #9227

Author: BridgeAR

packages/dd-trace/test/plugins/span-leak-detector.js

@@ -44,24 +44,52 @@ const MAX_GC_CYCLES = 10
 
 /**
  * Default upper bound on finished spans that may still be reachable at teardown
- * without indicating a leak. Benign retention is the handful of most-recent
- * traces whose async-context frames have not been overwritten yet (see above); a
- * sweep of the http/http2 suites topped out at two, so this is that measured
- * maximum plus one slot of margin. It is an absolute cap, not a per-request
- * allowance: a #9227-style leak retains one span per request and blows past it by
- * orders of magnitude, so the margin costs no detection power.
+ * without indicating a leak. Benign retention has two sources: the handful of
+ * most-recent traces whose async-context frames have not been overwritten yet
+ * (see above), and the small residue that survives `releaseKeepAliveRetainers`
+ * on HTTP-server suites (a middleware `next` closure still holding the last
+ * request's `req`). Both are recency-bounded, not per-request: an http-suite
+ * sweep tops out at a handful, so 10 covers it with margin. It is an absolute
+ * cap, not a per-request allowance — a #9227-style leak retains one span per
+ * request and blows past 10 by orders of magnitude, so the margin costs no
+ * detection power.
  *
  * A few suites exercise upstream libraries that pin a *fixed* number of finished
- * spans regardless of request count — e.g. `@grpc/grpc-js` keeps a cleared
- * `Timeout` on each pooled `Subchannel`, and under AsyncContextFrame that timer
- * retains the `{ ...store, span }` frame active when the subchannel was built.
- * That retention does not scale, so it is not the leak this detector hunts, but
- * it does exceed the default. Those suites raise the bound with
- * {@link SpanLeakDetector#setBaseline} in a `before` hook and restore it with
- * {@link SpanLeakDetector#resetBaseline} in `after`, so every other suite keeps
- * the tight default.
+ * spans regardless of request count, through a retainer `closeIdleConnections`
+ * cannot reach — e.g. `@grpc/grpc-js` keeps a cleared `Timeout` on each pooled
+ * `Subchannel`, and under AsyncContextFrame that timer retains the
+ * `{ ...store, span }` frame active when the subchannel was built. That retention
+ * does not scale, but it exceeds the default, so those suites raise the bound
+ * with {@link SpanLeakDetector#withSpanLeakBaseline}, keeping the tight default
+ * for every other suite.
  */
-const BASELINE_RETAINED = 3
+const BASELINE_RETAINED = 10
+
+/**
+ * Close idle connections on every live HTTP/net server so their per-connection
+ * keep-alive timers stop pinning finished spans. Node arms a keep-alive/headers
+ * `Timeout` per connection; under AsyncContextFrame that timer's callback closes
+ * over the `{ ...store, span }` frame active when the request ran, and it stays in
+ * the active-timer list — reachable from the still-open `Server` — until it fires.
+ * That is the dominant retainer for HTTP-server suites (express, fastify, koa,
+ * connect, the AppSec/IAST specs). Releasing it at the source lets those suites
+ * keep the tight default instead of each raising a baseline for benign residue.
+ *
+ * Best-effort: `_getActiveHandles` is internal and its entries vary by Node
+ * version, so guard every access. `closeIdleConnections` (Node >=18.2) only drops
+ * sockets with no in-flight request, so it never interrupts real work; the
+ * assertion runs at agent teardown, after the suite's requests have completed.
+ *
+ * @returns {void}
+ */
+function releaseKeepAliveRetainers () {
+  const handles = process._getActiveHandles?.()
+  if (handles === undefined) return
+
+  for (const handle of handles) {
+    handle?.closeIdleConnections?.()
+  }
+}
 
 class SpanLeakDetector {
   #registry
@@ -166,6 +194,8 @@ class SpanLeakDetector {
       return
     }
 
+    releaseKeepAliveRetainers()
+
     // Let any pending flush / microtasks settle, then force GC and give the
     // registry callbacks a turn. Repeat until retention is within the baseline or
     // the cycle budget is spent (polling because FinalizationRegistry callbacks

packages/dd-trace/test/plugins/span-leak-detector.spec.js

@@ -17,12 +17,14 @@ if (typeof global.gc !== 'function') {
 // grows with the request count must be reported as a leak, while the small,
 // recency-bounded baseline (the few most-recent traces whose async-context frames
 // have not been overwritten yet) must pass. The detector tolerates up to
-// BASELINE_RETAINED (3) survivors — a measured maximum of two across the http
-// suites plus one slot of margin — so the boundary cases below pin 3 (accepted)
-// and 4 (the first rejected). Uses fresh detector instances (not the agent
-// singleton) so every outcome can be asserted without a real teardown.
-
-const BASELINE_RETAINED = 3
+// BASELINE_RETAINED (10) survivors — the residual left after `closeIdleConnections`
+// releases the HTTP keep-alive retainer, still small enough that a real
+// one-span-per-request leak (dozens–hundreds) trips it — so the boundary cases
+// below pin 10 (accepted) and 11 (the first rejected). Uses fresh detector
+// instances (not the agent singleton) so every outcome can be asserted without a
+// real teardown.
+
+const BASELINE_RETAINED = 10
 
 async function forceGc () {
   for (let i = 0; i < 10; i++) {