lighthouse 11.7.0 → 12.0.0-dev.20240422

package/core/lib/network-request.d.ts

@@ -247,6 +247,7 @@ export class NetworkRequest {
      * is passed in via X-Headers similar to 'X-TotalFetchedSize'.
      */
     _updateTimingsForLightrider(): void;
+    serverResponseTime: number | undefined;
 }
 export namespace NetworkRequest {
     export { HEADER_TCP };

package/core/lib/network-request.js

@@ -536,6 +536,7 @@ class NetworkRequest {
       requestMs: requestMs,
       responseMs: responseMs,
     };
+    this.serverResponseTime = responseMs;
   }
 
   /**
@@ -574,8 +575,35 @@ class NetworkRequest {
    * @return {Lantern.NetworkRequest<NetworkRequest>}
    */
   static asLanternNetworkRequest(record) {
+    // In LR, network records are missing connection timing, but we've smuggled it in via headers.
+    let timing = record.timing;
+    let serverResponseTime;
+    if (global.isLightrider && record.lrStatistics) {
+      if (record.protocol.startsWith('h3')) {
+        // @ts-expect-error We don't need all the properties set.
+        timing = {
+          connectStart: 0,
+          connectEnd: record.lrStatistics.TCPMs,
+        };
+      } else {
+        // @ts-expect-error We don't need all the properties set.
+        timing = {
+          connectStart: 0,
+          sslStart: record.lrStatistics.TCPMs / 2,
+          connectEnd: record.lrStatistics.TCPMs,
+          sslEnd: record.lrStatistics.TCPMs,
+        };
+
+        // Lightrider does not have timings for sendEnd, but we do have this timing which should be
+        // close to the response time.
+        serverResponseTime = record.lrStatistics.requestMs;
+      }
+    }
+
     return {
       ...record,
+      timing,
+      serverResponseTime,
       record,
     };
   }
@@ -634,7 +662,7 @@ class NetworkRequest {
       /^content-encoding$/i,
       /^x-content-encoding-over-network$/i,
     ];
-    const compressionTypes = ['gzip', 'br', 'deflate'];
+    const compressionTypes = ['gzip', 'br', 'deflate', 'zstd'];
     return record.responseHeaders.some(header =>
       patterns.some(p => header.name.match(p)) && compressionTypes.includes(header.value)
     );

package/core/lib/proto-preprocessor.js

@@ -83,28 +83,44 @@ function processForProto(lhr) {
   }
 
   /**
-   * Remove any found empty strings, as they are dropped after round-tripping anyway
+   * Execute `cb(obj, key)` on every object property where obj[key] is a string, recursively.
    * @param {any} obj
+   * @param {(obj: Record<string, string>, key: string) => void} cb
    */
-  function removeStrings(obj) {
+  function iterateStrings(obj, cb) {
     if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
       Object.keys(obj).forEach(key => {
-        if (typeof obj[key] === 'string' && obj[key] === '') {
-          delete obj[key];
-        } else if (typeof obj[key] === 'object' || Array.isArray(obj[key])) {
-          removeStrings(obj[key]);
+        if (typeof obj[key] === 'string') {
+          cb(obj, key);
+        } else {
+          iterateStrings(obj[key], cb);
         }
       });
     } else if (Array.isArray(obj)) {
       obj.forEach(item => {
         if (typeof item === 'object' || Array.isArray(item)) {
-          removeStrings(item);
+          iterateStrings(item, cb);
         }
       });
     }
   }
 
-  removeStrings(reportJson);
+  iterateStrings(reportJson, (obj, key) => {
+    const value = obj[key];
+
+    // Remove empty strings, as they are dropped after round-tripping anyway.
+    if (value === '') {
+      delete obj[key];
+      return;
+    }
+
+    // Sanitize lone surrogates.
+    // @ts-expect-error node 20
+    if (String.prototype.isWellFormed && !value.isWellFormed()) {
+      // @ts-expect-error node 20
+      obj[key] = value.toWellFormed();
+    }
+  });
 
   return reportJson;
 }

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

@@ -403,6 +403,9 @@ class TraceProcessor {
    */
   static getMainThreadTopLevelEvents(trace, startTime = 0, endTime = Infinity) {
     const topLevelEvents = [];
+    /** @type {ToplevelEvent|undefined} */
+    let prevToplevel = undefined;
+
     // note: mainThreadEvents is already sorted by event start
     for (const event of trace.mainThreadEvents) {
       if (!this.isScheduleableTask(event) || !event.dur) continue;
@@ -411,11 +414,21 @@ class TraceProcessor {
       const end = (event.ts + event.dur - trace.timeOriginEvt.ts) / 1000;
       if (start > endTime || end < startTime) continue;
 
-      topLevelEvents.push({
+      // Temporary fix for a Chrome bug where some RunTask events can be overlapping.
+      // We correct that here be ensuring each RunTask ends at least 1 microsecond before the next
+      // https://github.com/GoogleChrome/lighthouse/issues/15896
+      // https://issues.chromium.org/issues/329678173
+      if (prevToplevel && start < prevToplevel.end) {
+        prevToplevel.end = start - 0.001;
+      }
+
+      prevToplevel = {
         start,
         end,
         duration: event.dur / 1000,
-      });
+      };
+
+      topLevelEvents.push(prevToplevel);
     }
 
     return topLevelEvents;

package/core/runner.js

@@ -106,7 +106,6 @@ class Runner {
           networkUserAgent: artifacts.NetworkUserAgent,
           hostUserAgent: artifacts.HostUserAgent,
           benchmarkIndex: artifacts.BenchmarkIndex,
-          benchmarkIndexes: artifacts.BenchmarkIndexes,
           credits,
         },
         audits: auditResultsById,
@@ -199,32 +198,27 @@ class Runner {
         data: sentryContext,
       });
 
-      /** @type {LH.Artifacts} */
-      let artifacts;
       if (settings.auditMode && !settings.gatherMode) {
         // No browser required, just load the artifacts from disk.
         const path = this._getDataSavePath(settings);
-        artifacts = assetSaver.loadArtifacts(path);
-      } else {
-        const runnerStatus = {msg: 'Gather phase', id: 'lh:runner:gather'};
-        log.time(runnerStatus, 'verbose');
-
-        artifacts = await gatherFn({
-          resolvedConfig: options.resolvedConfig,
-        });
-
-        log.timeEnd(runnerStatus);
-
-        // If `gather` is run multiple times before `audit`, the timing entries for each `gather` can pollute one another.
-        // We need to clear the timing entries at the end of gathering.
-        // Set artifacts.Timing again to ensure lh:runner:gather is included.
-        artifacts.Timing = log.takeTimeEntries();
-
-        // -G means save these to disk (e.g. ./latest-run).
-        if (settings.gatherMode) {
-          const path = this._getDataSavePath(settings);
-          await assetSaver.saveArtifacts(artifacts, path);
-        }
+        return assetSaver.loadArtifacts(path);
+      }
+
+      const runnerStatus = {msg: 'Gather phase', id: 'lh:runner:gather'};
+      log.time(runnerStatus, 'verbose');
+
+      const artifacts = await gatherFn({resolvedConfig: options.resolvedConfig});
+      log.timeEnd(runnerStatus);
+
+      // If `gather` is run multiple times before `audit`, the timing entries for each `gather` can pollute one another.
+      // We need to clear the timing entries at the end of gathering.
+      // Set artifacts.Timing again to ensure lh:runner:gather is included.
+      artifacts.Timing = log.takeTimeEntries();
+
+      // -G means save these to disk (e.g. ./latest-run).
+      if (settings.gatherMode) {
+        const path = this._getDataSavePath(settings);
+        await assetSaver.saveArtifacts(artifacts, path);
       }
 
       return artifacts;
@@ -304,7 +298,6 @@ class Runner {
         auditMode: undefined,
         output: undefined,
         channel: undefined,
-        budgets: undefined,
       };
       const normalizedGatherSettings = Object.assign({}, artifacts.settings, overrides);
       const normalizedAuditSettings = Object.assign({}, settings, overrides);