Node.js v21.7.2 ドキュメント

perf_hooks.performance#

現在のNode.jsインスタンスからパフォーマンスメトリックを収集するために使用できるオブジェクトです。ブラウザのwindow.performance と似ています。

performance.clearMarks([name])#

• name <文字列>

nameが指定されていない場合、パフォーマンスタイムラインからすべてのPerformanceMarkオブジェクトを削除します。nameが指定されている場合、名前付きのマークのみを削除します。

performance.clearMeasures([name])#

• name <文字列>

nameが指定されていない場合、パフォーマンスタイムラインからすべてのPerformanceMeasureオブジェクトを削除します。nameが指定されている場合、名前付きの測定値のみを削除します。

performance.clearResourceTimings([name])#

• name <文字列>

nameが指定されていない場合、リソースタイムラインからすべてのPerformanceResourceTimingオブジェクトを削除します。nameが指定されている場合、名前付きのリソースのみを削除します。

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

• utilization1 <オブジェクト> 以前の`eventLoopUtilization()`呼び出しの結果。
• utilization2 <オブジェクト> utilization1より前の`eventLoopUtilization()`呼び出しの結果。
• 戻り値: <オブジェクト>
  • idle <数値>
  • active <数値>
  • utilization <数値>

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が高くなる例を以下に示します。

'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 <文字列>
• type <string>
• 返り値: <PerformanceEntry[]>

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

performance.getEntriesByType(type)#

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

performanceEntry.entryTypeがtypeと等しいPerformanceEntryオブジェクトのリストを、performanceEntry.startTimeに関して時系列順に返します。

performance.mark(name[, options])#

• name <文字列>
• 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)#

• timingInfo <Object> Fetch Timing Info
• requestedUrl <string> リソースURL
• initiatorType <string> イニシエータ名（例: 'fetch')
• global <Object>
• cacheMode <string> キャッシュモードは空文字列('')または'local'でなければなりません。

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

リソースタイムラインに新しいPerformanceResourceTimingエントリを作成します。PerformanceResourceTimingはPerformanceEntryのサブクラスであり、そのperformanceEntry.entryTypeは常に'resource'です。パフォーマンスリソースは、リソースタイムラインにおける瞬間をマークするために使用されます。

作成されたPerformanceMarkエントリはグローバルリソースタイムラインに配置され、performance.getEntries、performance.getEntriesByName、performance.getEntriesByTypeを使用してクエリできます。観測が実行されたら、performance.clearResourceTimingsを使用してグローバルパフォーマンスタイムラインからエントリを手動でクリアする必要があります。

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

• name <文字列>
• 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」タイプのperformanceエントリオブジェクトに設定します。

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

performance.timeOrigin#

• <number>

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

performance.timerify(fn[, options])#

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

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

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

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

ラップされた関数がPromiseを返す場合、finallyハンドラがPromiseに添付され、finallyハンドラが呼び出されると期間が報告されます。

performance.toJSON()#

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

イベント: 'resourcetimingbufferfull'#

グローバルパフォーマンスリソースタイミングバッファがいっぱいになると、'resourcetimingbufferfull'イベントが発生します。イベントリスナーでperformance.setResourceTimingBufferSize()を使用してリソースタイミングバッファサイズを調整するか、performance.clearResourceTimings()を使用してバッファをクリアして、パフォーマンスタイムラインバッファにさらにエントリを追加できるようにします。

クラス: PerformanceEntry#

このクラスのコンストラクタは、ユーザーには直接公開されていません。

performanceEntry.duration#

• <number>

このエントリ経過した総ミリ秒数。この値は、すべてのパフォーマンスエントリタイプで意味のある値とは限りません。

performanceEntry.entryType#

• <string>

パフォーマンスエントリのタイプ。次のいずれかになります。

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

performanceEntry.name#

• <string>

パフォーマンスエントリの名称。

performanceEntry.startTime#

• <number>

パフォーマンスエントリの開始時刻を示す、高解像度のミリ秒単位のタイムスタンプ。

クラス: PerformanceMark#

• 継承元: <PerformanceEntry>

Performance.mark()メソッドで作成されたマークを公開します。

performanceMark.detail#

• <any>

Performance.mark()メソッドで作成時に指定された追加の詳細情報。

クラス: PerformanceMeasure#

• 継承元: <PerformanceEntry>

Performance.measure()メソッドで作成された測定値を公開します。

このクラスのコンストラクタは、ユーザーには直接公開されていません。

performanceMeasure.detail#

• <any>

Performance.measure()メソッドで作成時に指定された追加の詳細情報。

クラス: PerformanceNodeEntry#

• 継承元: <PerformanceEntry>

このクラスはNode.jsによる拡張です。Webブラウザでは使用できません。

Node.jsのタイミングに関する詳細なデータを提供します。

このクラスのコンストラクタは、ユーザーには直接公開されていません。

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フレームの送信と確認応答の受信との間の経過ミリ秒数。PINGフレームがHttp2Sessionで送信された場合にのみ存在します。
• 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#

• 継承元: <PerformanceEntry>

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

Node.js自体のタイミングの詳細を提供します。このクラスのコンストラクタはユーザーには公開されていません。

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

• <number>

V8 プラットフォームが初期化された時点の高解像度ミリ秒単位のタイムスタンプです。

クラス: PerformanceResourceTiming#

• 継承元: <PerformanceEntry>

アプリケーションのリソースの読み込みに関する詳細なネットワークタイミングデータを提供します。

このクラスのコンストラクタは、ユーザーには直接公開されていません。

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

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

クラス: PerformanceObserver#

PerformanceObserver.supportedEntryTypes#

• <string[]>

サポートされているタイプを取得します。

new PerformanceObserver(callback)#

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

PerformanceObserverオブジェクトは、新しいPerformanceEntryインスタンスがパフォーマンスタイムラインに追加されたときに通知を提供します。

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インスタンスは独自の追加のパフォーマンスオーバーヘッドを導入するため、インスタンスを無期限に通知に購読したままにしておくべきではありません。ユーザーは、必要なくなった時点でオブザーバーの接続を解除する必要があります。

新しいPerformanceEntryインスタンスについてPerformanceObserverが通知されると、callbackが呼び出されます。コールバックは、PerformanceObserverEntryListインスタンスとPerformanceObserverへの参照を受け取ります。

performanceObserver.disconnect()#

PerformanceObserverインスタンスをすべての通知から切断します。

performanceObserver.observe(options)#

• options <Object>
  • type <string> 単一の<PerformanceEntry>タイプ。entryTypesが既に指定されている場合は指定しないでください。
  • entryTypes <string[]>オブザーバーが関心のある<PerformanceEntry>インスタンスのタイプを識別する文字列の配列です。指定されていない場合、エラーがスローされます。
  • buffered <boolean> trueの場合、オブザーバーコールバックはグローバルなPerformanceEntryのバッファリングされたエントリのリストで呼び出されます。falseの場合、時点以降に作成されたPerformanceEntryのみがオブザーバーコールバックに送信されます。**デフォルト:** false。

options.entryTypesまたはoptions.typeによって識別される新しい<PerformanceEntry>インスタンスの通知に<PerformanceObserver>インスタンスをサブスクライブします。

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

クラス: PerformanceObserverEntryList#

PerformanceObserverEntryListクラスは、PerformanceObserverに渡されたPerformanceEntryインスタンスへのアクセスを提供するために使用されます。このクラスのコンストラクターはユーザーには公開されていません。

performanceObserverEntryList.getEntries()#

• 返り値: <PerformanceEntry[]>

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

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 <文字列>
• type <string>
• 返り値: <PerformanceEntry[]>

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

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.entryTypeがtypeと等しいPerformanceEntryオブジェクトのリストを、performanceEntry.startTimeに関して時系列順に返します。

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

perf_hooks.createHistogram([options])#

• options <Object>
  • lowest <number> | <bigint> 最小識別可能値。0より大きい整数値である必要があります。デフォルト: 1。
  • highest <number> | <bigint> 最高記録可能値。lowestの2倍以上である整数値である必要があります。デフォルト: Number.MAX_SAFE_INTEGER。
  • figures <number> 精度桁数。1から5の間の数値である必要があります。デフォルト: 3。
• 戻り値: <RecordableHistogram>

<RecordableHistogram>を返します。

perf_hooks.monitorEventLoopDelay([options])#

• options <Object>
  • resolution <number> サンプリングレート（ミリ秒単位）。0より大きい値である必要があります。デフォルト: 10。
• 戻り値: <IntervalHistogram>

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

時間経過に伴うイベントループの遅延をサンプリングして報告するIntervalHistogramオブジェクトを作成します。遅延はナノ秒単位で報告されます。

タイマーを使用してイベントループの遅延を概算で検出できるのは、タイマーの実行がlibuvイベントループのライフサイクルに特化して結びついているためです。つまり、ループの遅延はタイマーの実行の遅延を引き起こし、これらの遅延は、このAPIが検出することを意図したものです。

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

クラス: Histogram#

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>

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

クラス: IntervalHistogram extends Histogram#

指定された間隔で定期的に更新されるHistogram。

histogram.disable()#

• 戻り値: <boolean>

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

histogram.enable()#

• 戻り値: <boolean>

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

IntervalHistogramの複製#

<IntervalHistogram>インスタンスは<MessagePort>を介して複製できます。受信側では、ヒストグラムはenable()メソッドとdisable()メソッドを実装しないプレーンな<Histogram>オブジェクトとして複製されます。

クラス: RecordableHistogram extends Histogram#

histogram.add(other)#

• other <RecordableHistogram>

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

histogram.record(val)#

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

histogram.recordDelta()#

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

例#

非同期操作の持続時間の測定#

次の例では、非同期フックとパフォーマンスAPIを使用して、タイムアウト操作の実際の持続時間（コールバックの実行にかかった時間を含む）を測定します。

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

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

次の例では、依存関係をロードするためのrequire()操作の持続時間を測定します。

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

require('some-module'); copy

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

次の例は、HTTPクライアント（OutgoingMessage）とHTTPリクエスト（IncomingMessage）によって費やされた時間を追跡するために使用されます。HTTPクライアントの場合、リクエストの開始とレスポンスの受信の間の時間間隔を意味し、HTTPリクエストの場合、リクエストの受信とレスポンスの送信の間の時間間隔を意味します。

'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のみ）にかかる時間の測定#

'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にかかる時間の測定#

'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