Performance measurement APIs

Performance measurement APIs

Stability: 2 - Stable

This module provides an implementation of a subset of the W3C [Web Performance APIs][] as well as additional APIs for Node.js-specific performance measurements.

Node.js supports the following [Web Performance APIs][]:

[High Resolution Time][]
[Performance Timeline][]
[User Timing][]
[Resource Timing][]

import { performance, PerformanceObserver } from 'node:perf_hooks';

const obs = new PerformanceObserver((items) => {
  console.log(items.getEntries()[0].duration);
  performance.clearMarks();
});
obs.observe({ type: 'measure' });
performance.measure('Start to Now');

performance.mark('A');
doSomeLongRunningProcess(() => {
  performance.measure('A to Now', 'A');

  performance.mark('B');
  performance.measure('A to B', 'A', 'B');
});

const { PerformanceObserver, performance } = require('node:perf_hooks');

const obs = new PerformanceObserver((items) => {
  console.log(items.getEntries()[0].duration);
});
obs.observe({ type: 'measure' });
performance.measure('Start to Now');

performance.mark('A');
(async function doSomeLongRunningProcess() {
  await new Promise((r) => setTimeout(r, 5000));
  performance.measure('A to Now', 'A');

  performance.mark('B');
  performance.measure('A to B', 'A', 'B');
})();

`perf_hooks.performance`

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])`

name {string}

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])`

name {string}

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])`

name {string}

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]])`

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}
idle {number}
active {number}
utilization {number}

This is an alias of [perf_hooks.eventLoopUtilization()][].

This property is an extension by Node.js. It is not available in Web browsers.

`performance.getEntries()`

Returns: {PerformanceEntry[]}

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])`

name {string}
type {string}
Returns: {PerformanceEntry[]}

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)`

type {string}
Returns: {PerformanceEntry[]}

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])`

timingInfo {Object} [Fetch Timing Info][]
requestedUrl {string} The resource url
initiatorType {string} The initiator name, e.g: 'fetch'
global {Object}
cacheMode {string} The cache mode must be an empty string ('') or 'local'
bodyInfo {Object} [Fetch Response Body Info][]
responseStatus {number} The response's status code
deliveryType {string} The delivery type. Default: ''.

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`

Type: {PerformanceNodeTiming}

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: {number}

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`

Type: {number}

The [timeOrigin][] specifies the high resolution millisecond timestamp at which the current node process began, measured in Unix time.

`performance.timerify(fn[, options])`

fn {Function}
options {Object}
histogram {RecordableHistogram} A histogram object created using perf_hooks.createHistogram() that will record runtime durations in nanoseconds.

This is an alias of [perf_hooks.timerify()][].

This property is an extension by Node.js. It is not available in Web browsers.

`performance.toJSON()`

An object which is JSON representation of the performance object. It is similar to [window.performance.toJSON][] in browsers.

Event: `'resourcetimingbufferfull'`

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: `PerformanceEntry`

The constructor of this class is not exposed to users directly.

`performanceEntry.duration`

Type: {number}

The total number of milliseconds elapsed for this entry. This value will not be meaningful for all Performance Entry types.

`performanceEntry.entryType`

Type: {string}

The type of the performance entry. It may be one of:

'dns' (Node.js only)
'function' (Node.js only)
'gc' (Node.js only)
'http2' (Node.js only)
'http' (Node.js only)
'mark' (available on the Web)
'measure' (available on the Web)
'net' (Node.js only)
'node' (Node.js only)
'resource' (available on the Web)

`performanceEntry.name`

Type: {string}

The name of the performance entry.

`performanceEntry.startTime`

Type: {number}

The high resolution millisecond timestamp marking the starting time of the Performance Entry.

Class: `PerformanceMark`

Extends: {PerformanceEntry}

Exposes marks created via the Performance.mark() method.

`performanceMark.detail`

Type: {any}

Additional detail specified when creating with Performance.mark() method.

Class: `PerformanceMeasure`

Extends: {PerformanceEntry}

Exposes measures created via the Performance.measure() method.

The constructor of this class is not exposed to users directly.

`performanceMeasure.detail`

Type: {any}

Additional detail specified when creating with Performance.measure() method.

Class: `PerformanceNodeEntry`

Extends: {PerformanceEntry}

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`

Type: {any}

Additional detail specific to the entryType.

`performanceNodeEntry.flags`

Stability: 0 - Deprecated: Use performanceNodeEntry.detail instead.

Type: {number}

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.

Type: {number}

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_MINOR_MARK_SWEEP
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_MINOR_MARK_SWEEP
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`

Extends: {PerformanceEntry}

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`

Type: {number}

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`

Type: {number}

The high resolution millisecond timestamp at which the Node.js environment was initialized.

`performanceNodeTiming.idleTime`

Type: {number}

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`

Type: {number}

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`

Type: {number}

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`

Type: {number}

The high resolution millisecond timestamp at which the Node.js process was initialized.

`performanceNodeTiming.uvMetricsInfo`

Type: {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.

The values are exact up to Number.MAX_SAFE_INTEGER. Use [performanceNodeTiming.uvMetricsInfoBigInt][] to obtain the full 64-bit values reported by libuv.

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.uvMetricsInfoBigInt`

Type: {Object}
loopCount {bigint} Number of event loop iterations.
events {bigint} Number of events that have been processed by the event handler.
eventsWaiting {bigint} Number of events that were waiting to be processed when the event provider was called.

The same as [performanceNodeTiming.uvMetricsInfo][], except that the values are {bigint}s carrying the full 64-bit range reported by libuv.

Because JSON.stringify() cannot serialize {bigint} values, this property is not enumerable and is not included in the output of performanceNodeTiming.toJSON(). Copies of performance.nodeTiming made by spreading its enumerable properties, for example, remain serializable.

const { performance } = require('node:perf_hooks');

setImmediate(() => {
  console.log(performance.nodeTiming.uvMetricsInfoBigInt);
});

import { performance } from 'node:perf_hooks';

setImmediate(() => {
  console.log(performance.nodeTiming.uvMetricsInfoBigInt);
});

`performanceNodeTiming.v8Start`

Type: {number}

The high resolution millisecond timestamp at which the V8 platform was initialized.

Class: `PerformanceResourceTiming`

Extends: {PerformanceEntry}

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`

Type: {number}

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`

Type: {number}

The high resolution millisecond timestamp that represents the start time of the fetch which initiates the redirect.

`performanceResourceTiming.redirectEnd`

Type: {number}

The high resolution millisecond timestamp that will be created immediately after receiving the last byte of the response of the last redirect.

`performanceResourceTiming.fetchStart`

Type: {number}

The high resolution millisecond timestamp immediately before the Node.js starts to fetch the resource.

`performanceResourceTiming.domainLookupStart`

Type: {number}

The high resolution millisecond timestamp immediately before the Node.js starts the domain name lookup for the resource.

`performanceResourceTiming.domainLookupEnd`

Type: {number}

The high resolution millisecond timestamp representing the time immediately after the Node.js finished the domain name lookup for the resource.

`performanceResourceTiming.connectStart`

Type: {number}

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`

Type: {number}

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`

Type: {number}

The high resolution millisecond timestamp representing the time immediately before Node.js starts the handshake process to secure the current connection.

`performanceResourceTiming.requestStart`

Type: {number}

The high resolution millisecond timestamp representing the time immediately before Node.js receives the first byte of the response from the server.

`performanceResourceTiming.finalResponseHeadersStart`

Type: {number}

The high resolution millisecond timestamp representing the time immediately after Node.js receives the first byte of the final response, as opposed to an interim response.

`performanceResourceTiming.firstInterimResponseStart`

Type: {number}

The high resolution millisecond timestamp representing the time immediately after Node.js receives the first byte of the first interim response, such as a 103 Early Hints response.

`performanceResourceTiming.responseStart`

Type: {number}

The high resolution millisecond timestamp representing the time immediately after Node.js receives the first byte of the response from the server. This is firstInterimResponseStart when it is non-zero, and finalResponseHeadersStart otherwise.

`performanceResourceTiming.responseEnd`

Type: {number}

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`

Type: {number}

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`

Type: {number}

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`

Type: {number}

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.renderBlockingStatus`

Type: {string}

The render blocking status of the resource. It is either 'blocking' or 'non-blocking'.

`performanceResourceTiming.contentType`

Type: {string}

The minimized MIME type of the content of the fetched resource, or an empty string if it cannot be determined.

`performanceResourceTiming.contentEncoding`

Type: {string}

The content encoding of the fetched resource, such as 'gzip' or 'br'.

`performanceResourceTiming.toJSON()`

Returns a object that is the JSON representation of the PerformanceResourceTiming object

Class: `PerformanceObserver`

`PerformanceObserver.supportedEntryTypes`

Type: {string[]}

Get supported types.

`new PerformanceObserver(callback)`

callback {Function}
list {PerformanceObserverEntryList}
observer {PerformanceObserver}

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()`

Disconnects the PerformanceObserver instance from all notifications.

`performanceObserver.observe(options)`

options {Object}
type {string} A single {PerformanceEntry} type. Must not be given if entryTypes is already specified.
entryTypes {string[]} An array of strings identifying the types of {PerformanceEntry} instances the observer is interested in. If not provided an error will be thrown.
buffered {boolean} If true, the observer callback is called with a list global PerformanceEntry buffered entries. If false, only PerformanceEntrys created after the time point are sent to the observer callback. Default: false.

Subscribes the {PerformanceObserver} instance to notifications of new {PerformanceEntry} instances identified either by options.entryTypes or options.type:

import { performance, PerformanceObserver } from 'node:perf_hooks';

const obs = new PerformanceObserver((list, observer) => {
  // Called once asynchronously. `list` contains three items.
});
obs.observe({ type: 'mark' });

for (let n = 0; n < 3; n++)
  performance.mark(`test${n}`);

const {
  performance,
  PerformanceObserver,
} = require('node:perf_hooks');

const obs = new PerformanceObserver((list, observer) => {
  // Called once asynchronously. `list` contains three items.
});
obs.observe({ type: 'mark' });

for (let n = 0; n < 3; n++)
  performance.mark(`test${n}`);

`performanceObserver.takeRecords()`

Returns: {PerformanceEntry[]} Current list of entries stored in the performance observer, emptying it out.

Class: `PerformanceObserverEntryList`

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.getEntries()`

Returns: {PerformanceEntry[]}

Returns a list of PerformanceEntry objects in chronological order with respect to performanceEntry.startTime.

import { performance, PerformanceObserver } from 'node:perf_hooks';

const obs = new PerformanceObserver((perfObserverList, observer) => {
  console.log(perfObserverList.getEntries());
  /**
   * [
   *   PerformanceEntry {
   *     name: 'test',
   *     entryType: 'mark',
   *     startTime: 81.465639,
   *     duration: 0,
   *     detail: null
   *   },
   *   PerformanceEntry {
   *     name: 'meow',
   *     entryType: 'mark',
   *     startTime: 81.860064,
   *     duration: 0,
   *     detail: null
   *   }
   * ]
   */

  performance.clearMarks();
  performance.clearMeasures();
  observer.disconnect();
});
obs.observe({ type: 'mark' });

performance.mark('test');
performance.mark('meow');

const {
  performance,
  PerformanceObserver,
} = require('node:perf_hooks');

const obs = new PerformanceObserver((perfObserverList, observer) => {
  console.log(perfObserverList.getEntries());
  /**
   * [
   *   PerformanceEntry {
   *     name: 'test',
   *     entryType: 'mark',
   *     startTime: 81.465639,
   *     duration: 0,
   *     detail: null
   *   },
   *   PerformanceEntry {
   *     name: 'meow',
   *     entryType: 'mark',
   *     startTime: 81.860064,
   *     duration: 0,
   *     detail: null
   *   }
   * ]
   */

  performance.clearMarks();
  performance.clearMeasures();
  observer.disconnect();
});
obs.observe({ type: 'mark' });

performance.mark('test');
performance.mark('meow');

`performanceObserverEntryList.getEntriesByName(name[, type])`

name {string}
type {string}
Returns: {PerformanceEntry[]}

```mjs import { performance, PerformanceObserver } from 'node:perf_hooks';

const obs = new PerformanceObserver((perfObserverList, observer) => { console.log(perfObserverList.getEntriesByName('meow')); /* * [ * PerformanceEntry { * name: 'meow', * entryType: 'mark', * startTime: 98.545991, * duration: 0, * detail: null * } * ] / console.log(perfObserverList.getEntriesByName('nope')); // []

console.log(perfObserverList.getEntriesByName('test', 'mark')); /* * [ * PerformanceEntry { * name: 'test', * entryType: 'mark', * startTime: 63.518931, * duration: 0, * detail: null * } * ] / console.log(perfObserverList.getEntriesByName('test', 'measure')); // []

performance.clearMarks(); performance.clearMeasures(); observer.disconnect(); }); obs.observe({ entryTypes: ['mark', 'measure'] });

performance.mark('test');

（本文超出站点单文档体积上限，已截断）

Performance measurement APIs

Performance measurement APIs

perf_hooks.performance

performance.clearMarks([name])

performance.clearMeasures([name])

performance.clearResourceTimings([name])

performance.eventLoopUtilization([utilization1[, utilization2]])

performance.getEntries()

performance.getEntriesByName(name[, type])

performance.getEntriesByType(type)

performance.mark(name[, options])

performance.markResourceTiming(timingInfo, requestedUrl, initiatorType, global, cacheMode, bodyInfo, responseStatus[, deliveryType])

performance.measure(name[, startMarkOrOptions[, endMark]])

performance.nodeTiming

performance.now()

performance.setResourceTimingBufferSize(maxSize)

performance.timeOrigin

performance.timerify(fn[, options])

performance.toJSON()

Event: 'resourcetimingbufferfull'

Class: PerformanceEntry

performanceEntry.duration

performanceEntry.entryType

performanceEntry.name

performanceEntry.startTime

Class: PerformanceMark

performanceMark.detail

Class: PerformanceMeasure

performanceMeasure.detail

Class: PerformanceNodeEntry

performanceNodeEntry.detail

performanceNodeEntry.flags

performanceNodeEntry.kind

Garbage Collection ('gc') Details

HTTP ('http') Details

HTTP/2 ('http2') Details

Timerify ('function') Details

Net ('net') Details

DNS ('dns') Details

Class: PerformanceNodeTiming

performanceNodeTiming.bootstrapComplete

performanceNodeTiming.environment

performanceNodeTiming.idleTime

performanceNodeTiming.loopExit

performanceNodeTiming.loopStart

performanceNodeTiming.nodeStart

performanceNodeTiming.uvMetricsInfo

performanceNodeTiming.uvMetricsInfoBigInt

performanceNodeTiming.v8Start

Class: PerformanceResourceTiming

performanceResourceTiming.workerStart

performanceResourceTiming.redirectStart

performanceResourceTiming.redirectEnd

performanceResourceTiming.fetchStart

performanceResourceTiming.domainLookupStart

performanceResourceTiming.domainLookupEnd

performanceResourceTiming.connectStart

performanceResourceTiming.connectEnd

performanceResourceTiming.secureConnectionStart

performanceResourceTiming.requestStart

performanceResourceTiming.finalResponseHeadersStart

performanceResourceTiming.firstInterimResponseStart

performanceResourceTiming.responseStart

performanceResourceTiming.responseEnd

performanceResourceTiming.transferSize

performanceResourceTiming.encodedBodySize

performanceResourceTiming.decodedBodySize

performanceResourceTiming.renderBlockingStatus

performanceResourceTiming.contentType

performanceResourceTiming.contentEncoding

performanceResourceTiming.toJSON()

Class: PerformanceObserver

PerformanceObserver.supportedEntryTypes

new PerformanceObserver(callback)

performanceObserver.disconnect()

performanceObserver.observe(options)

performanceObserver.takeRecords()

Class: PerformanceObserverEntryList

performanceObserverEntryList.getEntries()

performanceObserverEntryList.getEntriesByName(name[, type])

`perf_hooks.performance`

`performance.clearMarks([name])`

`performance.clearMeasures([name])`

`performance.clearResourceTimings([name])`

`performance.eventLoopUtilization([utilization1[, utilization2]])`

`performance.getEntries()`

`performance.getEntriesByName(name[, type])`

`performance.getEntriesByType(type)`

`performance.mark(name[, options])`

`performance.markResourceTiming(timingInfo, requestedUrl, initiatorType, global, cacheMode, bodyInfo, responseStatus[, deliveryType])`

`performance.measure(name[, startMarkOrOptions[, endMark]])`

`performance.nodeTiming`

`performance.now()`

`performance.setResourceTimingBufferSize(maxSize)`

`performance.timeOrigin`

`performance.timerify(fn[, options])`

`performance.toJSON()`

Event: `'resourcetimingbufferfull'`

Class: `PerformanceEntry`

`performanceEntry.duration`

`performanceEntry.entryType`

`performanceEntry.name`

`performanceEntry.startTime`

Class: `PerformanceMark`

`performanceMark.detail`

Class: `PerformanceMeasure`

`performanceMeasure.detail`

Class: `PerformanceNodeEntry`

`performanceNodeEntry.detail`

`performanceNodeEntry.flags`

`performanceNodeEntry.kind`

Class: `PerformanceNodeTiming`

`performanceNodeTiming.bootstrapComplete`

`performanceNodeTiming.environment`

`performanceNodeTiming.idleTime`

`performanceNodeTiming.loopExit`

`performanceNodeTiming.loopStart`

`performanceNodeTiming.nodeStart`

`performanceNodeTiming.uvMetricsInfo`

`performanceNodeTiming.uvMetricsInfoBigInt`

`performanceNodeTiming.v8Start`

Class: `PerformanceResourceTiming`

`performanceResourceTiming.workerStart`

`performanceResourceTiming.redirectStart`

`performanceResourceTiming.redirectEnd`

`performanceResourceTiming.fetchStart`

`performanceResourceTiming.domainLookupStart`

`performanceResourceTiming.domainLookupEnd`

`performanceResourceTiming.connectStart`

`performanceResourceTiming.connectEnd`

`performanceResourceTiming.secureConnectionStart`

`performanceResourceTiming.requestStart`

`performanceResourceTiming.finalResponseHeadersStart`

`performanceResourceTiming.firstInterimResponseStart`

`performanceResourceTiming.responseStart`

`performanceResourceTiming.responseEnd`

`performanceResourceTiming.transferSize`

`performanceResourceTiming.encodedBodySize`

`performanceResourceTiming.decodedBodySize`

`performanceResourceTiming.renderBlockingStatus`

`performanceResourceTiming.contentType`

`performanceResourceTiming.contentEncoding`

`performanceResourceTiming.toJSON()`

Class: `PerformanceObserver`

`PerformanceObserver.supportedEntryTypes`

`new PerformanceObserver(callback)`

`performanceObserver.disconnect()`

`performanceObserver.observe(options)`

`performanceObserver.takeRecords()`

Class: `PerformanceObserverEntryList`

`performanceObserverEntryList.getEntries()`

`performanceObserverEntryList.getEntriesByName(name[, type])`