The Performance Timing API provides an implementation of theW3C Performance Timeline specification. The purpose of the APIis to support collection of high resolution performance metrics.This is the same Performance API as implemented in modern Web browsers.
const { performance } = require('perf_hooks');performance.mark('A');doSomeLongRunningProcess(() => { performance.mark('B'); performance.measure('A to B', 'A', 'B'); const measure = performance.getEntriesByName('A to B')[0]; console.log(measure.duration); // Prints the number of milliseconds between Mark 'A' and Mark 'B'});ThePerformance provides access to performance metric data. A singleinstance of this class is provided via theperformance property.
Remove all performance entry objects withentryType equal toname from thePerformance Timeline.
name<string>Ifname is not provided, removes allPerformanceFunction objects from thePerformance Timeline. Ifname is provided, removes entries withname.
Remove all performance entry objects withentryType equal togc from thePerformance Timeline.
name<string>Ifname is not provided, removes allPerformanceMark objects from thePerformance Timeline. Ifname is provided, removes only the named mark.
name<string>Ifname is not provided, removes allPerformanceMeasure objects from thePerformance Timeline. Ifname is provided, removes only objects whoseperformanceEntry.name matchesname.
Returns a list of allPerformanceEntry objects in chronological orderwith respect toperformanceEntry.startTime.
Returns a list of allPerformanceEntry objects in chronological orderwith respect toperformanceEntry.startTime whoseperformanceEntry.name isequal toname, and optionally, whoseperformanceEntry.entryType is equal totype.
Returns a list of allPerformanceEntry objects in chronological orderwith respect toperformanceEntry.startTime whoseperformanceEntry.entryTypeis equal totype.
name<string>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.
Value:<number>
The maximum number of Performance Entry items that should be added to thePerformance Timeline. This limit is not strictly enforced, but a processwarning will be emitted if the number of entries in the timeline exceedsthis limit.
Defaults to 150.
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, thenstartMark is set totimeOrigin by default.
TheendMark argument must identify anyexistingPerformanceMark in thePerformance Timeline or any of the timestamp properties provided by thePerformanceNodeTiming class. If the namedendMark does not exist, anerror will be thrown.
An instance of thePerformanceNodeTiming class that provides performancemetrics for specific Node.js operational milestones.
Returns the current high resolution millisecond timestamp, where 0 representsthe start of the currentnode process.
ThetimeOrigin specifies the high resolution millisecond timestamp atwhich the currentnode process began, measured in Unix time.
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.
const { performance, PerformanceObserver} = require('perf_hooks');function someFunction() { console.log('hello world');}const wrapped = performance.timerify(someFunction);const obs = new PerformanceObserver((list) => { console.log(list.getEntries()[0].duration); obs.disconnect(); performance.clearFunctions();});obs.observe({ entryTypes: ['function'] });// A performance timeline entry will be createdwrapped();The total number of milliseconds elapsed for this entry. This value will notbe meaningful for all Performance Entry types.
The name of the performance entry.
The high resolution millisecond timestamp marking the starting time of thePerformance Entry.
The type of the performance entry. Current it may be one of:'node','mark','measure','gc', or'function'.
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_MAJORperf_hooks.constants.NODE_PERFORMANCE_GC_MINORperf_hooks.constants.NODE_PERFORMANCE_GC_INCREMENTALperf_hooks.constants.NODE_PERFORMANCE_GC_WEAKCBProvides timing details for Node.js itself.
The high resolution millisecond timestamp at which the Node.js processcompleted bootstrapping. If bootstrapping has not yet finished, the propertyhas the value of -1.
The high resolution millisecond timestamp at which cluster processing ended. Ifcluster processing has not yet ended, the property has the value of -1.
The high resolution millisecond timestamp at which cluster processing started.If cluster processing has not yet started, the property has the value of -1.
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.
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.
The high resolution millisecond timestamp at which main module load ended.
The high resolution millisecond timestamp at which main module load started.
The high resolution millisecond timestamp at which the Node.js process wasinitialized.
The high resolution millisecond timestamp at which preload module load ended.
The high resolution millisecond timestamp at which preload module load started.
The high resolution millisecond timestamp at which third_party_mainprocessing ended. If third_party_main processing has not yet ended, theproperty has the value of -1.
The high resolution millisecond timestamp at which third_party_mainprocessing started. If third_party_main processing has not yet started, theproperty has the value of -1.
The high resolution millisecond timestamp at which the V8 platform wasinitialized.
callback<Function> APerformanceObserverCallback callback function.PerformanceObserver objects provide notifications when newPerformanceEntry instances have been added to the Performance Timeline.
const { performance, PerformanceObserver} = require('perf_hooks');const obs = new PerformanceObserver((list, observer) => { console.log(list.getEntries()); observer.disconnect();});obs.observe({ entryTypes: ['mark'], buffered: true });performance.mark('test');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.
ThePerformanceObserverCallback is invoked when aPerformanceObserver isnotified about newPerformanceEntry instances. The callback receives aPerformanceObserverEntryList instance and a reference to thePerformanceObserver.
ThePerformanceObserverEntryList class is used to provide access to thePerformanceEntry instances passed to aPerformanceObserver.
Returns a list ofPerformanceEntry objects in chronological orderwith respect toperformanceEntry.startTime.
Returns a list ofPerformanceEntry objects in chronological orderwith respect toperformanceEntry.startTime whoseperformanceEntry.name isequal toname, and optionally, whoseperformanceEntry.entryType is equal totype.
Returns a list ofPerformanceEntry objects in chronological orderwith respect toperformanceEntry.startTime whoseperformanceEntry.entryTypeis equal totype.
Disconnects thePerformanceObserver instance from all notifications.
options<Object>entryTypes<Array> An array of strings identifying the types ofPerformanceEntry instances the observer is interested in. If notprovided an error will be thrown.buffered<boolean> If true, the notification callback will becalled usingsetImmediate() and multiplePerformanceEntry instancenotifications will be buffered internally. Iffalse, notifications willbe immediate and synchronous.Default:false.Subscribes thePerformanceObserver instance to notifications of newPerformanceEntry instances identified byoptions.entryTypes.
Whenoptions.buffered isfalse, thecallback will be invoked once foreveryPerformanceEntry instance:
const { performance, PerformanceObserver} = require('perf_hooks');const obs = new PerformanceObserver((list, observer) => { // called three times synchronously. list contains one item});obs.observe({ entryTypes: ['mark'] });for (let n = 0; n < 3; n++) performance.mark(`test${n}`);const { performance, PerformanceObserver} = require('perf_hooks');const obs = new PerformanceObserver((list, observer) => { // called once. list contains three items});obs.observe({ entryTypes: ['mark'], buffered: true });for (let n = 0; n < 3; n++) performance.mark(`test${n}`);The following example uses theAsync Hooks and Performance APIs to measurethe actual duration of a Timeout operation (including the amount of time itto execute the callback).
'use strict';const async_hooks = require('async_hooks');const { performance, PerformanceObserver} = require('perf_hooks');const set = new Set();const hook = async_hooks.createHook({ init(id, type) { if (type === 'Timeout') { performance.mark(`Timeout-${id}-Init`); set.add(id); } }, destroy(id) { if (set.has(id)) { set.delete(id); performance.mark(`Timeout-${id}-Destroy`); performance.measure(`Timeout-${id}`, `Timeout-${id}-Init`, `Timeout-${id}-Destroy`); } }});hook.enable();const obs = new PerformanceObserver((list, observer) => { console.log(list.getEntries()[0]); performance.clearMarks(); performance.clearMeasures(); observer.disconnect();});obs.observe({ entryTypes: ['measure'], buffered: true });setTimeout(() => {}, 1000);The following example measures the duration ofrequire() operations to loaddependencies:
'use strict';const { performance, PerformanceObserver} = require('perf_hooks');const mod = require('module');// Monkey patch the require functionmod.Module.prototype.require = performance.timerify(mod.Module.prototype.require);require = performance.timerify(require);// Activate the observerconst obs = new PerformanceObserver((list) => { const entries = list.getEntries(); entries.forEach((entry) => { console.log(`require('${entry[0]}')`, entry.duration); }); obs.disconnect(); // Free memory performance.clearFunctions();});obs.observe({ entryTypes: ['function'], buffered: true });require('some-module');