22

✏️ Editing: perf_hooks.json

{
 "type": "module",
 "source": "doc/api/perf_hooks.md",
 "modules": [
 {
 "textRaw": "Performance measurement APIs",
 "name": "performance_measurement_apis",
 "introduced_in": "v8.5.0",
 "stability": 2,
 "stabilityText": "Stable",
 "desc": "Source Code: <a href=\"https://github.com/nodejs/node/blob/v12.22.12/lib/perf_hooks.js\">lib/perf_hooks.js</a>\nThis module provides an implementation of a subset of the W3C\n<a href=\"https://w3c.github.io/perf-timing-primer/\">Web Performance APIs</a> as well as additional APIs for\nNode.js-specific performance measurements.\nNode.js supports the following <a href=\"https://w3c.github.io/perf-timing-primer/\">Web Performance APIs</a>:\n<ul>\n<li><a href=\"https://www.w3.org/TR/hr-time-2\">High Resolution Time</a></li>\n<li><a href=\"https://w3c.github.io/performance-timeline/\">Performance Timeline</a></li>\n<li><a href=\"https://www.w3.org/TR/user-timing/\">User Timing</a></li>\n</ul>\n<pre><code class=\"language-js\">const { PerformanceObserver, performance } = require('perf_hooks');\n\nconst obs = new PerformanceObserver((items) => {\n console.log(items.getEntries()[0].duration);\n performance.clearMarks();\n});\nobs.observe({ entryTypes: ['measure'] });\nperformance.measure('Start to Now');\n\nperformance.mark('A');\ndoSomeLongRunningProcess(() => {\n performance.measure('A to Now', 'A');\n\n performance.mark('B');\n performance.measure('A to B', 'A', 'B');\n});\n</code></pre>",
 "properties": [
 {
 "textRaw": "`perf_hooks.performance`",
 "name": "performance",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "An object that can be used to collect performance metrics from the current\nNode.js instance. It is similar to <a href=\"https://developer.mozilla.org/en-US/docs/Web/API/Window/performance\"><code>window.performance</code></a> in browsers.",
 "methods": [
 {
 "textRaw": "`performance.clearMarks([name])`",
 "type": "method",
 "name": "clearMarks",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`name` {string}",
 "name": "name",
 "type": "string"
 }
 ]
 }
 ],
 "desc": "If <code>name</code> is not provided, removes all <code>PerformanceMark</code> objects from the\nPerformance Timeline. If <code>name</code> is provided, removes only the named mark."
 },
 {
 "textRaw": "`performance.eventLoopUtilization([utilization1[, utilization2]])`",
 "type": "method",
 "name": "eventLoopUtilization",
 "meta": {
 "added": [
 "v14.10.0",
 "v12.19.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "return": {
 "textRaw": "Returns {Object}",
 "name": "return",
 "type": "Object",
 "options": [
 {
 "textRaw": "`idle` {number}",
 "name": "idle",
 "type": "number"
 },
 {
 "textRaw": "`active` {number}",
 "name": "active",
 "type": "number"
 },
 {
 "textRaw": "`utilization` {number}",
 "name": "utilization",
 "type": "number"
 }
 ]
 },
 "params": [
 {
 "textRaw": "`utilization1` {Object} The result of a previous call to `eventLoopUtilization()`.",
 "name": "utilization1",
 "type": "Object",
 "desc": "The result of a previous call to `eventLoopUtilization()`."
 },
 {
 "textRaw": "`utilization2` {Object} The result of a previous call to `eventLoopUtilization()` prior to `utilization1`.",
 "name": "utilization2",
 "type": "Object",
 "desc": "The result of a previous call to `eventLoopUtilization()` prior to `utilization1`."
 }
 ]
 }
 ],
 "desc": "The <code>eventLoopUtilization()</code> method returns an object that contains the\ncumulative duration of time the event loop has been both idle and active as a\nhigh resolution milliseconds timer. The <code>utilization</code> value is the calculated\nEvent Loop Utilization (ELU).\nIf bootstrapping has not yet finished on the main thread the properties have\nthe value of <code>0</code>. The ELU is immediately available on <a href=\"worker_threads.md#worker_threads_worker_threads\">Worker threads</a> since\nbootstrap happens within the event loop.\nBoth <code>utilization1</code> and <code>utilization2</code> are optional parameters.\nIf <code>utilization1</code> is passed, then the delta between the current call's <code>active</code>\nand <code>idle</code> times, as well as the corresponding <code>utilization</code> value are\ncalculated and returned (similar to <a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a>).\nIf <code>utilization1</code> and <code>utilization2</code> are both passed, then the delta is\ncalculated between the two arguments. This is a convenience option because,\nunlike <a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a>, calculating the ELU is more complex than a\nsingle subtraction.\nELU is similar to CPU utilization, except that it only measures event loop\nstatistics and not CPU usage. It represents the percentage of time the event\nloop has spent outside the event loop's event provider (e.g. <code>epoll_wait</code>).\nNo other CPU idle time is taken into consideration. The following is an example\nof how a mostly idle process will have a high ELU.\n<pre><code class=\"language-js\">'use strict';\nconst { eventLoopUtilization } = require('perf_hooks').performance;\nconst { spawnSync } = require('child_process');\n\nsetImmediate(() => {\n const elu = eventLoopUtilization();\n spawnSync('sleep', ['5']);\n console.log(eventLoopUtilization(elu).utilization);\n});\n</code></pre>\nAlthough the CPU is mostly idle while running this script, the value of\n<code>utilization</code> is <code>1</code>. This is because the call to\n<a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a> blocks the event loop from proceeding.\nPassing in a user-defined object instead of the result of a previous call to\n<code>eventLoopUtilization()</code> will lead to undefined behavior. The return values\nare not guaranteed to reflect any correct state of the event loop."
 },
 {
 "textRaw": "`performance.mark([name])`",
 "type": "method",
 "name": "mark",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`name` {string}",
 "name": "name",
 "type": "string"
 }
 ]
 }
 ],
 "desc": "Creates a new <code>PerformanceMark</code> entry in the Performance Timeline. A\n<code>PerformanceMark</code> is a subclass of <code>PerformanceEntry</code> whose\n<code>performanceEntry.entryType</code> is always <code>'mark'</code>, and whose\n<code>performanceEntry.duration</code> is always <code>0</code>. Performance marks are used\nto mark specific significant moments in the Performance Timeline."
 },
 {
 "textRaw": "`performance.measure(name[, startMark[, endMark]])`",
 "type": "method",
 "name": "measure",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": [
 {
 "version": "v12.16.3",
 "pr-url": "https://github.com/nodejs/node/pull/32651",
 "description": "Make `startMark` and `endMark` parameters optional."
 }
 ]
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`name` {string}",
 "name": "name",
 "type": "string"
 },
 {
 "textRaw": "`startMark` {string} Optional.",
 "name": "startMark",
 "type": "string",
 "desc": "Optional."
 },
 {
 "textRaw": "`endMark` {string} Optional.",
 "name": "endMark",
 "type": "string",
 "desc": "Optional."
 }
 ]
 }
 ],
 "desc": "Creates a new <code>PerformanceMeasure</code> entry in the Performance Timeline. A\n<code>PerformanceMeasure</code> is a subclass of <code>PerformanceEntry</code> whose\n<code>performanceEntry.entryType</code> is always <code>'measure'</code>, and whose\n<code>performanceEntry.duration</code> measures the number of milliseconds elapsed since\n<code>startMark</code> and <code>endMark</code>.\nThe <code>startMark</code> argument may identify any existing <code>PerformanceMark</code> in the\nPerformance Timeline, or may identify any of the timestamp properties\nprovided by the <code>PerformanceNodeTiming</code> class. If the named <code>startMark</code> does\nnot exist, then <code>startMark</code> is set to <a href=\"https://w3c.github.io/hr-time/#dom-performance-timeorigin\"><code>timeOrigin</code></a> by default.\nThe optional <code>endMark</code> argument must identify any existing <code>PerformanceMark</code>\nin the Performance Timeline or any of the timestamp properties provided by the\n<code>PerformanceNodeTiming</code> class. <code>endMark</code> will be <code>performance.now()</code>\nif no parameter is passed, otherwise if the named <code>endMark</code> does not exist, an\nerror will be thrown."
 },
 {
 "textRaw": "`performance.now()`",
 "type": "method",
 "name": "now",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "return": {
 "textRaw": "Returns: {number}",
 "name": "return",
 "type": "number"
 },
 "params": []
 }
 ],
 "desc": "Returns the current high resolution millisecond timestamp, where 0 represents\nthe start of the current <code>node</code> process."
 },
 {
 "textRaw": "`performance.timerify(fn)`",
 "type": "method",
 "name": "timerify",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`fn` {Function}",
 "name": "fn",
 "type": "Function"
 }
 ]
 }
 ],
 "desc": "This property is an extension by Node.js. It is not available in Web browsers.\nWraps a function within a new function that measures the running time of the\nwrapped function. A <code>PerformanceObserver</code> must be subscribed to the <code>'function'</code>\nevent type in order for the timing details to be accessed.\n<pre><code class=\"language-js\">const {\n performance,\n PerformanceObserver\n} = require('perf_hooks');\n\nfunction someFunction() {\n console.log('hello world');\n}\n\nconst wrapped = performance.timerify(someFunction);\n\nconst obs = new PerformanceObserver((list) => {\n console.log(list.getEntries()[0].duration);\n obs.disconnect();\n});\nobs.observe({ entryTypes: ['function'] });\n\n// A performance timeline entry will be created\nwrapped();\n</code></pre>"
 },
 {
 "textRaw": "`performance.eventLoopUtilization([util1][,util2])`",
 "type": "method",
 "name": "eventLoopUtilization",
 "meta": {
 "added": [
 "v12.19.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "return": {
 "textRaw": "Returns {Object}",
 "name": "return",
 "type": "Object",
 "options": [
 {
 "textRaw": "`idle` {number}",
 "name": "idle",
 "type": "number"
 },
 {
 "textRaw": "`active` {number}",
 "name": "active",
 "type": "number"
 },
 {
 "textRaw": "`utilization` {number}",
 "name": "utilization",
 "type": "number"
 }
 ]
 },
 "params": [
 {
 "textRaw": "`util1` {Object} The result of a previous call to `eventLoopUtilization()`",
 "name": "util1",
 "type": "Object",
 "desc": "The result of a previous call to `eventLoopUtilization()`"
 },
 {
 "textRaw": "`util2` {Object} The result of a previous call to `eventLoopUtilization()` prior to `util1`",
 "name": "util2",
 "type": "Object",
 "desc": "The result of a previous call to `eventLoopUtilization()` prior to `util1`"
 }
 ]
 }
 ],
 "desc": "The <code>eventLoopUtilization()</code> method returns an object that contains the\ncumulative duration of time the event loop has been both idle and active as a\nhigh resolution milliseconds timer. The <code>utilization</code> value is the calculated\nEvent Loop Utilization (ELU). If bootstrapping has not yet finished, the\nproperties have the value of 0.\n<code>util1</code> and <code>util2</code> are optional parameters.\nIf <code>util1</code> is passed then the delta between the current call's <code>active</code> and\n<code>idle</code> times are calculated and returned (similar to <a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a>).\nLikewise the adjusted <code>utilization</code> value is calculated.\nIf <code>util1</code> and <code>util2</code> are both passed then the calculation adjustments are\ndone between the two arguments. This is a convenience option because unlike\n<a href=\"process.html#process_process_hrtime_time\"><code>process.hrtime()</code></a> additional work is done to calculate the ELU.\nELU is similar to CPU utilization except that it is calculated using high\nprecision wall-clock time. It represents the percentage of time the event loop\nhas spent outside the event loop's event provider (e.g. <code>epoll_wait</code>). No other\nCPU idle time is taken into consideration. The following is an example of how\na mostly idle process will have a high ELU.\n\n<pre><code class=\"language-js\">'use strict';\nconst { eventLoopUtilization } = require('perf_hooks').performance;\nconst { spawnSync } = require('child_process');\n\nsetImmediate(() => {\n const elu = eventLoopUtilization();\n spawnSync('sleep', ['5']);\n console.log(eventLoopUtilization(elu).utilization);\n});\n</code></pre>\nAlthough the CPU is mostly idle while running this script, the value of\n<code>utilization</code> is 1. This is because the call to <a href=\"child_process.html#child_process_child_process_spawnsync_command_args_options\"><code>child_process.spawnSync()</code></a>\nblocks the event loop from proceeding.\nPassing in a user-defined object instead of the result of a previous call to\n<code>eventLoopUtilization()</code> will lead to undefined behavior. The return values\nare not guaranteed to reflect any correct state of the event loop."
 }
 ],
 "properties": [
 {
 "textRaw": "`nodeTiming` {PerformanceNodeTiming}",
 "type": "PerformanceNodeTiming",
 "name": "nodeTiming",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "This property is an extension by Node.js. It is not available in Web browsers.\nAn instance of the <code>PerformanceNodeTiming</code> class that provides performance\nmetrics for specific Node.js operational milestones."
 },
 {
 "textRaw": "`timeOrigin` {number}",
 "type": "number",
 "name": "timeOrigin",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "The <a href=\"https://w3c.github.io/hr-time/#dom-performance-timeorigin\"><code>timeOrigin</code></a> specifies the high resolution millisecond timestamp at\nwhich the current <code>node</code> process began, measured in Unix time."
 }
 ]
 }
 ],
 "classes": [
 {
 "textRaw": "Class: `PerformanceEntry`",
 "type": "class",
 "name": "PerformanceEntry",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "properties": [
 {
 "textRaw": "`duration` {number}",
 "type": "number",
 "name": "duration",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "The total number of milliseconds elapsed for this entry. This value will not\nbe meaningful for all Performance Entry types."
 },
 {
 "textRaw": "`name` {string}",
 "type": "string",
 "name": "name",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "The name of the performance entry."
 },
 {
 "textRaw": "`startTime` {number}",
 "type": "number",
 "name": "startTime",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "The high resolution millisecond timestamp marking the starting time of the\nPerformance Entry."
 },
 {
 "textRaw": "`entryType` {string}",
 "type": "string",
 "name": "entryType",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "The type of the performance entry. It may be one of:\n<ul>\n<li><code>'node'</code> (Node.js only)</li>\n<li><code>'mark'</code> (available on the Web)</li>\n<li><code>'measure'</code> (available on the Web)</li>\n<li><code>'gc'</code> (Node.js only)</li>\n<li><code>'function'</code> (Node.js only)</li>\n<li><code>'http2'</code> (Node.js only)</li>\n<li><code>'http'</code> (Node.js only)</li>\n</ul>"
 },
 {
 "textRaw": "`kind` {number}",
 "type": "number",
 "name": "kind",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "This property is an extension by Node.js. It is not available in Web browsers.\nWhen <code>performanceEntry.entryType</code> is equal to <code>'gc'</code>, the <code>performance.kind</code>\nproperty identifies the type of garbage collection operation that occurred.\nThe value may be one of:\n<ul>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_MAJOR</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_MINOR</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_INCREMENTAL</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_WEAKCB</code></li>\n</ul>"
 },
 {
 "textRaw": "`flags` {number}",
 "type": "number",
 "name": "flags",
 "meta": {
 "added": [
 "v12.17.0"
 ],
 "changes": []
 },
 "desc": "This property is an extension by Node.js. It is not available in Web browsers.\nWhen <code>performanceEntry.entryType</code> is equal to <code>'gc'</code>, the <code>performance.flags</code>\nproperty contains additional information about garbage collection operation.\nThe value may be one of:\n<ul>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_NO</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_FORCED</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY</code></li>\n<li><code>perf_hooks.constants.NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE</code></li>\n</ul>"
 }
 ]
 },
 {
 "textRaw": "Class: `PerformanceNodeTiming extends PerformanceEntry`",
 "type": "class",
 "name": "PerformanceNodeTiming",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "This property is an extension by Node.js. It is not available in Web browsers.\nProvides timing details for Node.js itself. The constructor of this class\nis not exposed to users.",
 "properties": [
 {
 "textRaw": "`bootstrapComplete` {number}",
 "type": "number",
 "name": "bootstrapComplete",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "The high resolution millisecond timestamp at which the Node.js process\ncompleted bootstrapping. If bootstrapping has not yet finished, the property\nhas the value of -1."
 },
 {
 "textRaw": "`environment` {number}",
 "type": "number",
 "name": "environment",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "The high resolution millisecond timestamp at which the Node.js environment was\ninitialized."
 },
 {
 "textRaw": "`loopExit` {number}",
 "type": "number",
 "name": "loopExit",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "The high resolution millisecond timestamp at which the Node.js event loop\nexited. If the event loop has not yet exited, the property has the value of -1.\nIt can only have a value of not -1 in a handler of the <a href=\"process.html#process_event_exit\"><code>'exit'</code></a> event."
 },
 {
 "textRaw": "`loopStart` {number}",
 "type": "number",
 "name": "loopStart",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "The high resolution millisecond timestamp at which the Node.js event loop\nstarted. If the event loop has not yet started (e.g., in the first tick of the\nmain script), the property has the value of -1."
 },
 {
 "textRaw": "`nodeStart` {number}",
 "type": "number",
 "name": "nodeStart",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "The high resolution millisecond timestamp at which the Node.js process was\ninitialized."
 },
 {
 "textRaw": "`v8Start` {number}",
 "type": "number",
 "name": "v8Start",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "The high resolution millisecond timestamp at which the V8 platform was\ninitialized."
 },
 {
 "textRaw": "`idleTime` {number}",
 "type": "number",
 "name": "idleTime",
 "meta": {
 "added": [
 "v12.19.0"
 ],
 "changes": []
 },
 "desc": "The high resolution millisecond timestamp of the amount of time the event loop\nhas been idle within the event loop's event provider (e.g. <code>epoll_wait</code>). This\ndoes not take CPU usage into consideration. If the event loop has not yet\nstarted (e.g., in the first tick of the main script), the property has the\nvalue of 0."
 }
 ]
 },
 {
 "textRaw": "Class: `perf_hooks.PerformanceObserver`",
 "type": "class",
 "name": "perf_hooks.PerformanceObserver",
 "methods": [
 {
 "textRaw": "`performanceObserver.disconnect()`",
 "type": "method",
 "name": "disconnect",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "params": []
 }
 ],
 "desc": "Disconnects the <code>PerformanceObserver</code> instance from all notifications."
 },
 {
 "textRaw": "`performanceObserver.observe(options)`",
 "type": "method",
 "name": "observe",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`options` {Object}",
 "name": "options",
 "type": "Object",
 "options": [
 {
 "textRaw": "`entryTypes` {string[]} An array of strings identifying the types of `PerformanceEntry` instances the observer is interested in. If not provided an error will be thrown.",
 "name": "entryTypes",
 "type": "string[]",
 "desc": "An array of strings identifying the types of `PerformanceEntry` instances the observer is interested in. If not provided an error will be thrown."
 },
 {
 "textRaw": "`buffered` {boolean} If true, the notification callback will be called using `setImmediate()` and multiple `PerformanceEntry` instance notifications will be buffered internally. If `false`, notifications will be immediate and synchronous. **Default:** `false`.",
 "name": "buffered",
 "type": "boolean",
 "default": "`false`",
 "desc": "If true, the notification callback will be called using `setImmediate()` and multiple `PerformanceEntry` instance notifications will be buffered internally. If `false`, notifications will be immediate and synchronous."
 }
 ]
 }
 ]
 }
 ],
 "desc": "Subscribes the <code>PerformanceObserver</code> instance to notifications of new\n<code>PerformanceEntry</code> instances identified by <code>options.entryTypes</code>.\nWhen <code>options.buffered</code> is <code>false</code>, the <code>callback</code> will be invoked once for\nevery <code>PerformanceEntry</code> instance:\n<pre><code class=\"language-js\">const {\n performance,\n PerformanceObserver\n} = require('perf_hooks');\n\nconst obs = new PerformanceObserver((list, observer) => {\n // Called three times synchronously. `list` contains one item.\n});\nobs.observe({ entryTypes: ['mark'] });\n\nfor (let n = 0; n &#x3C; 3; n++)\n performance.mark(`test${n}`);\n</code></pre>\n<pre><code class=\"language-js\">const {\n performance,\n PerformanceObserver\n} = require('perf_hooks');\n\nconst obs = new PerformanceObserver((list, observer) => {\n // Called once. `list` contains three items.\n});\nobs.observe({ entryTypes: ['mark'], buffered: true });\n\nfor (let n = 0; n &#x3C; 3; n++)\n performance.mark(`test${n}`);\n</code></pre>"
 }
 ],
 "signatures": [
 {
 "params": [
 {
 "textRaw": "`callback` {Function}",
 "name": "callback",
 "type": "Function",
 "options": [
 {
 "textRaw": "`list` {PerformanceObserverEntryList}",
 "name": "list",
 "type": "PerformanceObserverEntryList"
 },
 {
 "textRaw": "`observer` {PerformanceObserver}",
 "name": "observer",
 "type": "PerformanceObserver"
 }
 ]
 }
 ],
 "desc": "<code>PerformanceObserver</code> objects provide notifications when new\n<code>PerformanceEntry</code> instances have been added to the Performance Timeline.\n<pre><code class=\"language-js\">const {\n performance,\n PerformanceObserver\n} = require('perf_hooks');\n\nconst obs = new PerformanceObserver((list, observer) => {\n console.log(list.getEntries());\n observer.disconnect();\n});\nobs.observe({ entryTypes: ['mark'], buffered: true });\n\nperformance.mark('test');\n</code></pre>\nBecause <code>PerformanceObserver</code> instances introduce their own additional\nperformance overhead, instances should not be left subscribed to notifications\nindefinitely. Users should disconnect observers as soon as they are no\nlonger needed.\nThe <code>callback</code> is invoked when a <code>PerformanceObserver</code> is\nnotified about new <code>PerformanceEntry</code> instances. The callback receives a\n<code>PerformanceObserverEntryList</code> instance and a reference to the\n<code>PerformanceObserver</code>."
 }
 ]
 },
 {
 "textRaw": "Class: `PerformanceObserverEntryList`",
 "type": "class",
 "name": "PerformanceObserverEntryList",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "desc": "The <code>PerformanceObserverEntryList</code> class is used to provide access to the\n<code>PerformanceEntry</code> instances passed to a <code>PerformanceObserver</code>.\nThe constructor of this class is not exposed to users.",
 "methods": [
 {
 "textRaw": "`performanceObserverEntryList.getEntries()`",
 "type": "method",
 "name": "getEntries",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "return": {
 "textRaw": "Returns: {PerformanceEntry[]}",
 "name": "return",
 "type": "PerformanceEntry[]"
 },
 "params": []
 }
 ],
 "desc": "Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code>."
 },
 {
 "textRaw": "`performanceObserverEntryList.getEntriesByName(name[, type])`",
 "type": "method",
 "name": "getEntriesByName",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "return": {
 "textRaw": "Returns: {PerformanceEntry[]}",
 "name": "return",
 "type": "PerformanceEntry[]"
 },
 "params": [
 {
 "textRaw": "`name` {string}",
 "name": "name",
 "type": "string"
 },
 {
 "textRaw": "`type` {string}",
 "name": "type",
 "type": "string"
 }
 ]
 }
 ],
 "desc": "Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.name</code> is\nequal to <code>name</code>, and optionally, whose <code>performanceEntry.entryType</code> is equal to\n<code>type</code>."
 },
 {
 "textRaw": "`performanceObserverEntryList.getEntriesByType(type)`",
 "type": "method",
 "name": "getEntriesByType",
 "meta": {
 "added": [
 "v8.5.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "return": {
 "textRaw": "Returns: {PerformanceEntry[]}",
 "name": "return",
 "type": "PerformanceEntry[]"
 },
 "params": [
 {
 "textRaw": "`type` {string}",
 "name": "type",
 "type": "string"
 }
 ]
 }
 ],
 "desc": "Returns a list of <code>PerformanceEntry</code> objects in chronological order\nwith respect to <code>performanceEntry.startTime</code> whose <code>performanceEntry.entryType</code>\nis equal to <code>type</code>."
 }
 ]
 }
 ],
 "methods": [
 {
 "textRaw": "`perf_hooks.monitorEventLoopDelay([options])`",
 "type": "method",
 "name": "monitorEventLoopDelay",
 "meta": {
 "added": [
 "v11.10.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "return": {
 "textRaw": "Returns: {Histogram}",
 "name": "return",
 "type": "Histogram"
 },
 "params": [
 {
 "textRaw": "`options` {Object}",
 "name": "options",
 "type": "Object",
 "options": [
 {
 "textRaw": "`resolution` {number} The sampling rate in milliseconds. Must be greater than zero. **Default:** `10`.",
 "name": "resolution",
 "type": "number",
 "default": "`10`",
 "desc": "The sampling rate in milliseconds. Must be greater than zero."
 }
 ]
 }
 ]
 }
 ],
 "desc": "This property is an extension by Node.js. It is not available in Web browsers.\nCreates a <code>Histogram</code> object that samples and reports the event loop delay\nover time. The delays will be reported in nanoseconds.\nUsing a timer to detect approximate event loop delay works because the\nexecution of timers is tied specifically to the lifecycle of the libuv\nevent loop. That is, a delay in the loop will cause a delay in the execution\nof the timer, and those delays are specifically what this API is intended to\ndetect.\n<pre><code class=\"language-js\">const { monitorEventLoopDelay } = require('perf_hooks');\nconst h = monitorEventLoopDelay({ resolution: 20 });\nh.enable();\n// Do something.\nh.disable();\nconsole.log(h.min);\nconsole.log(h.max);\nconsole.log(h.mean);\nconsole.log(h.stddev);\nconsole.log(h.percentiles);\nconsole.log(h.percentile(50));\nconsole.log(h.percentile(99));\n</code></pre>",
 "classes": [
 {
 "textRaw": "Class: `Histogram`",
 "type": "class",
 "name": "Histogram",
 "meta": {
 "added": [
 "v11.10.0"
 ],
 "changes": []
 },
 "desc": "Tracks the event loop delay at a given sampling rate. The constructor of\nthis class not exposed to users.\nThis property is an extension by Node.js. It is not available in Web browsers.",
 "methods": [
 {
 "textRaw": "`histogram.disable()`",
 "type": "method",
 "name": "disable",
 "meta": {
 "added": [
 "v11.10.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "return": {
 "textRaw": "Returns: {boolean}",
 "name": "return",
 "type": "boolean"
 },
 "params": []
 }
 ],
 "desc": "Disables the event loop delay sample timer. Returns <code>true</code> if the timer was\nstopped, <code>false</code> if it was already stopped."
 },
 {
 "textRaw": "`histogram.enable()`",
 "type": "method",
 "name": "enable",
 "meta": {
 "added": [
 "v11.10.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "return": {
 "textRaw": "Returns: {boolean}",
 "name": "return",
 "type": "boolean"
 },
 "params": []
 }
 ],
 "desc": "Enables the event loop delay sample timer. Returns <code>true</code> if the timer was\nstarted, <code>false</code> if it was already started."
 },
 {
 "textRaw": "`histogram.percentile(percentile)`",
 "type": "method",
 "name": "percentile",
 "meta": {
 "added": [
 "v11.10.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "return": {
 "textRaw": "Returns: {number}",
 "name": "return",
 "type": "number"
 },
 "params": [
 {
 "textRaw": "`percentile` {number} A percentile value between 1 and 100.",
 "name": "percentile",
 "type": "number",
 "desc": "A percentile value between 1 and 100."
 }
 ]
 }
 ],
 "desc": "Returns the value at the given percentile."
 },
 {
 "textRaw": "`histogram.reset()`",
 "type": "method",
 "name": "reset",
 "meta": {
 "added": [
 "v11.10.0"
 ],
 "changes": []
 },
 "signatures": [
 {
 "params": []
 }
 ],
 "desc": "Resets the collected histogram data."
 }
 ],
 "properties": [
 {
 "textRaw": "`exceeds` {number}",
 "type": "number",
 "name": "exceeds",
 "meta": {
 "added": [
 "v11.10.0"
 ],
 "changes": []
 },
 "desc": "The number of times the event loop delay exceeded the maximum 1 hour event\nloop delay threshold."
 },
 {
 "textRaw": "`max` {number}",
 "type": "number",
 "name": "max",
 "meta": {
 "added": [
 "v11.10.0"
 ],
 "changes": []
 },
 "desc": "The maximum recorded event loop delay."
 },
 {
 "textRaw": "`mean` {number}",
 "type": "number",
 "name": "mean",
 "meta": {
 "added": [
 "v11.10.0"
 ],
 "changes": []
 },
 "desc": "The mean of the recorded event loop delays."
 },
 {
 "textRaw": "`min` {number}",
 "type": "number",
 "name": "min",
 "meta": {
 "added": [
 "v11.10.0"
 ],
 "changes": []
 },
 "desc": "The minimum recorded event loop delay."
 },
 {
 "textRaw": "`percentiles` {Map}",
 "type": "Map",
 "name": "percentiles",
 "meta": {
 "added": [
 "v11.10.0"
 ],
 "changes": []
 },
 "desc": "Returns a <code>Map</code> object detailing the accumulated percentile distribution."
 },
 {
 "textRaw": "`stddev` {number}",
 "type": "number",
 "name": "stddev",
 "meta": {
 "added": [
 "v11.10.0"
 ],
 "changes": []
 },
 "desc": "The standard deviation of the recorded event loop delays.\n<h2>Examples</h2>"
 }
 ]
 }
 ],
 "modules": [
 {
 "textRaw": "Measuring the duration of async operations",
 "name": "measuring_the_duration_of_async_operations",
 "desc": "The following example uses the <a href=\"async_hooks.html\">Async Hooks</a> and Performance APIs to measure\nthe actual duration of a Timeout operation (including the amount of time it took\nto execute the callback).\n<pre><code class=\"language-js\">'use strict';\nconst async_hooks = require('async_hooks');\nconst {\n performance,\n PerformanceObserver\n} = require('perf_hooks');\n\nconst set = new Set();\nconst hook = async_hooks.createHook({\n init(id, type) {\n if (type === 'Timeout') {\n performance.mark(`Timeout-${id}-Init`);\n set.add(id);\n }\n },\n destroy(id) {\n if (set.has(id)) {\n set.delete(id);\n performance.mark(`Timeout-${id}-Destroy`);\n performance.measure(`Timeout-${id}`,\n `Timeout-${id}-Init`,\n `Timeout-${id}-Destroy`);\n }\n }\n});\nhook.enable();\n\nconst obs = new PerformanceObserver((list, observer) => {\n console.log(list.getEntries()[0]);\n performance.clearMarks();\n observer.disconnect();\n});\nobs.observe({ entryTypes: ['measure'], buffered: true });\n\nsetTimeout(() => {}, 1000);\n</code></pre>",
 "type": "module",
 "displayName": "Measuring the duration of async operations"
 },
 {
 "textRaw": "Measuring how long it takes to load dependencies",
 "name": "measuring_how_long_it_takes_to_load_dependencies",
 "desc": "The following example measures the duration of <code>require()</code> operations to load\ndependencies:\n\n<pre><code class=\"language-js\">'use strict';\nconst {\n performance,\n PerformanceObserver\n} = require('perf_hooks');\nconst mod = require('module');\n\n// Monkey patch the require function\nmod.Module.prototype.require =\n performance.timerify(mod.Module.prototype.require);\nrequire = performance.timerify(require);\n\n// Activate the observer\nconst obs = new PerformanceObserver((list) => {\n const entries = list.getEntries();\n entries.forEach((entry) => {\n console.log(`require('${entry[0]}')`, entry.duration);\n });\n obs.disconnect();\n});\nobs.observe({ entryTypes: ['function'], buffered: true });\n\nrequire('some-module');\n</code></pre>",
 "type": "module",
 "displayName": "Measuring how long it takes to load dependencies"
 }
 ]
 }
 ],
 "type": "module",
 "displayName": "Performance measurement APIs"
 }
 ]
}

MR SKB