perf_hooks.Performance

interface Performance

• readonly nodeTiming: PerformanceNodeTiming
• onresourcetimingbufferfull: null | (ev: Event) => void
• readonly timeOrigin: number
• addEventListener<K extends 'resourcetimingbufferfull'>(

  type: K,

  listener: (ev: PerformanceEventMap[K]) => void,

  options?: boolean | AddEventListenerOptions

  ): void;

  Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched.

  The options argument sets listener-specific options. For compatibility this can be a boolean, in which case the method behaves exactly as if the value was specified as options's capture.

  When set to true, options's capture prevents callback from being invoked when the event's eventPhase attribute value is BUBBLING_PHASE. When false (or not present), callback will not be invoked when event's eventPhase attribute value is CAPTURING_PHASE. Either way, callback will be invoked if event's eventPhase attribute value is AT_TARGET.

  When set to true, options's passive indicates that the callback will not cancel the event by invoking preventDefault(). This is used to enable performance optimizations described in § 2.8 Observing event listeners.

  When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed.

  If an AbortSignal is passed for options's signal, then the event listener will be removed when signal is aborted.

  The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.

  MDN Reference

  addEventListener(

  type: string,

  listener: EventListener | EventListenerObject,

  options?: boolean | AddEventListenerOptions

  ): void;

  Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched.

  The options argument sets listener-specific options. For compatibility this can be a boolean, in which case the method behaves exactly as if the value was specified as options's capture.

  When set to true, options's capture prevents callback from being invoked when the event's eventPhase attribute value is BUBBLING_PHASE. When false (or not present), callback will not be invoked when event's eventPhase attribute value is CAPTURING_PHASE. Either way, callback will be invoked if event's eventPhase attribute value is AT_TARGET.

  When set to true, options's passive indicates that the callback will not cancel the event by invoking preventDefault(). This is used to enable performance optimizations described in § 2.8 Observing event listeners.

  When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed.

  If an AbortSignal is passed for options's signal, then the event listener will be removed when signal is aborted.

  The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.

  MDN Reference
• clearMarks(

  markName?: string

  ): void;
• clearMeasures(

  measureName?: string

  ): void;
• clearResourceTimings(

  resourceTimingName?: string

  ): void;
• dispatchEvent(

  event: Event

  ): boolean;

  Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise.
• eventLoopUtilization(

  utilization1?: EventLoopUtilization,

  utilization2?: EventLoopUtilization

  ): EventLoopUtilization;

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

  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.

  @param utilization1

  The result of a previous call to eventLoopUtilization().

  @param utilization2

  The result of a previous call to eventLoopUtilization() prior to utilization1.

• getEntries(): PerformanceEntryList;
• getEntriesByName(

  name: string,

  type?: EntryType

  ): PerformanceEntryList;
• getEntriesByType(

  type: EntryType

  ): PerformanceEntryList;
• mark(

  markName: string,

  markOptions?: PerformanceMarkOptions

  ): PerformanceMark;
• markResourceTiming(

  timingInfo: FetchTimingInfo,

  requestedUrl: string,

  initiatorType: string,

  global: unknown,

  cacheMode: string,

  bodyInfo: unknown,

  responseStatus: number,

  deliveryType?: string

  ): PerformanceResourceTiming;
• measure(

  measureName: string,

  startMark?: string,

  endMark?: string

  ): PerformanceMeasure;

  measure(

  measureName: string,

  options: PerformanceMeasureOptions,

  endMark?: string

  ): PerformanceMeasure;
• now(): number;
• removeEventListener<K extends 'resourcetimingbufferfull'>(

  type: K,

  listener: (ev: PerformanceEventMap[K]) => void,

  options?: boolean | EventListenerOptions

  ): void;

  Removes the event listener in target's event listener list with the same type, callback, and options.

  MDN Reference

  removeEventListener(

  type: string,

  listener: EventListener | EventListenerObject,

  options?: boolean | EventListenerOptions

  ): void;

  Removes the event listener in target's event listener list with the same type, callback, and options.

  MDN Reference
• setResourceTimingBufferSize(

  maxSize: number

  ): void;
• timerify<T extends (...args: any[]) => any>(

  fn: T,

  options?: PerformanceTimerifyOptions

  ): T;

  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.
• toJSON(): any;