node:diagnostics_channel: sync with Node 26 + subsystem channels

src/js/builtins/CommonJS.ts

@@ -12,7 +12,11 @@ export function require(this: JSCommonJSModule, _: string) {
   return $overridableRequire.$apply(this, arguments);
 }
 
-// overridableRequire can be overridden by setting `Module.prototype.require`
+// overridableRequire can be overridden by setting `Module.prototype.require`.
+// When the "module.require" diagnostics tracing channel gains subscribers,
+// node:diagnostics_channel swaps this out for a tracing wrapper via that
+// setter (see internal/module_tracing), so the no-subscriber path has no
+// per-call overhead here.
 $overriddenName = "require";
 $visibility = "Private";
 export function overridableRequire(this: JSCommonJSModule, originalId: string, options: { paths?: string[] } = {}) {

src/js/internal/module_tracing.ts

@@ -0,0 +1,79 @@
+// Wires the "module.require" / "module.import" diagnostics tracing channels
+// into the CommonJS require path and dynamic import(). node:diagnostics_channel
+// calls install() on load; nothing here runs until it does, and the loaders
+// themselves carry no per-call check.
+
+const setHasModuleImportSubscribers = $newCppFunction(
+  "NodeDiagnosticsChannel.cpp",
+  "jsSetHasModuleImportSubscribers",
+  1,
+);
+
+let requireChannel;
+let importChannel;
+// The unwrapped overridableRequire (captured on first install so a user's own
+// Module.prototype.require override is what we wrap and restore).
+let baseRequire;
+let requireWrapped = false;
+
+function tracingRequire(this: any, originalId: string, options?: { paths?: string[] }) {
+  if (requireChannel !== undefined && requireChannel.hasSubscribers) {
+    return requireChannel.traceSync(
+      baseRequire,
+      { __proto__: null, parentFilename: this.filename, id: originalId },
+      this,
+      originalId,
+      options,
+    );
+  }
+  return baseRequire.$call(this, originalId, options);
+}
+Object.defineProperty(tracingRequire, "name", { value: "require" });
+
+function onRequireSubscribersChanged() {
+  const has = requireChannel !== undefined && requireChannel.hasSubscribers;
+  if (has === requireWrapped) return;
+  const Module = require("node:module");
+  if (has) {
+    // Capture once: a user wrapper installed between subscribe cycles may
+    // delegate to tracingRequire, so re-capturing it here would recurse.
+    baseRequire ??= Module.prototype.require;
+    Module.prototype.require = tracingRequire;
+    requireWrapped = true;
+  } else {
+    // Only unwrap what we wrapped; a user override installed while tracing was
+    // active stays.
+    if (Module.prototype.require === tracingRequire) {
+      Module.prototype.require = baseRequire;
+    }
+    requireWrapped = false;
+  }
+}
+
+function onImportSubscribersChanged() {
+  setHasModuleImportSubscribers(importChannel !== undefined && importChannel.hasSubscribers);
+}
+
+const moduleTracing = {
+  // Called from tryTraceModuleImport (C++) only when the import flag is set;
+  // `doImport` performs the dynamic import and returns its promise.
+  traceImport(doImport, parentURL, url) {
+    if (importChannel === undefined || !importChannel.hasSubscribers) {
+      return doImport();
+    }
+    return importChannel.tracePromise(doImport, { __proto__: null, parentURL, url });
+  },
+  // Called once from node:diagnostics_channel on load. Hooks every sub-channel
+  // so gaining/losing a subscriber on any of them re-evaluates the swap.
+  install(requireCh, importCh, hookSubscriberChange) {
+    requireChannel = requireCh;
+    importChannel = importCh;
+    hookSubscriberChange(requireCh, onRequireSubscribersChanged);
+    hookSubscriberChange(importCh, onImportSubscribersChanged);
+    // In case something subscribed before install() ran.
+    onRequireSubscribersChanged();
+    onImportSubscribersChanged();
+  },
+};
+
+export default moduleTracing;

src/js/node/_http_server.ts

@@ -21,6 +21,19 @@ const {
 const { ConnResetException, hasObserver, startPerf, stopPerf } = require("internal/shared");
 const kServerResponseStatistics = Symbol("ServerResponseStatistics");
 
+let onServerRequestStartChannel, onServerResponseCreatedChannel, onServerResponseFinishChannel;
+// In Node http.Server inherits listen() from net.Server, so http servers
+// publish on the net.server.listen tracing channel too; Bun's http.Server is
+// backed by Bun.serve and has its own listen(), so it publishes here directly.
+let netServerListenChannel;
+function initHttpServerChannels() {
+  const dc = require("node:diagnostics_channel");
+  onServerRequestStartChannel = dc.channel("http.server.request.start");
+  onServerResponseCreatedChannel = dc.channel("http.server.response.created");
+  onServerResponseFinishChannel = dc.channel("http.server.response.finish");
+  netServerListenChannel = dc.tracingChannel("net.server.listen");
+}
+
 const { isPrimary } = require("internal/cluster/isPrimary");
 const {
   throwOnInvalidTLSArray,
@@ -631,6 +644,14 @@ Server.prototype.listen = function () {
     onListen = lastArg;
   }
 
+  if (!netServerListenChannel) initHttpServerChannels();
+  if (netServerListenChannel.hasSubscribers) {
+    const arg0 = arguments[0];
+    const options =
+      typeof arg0 === "object" && arg0 !== null ? arg0 : socketPath != null ? { path: socketPath } : { port, host };
+    netServerListenChannel.asyncStart.publish({ server: this, options });
+  }
+
   try {
     // listenInCluster
 
@@ -677,6 +698,9 @@ Server.prototype.listen = function () {
 
     server[kRealListen](tls, port, host, socketPath, true, onListen);
   } catch (err) {
+    if (netServerListenChannel.hasSubscribers) {
+      netServerListenChannel.error.publish({ server: this, error: err });
+    }
     setTimeout(() => server.emit("error", err), 1);
   }
 
@@ -943,6 +967,31 @@ Server.prototype[kRealListen] = function (tls, port, host, socketPath, reusePort
         // 'upgrade' listener and false for a declined upgrade that falls
         // through to 'request'.
         http_req.upgrade = is_upgrade;
+
+        if (!is_upgrade) {
+          if (!onServerResponseCreatedChannel) initHttpServerChannels();
+          // Node publishes response.created from the ServerResponse constructor,
+          // which it only reaches after the upgrade check; Bun constructs the
+          // response unconditionally, so publish here instead.
+          if (onServerResponseCreatedChannel.hasSubscribers) {
+            onServerResponseCreatedChannel.publish({
+              request: http_req,
+              response: http_res,
+            });
+          }
+          if (onServerRequestStartChannel.hasSubscribers) {
+            onServerRequestStartChannel.publish({
+              request: http_req,
+              response: http_res,
+              socket,
+              server,
+            });
+          }
+          // Node's resOnFinish is always attached and checks hasSubscribers at
+          // 'finish' time, so a subscriber added mid-request still observes it.
+          http_res.on("finish", publishServerResponseFinish);
+        }
+
         if (isPipelined) {
           // A previous response on this connection has not finished yet: like
           // Node.js, this response is queued (res.socket === null) and its
@@ -1129,6 +1178,10 @@ Server.prototype[kRealListen] = function (tls, port, host, socketPath, reusePort
     isHTTPS = this[serverSymbol].protocol === "https";
     applyServerCustomOptions(this);
 
+    if (netServerListenChannel.hasSubscribers) {
+      netServerListenChannel.asyncEnd.publish({ server: this });
+    }
+
     if (this?._unref) {
       this[serverSymbol]?.unref?.();
     }
@@ -2158,6 +2211,19 @@ function _writeHead(statusCode, reason, obj, response) {
 
 Object.defineProperty(NodeHTTPServerSocket, "name", { value: "Socket" });
 
+function publishServerResponseFinish(this: any) {
+  if (!onServerResponseFinishChannel.hasSubscribers) return;
+  // Same socket lookup as emitResponseFinishHandleSocket (req.socket may be
+  // nulled by the stream destroyer; this.socket is the assignSocket fallback).
+  const socket = this.req?.socket ?? this.socket;
+  onServerResponseFinishChannel.publish({
+    request: this.req,
+    response: this,
+    socket,
+    server: socket?.server,
+  });
+}
+
 function ServerResponse(req, options): void {
   if (!(this instanceof ServerResponse)) return new ServerResponse(req, options);
   OutgoingMessage.$call(this, options);

src/js/node/child_process.ts

@@ -22,6 +22,13 @@ var BufferIsEncoding = Buffer.isEncoding;
 var kEmptyObject = ObjectCreate(null);
 var signals = OsModule.constants.signals;
 
+let childProcessChannel, childProcessSpawn;
+function initChildProcessChannels() {
+  const dc = require("node:diagnostics_channel");
+  childProcessChannel = dc.channel("child_process");
+  childProcessSpawn = dc.tracingChannel("child_process.spawn");
+}
+
 var ArrayPrototypeJoin = Array.prototype.join;
 var ArrayPrototypeIncludes = Array.prototype.includes;
 var ArrayPrototypeSlice = Array.prototype.slice;
@@ -1107,6 +1114,16 @@ class ChildProcess extends EventEmitter {
   channel;
   killed = false;
 
+  constructor() {
+    super();
+    if (!childProcessChannel) initChildProcessChannels();
+    if (childProcessChannel.hasSubscribers) {
+      childProcessChannel.publish({
+        process: this,
+      });
+    }
+  }
+
   [Symbol.dispose]() {
     if (!this.killed) {
       this.kill();
@@ -1401,6 +1418,10 @@ class ChildProcess extends EventEmitter {
     // Bun.spawn() expects cmd[0] to be the command to run, and argv0 to replace the first arg when running the command,
     // so we have to set argv0 to spawnargs[0] and cmd[0] to file
 
+    if (childProcessSpawn.hasSubscribers) {
+      childProcessSpawn.start.publish({ process: this, options });
+    }
+
     try {
       this.#handle = Bun.spawn({
         cmd: [file, ...Array.prototype.slice.$call(spawnargs, 1)],
@@ -1441,6 +1462,10 @@ class ChildProcess extends EventEmitter {
 
       $debug("ChildProcess: spawn", this.pid, spawnargs);
 
+      if (childProcessSpawn.hasSubscribers) {
+        childProcessSpawn.end.publish({ process: this });
+      }
+
       process.nextTick(() => {
         this.emit("spawn");
       });
@@ -1478,6 +1503,9 @@ class ChildProcess extends EventEmitter {
         this.#handle = null;
         ex.syscall = "spawn " + this.spawnfile;
         ex.spawnargs = Array.prototype.slice.$call(this.spawnargs, 1);
+        if (childProcessSpawn.hasSubscribers) {
+          childProcessSpawn.error.publish({ process: this, error: ex });
+        }
         process.nextTick(() => {
           this.emit("error", ex);
           this.emit("close", (ex as SystemError).errno ?? -1);
@@ -1494,6 +1522,9 @@ class ChildProcess extends EventEmitter {
           // synchronously, with `syscall: "spawn"` (no file appended).
           ex.syscall = "spawn";
         }
+        if (childProcessSpawn.hasSubscribers) {
+          childProcessSpawn.error.publish({ process: this, error: ex });
+        }
         throw ex;
       }
     }