Skip to content

Commit 127cb31

Browse files
greenheadHQaduh95
greenheadHQ
authored and
aduh95
committed
perf_hooks: add missing resource timing attributes
Add the finalResponseHeadersStart, firstInterimResponseStart, renderBlockingStatus, contentType and contentEncoding getters to PerformanceResourceTiming and update the WPT status accordingly. Signed-off-by: greenhead <[email protected]> PR-URL: #65017 Refs: #51589 Reviewed-By: Daeyeon Jeong <[email protected]> Reviewed-By: Chengzhong Wu <[email protected]>
1 parent 80568f6 commit 127cb31

6 files changed

Lines changed: 320 additions & 14 deletions

File tree

‎doc/api/perf_hooks.md‎

Lines changed: 79 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1087,6 +1087,54 @@ changes:
10871087
The high resolution millisecond timestamp representing the time immediately
10881088
before Node.js receives the first byte of the response from the server.
10891089

1090+
### `performanceResourceTiming.finalResponseHeadersStart`
1091+
1092+
<!-- YAML
1093+
added: REPLACEME
1094+
-->
1095+
1096+
* Type: {number}
1097+
1098+
The high resolution millisecond timestamp representing the time immediately
1099+
after Node.js receives the first byte of the final response,
1100+
as opposed to an interim response.
1101+
1102+
### `performanceResourceTiming.firstInterimResponseStart`
1103+
1104+
<!-- YAML
1105+
added: REPLACEME
1106+
-->
1107+
1108+
* Type: {number}
1109+
1110+
The high resolution millisecond timestamp representing the time immediately
1111+
after Node.js receives the first byte of the first interim response, such as
1112+
a `103 Early Hints` response.
1113+
1114+
### `performanceResourceTiming.responseStart`
1115+
1116+
<!-- YAML
1117+
added:
1118+
- v18.2.0
1119+
- v16.17.0
1120+
changes:
1121+
- version: REPLACEME
1122+
pr-url: https://github.com/nodejs/node/pull/65017
1123+
description: This property now returns `firstInterimResponseStart`
1124+
when it is non-zero.
1125+
- version: v19.0.0
1126+
pr-url: https://github.com/nodejs/node/pull/44483
1127+
description: This property getter must be called with the
1128+
`PerformanceResourceTiming` object as the receiver.
1129+
-->
1130+
1131+
* Type: {number}
1132+
1133+
The high resolution millisecond timestamp representing the time immediately
1134+
after Node.js receives the first byte of the response from the server. This
1135+
is `firstInterimResponseStart` when it is non-zero, and
1136+
`finalResponseHeadersStart` otherwise.
1137+
10901138
### `performanceResourceTiming.responseEnd`
10911139

10921140
<!-- YAML
@@ -1162,6 +1210,37 @@ A number representing the size (in octets) received from the fetch
11621210
(HTTP or cache), of the message body, after removing any applied
11631211
content-codings.
11641212

1213+
### `performanceResourceTiming.renderBlockingStatus`
1214+
1215+
<!-- YAML
1216+
added: REPLACEME
1217+
-->
1218+
1219+
* Type: {string}
1220+
1221+
The render blocking status of the resource. It is either `'blocking'` or `'non-blocking'`.
1222+
1223+
### `performanceResourceTiming.contentType`
1224+
1225+
<!-- YAML
1226+
added: REPLACEME
1227+
-->
1228+
1229+
* Type: {string}
1230+
1231+
The minimized MIME type of the content of the fetched resource, or an empty
1232+
string if it cannot be determined.
1233+
1234+
### `performanceResourceTiming.contentEncoding`
1235+
1236+
<!-- YAML
1237+
added: REPLACEME
1238+
-->
1239+
1240+
* Type: {string}
1241+
1242+
The content encoding of the fetched resource, such as `'gzip'` or `'br'`.
1243+
11651244
### `performanceResourceTiming.toJSON()`
11661245

11671246
<!-- YAML

‎lib/internal/perf/resource_timing.js‎

Lines changed: 40 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,6 +17,7 @@ const { enqueue, bufferResourceTiming } = require('internal/perf/observe');
1717
const { validateThisInternalField } = require('internal/validators');
1818
const { kEnumerableProperty } = require('internal/util');
1919

20+
const kBodyInfo = Symbol('kBodyInfo');
2021
const kCacheMode = Symbol('kCacheMode');
2122
const kRequestedUrl = Symbol('kRequestedUrl');
2223
const kTimingInfo = Symbol('kTimingInfo');
@@ -110,11 +111,22 @@ class PerformanceResourceTiming extends PerformanceEntry {
110111
return this[kTimingInfo].finalNetworkRequestStartTime;
111112
}
112113

113-
get responseStart() {
114+
get finalResponseHeadersStart() {
114115
validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
115116
return this[kTimingInfo].finalNetworkResponseStartTime;
116117
}
117118

119+
get firstInterimResponseStart() {
120+
validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
121+
return this[kTimingInfo].firstInterimNetworkResponseStartTime ?? 0;
122+
}
123+
124+
get responseStart() {
125+
validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
126+
return this[kTimingInfo].firstInterimNetworkResponseStartTime ||
127+
this[kTimingInfo].finalNetworkResponseStartTime;
128+
}
129+
118130
get responseEnd() {
119131
validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
120132
return this[kTimingInfo].endTime;
@@ -148,6 +160,22 @@ class PerformanceResourceTiming extends PerformanceEntry {
148160
return this[kResponseStatus];
149161
}
150162

163+
get renderBlockingStatus() {
164+
validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
165+
return this[kTimingInfo].renderBlocking === true ?
166+
'blocking' : 'non-blocking';
167+
}
168+
169+
get contentType() {
170+
validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
171+
return this[kBodyInfo]?.contentType ?? '';
172+
}
173+
174+
get contentEncoding() {
175+
validateThisInternalField(this, kTimingInfo, 'PerformanceResourceTiming');
176+
return this[kBodyInfo]?.contentEncoding ?? '';
177+
}
178+
151179
toJSON() {
152180
validateThisInternalField(this, kInitiatorType, 'PerformanceResourceTiming');
153181
return {
@@ -167,13 +195,18 @@ class PerformanceResourceTiming extends PerformanceEntry {
167195
connectEnd: this.connectEnd,
168196
secureConnectionStart: this.secureConnectionStart,
169197
requestStart: this.requestStart,
198+
finalResponseHeadersStart: this.finalResponseHeadersStart,
199+
firstInterimResponseStart: this.firstInterimResponseStart,
170200
responseStart: this.responseStart,
171201
responseEnd: this.responseEnd,
172202
transferSize: this.transferSize,
173203
encodedBodySize: this.encodedBodySize,
174204
decodedBodySize: this.decodedBodySize,
175205
deliveryType: this.deliveryType,
176206
responseStatus: this.responseStatus,
207+
renderBlockingStatus: this.renderBlockingStatus,
208+
contentType: this.contentType,
209+
contentEncoding: this.contentEncoding,
177210
};
178211
}
179212
}
@@ -191,13 +224,18 @@ ObjectDefineProperties(PerformanceResourceTiming.prototype, {
191224
connectEnd: kEnumerableProperty,
192225
secureConnectionStart: kEnumerableProperty,
193226
requestStart: kEnumerableProperty,
227+
finalResponseHeadersStart: kEnumerableProperty,
228+
firstInterimResponseStart: kEnumerableProperty,
194229
responseStart: kEnumerableProperty,
195230
responseEnd: kEnumerableProperty,
196231
transferSize: kEnumerableProperty,
197232
encodedBodySize: kEnumerableProperty,
198233
decodedBodySize: kEnumerableProperty,
199234
deliveryType: kEnumerableProperty,
200235
responseStatus: kEnumerableProperty,
236+
renderBlockingStatus: kEnumerableProperty,
237+
contentType: kEnumerableProperty,
238+
contentEncoding: kEnumerableProperty,
201239
toJSON: kEnumerableProperty,
202240
[SymbolToStringTag]: {
203241
__proto__: null,
@@ -224,6 +262,7 @@ function createPerformanceResourceTiming(
224262
// The spec doesn't say to validate it in the class construction.
225263
resourceTiming[kTimingInfo] = timingInfo;
226264
resourceTiming[kCacheMode] = cacheMode;
265+
resourceTiming[kBodyInfo] = bodyInfo;
227266
resourceTiming[kDeliveryType] = deliveryType;
228267
resourceTiming[kResponseStatus] = responseStatus;
229268

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

Lines changed: 116 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,116 @@
1+
'use strict';
2+
3+
require('../common');
4+
const assert = require('assert');
5+
const {
6+
PerformanceResourceTiming,
7+
performance,
8+
} = require('perf_hooks');
9+
10+
// Covers the IDL attributes finalResponseHeadersStart,
11+
// firstInterimResponseStart, renderBlockingStatus, contentType and contentEncoding,
12+
// and the spec requirement that responseStart prefers a non-zero
13+
// firstInterimResponseStart over finalResponseHeadersStart.
14+
15+
function createTimingInfo(overrides = {}) {
16+
return {
17+
startTime: 0,
18+
redirectStartTime: 0,
19+
redirectEndTime: 0,
20+
postRedirectStartTime: 0,
21+
finalServiceWorkerStartTime: 0,
22+
finalNetworkRequestStartTime: 0,
23+
finalNetworkResponseStartTime: 0,
24+
endTime: 0,
25+
encodedBodySize: 0,
26+
decodedBodySize: 0,
27+
finalConnectionTimingInfo: null,
28+
...overrides,
29+
};
30+
}
31+
32+
function markResourceTiming(timingInfo, bodyInfo) {
33+
return performance.markResourceTiming(
34+
timingInfo,
35+
'http://localhost:8080',
36+
'fetch',
37+
{},
38+
'',
39+
bodyInfo,
40+
200,
41+
'',
42+
);
43+
}
44+
45+
// Default values when no optional timing or body metadata is present.
46+
{
47+
const resource = markResourceTiming(createTimingInfo(), {});
48+
49+
assert.strictEqual(resource.finalResponseHeadersStart, 0);
50+
assert.strictEqual(resource.firstInterimResponseStart, 0);
51+
assert.strictEqual(resource.responseStart, 0);
52+
assert.strictEqual(resource.renderBlockingStatus, 'non-blocking');
53+
assert.strictEqual(resource.contentType, '');
54+
assert.strictEqual(resource.contentEncoding, '');
55+
}
56+
57+
// responseStart falls back to the final response when no interim response timing was recorded.
58+
{
59+
const resource = markResourceTiming(createTimingInfo({
60+
finalNetworkResponseStartTime: 123,
61+
firstInterimNetworkResponseStartTime: 0,
62+
}), {});
63+
64+
assert.strictEqual(resource.finalResponseHeadersStart, 123);
65+
assert.strictEqual(resource.firstInterimResponseStart, 0);
66+
assert.strictEqual(resource.responseStart, 123);
67+
}
68+
69+
// Values reflected from timing info and body info.
70+
{
71+
const timingInfo = createTimingInfo({
72+
finalNetworkResponseStartTime: 123,
73+
firstInterimNetworkResponseStartTime: 45,
74+
renderBlocking: true,
75+
});
76+
const bodyInfo = {
77+
contentType: 'text/html',
78+
contentEncoding: 'gzip',
79+
};
80+
const resource = markResourceTiming(timingInfo, bodyInfo);
81+
82+
assert.strictEqual(resource.finalResponseHeadersStart, 123);
83+
assert.strictEqual(resource.firstInterimResponseStart, 45);
84+
assert.strictEqual(resource.responseStart, 45);
85+
assert.strictEqual(resource.renderBlockingStatus, 'blocking');
86+
assert.strictEqual(resource.contentType, 'text/html');
87+
assert.strictEqual(resource.contentEncoding, 'gzip');
88+
89+
const json = resource.toJSON();
90+
assert.strictEqual(json.finalResponseHeadersStart, 123);
91+
assert.strictEqual(json.firstInterimResponseStart, 45);
92+
assert.strictEqual(json.responseStart, 45);
93+
assert.strictEqual(json.renderBlockingStatus, 'blocking');
94+
assert.strictEqual(json.contentType, 'text/html');
95+
assert.strictEqual(json.contentEncoding, 'gzip');
96+
}
97+
98+
// The attributes are enumerable getters on the prototype and perform a
99+
// brand check like the other PerformanceResourceTiming attributes.
100+
for (const name of [
101+
'finalResponseHeadersStart',
102+
'firstInterimResponseStart',
103+
'renderBlockingStatus',
104+
'contentType',
105+
'contentEncoding',
106+
]) {
107+
const desc = Object.getOwnPropertyDescriptor(
108+
PerformanceResourceTiming.prototype, name);
109+
assert.strictEqual(desc.enumerable, true, name);
110+
assert.strictEqual(typeof desc.get, 'function', name);
111+
assert.throws(() => desc.get.call({}), {
112+
code: 'ERR_INVALID_THIS',
113+
}, name);
114+
}
115+
116+
performance.clearResourceTimings();

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

Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,67 @@
1+
// The ESM common wrapper does not export localhostIPv4.
2+
// eslint-disable-next-line node-core/require-common-first
3+
import common from '../common/index.js';
4+
5+
import assert from 'node:assert';
6+
import { once } from 'node:events';
7+
import { createServer } from 'node:http';
8+
import {
9+
PerformanceResourceTiming,
10+
performance,
11+
} from 'node:perf_hooks';
12+
13+
// This test ensures that built-in fetch creates a PerformanceResourceTiming
14+
// entry with the resource timing attributes exposed by Node.js.
15+
16+
const responseBody = 'Hello world';
17+
const server = createServer(common.mustCall((req, res) => {
18+
res.end(responseBody);
19+
}));
20+
21+
server.listen(0, common.localhostIPv4);
22+
await once(server, 'listening');
23+
24+
async function closeServer() {
25+
if (server.listening) {
26+
await new Promise((resolve) => server.close(resolve));
27+
}
28+
}
29+
30+
try {
31+
performance.clearResourceTimings();
32+
33+
const url = `http://${common.localhostIPv4}:${server.address().port}/`;
34+
const response = await fetch(url);
35+
assert.strictEqual(await response.text(), responseBody);
36+
await closeServer();
37+
38+
const entries = performance.getEntriesByName(url, 'resource');
39+
assert.strictEqual(entries.length, 1);
40+
41+
const [entry] = entries;
42+
assert(entry instanceof PerformanceResourceTiming);
43+
assert.strictEqual(entry.initiatorType, 'fetch');
44+
assert.strictEqual(entry.responseStatus, 200);
45+
assert(entry.finalResponseHeadersStart > 0);
46+
assert.strictEqual(entry.firstInterimResponseStart, 0);
47+
assert.strictEqual(entry.responseStart, entry.finalResponseHeadersStart);
48+
assert(entry.responseEnd >= entry.responseStart);
49+
assert.strictEqual(entry.renderBlockingStatus, 'non-blocking');
50+
assert.strictEqual(entry.contentType, '');
51+
assert.strictEqual(entry.contentEncoding, '');
52+
53+
const json = entry.toJSON();
54+
for (const name of [
55+
'finalResponseHeadersStart',
56+
'firstInterimResponseStart',
57+
'responseStart',
58+
'renderBlockingStatus',
59+
'contentType',
60+
'contentEncoding',
61+
]) {
62+
assert.strictEqual(json[name], entry[name], name);
63+
}
64+
} finally {
65+
performance.clearResourceTimings();
66+
await closeServer();
67+
}

0 commit comments

Comments
 (0)