perf_hooks: fix observable when using resource

RafaelGSS · RafaelGSS · commit bfa9754c6c24 · 2022-04-20T07:41:30.000-03:00
diff --git a/lib/internal/perf/observe.js b/lib/internal/perf/observe.js
@@ -343,8 +343,9 @@ function enqueue(entry) {
     buffer = markEntryBuffer;
   } else if (entryType === 'measure') {
     buffer = measureEntryBuffer;
-  } else {
+  } else if (entryType === 'resource') {
     buffer = resourceTimingBuffer;
+  } else {
     return;
   }
 
diff --git a/lib/internal/perf/resource_timing.js b/lib/internal/perf/resource_timing.js
@@ -1,26 +1,27 @@
-// https://github.com/nodejs/undici/issues/952
+'use strict';
 // https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming
 
 const { InternalPerformanceEntry } = require('internal/perf/performance_entry');
 const { SymbolToStringTag } = primordials;
-const assert = require('assert')
+const assert = require('internal/assert');
 const { enqueue } = require('internal/perf/observe');
+const { Symbol } = primordials;
 
 const kCacheMode = Symbol('kCacheMode');
 const kRequestedUrl = Symbol('kRequestedUrl');
 const kTimingInfo = Symbol('kTimingInfo');
 const kInitiatorType = Symbol('kInitiatorType');
 
 class PerformanceResourceTiming extends InternalPerformanceEntry {
-  constructor(requestedUrl, start, initiatorType, timingInfo, cacheMode = "") {
+  constructor(requestedUrl, start, initiatorType, timingInfo, cacheMode = '') {
     super(requestedUrl, 'resource', start);
     // https://w3c.github.io/resource-timing/#dfn-setup-the-resource-timing-entry
-    assert.ok(cacheMode === "" || cacheMode === "local")
-    this[kInitiatorType] = initiatorType
-    this[kRequestedUrl] = requestedUrl
+    assert.ok(cacheMode === '' || cacheMode === 'local');
+    this[kInitiatorType] = initiatorType;
+    this[kRequestedUrl] = requestedUrl;
     // https://fetch.spec.whatwg.org/#fetch-timing-info
-    this[kTimingInfo] = timingInfo
-    this[kCacheMode] = cacheMode
+    this[kTimingInfo] = timingInfo;
+    this[kCacheMode] = cacheMode;
   }
 
   get [SymbolToStringTag]() {
@@ -118,7 +119,7 @@ class PerformanceResourceTiming extends InternalPerformanceEntry {
       entryType: this.entryType,
       startTime: this.startTime,
       duration: this.duration,
-    }
+    };
   }
 }
 
@@ -128,14 +129,13 @@ function markResourceTiming(
   requestedUrl,
   initiatorType,
   global,
-  cacheMode
+  cacheMode,
 ) {
   // TODO(rafaelgss): Probably must have some asserts here for:
   // - timingInfo
   // - requestedUrl
   // - initiatorType
   // - cacheMode
- 
   // 1. Create a PerformanceResourceTiming object entry in global's realm.
   // TODO(rafaelgss): why and how should I put `resource` into global object?
   const resource = new PerformanceResourceTiming(
@@ -144,7 +144,7 @@ function markResourceTiming(
     timingInfo.startTime,
     initiatorType,
     timingInfo,
-    cacheMode
+    cacheMode,
   );
   enqueue(resource);
   return resource;
diff --git a/lib/perf_hooks.js b/lib/perf_hooks.js
@@ -9,7 +9,7 @@ const {
 } = internalBinding('performance');
 
 const { PerformanceEntry } = require('internal/perf/performance_entry');
-const { PerformanceResourceTiming } = require('internal/perf/resource_timing')
+const { PerformanceResourceTiming } = require('internal/perf/resource_timing');
 const {
   PerformanceObserver,
   PerformanceObserverEntryList,
diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js
@@ -98,6 +98,7 @@ const expectedModules = new Set([
   'NativeModule internal/perf/performance',
   'NativeModule internal/perf/timerify',
   'NativeModule internal/perf/usertiming',
+  'NativeModule internal/perf/resource_timing',
   'NativeModule internal/perf/utils',
   'NativeModule internal/priority_queue',
   'NativeModule internal/process/esm_loader',
diff --git a/test/parallel/test-perf-hooks-resourcetiming.js b/test/parallel/test-perf-hooks-resourcetiming.js
@@ -33,17 +33,17 @@ function createTimingInfo({
 }) {
   if (finalConnectionTimingInfo !== null) {
     finalConnectionTimingInfo.domainLookupStartTime =
-        finalConnectionTimingInfo.domainLookupStartTime || 0
+        finalConnectionTimingInfo.domainLookupStartTime || 0;
     finalConnectionTimingInfo.domainLookupEndTime =
-        finalConnectionTimingInfo.domainLookupEndTime || 0
+        finalConnectionTimingInfo.domainLookupEndTime || 0;
     finalConnectionTimingInfo.connectionStartTime =
-        finalConnectionTimingInfo.connectionStartTime || 0
+        finalConnectionTimingInfo.connectionStartTime || 0;
     finalConnectionTimingInfo.connectionEndTime =
-        finalConnectionTimingInfo.connectionEndTime || 0
+        finalConnectionTimingInfo.connectionEndTime || 0;
     finalConnectionTimingInfo.secureConnectionStartTime =
-        finalConnectionTimingInfo.secureConnectionStartTime || 0
+        finalConnectionTimingInfo.secureConnectionStartTime || 0;
     finalConnectionTimingInfo.ALPNNegotiatedProtocol =
-        finalConnectionTimingInfo.ALPNNegotiatedProtocol || []
+        finalConnectionTimingInfo.ALPNNegotiatedProtocol || [];
   }
   return {
     startTime,
@@ -57,27 +57,53 @@ function createTimingInfo({
     encodedBodySize,
     decodedBodySize,
     finalConnectionTimingInfo,
-  }
+  };
 }
 
+// Using performance.getEntries*()
 {
-  const obs = new PerformanceObserver(common.mustCall((list) => {
-    {
-      const entries = list.getEntries();
-      assert.strictEqual(entries.length, 1);
-    }
-    {
-      const entries = list.getEntriesByType('resource');
-      assert.strictEqual(entries.length, 1);
-    }
-    {
-      const entries = list.getEntriesByName('http://localhost:8080');
-      assert.strictEqual(entries.length, 1);
-    }
-    obs.disconnect();
-  }));
-  obs.observe({ entryTypes: ['resource'] });
+  const timingInfo = createTimingInfo({ finalConnectionTimingInfo: {} });
+  const customGlobal = {};
+  const requestedUrl = 'http://localhost:8080';
+  const cacheMode = 'local';
+  const initiatorType = 'fetch';
+  const resource = markResourceTiming(
+    timingInfo,
+    requestedUrl,
+    initiatorType,
+    customGlobal,
+    cacheMode,
+  );
+
+  assert(resource instanceof PerformanceEntry);
+  assert(resource instanceof PerformanceResourceTiming);
+
+  {
+    const entries = performance.getEntries();
+    assert.strictEqual(entries.length, 1);
+    assert(entries[0] instanceof PerformanceResourceTiming);
+  }
+
+  {
+    const entries = performance.getEntriesByType('resource');
+    assert.strictEqual(entries.length, 1);
+    assert(entries[0] instanceof PerformanceResourceTiming);
+  }
+
+  {
+    const entries = performance.getEntriesByName(resource.name);
+    assert.strictEqual(entries.length, 1);
+    assert(entries[0] instanceof PerformanceResourceTiming);
+  }
+
+  clearResourceTimings();
+  assert.strictEqual(performance.getEntries().length, 0);
+}
+
+// Assert resource data based in timingInfo
 
+// default values
+{
   const timingInfo = createTimingInfo({ finalConnectionTimingInfo: {} });
   const customGlobal = {};
   const requestedUrl = 'http://localhost:8080';
@@ -108,14 +134,14 @@ function createTimingInfo({
   assert.strictEqual(resource.connectStart, 0);
   assert.strictEqual(resource.connectEnd, 0);
   assert.strictEqual(resource.secureConnectionStart, 0);
-  assert.deepEqual(resource.nextHopProtocol, []);
+  assert.deepStrictEqual(resource.nextHopProtocol, []);
   assert.strictEqual(resource.requestStart, 0);
   assert.strictEqual(resource.responseStart, 0);
   assert.strictEqual(resource.responseEnd, 0);
   assert.strictEqual(resource.encodedBodySize, 0);
   assert.strictEqual(resource.decodedBodySize, 0);
   assert.strictEqual(resource.transferSize, 0);
-  assert.deepEqual(resource.toJSON(), {
+  assert.deepStrictEqual(resource.toJSON(), {
     initiatorType,
     requestedUrl,
     cacheMode,
@@ -124,4 +150,93 @@ function createTimingInfo({
     startTime: timingInfo.startTime,
     duration: 0
   });
+
+  assert(resource instanceof PerformanceEntry);
+  assert(resource instanceof PerformanceResourceTiming);
+
+  clearResourceTimings();
+  const entries = performance.getEntries();
+  assert.strictEqual(entries.length, 0);
+}
+
+// custom getters math
+{
+  const timingInfo = createTimingInfo({
+    endTime: 100,
+    startTime: 50,
+    encodedBodySize: 150,
+  });
+  const customGlobal = {};
+  const requestedUrl = 'http://localhost:8080';
+  const cacheMode = '';
+  const initiatorType = 'fetch';
+  const resource = markResourceTiming(
+    timingInfo,
+    requestedUrl,
+    initiatorType,
+    customGlobal,
+    cacheMode,
+  );
+
+  assert(resource instanceof PerformanceEntry);
+  assert(resource instanceof PerformanceResourceTiming);
+
+  assert.strictEqual(resource.entryType, 'resource');
+  assert.strictEqual(resource.name, requestedUrl);
+  assert.ok(typeof resource.cacheMode === 'undefined', 'cacheMode does not have a getter');
+  assert.strictEqual(resource.startTime, timingInfo.startTime);
+  // Duration should be the timingInfo endTime - startTime
+  assert.strictEqual(resource.duration, 50);
+  // TransferSize should be encodedBodySize + 300 when cacheMode is empty
+  assert.strictEqual(resource.transferSize, 450);
+
+  assert(resource instanceof PerformanceEntry);
+  assert(resource instanceof PerformanceResourceTiming);
+
+  clearResourceTimings();
+  const entries = performance.getEntries();
+  assert.strictEqual(entries.length, 0);
+}
+
+// Using PerformanceObserver
+{
+  const obs = new PerformanceObserver(common.mustCall((list) => {
+    {
+      const entries = list.getEntries();
+      assert.strictEqual(entries.length, 1);
+      assert(entries[0] instanceof PerformanceResourceTiming);
+    }
+    {
+      const entries = list.getEntriesByType('resource');
+      assert.strictEqual(entries.length, 1);
+      assert(entries[0] instanceof PerformanceResourceTiming);
+    }
+    {
+      const entries = list.getEntriesByName('http://localhost:8080');
+      assert.strictEqual(entries.length, 1);
+      assert(entries[0] instanceof PerformanceResourceTiming);
+    }
+    obs.disconnect();
+  }));
+  obs.observe({ entryTypes: ['resource'] });
+
+  const timingInfo = createTimingInfo({ finalConnectionTimingInfo: {} });
+  const customGlobal = {};
+  const requestedUrl = 'http://localhost:8080';
+  const cacheMode = 'local';
+  const initiatorType = 'fetch';
+  const resource = markResourceTiming(
+    timingInfo,
+    requestedUrl,
+    initiatorType,
+    customGlobal,
+    cacheMode,
+  );
+
+  assert(resource instanceof PerformanceEntry);
+  assert(resource instanceof PerformanceResourceTiming);
+
+  clearResourceTimings();
+  const entries = performance.getEntries();
+  assert.strictEqual(entries.length, 0);
 }
