Node.js v24.0.0 文档

diagnostics_channel.hasSubscribers(name)#

• name <string> | <symbol> 通道名称
• 返回：<boolean> 是否有活动的订阅者

检查指定名称的通道是否存在活动的订阅者。 如果你要发送的消息准备起来可能很昂贵，这将很有帮助。

这个 API 是可选的，但在尝试从性能非常敏感的代码发布消息时很有用。

import diagnostics_channel from 'node:diagnostics_channel';

if (diagnostics_channel.hasSubscribers('my-channel')) {
  // There are subscribers, prepare and publish message
}const diagnostics_channel = require('node:diagnostics_channel');

if (diagnostics_channel.hasSubscribers('my-channel')) {
  // There are subscribers, prepare and publish message
}copy

diagnostics_channel.channel(name)#

• name <string> | <symbol> 通道名称
• 返回：<Channel> 命名的通道对象

对于任何想要发布到命名通道的人来说，这是主要的入口点。 它生成一个通道对象，该对象经过优化，可以尽可能减少发布时的开销。

import diagnostics_channel from 'node:diagnostics_channel';

const channel = diagnostics_channel.channel('my-channel');const diagnostics_channel = require('node:diagnostics_channel');

const channel = diagnostics_channel.channel('my-channel');copy

diagnostics_channel.subscribe(name, onMessage)#

• name <string> | <symbol> 通道名称
• onMessage <Function> 接收通道消息的处理函数
  • message <any> 消息数据
  • name <string> | <symbol> 通道的名称

注册一个消息处理函数以订阅此通道。 每当消息发布到通道时，将同步运行此消息处理函数。 消息处理函数中抛出的任何错误都将触发 'uncaughtException'。

import diagnostics_channel from 'node:diagnostics_channel';

diagnostics_channel.subscribe('my-channel', (message, name) => {
  // Received data
});const diagnostics_channel = require('node:diagnostics_channel');

diagnostics_channel.subscribe('my-channel', (message, name) => {
  // Received data
});copy

diagnostics_channel.unsubscribe(name, onMessage)#

• name <string> | <symbol> 通道名称
• onMessage <Function> 要删除的先前订阅的处理函数
• 返回：<boolean> 如果找到该处理函数，则为 true，否则为 false。

删除先前使用 diagnostics_channel.subscribe(name, onMessage) 注册到此通道的消息处理函数。

import diagnostics_channel from 'node:diagnostics_channel';

function onMessage(message, name) {
  // Received data
}

diagnostics_channel.subscribe('my-channel', onMessage);

diagnostics_channel.unsubscribe('my-channel', onMessage);const diagnostics_channel = require('node:diagnostics_channel');

function onMessage(message, name) {
  // Received data
}

diagnostics_channel.subscribe('my-channel', onMessage);

diagnostics_channel.unsubscribe('my-channel', onMessage);copy

diagnostics_channel.tracingChannel(nameOrChannels)#

• nameOrChannels <string> | <TracingChannel> 通道名称或包含所有 TracingChannel 通道的对象
• 返回：<TracingChannel> 要跟踪的通道集合

为给定的 TracingChannel 通道创建一个 TracingChannel 包装器。 如果给出了名称，则将以 tracing:${name}:${eventType} 的形式创建相应的跟踪通道，其中 eventType 对应于 TracingChannel 通道的类型。

import diagnostics_channel from 'node:diagnostics_channel';

const channelsByName = diagnostics_channel.tracingChannel('my-channel');

// or...

const channelsByCollection = diagnostics_channel.tracingChannel({
  start: diagnostics_channel.channel('tracing:my-channel:start'),
  end: diagnostics_channel.channel('tracing:my-channel:end'),
  asyncStart: diagnostics_channel.channel('tracing:my-channel:asyncStart'),
  asyncEnd: diagnostics_channel.channel('tracing:my-channel:asyncEnd'),
  error: diagnostics_channel.channel('tracing:my-channel:error'),
});const diagnostics_channel = require('node:diagnostics_channel');

const channelsByName = diagnostics_channel.tracingChannel('my-channel');

// or...

const channelsByCollection = diagnostics_channel.tracingChannel({
  start: diagnostics_channel.channel('tracing:my-channel:start'),
  end: diagnostics_channel.channel('tracing:my-channel:end'),
  asyncStart: diagnostics_channel.channel('tracing:my-channel:asyncStart'),
  asyncEnd: diagnostics_channel.channel('tracing:my-channel:asyncEnd'),
  error: diagnostics_channel.channel('tracing:my-channel:error'),
});copy

channel.hasSubscribers#

• 返回：<boolean> 是否有活动的订阅者

检查此通道是否存在活动的订阅者。 如果你要发送的消息准备起来可能很昂贵，这将很有帮助。

这个 API 是可选的，但在尝试从性能非常敏感的代码发布消息时很有用。

import diagnostics_channel from 'node:diagnostics_channel';

const channel = diagnostics_channel.channel('my-channel');

if (channel.hasSubscribers) {
  // There are subscribers, prepare and publish message
}const diagnostics_channel = require('node:diagnostics_channel');

const channel = diagnostics_channel.channel('my-channel');

if (channel.hasSubscribers) {
  // There are subscribers, prepare and publish message
}copy

channel.publish(message)#

• message <any> 要发送给通道订阅者的消息

将消息发布到通道的任何订阅者。 这将同步触发消息处理函数，因此它们将在同一上下文中执行。

import diagnostics_channel from 'node:diagnostics_channel';

const channel = diagnostics_channel.channel('my-channel');

channel.publish({
  some: 'message',
});const diagnostics_channel = require('node:diagnostics_channel');

const channel = diagnostics_channel.channel('my-channel');

channel.publish({
  some: 'message',
});copy

channel.subscribe(onMessage)#

• onMessage <Function> 接收通道消息的处理函数
  • message <any> 消息数据
  • name <string> | <symbol> 通道的名称

注册一个消息处理函数以订阅此通道。 每当消息发布到通道时，将同步运行此消息处理函数。 消息处理函数中抛出的任何错误都将触发 'uncaughtException'。

import diagnostics_channel from 'node:diagnostics_channel';

const channel = diagnostics_channel.channel('my-channel');

channel.subscribe((message, name) => {
  // Received data
});const diagnostics_channel = require('node:diagnostics_channel');

const channel = diagnostics_channel.channel('my-channel');

channel.subscribe((message, name) => {
  // Received data
});copy

channel.unsubscribe(onMessage)#

• onMessage <Function> 要删除的先前订阅的处理函数
• 返回：<boolean> 如果找到该处理函数，则为 true，否则为 false。

删除先前使用 channel.subscribe(onMessage) 注册到此通道的消息处理函数。

import diagnostics_channel from 'node:diagnostics_channel';

const channel = diagnostics_channel.channel('my-channel');

function onMessage(message, name) {
  // Received data
}

channel.subscribe(onMessage);

channel.unsubscribe(onMessage);const diagnostics_channel = require('node:diagnostics_channel');

const channel = diagnostics_channel.channel('my-channel');

function onMessage(message, name) {
  // Received data
}

channel.subscribe(onMessage);

channel.unsubscribe(onMessage);copy

channel.bindStore(store[, transform])#

• store <AsyncLocalStorage> 要将上下文数据绑定到的存储
• transform <Function> 在设置存储上下文之前转换上下文数据

当调用 channel.runStores(context, ...) 时，给定的上下文数据将应用于绑定到该通道的任何存储。 如果存储已经绑定，则先前的 transform 函数将被新的函数替换。 可以省略 transform 函数以将给定的上下文数据直接设置为上下文。

import diagnostics_channel from 'node:diagnostics_channel';
import { AsyncLocalStorage } from 'node:async_hooks';

const store = new AsyncLocalStorage();

const channel = diagnostics_channel.channel('my-channel');

channel.bindStore(store, (data) => {
  return { data };
});const diagnostics_channel = require('node:diagnostics_channel');
const { AsyncLocalStorage } = require('node:async_hooks');

const store = new AsyncLocalStorage();

const channel = diagnostics_channel.channel('my-channel');

channel.bindStore(store, (data) => {
  return { data };
});copy

channel.unbindStore(store)#

• store <AsyncLocalStorage> 要从通道取消绑定的存储。
• 返回：<boolean> 如果找到该存储，则为 true，否则为 false。

删除先前使用 channel.bindStore(store) 注册到此通道的消息处理函数。

import diagnostics_channel from 'node:diagnostics_channel';
import { AsyncLocalStorage } from 'node:async_hooks';

const store = new AsyncLocalStorage();

const channel = diagnostics_channel.channel('my-channel');

channel.bindStore(store);
channel.unbindStore(store);const diagnostics_channel = require('node:diagnostics_channel');
const { AsyncLocalStorage } = require('node:async_hooks');

const store = new AsyncLocalStorage();

const channel = diagnostics_channel.channel('my-channel');

channel.bindStore(store);
channel.unbindStore(store);copy

channel.runStores(context, fn[, thisArg[, ...args]])#

• context <any> 要发送给订阅者并绑定到存储的消息
• fn <Function> 要在输入的存储上下文中运行的处理函数
• thisArg <any> 用于函数调用的接收者。
• ...args <any> 要传递给函数的可选参数。

在给定函数执行期间，将给定的数据应用于绑定到该通道的任何 AsyncLocalStorage 实例，然后在应用到存储区的该数据范围内发布到该通道。

如果给 channel.bindStore(store) 提供了一个转换函数，它将被用于在消息数据成为存储区的上下文值之前转换消息数据。在需要上下文链接的情况下，可以从转换函数中访问先前的存储上下文。

应用于存储区的上下文应该可以在从给定函数开始执行的任何异步代码中访问，但是在某些情况下可能会发生上下文丢失。

import diagnostics_channel from 'node:diagnostics_channel';
import { AsyncLocalStorage } from 'node:async_hooks';

const store = new AsyncLocalStorage();

const channel = diagnostics_channel.channel('my-channel');

channel.bindStore(store, (message) => {
  const parent = store.getStore();
  return new Span(message, parent);
});
channel.runStores({ some: 'message' }, () => {
  store.getStore(); // Span({ some: 'message' })
});const diagnostics_channel = require('node:diagnostics_channel');
const { AsyncLocalStorage } = require('node:async_hooks');

const store = new AsyncLocalStorage();

const channel = diagnostics_channel.channel('my-channel');

channel.bindStore(store, (message) => {
  const parent = store.getStore();
  return new Span(message, parent);
});
channel.runStores({ some: 'message' }, () => {
  store.getStore(); // Span({ some: 'message' })
});copy

tracingChannel.subscribe(subscribers)#

• subscribers <Object> TracingChannel 通道订阅者的集合
  • start <Function> start 事件订阅者
  • end <Function> end 事件订阅者
  • asyncStart <Function> asyncStart 事件订阅者
  • asyncEnd <Function> asyncEnd 事件订阅者
  • error <Function> error 事件订阅者

帮助程序，用于将一组函数订阅到相应的通道。这与在每个通道上单独调用 channel.subscribe(onMessage) 相同。

import diagnostics_channel from 'node:diagnostics_channel';

const channels = diagnostics_channel.tracingChannel('my-channel');

channels.subscribe({
  start(message) {
    // Handle start message
  },
  end(message) {
    // Handle end message
  },
  asyncStart(message) {
    // Handle asyncStart message
  },
  asyncEnd(message) {
    // Handle asyncEnd message
  },
  error(message) {
    // Handle error message
  },
});const diagnostics_channel = require('node:diagnostics_channel');

const channels = diagnostics_channel.tracingChannel('my-channel');

channels.subscribe({
  start(message) {
    // Handle start message
  },
  end(message) {
    // Handle end message
  },
  asyncStart(message) {
    // Handle asyncStart message
  },
  asyncEnd(message) {
    // Handle asyncEnd message
  },
  error(message) {
    // Handle error message
  },
});copy

tracingChannel.unsubscribe(subscribers)#

• subscribers <Object> TracingChannel 通道订阅者的集合
  • start <Function> start 事件订阅者
  • end <Function> end 事件订阅者
  • asyncStart <Function> asyncStart 事件订阅者
  • asyncEnd <Function> asyncEnd 事件订阅者
  • error <Function> error 事件订阅者
• 返回值: <boolean> 如果所有处理程序都已成功取消订阅，则为 true，否则为 false。

帮助程序，用于从相应的通道取消订阅一组函数。这与在每个通道上单独调用 channel.unsubscribe(onMessage) 相同。

import diagnostics_channel from 'node:diagnostics_channel';

const channels = diagnostics_channel.tracingChannel('my-channel');

channels.unsubscribe({
  start(message) {
    // Handle start message
  },
  end(message) {
    // Handle end message
  },
  asyncStart(message) {
    // Handle asyncStart message
  },
  asyncEnd(message) {
    // Handle asyncEnd message
  },
  error(message) {
    // Handle error message
  },
});const diagnostics_channel = require('node:diagnostics_channel');

const channels = diagnostics_channel.tracingChannel('my-channel');

channels.unsubscribe({
  start(message) {
    // Handle start message
  },
  end(message) {
    // Handle end message
  },
  asyncStart(message) {
    // Handle asyncStart message
  },
  asyncEnd(message) {
    // Handle asyncEnd message
  },
  error(message) {
    // Handle error message
  },
});copy

tracingChannel.traceSync(fn[, context[, thisArg[, ...args]]])#

• fn <Function> 要包装追踪的函数
• context <Object> 用于关联事件的共享对象
• thisArg <any> 用于函数调用的接收者
• ...args <any> 要传递给函数的可选参数
• 返回值: <any> 给定函数的返回值

追踪同步函数调用。这将始终生成围绕执行的 start 事件 和 end 事件，如果给定函数抛出错误，则可能会生成 error 事件。这将在 start 通道上使用 channel.runStores(context, ...) 运行给定函数，这确保所有事件都应将任何绑定的存储区设置为与此追踪上下文匹配。

为确保仅形成正确的追踪图，仅当在开始追踪之前存在订阅者时才会发布事件。在追踪开始后添加的订阅将不会收到来自该追踪的未来事件，只会看到未来的追踪。

import diagnostics_channel from 'node:diagnostics_channel';

const channels = diagnostics_channel.tracingChannel('my-channel');

channels.traceSync(() => {
  // Do something
}, {
  some: 'thing',
});const diagnostics_channel = require('node:diagnostics_channel');

const channels = diagnostics_channel.tracingChannel('my-channel');

channels.traceSync(() => {
  // Do something
}, {
  some: 'thing',
});copy

tracingChannel.tracePromise(fn[, context[, thisArg[, ...args]]])#

• fn <Function> 返回 Promise 的函数，用于包装追踪
• context <Object> 用于关联追踪事件的共享对象
• thisArg <any> 用于函数调用的接收者
• ...args <any> 要传递给函数的可选参数
• 返回值: <Promise> 从给定函数返回的 Promise 链接

追踪返回 Promise 的函数调用。这将始终在函数执行的同步部分生成 start 事件 和 end 事件，并且在达到 Promise 继续时生成 asyncStart 事件 和 asyncEnd 事件。如果给定函数抛出错误或返回的 Promise 拒绝，则也可能生成 error 事件。这将在 start 通道上使用 channel.runStores(context, ...) 运行给定函数，这确保所有事件都应将任何绑定的存储区设置为与此追踪上下文匹配。

为确保仅形成正确的追踪图，仅当在开始追踪之前存在订阅者时才会发布事件。在追踪开始后添加的订阅将不会收到来自该追踪的未来事件，只会看到未来的追踪。

import diagnostics_channel from 'node:diagnostics_channel';

const channels = diagnostics_channel.tracingChannel('my-channel');

channels.tracePromise(async () => {
  // Do something
}, {
  some: 'thing',
});const diagnostics_channel = require('node:diagnostics_channel');

const channels = diagnostics_channel.tracingChannel('my-channel');

channels.tracePromise(async () => {
  // Do something
}, {
  some: 'thing',
});copy

tracingChannel.traceCallback(fn[, position[, context[, thisArg[, ...args]]]])#

• fn <Function> 使用函数的回调来包装追踪
• position <number> 预期回调的从零开始的参数位置（如果传递 undefined，则默认为最后一个参数）
• context <Object> 用于关联追踪事件的共享对象（如果传递 undefined，则默认为 {}）
• thisArg <any> 用于函数调用的接收者
• ...args <any> 要传递给函数的参数（必须包括回调）
• 返回值: <any> 给定函数的返回值

追踪接收回调的函数调用。回调预计遵循通常使用的错误作为第一个参数的约定。这将始终在函数执行的同步部分生成 start 事件 和 end 事件，并且将在回调执行期间生成 asyncStart 事件 和 asyncEnd 事件。如果给定函数抛出或传递给回调的第一个参数被设置，则也可能生成 error 事件。这将在 start 通道上使用 channel.runStores(context, ...) 运行给定函数，这确保所有事件都应将任何绑定的存储区设置为与此追踪上下文匹配。

为确保仅形成正确的追踪图，仅当在开始追踪之前存在订阅者时才会发布事件。在追踪开始后添加的订阅将不会收到来自该追踪的未来事件，只会看到未来的追踪。

import diagnostics_channel from 'node:diagnostics_channel';

const channels = diagnostics_channel.tracingChannel('my-channel');

channels.traceCallback((arg1, callback) => {
  // Do something
  callback(null, 'result');
}, 1, {
  some: 'thing',
}, thisArg, arg1, callback);const diagnostics_channel = require('node:diagnostics_channel');

const channels = diagnostics_channel.tracingChannel('my-channel');

channels.traceCallback((arg1, callback) => {
  // Do something
  callback(null, 'result');
}, 1, {
  some: 'thing',
}, thisArg, arg1, callback);copy

回调也将使用 channel.runStores(context, ...) 运行，这在某些情况下可以恢复上下文丢失。

import diagnostics_channel from 'node:diagnostics_channel';
import { AsyncLocalStorage } from 'node:async_hooks';

const channels = diagnostics_channel.tracingChannel('my-channel');
const myStore = new AsyncLocalStorage();

// The start channel sets the initial store data to something
// and stores that store data value on the trace context object
channels.start.bindStore(myStore, (data) => {
  const span = new Span(data);
  data.span = span;
  return span;
});

// Then asyncStart can restore from that data it stored previously
channels.asyncStart.bindStore(myStore, (data) => {
  return data.span;
});const diagnostics_channel = require('node:diagnostics_channel');
const { AsyncLocalStorage } = require('node:async_hooks');

const channels = diagnostics_channel.tracingChannel('my-channel');
const myStore = new AsyncLocalStorage();

// The start channel sets the initial store data to something
// and stores that store data value on the trace context object
channels.start.bindStore(myStore, (data) => {
  const span = new Span(data);
  data.span = span;
  return span;
});

// Then asyncStart can restore from that data it stored previously
channels.asyncStart.bindStore(myStore, (data) => {
  return data.span;
});copy

tracingChannel.hasSubscribers#

• 返回值: <boolean> 如果任何单个通道都有订阅者，则为 true，否则为 false。

这是 TracingChannel 实例上可用的帮助方法，用于检查任何 TracingChannel 通道 是否有订阅者。 如果它们中的任何一个至少有一个订阅者，则返回 true，否则返回 false。

import diagnostics_channel from 'node:diagnostics_channel';

const channels = diagnostics_channel.tracingChannel('my-channel');

if (channels.hasSubscribers) {
  // Do something
}const diagnostics_channel = require('node:diagnostics_channel');

const channels = diagnostics_channel.tracingChannel('my-channel');

if (channels.hasSubscribers) {
  // Do something
}copy

start(event)#

• 名称: tracing:${name}:start

start 事件表示调用函数的时间点。 此时，事件数据可能包含函数参数或在函数执行开始时可用的任何其他内容。

end(event)#

• 名称: tracing:${name}:end

end 事件表示函数调用返回一个值的时间点。对于异步函数，这是指 Promise 返回的时间点，而不是函数本身在内部发出返回语句的时间点。 在这个时间点，如果被追踪的函数是同步的，则 result 字段将被设置为函数的返回值。 另外，也可能存在 error 字段，表示任何抛出的错误。

建议专门监听 error 事件来跟踪错误，因为可追踪的操作可能产生多个错误。 例如，一个失败的异步任务可能在任务的同步部分抛出错误之前就在内部启动。

asyncStart(event)#

• 名称: tracing:${name}:asyncStart

asyncStart 事件表示已到达可追踪函数的回调或延续。 此时，诸如回调参数之类的内容可能可用，或者任何其他表达操作“结果”的内容。

对于基于回调的函数，如果回调的第一个参数不是 undefined 或 null，则将其分配给 error 字段，并将第二个参数分配给 result 字段。

对于 Promise，resolve 路径的参数将分配给 result，而 reject 路径的参数将分配给 error。

建议专门监听 error 事件来跟踪错误，因为可追踪的操作可能产生多个错误。 例如，一个失败的异步任务可能在任务的同步部分抛出错误之前就在内部启动。

asyncEnd(event)#

• 名称: tracing:${name}:asyncEnd

asyncEnd 事件表示异步函数的回调返回。 在 asyncStart 事件之后，事件数据不太可能发生变化，但是查看回调完成的时间点可能很有用。

error(event)#

• 名称: tracing:${name}:error

error 事件表示可追踪函数以同步或异步方式产生的任何错误。 如果在被追踪函数的同步部分中抛出错误，则该错误将分配给事件的 error 字段，并且将触发 error 事件。 如果通过回调或 Promise 拒绝异步接收到错误，它也将分配给事件的 error 字段并触发 error 事件。

单个可追踪函数调用可能会多次产生错误，因此在消费此事件时应考虑这一点。 例如，如果另一个异步任务在内部被触发并失败，然后函数的同步部分抛出错误，则将发出两个 error 事件，一个用于同步错误，另一个用于异步错误。

Console#

console.log

• args <any[]>

当调用 console.log() 时发出。 接收传递给 console.log() 的参数数组。

console.info

• args <any[]>

当调用 console.info() 时发出。 接收传递给 console.info() 的参数数组。

console.debug

• args <any[]>

当调用 console.debug() 时发出。 接收传递给 console.debug() 的参数数组。

console.warn

• args <any[]>

当调用 console.warn() 时发出。 接收传递给 console.warn() 的参数数组。

console.error

• args <any[]>

当调用 console.error() 时发出。 接收传递给 console.error() 的参数数组。

HTTP#

http.client.request.created

• request <http.ClientRequest>

当客户端创建请求对象时发出。 与 http.client.request.start 不同，此事件在请求发送之前发出。

http.client.request.start

• request <http.ClientRequest>

当客户端启动请求时发出。

http.client.request.error

• request <http.ClientRequest>
• error <Error>

当客户端请求期间发生错误时发出。

http.client.response.finish

• request <http.ClientRequest>
• response <http.IncomingMessage>

当客户端收到响应时发出。

http.server.request.start

• request <http.IncomingMessage>
• response <http.ServerResponse>
• socket <net.Socket>
• server <http.Server>

当服务器收到请求时发出。

http.server.response.created

• request <http.IncomingMessage>
• response <http.ServerResponse>

当服务器创建响应时发出。 该事件在发送响应之前发出。

http.server.response.finish

• request <http.IncomingMessage>
• response <http.ServerResponse>
• socket <net.Socket>
• server <http.Server>

当服务器发送响应时发出。

模块#

module.require.start

• event <Object> 包含以下属性
  • id - 传递给 require() 的参数。 模块名称。
  • parentFilename - 尝试 require(id) 的模块的名称。

当执行 require() 时发出。 参见 start 事件。

module.require.end

• event <Object> 包含以下属性
  • id - 传递给 require() 的参数。 模块名称。
  • parentFilename - 尝试 require(id) 的模块的名称。

当 require() 调用返回时发出。 参见 end 事件。

module.require.error

• event <Object> 包含以下属性
  • id - 传递给 require() 的参数。 模块名称。
  • parentFilename - 尝试 require(id) 的模块的名称。
• error <Error>

当 require() 抛出错误时发出。 参见 error 事件。

module.import.asyncStart

• event <Object> 包含以下属性
  • id - 传递给 import() 的参数。 模块名称。
  • parentURL - 尝试 import(id) 的模块的 URL 对象。

当调用 import() 时发出。 参见 asyncStart 事件。

module.import.asyncEnd

• event <Object> 包含以下属性
  • id - 传递给 import() 的参数。 模块名称。
  • parentURL - 尝试 import(id) 的模块的 URL 对象。

当 import() 完成时发出。 参见 asyncEnd 事件。

module.import.error

• event <Object> 包含以下属性
  • id - 传递给 import() 的参数。 模块名称。
  • parentURL - 尝试 import(id) 的模块的 URL 对象。
• error <Error>

当 import() 抛出错误时发出。 参见 error 事件。

NET#

net.client.socket

• socket <net.Socket>

当创建新的 TCP 或管道客户端套接字时发出。

net.server.socket

• socket <net.Socket>

当收到新的 TCP 或管道连接时发出。

tracing:net.server.listen:asyncStart

• server <net.Server>
• options <Object>

当调用 net.Server.listen() 时发出，在实际设置端口或管道之前。

tracing:net.server.listen:asyncEnd

• server <net.Server>

当 net.Server.listen() 完成并且服务器已准备好接受连接时发出。

tracing:net.server.listen:error

• server <net.Server>
• error <Error>

当 net.Server.listen() 返回错误时发出。

UDP#

udp.socket

• socket <dgram.Socket>

当创建新的 UDP 套接字时发出。

进程#

child_process

• process <ChildProcess>

当创建新进程时发出。

execve

• execPath <string>
• args <string[]>
• env <string[]>

当调用 process.execve() 时发出。

Worker Thread#

worker_threads

• worker Worker

当创建新线程时发出。