lighthouse 9.5.0-dev.20230124 → 9.5.0-dev.20230125

package/core/lib/network-request.js

@@ -125,6 +125,8 @@ class NetworkRequest {
     this.parsedURL = /** @type {ParsedURL} */ ({scheme: ''});
     this.documentURL = '';
 
+    /** When the renderer process initially discovers a network request, in milliseconds. */
+    this.rendererStartTime = -1;
     /**
      * When the network service is about to handle a request, ie. just before going to the
      * HTTP cache or going to the network for DNS/connection setup, in milliseconds.
@@ -222,6 +224,7 @@ class NetworkRequest {
     };
     this.isSecure = UrlUtils.isSecureScheme(this.parsedURL.scheme);
 
+    this.rendererStartTime = data.timestamp * 1000;
     // Expected to be overriden with better value in `_recomputeTimesWithResourceTiming`.
     this.startTime = data.timestamp * 1000;
 

package/core/lib/stack-packs.js

@@ -19,6 +19,10 @@ const stackPacksToInclude = [
     packId: 'wordpress',
     requiredStacks: ['js:wordpress'],
   },
+  {
+    packId: 'wp-rocket',
+    requiredStacks: ['js:wp-rocket'],
+  },
   {
     packId: 'ezoic',
     requiredStacks: ['js:ezoic'],

package/core/lib/tracehouse/trace-processor.d.ts

@@ -148,13 +148,22 @@ export class TraceProcessor {
     static getMainThreadTopLevelEvents(trace: LH.Artifacts.ProcessedTrace, startTime?: number | undefined, endTime?: number | undefined): Array<ToplevelEvent>;
     /**
      * @param {LH.TraceEvent[]} events
-     * @return {{pid: number, tid: number, frameId: string}}
+     * @return {{startingPid: number, frameId: string}}
      */
     static findMainFrameIds(events: LH.TraceEvent[]): {
-        pid: number;
-        tid: number;
+        startingPid: number;
         frameId: string;
     };
+    /**
+     * If there were any cross-origin navigations, there'll be more than one pid returned
+     * @param {{startingPid: number, frameId: string}} mainFrameInfo
+     * @param {LH.TraceEvent[]} keyEvents
+     * @return {Map<number, number>} Map where keys are process IDs and their values are thread IDs
+     */
+    static findMainFramePidTids(mainFrameInfo: {
+        startingPid: number;
+        frameId: string;
+    }, keyEvents: LH.TraceEvent[]): Map<number, number>;
     /**
      * @param {LH.TraceEvent} evt
      * @return {boolean}
@@ -239,14 +248,14 @@ export class TraceProcessor {
      *      Can also be skewed by several hundred milliseconds or even seconds when the browser takes a long
      *      time to unload `about:blank`.
      *
-     * @param {{keyEvents: Array<LH.TraceEvent>, frameEvents: Array<LH.TraceEvent>, mainFrameIds: {frameId: string}}} traceEventSubsets
+     * @param {{keyEvents: Array<LH.TraceEvent>, frameEvents: Array<LH.TraceEvent>, mainFrameInfo: {frameId: string}}} traceEventSubsets
      * @param {TimeOriginDeterminationMethod} method
      * @return {LH.TraceEvent}
      */
     static computeTimeOrigin(traceEventSubsets: {
         keyEvents: Array<LH.TraceEvent>;
         frameEvents: Array<LH.TraceEvent>;
-        mainFrameIds: {
+        mainFrameInfo: {
             frameId: string;
         };
     }, method: TimeOriginDeterminationMethod): LH.TraceEvent;

package/core/lib/tracehouse/trace-processor.js

@@ -423,7 +423,7 @@ class TraceProcessor {
 
   /**
    * @param {LH.TraceEvent[]} events
-   * @return {{pid: number, tid: number, frameId: string}}
+   * @return {{startingPid: number, frameId: string}}
    */
   static findMainFrameIds(events) {
     // Prefer the newer TracingStartedInBrowser event first, if it exists
@@ -433,14 +433,9 @@ class TraceProcessor {
       const frameId = mainFrame?.frame;
       const pid = mainFrame?.processId;
 
-      const threadNameEvt = events.find(e => e.pid === pid && e.ph === 'M' &&
-        e.cat === '__metadata' && e.name === 'thread_name' && e.args.name === 'CrRendererMain');
-      const tid = threadNameEvt?.tid;
-
-      if (pid && tid && frameId) {
+      if (pid && frameId) {
         return {
-          pid,
-          tid,
+          startingPid: pid,
           frameId,
         };
       }
@@ -454,8 +449,7 @@ class TraceProcessor {
       const frameId = startedInPageEvt.args.data.page;
       if (frameId) {
         return {
-          pid: startedInPageEvt.pid,
-          tid: startedInPageEvt.tid,
+          startingPid: startedInPageEvt.pid,
           frameId,
         };
       }
@@ -478,8 +472,7 @@ class TraceProcessor {
       const frameId = navStartEvt.args.frame;
       if (frameId) {
         return {
-          pid: navStartEvt.pid,
-          tid: navStartEvt.tid,
+          startingPid: navStartEvt.pid,
           frameId,
         };
       }
@@ -488,6 +481,47 @@ class TraceProcessor {
     throw this.createNoTracingStartedError();
   }
 
+  /**
+   * If there were any cross-origin navigations, there'll be more than one pid returned
+   * @param {{startingPid: number, frameId: string}} mainFrameInfo
+   * @param {LH.TraceEvent[]} keyEvents
+   * @return {Map<number, number>} Map where keys are process IDs and their values are thread IDs
+   */
+  static findMainFramePidTids(mainFrameInfo, keyEvents) {
+    const frameCommittedEvts = keyEvents.filter(evt =>
+      evt.name === 'FrameCommittedInBrowser' &&
+      evt.args?.data?.frame === mainFrameInfo.frameId
+    );
+
+    // "Modern" traces with a navigation have a FrameCommittedInBrowser event
+    const mainFramePids = frameCommittedEvts.length
+      ? frameCommittedEvts.map(e => e?.args?.data?.processId)
+      // …But old traces and some timespan traces may not. In these situations, we'll assume the
+      // primary process ID remains constant (as there were no navigations).
+      : [mainFrameInfo.startingPid];
+
+    const pidToTid = new Map();
+
+    mainFramePids.forEach(pid => {
+      // While renderer tids are generally predictable, we'll doublecheck it
+      const threadNameEvt = keyEvents.find(e =>
+        e.cat === '__metadata' &&
+        e.pid === pid &&
+        e.ph === 'M' &&
+        e.name === 'thread_name' &&
+        e.args.name === 'CrRendererMain'
+      );
+      const tid = threadNameEvt?.tid;
+
+      if (!tid) {
+        throw new Error('Unable to determine tid for renderer process');
+      }
+
+      pidToTid.set(pid, tid);
+    });
+    return pidToTid;
+  }
+
   /**
    * @param {LH.TraceEvent} evt
    * @return {boolean}
@@ -583,6 +617,9 @@ class TraceProcessor {
       while (parentFrames.has(cur)) {
         cur = /** @type {string} */ (parentFrames.get(cur));
       }
+      if (cur === undefined) {
+        throw new Error('Unexpected undefined frameId');
+      }
       frameIdToRootFrameId.set(frame.id, cur);
     }
 
@@ -609,7 +646,15 @@ class TraceProcessor {
     });
 
     // Find the inspected frame
-    const mainFrameIds = this.findMainFrameIds(keyEvents);
+    const mainFrameInfo = this.findMainFrameIds(keyEvents);
+    const rendererPidToTid = this.findMainFramePidTids(mainFrameInfo, keyEvents);
+
+    // Subset all trace events to just our tab's process (incl threads other than main)
+    // stable-sort events to keep them correctly nested.
+    const processEvents = TraceProcessor
+      .filteredTraceSort(trace.traceEvents, e => rendererPidToTid.has(e.pid));
+
+    // TODO(paulirish): filter down frames (and subsequent actions) to the primary process tree & frame tree
 
     /** @type {Map<string, {id: string, url: string, parent?: string}>} */
     const framesById = new Map();
@@ -645,18 +690,32 @@ class TraceProcessor {
           parent: evt.args.data.parent,
         });
       });
+
     const frames = [...framesById.values()];
     const frameIdToRootFrameId = this.resolveRootFrames(frames);
 
+    const inspectedTreeFrameIds = [...frameIdToRootFrameId.entries()]
+      .filter(([, rootFrameId]) => rootFrameId === mainFrameInfo.frameId)
+      .map(([child]) => child);
+
     // Filter to just events matching the main frame ID, just to make sure.
-    const frameEvents = keyEvents.filter(e => e.args.frame === mainFrameIds.frameId);
+    /** @param {LH.TraceEvent} e */
+    function associatedToMainFrame(e) {
+      const frameId = e.args?.data?.frame || e.args.frame;
+      return frameId === mainFrameInfo.frameId;
+    }
+
+    /** @param {LH.TraceEvent} e */
+    function associatedToAllFrames(e) {
+      const frameId = e.args?.data?.frame || e.args.frame;
+      return frameId ? inspectedTreeFrameIds.includes(frameId) : false;
+    }
+    const frameEvents = keyEvents.filter(e => associatedToMainFrame(e));
 
     // Filter to just events matching the main frame ID or any child frame IDs.
     let frameTreeEvents = [];
-    if (frameIdToRootFrameId.has(mainFrameIds.frameId)) {
-      frameTreeEvents = keyEvents.filter(e => {
-        return e.args.frame && frameIdToRootFrameId.get(e.args.frame) === mainFrameIds.frameId;
-      });
+    if (frameIdToRootFrameId.has(mainFrameInfo.frameId)) {
+      frameTreeEvents = keyEvents.filter(e => associatedToAllFrames(e));
     } else {
       // In practice, there should always be TracingStartedInBrowser/FrameCommittedInBrowser events to
       // define the frame tree. Unfortunately, many test traces do not that frame info due to minification.
@@ -665,23 +724,17 @@ class TraceProcessor {
         'TraceProcessor',
         'frameTreeEvents may be incomplete, make sure the trace has frame events'
       );
-      frameIdToRootFrameId.set(mainFrameIds.frameId, mainFrameIds.frameId);
+      frameIdToRootFrameId.set(mainFrameInfo.frameId, mainFrameInfo.frameId);
       frameTreeEvents = frameEvents;
     }
 
     // Compute our time origin to use for all relative timings.
     const timeOriginEvt = this.computeTimeOrigin(
-      {keyEvents, frameEvents, mainFrameIds},
+      {keyEvents, frameEvents, mainFrameInfo: mainFrameInfo},
       timeOriginDeterminationMethod
     );
 
-    // Subset all trace events to just our tab's process (incl threads other than main)
-    // stable-sort events to keep them correctly nested.
-    const processEvents = TraceProcessor
-      .filteredTraceSort(trace.traceEvents, e => e.pid === mainFrameIds.pid);
-
-    const mainThreadEvents = processEvents
-      .filter(e => e.tid === mainFrameIds.tid);
+    const mainThreadEvents = processEvents.filter(e => e.tid === rendererPidToTid.get(e.pid));
 
     // Ensure our traceEnd reflects all page activity.
     const traceEnd = this.computeTraceEnd(trace.traceEvents, timeOriginEvt);
@@ -694,7 +747,7 @@ class TraceProcessor {
       frameEvents,
       frameTreeEvents,
       processEvents,
-      mainFrameIds,
+      mainFrameInfo,
       timeOriginEvt,
       timings: {
         timeOrigin: 0,
@@ -704,6 +757,8 @@ class TraceProcessor {
         timeOrigin: timeOriginEvt.ts,
         traceEnd: traceEnd.timestamp,
       },
+      _keyEvents: keyEvents,
+      _rendererPidToTid: rendererPidToTid,
     };
   }
 
@@ -807,7 +862,7 @@ class TraceProcessor {
    *      Can also be skewed by several hundred milliseconds or even seconds when the browser takes a long
    *      time to unload `about:blank`.
    *
-   * @param {{keyEvents: Array<LH.TraceEvent>, frameEvents: Array<LH.TraceEvent>, mainFrameIds: {frameId: string}}} traceEventSubsets
+   * @param {{keyEvents: Array<LH.TraceEvent>, frameEvents: Array<LH.TraceEvent>, mainFrameInfo: {frameId: string}}} traceEventSubsets
    * @param {TimeOriginDeterminationMethod} method
    * @return {LH.TraceEvent}
    */
@@ -833,7 +888,7 @@ class TraceProcessor {
         const fetchStart = traceEventSubsets.keyEvents.find(event => {
           if (event.name !== 'ResourceSendRequest') return false;
           const data = event.args.data || {};
-          return data.frame === traceEventSubsets.mainFrameIds.frameId;
+          return data.frame === traceEventSubsets.mainFrameInfo.frameId;
         });
         if (!fetchStart) throw this.createNoResourceSendRequestError();
         return fetchStart;

package/core/lib/traces/metric-trace-events.js

@@ -128,7 +128,7 @@ class MetricTraceEvents {
     if (!timeOriginMetric) return {errorMessage: 'timeorigin Metric not found in definitions'};
     try {
       const frameIds = TraceProcessor.findMainFrameIds(this._traceEvents);
-      return {pid: frameIds.pid, tid: frameIds.tid, ts: timeOriginMetric.ts};
+      return {pid: frameIds.startingPid, tid: 1, ts: timeOriginMetric.ts};
     } catch (err) {
       return {errorMessage: err.message};
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "9.5.0-dev.20230124",
+  "version": "9.5.0-dev.20230125",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {
@@ -86,7 +86,6 @@
     "diff:sample-json": "yarn i18n:checks && bash core/scripts/assert-golden-lhr-unchanged.sh",
     "diff:flow-sample-json": "yarn i18n:collect-strings && bash core/scripts/assert-baseline-flow-result-unchanged.sh",
     "computeBenchmarkIndex": "./core/scripts/benchmark.js",
-    "minify-latest-run": "./core/scripts/lantern/minify-trace.js ./latest-run/defaultPass.trace.json ./latest-run/defaultPass.trace.min.json && ./core/scripts/lantern/minify-devtoolslog.js ./latest-run/defaultPass.devtoolslog.json ./latest-run/defaultPass.devtoolslog.min.json",
     "save-latest-run": "./core/scripts/save-latest-run.sh",
     "compile-proto": "protoc --python_out=./ ./proto/lighthouse-result.proto && mv ./proto/*_pb2.py ./proto/scripts || (echo \"❌ Install protobuf = 3.20.x to compile the proto file.\" && false)",
     "build-proto-roundtrip": "mkdir -p .tmp && python3 proto/scripts/json_roundtrip_via_proto.py",
@@ -187,7 +186,7 @@
   },
   "dependencies": {
     "@sentry/node": "^6.17.4",
-    "axe-core": "4.4.1",
+    "axe-core": "4.6.3",
     "chrome-launcher": "^0.15.1",
     "configstore": "^5.0.1",
     "csp_evaluator": "1.1.1",
@@ -195,9 +194,9 @@
     "http-link-header": "^0.8.0",
     "intl-messageformat": "^4.4.0",
     "jpeg-js": "^0.4.4",
-    "js-library-detector": "^6.5.0",
+    "js-library-detector": "^6.6.0",
     "lighthouse-logger": "^1.3.0",
-    "lighthouse-stack-packs": "1.8.2",
+    "lighthouse-stack-packs": "1.9.0",
     "lodash": "^4.17.21",
     "lookup-closest-locale": "6.2.0",
     "metaviewport-parser": "0.3.0",