performance.clearMarks([name])#

• name<string>

Ifname is not provided, removes allPerformanceMark objects from thePerformance Timeline. Ifname is provided, removes only the named mark.

performance.clearMeasures([name])#

• name<string>

Ifname is not provided, removes allPerformanceMeasure objects from thePerformance Timeline. Ifname is provided, removes only the named measure.

performance.clearResourceTimings([name])#

• name<string>

Ifname is not provided, removes allPerformanceResourceTiming objects fromthe Resource Timeline. Ifname is provided, removes only the named resource.

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

• utilization1<Object> The result of a previous call toeventLoopUtilization().
• utilization2<Object> The result of a previous call toeventLoopUtilization() prior toutilization1.
• Returns:<Object>
  • idle<number>
  • active<number>
  • utilization<number>

TheeventLoopUtilization() method returns an object that contains thecumulative duration of time the event loop has been both idle and active as ahigh resolution milliseconds timer. Theutilization value is the calculatedEvent Loop Utilization (ELU).

If bootstrapping has not yet finished on the main thread the properties havethe value of0. The ELU is immediately available onWorker threads sincebootstrap happens within the event loop.

Bothutilization1 andutilization2 are optional parameters.

Ifutilization1 is passed, then the delta between the current call'sactiveandidle times, as well as the correspondingutilization value arecalculated and returned (similar toprocess.hrtime()).

Ifutilization1 andutilization2 are both passed, then the delta iscalculated between the two arguments. This is a convenience option because,unlikeprocess.hrtime(), calculating the ELU is more complex than asingle subtraction.

ELU is similar to CPU utilization, except that it only measures event loopstatistics and not CPU usage. It represents the percentage of time the eventloop 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 exampleof 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);});copy

Although the CPU is mostly idle while running this script, the value ofutilization is1. This is because the call tochild_process.spawnSync() blocks the event loop from proceeding.

Passing in a user-defined object instead of the result of a previous call toeventLoopUtilization() will lead to undefined behavior. The return valuesare not guaranteed to reflect any correct state of the event loop.

performance.getEntries()#

• Returns:<PerformanceEntry[]>

Returns a list ofPerformanceEntry objects in chronological order withrespect toperformanceEntry.startTime. If you are only interested inperformance entries of certain types or that have certain names, seeperformance.getEntriesByType() andperformance.getEntriesByName().

performance.getEntriesByName(name[, type])#

• name<string>
• type<string>
• Returns:<PerformanceEntry[]>

Returns a list ofPerformanceEntry objects in chronological orderwith respect toperformanceEntry.startTime whoseperformanceEntry.name isequal toname, and optionally, whoseperformanceEntry.entryType is equal totype.

performance.getEntriesByType(type)#

• type<string>
• Returns:<PerformanceEntry[]>

Returns a list ofPerformanceEntry objects in chronological orderwith respect toperformanceEntry.startTime whoseperformanceEntry.entryTypeis equal totype.

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 newPerformanceMark entry in the Performance Timeline. APerformanceMark is a subclass ofPerformanceEntry whoseperformanceEntry.entryType is always'mark', and whoseperformanceEntry.duration is always0. Performance marks are usedto mark specific significant moments in the Performance Timeline.

The createdPerformanceMark entry is put in the global Performance Timelineand can be queried withperformance.getEntries,performance.getEntriesByName, andperformance.getEntriesByType. When theobservation is performed, the entries should be cleared from the globalPerformance Timeline manually withperformance.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 newPerformanceResourceTiming entry in the Resource Timeline. APerformanceResourceTiming is a subclass ofPerformanceEntry whoseperformanceEntry.entryType is always'resource'. Performance resourcesare used to mark moments in the Resource Timeline.

The createdPerformanceMark entry is put in the global Resource Timelineand can be queried withperformance.getEntries,performance.getEntriesByName, andperformance.getEntriesByType. When theobservation is performed, the entries should be cleared from the globalPerformance Timeline manually withperformance.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 stringidentifying a previously recorded mark.
  • start<number> |<string> Timestamp to be used as the start time, or a stringidentifying a previously recorded mark.
• endMark<string> Optional. Must be omitted ifstartMarkOrOptions is an<Object>.

Creates a newPerformanceMeasure entry in the Performance Timeline. APerformanceMeasure is a subclass ofPerformanceEntry whoseperformanceEntry.entryType is always'measure', and whoseperformanceEntry.duration measures the number of milliseconds elapsed sincestartMark andendMark.

ThestartMark argument may identify anyexistingPerformanceMark in thePerformance Timeline, ormay identify any of the timestamp propertiesprovided by thePerformanceNodeTiming class. If the namedstartMark doesnot exist, an error is thrown.

The optionalendMark argument must identify anyexistingPerformanceMarkin the Performance Timeline or any of the timestamp properties provided by thePerformanceNodeTiming class.endMark will beperformance.now()if no parameter is passed, otherwise if the namedendMark does not exist, anerror will be thrown.

The createdPerformanceMeasure entry is put in the global Performance Timelineand can be queried withperformance.getEntries,performance.getEntriesByName, andperformance.getEntriesByType. When theobservation is performed, the entries should be cleared from the globalPerformance Timeline manually withperformance.clearMeasures.

performance.nodeTiming#

• Type:<PerformanceNodeTiming>

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

An instance of thePerformanceNodeTiming class that provides performancemetrics for specific Node.js operational milestones.

performance.now()#

• Returns:<number>

Returns the current high resolution millisecond timestamp, where 0 representsthe start of the currentnode process.

performance.setResourceTimingBufferSize(maxSize)#

Sets the global performance resource timing buffer size to the specified numberof "resource" type performance entry objects.

By default the max buffer size is set to 250.

performance.timeOrigin#

• Type:<number>

ThetimeOrigin specifies the high resolution millisecond timestamp atwhich the currentnode process began, measured in Unix time.

performance.timerify(fn[, options])#

• fn<Function>
• options<Object>
  • histogram<RecordableHistogram> A histogram object created usingperf_hooks.createHistogram() that will record runtime durations innanoseconds.

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 thewrapped function. APerformanceObserver must be subscribed to the'function'event type in order for the timing details to be accessed.

import { performance,PerformanceObserver }from'node:perf_hooks';functionsomeFunction() {console.log('hello world');}const wrapped = performance.timerify(someFunction);const obs =newPerformanceObserver((list) => {console.log(list.getEntries()[0].duration);  performance.clearMarks();  performance.clearMeasures();  obs.disconnect();});obs.observe({entryTypes: ['function'] });// A performance timeline entry will be createdwrapped();const {  performance,PerformanceObserver,} =require('node:perf_hooks');functionsomeFunction() {console.log('hello world');}const wrapped = performance.timerify(someFunction);const obs =newPerformanceObserver((list) => {console.log(list.getEntries()[0].duration);  performance.clearMarks();  performance.clearMeasures();  obs.disconnect();});obs.observe({entryTypes: ['function'] });// A performance timeline entry will be createdwrapped();copy

If the wrapped function returns a promise, a finally handler will be attachedto the promise and the duration will be reported once the finally handler isinvoked.

performance.toJSON()#

An object which is JSON representation of theperformance object. Itis similar towindow.performance.toJSON in browsers.

performanceEntry.duration#

• Type:<number>

The total number of milliseconds elapsed for this entry. This value will notbe 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 thePerformance Entry.

performanceMark.detail#

• Type:<any>

Additional detail specified when creating withPerformance.mark() method.

performanceMeasure.detail#

• Type:<any>

Additional detail specified when creating withPerformance.measure() method.

performanceNodeEntry.detail#

• Type:<any>

Additional detail specific to theentryType.

performanceNodeEntry.flags#

• Type:<number>

WhenperformanceEntry.entryType is equal to'gc', theperformance.flagsproperty 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#

• Type:<number>

WhenperformanceEntry.entryType is equal to'gc', theperformance.kindproperty 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#

WhenperformanceEntry.type is equal to'gc', theperformanceNodeEntry.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#

WhenperformanceEntry.type is equal to'http', theperformanceNodeEntry.detail property will be an<Object> containingadditional information.

IfperformanceEntry.name is equal toHttpClient, thedetailwill contain the following properties:req,res. And thereq propertywill be an<Object> containingmethod,url,headers, theres propertywill be an<Object> containingstatusCode,statusMessage,headers.

IfperformanceEntry.name is equal toHttpRequest, thedetailwill contain the following properties:req,res. And thereq propertywill be an<Object> containingmethod,url,headers, theres propertywill be an<Object> containingstatusCode,statusMessage,headers.

This could add additional memory overhead and should only be used fordiagnostic purposes, not left turned on in production by default.

HTTP/2 ('http2') Details#

WhenperformanceEntry.type is equal to'http2', theperformanceNodeEntry.detail property will be an<Object> containingadditional performance information.

IfperformanceEntry.name is equal toHttp2Stream, thedetailwill contain the following properties:

• bytesRead<number> The number ofDATA frame bytes received for thisHttp2Stream.
• bytesWritten<number> The number ofDATA frame bytes sent for thisHttp2Stream.
• id<number> The identifier of the associatedHttp2Stream
• timeToFirstByte<number> The number of milliseconds elapsed between thePerformanceEntrystartTime and the reception of the firstDATA frame.
• timeToFirstByteSent<number> The number of milliseconds elapsed betweenthePerformanceEntrystartTime and sending of the firstDATA frame.
• timeToFirstHeader<number> The number of milliseconds elapsed between thePerformanceEntrystartTime and the reception of the first header.

IfperformanceEntry.name is equal toHttp2Session, thedetail willcontain the following properties:

• bytesRead<number> The number of bytes received for thisHttp2Session.
• bytesWritten<number> The number of bytes sent for thisHttp2Session.
• framesReceived<number> The number of HTTP/2 frames received by theHttp2Session.
• framesSent<number> The number of HTTP/2 frames sent by theHttp2Session.
• maxConcurrentStreams<number> The maximum number of streams concurrentlyopen during the lifetime of theHttp2Session.
• pingRTT<number> The number of milliseconds elapsed since the transmissionof aPING frame and the reception of its acknowledgment. Only present ifaPING frame has been sent on theHttp2Session.
• streamAverageDuration<number> The average duration (in milliseconds) forallHttp2Stream instances.
• streamCount<number> The number ofHttp2Stream instances processed bytheHttp2Session.
• type<string> Either'server' or'client' to identify the type ofHttp2Session.

Timerify ('function') Details#

WhenperformanceEntry.type is equal to'function', theperformanceNodeEntry.detail property will be an<Array> listingthe input arguments to the timed function.

Net ('net') Details#

WhenperformanceEntry.type is equal to'net', theperformanceNodeEntry.detail property will be an<Object> containingadditional information.

IfperformanceEntry.name is equal toconnect, thedetailwill contain the following properties:host,port.

DNS ('dns') Details#

WhenperformanceEntry.type is equal to'dns', theperformanceNodeEntry.detail property will be an<Object> containingadditional information.

IfperformanceEntry.name is equal tolookup, thedetailwill contain the following properties:hostname,family,hints,verbatim,addresses.

IfperformanceEntry.name is equal tolookupService, thedetail willcontain the following properties:host,port,hostname,service.

IfperformanceEntry.name is equal toqueryxxx orgetHostByAddr, thedetail willcontain the following properties:host,ttl,result. The value ofresult issame as the result ofqueryxxx orgetHostByAddr.

performanceNodeTiming.bootstrapComplete#

• Type:<number>

The high resolution millisecond timestamp at which the Node.js processcompleted bootstrapping. If bootstrapping has not yet finished, the propertyhas the value of -1.

performanceNodeTiming.environment#

• Type:<number>

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

performanceNodeTiming.idleTime#

• Type:<number>

The high resolution millisecond timestamp of the amount of time the event loophas been idle within the event loop's event provider (e.g.epoll_wait). Thisdoes not take CPU usage into consideration. If the event loop has not yetstarted (e.g., in the first tick of the main script), the property has thevalue of 0.

performanceNodeTiming.loopExit#

• Type:<number>

The high resolution millisecond timestamp at which the Node.js event loopexited. 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 loopstarted. If the event loop has not yet started (e.g., in the first tick of themain script), the property has the value of -1.

performanceNodeTiming.nodeStart#

• Type:<number>

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

performanceNodeTiming.uvMetricsInfo#

• 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 theuv_metrics_info function.It returns the current set of event loop metrics.

It is recommended to use this property inside a function whose execution wasscheduled usingsetImmediate to avoid collecting metrics before finishing alloperations 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);});copy

performanceNodeTiming.v8Start#

• Type:<number>

The high resolution millisecond timestamp at which the V8 platform wasinitialized.

performanceResourceTiming.workerStart#

• Type:<number>

The high resolution millisecond timestamp at immediately before dispatchingthefetch request. If the resource is not intercepted by a worker the propertywill always return 0.

performanceResourceTiming.redirectStart#

• Type:<number>

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

performanceResourceTiming.redirectEnd#

• Type:<number>

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

performanceResourceTiming.fetchStart#

• Type:<number>

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

performanceResourceTiming.domainLookupStart#

• Type:<number>

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

performanceResourceTiming.domainLookupEnd#

• Type:<number>

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

performanceResourceTiming.connectStart#

• Type:<number>

The high resolution millisecond timestamp representing the time immediatelybefore Node.js starts to establish the connection to the server to retrievethe resource.

performanceResourceTiming.connectEnd#

• Type:<number>

The high resolution millisecond timestamp representing the time immediatelyafter Node.js finishes establishing the connection to the server to retrievethe resource.

performanceResourceTiming.secureConnectionStart#

• Type:<number>

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

performanceResourceTiming.requestStart#

• Type:<number>

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

performanceResourceTiming.responseEnd#

• Type:<number>

The high resolution millisecond timestamp representing the time immediatelyafter Node.js receives the last byte of the resource or immediately beforethe transport connection is closed, whichever comes first.

performanceResourceTiming.transferSize#

• Type:<number>

A number representing the size (in octets) of the fetched resource. The sizeincludes 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 appliedcontent-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 appliedcontent-codings.

performanceResourceTiming.toJSON()#

Returns aobject that is the JSON representation of thePerformanceResourceTiming object

PerformanceObserver.supportedEntryTypes#

• Type:<string[]>

Get supported types.

new PerformanceObserver(callback)#

• callback<Function>
  • list<PerformanceObserverEntryList>
  • observer<PerformanceObserver>

PerformanceObserver objects provide notifications when newPerformanceEntry instances have been added to the Performance Timeline.

import { performance,PerformanceObserver }from'node:perf_hooks';const obs =newPerformanceObserver((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 =newPerformanceObserver((list, observer) => {console.log(list.getEntries());  performance.clearMarks();  performance.clearMeasures();  observer.disconnect();});obs.observe({entryTypes: ['mark'],buffered:true });performance.mark('test');copy

BecausePerformanceObserver instances introduce their own additionalperformance overhead, instances should not be left subscribed to notificationsindefinitely. Users should disconnect observers as soon as they are nolonger needed.

Thecallback is invoked when aPerformanceObserver isnotified about newPerformanceEntry instances. The callback receives aPerformanceObserverEntryList instance and a reference to thePerformanceObserver.

performanceObserver.disconnect()#

Disconnects thePerformanceObserver instance from all notifications.

performanceObserver.observe(options)#

• options<Object>
  • type<string> A single<PerformanceEntry> type. Must not be givenifentryTypes is already specified.
  • entryTypes<string[]> An array of strings identifying the types of<PerformanceEntry> instances the observer is interested in. If notprovided an error will be thrown.
  • buffered<boolean> If true, the observer callback is called with alist globalPerformanceEntry buffered entries. If false, onlyPerformanceEntrys created after the time point are sent to theobserver callback.Default:false.

Subscribes the<PerformanceObserver> instance to notifications of new<PerformanceEntry> instances identified either byoptions.entryTypesoroptions.type:

import { performance,PerformanceObserver }from'node:perf_hooks';const obs =newPerformanceObserver((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 =newPerformanceObserver((list, observer) => {// Called once asynchronously. `list` contains three items.});obs.observe({type:'mark' });for (let n =0; n <3; n++)  performance.mark(`test${n}`);copy

performanceObserver.takeRecords()#

• Returns:<PerformanceEntry[]> Current list of entries stored in the performance observer, emptying it out.

performanceObserverEntryList.getEntries()#

• Returns:<PerformanceEntry[]>

Returns a list ofPerformanceEntry objects in chronological orderwith respect toperformanceEntry.startTime.

import { performance,PerformanceObserver }from'node:perf_hooks';const obs =newPerformanceObserver((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 =newPerformanceObserver((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');copy

performanceObserverEntryList.getEntriesByName(name[, type])#

• name<string>
• type<string>
• Returns:<PerformanceEntry[]>

Returns a list ofPerformanceEntry objects in chronological orderwith respect toperformanceEntry.startTime whoseperformanceEntry.name isequal toname, and optionally, whoseperformanceEntry.entryType is equal totype.

import { performance,PerformanceObserver }from'node:perf_hooks';const obs =newPerformanceObserver((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');const {  performance,PerformanceObserver,} =require('node:perf_hooks');const obs =newPerformanceObserver((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');copy

performanceObserverEntryList.getEntriesByType(type)#

• type<string>
• Returns:<PerformanceEntry[]>

Returns a list ofPerformanceEntry objects in chronological orderwith respect toperformanceEntry.startTime whoseperformanceEntry.entryTypeis equal totype.

import { performance,PerformanceObserver }from'node:perf_hooks';const obs =newPerformanceObserver((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');const {  performance,PerformanceObserver,} =require('node:perf_hooks');const obs =newPerformanceObserver((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');copy

histogram.count#

• Type:<number>

The number of samples recorded by the histogram.

histogram.countBigInt#

• Type:<bigint>

The number of samples recorded by the histogram.

histogram.exceeds#

• Type:<number>

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

histogram.exceedsBigInt#

• Type:<bigint>

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

histogram.max#

• Type:<number>

The maximum recorded event loop delay.

histogram.maxBigInt#

• Type:<bigint>

The maximum recorded event loop delay.

histogram.mean#

• Type:<number>

The mean of the recorded event loop delays.

histogram.min#

• Type:<number>

The minimum recorded event loop delay.

histogram.minBigInt#

• Type:<bigint>

The minimum recorded event loop delay.

histogram.percentile(percentile)#

• percentile<number> A percentile value in the range (0, 100].
• Returns:<number>

Returns the value at the given percentile.

histogram.percentileBigInt(percentile)#

• percentile<number> A percentile value in the range (0, 100].
• Returns:<bigint>

Returns the value at the given percentile.

histogram.percentiles#

• Type:<Map>

Returns aMap object detailing the accumulated percentile distribution.

histogram.percentilesBigInt#

• Type:<Map>

Returns aMap object detailing the accumulated percentile distribution.

histogram.reset()#

Resets the collected histogram data.

histogram.stddev#

• Type:<number>

The standard deviation of the recorded event loop delays.

histogram.disable()#

• Returns:<boolean>

Disables the update interval timer. Returnstrue if the timer wasstopped,false if it was already stopped.

histogram.enable()#

• Returns:<boolean>

Enables the update interval timer. Returnstrue if the timer wasstarted,false if it was already started.

histogram[Symbol.dispose]()#

Disables the update interval timer when the histogram is disposed.

const { monitorEventLoopDelay } =require('node:perf_hooks');{using hist =monitorEventLoopDelay({resolution:20 });  hist.enable();// The histogram will be disabled when the block is exited.}copy

Cloning anIntervalHistogram#

<IntervalHistogram> instances can be cloned via<MessagePort>. On the receivingend, the histogram is cloned as a plain<Histogram> object that does notimplement theenable() anddisable() methods.

histogram.add(other)#

• other<RecordableHistogram>

Adds the values fromother to this histogram.

histogram.record(val)#

• val<number> |<bigint> The amount to record in the histogram.

histogram.recordDelta()#

Calculates the amount of time (in nanoseconds) that has passed since theprevious call torecordDelta() and records that amount in the histogram.

Measuring the duration of async operations#

The following example uses theAsync Hooks and Performance APIs to measurethe actual duration of a Timeout operation (including the amount of time it tookto execute the callback).

import { createHook }from'node:async_hooks';import { performance,PerformanceObserver }from'node:perf_hooks';const set =newSet();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 =newPerformanceObserver((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 =newSet();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 =newPerformanceObserver((list, observer) => {console.log(list.getEntries()[0]);  performance.clearMarks();  performance.clearMeasures();  observer.disconnect();});obs.observe({entryTypes: ['measure'] });setTimeout(() => {},1000);copy

Measuring how long it takes to load dependencies#

The following example measures the duration ofrequire() operations to loaddependencies:

import { performance,PerformanceObserver }from'node:perf_hooks';// Activate the observerconst obs =newPerformanceObserver((list) => {const entries = list.getEntries();  entries.forEach((entry) => {console.log(`import('${entry[0]}')`, entry.duration);  });  performance.clearMarks();  performance.clearMeasures();  obs.disconnect();});obs.observe({entryTypes: ['function'],buffered:true });const timedImport = performance.timerify(async (module) => {returnawaitimport(module);});awaittimedImport('some-module');'use strict';const {  performance,PerformanceObserver,} =require('node:perf_hooks');const mod =require('node:module');// Monkey patch the require functionmod.Module.prototype.require =  performance.timerify(mod.Module.prototype.require);require = performance.timerify(require);// Activate the observerconst obs =newPerformanceObserver((list) => {const entries = list.getEntries();  entries.forEach((entry) => {console.log(`require('${entry[0]}')`, entry.duration);  });  performance.clearMarks();  performance.clearMeasures();  obs.disconnect();});obs.observe({entryTypes: ['function'] });require('some-module');copy

Measuring how long one HTTP round-trip takes#

The following example is used to trace the time spent by HTTP client(OutgoingMessage) and HTTP request (IncomingMessage). For HTTP client,it means the time interval between starting the request and receiving theresponse, and for HTTP request, it means the time interval between receivingthe request and sending the response:

import {PerformanceObserver }from'node:perf_hooks';import { createServer, get }from'node:http';const obs =newPerformanceObserver((items) => {  items.getEntries().forEach((item) => {console.log(item);  });});obs.observe({entryTypes: ['http'] });constPORT =8080;createServer((req, res) => {  res.end('ok');}).listen(PORT,() => {get(`http://127.0.0.1:${PORT}`);});'use strict';const {PerformanceObserver } =require('node:perf_hooks');const http =require('node:http');const obs =newPerformanceObserver((items) => {  items.getEntries().forEach((item) => {console.log(item);  });});obs.observe({entryTypes: ['http'] });constPORT =8080;http.createServer((req, res) => {  res.end('ok');}).listen(PORT,() => {  http.get(`http://127.0.0.1:${PORT}`);});copy

Measuring how long thenet.connect (only for TCP) takes when the connection is successful#

import {PerformanceObserver }from'node:perf_hooks';import { connect, createServer }from'node:net';const obs =newPerformanceObserver((items) => {  items.getEntries().forEach((item) => {console.log(item);  });});obs.observe({entryTypes: ['net'] });constPORT =8080;createServer((socket) => {  socket.destroy();}).listen(PORT,() => {connect(PORT);});'use strict';const {PerformanceObserver } =require('node:perf_hooks');const net =require('node:net');const obs =newPerformanceObserver((items) => {  items.getEntries().forEach((item) => {console.log(item);  });});obs.observe({entryTypes: ['net'] });constPORT =8080;net.createServer((socket) => {  socket.destroy();}).listen(PORT,() => {  net.connect(PORT);});copy

Measuring how long the DNS takes when the request is successful#

import {PerformanceObserver }from'node:perf_hooks';import { lookup, promises }from'node:dns';const obs =newPerformanceObserver((items) => {  items.getEntries().forEach((item) => {console.log(item);  });});obs.observe({entryTypes: ['dns'] });lookup('localhost',() => {});promises.resolve('localhost');'use strict';const {PerformanceObserver } =require('node:perf_hooks');const dns =require('node:dns');const obs =newPerformanceObserver((items) => {  items.getEntries().forEach((item) => {console.log(item);  });});obs.observe({entryTypes: ['dns'] });dns.lookup('localhost',() => {});dns.promises.resolve('localhost');copy