fix: also memoize sub-channels of native tracingChannel(name)

On Node versions where the GC bug exists AND tracingChannel is native
(Node 16.17+/18.7+ through 20.5), tracingChannel(name) creates its
five sub-channels by calling Node's internal channel() registry
directly — bypassing dc.channel's memoization. So a publisher
capturing tracingChannel(name).start in a closure can end up with a
different Channel than a subscriber attaching via dc.channel(
'tracing:name:start').subscribe(...) for the same name.

Wrap dc.tracingChannel on those versions to construct the
TracingChannel via the {start, end, ...} object form, supplying
memoized sub-channels from dc.channel. Native tracingChannel accepts
this form, so the result is a real native TracingChannel with stable
sub-channel identity.

The wrap is applied unconditionally inside this patch (which itself is
only loaded when hasGarbageCollectionBug() is true). For
!hasTracingChannel versions, the polyfill in patch-tracing-channel.js
runs after this and overwrites dc.tracingChannel — that path already
captures dc.channel transitively, so the polyfilled tracingChannel
inherits the memoization. No coverage gap on either side.

Three new test cases pin the contract — all six sub-channel-stability
assertions fail on the prior version (channel-only memoization),
all sixteen pass with this commit. Object-form tracingChannel input
is passed through unchanged.

Author: bm1549

patch-garbage-collection-bug.js

@@ -9,6 +9,7 @@ const {
 
 module.exports = function(unpatched) {
   const dc_channel = unpatched.channel;
+  const dc_tracingChannel = unpatched.tracingChannel;
   const channels = new WeakSet();
   const byName = new Map();
 
@@ -43,5 +44,28 @@ module.exports = function(unpatched) {
     return ch;
   };
 
+  // tracingChannel(name) on affected versions where it's native (Node 16.17+/18.7+)
+  // bypasses dc.channel above: native tracingChannel uses Node's internal channel()
+  // registry directly, so its sub-channels (start/end/asyncStart/asyncEnd/error)
+  // can still diverge from each other and from a bare dc.channel(name) lookup for
+  // the same name. Construct the TracingChannel from the memoized dc.channel results
+  // via the {start, end, ...} form so all paths see the same Channel identity.
+  // (When the polyfill in patch-tracing-channel.js runs later — for !hasTracingChannel
+  // versions — it overwrites this; that path already captures dc.channel transitively.)
+  if (typeof dc_tracingChannel === 'function') {
+    dc.tracingChannel = function tracingChannel(nameOrChannels) {
+      if (typeof nameOrChannels !== 'string') {
+        return dc_tracingChannel.call(this, nameOrChannels);
+      }
+      return dc_tracingChannel.call(this, {
+        start: dc.channel(`tracing:${nameOrChannels}:start`),
+        end: dc.channel(`tracing:${nameOrChannels}:end`),
+        asyncStart: dc.channel(`tracing:${nameOrChannels}:asyncStart`),
+        asyncEnd: dc.channel(`tracing:${nameOrChannels}:asyncEnd`),
+        error: dc.channel(`tracing:${nameOrChannels}:error`),
+      });
+    };
+  }
+
   return dc;
 };

test/garbage-collection-patch.spec.js

@@ -63,6 +63,75 @@ test('garbage-collection patch: distinct names get distinct Channel objects', t
   t.end();
 });
 
+// Mock that also exposes a native-tracingChannel-like function. Native
+// tracingChannel(name) creates 5 sub-channels by calling the underlying
+// channel() function once for each sub-channel — so it inherits whatever
+// non-stability that channel() has. The patch needs to wrap tracingChannel
+// to feed memoized channels in instead.
+function mockUnpatchedWithTracingChannel() {
+  const base = mockUnpatched();
+  function tracingChannel(nameOrChannels) {
+    if (typeof nameOrChannels === 'string') {
+      // Mimic native: call channel() for each sub-channel name. With our
+      // mock channel() returning fresh objects every call, sub-channels
+      // diverge across two tracingChannel(name) calls without the patch.
+      return {
+        start: base.channel(`tracing:${nameOrChannels}:start`),
+        end: base.channel(`tracing:${nameOrChannels}:end`),
+        asyncStart: base.channel(`tracing:${nameOrChannels}:asyncStart`),
+        asyncEnd: base.channel(`tracing:${nameOrChannels}:asyncEnd`),
+        error: base.channel(`tracing:${nameOrChannels}:error`)
+      };
+    }
+    return { ...nameOrChannels };
+  }
+  return Object.assign(base, { tracingChannel });
+}
+
+test('garbage-collection patch: native tracingChannel sub-channels are stable per name', t => {
+  const { channel, tracingChannel } = mockUnpatchedWithTracingChannel();
+  const dc = patch({ channel, tracingChannel });
+
+  const a = dc.tracingChannel('foo');
+  const b = dc.tracingChannel('foo');
+
+  t.strictEqual(a.start, b.start, 'tracingChannel(name).start stable across calls');
+  t.strictEqual(a.end, b.end, 'tracingChannel(name).end stable across calls');
+  t.strictEqual(a.asyncStart, b.asyncStart, 'tracingChannel(name).asyncStart stable across calls');
+  t.strictEqual(a.asyncEnd, b.asyncEnd, 'tracingChannel(name).asyncEnd stable across calls');
+  t.strictEqual(a.error, b.error, 'tracingChannel(name).error stable across calls');
+
+  t.end();
+});
+
+test('garbage-collection patch: tracingChannel sub-channels match bare channel() lookups for the same name', t => {
+  // The bug surface dd-trace's instrumentation hits: a publisher captures
+  // tracingChannel(name).start in a closure, while a subscriber attaches
+  // via dc.channel('tracing:name:start').subscribe(...). Without the patch,
+  // those two see different Channel objects and never communicate.
+  const { channel, tracingChannel } = mockUnpatchedWithTracingChannel();
+  const dc = patch({ channel, tracingChannel });
+
+  const tc = dc.tracingChannel('observable');
+  const bareStart = dc.channel('tracing:observable:start');
+
+  t.strictEqual(tc.start, bareStart, 'tracingChannel.start === channel("tracing:name:start")');
+  t.end();
+});
+
+test('garbage-collection patch: tracingChannel({channels}) form is passed through unchanged', t => {
+  const { channel, tracingChannel } = mockUnpatchedWithTracingChannel();
+  const dc = patch({ channel, tracingChannel });
+
+  const start = dc.channel('manual:start');
+  const end = dc.channel('manual:end');
+  const tc = dc.tracingChannel({ start, end });
+
+  t.strictEqual(tc.start, start, 'object-form start preserved');
+  t.strictEqual(tc.end, end, 'object-form end preserved');
+  t.end();
+});
+
 test('garbage-collection patch: subscribers attach to the memoized Channel and receive publishes', t => {
   // This is the end-to-end shape the bug produces: the publisher captures
   // a Channel from one call, the subscriber attaches via a later call.