perf_hooks: web performance timeline compliance

Author: legendecas

lib/internal/errors.js

@@ -1226,8 +1226,6 @@ E('ERR_INVALID_PACKAGE_TARGET',
       pkgPath}package.json${base ? ` imported from ${base}` : ''}${relError ?
       '; targets must start with "./"' : ''}`;
   }, Error);
-E('ERR_INVALID_PERFORMANCE_MARK',
-  'The "%s" performance mark has not been set', Error);
 E('ERR_INVALID_PROTOCOL',
   'Protocol "%s" not supported. Expected "%s"',
   TypeError);

lib/internal/perf/observe.js

@@ -4,6 +4,7 @@ const {
   ArrayFrom,
   ArrayIsArray,
   ArrayPrototypeFilter,
+  ArrayPrototypeFlatMap,
   ArrayPrototypeIncludes,
   ArrayPrototypePush,
   ArrayPrototypeSlice,
@@ -82,7 +83,12 @@ const kSupportedEntryTypes = ObjectFreeze([
   'mark',
   'measure',
 ]);
+const kTimelineEntryTypes = ObjectFreeze([
+  'mark',
+  'measure',
+]);
 
+const kPerformanceEntryBuffer = new SafeMap();
 const kObservers = new SafeSet();
 const kPending = new SafeSet();
 let isPending = false;
@@ -190,6 +196,7 @@ class PerformanceObserver {
     const {
       entryTypes,
       type,
+      buffered,
     } = { ...options };
     if (entryTypes === undefined && type === undefined)
       throw new ERR_MISSING_ARGS('options.entryTypes', 'options.type');
@@ -229,6 +236,13 @@ class PerformanceObserver {
         return;
       this[kEntryTypes].add(type);
       maybeIncrementObserverCount(type);
+      if (buffered) {
+        const entries = filterBufferMapByNameAndType(undefined, type);
+        this[kBuffer].push(...entries);
+        kPending.add(this);
+        if (kPending.size)
+          queuePending();
+      }
     }
 
     if (this[kEntryTypes].size)
@@ -291,6 +305,52 @@ function enqueue(entry) {
   for (const obs of kObservers) {
     obs[kMaybeBuffer](entry);
   }
+
+  const entryType = entry.entryType;
+  if (!kTimelineEntryTypes.includes(entryType)) {
+    return;
+  }
+  const buffer = getEntryBuffer(entryType);
+  buffer.push(entry);
+}
+
+function clearEntriesFromBuffer(type, name) {
+  if (name === undefined) {
+    kPerformanceEntryBuffer.delete(type);
+    return;
+  }
+  let buffer = getEntryBuffer(type);
+  buffer = ArrayPrototypeFilter(
+    buffer,
+    (entry) => entry.name !== name);
+  kPerformanceEntryBuffer.set(type, buffer);
+}
+
+function getEntryBuffer(type) {
+  let buffer = kPerformanceEntryBuffer.get(type);
+  if (buffer === undefined) {
+    buffer = [];
+    kPerformanceEntryBuffer.set(type, buffer);
+  }
+  return buffer;
+}
+
+function filterBufferMapByNameAndType(name, type) {
+  let bufferList;
+  if (type !== undefined) {
+    bufferList = kPerformanceEntryBuffer.get(type) ?? [];
+  } else {
+    bufferList = ArrayFrom(kPerformanceEntryBuffer.values());
+  }
+  return ArrayPrototypeFlatMap(bufferList,
+                               (buffer) => filterBufferByName(buffer, name));
+}
+
+function filterBufferByName(buffer, name) {
+  if (name === undefined) {
+    return buffer;
+  }
+  return ArrayPrototypeFilter(buffer, (it) => it.name === name);
 }
 
 function observerCallback(name, type, startTime, duration, details) {
@@ -342,4 +402,6 @@ module.exports = {
   PerformanceObserver,
   enqueue,
   hasObserver,
+  clearEntriesFromBuffer,
+  filterBufferMapByNameAndType,
 };

lib/internal/perf/performance.js

@@ -16,8 +16,12 @@ const { now } = require('internal/perf/utils');
 const {
   mark,
   measure,
-  clearMarks,
+  clearMarkTimings,
 } = require('internal/perf/usertiming');
+const {
+  clearEntriesFromBuffer,
+  filterBufferMapByNameAndType,
+} = require('internal/perf/observe');
 
 const eventLoopUtilization = require('internal/perf/event_loop_utilization');
 const nodeTiming = require('internal/perf/nodetiming');
@@ -48,7 +52,6 @@ class Performance extends EventTarget {
       timeOrigin: this.timeOrigin,
     }, opts)}`;
   }
-
 }
 
 function toJSON() {
@@ -59,6 +62,39 @@ function toJSON() {
   };
 }
 
+function clearMarks(name) {
+  if (name !== undefined) {
+    name = `${name}`;
+  }
+  clearMarkTimings(name);
+  clearEntriesFromBuffer('mark', name);
+}
+
+function clearMeasures(name) {
+  if (name !== undefined) {
+    name = `${name}`;
+  }
+  clearEntriesFromBuffer('measure', name);
+}
+
+function getEntries() {
+  return filterBufferMapByNameAndType();
+}
+
+function getEntriesByName(name) {
+  if (name !== undefined) {
+    name = `${name}`;
+  }
+  return filterBufferMapByNameAndType(name, undefined);
+}
+
+function getEntriesByType(type) {
+  if (type !== undefined) {
+    type = `${type}`;
+  }
+  return filterBufferMapByNameAndType(undefined, type);
+}
+
 class InternalPerformance extends EventTarget {}
 InternalPerformance.prototype.constructor = Performance.prototype.constructor;
 ObjectSetPrototypeOf(InternalPerformance.prototype, Performance.prototype);
@@ -69,11 +105,31 @@ ObjectDefineProperties(Performance.prototype, {
     enumerable: false,
     value: clearMarks,
   },
+  clearMeasures: {
+    configurable: true,
+    enumerable: false,
+    value: clearMeasures,
+  },
   eventLoopUtilization: {
     configurable: true,
     enumerable: false,
     value: eventLoopUtilization,
   },
+  getEntries: {
+    configurable: true,
+    enumerable: false,
+    value: getEntries,
+  },
+  getEntriesByName: {
+    configurable: true,
+    enumerable: false,
+    value: getEntriesByName,
+  },
+  getEntriesByType: {
+    configurable: true,
+    enumerable: false,
+    value: getEntriesByType,
+  },
   mark: {
     configurable: true,
     enumerable: false,