perf_hooks: test resource timing fetch integration

Signed-off-by: greenhead <greenheadhq@gmail.com>

Author: greenheadHQ

doc/api/perf_hooks.md

@@ -1100,7 +1100,7 @@ added: REPLACEME
 * Type: {number}
 
 The high resolution millisecond timestamp representing the time immediately
-after Node.js receives the first byte of the headers of the final response,
+after Node.js receives the first byte of the final response,
 as opposed to an interim response.
 
 ### `performanceResourceTiming.firstInterimResponseStart`
@@ -1113,8 +1113,8 @@ added: REPLACEME
 
 The high resolution millisecond timestamp representing the time immediately
 after Node.js receives the first byte of the first interim response, such as
-a `103 Early Hints` response. Node.js does not currently record interim
-responses, so the property always returns 0.
+a `103 Early Hints` response. For entries created by the built-in `fetch()`
+implementation, this is currently `0` because interim response timings are not recorded.
 
 ### `performanceResourceTiming.responseStart`
 
@@ -1224,8 +1224,8 @@ added: REPLACEME
 * Type: {string}
 
 The render blocking status of the resource. It is either `'blocking'` or
-`'non-blocking'`. Resources fetched by Node.js are never render blocking, so
-the property always returns `'non-blocking'`.
+`'non-blocking'`. Entries created by the built-in `fetch()` implementation
+return `'non-blocking'`.
 
 ### `performanceResourceTiming.contentType`
 
@@ -1236,8 +1236,8 @@ added: REPLACEME
 * Type: {string}
 
 The minimized MIME type of the content of the fetched resource, or an empty
-string if it cannot be determined. Node.js does not currently populate this
-field, so the property returns an empty string.
+string if it cannot be determined. Entries created by the built-in `fetch()`
+implementation currently return an empty string.
 
 ### `performanceResourceTiming.contentEncoding`
 
@@ -1249,8 +1249,8 @@ added: REPLACEME
 
 The content encoding, such as `'gzip'` or `'br'`, that was applied to the
 fetched resource, or an empty string if none was applied or it cannot be
-determined. Node.js does not currently populate this field, so the property
-returns an empty string.
+determined. Entries created by the built-in `fetch()` implementation currently
+return an empty string.
 
 ### `performanceResourceTiming.toJSON()`
 

test/parallel/test-perf-hooks-resourcetiming-attributes.js

@@ -42,8 +42,7 @@ function markResourceTiming(timingInfo, bodyInfo) {
   );
 }
 
-// Default values with an empty body info, mirroring what the fetch
-// implementation passes for a response with no body metadata.
+// Default values when no optional timing or body metadata is present.
 {
   const resource = markResourceTiming(createTimingInfo(), {});
 
@@ -55,6 +54,18 @@ function markResourceTiming(timingInfo, bodyInfo) {
   assert.strictEqual(resource.contentEncoding, '');
 }
 
+// responseStart falls back to the final response when no interim response timing was recorded.
+{
+  const resource = markResourceTiming(createTimingInfo({
+    finalNetworkResponseStartTime: 123,
+    firstInterimNetworkResponseStartTime: 0,
+  }), {});
+
+  assert.strictEqual(resource.finalResponseHeadersStart, 123);
+  assert.strictEqual(resource.firstInterimResponseStart, 0);
+  assert.strictEqual(resource.responseStart, 123);
+}
+
 // Values reflected from timing info and body info.
 {
   const timingInfo = createTimingInfo({

test/parallel/test-perf-hooks-resourcetiming-fetch.mjs

@@ -0,0 +1,67 @@
+// The ESM common wrapper does not export localhostIPv4.
+// eslint-disable-next-line node-core/require-common-first
+import common from '../common/index.js';
+
+import assert from 'node:assert';
+import { once } from 'node:events';
+import { createServer } from 'node:http';
+import {
+  PerformanceResourceTiming,
+  performance,
+} from 'node:perf_hooks';
+
+// This test ensures that built-in fetch creates a PerformanceResourceTiming
+// entry with the resource timing attributes exposed by Node.js.
+
+const responseBody = 'Hello world';
+const server = createServer(common.mustCall((req, res) => {
+  res.end(responseBody);
+}));
+
+server.listen(0, common.localhostIPv4);
+await once(server, 'listening');
+
+async function closeServer() {
+  if (server.listening) {
+    await new Promise((resolve) => server.close(resolve));
+  }
+}
+
+try {
+  performance.clearResourceTimings();
+
+  const url = `http://${common.localhostIPv4}:${server.address().port}/`;
+  const response = await fetch(url);
+  assert.strictEqual(await response.text(), responseBody);
+  await closeServer();
+
+  const entries = performance.getEntriesByName(url, 'resource');
+  assert.strictEqual(entries.length, 1);
+
+  const [entry] = entries;
+  assert(entry instanceof PerformanceResourceTiming);
+  assert.strictEqual(entry.initiatorType, 'fetch');
+  assert.strictEqual(entry.responseStatus, 200);
+  assert(entry.finalResponseHeadersStart > 0);
+  assert.strictEqual(entry.firstInterimResponseStart, 0);
+  assert.strictEqual(entry.responseStart, entry.finalResponseHeadersStart);
+  assert(entry.responseEnd >= entry.responseStart);
+  assert.strictEqual(entry.renderBlockingStatus, 'non-blocking');
+  assert.strictEqual(entry.contentType, '');
+  assert.strictEqual(entry.contentEncoding, '');
+
+  const json = entry.toJSON();
+  for (const name of [
+    'finalResponseHeadersStart',
+    'firstInterimResponseStart',
+    'responseStart',
+    'renderBlockingStatus',
+    'contentType',
+    'contentEncoding',
+  ]) {
+    assert.strictEqual(json[name], entry[name], name);
+  }
+} finally {
+  performance.clearResourceTimings();
+  await closeServer();
+}