diagnostics_channel: early-exit tracing channel trace methods

deps/histogram/src/hdr_atomic.h

@@ -27,7 +27,7 @@ static void hdr_atomic_store_pointer(void** pointer, void* value)
 }
 
 static int64_t __inline hdr_atomic_load_64(int64_t* field)
-{ 
+{
 	_ReadBarrier();
 	return *field;
 }

deps/undici/src/types/readable.d.ts

@@ -44,7 +44,7 @@ declare class BodyReadable extends Readable {
    */
   readonly bodyUsed: boolean
 
-  /** 
+  /**
    * If body is null, it should return null as the body
    *
    *  If body is not null, should return the body as a ReadableStream

deps/undici/src/types/webidl.d.ts

@@ -145,7 +145,7 @@ interface WebidlConverters {
   ): NodeJS.TypedArray | ArrayBufferLike | DataView
 
   ['sequence<ByteString>']: SequenceConverter<string>
-  
+
   ['sequence<sequence<ByteString>>']: SequenceConverter<string[]>
 
   ['record<ByteString, ByteString>']: RecordConverter<string, string>

deps/uv/src/unix/core.c

@@ -1677,7 +1677,7 @@ int uv_thread_setpriority(uv_thread_t tid, int priority) {
     param.sched_priority = prio;
     r = pthread_setschedparam(tid, policy, &param);
     if (r != 0)
-      return UV__ERR(errno);  
+      return UV__ERR(errno);
   }
 
   return 0;

deps/v8/third_party/ittapi/src/ittnotify/ittnotify_static.c

@@ -20,7 +20,7 @@
 #include <stdarg.h>
 #include <string.h>
 
-#define INTEL_NO_MACRO_BODY 
+#define INTEL_NO_MACRO_BODY
 #define INTEL_ITTNOTIFY_API_PRIVATE
 #include "ittnotify.h"
 #include "legacy/ittnotify.h"
@@ -1356,4 +1356,3 @@ ITT_EXTERN_C void _N_(mark_pt_region_end)(__itt_pt_region region)
      (void)region;
 #endif
 }
-

doc/api/diagnostics_channel.md

@@ -789,6 +789,11 @@ if the given function throws an error. This will run the given function using
 [`channel.runStores(context, ...)`][] on the `start` channel which ensures all
 events should have any bound stores set to match this trace context.
 
+To ensure only correct trace graphs are formed, events will only be published
+if subscribers are present prior to starting the trace. Subscriptions which are
+added after the trace begins will not receive future events from that trace,
+only future traces will be seen.
+
 ```mjs
 import diagnostics_channel from 'node:diagnostics_channel';
 
@@ -838,6 +843,11 @@ returned promise rejects. This will run the given function using
 [`channel.runStores(context, ...)`][] on the `start` channel which ensures all
 events should have any bound stores set to match this trace context.
 
+To ensure only correct trace graphs are formed, events will only be published
+if subscribers are present prior to starting the trace. Subscriptions which are
+added after the trace begins will not receive future events from that trace,
+only future traces will be seen.
+
 ```mjs
 import diagnostics_channel from 'node:diagnostics_channel';
 
@@ -891,6 +901,11 @@ the callback is set. This will run the given function using
 [`channel.runStores(context, ...)`][] on the `start` channel which ensures all
 events should have any bound stores set to match this trace context.
 
+To ensure only correct trace graphs are formed, events will only be published
+if subscribers are present prior to starting the trace. Subscriptions which are
+added after the trace begins will not receive future events from that trace,
+only future traces will be seen.
+
 ```mjs
 import diagnostics_channel from 'node:diagnostics_channel';
 
@@ -979,6 +994,11 @@ of the callback while the `error` will either be a thrown error visible in the
 `end` event or the first callback argument in either of the `asyncStart` or
 `asyncEnd` events.
 
+To ensure only correct trace graphs are formed, events should only be published
+if subscribers are present prior to starting the trace. Subscriptions which are
+added after the trace begins should not receive future events from that trace,
+only future traces will be seen.
+
 Tracing channels should follow a naming pattern of:
 
 * `tracing:module.class.method:start` or `tracing:module.function:start`

lib/diagnostics_channel.js

@@ -6,6 +6,7 @@ const {
   ArrayPrototypePush,
   ArrayPrototypeSplice,
   SafeFinalizationRegistry,
+  ObjectDefineProperty,
   ObjectGetPrototypeOf,
   ObjectSetPrototypeOf,
   Promise,
@@ -250,35 +251,40 @@ function assertChannel(value, name) {
   }
 }
 
+function tracingChannelFrom(nameOrChannels, name) {
+  if (typeof nameOrChannels === 'string') {
+    return channel(`tracing:${nameOrChannels}:${name}`);
+  }
+
+  if (typeof nameOrChannels === 'object' && nameOrChannels !== null) {
+    const channel = nameOrChannels[name];
+    assertChannel(channel, `nameOrChannels.${name}`);
+    return channel;
+  }
+
+  throw new ERR_INVALID_ARG_TYPE('nameOrChannels',
+                                 ['string', 'object', 'TracingChannel'],
+                                 nameOrChannels);
+}
+
 class TracingChannel {
   constructor(nameOrChannels) {
-    if (typeof nameOrChannels === 'string') {
-      this.start = channel(`tracing:${nameOrChannels}:start`);
-      this.end = channel(`tracing:${nameOrChannels}:end`);
-      this.asyncStart = channel(`tracing:${nameOrChannels}:asyncStart`);
-      this.asyncEnd = channel(`tracing:${nameOrChannels}:asyncEnd`);
-      this.error = channel(`tracing:${nameOrChannels}:error`);
-    } else if (typeof nameOrChannels === 'object') {
-      const { start, end, asyncStart, asyncEnd, error } = nameOrChannels;
-
-      assertChannel(start, 'nameOrChannels.start');
-      assertChannel(end, 'nameOrChannels.end');
-      assertChannel(asyncStart, 'nameOrChannels.asyncStart');
-      assertChannel(asyncEnd, 'nameOrChannels.asyncEnd');
-      assertChannel(error, 'nameOrChannels.error');
-
-      this.start = start;
-      this.end = end;
-      this.asyncStart = asyncStart;
-      this.asyncEnd = asyncEnd;
-      this.error = error;
-    } else {
-      throw new ERR_INVALID_ARG_TYPE('nameOrChannels',
-                                     ['string', 'object', 'Channel'],
-                                     nameOrChannels);
+    for (const eventName of traceEvents) {
+      ObjectDefineProperty(this, eventName, {
+        __proto__: null,
+        value: tracingChannelFrom(nameOrChannels, eventName),
+      });
     }
   }
 
+  get hasSubscribers() {
+    return this.start.hasSubscribers ||
+      this.end.hasSubscribers ||
+      this.asyncStart.hasSubscribers ||
+      this.asyncEnd.hasSubscribers ||
+      this.error.hasSubscribers;
+  }
+
   subscribe(handlers) {
     for (const name of traceEvents) {
       if (!handlers[name]) continue;
@@ -302,6 +308,10 @@ class TracingChannel {
   }
 
   traceSync(fn, context = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) {
+      return ReflectApply(fn, thisArg, args);
+    }
+
     const { start, end, error } = this;
 
     return start.runStores(context, () => {
@@ -320,6 +330,10 @@ class TracingChannel {
   }
 
   tracePromise(fn, context = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) {
+      return ReflectApply(fn, thisArg, args);
+    }
+
     const { start, end, asyncStart, asyncEnd, error } = this;
 
     function reject(err) {
@@ -358,6 +372,10 @@ class TracingChannel {
   }
 
   traceCallback(fn, position = -1, context = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) {
+      return ReflectApply(fn, thisArg, args);
+    }
+
     const { start, end, asyncStart, asyncEnd, error } = this;
 
     function wrappedCallback(err, res) {

test/parallel/test-diagnostics-channel-tracing-channel-args-types.js

@@ -24,7 +24,7 @@ assert.throws(() => (channel = dc.tracingChannel(0)), {
   code: 'ERR_INVALID_ARG_TYPE',
   name: 'TypeError',
   message:
-    /The "nameOrChannels" argument must be of type string or an instance of Channel or Object/,
+    /The "nameOrChannels" argument must be of type string or an instance of TracingChannel or Object/,
 });
 
 // tracingChannel creating without instance of Channel must throw error

test/parallel/test-diagnostics-channel-tracing-channel-callback-early-exit.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const common = require('../common');
+const dc = require('diagnostics_channel');
+
+const channel = dc.tracingChannel('test');
+
+const handlers = {
+  start: common.mustNotCall(),
+  end: common.mustNotCall(),
+  asyncStart: common.mustNotCall(),
+  asyncEnd: common.mustNotCall(),
+  error: common.mustNotCall()
+};
+
+// While subscribe occurs _before_ the callback executes,
+// no async events should be published.
+channel.traceCallback(setImmediate, 0, {}, null, common.mustCall());
+channel.subscribe(handlers);