perf_hooks

Additional detail specific to the entryType.

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

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

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

The name of the performance entry.

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

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.

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

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.

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.

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.

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

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.

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

Disconnects the PerformanceObserver instance from all notifications.

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

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');

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 totype.

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.mark('meow');

Returns a list of PerformanceEntry objects in chronological order with respect to performanceEntry.startTime whose performanceEntry.entryType is equal to type.

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

const obs = new PerformanceObserver((perfObserverList, observer) => {
  console.log(perfObserverList.getEntriesByType('mark'));

   * [
   *   PerformanceEntry {
   *     name: 'test',
   *     entryType: 'mark',
   *     startTime: 55.897834,
   *     duration: 0,
   *     detail: null
   *   },
   *   PerformanceEntry {
   *     name: 'meow',
   *     entryType: 'mark',
   *     startTime: 56.350146,
   *     duration: 0,
   *     detail: null
   *   }
   * ]

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

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

The high resolution millisecond timestamp representing the time immediately after Node.js finishes establishing the connection to the server to retrieve the resource.

The high resolution millisecond timestamp representing the time immediately before Node.js starts to establish the connection to the server to retrieve the resource.

A number representing the size (in octets) received from the fetch (HTTP or cache), of the message body, after removing any applied content-codings.

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

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

A number representing the size (in octets) received from the fetch (HTTP or cache), of the payload body, before removing any applied content-codings.

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

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

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

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

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.

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

A number representing the size (in octets) of the fetched resource. The size includes the response header fields plus the response payload body.

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.

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

The minimum recordable value. Must be an integer value greater than 0.

The maximum recordable value. Must be an integer value greater than min.

The number of accuracy digits. Must be a number between 1 and 5.

The sampling rate in milliseconds. Must be greater than zero.

The number of samples recorded by the histogram.

The number of samples recorded by the histogram. v17.4.0, v16.14.0

The number of times the event loop delay exceeded the maximum 1 hour event loop delay threshold.

The number of times the event loop delay exceeded the maximum 1 hour event loop delay threshold.

The maximum recorded event loop delay.

The maximum recorded event loop delay. v17.4.0, v16.14.0

The mean of the recorded event loop delays.

The minimum recorded event loop delay.

The minimum recorded event loop delay. v17.4.0, v16.14.0

Returns a Map object detailing the accumulated percentile distribution.

Returns a Map object detailing the accumulated percentile distribution.

The standard deviation of the recorded event loop delays.

Returns the value at the given percentile.

Returns the value at the given percentile.

Resets the collected histogram data.

Enables the update interval timer. Returns true if the timer was started, false if it was already started.

Disables the update interval timer. Returns true if the timer was stopped, false if it was already stopped.

Additional optional detail to include with the mark.

An optional timestamp to be used as the mark time.

Additional optional detail to include with the mark.

Duration between start and end times.

Timestamp to be used as the end time, or a string identifying a previously recorded mark.

Timestamp to be used as the start time, or a string identifying a previously recorded mark.

When performanceEntry.entryType is equal to 'gc', the performance.kind property identifies the type of garbage collection operation that occurred. See perf_hooks.constants for valid values.

When performanceEntry.entryType is equal to 'gc', the performance.flags property contains additional information about garbage collection operation. See perf_hooks.constants for valid values.

eventLoopUtilization is similar to CPU utilization except that it is calculated using high precision wall-clock time. 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.

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.

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

If name is not provided, removes all PerformanceMark objects from the Performance Timeline. If name is provided, removes only the named mark.

If name is not provided, removes all PerformanceMeasure objects from the Performance Timeline. If name is provided, removes only the named measure.

If name is not provided, removes all PerformanceResourceTiming objects from the Resource Timeline. If name is provided, removes only the named resource.

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

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.

Returns a list of PerformanceEntry objects in chronological order with respect to performanceEntry.startTime whose performanceEntry.entryType is equal to type.

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.

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.

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 the Performance Timeline, or may identify any of the timestamp properties provided by the PerformanceNodeTiming class. If the named startMark does not exist, then startMark is set to timeOrigin by default.

The endMark argument must identify any existing PerformanceMark in the the Performance Timeline or any of the timestamp properties provided by the PerformanceNodeTiming class. If the named endMark does not exist, an error will be thrown.

Returns the current high resolution millisecond timestamp, where 0 represents the start of the current node process.

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.

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'] });

// A performance timeline entry will be created
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.

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

Calculates the amount of time (in nanoseconds) that has passed since the previous call to recordDelta() and records that amount in the histogram.

Adds the values from other to this histogram.

A histogram object created using perf_hooks.createHistogram() that will record runtime durations in nanoseconds.

Number of event loop iterations.

Number of events that have been processed by the event handler.

Number of events that were waiting to be processed when the event provider was called.