Node.js v25.0.0 ドキュメンテーション

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> utilization1 より前の eventLoopUtilization() 呼び出しの結果。
• 戻り値: <Object>
  • idle <number>
  • active <number>
  • utilization <number>

eventLoopUtilization() メソッドは、イベントループがアイドル状態であった時間とアクティブであった時間の累積期間を高分解能ミリ秒タイマーとして含むオブジェクトを返します。utilization の値は、計算されたイベントループ使用率 (ELU) です。

メインスレッドでブートストラップがまだ完了していない場合、プロパティの値は 0 になります。ELU は、ワーカースレッドではイベントループ内でブートストラップが行われるため、すぐに利用可能です。

utilization1 と utilization2 はどちらもオプションのパラメータです。

utilization1 が渡された場合、現在の呼び出しの active と idle の時間との差分、および対応する utilization の値が計算されて返されます (process.hrtime() と同様です)。

utilization1 と utilization2 の両方が渡された場合、2つの引数の間で差分が計算されます。これは便利なオプションです。なぜなら、process.hrtime() とは異なり、ELU の計算は単純な引き算よりも複雑だからです。

ELU は CPU 使用率に似ていますが、CPU 使用率ではなくイベントループの統計のみを測定します。これは、イベントループがイベントループのイベントプロバイダー (例: epoll_wait) の外で費やした時間の割合を表します。他の CPU アイドル時間は考慮されません。以下は、ほとんどアイドル状態のプロセスが高い ELU を持つ例です。

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

setImmediate(() => {
  const elu = eventLoopUtilization();
  spawnSync('sleep', ['5']);
  console.log(eventLoopUtilization(elu).utilization);
});'use strict';
const { eventLoopUtilization } = require('node:perf_hooks').performance;
const { spawnSync } = require('node:child_process');

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

このスクリプトを実行している間、CPU はほとんどアイドル状態ですが、utilization の値は 1 です。これは、child_process.spawnSync() の呼び出しがイベントループの進行をブロックするためです。

以前の eventLoopUtilization() 呼び出しの結果ではなく、ユーザー定義のオブジェクトを渡すと、未定義の動作につながります。戻り値は、イベントループの正しい状態を反映することを保証しません。

performance.getEntries()#

• 戻り値: <PerformanceEntry[]>

performanceEntry.startTime に関して時系列順に並んだ PerformanceEntry オブジェクトのリストを返します。特定のタイプまたは特定の名前のパフォーマンスエントリのみに関心がある場合は、performance.getEntriesByType() と performance.getEntriesByName() を参照してください。

performance.getEntriesByName(name[, type])#

• name <string>
• type <string>
• 戻り値: <PerformanceEntry[]>

performanceEntry.startTime に関して時系列順に並んだ PerformanceEntry オブジェクトのリストを返します。このリストには、performanceEntry.name が name と等しく、オプションで performanceEntry.entryType が type と等しいエントリが含まれます。

performance.getEntriesByType(type)#

• type <string>
• 戻り値: <PerformanceEntry[]>

performanceEntry.startTime に関して時系列順に並んだ PerformanceEntry オブジェクトのリストを返します。このリストには、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 による拡張です。Web ブラウザでは利用できません。

リソースタイムラインに新しい 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 による拡張です。Web ブラウザでは利用できません。

特定の Node.js の運用マイルストーンに関するパフォーマンスメトリクスを提供する PerformanceNodeTiming クラスのインスタンス。

performance.now()#

• 戻り値: <number>

現在の高分解能ミリ秒タイムスタンプを返します。0 は現在の node プロセスの開始を表します。

performance.setResourceTimingBufferSize(maxSize)#

グローバルなパフォーマンスリソースタイミングバッファのサイズを、指定された数の "resource" タイプのパフォーマンスエントリオブジェクトに設定します。

デフォルトでは、最大バッファサイズは 250 に設定されています。

performance.timeOrigin#

• 型: <number>

timeOrigin は、現在の node プロセスが開始した高分解能ミリ秒タイムスタンプを、Unix 時間で指定します。

performance.timerify(fn[, options])#

• fn <Function>
• options <Object>
  • histogram <RecordableHistogram> 実行時間をナノ秒単位で記録する、perf_hooks.createHistogram() を使用して作成されたヒストグラムオブジェクト。

このプロパティは Node.js による拡張です。Web ブラウザでは利用できません。

関数を、ラップされた関数の実行時間を測定する新しい関数でラップします。タイミングの詳細にアクセスするためには、PerformanceObserver が 'function' イベントタイプにサブスクライブされている必要があります。

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

function someFunction() {
  console.log('hello world');
}

const wrapped = performance.timerify(someFunction);

const obs = new PerformanceObserver((list) => {
  console.log(list.getEntries()[0].duration);

  performance.clearMarks();
  performance.clearMeasures();
  obs.disconnect();
});
obs.observe({ entryTypes: ['function'] });

// A performance timeline entry will be created
wrapped();const {
  performance,
  PerformanceObserver,
} = require('node:perf_hooks');

function someFunction() {
  console.log('hello world');
}

const wrapped = performance.timerify(someFunction);

const obs = new PerformanceObserver((list) => {
  console.log(list.getEntries()[0].duration);

  performance.clearMarks();
  performance.clearMeasures();
  obs.disconnect();
});
obs.observe({ entryTypes: ['function'] });

// A performance timeline entry will be created
wrapped();copy

ラップされた関数がプロミスを返す場合、プロミスに finally ハンドラがアタッチされ、finally ハンドラが呼び出されたときに実行時間が報告されます。

performance.toJSON()#

performance オブジェクトの JSON 表現であるオブジェクトです。ブラウザの window.performance.toJSON に似ています。

performanceEntry.duration#

• 型: <number>

このエントリに対して経過した合計ミリ秒数。この値は、すべての Performance Entry タイプで意味があるわけではありません。

performanceEntry.entryType#

• 型: <string>

パフォーマンスエントリのタイプ。以下のいずれかです。

• 'dns' (Node.js のみ)
• 'function' (Node.js のみ)
• 'gc' (Node.js のみ)
• 'http2' (Node.js のみ)
• 'http' (Node.js のみ)
• 'mark' (Web で利用可能)
• 'measure' (Web で利用可能)
• 'net' (Node.js のみ)
• 'node' (Node.js のみ)
• 'resource' (Web で利用可能)

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 プロパティは2つのプロパティを持つ <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 プロパティは method、url、headers を含む <Object> であり、res プロパティは statusCode、statusMessage、headers を含む <Object> です。

performanceEntry.name が HttpRequest の場合、detail には req と res のプロパティが含まれます。req プロパティは method、url、headers を含む <Object> であり、res プロパティは statusCode、statusMessage、headers を含む <Object> です。

これにより追加のメモリオーバーヘッドが発生する可能性があるため、診断目的でのみ使用し、本番環境でデフォルトで有効にしないでください。

HTTP/2 ('http2') の詳細#

performanceEntry.type が 'http2' の場合、performanceNodeEntry.detail プロパティは追加のパフォーマンス情報を含む <Object> になります。

performanceEntry.name が Http2Stream の場合、detail には以下のプロパティが含まれます。

• bytesRead <number> この Http2Stream で受信した DATA フレームのバイト数。
• bytesWritten <number> この Http2Stream で送信した DATA フレームのバイト数。
• 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> Http2Session によって受信された HTTP/2 フレームの数。
• framesSent <number> Http2Session によって送信された HTTP/2 フレームの数。
• maxConcurrentStreams <number> Http2Session の存続期間中に同時に開かれていたストリームの最大数。
• pingRTT <number> PING フレームの送信とその確認応答の受信との間に経過したミリ秒数。Http2Session で PING フレームが送信された場合にのみ存在します。
• streamAverageDuration <number> すべての Http2Stream インスタンスの平均期間 (ミリ秒単位)。
• streamCount <number> Http2Session によって処理された Http2Stream インスタンスの数。
• 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) 内でアイドル状態であった時間の高分解能ミリ秒タイムスタンプ。これは CPU 使用率を考慮しません。イベントループがまだ開始していない場合 (例: メインスクリプトの最初のティック)、プロパティの値は 0 です。

performanceNodeTiming.loopExit#

• 型: <number>

Node.js イベントループが終了した高分解能ミリ秒タイムスタンプ。イベントループがまだ終了していない場合、プロパティの値は -1 です。'exit' イベントのハンドラ内でのみ -1 以外の値を持つことができます。

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

performanceNodeTiming.v8Start#

• 型: <number>

V8 プラットフォームが初期化された高分解能ミリ秒タイムスタンプ。

performanceResourceTiming.workerStart#

• 型: <number>

fetch リクエストをディスパッチする直前の高分解能ミリ秒タイムスタンプ。リソースがワーカーによってインターセプトされない場合、このプロパティは常に 0 を返します。

performanceResourceTiming.redirectStart#

• 型: <number>

リダイレクトを開始する fetch の開始時刻を表す高分解能ミリ秒タイムスタンプ。

performanceResourceTiming.redirectEnd#

• 型: <number>

最後のリダイレクトのレスポンスの最後のバイトを受信した直後に作成される高分解能ミリ秒タイムスタンプ。

performanceResourceTiming.fetchStart#

• 型: <number>

Node.js がリソースのフェッチを開始する直前の高分解能ミリ秒タイムスタンプ。

performanceResourceTiming.domainLookupStart#

• 型: <number>

Node.js がリソースのドメイン名検索を開始する直前の高分解能ミリ秒タイムスタンプ。

performanceResourceTiming.domainLookupEnd#

• 型: <number>

Node.js がリソースのドメイン名検索を完了した直後の時刻を表す高分解能ミリ秒タイムスタンプ。

performanceResourceTiming.connectStart#

• 型: <number>

Node.js がリソースを取得するためにサーバーへの接続を確立し始める直前の時刻を表す高分解能ミリ秒タイムスタンプ。

performanceResourceTiming.connectEnd#

• 型: <number>

Node.js がリソースを取得するためにサーバーへの接続を確立し終えた直後の時刻を表す高分解能ミリ秒タイムスタンプ。

performanceResourceTiming.secureConnectionStart#

• 型: <number>

Node.js が現在の接続を保護するためにハンドシェイクプロセスを開始する直前の時刻を表す高分解能ミリ秒タイムスタンプ。

performanceResourceTiming.requestStart#

• 型: <number>

Node.js がサーバーからレスポンスの最初のバイトを受信する直前の時刻を表す高分解能ミリ秒タイムスタンプ。

performanceResourceTiming.responseEnd#

• 型: <number>

Node.js がリソースの最後のバイトを受信した直後、またはトランスポート接続が閉じる直前の、いずれか早い方の時刻を表す高分解能ミリ秒タイムスタンプ。

performanceResourceTiming.transferSize#

• 型: <number>

フェッチされたリソースのサイズ (オクテット単位) を表す数値。サイズには、レスポンスヘッダーフィールドとレスポンスペイロードボディが含まれます。

performanceResourceTiming.encodedBodySize#

• 型: <number>

フェッチ (HTTP またはキャッシュ) から受信したペイロードボディのサイズ (オクテット単位) を表す数値。適用されたコンテンツエンコーディングを削除する前の値です。

performanceResourceTiming.decodedBodySize#

• 型: <number>

フェッチ (HTTP またはキャッシュ) から受信したメッセージボディのサイズ (オクテット単位) を表す数値。適用されたコンテンツエンコーディングを削除した後の値です。

performanceResourceTiming.toJSON()#

PerformanceResourceTiming オブジェクトの JSON 表現である object を返します。

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

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> インスタンスを、options.entryTypes または options.type のいずれかで識別される新しい <PerformanceEntry> インスタンスの通知にサブスクライブします。

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

performanceObserver.takeRecords()#

• 戻り値: <PerformanceEntry[]> パフォーマンスオブザーバーに保存されている現在のエントリのリスト。リストは空になります。

performanceObserverEntryList.getEntries()#

• 戻り値: <PerformanceEntry[]>

performanceEntry.startTime に関して時系列順に並んだ PerformanceEntry オブジェクトのリストを返します。

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

performanceObserverEntryList.getEntriesByName(name[, type])#

• name <string>
• type <string>
• 戻り値: <PerformanceEntry[]>

performanceEntry.startTime に関して時系列順に並んだ PerformanceEntry オブジェクトのリストを返します。このリストには、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');copy

performanceObserverEntryList.getEntriesByType(type)#

• type <string>
• 戻り値: <PerformanceEntry[]>

performanceEntry.startTime に関して時系列順に並んだ PerformanceEntry オブジェクトのリストを返します。このリストには、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');copy

histogram.count#

• 型: <number>

ヒストグラムによって記録されたサンプル数。

histogram.countBigInt#

• 型: <bigint>

ヒストグラムによって記録されたサンプル数。

histogram.exceeds#

• 型: <number>

イベントループの遅延が最大1時間のイベントループ遅延しきい値を超えた回数。

histogram.exceedsBigInt#

• 型: <bigint>

イベントループの遅延が最大1時間のイベントループ遅延しきい値を超えた回数。

histogram.max#

• 型: <number>

記録された最大のイベントループ遅延。

histogram.maxBigInt#

• 型: <bigint>

記録された最大のイベントループ遅延。

histogram.mean#

• 型: <number>

記録されたイベントループ遅延の平均値。

histogram.min#

• 型: <number>

記録された最小のイベントループ遅延。

histogram.minBigInt#

• 型: <bigint>

記録された最小のイベントループ遅延。

histogram.percentile(percentile)#

• percentile <number> (0, 100] の範囲のパーセンタイル値。
• 戻り値: <number>

指定されたパーセンタイルの値を返します。

histogram.percentileBigInt(percentile)#

• percentile <number> (0, 100] の範囲のパーセンタイル値。
• 戻り値: <bigint>

指定されたパーセンタイルの値を返します。

histogram.percentiles#

• 型: <Map>

累積されたパーセンタイル分布を詳述する Map オブジェクトを返します。

histogram.percentilesBigInt#

• 型: <Map>

累積されたパーセンタイル分布を詳述する Map オブジェクトを返します。

histogram.reset()#

収集されたヒストグラムデータをリセットします。

histogram.stddev#

• 型: <number>

記録されたイベントループ遅延の標準偏差。

histogram.disable()#

• 戻り値: <boolean>

更新間隔タイマーを無効にします。タイマーが停止した場合は true を、すでに停止していた場合は false を返します。

histogram.enable()#

• 戻り値: <boolean>

更新間隔タイマーを有効にします。タイマーが開始された場合は true を、すでに開始されていた場合は false を返します。

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> を介してクローン作成できます。受信側では、ヒストグラムは enable() と disable() メソッドを実装しないプレーンな <Histogram> オブジェクトとしてクローンされます。

histogram.add(other)#

• other <RecordableHistogram>

other からの値をこのヒストグラムに追加します。

histogram.record(val)#

• val <number> | <bigint> ヒストグラムに記録する量。

histogram.recordDelta()#

前回の recordDelta() の呼び出しから経過した時間 (ナノ秒単位) を計算し、その量をヒストグラムに記録します。

非同期操作の実行時間を測定する#

以下の例では、Async Hooks と Performance API を使用して、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);copy

依存関係のロードにかかる時間を測定する#

以下の例では、依存関係をロードするための 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');copy

HTTP のラウンドトリップに1回かかる時間を測定する#

以下の例は、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}`);
});copy

接続が成功した場合に 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);
});copy

リクエストが成功した場合に 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');copy