lighthouse 9.5.0-dev.20220504 → 9.5.0-dev.20220507

package/lighthouse-cli/test/smokehouse/lighthouse-runners/bundle.js

@@ -8,47 +8,76 @@
  * @fileoverview  A runner that launches Chrome and executes Lighthouse via a
  * bundle to test that bundling has produced correct and runnable code.
  * Currently uses `lighthouse-dt-bundle.js`.
+ * Runs in a worker to avoid messing up marky's global state.
  */
 
 import fs from 'fs';
+import os from 'os';
+import {Worker, isMainThread, parentPort, workerData} from 'worker_threads';
+import {once} from 'events';
 
 import puppeteer from 'puppeteer-core';
 import ChromeLauncher from 'chrome-launcher';
 
 import ChromeProtocol from '../../../../lighthouse-core/gather/connections/cri.js';
 import {LH_ROOT} from '../../../../root.js';
+import {loadArtifacts, saveArtifacts} from '../../../../lighthouse-core/lib/asset-saver.js';
 
-const originalBuffer = global.Buffer;
-const originalRequire = global.require;
-if (typeof globalThis === 'undefined') {
-  // @ts-expect-error - exposing for loading of dt-bundle.
-  global.globalThis = global;
+// This runs only in the worker. The rest runs on the main thread.
+if (!isMainThread && parentPort) {
+  (async () => {
+    const {url, configJson, testRunnerOptions} = workerData;
+    try {
+      const result = await runBundledLighthouse(url, configJson, testRunnerOptions);
+      // Save to assets directory because LighthouseError won't survive postMessage.
+      const assetsDir = fs.mkdtempSync(os.tmpdir() + '/smoke-bundle-assets-');
+      await saveArtifacts(result.artifacts, assetsDir);
+      const value = {
+        lhr: result.lhr,
+        assetsDir,
+      };
+      parentPort?.postMessage({type: 'result', value});
+    } catch (err) {
+      console.error(err);
+      parentPort?.postMessage({type: 'error', value: err});
+    }
+  })();
 }
 
-// Load bundle, which creates a `global.runBundledLighthouse`.
-eval(fs.readFileSync(LH_ROOT + '/dist/lighthouse-dt-bundle.js', 'utf-8'));
-
-global.require = originalRequire;
-global.Buffer = originalBuffer;
-
-/** @type {import('../../../../lighthouse-core/index.js')} */
-// @ts-expect-error - not worth giving test global an actual type.
-const lighthouse = global.runBundledLighthouse;
-
 /**
- * Launch Chrome and do a full Lighthouse run via the Lighthouse DevTools bundle.
  * @param {string} url
- * @param {LH.Config.Json=} configJson
- * @param {{isDebug?: boolean, useFraggleRock?: boolean}=} testRunnerOptions
- * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
+ * @param {LH.Config.Json|undefined} configJson
+ * @param {{isDebug?: boolean, useFraggleRock?: boolean}} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts}>}
  */
-async function runLighthouse(url, configJson, testRunnerOptions = {}) {
+async function runBundledLighthouse(url, configJson, testRunnerOptions) {
+  if (isMainThread || !parentPort) {
+    throw new Error('must be called in worker');
+  }
+
+  const originalBuffer = global.Buffer;
+  const originalRequire = global.require;
+  if (typeof globalThis === 'undefined') {
+    // @ts-expect-error - exposing for loading of dt-bundle.
+    global.globalThis = global;
+  }
+
+  // Load bundle, which creates a `global.runBundledLighthouse`.
+  eval(fs.readFileSync(LH_ROOT + '/dist/lighthouse-dt-bundle.js', 'utf-8'));
+
+  global.require = originalRequire;
+  global.Buffer = originalBuffer;
+
+  /** @type {import('../../../../lighthouse-core/index.js')} */
+  // @ts-expect-error - not worth giving test global an actual type.
+  const lighthouse = global.runBundledLighthouse;
+
   // Launch and connect to Chrome.
   const launchedChrome = await ChromeLauncher.launch();
   const port = launchedChrome.port;
 
+  // Run Lighthouse.
   try {
-    // Run Lighthouse.
     const logLevel = testRunnerOptions.isDebug ? 'info' : undefined;
     let runnerResult;
     if (testRunnerOptions.useFraggleRock) {
@@ -66,7 +95,6 @@ async function runLighthouse(url, configJson, testRunnerOptions = {}) {
     return {
       lhr: runnerResult.lhr,
       artifacts: runnerResult.artifacts,
-      log: '', // TODO: if want to run in parallel, need to capture lighthouse-logger output.
     };
   } finally {
     // Clean up and return results.
@@ -74,6 +102,53 @@ async function runLighthouse(url, configJson, testRunnerOptions = {}) {
   }
 }
 
+/**
+ * Launch Chrome and do a full Lighthouse run via the Lighthouse DevTools bundle.
+ * @param {string} url
+ * @param {LH.Config.Json=} configJson
+ * @param {{isDebug?: boolean, useFraggleRock?: boolean}=} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
+ */
+async function runLighthouse(url, configJson, testRunnerOptions = {}) {
+  /** @type {string[]} */
+  const logs = [];
+  const worker = new Worker(new URL(import.meta.url), {
+    stdout: true,
+    stderr: true,
+    workerData: {url, configJson, testRunnerOptions},
+  });
+  worker.stdout.setEncoding('utf8');
+  worker.stderr.setEncoding('utf8');
+  worker.stdout.addListener('data', (data) => {
+    process.stdout.write(data);
+    logs.push(`STDOUT: ${data}`);
+  });
+  worker.stderr.addListener('data', (data) => {
+    process.stderr.write(data);
+    logs.push(`STDERR: ${data}`);
+  });
+  const [workerResponse] = await once(worker, 'message');
+  const log = logs.join('') + '\n';
+
+  if (workerResponse.type === 'error') {
+    new Error(`Worker returned an error: ${workerResponse.value}\nLog:\n${log}`);
+  }
+
+  const result = workerResponse.value;
+  if (!result.lhr || !result.assetsDir) {
+    throw new Error(`invalid response from worker:\n${JSON.stringify(result, null, 2)}`);
+  }
+
+  const artifacts = loadArtifacts(result.assetsDir);
+  fs.rmSync(result.assetsDir, {recursive: true});
+
+  return {
+    lhr: result.lhr,
+    artifacts,
+    log,
+  };
+}
+
 export {
   runLighthouse,
 };

package/lighthouse-cli/test/smokehouse/version-check-test.js

@@ -6,8 +6,6 @@
 
 import {chromiumVersionCheck, compareVersions} from './version-check.js';
 
-/* eslint-env jest */
-
 describe('version check', () => {
   it('compareVersions', async () => {
     expect(compareVersions([100, 0, 0, 0], [100, 0, 0, 0])).toBe(0);

package/lighthouse-core/audits/bootup-time.js

@@ -6,11 +6,11 @@
 'use strict';
 
 const Audit = require('./audit.js');
-const NetworkRequest = require('../lib/network-request.js');
 const {taskGroups} = require('../lib/tracehouse/task-groups.js');
 const i18n = require('../lib/i18n/i18n.js');
 const NetworkRecords = require('../computed/network-records.js');
 const MainThreadTasks = require('../computed/main-thread-tasks.js');
+const {getExecutionTimingsByURL} = require('../lib/tracehouse/task-summary.js');
 
 const UIStrings = {
   /** Title of a diagnostic audit that provides detail on the time spent executing javascript files during the load. This descriptive title is shown to users when the amount is acceptable and no user action is required. */
@@ -34,18 +34,6 @@ const UIStrings = {
 
 const str_ = i18n.createMessageInstanceIdFn(__filename, UIStrings);
 
-// These trace events, when not triggered by a script inside a particular task, are just general Chrome overhead.
-const BROWSER_TASK_NAMES_SET = new Set([
-  'CpuProfiler::StartProfiling',
-]);
-
-// These trace events, when not triggered by a script inside a particular task, are GC Chrome overhead.
-const BROWSER_GC_TASK_NAMES_SET = new Set([
-  'V8.GCCompactor',
-  'MajorGC',
-  'MinorGC',
-]);
-
 class BootupTime extends Audit {
   /**
    * @return {LH.Audit.Meta}
@@ -74,61 +62,6 @@ class BootupTime extends Audit {
     };
   }
 
-  /**
-   * @param {LH.Artifacts.NetworkRequest[]} records
-   */
-  static getJavaScriptURLs(records) {
-    /** @type {Set<string>} */
-    const urls = new Set();
-    for (const record of records) {
-      if (record.resourceType === NetworkRequest.TYPES.Script) {
-        urls.add(record.url);
-      }
-    }
-
-    return urls;
-  }
-
-  /**
-   * @param {LH.Artifacts.TaskNode} task
-   * @param {Set<string>} jsURLs
-   * @return {string}
-   */
-  static getAttributableURLForTask(task, jsURLs) {
-    const jsURL = task.attributableURLs.find(url => jsURLs.has(url));
-    const fallbackURL = task.attributableURLs[0];
-    let attributableURL = jsURL || fallbackURL;
-    // If we can't find what URL was responsible for this execution, attribute it to the root page
-    // or Chrome depending on the type of work.
-    if (!attributableURL || attributableURL === 'about:blank') {
-      if (BROWSER_TASK_NAMES_SET.has(task.event.name)) attributableURL = 'Browser';
-      else if (BROWSER_GC_TASK_NAMES_SET.has(task.event.name)) attributableURL = 'Browser GC';
-      else attributableURL = 'Unattributable';
-    }
-
-    return attributableURL;
-  }
-
-  /**
-   * @param {LH.Artifacts.TaskNode[]} tasks
-   * @param {Set<string>} jsURLs
-   * @return {Map<string, Object<string, number>>}
-   */
-  static getExecutionTimingsByURL(tasks, jsURLs) {
-    /** @type {Map<string, Object<string, number>>} */
-    const result = new Map();
-
-    for (const task of tasks) {
-      const attributableURL = BootupTime.getAttributableURLForTask(task, jsURLs);
-      const timingByGroupId = result.get(attributableURL) || {};
-      const originalTime = timingByGroupId[task.group.id] || 0;
-      timingByGroupId[task.group.id] = originalTime + task.selfTime;
-      result.set(attributableURL, timingByGroupId);
-    }
-
-    return result;
-  }
-
   /**
    * @param {LH.Artifacts} artifacts
    * @param {LH.Audit.Context} context
@@ -143,8 +76,7 @@ class BootupTime extends Audit {
     const multiplier = settings.throttlingMethod === 'simulate' ?
       settings.throttling.cpuSlowdownMultiplier : 1;
 
-    const jsURLs = BootupTime.getJavaScriptURLs(networkRecords);
-    const executionTimings = BootupTime.getExecutionTimingsByURL(tasks, jsURLs);
+    const executionTimings = getExecutionTimingsByURL(tasks, networkRecords);
 
     let hadExcessiveChromeExtension = false;
     let totalBootupTime = 0;

package/lighthouse-core/audits/long-tasks.js

@@ -9,9 +9,9 @@ const Audit = require('./audit.js');
 const NetworkRecords = require('../computed/network-records.js');
 const i18n = require('../lib/i18n/i18n.js');
 const MainThreadTasks = require('../computed/main-thread-tasks.js');
-const BootupTime = require('./bootup-time.js');
 const PageDependencyGraph = require('../computed/page-dependency-graph.js');
 const LoadSimulator = require('../computed/load-simulator.js');
+const {getJavaScriptURLs, getAttributableURLForTask} = require('../lib/tracehouse/task-summary.js');
 
 /** We don't always have timing data for short tasks, if we're missing timing data. Treat it as though it were 0ms. */
 const DEFAULT_TIMING = {startTime: 0, endTime: 0, duration: 0};
@@ -78,7 +78,7 @@ class LongTasks extends Audit {
       }
     }
 
-    const jsURLs = BootupTime.getJavaScriptURLs(networkRecords);
+    const jsURLs = getJavaScriptURLs(networkRecords);
     // Only consider up to 20 long, top-level (no parent) tasks that have an explicit endTime
     const longtasks = tasks
       .map(t => {
@@ -91,7 +91,7 @@ class LongTasks extends Audit {
 
     // TODO(beytoven): Add start time that matches with the simulated throttling
     const results = longtasks.map(task => ({
-      url: BootupTime.getAttributableURLForTask(task, jsURLs),
+      url: getAttributableURLForTask(task, jsURLs),
       duration: task.duration,
       startTime: task.startTime,
     }));

package/lighthouse-core/audits/metrics/experimental-interaction-to-next-paint.js

@@ -63,19 +63,21 @@ class ExperimentalInteractionToNextPaint extends Audit {
 
     const trace = artifacts.traces[Audit.DEFAULT_PASS];
     const metricData = {trace, settings};
-    const metricResult = await ComputedResponsivenes.request(metricData, context);
+    const responsivenessEvent = await ComputedResponsivenes.request(metricData, context);
 
     // TODO: include the no-interaction state in the report instead of using n/a.
-    if (metricResult === null) {
+    if (responsivenessEvent === null) {
       return {score: null, notApplicable: true};
     }
 
+    const timing = responsivenessEvent.args.data.maxDuration;
+
     return {
       score: Audit.computeLogNormalScore({p10: context.options.p10, median: context.options.median},
-        metricResult.timing),
-      numericValue: metricResult.timing,
+        timing),
+      numericValue: timing,
       numericUnit: 'millisecond',
-      displayValue: str_(i18n.UIStrings.ms, {timeInMs: metricResult.timing}),
+      displayValue: str_(i18n.UIStrings.ms, {timeInMs: timing}),
     };
   }
 }

package/lighthouse-core/audits/third-party-summary.js

@@ -6,11 +6,11 @@
 'use strict';
 
 const Audit = require('./audit.js');
-const BootupTime = require('./bootup-time.js');
 const i18n = require('../lib/i18n/i18n.js');
 const thirdPartyWeb = require('../lib/third-party-web.js');
 const NetworkRecords = require('../computed/network-records.js');
 const MainThreadTasks = require('../computed/main-thread-tasks.js');
+const {getJavaScriptURLs, getAttributableURLForTask} = require('../lib/tracehouse/task-summary.js');
 
 const UIStrings = {
   /** Title of a diagnostic audit that provides details about the code on a web page that the user doesn't control (referred to as "third-party code"). This descriptive title is shown to users when the amount is acceptable and no user action is required. */
@@ -98,10 +98,10 @@ class ThirdPartySummary extends Audit {
       byURL.set(request.url, urlSummary);
     }
 
-    const jsURLs = BootupTime.getJavaScriptURLs(networkRecords);
+    const jsURLs = getJavaScriptURLs(networkRecords);
 
     for (const task of mainThreadTasks) {
-      const attributableURL = BootupTime.getAttributableURLForTask(task, jsURLs);
+      const attributableURL = getAttributableURLForTask(task, jsURLs);
 
       const urlSummary = byURL.get(attributableURL) || {...defaultSummary};
       const taskDuration = task.selfTime * cpuMultiplier;

package/lighthouse-core/computed/metrics/responsiveness.js

@@ -11,24 +11,25 @@
  * user input in the provided trace).
  */
 
+/** @typedef {LH.Trace.CompleteEvent & {name: 'Responsiveness.Renderer.UserInteraction', args: {frame: string, data: {interactionType: 'drag'|'keyboard'|'tapOrClick', maxDuration: number}}}} ResponsivenessEvent */
+
 const makeComputedArtifact = require('../computed-artifact.js');
 const ProcessedTrace = require('../processed-trace.js');
 
 class Responsiveness {
   /**
    * @param {LH.Artifacts.ProcessedTrace} processedTrace
-   * @return {{timing: number}|null}
+   * @return {ResponsivenessEvent|null}
    */
   static getHighPercentileResponsiveness(processedTrace) {
-    const durations = processedTrace.frameTreeEvents
+    const responsivenessEvents = processedTrace.frameTreeEvents
       // https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/timing/responsiveness_metrics.cc;l=146-150;drc=a1a2302f30b0a58f7669a41c80acdf1fa11958dd
-      .filter(e => e.name === 'Responsiveness.Renderer.UserInteraction')
-      .map(evt => evt.args.data?.maxDuration)
-      .filter(/** @return {duration is number} */duration => duration !== undefined)
-      .sort((a, b) => b - a);
+      .filter(/** @return {e is ResponsivenessEvent} */ e => {
+        return e.name === 'Responsiveness.Renderer.UserInteraction';
+      }).sort((a, b) => b.args.data.maxDuration - a.args.data.maxDuration);
 
     // If there were no interactions with the page, the metric is N/A.
-    if (durations.length === 0) {
+    if (responsivenessEvents.length === 0) {
       return null;
     }
 
@@ -36,17 +37,15 @@ class Responsiveness {
     // keeps the 10 worst events around, so it can never be more than the 10th from
     // last array element. To keep things simpler, sort desc and pick from front.
     // See https://source.chromium.org/chromium/chromium/src/+/main:components/page_load_metrics/browser/responsiveness_metrics_normalization.cc;l=45-59;drc=cb0f9c8b559d9c7c3cb4ca94fc1118cc015d38ad
-    const index = Math.min(9, Math.floor(durations.length / 50));
+    const index = Math.min(9, Math.floor(responsivenessEvents.length / 50));
 
-    return {
-      timing: durations[index],
-    };
+    return responsivenessEvents[index];
   }
 
   /**
    * @param {{trace: LH.Trace, settings: Immutable<LH.Config.Settings>}} data
    * @param {LH.Artifacts.ComputedContext} context
-   * @return {Promise<LH.Artifacts.Metric|null>}
+   * @return {Promise<ResponsivenessEvent|null>}
    */
   static async compute_(data, context) {
     if (data.settings.throttlingMethod === 'simulate') {
@@ -54,7 +53,9 @@ class Responsiveness {
     }
 
     const processedTrace = await ProcessedTrace.request(data.trace, context);
-    return Responsiveness.getHighPercentileResponsiveness(processedTrace);
+    const event = Responsiveness.getHighPercentileResponsiveness(processedTrace);
+
+    return JSON.parse(JSON.stringify(event));
   }
 }
 

package/lighthouse-core/fraggle-rock/gather/driver.js

@@ -74,7 +74,7 @@ class Driver {
     const session = await this._page.target().createCDPSession();
     this._session = this.defaultSession = new ProtocolSession(session);
     this._executionContext = new ExecutionContext(this._session);
-    this._fetcher = new Fetcher(this._session, this._executionContext);
+    this._fetcher = new Fetcher(this._session);
     log.timeEnd(status);
   }
 

package/lighthouse-core/gather/driver.js

@@ -64,7 +64,7 @@ class Driver {
   defaultSession = this;
 
   // eslint-disable-next-line no-invalid-this
-  fetcher = new Fetcher(this.defaultSession, this.executionContext);
+  fetcher = new Fetcher(this.defaultSession);
 
   /**
    * @param {Connection} connection