perf_hooks.performance#
Added in: v8.5.0
An object that can be used to collect performance metrics from the current
Node.js instance. It is similar to window.performance in browsers.
performance.clearMarks([name])#
If name is not provided, removes all PerformanceMark objects from the
Performance Timeline. If name is provided, removes only the named mark.
performance.clearMeasures([name])#
If name is not provided, removes all PerformanceMeasure objects from the
Performance Timeline. If name is provided, removes only the named measure.
performance.clearResourceTimings([name])#
If name is not provided, removes all PerformanceResourceTiming objects from
the Resource Timeline. If name is provided, removes only the named resource.
performance.eventLoopUtilization([utilization1[, utilization2]])#
Added in: v14.10.0, v12.19.0
utilization1 <Object> The result of a previous call to
eventLoopUtilization().
utilization2 <Object> The result of a previous call to
eventLoopUtilization() prior to utilization1.
- Returns: <Object>
The eventLoopUtilization() method returns an object that contains the
cumulative duration of time the event loop has been both idle and active as a
high resolution milliseconds timer. The utilization value is the calculated
Event Loop Utilization (ELU).
If bootstrapping has not yet finished on the main thread the properties have
the value of 0. The ELU is immediately available on Worker threads since
bootstrap happens within the event loop.
Both utilization1 and utilization2 are optional parameters.
If utilization1 is passed, then the delta between the current call's active
and idle times, as well as the corresponding utilization value are
calculated and returned (similar to process.hrtime()).
If utilization1 and utilization2 are both passed, then the delta is
calculated between the two arguments. This is a convenience option because,
unlike process.hrtime(), calculating the ELU is more complex than a
single subtraction.
ELU is similar to CPU utilization, except that it only measures event loop
statistics and not CPU usage. It represents the percentage of time the event
loop has spent outside the event loop's event provider (e.g. epoll_wait).
No other CPU idle time is taken into consideration. The following is an example
of how a mostly idle process will have a high ELU.
import { eventLoopUtilization } from 'node:perf_hooks';
import { spawnSync } from 'node:child_process';
setImmediate(() => {
const elu = eventLoopUtilization();
spawnSync('sleep', ['5']);
console.log(eventLoopUtilization(elu).utilization);
});'use strict';
const { eventLoopUtilization } = require('node:perf_hooks').performance;
const { spawnSync } = require('node:child_process');
setImmediate(() => {
const elu = eventLoopUtilization();
spawnSync('sleep', ['5']);
console.log(eventLoopUtilization(elu).utilization);
});
Although the CPU is mostly idle while running this script, the value of
utilization is 1. This is because the call to
child_process.spawnSync() blocks the event loop from proceeding.
Passing in a user-defined object instead of the result of a previous call to
eventLoopUtilization() will lead to undefined behavior. The return values
are not guaranteed to reflect any correct state of the event loop.
performance.getEntries()#
Returns a list of PerformanceEntry objects in chronological order with
respect to performanceEntry.startTime. If you are only interested in
performance entries of certain types or that have certain names, see
performance.getEntriesByType() and performance.getEntriesByName().
performance.getEntriesByName(name[, type])#
Returns a list of PerformanceEntry objects in chronological order
with respect to performanceEntry.startTime whose performanceEntry.name is
equal to name, and optionally, whose performanceEntry.entryType is equal to
type.
performance.getEntriesByType(type)#
Returns a list of PerformanceEntry objects in chronological order
with respect to performanceEntry.startTime whose performanceEntry.entryType
is equal to type.
performance.mark(name[, options])#
name <string>
options <Object>
detail <any> Additional optional detail to include with the mark.
startTime <number> An optional timestamp to be used as the mark time.
Default: performance.now().
Creates a new PerformanceMark entry in the Performance Timeline. A
PerformanceMark is a subclass of PerformanceEntry whose
performanceEntry.entryType is always 'mark', and whose
performanceEntry.duration is always 0. Performance marks are used
to mark specific significant moments in the Performance Timeline.
The created PerformanceMark entry is put in the global Performance Timeline
and can be queried with performance.getEntries,
performance.getEntriesByName, and performance.getEntriesByType. When the
observation is performed, the entries should be cleared from the global
Performance Timeline manually with performance.clearMarks.
performance.markResourceTiming(timingInfo, requestedUrl, initiatorType, global, cacheMode, bodyInfo, responseStatus[, deliveryType])#
This property is an extension by Node.js. It is not available in Web browsers.
Creates a new PerformanceResourceTiming entry in the Resource Timeline. A
PerformanceResourceTiming is a subclass of PerformanceEntry whose
performanceEntry.entryType is always 'resource'. Performance resources
are used to mark moments in the Resource Timeline.
The created PerformanceMark entry is put in the global Resource Timeline
and can be queried with performance.getEntries,
performance.getEntriesByName, and performance.getEntriesByType. When the
observation is performed, the entries should be cleared from the global
Performance Timeline manually with performance.clearResourceTimings.
performance.measure(name[, startMarkOrOptions[, endMark]])#
name <string>
startMarkOrOptions <string> | <Object> Optional.
detail <any> Additional optional detail to include with the measure.
duration <number> Duration between start and end times.
end <number> | <string> Timestamp to be used as the end time, or a string
identifying a previously recorded mark.
start <number> | <string> Timestamp to be used as the start time, or a string
identifying a previously recorded mark.
endMark <string> Optional. Must be omitted if startMarkOrOptions is an
<Object>.
Creates a new PerformanceMeasure entry in the Performance Timeline. A
PerformanceMeasure is a subclass of PerformanceEntry whose
performanceEntry.entryType is always 'measure', and whose
performanceEntry.duration measures the number of milliseconds elapsed since
startMark and endMark.
The startMark argument may identify any existing PerformanceMark in the
Performance Timeline, or may identify any of the timestamp properties
provided by the PerformanceNodeTiming class. If the named startMark does
not exist, an error is thrown.
The optional endMark argument must identify any existing PerformanceMark
in the Performance Timeline or any of the timestamp properties provided by the
PerformanceNodeTiming class. endMark will be performance.now()
if no parameter is passed, otherwise if the named endMark does not exist, an
error will be thrown.
The created PerformanceMeasure entry is put in the global Performance Timeline
and can be queried with performance.getEntries,
performance.getEntriesByName, and performance.getEntriesByType. When the
observation is performed, the entries should be cleared from the global
Performance Timeline manually with performance.clearMeasures.
performance.nodeTiming#
Added in: v8.5.0
This property is an extension by Node.js. It is not available in Web browsers.
An instance of the PerformanceNodeTiming class that provides performance
metrics for specific Node.js operational milestones.
performance.now()#
Returns the current high resolution millisecond timestamp, where 0 represents
the start of the current node process.
performance.setResourceTimingBufferSize(maxSize)#
Sets the global performance resource timing buffer size to the specified number
of "resource" type performance entry objects.
By default the max buffer size is set to 250.
performance.timeOrigin#
Added in: v8.5.0
The timeOrigin specifies the high resolution millisecond timestamp at
which the current node process began, measured in Unix time.
performance.timerify(fn[, options])#
This property is an extension by Node.js. It is not available in Web browsers.
Wraps a function within a new function that measures the running time of the
wrapped function. A PerformanceObserver must be subscribed to the 'function'
event type in order for the timing details to be accessed.
import { performance, PerformanceObserver } from 'node:perf_hooks';
function someFunction() {
console.log('hello world');
}
const wrapped = performance.timerify(someFunction);
const obs = new PerformanceObserver((list) => {
console.log(list.getEntries()[0].duration);
performance.clearMarks();
performance.clearMeasures();
obs.disconnect();
});
obs.observe({ entryTypes: ['function'] });
wrapped();const {
performance,
PerformanceObserver,
} = require('node:perf_hooks');
function someFunction() {
console.log('hello world');
}
const wrapped = performance.timerify(someFunction);
const obs = new PerformanceObserver((list) => {
console.log(list.getEntries()[0].duration);
performance.clearMarks();
performance.clearMeasures();
obs.disconnect();
});
obs.observe({ entryTypes: ['function'] });
wrapped();
If the wrapped function returns a promise, a finally handler will be attached
to the promise and the duration will be reported once the finally handler is
invoked.
performance.toJSON()#
An object which is JSON representation of the performance object. It
is similar to window.performance.toJSON in browsers.
Event: 'resourcetimingbufferfull'#
Added in: v18.8.0
The 'resourcetimingbufferfull' event is fired when the global performance
resource timing buffer is full. Adjust resource timing buffer size with
performance.setResourceTimingBufferSize() or clear the buffer with
performance.clearResourceTimings() in the event listener to allow
more entries to be added to the performance timeline buffer.
Class: PerformanceNodeEntry#
Added in: v19.0.0
This class is an extension by Node.js. It is not available in Web browsers.
Provides detailed Node.js timing data.
The constructor of this class is not exposed to users directly.
performanceNodeEntry.detail#
Additional detail specific to the entryType.
performanceNodeEntry.flags#
Stability: 0 - Deprecated: Use
performanceNodeEntry.detail instead.
When performanceEntry.entryType is equal to 'gc', the performance.flags
property contains additional information about garbage collection operation.
The value may be one of:
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE
performanceNodeEntry.kind#
Stability: 0 - Deprecated: Use
performanceNodeEntry.detail instead.
When performanceEntry.entryType is equal to 'gc', the performance.kind
property identifies the type of garbage collection operation that occurred.
The value may be one of:
perf_hooks.constants.NODE_PERFORMANCE_GC_MAJOR
perf_hooks.constants.NODE_PERFORMANCE_GC_MINOR
perf_hooks.constants.NODE_PERFORMANCE_GC_INCREMENTAL
perf_hooks.constants.NODE_PERFORMANCE_GC_WEAKCB
Garbage Collection ('gc') Details#
When performanceEntry.type is equal to 'gc', the
performanceNodeEntry.detail property will be an <Object> with two properties:
kind <number> One of:
perf_hooks.constants.NODE_PERFORMANCE_GC_MAJOR
perf_hooks.constants.NODE_PERFORMANCE_GC_MINOR
perf_hooks.constants.NODE_PERFORMANCE_GC_INCREMENTAL
perf_hooks.constants.NODE_PERFORMANCE_GC_WEAKCB
flags <number> One of:
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY
perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE
HTTP ('http') Details#
When performanceEntry.type is equal to 'http', the
performanceNodeEntry.detail property will be an <Object> containing
additional information.
If performanceEntry.name is equal to HttpClient, the detail
will contain the following properties: req, res. And the req property
will be an <Object> containing method, url, headers, the res property
will be an <Object> containing statusCode, statusMessage, headers.
If performanceEntry.name is equal to HttpRequest, the detail
will contain the following properties: req, res. And the req property
will be an <Object> containing method, url, headers, the res property
will be an <Object> containing statusCode, statusMessage, headers.
This could add additional memory overhead and should only be used for
diagnostic purposes, not left turned on in production by default.
HTTP/2 ('http2') Details#
When performanceEntry.type is equal to 'http2', the
performanceNodeEntry.detail property will be an <Object> containing
additional performance information.
If performanceEntry.name is equal to Http2Stream, the detail
will contain the following properties:
bytesRead <number> The number of DATA frame bytes received for this
Http2Stream.
bytesWritten <number> The number of DATA frame bytes sent for this
Http2Stream.
id <number> The identifier of the associated Http2Stream
timeToFirstByte <number> The number of milliseconds elapsed between the
PerformanceEntry startTime and the reception of the first DATA frame.
timeToFirstByteSent <number> The number of milliseconds elapsed between
the PerformanceEntry startTime and sending of the first DATA frame.
timeToFirstHeader <number> The number of milliseconds elapsed between the
PerformanceEntry startTime and the reception of the first header.
If performanceEntry.name is equal to Http2Session, the detail will
contain the following properties:
bytesRead <number> The number of bytes received for this Http2Session.
bytesWritten <number> The number of bytes sent for this Http2Session.
framesReceived <number> The number of HTTP/2 frames received by the
Http2Session.
framesSent <number> The number of HTTP/2 frames sent by the Http2Session.
maxConcurrentStreams <number> The maximum number of streams concurrently
open during the lifetime of the Http2Session.
pingRTT <number> The number of milliseconds elapsed since the transmission
of a PING frame and the reception of its acknowledgment. Only present if
a PING frame has been sent on the Http2Session.
streamAverageDuration <number> The average duration (in milliseconds) for
all Http2Stream instances.
streamCount <number> The number of Http2Stream instances processed by
the Http2Session.
type <string> Either 'server' or 'client' to identify the type of
Http2Session.
Timerify ('function') Details#
When performanceEntry.type is equal to 'function', the
performanceNodeEntry.detail property will be an <Array> listing
the input arguments to the timed function.
Net ('net') Details#
When performanceEntry.type is equal to 'net', the
performanceNodeEntry.detail property will be an <Object> containing
additional information.
If performanceEntry.name is equal to connect, the detail
will contain the following properties: host, port.
DNS ('dns') Details#
When performanceEntry.type is equal to 'dns', the
performanceNodeEntry.detail property will be an <Object> containing
additional information.
If performanceEntry.name is equal to lookup, the detail
will contain the following properties: hostname, family, hints, verbatim,
addresses.
If performanceEntry.name is equal to lookupService, the detail will
contain the following properties: host, port, hostname, service.
If performanceEntry.name is equal to queryxxx or getHostByAddr, the detail will
contain the following properties: host, ttl, result. The value of result is
same as the result of queryxxx or getHostByAddr.
Class: PerformanceNodeTiming#
Added in: v8.5.0
This property is an extension by Node.js. It is not available in Web browsers.
Provides timing details for Node.js itself. The constructor of this class
is not exposed to users.
performanceNodeTiming.bootstrapComplete#
Added in: v8.5.0
The high resolution millisecond timestamp at which the Node.js process
completed bootstrapping. If bootstrapping has not yet finished, the property
has the value of -1.
performanceNodeTiming.environment#
Added in: v8.5.0
The high resolution millisecond timestamp at which the Node.js environment was
initialized.
performanceNodeTiming.idleTime#
Added in: v14.10.0, v12.19.0
The high resolution millisecond timestamp of the amount of time the event loop
has been idle within the event loop's event provider (e.g. epoll_wait). This
does not take CPU usage into consideration. If the event loop has not yet
started (e.g., in the first tick of the main script), the property has the
value of 0.
performanceNodeTiming.loopExit#
Added in: v8.5.0
The high resolution millisecond timestamp at which the Node.js event loop
exited. If the event loop has not yet exited, the property has the value of -1.
It can only have a value of not -1 in a handler of the 'exit' event.
performanceNodeTiming.loopStart#
Added in: v8.5.0
The high resolution millisecond timestamp at which the Node.js event loop
started. If the event loop has not yet started (e.g., in the first tick of the
main script), the property has the value of -1.
performanceNodeTiming.nodeStart#
Added in: v8.5.0
The high resolution millisecond timestamp at which the Node.js process was
initialized.
performanceNodeTiming.uvMetricsInfo#
Added in: v22.8.0
- Returns: <Object>
loopCount <number> Number of event loop iterations.
events <number> Number of events that have been processed by the event handler.
eventsWaiting <number> Number of events that were waiting to be processed when the event provider was called.
This is a wrapper to the uv_metrics_info function.
It returns the current set of event loop metrics.
It is recommended to use this property inside a function whose execution was
scheduled using setImmediate to avoid collecting metrics before finishing all
operations scheduled during the current loop iteration.
const { performance } = require('node:perf_hooks');
setImmediate(() => {
console.log(performance.nodeTiming.uvMetricsInfo);
});import { performance } from 'node:perf_hooks';
setImmediate(() => {
console.log(performance.nodeTiming.uvMetricsInfo);
});
performanceNodeTiming.v8Start#
Added in: v8.5.0
The high resolution millisecond timestamp at which the V8 platform was
initialized.
Class: PerformanceResourceTiming#
Added in: v18.2.0, v16.17.0
Provides detailed network timing data regarding the loading of an application's
resources.
The constructor of this class is not exposed to users directly.
performanceResourceTiming.workerStart#
The high resolution millisecond timestamp at immediately before dispatching
the fetch request. If the resource is not intercepted by a worker the property
will always return 0.
performanceResourceTiming.redirectStart#
The high resolution millisecond timestamp that represents the start time
of the fetch which initiates the redirect.
performanceResourceTiming.redirectEnd#
The high resolution millisecond timestamp that will be created immediately after
receiving the last byte of the response of the last redirect.
performanceResourceTiming.fetchStart#
The high resolution millisecond timestamp immediately before the Node.js starts
to fetch the resource.
performanceResourceTiming.domainLookupStart#
The high resolution millisecond timestamp immediately before the Node.js starts
the domain name lookup for the resource.
performanceResourceTiming.domainLookupEnd#
The high resolution millisecond timestamp representing the time immediately
after the Node.js finished the domain name lookup for the resource.
performanceResourceTiming.connectStart#
The high resolution millisecond timestamp representing the time immediately
before Node.js starts to establish the connection to the server to retrieve
the resource.
performanceResourceTiming.connectEnd#
The high resolution millisecond timestamp representing the time immediately
after Node.js finishes establishing the connection to the server to retrieve
the resource.
performanceResourceTiming.secureConnectionStart#
The high resolution millisecond timestamp representing the time immediately
before Node.js starts the handshake process to secure the current connection.
performanceResourceTiming.requestStart#
The high resolution millisecond timestamp representing the time immediately
before Node.js receives the first byte of the response from the server.
performanceResourceTiming.responseEnd#
The high resolution millisecond timestamp representing the time immediately
after Node.js receives the last byte of the resource or immediately before
the transport connection is closed, whichever comes first.
performanceResourceTiming.transferSize#
A number representing the size (in octets) of the fetched resource. The size
includes the response header fields plus the response payload body.
performanceResourceTiming.encodedBodySize#
A number representing the size (in octets) received from the fetch
(HTTP or cache), of the payload body, before removing any applied
content-codings.
performanceResourceTiming.decodedBodySize#
A number representing the size (in octets) received from the fetch
(HTTP or cache), of the message body, after removing any applied
content-codings.
performanceResourceTiming.toJSON()#
Returns a object that is the JSON representation of the
PerformanceResourceTiming object
Class: PerformanceObserver#
Added in: v8.5.0
PerformanceObserver.supportedEntryTypes#
Added in: v16.0.0
Get supported types.
new PerformanceObserver(callback)#
PerformanceObserver objects provide notifications when new
PerformanceEntry instances have been added to the Performance Timeline.
import { performance, PerformanceObserver } from 'node:perf_hooks';
const obs = new PerformanceObserver((list, observer) => {
console.log(list.getEntries());
performance.clearMarks();
performance.clearMeasures();
observer.disconnect();
});
obs.observe({ entryTypes: ['mark'], buffered: true });
performance.mark('test');const {
performance,
PerformanceObserver,
} = require('node:perf_hooks');
const obs = new PerformanceObserver((list, observer) => {
console.log(list.getEntries());
performance.clearMarks();
performance.clearMeasures();
observer.disconnect();
});
obs.observe({ entryTypes: ['mark'], buffered: true });
performance.mark('test');
Because PerformanceObserver instances introduce their own additional
performance overhead, instances should not be left subscribed to notifications
indefinitely. Users should disconnect observers as soon as they are no
longer needed.
The callback is invoked when a PerformanceObserver is
notified about new PerformanceEntry instances. The callback receives a
PerformanceObserverEntryList instance and a reference to the
PerformanceObserver.
performanceObserver.disconnect()#
Added in: v8.5.0
Disconnects the PerformanceObserver instance from all notifications.
performanceObserver.takeRecords()#
Added in: v16.0.0
- Returns: <PerformanceEntry[]> Current list of entries stored in the performance observer, emptying it out.
Class: PerformanceObserverEntryList#
Added in: v8.5.0
The PerformanceObserverEntryList class is used to provide access to the
PerformanceEntry instances passed to a PerformanceObserver.
The constructor of this class is not exposed to users.
performanceObserverEntryList.getEntriesByName(name[, type])#
Added in: v8.5.0
Returns a list of PerformanceEntry objects in chronological order
with respect to performanceEntry.startTime whose performanceEntry.name is
equal to name, and optionally, whose performanceEntry.entryType is equal to
type.
import { performance, PerformanceObserver } from 'node:perf_hooks';
const obs = new PerformanceObserver((perfObserverList, observer) => {
console.log(perfObserverList.getEntriesByName('meow'));
console.log(perfObserverList.getEntriesByName('nope'));
console.log(perfObserverList.getEntriesByName('test', 'mark'));
console.log(perfObserverList.getEntriesByName('test', 'measure'));
performance.clearMarks();
performance.clearMeasures();
observer.disconnect();
});
obs.observe({ entryTypes: ['mark', 'measure'] });
performance.mark('test');
performance.mark('meow');const {
performance,
PerformanceObserver,
} = require('node:perf_hooks');
const obs = new PerformanceObserver((perfObserverList, observer) => {
console.log(perfObserverList.getEntriesByName('meow'));
console.log(perfObserverList.getEntriesByName('nope'));
console.log(perfObserverList.getEntriesByName('test', 'mark'));
console.log(perfObserverList.getEntriesByName('test', 'measure'));
performance.clearMarks();
performance.clearMeasures();
observer.disconnect();
});
obs.observe({ entryTypes: ['mark', 'measure'] });
performance.mark('test');
performance.mark('meow');
Class: Histogram#
Added in: v11.10.0
histogram.count#
Added in: v17.4.0, v16.14.0
The number of samples recorded by the histogram.
histogram.countBigInt#
Added in: v17.4.0, v16.14.0
The number of samples recorded by the histogram.
histogram.exceeds#
Added in: v11.10.0
The number of times the event loop delay exceeded the maximum 1 hour event
loop delay threshold.
histogram.exceedsBigInt#
Added in: v17.4.0, v16.14.0
The number of times the event loop delay exceeded the maximum 1 hour event
loop delay threshold.
histogram.max#
Added in: v11.10.0
The maximum recorded event loop delay.
histogram.maxBigInt#
Added in: v17.4.0, v16.14.0
The maximum recorded event loop delay.
histogram.mean#
Added in: v11.10.0
The mean of the recorded event loop delays.
histogram.min#
Added in: v11.10.0
The minimum recorded event loop delay.
histogram.minBigInt#
Added in: v17.4.0, v16.14.0
The minimum recorded event loop delay.
histogram.percentile(percentile)#
Added in: v11.10.0
Returns the value at the given percentile.
histogram.percentileBigInt(percentile)#
Added in: v17.4.0, v16.14.0
Returns the value at the given percentile.
histogram.percentiles#
Added in: v11.10.0
Returns a Map object detailing the accumulated percentile distribution.
histogram.percentilesBigInt#
Added in: v17.4.0, v16.14.0
Returns a Map object detailing the accumulated percentile distribution.
histogram.reset()#
Added in: v11.10.0
Resets the collected histogram data.
histogram.stddev#
Added in: v11.10.0
The standard deviation of the recorded event loop delays.
Examples#
Measuring the duration of async operations#
The following example uses the Async Hooks and Performance APIs to measure
the actual duration of a Timeout operation (including the amount of time it took
to execute the callback).
import { createHook } from 'node:async_hooks';
import { performance, PerformanceObserver } from 'node:perf_hooks';
const set = new Set();
const hook = createHook({
init(id, type) {
if (type === 'Timeout') {
performance.mark(`Timeout-${id}-Init`);
set.add(id);
}
},
destroy(id) {
if (set.has(id)) {
set.delete(id);
performance.mark(`Timeout-${id}-Destroy`);
performance.measure(`Timeout-${id}`,
`Timeout-${id}-Init`,
`Timeout-${id}-Destroy`);
}
},
});
hook.enable();
const obs = new PerformanceObserver((list, observer) => {
console.log(list.getEntries()[0]);
performance.clearMarks();
performance.clearMeasures();
observer.disconnect();
});
obs.observe({ entryTypes: ['measure'], buffered: true });
setTimeout(() => {}, 1000);'use strict';
const async_hooks = require('node:async_hooks');
const {
performance,
PerformanceObserver,
} = require('node:perf_hooks');
const set = new Set();
const hook = async_hooks.createHook({
init(id, type) {
if (type === 'Timeout') {
performance.mark(`Timeout-${id}-Init`);
set.add(id);
}
},
destroy(id) {
if (set.has(id)) {
set.delete(id);
performance.mark(`Timeout-${id}-Destroy`);
performance.measure(`Timeout-${id}`,
`Timeout-${id}-Init`,
`Timeout-${id}-Destroy`);
}
},
});
hook.enable();
const obs = new PerformanceObserver((list, observer) => {
console.log(list.getEntries()[0]);
performance.clearMarks();
performance.clearMeasures();
observer.disconnect();
});
obs.observe({ entryTypes: ['measure'] });
setTimeout(() => {}, 1000);