performance.clearMarks([name])

• name <string>

Если name не указан, из временной шкалы производительности удаляются все объекты PerformanceMark. Если name указан, удаляется только метка с этим именем.

performance.clearMeasures([name])

• name <string>

Если name не указан, из временной шкалы производительности удаляются все объекты PerformanceMeasure. Если name указан, удаляется только измерение с этим именем.

performance.clearResourceTimings([name])

• name <string>

Если name не указан, из временной шкалы ресурсов удаляются все объекты PerformanceResourceTiming. Если name указан, удаляется только ресурс с этим именем.

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

• utilization1 <Object> Результат предыдущего вызова eventLoopUtilization().
• utilization2 <Object> Результат предыдущего вызова eventLoopUtilization() перед utilization1.
• Возвращает: <Object>
  • idle <number>
  • active <number>
  • utilization <number>

Метод eventLoopUtilization() возвращает объект, содержащий накопленную продолжительность периодов простоя и активности цикла событий, измеренную таймером с точностью до миллисекунды. Значение utilization представляет собой рассчитанный коэффициент использования цикла событий (ELU).

Если инициализация основного потока ещё не завершена, свойства имеют значение 0. В рабочих потоках ELU доступен сразу, поскольку инициализация происходит внутри цикла событий.

Параметры utilization1 и utilization2 являются необязательными.

Если передан utilization1, вычисляется и возвращается разница между значениями времени active и idle текущего вызова, а также соответствующее значение utilization (аналогично process.hrtime()).

Если переданы оба параметра — utilization1 и utilization2, разница вычисляется между этими двумя аргументами. Это удобный вариант, поскольку вычисление ELU, в отличие от process.hrtime(), сложнее простого вычитания.

ELU похож на загрузку ЦП, но измеряет только статистику цикла событий, а не загрузку ЦП. Он отражает процент времени, в течение которого цикл событий находился вне своего обработчика событий (например, epoll_wait). Время простоя ЦП не учитывается. Ниже приведён пример процесса с высокой 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);
});

Хотя во время выполнения этого скрипта ЦП почти не загружен, значение utilization равно 1. Это происходит потому, что вызов child_process.spawnSync() блокирует дальнейшую работу цикла событий.

Передача пользовательского объекта вместо результата предыдущего вызова eventLoopUtilization() приведёт к неопределённому поведению. Возвращаемые значения не гарантируют отражение корректного состояния цикла событий.

performance.getEntries()

• Возвращает: <PerformanceEntry[]>

Возвращает список объектов PerformanceEntry в хронологическом порядке относительно performanceEntry.startTime. Если нужны записи производительности только определённых типов или с определёнными именами, см. performance.getEntriesByType() и performance.getEntriesByName().

performance.getEntriesByName(name[, type])

• name <string>
• type <string>
• Возвращает: <PerformanceEntry[]>

Возвращает список объектов PerformanceEntry в хронологическом порядке относительно performanceEntry.startTime, у которых performanceEntry.name равен name и, при необходимости, performanceEntry.entryType равен type.

performance.getEntriesByType(type)

• type <string>
• Возвращает: <PerformanceEntry[]>

Возвращает список объектов PerformanceEntry в хронологическом порядке относительно performanceEntry.startTime, у которых performanceEntry.entryType равен type.

performance.mark(name[, options])

• name <string>
• options <Object>
  • detail <any> Дополнительные необязательные сведения, которые нужно включить в метку.
  • startTime <number> Необязательная временная метка, используемая в качестве времени метки. По умолчанию: performance.now().

Создаёт новую запись PerformanceMark на временной шкале производительности. PerformanceMark — это подкласс PerformanceEntry, у которого performanceEntry.entryType всегда равен 'mark', а performanceEntry.duration всегда равен 0. Метки производительности используются для обозначения важных событий на временной шкале производительности.

Созданная запись PerformanceMark помещается в глобальную временную шкалу производительности и может быть получена с помощью performance.getEntries, performance.getEntriesByName и performance.getEntriesByType. После выполнения наблюдения записи следует вручную удалить из глобальной временной шкалы производительности с помощью performance.clearMarks.

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

• timingInfo <Object> Информация о времени Fetch
• requestedUrl <string> URL ресурса
• initiatorType <string> Имя инициатора, например: 'fetch'
• global <Object>
• cacheMode <string> Режим кэша должен быть пустой строкой ('') или 'local'
• bodyInfo <Object> Информация о теле ответа Fetch
• responseStatus <number> Код состояния ответа
• deliveryType <string> Тип доставки. По умолчанию: ''.

Это свойство является расширением Node.js. Оно недоступно в веб-браузерах.

Создаёт новую запись PerformanceResourceTiming на временной шкале ресурсов. PerformanceResourceTiming — это подкласс PerformanceEntry, у которого performanceEntry.entryType всегда равен 'resource'. Записи о производительности ресурсов используются для отметки моментов на временной шкале ресурсов.

Созданная запись PerformanceMark помещается в глобальную временную шкалу ресурсов и может быть получена с помощью performance.getEntries, performance.getEntriesByName и performance.getEntriesByType. После выполнения наблюдения записи следует вручную удалить из глобальной временной шкалы производительности с помощью performance.clearResourceTimings.

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

• name <string>
• startMarkOrOptions <string> | <Object> Необязательный параметр.
  • detail <any> Дополнительные необязательные сведения, которые нужно включить в измерение.
  • duration <number> Продолжительность между временем начала и окончания.
  • end <number> | <string> Временная метка, используемая как время окончания, либо строка, указывающая на ранее записанную метку.
  • start <number> | <string> Временная метка, используемая как время начала, либо строка, указывающая на ранее записанную метку.
• endMark <string> Необязательный параметр. Его следует опустить, если startMarkOrOptions является объектом <Object>.

Создаёт новую запись PerformanceMeasure на временной шкале производительности. PerformanceMeasure — это подкласс PerformanceEntry, у которого performanceEntry.entryType всегда равен 'measure', а performanceEntry.duration измеряет количество миллисекунд, прошедших между startMark и endMark.

Аргумент startMark может указывать на любую существующую запись PerformanceMark на временной шкале производительности или на любое свойство временной метки, предоставляемое классом PerformanceNodeTiming. Если запись startMark с указанным именем не существует, выбрасывается ошибка.

Необязательный аргумент endMark должен указывать на любую существующую запись PerformanceMark на временной шкале производительности или на любое свойство временной метки, предоставляемое классом PerformanceNodeTiming. Если параметр не передан, endMark будет равен performance.now(); в противном случае, если запись endMark с указанным именем не существует, будет выброшена ошибка.

Созданная запись PerformanceMeasure помещается в глобальную временную шкалу производительности и может быть получена с помощью performance.getEntries, performance.getEntriesByName и performance.getEntriesByType. После выполнения наблюдения записи следует вручную удалить из глобальной временной шкалы производительности с помощью performance.clearMeasures.

performance.nodeTiming

• Тип: <PerformanceNodeTiming>

Это свойство является расширением Node.js. Оно недоступно в веб-браузерах.

Экземпляр класса PerformanceNodeTiming, предоставляющий метрики производительности для определённых этапов работы Node.js.

performance.now()

• Возвращает: <number>

Возвращает текущую временную метку в миллисекундах с высоким разрешением, где 0 соответствует началу текущего процесса node.

performance.setResourceTimingBufferSize(maxSize)

Задаёт размер глобального буфера измерения времени ресурсов, равный указанному количеству объектов записей производительности типа "resource".

По умолчанию максимальный размер буфера равен 250.

performance.timeOrigin

• Тип: <number>

timeOrigin задаёт временную метку в миллисекундах с высоким разрешением, соответствующую началу текущего процесса node, измеренную по времени Unix.

performance.timerify(fn[, options])

• fn <Function>
• options <Object>
  • histogram <RecordableHistogram> Объект гистограммы, созданный с помощью perf_hooks.createHistogram(), который будет записывать длительность выполнения в наносекундах.

Это свойство является расширением Node.js. Оно недоступно в веб-браузерах.

Оборачивает функцию в новую функцию, измеряющую время выполнения исходной функции. Чтобы получить сведения о времени выполнения, необходимо подписать PerformanceObserver на тип события 'function'.

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

const {
  performance,
  PerformanceObserver,
} = require('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();

Если обёрнутая функция возвращает промис, к нему будет добавлен обработчик finally, и длительность выполнения будет сообщена после вызова этого обработчика.

performance.toJSON()

Объект, представляющий объект performance в формате JSON. Он аналогичен window.performance.toJSON в браузерах.

performanceEntry.duration

• Тип: <number>

Общее количество миллисекунд, прошедших для этой записи. Это значение не имеет смысла для записей производительности всех типов.

performanceEntry.entryType

• Тип: <string>

Тип записи производительности. Это может быть одно из следующих значений:

• 'dns' (только в Node.js)
• 'function' (только в Node.js)
• 'gc' (только в Node.js)
• 'http2' (только в Node.js)
• 'http' (только в Node.js)
• 'mark' (доступно в веб-браузерах)
• 'measure' (доступно в веб-браузерах)
• 'net' (только в Node.js)
• 'node' (только в Node.js)
• 'resource' (доступно в веб-браузерах)

performanceEntry.name

• Тип: <string>

Имя записи производительности.

performanceEntry.startTime

• Тип: <number>

Временная метка в миллисекундах с высоким разрешением, обозначающая время начала записи производительности.

performanceMark.detail

• Тип: <any>

Дополнительные сведения, заданные при создании методом Performance.mark().

performanceMeasure.detail

• Тип: <any>

Дополнительные сведения, заданные при создании методом Performance.measure().

performanceNodeEntry.detail

• Тип: <any>

Дополнительные сведения, относящиеся к entryType.

performanceNodeEntry.flags

• Тип: <number>

Если performanceEntry.entryType равно 'gc', свойство performance.flags содержит дополнительные сведения об операции сборки мусора. Значение может быть одним из следующих:

• 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

• Тип: <number>

Если performanceEntry.entryType равно 'gc', свойство performance.kind определяет тип выполненной операции сборки мусора. Значение может быть одним из следующих:

• 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

Подробные сведения о сборке мусора ('gc')

Если performanceEntry.type равно 'gc', свойство performanceNodeEntry.detail будет объектом <Object> с двумя свойствами:

• kind <number> Одно из значений:
  • 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> Одно из значений:
  • 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')

Если performanceEntry.type равно 'http', свойство performanceNodeEntry.detail будет объектом <Object>, содержащим дополнительные сведения.

Если performanceEntry.name равно HttpClient, detail будет содержать следующие свойства: req, res. А свойство req будет объектом <Object>, содержащим method, url, headers; свойство res будет объектом <Object>, содержащим statusCode, statusMessage, headers.

Если performanceEntry.name равно HttpRequest, detail будет содержать следующие свойства: req, res. А свойство req будет объектом <Object>, содержащим method, url, headers; свойство res будет объектом <Object>, содержащим statusCode, statusMessage, headers.

Это может привести к дополнительным затратам памяти; эту возможность следует использовать только для диагностики, а не оставлять включённой по умолчанию в рабочей среде.

Подробные сведения о HTTP/2 ('http2')

Если performanceEntry.type равно 'http2', свойство performanceNodeEntry.detail будет объектом <Object>, содержащим дополнительные сведения о производительности.

Если performanceEntry.name равно Http2Stream, detail будет содержать следующие свойства:

• bytesRead <number> Количество байтов данных фреймов DATA, полученных для этого Http2Stream.
• bytesWritten <number> Количество байтов данных фреймов DATA, отправленных для этого Http2Stream.
• id <number> Идентификатор связанного Http2Stream
• timeToFirstByte <number> Количество миллисекунд между PerformanceEntry startTime и получением первого фрейма DATA.
• timeToFirstByteSent <number> Количество миллисекунд между PerformanceEntry startTime и отправкой первого фрейма DATA.
• timeToFirstHeader <number> Количество миллисекунд между PerformanceEntry startTime и получением первого заголовка.

Если performanceEntry.name равно Http2Session, detail будет содержать следующие свойства:

• bytesRead <number> Количество байтов, полученных для этого Http2Session.
• bytesWritten <number> Количество байтов, отправленных для этого Http2Session.
• framesReceived <number> Количество фреймов HTTP/2, полученных Http2Session.
• framesSent <number> Количество фреймов HTTP/2, отправленных Http2Session.
• maxConcurrentStreams <number> Максимальное количество потоков, одновременно открытых за время существования Http2Session.
• pingRTT <number> Количество миллисекунд, прошедших между отправкой фрейма PING и получением подтверждения. Присутствует только в том случае, если для Http2Session был отправлен фрейм PING.
• streamAverageDuration <number> Средняя продолжительность (в миллисекундах) для всех экземпляров Http2Stream.
• streamCount <number> Количество экземпляров Http2Stream, обработанных Http2Session.
• type <string> Значение 'server' или 'client', определяющее тип Http2Session.

Подробные сведения о Timerify ('function')

Если performanceEntry.type равно 'function', свойство performanceNodeEntry.detail будет массивом <Array> со списком входных аргументов функции, для которой измеряется время.

Подробные сведения о Net ('net')

Если performanceEntry.type равно 'net', свойство performanceNodeEntry.detail будет объектом <Object>, содержащим дополнительные сведения.

Если performanceEntry.name равно connect, detail будет содержать следующие свойства: host, port.

Подробные сведения о DNS ('dns')

Если performanceEntry.type равно 'dns', свойство performanceNodeEntry.detail будет объектом <Object>, содержащим дополнительные сведения.

Если performanceEntry.name равно lookup, detail будет содержать следующие свойства: hostname, family, hints, verbatim, addresses.

Если performanceEntry.name равно lookupService, detail будет содержать следующие свойства: host, port, hostname, service.

Если performanceEntry.name равно queryxxx или getHostByAddr, detail будет содержать следующие свойства: host, ttl, result. Значение result совпадает с результатом queryxxx или getHostByAddr.

performanceNodeTiming.bootstrapComplete

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, соответствующая моменту завершения начальной загрузки процесса Node.js. Если начальная загрузка ещё не завершена, значение свойства равно -1.

performanceNodeTiming.environment

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, соответствующая моменту инициализации среды Node.js.

performanceNodeTiming.idleTime

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, обозначающая время простоя цикла событий внутри поставщика событий цикла событий (например, epoll_wait). Загрузка ЦП при этом не учитывается. Если цикл событий ещё не запущен (например, на первом такте основного скрипта), значение свойства равно 0.

performanceNodeTiming.loopExit

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, соответствующая моменту выхода цикла событий Node.js. Если цикл событий ещё не завершился, значение свойства равно -1. Оно может принимать значение, отличное от -1, только в обработчике события 'exit'.

performanceNodeTiming.loopStart

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, соответствующая моменту запуска цикла событий Node.js. Если цикл событий ещё не запущен (например, на первом такте основного скрипта), значение свойства равно -1.

performanceNodeTiming.nodeStart

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, соответствующая моменту инициализации процесса Node.js.

performanceNodeTiming.uvMetricsInfo

• Возвращает: <Object>
  • loopCount <number> Количество итераций цикла событий.
  • events <number> Количество событий, обработанных обработчиком событий.
  • eventsWaiting <number> Количество событий, ожидавших обработки на момент вызова поставщика событий.

Это обёртка для функции uv_metrics_info. Она возвращает текущий набор метрик цикла событий.

Рекомендуется использовать это свойство внутри функции, выполнение которой запланировано с помощью setImmediate, чтобы не собирать метрики до завершения всех операций, запланированных в ходе текущей итерации цикла.

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

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, соответствующая моменту инициализации платформы V8.

performanceResourceTiming.workerStart

• Тип: <number>

Метка времени с высокой точностью в миллисекундах непосредственно перед отправкой запроса fetch. Если ресурс не перехвачен рабочим потоком, свойство всегда возвращает 0.

performanceResourceTiming.redirectStart

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, обозначающая время начала запроса fetch, инициирующего перенаправление.

performanceResourceTiming.redirectEnd

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, которая будет зафиксирована сразу после получения последнего байта ответа последнего перенаправления.

performanceResourceTiming.fetchStart

• Тип: <number>

Метка времени с высокой точностью в миллисекундах непосредственно перед тем, как Node.js начинает получать ресурс.

performanceResourceTiming.domainLookupStart

• Тип: <number>

Метка времени с высокой точностью в миллисекундах непосредственно перед тем, как Node.js начинает поиск доменного имени ресурса.

performanceResourceTiming.domainLookupEnd

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, обозначающая момент сразу после завершения Node.js поиска доменного имени ресурса.

performanceResourceTiming.connectStart

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, обозначающая момент непосредственно перед тем, как Node.js начинает устанавливать соединение с сервером для получения ресурса.

performanceResourceTiming.connectEnd

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, обозначающая момент сразу после завершения Node.js установки соединения с сервером для получения ресурса.

performanceResourceTiming.secureConnectionStart

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, обозначающая момент непосредственно перед тем, как Node.js начинает процесс рукопожатия для защиты текущего соединения.

performanceResourceTiming.requestStart

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, обозначающая момент непосредственно перед получением Node.js первого байта ответа от сервера.

performanceResourceTiming.responseEnd

• Тип: <number>

Метка времени с высокой точностью в миллисекундах, обозначающая момент сразу после получения Node.js последнего байта ресурса или непосредственно перед закрытием транспортного соединения — в зависимости от того, что произойдёт раньше.

performanceResourceTiming.transferSize

• Тип: <number>

Число, обозначающее размер загруженного ресурса (в октетах). Размер включает поля заголовка ответа и тело полезной нагрузки ответа.

performanceResourceTiming.encodedBodySize

• Тип: <number>

Число, обозначающее размер тела полезной нагрузки (в октетах), полученного в результате fetch (по HTTP или из кэша), до удаления применённых кодировок содержимого.

performanceResourceTiming.decodedBodySize

• Тип: <number>

Число, обозначающее размер тела сообщения (в октетах), полученного в результате fetch (по HTTP или из кэша), после удаления применённых кодировок содержимого.

performanceResourceTiming.toJSON()

Возвращает object — JSON-представление объекта PerformanceResourceTiming.

PerformanceObserver.supportedEntryTypes

• Тип: <string[]>

Возвращает поддерживаемые типы.

new PerformanceObserver(callback)

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

Объекты PerformanceObserver уведомляют о добавлении новых экземпляров PerformanceEntry в 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');

Поскольку экземпляры PerformanceObserver создают дополнительную нагрузку на производительность, не следует оставлять их подписанными на уведомления на неопределённый срок. Пользователям следует отключать наблюдатели, как только они перестанут быть нужны.

Функция callback вызывается, когда PerformanceObserver получает уведомление о новых экземплярах PerformanceEntry. Обратный вызов получает экземпляр PerformanceObserverEntryList и ссылку на PerformanceObserver.

performanceObserver.disconnect()

Отключает экземпляр PerformanceObserver от всех уведомлений.

performanceObserver.observe(options)

• options <Object>
  • type <string> Один тип <PerformanceEntry>. Не указывайте, если уже задан entryTypes.
  • entryTypes <string[]> Массив строк, определяющих типы экземпляров <PerformanceEntry>, представляющих интерес для наблюдателя. Если параметр не указан, будет вызвана ошибка.
  • buffered <boolean> Если значение равно true, обратный вызов наблюдателя вызывается со списком всех буферизованных записей PerformanceEntry. Если значение равно false, в обратный вызов наблюдателя передаются только PerformanceEntrys, созданные после указанного момента времени. По умолчанию: false.

Подписывает экземпляр <PerformanceObserver> на уведомления о новых экземплярах <PerformanceEntry>, определяемых с помощью options.entryTypes или 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()

• Возвращает: <PerformanceEntry[]> Текущий список записей, сохранённых в наблюдателе производительности; после возврата список очищается.

performanceObserverEntryList.getEntries()

• Возвращает: <PerformanceEntry[]>

Возвращает список объектов PerformanceEntry в хронологическом порядке относительно 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>
• Возвращает: <PerformanceEntry[]>

Возвращает список объектов PerformanceEntry в хронологическом порядке относительно performanceEntry.startTime, у которых performanceEntry.name равно name и, при необходимости, performanceEntry.entryType равно type.

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

const {
  performance,
  PerformanceObserver,
} = require('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');

performanceObserverEntryList.getEntriesByType(type)

• type <string>
• Возвращает: <PerformanceEntry[]>

Возвращает список объектов PerformanceEntry в хронологическом порядке относительно performanceEntry.startTime, у которых performanceEntry.entryType равно 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');

const {
  performance,
  PerformanceObserver,
} = require('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');

histogram.count

• Тип: <number>

Количество выборок, записанных гистограммой.

histogram.countBigInt

• Тип: <bigint>

Количество выборок, записанных гистограммой.

histogram.exceeds

• Тип: <number>

Количество случаев, когда задержка цикла событий превышала максимальный порог задержки цикла событий, равный 1 часу.

histogram.exceedsBigInt

• Тип: <bigint>

Количество случаев, когда задержка цикла событий превышала максимальный порог задержки цикла событий, равный 1 часу.

histogram.max

• Тип: <number>

Максимальная зарегистрированная задержка цикла событий.

histogram.maxBigInt

• Тип: <bigint>

Максимальная зарегистрированная задержка цикла событий.

histogram.mean

• Тип: <number>

Среднее значение зарегистрированных задержек цикла событий.

histogram.min

• Тип: <number>

Минимальная зарегистрированная задержка цикла событий.

histogram.minBigInt

• Тип: <bigint>

Минимальная зарегистрированная задержка цикла событий.

histogram.percentile(percentile)

• percentile <number> Значение процентиля в диапазоне (0, 100].
• Возвращает: <number>

Возвращает значение для заданного процентиля.

histogram.percentileBigInt(percentile)

• percentile <number> Значение процентиля в диапазоне (0, 100].
• Возвращает: <bigint>

Возвращает значение для заданного процентиля.

histogram.percentiles

• Тип: <Map>

Возвращает объект Map с данными о накопленном распределении процентилей.

histogram.percentilesBigInt

• Тип: <Map>

Возвращает объект Map с данными о накопленном распределении процентилей.

histogram.reset()

Сбрасывает собранные данные гистограммы.

histogram.stddev

• Тип: <number>

Стандартное отклонение зарегистрированных задержек цикла событий.

histogram.disable()

• Возвращает: <boolean>

Отключает таймер интервала обновления. Возвращает true, если таймер был остановлен, и false, если он уже был остановлен.

histogram.enable()

• Возвращает: <boolean>

Включает таймер интервала обновления. Возвращает true, если таймер был запущен, и false, если он уже был запущен.

Клонирование IntervalHistogram

Экземпляры <IntervalHistogram> можно клонировать с помощью <MessagePort>. На принимающей стороне гистограмма клонируется как обычный объект <Histogram>, не реализующий методы enable() и disable().

histogram.add(other)

• other <RecordableHistogram>

Добавляет в эту гистограмму значения из other.

histogram.record(val)

• val <number> | <bigint> Значение, записываемое в гистограмму.

histogram.recordDelta()

Вычисляет время (в наносекундах), прошедшее с предыдущего вызова recordDelta(), и записывает это значение в гистограмму.

Измерение длительности асинхронных операций

В следующем примере используются API Async Hooks и Performance для измерения фактической длительности операции Timeout (включая время выполнения обратного вызова).

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

const set = new Set();
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 = new PerformanceObserver((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 = 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'] });

setTimeout(() => {}, 1000);

Измерение времени загрузки зависимостей

В следующем примере измеряется длительность операций require() по загрузке зависимостей:

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

// Activate the observer
const obs = new PerformanceObserver((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) => {
  return await import(module);
});

await timedImport('some-module');

'use strict';
const {
  performance,
  PerformanceObserver,
} = require('node:perf_hooks');
const mod = require('node:module');

// Monkey patch the require function
mod.Module.prototype.require =
  performance.timerify(mod.Module.prototype.require);
require = performance.timerify(require);

// Activate the observer
const obs = new PerformanceObserver((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');

Измерение времени одного обмена данными по HTTP

Следующий пример используется для отслеживания времени, затраченного HTTP-клиентом (OutgoingMessage) и HTTP-запросом (IncomingMessage). Для HTTP-клиента это интервал времени между отправкой запроса и получением ответа, а для HTTP-запроса — интервал времени между получением запроса и отправкой ответа:

import { PerformanceObserver } from 'node:perf_hooks';
import { createServer, get } from 'node:http';

const obs = new PerformanceObserver((items) => {
  items.getEntries().forEach((item) => {
    console.log(item);
  });
});

obs.observe({ entryTypes: ['http'] });

const PORT = 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 = new PerformanceObserver((items) => {
  items.getEntries().forEach((item) => {
    console.log(item);
  });
});

obs.observe({ entryTypes: ['http'] });

const PORT = 8080;

http.createServer((req, res) => {
  res.end('ok');
}).listen(PORT, () => {
  http.get(`http://127.0.0.1:${PORT}`);
});

Измерение времени выполнения net.connect (только для TCP) при успешном подключении

import { PerformanceObserver } from 'node:perf_hooks';
import { connect, createServer } from 'node:net';

const obs = new PerformanceObserver((items) => {
  items.getEntries().forEach((item) => {
    console.log(item);
  });
});
obs.observe({ entryTypes: ['net'] });
const PORT = 8080;
createServer((socket) => {
  socket.destroy();
}).listen(PORT, () => {
  connect(PORT);
});

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

Измерение времени выполнения DNS при успешном запросе

import { PerformanceObserver } from 'node:perf_hooks';
import { lookup, promises } from 'node:dns';

const obs = new PerformanceObserver((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 = new PerformanceObserver((items) => {
  items.getEntries().forEach((item) => {
    console.log(item);
  });
});
obs.observe({ entryTypes: ['dns'] });
dns.lookup('localhost', () => {});
dns.promises.resolve('localhost');