API de mesure de la performance

[Stable: 2 - Stable]

Stable: 2 Stability: 2 - Stable

Code source : lib/perf_hooks.js

Ce module fournit une implémentation d'un sous-ensemble des API de performance Web du W3C, ainsi que des API supplémentaires pour les mesures de performance spécifiques à Node.js.

Node.js prend en charge les API de performance Web suivantes :

• Temps haute résolution
• Chronologie des performances
• Temps utilisateur
• Temps de ressource

ESM

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

const obs = new PerformanceObserver((items) => {
  console.log(items.getEntries()[0].duration);
  performance.clearMarks();
});
obs.observe({ type: 'measure' });
performance.measure('Start to Now');

performance.mark('A');
doSomeLongRunningProcess(() => {
  performance.measure('A to Now', 'A');

  performance.mark('B');
  performance.measure('A to B', 'A', 'B');
});

CJS

const { PerformanceObserver, performance } = require('node:perf_hooks');

const obs = new PerformanceObserver((items) => {
  console.log(items.getEntries()[0].duration);
});
obs.observe({ type: 'measure' });
performance.measure('Start to Now');

performance.mark('A');
(async function doSomeLongRunningProcess() {
  await new Promise((r) => setTimeout(r, 5000));
  performance.measure('A to Now', 'A');

  performance.mark('B');
  performance.measure('A to B', 'A', 'B');
})();

perf_hooks.performance

Ajouté dans : v8.5.0

Un objet qui peut être utilisé pour collecter des mesures de performance à partir de l’instance Node.js actuelle. Il est similaire à window.performance dans les navigateurs.

performance.clearMarks([name])

[Historique]

Version	Modifications
v19.0.0	Cette méthode doit être appelée avec l'objet performance comme récepteur.
v8.5.0	Ajouté dans : v8.5.0

• name <string>

Si name n'est pas fourni, supprime tous les objets PerformanceMark de la chronologie des performances. Si name est fourni, supprime uniquement la marque nommée.

performance.clearMeasures([name])

[Historique]

Version	Modifications
v19.0.0	Cette méthode doit être appelée avec l'objet performance comme récepteur.
v16.7.0	Ajouté dans : v16.7.0

• name <string>

Si name n'est pas fourni, supprime tous les objets PerformanceMeasure de la chronologie des performances. Si name est fourni, supprime uniquement la mesure nommée.

performance.clearResourceTimings([name])

[Historique]

Version	Modifications
v19.0.0	Cette méthode doit être appelée avec l'objet performance comme récepteur.
v18.2.0, v16.17.0	Ajouté dans : v18.2.0, v16.17.0

• name <string>

Si name n'est pas fourni, supprime tous les objets PerformanceResourceTiming de la chronologie des ressources. Si name est fourni, supprime uniquement la ressource nommée.

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

Ajouté dans : v14.10.0, v12.19.0

• utilization1 <Object> Le résultat d'un appel précédent à eventLoopUtilization().
• utilization2 <Object> Le résultat d'un appel précédent à eventLoopUtilization() avant utilization1.
• Retourne : <Object>
  • idle <number>
  • active <number>
  • utilization <number>

La méthode eventLoopUtilization() retourne un objet qui contient la durée cumulative du temps pendant lequel la boucle d'événements a été à la fois inactive et active en tant que temporisateur en millisecondes haute résolution. La valeur utilization est l'utilisation calculée de la boucle d'événements (ELU).

Si l'amorçage n'est pas encore terminé sur le thread principal, les propriétés ont la valeur 0. L'ELU est immédiatement disponible sur les threads Worker car l'amorçage se produit dans la boucle d'événements.

utilization1 et utilization2 sont des paramètres facultatifs.

Si utilization1 est passé, alors le delta entre les temps active et idle de l'appel actuel, ainsi que la valeur utilization correspondante, sont calculés et retournés (similaire à process.hrtime()).

Si utilization1 et utilization2 sont tous deux passés, alors le delta est calculé entre les deux arguments. Il s'agit d'une option pratique car, contrairement à process.hrtime(), le calcul de l'ELU est plus complexe qu'une simple soustraction.

L'ELU est similaire à l'utilisation du CPU, sauf qu'elle ne mesure que les statistiques de la boucle d'événements et non l'utilisation du CPU. Elle représente le pourcentage de temps que la boucle d'événements a passé en dehors du fournisseur d'événements de la boucle d'événements (par exemple, epoll_wait). Aucun autre temps d'inactivité du CPU n'est pris en compte. Voici un exemple de la façon dont un processus principalement inactif aura une ELU élevée.

ESM

import { eventLoopUtilization } from 'node:perf_hooks';
import { spawnSync } from 'node:child_process';

setImmediate(() => {
  const elu = eventLoopUtilization();
  spawnSync('sleep', ['5']);
  console.log(eventLoopUtilization(elu).utilization);
});

CJS

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

Bien que le CPU soit principalement inactif pendant l'exécution de ce script, la valeur de utilization est 1. En effet, l'appel à child_process.spawnSync() empêche la boucle d'événements de progresser.

Passer un objet défini par l'utilisateur au lieu du résultat d'un appel précédent à eventLoopUtilization() conduira à un comportement non défini. Les valeurs de retour ne sont pas garanties de refléter un état correct de la boucle d'événements.

performance.getEntries()

[Historique]

Version	Modifications
v19.0.0	Cette méthode doit être appelée avec l'objet performance comme récepteur.
v16.7.0	Ajoutée dans : v16.7.0

• Retourne : <PerformanceEntry[]>

Retourne une liste d'objets PerformanceEntry par ordre chronologique par rapport à performanceEntry.startTime. Si vous êtes uniquement intéressé par les entrées de performance de certains types ou qui ont certains noms, consultez performance.getEntriesByType() et performance.getEntriesByName().

performance.getEntriesByName(name[, type])

[Historique]

Version	Modifications
v19.0.0	Cette méthode doit être appelée avec l'objet performance comme récepteur.
v16.7.0	Ajoutée dans : v16.7.0

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

Retourne une liste d'objets PerformanceEntry par ordre chronologique par rapport à performanceEntry.startTime dont performanceEntry.name est égal à name et, éventuellement, dont performanceEntry.entryType est égal à type.

performance.getEntriesByType(type)

[Historique]

Version	Modifications
v19.0.0	Cette méthode doit être appelée avec l'objet performance comme récepteur.
v16.7.0	Ajoutée dans : v16.7.0

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

Retourne une liste d'objets PerformanceEntry par ordre chronologique par rapport à performanceEntry.startTime dont performanceEntry.entryType est égal à type.

performance.mark(name[, options])

[Historique]

Version	Modifications
v19.0.0	Cette méthode doit être appelée avec l'objet performance comme récepteur. L'argument name n'est plus optionnel.
v16.0.0	Mis à jour pour se conformer à la spécification User Timing Level 3.
v8.5.0	Ajoutée dans : v8.5.0

• name <string>
• options <Object>
  • detail <any> Détail optionnel supplémentaire à inclure avec la marque.
  • startTime <number> Un horodatage optionnel à utiliser comme heure de la marque. Par défaut : performance.now().

Crée une nouvelle entrée PerformanceMark dans la Performance Timeline. Une PerformanceMark est une sous-classe de PerformanceEntry dont performanceEntry.entryType est toujours 'mark', et dont performanceEntry.duration est toujours 0. Les marques de performance sont utilisées pour marquer des moments importants spécifiques dans la Performance Timeline.

L'entrée PerformanceMark créée est placée dans la Performance Timeline globale et peut être interrogée avec performance.getEntries, performance.getEntriesByName et performance.getEntriesByType. Lorsque l'observation est effectuée, les entrées doivent être effacées manuellement de la Performance Timeline globale avec performance.clearMarks.

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

[Historique]

Version	Modifications
v22.2.0	Ajout des arguments bodyInfo, responseStatus et deliveryType.
v18.2.0, v16.17.0	Ajouté dans : v18.2.0, v16.17.0

• timingInfo <Object> Fetch Timing Info
• requestedUrl <string> L'URL de la ressource
• initiatorType <string> Le nom de l'initiateur, par exemple : 'fetch'
• global <Object>
• cacheMode <string> Le mode de cache doit être une chaîne vide ('') ou 'local'
• bodyInfo <Object> Fetch Response Body Info
• responseStatus <number> Le code d'état de la réponse
• deliveryType <string> Le type de livraison. Par défaut : ''.

Cette propriété est une extension de Node.js. Elle n'est pas disponible dans les navigateurs Web.

Crée une nouvelle entrée PerformanceResourceTiming dans la Timeline des ressources. Un PerformanceResourceTiming est une sous-classe de PerformanceEntry dont performanceEntry.entryType est toujours 'resource'. Les ressources de performance sont utilisées pour marquer des moments dans la Timeline des ressources.

L'entrée PerformanceMark créée est placée dans la Timeline des ressources globale et peut être interrogée avec performance.getEntries, performance.getEntriesByName et performance.getEntriesByType. Lorsque l'observation est effectuée, les entrées doivent être effacées manuellement de la Timeline des performances globale avec performance.clearResourceTimings.

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

[Historique]

Version	Modifications
v19.0.0	Cette méthode doit être appelée avec l'objet performance comme récepteur.
v16.0.0	Mise à jour pour être conforme à la spécification User Timing Level 3.
v13.13.0, v12.16.3	Les paramètres startMark et endMark sont rendus optionnels.
v8.5.0	Ajouté dans : v8.5.0

• name <string>

• startMarkOrOptions <string> | <Object> Optionnel.

  • detail <any> Détail optionnel supplémentaire à inclure avec la mesure.
  • duration <number> Durée entre les heures de début et de fin.
  • end <number> | <string> Horodatage à utiliser comme heure de fin, ou une chaîne identifiant une marque précédemment enregistrée.
  • start <number> | <string> Horodatage à utiliser comme heure de début, ou une chaîne identifiant une marque précédemment enregistrée.

• endMark <string> Optionnel. Doit être omis si startMarkOrOptions est un <Object>.

Crée une nouvelle entrée PerformanceMeasure dans la Performance Timeline. Un PerformanceMeasure est une sous-classe de PerformanceEntry dont performanceEntry.entryType est toujours 'measure', et dont performanceEntry.duration mesure le nombre de millisecondes écoulées entre startMark et endMark.

L'argument startMark peut identifier n'importe quel PerformanceMark existant dans la Performance Timeline, ou peut identifier l'une des propriétés d'horodatage fournies par la classe PerformanceNodeTiming. Si le startMark nommé n'existe pas, une erreur est renvoyée.

L'argument optionnel endMark doit identifier n'importe quel PerformanceMark existant dans la Performance Timeline ou l'une des propriétés d'horodatage fournies par la classe PerformanceNodeTiming. endMark sera performance.now() si aucun paramètre n'est passé, sinon, si le endMark nommé n'existe pas, une erreur sera renvoyée.

L'entrée PerformanceMeasure créée est placée dans la Performance Timeline globale et peut être interrogée avec performance.getEntries, performance.getEntriesByName et performance.getEntriesByType. Lorsque l'observation est effectuée, les entrées doivent être effacées manuellement de la Performance Timeline globale avec performance.clearMeasures.

performance.nodeTiming

Ajouté dans : v8.5.0

• <PerformanceNodeTiming>

Cette propriété est une extension de Node.js. Elle n’est pas disponible dans les navigateurs Web.

Une instance de la classe PerformanceNodeTiming qui fournit des mesures de performance pour des étapes opérationnelles spécifiques de Node.js.

performance.now()

[Historique]

Version	Modifications
v19.0.0	Cette méthode doit être appelée avec l’objet performance comme récepteur.
v8.5.0	Ajouté dans : v8.5.0

• Retourne : <number>

Retourne l’horodatage actuel en millisecondes à haute résolution, où 0 représente le début du processus node actuel.

performance.setResourceTimingBufferSize(maxSize)

[Historique]

Version	Modifications
v19.0.0	Cette méthode doit être appelée avec l’objet performance comme récepteur.
v18.8.0	Ajouté dans : v18.8.0

Définit la taille globale de la mémoire tampon de minutage des ressources de performance au nombre spécifié d’objets d’entrée de performance de type « resource ».

Par défaut, la taille maximale de la mémoire tampon est définie sur 250.

performance.timeOrigin

Ajouté dans : v8.5.0

• <number>

timeOrigin spécifie l’horodatage en millisecondes à haute résolution auquel le processus node actuel a commencé, mesuré en temps Unix.

performance.timerify(fn[, options])

[Historique]

Version	Modifications
v16.0.0	Ajout de l’option histogram.
v16.0.0	Réimplémenté pour utiliser du JavaScript pur et la possibilité de chronométrer les fonctions asynchrones.
v8.5.0	Ajouté dans : v8.5.0

• fn <Function>
• options <Object>
  • histogram <RecordableHistogram> Un objet histogramme créé à l’aide de perf_hooks.createHistogram() qui enregistrera les durées d’exécution en nanosecondes.

Cette propriété est une extension de Node.js. Elle n’est pas disponible dans les navigateurs Web.

Encapsule une fonction dans une nouvelle fonction qui mesure le temps d’exécution de la fonction encapsulée. Un PerformanceObserver doit être abonné au type d’événement 'function' pour que les détails de synchronisation soient accessibles.

ESM

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

CJS

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

Si la fonction encapsulée retourne une promesse, un gestionnaire finally sera attaché à la promesse et la durée sera signalée une fois que le gestionnaire finally sera appelé.

performance.toJSON()

[Historique]

Version	Modifications
v19.0.0	Cette méthode doit être appelée avec l'objet performance comme récepteur.
v16.1.0	Ajoutée dans : v16.1.0

Un objet qui est une représentation JSON de l'objet performance. Il est similaire à window.performance.toJSON dans les navigateurs.

Événement : 'resourcetimingbufferfull'

Ajoutée dans : v18.8.0

L'événement 'resourcetimingbufferfull' est déclenché lorsque la mémoire tampon globale de synchronisation des ressources de performance est pleine. Ajustez la taille de la mémoire tampon de synchronisation des ressources avec performance.setResourceTimingBufferSize() ou effacez la mémoire tampon avec performance.clearResourceTimings() dans l'écouteur d'événements pour permettre à davantage d'entrées d'être ajoutées à la mémoire tampon de la timeline de performance.

Class: PerformanceEntry

Ajoutée dans : v8.5.0

Le constructeur de cette classe n'est pas directement exposé aux utilisateurs.

performanceEntry.duration

[Historique]

Version	Modifications
v19.0.0	Ce getter de propriété doit être appelé avec l'objet PerformanceEntry comme récepteur.
v8.5.0	Ajoutée dans : v8.5.0

• <number>

Le nombre total de millisecondes écoulées pour cette entrée. Cette valeur n'aura pas de sens pour tous les types d'entrée de performance.

performanceEntry.entryType

[Historique]

Version	Modifications
v19.0.0	Ce getter de propriété doit être appelé avec l'objet PerformanceEntry comme récepteur.
v8.5.0	Ajoutée dans : v8.5.0

• <string>

Le type de l'entrée de performance. Il peut être l'un des suivants :

• 'dns' (Node.js uniquement)
• 'function' (Node.js uniquement)
• 'gc' (Node.js uniquement)
• 'http2' (Node.js uniquement)
• 'http' (Node.js uniquement)
• 'mark' (disponible sur le Web)
• 'measure' (disponible sur le Web)
• 'net' (Node.js uniquement)
• 'node' (Node.js uniquement)
• 'resource' (disponible sur le Web)

performanceEntry.name

[Historique]

Version	Modifications
v19.0.0	L'accesseur de cette propriété doit être appelé avec l'objet PerformanceEntry comme récepteur.
v8.5.0	Ajouté dans : v8.5.0

• <string>

Le nom de l'entrée de performance.

performanceEntry.startTime

[Historique]

Version	Modifications
v19.0.0	L'accesseur de cette propriété doit être appelé avec l'objet PerformanceEntry comme récepteur.
v8.5.0	Ajouté dans : v8.5.0

• <number>

L'horodatage en millisecondes haute résolution marquant l'heure de début de l'entrée de performance.

Classe : PerformanceMark

Ajouté dans : v18.2.0, v16.17.0

• Étend : <PerformanceEntry>

Expose les marques créées via la méthode Performance.mark().

performanceMark.detail

[Historique]

Version	Modifications
v19.0.0	L'accesseur de cette propriété doit être appelé avec l'objet PerformanceMark comme récepteur.
v16.0.0	Ajouté dans : v16.0.0

• <any>

Détail supplémentaire spécifié lors de la création avec la méthode Performance.mark().

Classe : PerformanceMeasure

Ajouté dans : v18.2.0, v16.17.0

• Étend : <PerformanceEntry>

Expose les mesures créées via la méthode Performance.measure().

Le constructeur de cette classe n'est pas directement exposé aux utilisateurs.

performanceMeasure.detail

[Historique]

Version	Modifications
v19.0.0	L'accesseur de cette propriété doit être appelé avec l'objet PerformanceMeasure comme récepteur.
v16.0.0	Ajouté dans : v16.0.0

• <any>

Détail supplémentaire spécifié lors de la création avec la méthode Performance.measure().

Classe : PerformanceNodeEntry

Ajouté dans : v19.0.0

• Hérite de : <PerformanceEntry>

Cette classe est une extension de Node.js. Elle n’est pas disponible dans les navigateurs Web.

Fournit des données de synchronisation Node.js détaillées.

Le constructeur de cette classe n’est pas directement exposé aux utilisateurs.

performanceNodeEntry.detail

[Historique]

Version	Modifications
v19.0.0	Ce getter de propriété doit être appelé avec l’objet PerformanceNodeEntry comme récepteur.
v16.0.0	Ajouté dans : v16.0.0

• <any>

Détails supplémentaires spécifiques au entryType.

performanceNodeEntry.flags

[Historique]

Version	Modifications
v16.0.0	Obsolète lors de l’exécution. Maintenant déplacé vers la propriété detail lorsque entryType est 'gc'.
v13.9.0, v12.17.0	Ajouté dans : v13.9.0, v12.17.0

[Stable : 0 - Obsolète]

Stable : 0 Stabilité : 0 - Obsolète : Utilisez plutôt performanceNodeEntry.detail.

• <number>

Lorsque performanceEntry.entryType est égal à 'gc', la propriété performance.flags contient des informations supplémentaires sur l’opération de garbage collection. La valeur peut être l’une des suivantes :

• 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

[Historique]

Version	Modifications
v16.0.0	Obsolète lors de l’exécution. Maintenant déplacé vers la propriété detail lorsque entryType est 'gc'.
v8.5.0	Ajouté dans : v8.5.0

[Stable : 0 - Obsolète]

Stable : 0 Stabilité : 0 - Obsolète : Utilisez plutôt performanceNodeEntry.detail.

• <number>

Lorsque performanceEntry.entryType est égal à 'gc', la propriété performance.kind identifie le type d’opération de garbage collection qui s’est produite. La valeur peut être l’une des suivantes :

• 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

Détails du ramasse-miettes ('gc')

Quand performanceEntry.type est égal à 'gc', la propriété performanceNodeEntry.detail sera un <Object> avec deux propriétés :

• kind <number> Un parmi :

  • 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> Un parmi :

  • 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

Détails HTTP ('http')

Quand performanceEntry.type est égal à 'http', la propriété performanceNodeEntry.detail sera un <Object> contenant des informations supplémentaires.

Si performanceEntry.name est égal à HttpClient, le detail contiendra les propriétés suivantes : req, res. Et la propriété req sera un <Object> contenant method, url, headers, la propriété res sera un <Object> contenant statusCode, statusMessage, headers.

Si performanceEntry.name est égal à HttpRequest, le detail contiendra les propriétés suivantes : req, res. Et la propriété req sera un <Object> contenant method, url, headers, la propriété res sera un <Object> contenant statusCode, statusMessage, headers.

Cela pourrait ajouter une surcharge mémoire supplémentaire et ne devrait être utilisé qu'à des fins de diagnostic, et non être activé en production par défaut.

Détails HTTP/2 ('http2')

Quand performanceEntry.type est égal à 'http2', la propriété performanceNodeEntry.detail sera un <Object> contenant des informations de performance additionnelles.

Si performanceEntry.name est égal à Http2Stream, le detail contiendra les propriétés suivantes :

• bytesRead <number> Le nombre d'octets de trame DATA reçus pour ce Http2Stream.
• bytesWritten <number> Le nombre d'octets de trame DATA envoyés pour ce Http2Stream.
• id <number> L'identifiant du Http2Stream associé.
• timeToFirstByte <number> Le nombre de millisecondes écoulées entre le startTime de PerformanceEntry et la réception de la première trame DATA.
• timeToFirstByteSent <number> Le nombre de millisecondes écoulées entre le startTime de PerformanceEntry et l'envoi de la première trame DATA.
• timeToFirstHeader <number> Le nombre de millisecondes écoulées entre le startTime de PerformanceEntry et la réception du premier en-tête.

Si performanceEntry.name est égal à Http2Session, le detail contiendra les propriétés suivantes :

• bytesRead <number> Le nombre d'octets reçus pour cette Http2Session.
• bytesWritten <number> Le nombre d'octets envoyés pour cette Http2Session.
• framesReceived <number> Le nombre de trames HTTP/2 reçues par la Http2Session.
• framesSent <number> Le nombre de trames HTTP/2 envoyées par la Http2Session.
• maxConcurrentStreams <number> Le nombre maximum de flux ouverts simultanément pendant la durée de vie de la Http2Session.
• pingRTT <number> Le nombre de millisecondes écoulées depuis la transmission d'une trame PING et la réception de son accusé de réception. Présent uniquement si une trame PING a été envoyée sur la Http2Session.
• streamAverageDuration <number> La durée moyenne (en millisecondes) pour toutes les instances Http2Stream.
• streamCount <number> Le nombre d'instances Http2Stream traitées par la Http2Session.
• type <string> Soit 'server' soit 'client' pour identifier le type de Http2Session.

Timerify ('function') Détails

Quand performanceEntry.type est égal à 'function', la propriété performanceNodeEntry.detail sera un <Array> listant les arguments d'entrée de la fonction chronométrée.

Net ('net') Détails

Quand performanceEntry.type est égal à 'net', la propriété performanceNodeEntry.detail sera un <Object> contenant des informations supplémentaires.

Si performanceEntry.name est égal à connect, le detail contiendra les propriétés suivantes : host, port.

DNS ('dns') Détails

Quand performanceEntry.type est égal à 'dns', la propriété performanceNodeEntry.detail sera un <Object> contenant des informations supplémentaires.

Si performanceEntry.name est égal à lookup, le detail contiendra les propriétés suivantes : hostname, family, hints, verbatim, addresses.

Si performanceEntry.name est égal à lookupService, le detail contiendra les propriétés suivantes : host, port, hostname, service.

Si performanceEntry.name est égal à queryxxx ou getHostByAddr, le detail contiendra les propriétés suivantes : host, ttl, result. La valeur de result est la même que le résultat de queryxxx ou getHostByAddr.

Class : PerformanceNodeTiming

Ajouté dans : v8.5.0

• Étend : <PerformanceEntry>

Cette propriété est une extension de Node.js. Elle n’est pas disponible dans les navigateurs Web.

Fournit des détails de synchronisation pour Node.js lui-même. Le constructeur de cette classe n’est pas exposé aux utilisateurs.

performanceNodeTiming.bootstrapComplete

Ajouté dans : v8.5.0

• <number>

L’horodatage en millisecondes haute résolution auquel le processus Node.js a terminé l’amorçage. Si l’amorçage n’est pas encore terminé, la propriété a la valeur -1.

performanceNodeTiming.environment

Ajouté dans : v8.5.0

• <number>

L’horodatage en millisecondes haute résolution auquel l’environnement Node.js a été initialisé.

performanceNodeTiming.idleTime

Ajouté dans : v14.10.0, v12.19.0

• <number>

L’horodatage en millisecondes haute résolution du temps pendant lequel la boucle d’événements a été inactive dans le fournisseur d’événements de la boucle d’événements (par exemple, epoll_wait). Ceci ne tient pas compte de l’utilisation du CPU. Si la boucle d’événements n’a pas encore démarré (par exemple, dans le premier tick du script principal), la propriété a la valeur 0.

performanceNodeTiming.loopExit

Ajouté dans : v8.5.0

• <number>

L’horodatage en millisecondes haute résolution auquel la boucle d’événements Node.js s’est terminée. Si la boucle d’événements n’est pas encore terminée, la propriété a la valeur -1. Elle ne peut avoir une valeur différente de -1 que dans un gestionnaire de l’événement 'exit'.

performanceNodeTiming.loopStart

Ajouté dans : v8.5.0

• <number>

L’horodatage en millisecondes haute résolution auquel la boucle d’événements Node.js a démarré. Si la boucle d’événements n’a pas encore démarré (par exemple, dans le premier tick du script principal), la propriété a la valeur -1.

performanceNodeTiming.nodeStart

Ajouté dans : v8.5.0

• <number>

L’horodatage en millisecondes haute résolution auquel le processus Node.js a été initialisé.

performanceNodeTiming.uvMetricsInfo

Ajouté dans : v22.8.0, v20.18.0

• Retourne : <Object>
  • loopCount <number> Nombre d’itérations de la boucle d’événements.
  • events <number> Nombre d’événements qui ont été traités par le gestionnaire d’événements.
  • eventsWaiting <number> Nombre d’événements qui attendaient d’être traités lorsque le fournisseur d’événements a été appelé.

Ceci est un wrapper de la fonction uv_metrics_info. Il retourne l’ensemble actuel des métriques de la boucle d’événements.

Il est recommandé d’utiliser cette propriété à l’intérieur d’une fonction dont l’exécution a été planifiée à l’aide de setImmediate pour éviter de collecter des métriques avant de terminer toutes les opérations planifiées pendant l’itération de la boucle actuelle.

CJS

const { performance } = require('node:perf_hooks');

setImmediate(() => {
  console.log(performance.nodeTiming.uvMetricsInfo);
});

ESM

import { performance } from 'node:perf_hooks';

setImmediate(() => {
  console.log(performance.nodeTiming.uvMetricsInfo);
});

performanceNodeTiming.v8Start

Ajouté dans : v8.5.0

• <number>

L’horodatage en millisecondes à haute résolution auquel la plateforme V8 a été initialisée.

Classe : PerformanceResourceTiming

Ajouté dans : v18.2.0, v16.17.0

• Hérite de : <PerformanceEntry>

Fournit des données de minutage réseau détaillées concernant le chargement des ressources d’une application.

Le constructeur de cette classe n’est pas directement exposé aux utilisateurs.

performanceResourceTiming.workerStart

[Historique]

Version	Modifications
v19.0.0	Ce getter de propriété doit être appelé avec l’objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajouté dans : v18.2.0, v16.17.0

• <number>

L’horodatage en millisecondes à haute résolution immédiatement avant la répartition de la requête fetch. Si la ressource n’est pas interceptée par un worker, la propriété renvoie toujours 0.

performanceResourceTiming.redirectStart

[Historique]

Version	Modifications
v19.0.0	Ce getter de propriété doit être appelé avec l’objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajouté dans : v18.2.0, v16.17.0

• <number>

L’horodatage en millisecondes à haute résolution qui représente l’heure de début de la récupération qui initie la redirection.

performanceResourceTiming.redirectEnd

[Historique]

Version	Modifications
v19.0.0	Ce getter de propriété doit être appelé avec l’objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajouté dans : v18.2.0, v16.17.0

• <number>

L’horodatage en millisecondes à haute résolution qui sera créé immédiatement après la réception du dernier octet de la réponse de la dernière redirection.

performanceResourceTiming.fetchStart

[Historique]

Version	Modifications
v19.0.0	Le getter de cette propriété doit être appelé avec l'objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajouté dans : v18.2.0, v16.17.0

• <number>

Le timestamp en millisecondes à haute résolution juste avant que Node.js ne commence à récupérer la ressource.

performanceResourceTiming.domainLookupStart

[Historique]

Version	Modifications
v19.0.0	Le getter de cette propriété doit être appelé avec l'objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajouté dans : v18.2.0, v16.17.0

• <number>

Le timestamp en millisecondes à haute résolution juste avant que Node.js ne commence la recherche du nom de domaine pour la ressource.

performanceResourceTiming.domainLookupEnd

[Historique]

Version	Modifications
v19.0.0	Le getter de cette propriété doit être appelé avec l'objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajouté dans : v18.2.0, v16.17.0

• <number>

Le timestamp en millisecondes à haute résolution représentant le moment immédiatement après que Node.js ait terminé la recherche du nom de domaine pour la ressource.

performanceResourceTiming.connectStart

[Historique]

Version	Modifications
v19.0.0	Le getter de cette propriété doit être appelé avec l'objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajouté dans : v18.2.0, v16.17.0

• <number>

Le timestamp en millisecondes à haute résolution représentant le moment immédiatement avant que Node.js ne commence à établir la connexion au serveur pour récupérer la ressource.

performanceResourceTiming.connectEnd

[Historique]

Version	Modifications
v19.0.0	L'accesseur de cette propriété doit être appelé avec l'objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajouté dans : v18.2.0, v16.17.0

• <number>

L'horodatage en millisecondes haute résolution représentant le moment immédiatement après que Node.js a terminé d'établir la connexion au serveur pour récupérer la ressource.

performanceResourceTiming.secureConnectionStart

[Historique]

Version	Modifications
v19.0.0	L'accesseur de cette propriété doit être appelé avec l'objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajouté dans : v18.2.0, v16.17.0

• <number>

L'horodatage en millisecondes haute résolution représentant le moment immédiatement avant que Node.js ne démarre le processus de négociation pour sécuriser la connexion actuelle.

performanceResourceTiming.requestStart

[Historique]

Version	Modifications
v19.0.0	L'accesseur de cette propriété doit être appelé avec l'objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajouté dans : v18.2.0, v16.17.0

• <number>

L'horodatage en millisecondes haute résolution représentant le moment immédiatement avant que Node.js ne reçoive le premier octet de la réponse du serveur.

performanceResourceTiming.responseEnd

[Historique]

Version	Modifications
v19.0.0	L'accesseur de cette propriété doit être appelé avec l'objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajouté dans : v18.2.0, v16.17.0

• <number>

L'horodatage en millisecondes haute résolution représentant le moment immédiatement après que Node.js a reçu le dernier octet de la ressource ou immédiatement avant la fermeture de la connexion de transport, selon la première éventualité.

performanceResourceTiming.transferSize

[Historique]

Version	Modifications
v19.0.0	L'accesseur de cette propriété doit être appelé avec l'objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajoutée dans : v18.2.0, v16.17.0

• <number>

Un nombre représentant la taille (en octets) de la ressource récupérée. La taille inclut les champs d'en-tête de réponse plus le corps de la charge utile de réponse.

performanceResourceTiming.encodedBodySize

[Historique]

Version	Modifications
v19.0.0	L'accesseur de cette propriété doit être appelé avec l'objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajoutée dans : v18.2.0, v16.17.0

• <number>

Un nombre représentant la taille (en octets) reçue de la requête (HTTP ou cache) du corps de la charge utile, avant de supprimer tout codage de contenu appliqué.

performanceResourceTiming.decodedBodySize

[Historique]

Version	Modifications
v19.0.0	L'accesseur de cette propriété doit être appelé avec l'objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajoutée dans : v18.2.0, v16.17.0

• <number>

Un nombre représentant la taille (en octets) reçue de la requête (HTTP ou cache) du corps du message, après avoir supprimé tout codage de contenu appliqué.

performanceResourceTiming.toJSON()

[Historique]

Version	Modifications
v19.0.0	Cette méthode doit être appelée avec l'objet PerformanceResourceTiming comme récepteur.
v18.2.0, v16.17.0	Ajoutée dans : v18.2.0, v16.17.0

Renvoie un object qui est la représentation JSON de l'objet PerformanceResourceTiming.

Classe : PerformanceObserver

Ajoutée dans : v8.5.0

PerformanceObserver.supportedEntryTypes

Ajoutée dans : v16.0.0

• <string[]>

Récupérer les types supportés.

new PerformanceObserver(callback)

[Historique]

Version	Modifications
v18.0.0	Le passage d'un rappel invalide à l'argument callback lève désormais ERR_INVALID_ARG_TYPE au lieu de ERR_INVALID_CALLBACK.
v8.5.0	Ajouté dans : v8.5.0

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

Les objets PerformanceObserver fournissent des notifications lorsque de nouvelles instances PerformanceEntry ont été ajoutées à la chronologie des performances (Performance Timeline).

ESM

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

CJS

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

Étant donné que les instances PerformanceObserver introduisent leurs propres frais de performance supplémentaires, les instances ne doivent pas rester abonnées indéfiniment aux notifications. Les utilisateurs doivent déconnecter les observers dès qu'ils ne sont plus nécessaires.

Le callback est invoqué lorsqu'un PerformanceObserver est notifié de nouvelles instances PerformanceEntry. Le rappel reçoit une instance PerformanceObserverEntryList et une référence au PerformanceObserver.

performanceObserver.disconnect()

Ajouté dans : v8.5.0

Déconnecte l'instance PerformanceObserver de toutes les notifications.

performanceObserver.observe(options)

[Historique]

Version	Modifications
v16.7.0	Mis à jour pour se conformer à Performance Timeline Level 2. L'option buffered a été rajoutée.
v16.0.0	Mis à jour pour se conformer à User Timing Level 3. L'option buffered a été supprimée.
v8.5.0	Ajouté dans : v8.5.0

• options <Object>
  • type <string> Un seul type <PerformanceEntry>. Ne doit pas être fourni si entryTypes est déjà spécifié.
  • entryTypes <string[]> Un tableau de chaînes identifiant les types d'instances <PerformanceEntry> qui intéressent l'observateur. Si elle n'est pas fournie, une erreur sera levée.
  • buffered <boolean> Si true, le callback de l'observateur est appelé avec une liste d'entrées PerformanceEntry globales mises en mémoire tampon. Si false, seules les PerformanceEntry créées après le point temporel sont envoyées au callback de l'observateur. Par défaut : false.

Abonne l'instance de <PerformanceObserver> aux notifications des nouvelles instances de <PerformanceEntry> identifiées soit par options.entryTypes, soit par options.type :

ESM

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

const obs = new PerformanceObserver((list, observer) => {
  // Appelé une fois de manière asynchrone. `list` contient trois éléments.
});
obs.observe({ type: 'mark' });

for (let n = 0; n < 3; n++)
  performance.mark(`test${n}`);

CJS

const {
  performance,
  PerformanceObserver,
} = require('node:perf_hooks');

const obs = new PerformanceObserver((list, observer) => {
  // Appelé une fois de manière asynchrone. `list` contient trois éléments.
});
obs.observe({ type: 'mark' });

for (let n = 0; n < 3; n++)
  performance.mark(`test${n}`);

performanceObserver.takeRecords()

Ajouté dans : v16.0.0

• Retourne : <PerformanceEntry[]> Liste actuelle des entrées stockées dans l'observateur de performance, en la vidant.

Classe : PerformanceObserverEntryList

Ajouté dans : v8.5.0

La classe PerformanceObserverEntryList est utilisée pour fournir un accès aux instances PerformanceEntry passées à un PerformanceObserver. Le constructeur de cette classe n'est pas exposé aux utilisateurs.

performanceObserverEntryList.getEntries()

Ajouté dans : v8.5.0

• Retourne : <PerformanceEntry[]>

Retourne une liste d'objets PerformanceEntry dans l'ordre chronologique par rapport à performanceEntry.startTime.

ESM

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

CJS

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])

Ajouté dans : v8.5.0

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

Retourne une liste d'objets PerformanceEntry dans l'ordre chronologique par rapport à performanceEntry.startTime dont performanceEntry.name est égal à name, et éventuellement, dont performanceEntry.entryType est égal à type.

ESM

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

CJS

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)

Ajouté dans : v8.5.0

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

Retourne une liste d'objets PerformanceEntry dans l'ordre chronologique par rapport à performanceEntry.startTime dont la propriété performanceEntry.entryType est égale à type.

ESM

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

CJS

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

perf_hooks.createHistogram([options])

Ajouté dans : v15.9.0, v14.18.0

• options <Object>

  • lowest <number> | <bigint> La valeur discernable la plus basse. Doit être une valeur entière supérieure à 0. Par défaut : 1.
  • highest <number> | <bigint> La valeur enregistrable la plus élevée. Doit être une valeur entière égale ou supérieure à deux fois lowest. Par défaut : Number.MAX_SAFE_INTEGER.
  • figures <number> Le nombre de chiffres de précision. Doit être un nombre compris entre 1 et 5. Par défaut : 3.

• Retourne : <RecordableHistogram>

Retourne un <RecordableHistogram>.

perf_hooks.monitorEventLoopDelay([options])

Ajouté dans: v11.10.0

• options <Object>

  • resolution <number> Le taux d'échantillonnage en millisecondes. Doit être supérieur à zéro. Par défaut: 10.

• Retourne: <IntervalHistogram>

Cette propriété est une extension de Node.js. Elle n'est pas disponible dans les navigateurs Web.

Crée un objet IntervalHistogram qui échantillonne et rapporte le délai de la boucle d'événements au fil du temps. Les délais seront rapportés en nanosecondes.

L'utilisation d'un minuteur pour détecter le délai approximatif de la boucle d'événements fonctionne car l'exécution des minuteurs est spécifiquement liée au cycle de vie de la boucle d'événements libuv. C'est-à-dire qu'un délai dans la boucle entraînera un délai dans l'exécution du minuteur, et ces délais sont précisément ce que cette API est destinée à détecter.

ESM

import { monitorEventLoopDelay } from 'node:perf_hooks';

const h = monitorEventLoopDelay({ resolution: 20 });
h.enable();
// Do something.
h.disable();
console.log(h.min);
console.log(h.max);
console.log(h.mean);
console.log(h.stddev);
console.log(h.percentiles);
console.log(h.percentile(50));
console.log(h.percentile(99));

CJS

const { monitorEventLoopDelay } = require('node:perf_hooks');
const h = monitorEventLoopDelay({ resolution: 20 });
h.enable();
// Do something.
h.disable();
console.log(h.min);
console.log(h.max);
console.log(h.mean);
console.log(h.stddev);
console.log(h.percentiles);
console.log(h.percentile(50));
console.log(h.percentile(99));

Classe : Histogram

Ajouté dans : v11.10.0

histogram.count

Ajouté dans : v17.4.0, v16.14.0

• <number>

Le nombre d'échantillons enregistrés par l'histogramme.

histogram.countBigInt

Ajouté dans : v17.4.0, v16.14.0

• <bigint>

Le nombre d'échantillons enregistrés par l'histogramme.

histogram.exceeds

Ajouté dans : v11.10.0

• <number>

Le nombre de fois où le délai de la boucle d'événements a dépassé le seuil maximal d'une heure.

histogram.exceedsBigInt

Ajouté dans : v17.4.0, v16.14.0

• <bigint>

Le nombre de fois où le délai de la boucle d'événements a dépassé le seuil maximal d'une heure.

histogram.max

Ajouté dans : v11.10.0

• <number>

Le délai maximal enregistré de la boucle d'événements.

histogram.maxBigInt

Ajouté dans : v17.4.0, v16.14.0

• <bigint>

Le délai maximal enregistré de la boucle d'événements.

histogram.mean

Ajouté dans : v11.10.0

• <number>

La moyenne des délais enregistrés de la boucle d'événements.

histogram.min

Ajouté dans : v11.10.0

• <number>

Le délai minimal enregistré de la boucle d'événements.

histogram.minBigInt

Ajouté dans : v17.4.0, v16.14.0

• <bigint>

Le délai minimal enregistré de la boucle d'événements.

histogram.percentile(percentile)

Ajouté dans : v11.10.0

• percentile <number> Une valeur de percentile dans la plage (0, 100].
• Returns : <number>

Retourne la valeur au percentile donné.

histogram.percentileBigInt(percentile)

Ajouté dans : v17.4.0, v16.14.0

• percentile <number> Une valeur de percentile dans la plage (0, 100].
• Returns : <bigint>

Retourne la valeur au percentile donné.

histogram.percentiles

Ajouté dans : v11.10.0

• <Map>

Retourne un objet Map détaillant la distribution percentile accumulée.

histogram.percentilesBigInt

Ajouté dans : v17.4.0, v16.14.0

• <Map>

Retourne un objet Map détaillant la distribution percentile accumulée.

histogram.reset()

Ajouté dans : v11.10.0

Réinitialise les données de l’histogramme collectées.

histogram.stddev

Ajouté dans : v11.10.0

• <number>

L’écart type des délais de la boucle d’événements enregistrés.

Class: IntervalHistogram extends Histogram

Un Histogram qui est mis à jour périodiquement à un intervalle donné.

histogram.disable()

Ajouté dans : v11.10.0

• Retourne : <boolean>

Désactive le temporisateur d’intervalle de mise à jour. Retourne true si le temporisateur a été arrêté, false s’il était déjà arrêté.

histogram.enable()

Ajouté dans : v11.10.0

• Retourne : <boolean>

Active le temporisateur d’intervalle de mise à jour. Retourne true si le temporisateur a été démarré, false s’il était déjà démarré.

Cloner un IntervalHistogram

Les instances <IntervalHistogram> peuvent être clonées via <MessagePort>. À l’extrémité de réception, l’histogramme est cloné en tant qu’objet <Histogram> brut qui n’implémente pas les méthodes enable() et disable().

Class: RecordableHistogram extends Histogram

Ajouté dans : v15.9.0, v14.18.0

histogram.add(other)

Ajouté dans : v17.4.0, v16.14.0

• other <RecordableHistogram>

Ajoute les valeurs de other à cet histogramme.

histogram.record(val)

Ajouté dans : v15.9.0, v14.18.0

• val <number> | <bigint> La valeur à enregistrer dans l'histogramme.

histogram.recordDelta()

Ajouté dans : v15.9.0, v14.18.0

Calcule la quantité de temps (en nanosecondes) qui s'est écoulée depuis l'appel précédent à recordDelta() et enregistre cette quantité dans l'histogramme.

Exemples

Mesurer la durée des opérations asynchrones

L'exemple suivant utilise les API Hooks Async et Performance pour mesurer la durée réelle d'une opération Timeout (y compris le temps nécessaire à l'exécution du callback).

ESM

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

CJS

'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'], buffered: true });

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

Mesurer le temps nécessaire pour charger les dépendances

L'exemple suivant mesure la durée des opérations require() pour charger les dépendances :

ESM

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

// Activer l'observateur
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');

CJS

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

// Monkey patch la fonction require
mod.Module.prototype.require =
  performance.timerify(mod.Module.prototype.require);
require = performance.timerify(require);

// Activer l'observateur
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'], buffered: true });

require('some-module');

Mesurer la durée d'un aller-retour HTTP

L'exemple suivant est utilisé pour suivre le temps passé par le client HTTP (OutgoingMessage) et la requête HTTP (IncomingMessage). Pour le client HTTP, cela signifie l'intervalle de temps entre le début de la requête et la réception de la réponse, et pour la requête HTTP, cela signifie l'intervalle de temps entre la réception de la requête et l'envoi de la réponse :

ESM

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

CJS

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

Mesurer le temps que prend net.connect (uniquement pour TCP) lorsque la connexion réussit

ESM

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

CJS

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

Mesurer le temps que prend le DNS lorsque la requête réussit

ESM

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

CJS

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