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>

Это псевдоним perf_hooks.eventLoopUtilization().

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

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(), который записывает длительность выполнения в наносекундах.

Это псевдоним perf_hooks.timerify().

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

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 до получения подтверждения. Присутствует только в том случае, если кадр PING был отправлен через Http2Session.
• streamAverageDuration <number> Средняя длительность (в миллисекундах) всех экземпляров Http2Stream.
• streamCount <number> Количество экземпляров Http2Stream, обработанных Http2Session.
• type <string> Для определения типа Http2Session используется либо 'server', либо 'client'.

Сведения о 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>

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

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>

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

performanceResourceTiming.decodedBodySize

• Тип: <number>

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

performanceResourceTiming.toJSON()

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

PerformanceObserver.supportedEntryTypes

• Тип: <string[]>

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

new PerformanceObserver(callback)

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

Объекты PerformanceObserver уведомляют о добавлении новых экземпляров PerformanceEntry в шкалу производительности.

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, в обратный вызов наблюдателя передаются только записи PerformanceEntry, созданные после указанного момента времени. По умолчанию: 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>

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

histogram.exceedsBigInt

• Тип: <bigint>

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

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, если он уже был запущен.

histogram[Symbol.dispose]()

Отключает таймер интервала обновления при удалении гистограммы.

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

Клонирование 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');