lib,test: rename suppressed/subscriberId to bypass/bypassId in diagnostics_channel

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

Author: DivyanshuX9

lib/diagnostics_channel.js

@@ -36,18 +36,18 @@ const { subscribers: subscriberCounts } = dc_binding;
 const { WeakReference } = require('internal/util');
 const { isPromise } = require('internal/util/types');
 
-let suppressionStorage;
+let bypassStorage;
 
-function getSuppressionsStorage() {
-  if (suppressionStorage === undefined) {
+function getBypassStorage() {
+  if (bypassStorage === undefined) {
     const { AsyncLocalStorage } = require('async_hooks');
-    suppressionStorage = new AsyncLocalStorage();
+    bypassStorage = new AsyncLocalStorage();
   }
-  return suppressionStorage;
+  return bypassStorage;
 }
 
 function withSuppressionsContext(set, fn, thisArg, args) {
-  return getSuppressionsStorage().run(
+  return getBypassStorage().run(
     set,
     () => ReflectApply(fn, thisArg, args),
   );
@@ -125,7 +125,7 @@ class RunStoresScope {
     // eslint-disable-next-line no-restricted-globals
     using stack = new DisposableStack();
 
-    // Normal stores - exactly as before, zero extra cost
+    // Normal stores, unchanged from before.
     if (activeChannel._stores) {
       for (const entry of activeChannel._stores.entries()) {
         const store = entry[0];
@@ -145,13 +145,13 @@ class RunStoresScope {
       }
     }
 
-    // Bypass stores - only entered if bypass stores exist
+    // Bypass stores, only checked when bypass stores exist.
     if (activeChannel._bypassStores) {
-      const activeKeys = getSuppressionsStorage().getStore();
+      const activeKeys = getBypassStorage().getStore();
       for (const entry of activeChannel._bypassStores.entries()) {
         const store = entry[0];
-        const { transform, subscriberId } = entry[1];
-        if (activeKeys?.has(subscriberId)) continue;
+        const { transform, bypassId } = entry[1];
+        if (activeKeys?.has(bypassId)) continue;
         let newContext = data;
         if (transform) {
           try {
@@ -183,18 +183,18 @@ class RunStoresScope {
 class ActiveChannel {
   subscribe(subscription, options = {}) {
     validateFunction(subscription, 'subscription');
-    const subscriberId = options?.subscriberId;
+    const bypassId = options?.bypassId;
 
-    if (subscriberId !== undefined) {
-      validateBypassKey(subscriberId, 'subscriberId');
-      // Bypass path - lazy separate array
+    if (bypassId !== undefined) {
+      validateBypassKey(bypassId, 'bypassId');
+      // Bypass path, lazy separate array only allocated when needed.
       if (this._bypassSubscribers === null) {
         this._bypassSubscribers = [];
       }
       this._bypassSubscribers = ArrayPrototypeSlice(this._bypassSubscribers);
-      ArrayPrototypePush(this._bypassSubscribers, { handler: subscription, subscriberId });
+      ArrayPrototypePush(this._bypassSubscribers, { handler: subscription, bypassId });
     } else {
-      // Normal path - plain function, zero extra cost
+      // Normal path, plain function call with no extra overhead.
       this._subscribers = ArrayPrototypeSlice(this._subscribers);
       ArrayPrototypePush(this._subscribers, subscription);
     }
@@ -252,11 +252,11 @@ class ActiveChannel {
   }
 
   bindStore(store, transform, options = {}) {
-    const subscriberId = options?.subscriberId;
+    const bypassId = options?.bypassId;
 
-    if (subscriberId !== undefined) {
-      validateBypassKey(subscriberId, 'subscriberId');
-      // Bypass path - lazy separate SafeMap
+    if (bypassId !== undefined) {
+      validateBypassKey(bypassId, 'bypassId');
+      // Bypass path, lazy separate SafeMap only allocated when needed.
       if (this._bypassStores === null) {
         this._bypassStores = new SafeMap();
       }
@@ -265,9 +265,9 @@ class ActiveChannel {
         channels.incRef(this.name);
         if (this._index !== undefined) subscriberCounts[this._index]++;
       }
-      this._bypassStores.set(store, { transform, subscriberId });
+      this._bypassStores.set(store, { transform, bypassId });
     } else {
-      // Normal path - plain transform, zero extra cost
+      // Normal path, plain transform with no extra overhead.
       const replacing = this._stores.has(store);
       if (!replacing) {
         channels.incRef(this.name);
@@ -305,7 +305,7 @@ class ActiveChannel {
   }
 
   publish(data) {
-    // Normal path - no ALS lookup, plain function call, zero overhead
+    // Normal path, no ALS lookup, plain function call, zero overhead.
     const subscribers = this._subscribers;
     for (let i = 0; i < subscribers.length; i++) {
       try {
@@ -317,14 +317,14 @@ class ActiveChannel {
       }
     }
 
-    // Bypass path - only entered if bypass subscribers exist
+    // Bypass path, only entered if bypass subscribers exist.
     if (this._bypassSubscribers !== null) {
-      const activeKeys = getSuppressionsStorage().getStore();
+      const activeKeys = getBypassStorage().getStore();
       const bypassSubscribers = this._bypassSubscribers;
       for (let i = 0; i < bypassSubscribers.length; i++) {
         try {
-          const { handler, subscriberId } = bypassSubscribers[i];
-          if (activeKeys?.has(subscriberId)) continue;
+          const { handler, bypassId } = bypassSubscribers[i];
+          if (activeKeys?.has(bypassId)) continue;
           handler(data, this.name);
         } catch (err) {
           process.nextTick(() => {
@@ -776,12 +776,12 @@ function tracingChannel(nameOrChannels) {
 
 dc_binding.linkNativeChannel((name) => channel(name));
 
-function suppressed(key, fn, thisArg, ...args) {
+function bypass(key, fn, thisArg, ...args) {
   validateFunction(fn, 'fn');
 
   validateBypassKey(key, 'key');
 
-  const currentSet = getSuppressionsStorage().getStore();
+  const currentSet = getBypassStorage().getStore();
   const next = currentSet ? new SafeSet(currentSet) : new SafeSet();
   next.add(key);
   return withSuppressionsContext(next, fn, thisArg, args);
@@ -791,7 +791,7 @@ module.exports = {
   channel,
   hasSubscribers,
   subscribe,
-  suppressed,
+  bypass,
   tracingChannel,
   unsubscribe,
   boundedChannel,

…/test-diagnostics-channel-suppression.js …allel/test-diagnostics-channel-bypass.jstest/parallel/test-diagnostics-channel-suppression.js renamed to test/parallel/test-diagnostics-channel-bypass.js test/parallel/test-diagnostics-channel-suppression.js renamed to test/parallel/test-diagnostics-channel-bypass.js

@@ -2,60 +2,60 @@
 
 const common = require('../common');
 const assert = require('assert');
-const { channel, suppressed } = require('node:diagnostics_channel');
+const { channel, bypass } = require('node:diagnostics_channel');
 const { AsyncLocalStorage } = require('async_hooks');
 
-// Test 1: Basic suppression - subscriber with subscriberId is skipped inside suppressed()
+// Test 1: Basic bypass - subscriber with bypassId is skipped inside bypass()
 {
   const key = Symbol('tracer');
-  const ch = channel('test-suppression-basic');
+  const ch = channel('test-bypass-basic');
   const handler = common.mustNotCall();
-  ch.subscribe(handler, { subscriberId: key });
+  ch.subscribe(handler, { bypassId: key });
 
-  suppressed(key, common.mustCall(() => {
+  bypass(key, common.mustCall(() => {
     ch.publish({});
   }));
 
   ch.unsubscribe(handler);
 }
 
-// Test 2: Non-opted subscriber fires even inside suppressed() scope
+// Test 2: Non-opted subscriber fires even inside bypass() scope
 {
   const key = Symbol('tracer2');
-  const ch = channel('test-suppression-nonopted');
+  const ch = channel('test-bypass-nonopted');
   const optedHandler = common.mustNotCall();
   const regularHandler = common.mustCall();
-  ch.subscribe(optedHandler, { subscriberId: key });
-  ch.subscribe(regularHandler); // no suppression
+  ch.subscribe(optedHandler, { bypassId: key });
+  ch.subscribe(regularHandler); // no bypass
 
-  suppressed(key, common.mustCall(() => {
+  bypass(key, common.mustCall(() => {
     ch.publish({});
   }));
 
   ch.unsubscribe(optedHandler);
   ch.unsubscribe(regularHandler);
 }
 
-// Test 3: Two APMs with different keys don't suppress each other
+// Test 3: Two APMs with different keys don't bypass each other
 {
   const k1 = Symbol('k1');
   const k2 = Symbol('k2');
-  const ch = channel('test-suppression-two-keys');
+  const ch = channel('test-bypass-two-keys');
   let h1Calls = 0;
   let h2Calls = 0;
   const h1 = common.mustCall(() => { h1Calls++; }, 1);
   const h2 = common.mustCall(() => { h2Calls++; }, 1);
-  ch.subscribe(h1, { subscriberId: k1 });
-  ch.subscribe(h2, { subscriberId: k2 });
+  ch.subscribe(h1, { bypassId: k1 });
+  ch.subscribe(h2, { bypassId: k2 });
 
-  suppressed(k1, common.mustCall(() => {
+  bypass(k1, common.mustCall(() => {
     ch.publish({});
   }));
 
   assert.strictEqual(h1Calls, 0);
   assert.strictEqual(h2Calls, 1);
 
-  suppressed(k2, common.mustCall(() => {
+  bypass(k2, common.mustCall(() => {
     ch.publish({});
   }));
 
@@ -66,23 +66,23 @@ const { AsyncLocalStorage } = require('async_hooks');
   ch.unsubscribe(h2);
 }
 
-// Test 4: Nested suppressed() calls (same key, different keys)
+// Test 4: Nested bypass() calls (same key, different keys)
 {
   const k1 = Symbol('nested1');
   const k2 = Symbol('nested2');
-  const ch = channel('test-suppression-nested');
+  const ch = channel('test-bypass-nested');
   const h1 = common.mustNotCall();
   let h2Calls = 0;
   const h2 = common.mustCall(() => { h2Calls++; }, 2);
-  ch.subscribe(h1, { subscriberId: k1 });
-  ch.subscribe(h2, { subscriberId: k2 });
+  ch.subscribe(h1, { bypassId: k1 });
+  ch.subscribe(h2, { bypassId: k2 });
 
-  suppressed(k1, common.mustCall(() => {
+  bypass(k1, common.mustCall(() => {
     // Inside k1, h1 skipped, h2 runs
     ch.publish({});
     assert.strictEqual(h2Calls, 1);
 
-    suppressed(k2, common.mustCall(() => {
+    bypass(k2, common.mustCall(() => {
       // Inside both, both skipped
       ch.publish({});
       assert.strictEqual(h2Calls, 1);
@@ -97,15 +97,15 @@ const { AsyncLocalStorage } = require('async_hooks');
   ch.unsubscribe(h2);
 }
 
-// Test 5: suppressed() across a Promise boundary
+// Test 5: bypass() across a Promise boundary
 {
   const key = Symbol('promise');
-  const ch = channel('test-suppression-promise');
+  const ch = channel('test-bypass-promise');
   const handler = common.mustNotCall();
-  ch.subscribe(handler, { subscriberId: key });
+  ch.subscribe(handler, { bypassId: key });
   const done = common.mustCall();
 
-  suppressed(key, common.mustCall(async () => {
+  bypass(key, common.mustCall(async () => {
     await Promise.resolve();
     ch.publish({});
   })).then(common.mustCall(() => {
@@ -114,15 +114,15 @@ const { AsyncLocalStorage } = require('async_hooks');
   }));
 }
 
-// Test 6: suppressed() across setImmediate and queueMicrotask
+// Test 6: bypass() across setImmediate and queueMicrotask
 {
   const key = Symbol('timers');
-  const ch = channel('test-suppression-timers');
+  const ch = channel('test-bypass-timers');
   const handler = common.mustNotCall();
-  ch.subscribe(handler, { subscriberId: key });
+  ch.subscribe(handler, { bypassId: key });
   const done = common.mustCall();
 
-  suppressed(key, common.mustCall(async () => {
+  bypass(key, common.mustCall(async () => {
     await new Promise((resolve) => {
       setImmediate(common.mustCall(() => {
         ch.publish({});
@@ -139,33 +139,32 @@ const { AsyncLocalStorage } = require('async_hooks');
   }));
 }
 
-// Test 7: unsubscribe() works correctly after using subscriberId
+// Test 7: unsubscribe() works correctly after using bypassId
 {
   const key = Symbol('unsub');
-  const ch = channel('test-suppression-unsubscribe');
+  const ch = channel('test-bypass-unsubscribe');
   const handler = common.mustNotCall();
-  ch.subscribe(handler, { subscriberId: key });
+  ch.subscribe(handler, { bypassId: key });
   ch.unsubscribe(handler);
 
   // Should not throw and should not be called
-  suppressed(key, common.mustCall(() => {
+  bypass(key, common.mustCall(() => {
     ch.publish({});
   }));
-
 }
 
-// Test 8: bindStore with subscriberId is skipped inside suppressed()
+// Test 8: bindStore with bypassId is skipped inside bypass()
 {
   const key = Symbol('store');
-  const ch = channel('test-suppression-store');
+  const ch = channel('test-bypass-store');
   const als = new AsyncLocalStorage();
   const normalAls = new AsyncLocalStorage();
 
-  // Normal store - no subscriberId, must always be entered
+  // Normal store, no bypassId, must always be entered.
   ch.bindStore(normalAls, common.mustCall((data) => ({ value: data.value })));
 
-  // Bypass store - must NOT be entered inside suppressed()
-  ch.bindStore(als, common.mustNotCall(), { subscriberId: key });
+  // Bypass store, must NOT be entered inside bypass().
+  ch.bindStore(als, common.mustNotCall(), { bypassId: key });
 
   // Handler verifies:
   // - normal store WAS entered (normalAls has value)
@@ -176,7 +175,7 @@ const { AsyncLocalStorage } = require('async_hooks');
   });
   ch.subscribe(handler);
 
-  suppressed(key, common.mustCall(() => {
+  bypass(key, common.mustCall(() => {
     ch.runStores({ value: 42 }, common.mustCall());
   }));
 
@@ -185,24 +184,24 @@ const { AsyncLocalStorage } = require('async_hooks');
   ch.unbindStore(normalAls);
 }
 
-// Test 9: Wrong type for subscriberId throws ERR_INVALID_ARG_TYPE
+// Test 9: Wrong type for bypassId throws ERR_INVALID_ARG_TYPE
 {
-  const ch = channel('test-suppression-wrong-type');
+  const ch = channel('test-bypass-wrong-type');
   const bad = 'not-allowed';
-  assert.throws(() => ch.subscribe(() => {}, { subscriberId: bad }), {
+  assert.throws(() => ch.subscribe(() => {}, { bypassId: bad }), {
     name: 'TypeError'
   });
   const als = new AsyncLocalStorage();
-  assert.throws(() => ch.bindStore(als, (d) => d, { subscriberId: bad }), {
+  assert.throws(() => ch.bindStore(als, (d) => d, { bypassId: bad }), {
     name: 'TypeError'
   });
 }
 
-// Test 10: suppressed() return value passes through fn's return value
+// Test 10: bypass() return value passes through fn's return value
 {
   const key = Symbol('return');
   const receiver = { value: 41 };
-  const result = suppressed(key, common.mustCall(function(a, b) {
+  const result = bypass(key, common.mustCall(function(a, b) {
     assert.strictEqual(this, receiver);
     assert.strictEqual(a, 'a');
     assert.strictEqual(b, 'b');