lighthouse 10.3.0-dev.20230709 → 10.4.0

package/cli/test/smokehouse/frontends/smokehouse-bin.js

@@ -25,6 +25,8 @@ import {runSmokehouse, getShardedDefinitions} from '../smokehouse.js';
 import {updateTestDefnFormat} from './back-compat-util.js';
 import {LH_ROOT} from '../../../../root.js';
 import exclusions from '../config/exclusions.js';
+import {saveArtifacts} from '../../../../core/lib/asset-saver.js';
+import {saveLhr} from '../../../../core/lib/asset-saver.js';
 
 const coreTestDefnsPath =
   path.join(LH_ROOT, 'cli/test/smokehouse/core-tests.js');
@@ -230,19 +232,23 @@ async function begin() {
   if (!smokehouseResult.success) {
     const failedTestResults = smokehouseResult.testResults.filter(r => r.failed);
 
-    // For CI, save failed runs to directory to be uploaded.
-    if (process.env.CI) {
-      const failuresDir = `${LH_ROOT}/.tmp/smokehouse-ci-failures`;
-      fs.mkdirSync(failuresDir, {recursive: true});
-
-      for (const testResult of failedTestResults) {
-        for (let i = 0; i < testResult.runs.length; i++) {
-          const run = testResult.runs[i];
-          fs.writeFileSync(`${failuresDir}/${testResult.id}-${i}.json`, JSON.stringify({
-            ...run,
-            lighthouseLog: run.lighthouseLog.split('\n'),
-            assertionLog: run.assertionLog.split('\n'),
-          }, null, 2));
+    // Save failed runs to directory. In CI, this is uploaded as an artifact.
+    const failuresDir = `${LH_ROOT}/.tmp/smokehouse-failures`;
+    fs.rmSync(failuresDir, {recursive: true, force: true});
+    fs.mkdirSync(failuresDir);
+
+    for (const testResult of failedTestResults) {
+      for (let i = 0; i < testResult.runs.length; i++) {
+        const runDir = `${failuresDir}/${i}/${testResult.id}`;
+        fs.mkdirSync(runDir, {recursive: true});
+
+        const run = testResult.runs[i];
+        await saveArtifacts(run.artifacts, runDir);
+        await saveLhr(run.lhr, runDir);
+        fs.writeFileSync(`${runDir}/assertionLog.txt`, run.assertionLog);
+        fs.writeFileSync(`${runDir}/lighthouseLog.txt`, run.lighthouseLog);
+        if (run.networkRequests) {
+          fs.writeFileSync(`${runDir}/networkRequests.txt`, run.networkRequests.join('\n'));
         }
       }
     }

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

@@ -82,7 +82,7 @@ async function runBundledLighthouse(url, config, testRunnerOptions) {
 
   // Run Lighthouse.
   try {
-    const logLevel = testRunnerOptions.isDebug ? 'info' : undefined;
+    const logLevel = testRunnerOptions.isDebug ? 'verbose' : 'info';
     let runnerResult;
     if (testRunnerOptions.useLegacyNavigation) {
       const connection = new CriConnection(port);
@@ -124,12 +124,10 @@ async function runLighthouse(url, config, testRunnerOptions = {}) {
   worker.stdout.setEncoding('utf8');
   worker.stderr.setEncoding('utf8');
   worker.stdout.addListener('data', (data) => {
-    process.stdout.write(data);
-    logs.push(`STDOUT: ${data}`);
+    logs.push(`[STDOUT] ${data}`);
   });
   worker.stderr.addListener('data', (data) => {
-    process.stderr.write(data);
-    logs.push(`STDERR: ${data}`);
+    logs.push(`[STDERR] ${data}`);
   });
   const [workerResponse] = await once(worker, 'message');
   const log = logs.join('') + '\n';

package/core/audits/long-tasks.d.ts

@@ -1,5 +1,53 @@
 export default LongTasks;
+export type TaskGroupIds = import('../lib/tracehouse/task-groups.js').TaskGroupIds;
+export type Timing = {
+    startTime: number;
+    duration: number;
+};
+export type DebugTask = Timing & {
+    [p: string]: number;
+    urlIndex: number;
+};
+/** @typedef {import('../lib/tracehouse/task-groups.js').TaskGroupIds} TaskGroupIds */
+/** @typedef {{startTime: number, duration: number}} Timing */
+/** @typedef {Timing & {urlIndex: number, [p: string]: number}} DebugTask */
 declare class LongTasks extends Audit {
+    /**
+     * Returns the timing information for the given task, recursively walking the
+     * task's children and adding up time spent in each type of task activity.
+     * If `taskTimingsByEvent` is present, it will be used for task timing instead
+     * of the timings on the tasks themselves.
+     * If `timeByTaskGroup` is not provided, a new Map will be populated with
+     * timing breakdown; if one is provided, timing breakdown will be added to the
+     * existing breakdown.
+     *
+     * TODO: when simulated, a significant number of child tasks are dropped, so
+     * most time will be attributed to 'other' (the category of the top-level
+     * RunTask). See pruning in `PageDependencyGraph.linkCPUNodes`.
+     * @param {LH.Artifacts.TaskNode} task
+     * @param {Map<LH.TraceEvent, LH.Gatherer.Simulation.NodeTiming>|undefined} taskTimingsByEvent
+     * @param {Map<TaskGroupIds, number>} [timeByTaskGroup]
+     * @return {{startTime: number, duration: number, timeByTaskGroup: Map<TaskGroupIds, number>}}
+     */
+    static getTimingBreakdown(task: LH.Artifacts.TaskNode, taskTimingsByEvent: Map<LH.TraceEvent, LH.Gatherer.Simulation.NodeTiming> | undefined, timeByTaskGroup?: Map<import("../lib/tracehouse/task-groups.js").TaskGroupIds, number> | undefined): {
+        startTime: number;
+        duration: number;
+        timeByTaskGroup: Map<TaskGroupIds, number>;
+    };
+    /**
+     * @param {Array<LH.Artifacts.TaskNode>} longTasks
+     * @param {Set<string>} jsUrls
+     * @param {Map<LH.TraceEvent, LH.Gatherer.Simulation.NodeTiming>|undefined} taskTimingsByEvent
+     * @return {LH.Audit.Details.DebugData}
+     */
+    static makeDebugData(longTasks: Array<LH.Artifacts.TaskNode>, jsUrls: Set<string>, taskTimingsByEvent: Map<LH.TraceEvent, LH.Gatherer.Simulation.NodeTiming> | undefined): LH.Audit.Details.DebugData;
+    /**
+     * Get timing from task, overridden by taskTimingsByEvent if provided.
+     * @param {LH.Artifacts.TaskNode} task
+     * @param {Map<LH.TraceEvent, LH.Gatherer.Simulation.NodeTiming>|undefined} taskTimingsByEvent
+     * @return {Timing}
+     */
+    static getTiming(task: LH.Artifacts.TaskNode, taskTimingsByEvent: Map<LH.TraceEvent, LH.Gatherer.Simulation.NodeTiming> | undefined): Timing;
     /**
      * @param {LH.Artifacts} artifacts
      * @param {LH.Audit.Context} context

package/core/audits/long-tasks.js

@@ -14,6 +14,7 @@ import {getJavaScriptURLs, getAttributableURLForTask} from '../lib/tracehouse/ta
 
 /** 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};
+const DISPLAYED_TASK_COUNT = 20;
 
 const UIStrings = {
   /** Title of a diagnostic LH audit that provides details on the longest running tasks that occur when the page loads. */
@@ -31,6 +32,30 @@ const UIStrings = {
 
 const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
 
+/**
+ * Insert `url` into `urls` array if not already present. Returns
+ * the index of `url` in `urls` for later lookup.
+ * @param {Array<string>} urls
+ * @param {string} url
+ */
+function insertUrl(urls, url) {
+  const index = urls.indexOf(url);
+  if (index > -1) return index;
+  return urls.push(url) - 1;
+}
+
+/**
+ * @param {number} value
+ * @return {number}
+ */
+function roundTenths(value) {
+  return Math.round(value * 10) / 10;
+}
+
+/** @typedef {import('../lib/tracehouse/task-groups.js').TaskGroupIds} TaskGroupIds */
+/** @typedef {{startTime: number, duration: number}} Timing */
+/** @typedef {Timing & {urlIndex: number, [p: string]: number}} DebugTask */
+
 class LongTasks extends Audit {
   /**
    * @return {LH.Audit.Meta}
@@ -45,6 +70,102 @@ class LongTasks extends Audit {
     };
   }
 
+  /**
+   * Returns the timing information for the given task, recursively walking the
+   * task's children and adding up time spent in each type of task activity.
+   * If `taskTimingsByEvent` is present, it will be used for task timing instead
+   * of the timings on the tasks themselves.
+   * If `timeByTaskGroup` is not provided, a new Map will be populated with
+   * timing breakdown; if one is provided, timing breakdown will be added to the
+   * existing breakdown.
+   *
+   * TODO: when simulated, a significant number of child tasks are dropped, so
+   * most time will be attributed to 'other' (the category of the top-level
+   * RunTask). See pruning in `PageDependencyGraph.linkCPUNodes`.
+   * @param {LH.Artifacts.TaskNode} task
+   * @param {Map<LH.TraceEvent, LH.Gatherer.Simulation.NodeTiming>|undefined} taskTimingsByEvent
+   * @param {Map<TaskGroupIds, number>} [timeByTaskGroup]
+   * @return {{startTime: number, duration: number, timeByTaskGroup: Map<TaskGroupIds, number>}}
+   */
+  static getTimingBreakdown(task, taskTimingsByEvent, timeByTaskGroup = new Map()) {
+    const taskTiming = LongTasks.getTiming(task, taskTimingsByEvent);
+
+    // Add up child time, while recursively stepping in to accumulate group times.
+    let childrenTime = 0;
+    if (taskTiming.duration > 0) {
+      for (const child of task.children) {
+        const {duration} = LongTasks.getTimingBreakdown(child, taskTimingsByEvent, timeByTaskGroup);
+        childrenTime += duration;
+      }
+    }
+
+    // Add this task's selfTime to its group's total time.
+    const selfTime = taskTiming.duration - childrenTime;
+    const taskGroupTime = timeByTaskGroup.get(task.group.id) || 0;
+    timeByTaskGroup.set(task.group.id, taskGroupTime + selfTime);
+
+    return {
+      startTime: taskTiming.startTime,
+      duration: taskTiming.duration,
+      timeByTaskGroup,
+    };
+  }
+
+  /**
+   * @param {Array<LH.Artifacts.TaskNode>} longTasks
+   * @param {Set<string>} jsUrls
+   * @param {Map<LH.TraceEvent, LH.Gatherer.Simulation.NodeTiming>|undefined} taskTimingsByEvent
+   * @return {LH.Audit.Details.DebugData}
+   */
+  static makeDebugData(longTasks, jsUrls, taskTimingsByEvent) {
+    /** @type {Array<string>} */
+    const urls = [];
+    /** @type {Array<DebugTask>} */
+    const tasks = [];
+
+    for (const longTask of longTasks) {
+      const attributableUrl = getAttributableURLForTask(longTask, jsUrls);
+
+      const {startTime, duration, timeByTaskGroup} =
+          LongTasks.getTimingBreakdown(longTask, taskTimingsByEvent);
+
+      // Round time per group and sort entries so order is consistent.
+      const timeByTaskGroupEntries = [...timeByTaskGroup]
+        .map(/** @return {[TaskGroupIds, number]} */ ([group, time]) => [group, roundTenths(time)])
+        .sort((a, b) => a[0].localeCompare(b[0]));
+
+      tasks.push({
+        urlIndex: insertUrl(urls, attributableUrl),
+        startTime: roundTenths(startTime),
+        duration: roundTenths(duration),
+        ...Object.fromEntries(timeByTaskGroupEntries),
+      });
+    }
+
+    return {
+      type: 'debugdata',
+      urls,
+      tasks,
+    };
+  }
+
+  /**
+   * Get timing from task, overridden by taskTimingsByEvent if provided.
+   * @param {LH.Artifacts.TaskNode} task
+   * @param {Map<LH.TraceEvent, LH.Gatherer.Simulation.NodeTiming>|undefined} taskTimingsByEvent
+   * @return {Timing}
+   */
+  static getTiming(task, taskTimingsByEvent) {
+    /** @type {Timing} */
+    let timing = task;
+    if (taskTimingsByEvent) {
+      timing = taskTimingsByEvent.get(task.event) || DEFAULT_TIMING;
+    }
+
+    const {duration, startTime} = timing;
+    return {duration, startTime};
+  }
+
   /**
    * @param {LH.Artifacts} artifacts
    * @param {LH.Audit.Context} context
@@ -58,10 +179,12 @@ class LongTasks extends Audit {
     const devtoolsLog = artifacts.devtoolsLogs[LongTasks.DEFAULT_PASS];
     const networkRecords = await NetworkRecords.request(devtoolsLog, context);
 
-    /** @type {Map<LH.TraceEvent, LH.Gatherer.Simulation.NodeTiming>} */
-    const taskTimingsByEvent = new Map();
+    /** @type {Map<LH.TraceEvent, LH.Gatherer.Simulation.NodeTiming>|undefined} */
+    let taskTimingsByEvent;
 
     if (settings.throttlingMethod === 'simulate') {
+      taskTimingsByEvent = new Map();
+
       const simulatorOptions = {devtoolsLog, settings: context.settings};
       const pageGraph = await PageDependencyGraph.request({trace, devtoolsLog, URL}, context);
       const simulator = await LoadSimulator.request(simulatorOptions, context);
@@ -70,30 +193,32 @@ class LongTasks extends Audit {
         if (node.type !== 'cpu') continue;
         taskTimingsByEvent.set(node.event, timing);
       }
-    } else {
-      for (const task of tasks) {
-        if (task.unbounded || task.parent) continue;
-        taskTimingsByEvent.set(task.event, task);
-      }
     }
 
     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 => {
-        const timing = taskTimingsByEvent.get(t.event) || DEFAULT_TIMING;
-        return {...t, duration: timing.duration, startTime: timing.startTime};
+
+    // Only consider top-level (no parent) long tasks that have an explicit endTime.
+    const longTasks = tasks
+      .map(task => {
+        // Use duration from simulation, if available.
+        const {duration} = LongTasks.getTiming(task, taskTimingsByEvent);
+        return {task, duration};
+      })
+      .filter(({task, duration}) => {
+        return duration >= 50 && !task.unbounded && !task.parent;
       })
-      .filter(t => t.duration >= 50 && !t.unbounded && !t.parent)
       .sort((a, b) => b.duration - a.duration)
-      .slice(0, 20);
+      .map(({task}) => task);
 
     // TODO(beytoven): Add start time that matches with the simulated throttling
-    const results = longtasks.map(task => ({
-      url: getAttributableURLForTask(task, jsURLs),
-      duration: task.duration,
-      startTime: task.startTime,
-    }));
+    const results = longTasks.map(task => {
+      const timing = LongTasks.getTiming(task, taskTimingsByEvent);
+      return {
+        url: getAttributableURLForTask(task, jsURLs),
+        duration: timing.duration,
+        startTime: timing.startTime,
+      };
+    }).slice(0, DISPLAYED_TASK_COUNT);
 
     /** @type {LH.Audit.Details.Table['headings']} */
     const headings = [
@@ -107,6 +232,8 @@ class LongTasks extends Audit {
     const tableDetails = Audit.makeTableDetails(headings, results,
       {sortedBy: ['duration'], skipSumming: ['startTime']});
 
+    tableDetails.debugData = LongTasks.makeDebugData(longTasks, jsURLs, taskTimingsByEvent);
+
     let displayValue;
     if (results.length > 0) {
       displayValue = str_(UIStrings.displayValue, {itemCount: results.length});