lib,test: propagate bypass context through TracingChannel trace methods

Signed-off-by: Divyanshu Sharma <divyanshu88999@gmail.com>

Author: DivyanshuX9

lib/diagnostics_channel.js

@@ -552,6 +552,7 @@ function boundedChannel(nameOrChannels) {
 class TracingChannel {
   #callWindow;
   #continuationWindow;
+  #bypassIds = null;
 
   constructor(nameOrChannels) {
     // Create a BoundedChannel for start/end (call window)
@@ -601,7 +602,23 @@ class TracingChannel {
       this.error?.hasSubscribers;
   }
 
+  #allBypassed() {
+    const activeKeys = bypassStorage?.getStore();
+    if (!activeKeys) return false;
+    const ids = this.#bypassIds;
+    if (ids === null) return false;
+    for (const id of ids) {
+      if (activeKeys.has(id)) return true;
+    }
+    return false;
+  }
+
   subscribe(handlers, options) {
+    if (options?.bypassId !== undefined) {
+      if (this.#bypassIds === null) this.#bypassIds = new SafeSet();
+      this.#bypassIds.add(options.bypassId);
+    }
+
     // Subscribe to call window (start/end)
     if (handlers.start || handlers.end) {
       this.#callWindow.subscribe({
@@ -658,7 +675,7 @@ class TracingChannel {
   }
 
   traceSync(fn, context = {}, thisArg, ...args) {
-    if (!this.hasSubscribers) {
+    if (!this.hasSubscribers || this.#allBypassed()) {
       return ReflectApply(fn, thisArg, args);
     }
 
@@ -678,7 +695,7 @@ class TracingChannel {
   }
 
   tracePromise(fn, context = {}, thisArg, ...args) {
-    if (!this.hasSubscribers) {
+    if (!this.hasSubscribers || this.#allBypassed()) {
       const result = ReflectApply(fn, thisArg, args);
       if (typeof result?.then !== 'function') {
         emitNonThenableWarning(fn);
@@ -733,7 +750,7 @@ class TracingChannel {
   }
 
   traceCallback(fn, position = -1, context = {}, thisArg, ...args) {
-    if (!this.hasSubscribers) {
+    if (!this.hasSubscribers || this.#allBypassed()) {
       return ReflectApply(fn, thisArg, args);
     }
 

test/parallel/test-diagnostics-channel-bypass.js

@@ -209,3 +209,99 @@ const { AsyncLocalStorage } = require('async_hooks');
   }), receiver, 'a', 'b');
   assert.strictEqual(result, 42);
 }
+
+// Test 11: TracingChannel traceSync respects bypass
+{
+  const { tracingChannel } = require('node:diagnostics_channel');
+  const key = Symbol('tracing-sync');
+  const tc = tracingChannel('test-bypass-tracing-sync');
+  const startHandler = common.mustNotCall();
+  const endHandler = common.mustNotCall();
+  const errorHandler = common.mustNotCall();
+
+  tc.subscribe({
+    start: startHandler,
+    end: endHandler,
+    error: errorHandler,
+  }, { bypassId: key });
+
+  bypass(key, common.mustCall(() => {
+    tc.traceSync(common.mustCall(), {});
+  }));
+
+  tc.unsubscribe({
+    start: startHandler,
+    end: endHandler,
+    error: errorHandler,
+  });
+}
+
+// Test 12: TracingChannel tracePromise respects bypass
+{
+  const { tracingChannel } = require('node:diagnostics_channel');
+  const key = Symbol('tracing-promise');
+  const tc = tracingChannel('test-bypass-tracing-promise');
+  const startHandler = common.mustNotCall();
+  const endHandler = common.mustNotCall();
+  const asyncStartHandler = common.mustNotCall();
+  const asyncEndHandler = common.mustNotCall();
+  const done = common.mustCall();
+
+  tc.subscribe({
+    start: startHandler,
+    end: endHandler,
+    asyncStart: asyncStartHandler,
+    asyncEnd: asyncEndHandler,
+  }, { bypassId: key });
+
+  bypass(key, common.mustCall(() => {
+    return tc.tracePromise(common.mustCall(() => Promise.resolve(42)), {});
+  })).then(common.mustCall(() => {
+    tc.unsubscribe({
+      start: startHandler,
+      end: endHandler,
+      asyncStart: asyncStartHandler,
+      asyncEnd: asyncEndHandler,
+    });
+    done();
+  }));
+}
+
+// Test 13: TracingChannel traceCallback respects bypass
+{
+  const { tracingChannel } = require('node:diagnostics_channel');
+  const key = Symbol('tracing-callback');
+  const tc = tracingChannel('test-bypass-tracing-callback');
+  const startHandler = common.mustNotCall();
+  const endHandler = common.mustNotCall();
+  const asyncStartHandler = common.mustNotCall();
+  const asyncEndHandler = common.mustNotCall();
+  const done = common.mustCall();
+
+  tc.subscribe({
+    start: startHandler,
+    end: endHandler,
+    asyncStart: asyncStartHandler,
+    asyncEnd: asyncEndHandler,
+  }, { bypassId: key });
+
+  bypass(key, common.mustCall(() => {
+    tc.traceCallback(
+      common.mustCall((cb) => setImmediate(cb, null, 'result')),
+      -1,
+      {},
+      null,
+      common.mustCall((err, res) => {
+        assert.strictEqual(err, null);
+        assert.strictEqual(res, 'result');
+        tc.unsubscribe({
+          start: startHandler,
+          end: endHandler,
+          asyncStart: asyncStartHandler,
+          asyncEnd: asyncEndHandler,
+        });
+        done();
+      })
+    );
+  }));
+}