lighthouse 9.5.0-dev.20230201 → 9.5.0-dev.20230202

package/core/gather/driver/prepare.d.ts

@@ -43,4 +43,10 @@ export function prepareTargetForIndividualNavigation(session: LH.Gatherer.FRProt
 }): Promise<{
     warnings: Array<LH.IcuMessage>;
 }>;
+/**
+ * Enables `Debugger` domain to receive async stacktrace information on network request initiators.
+ * This is critical for tracking attribution of tasks and performance simulation accuracy.
+ * @param {LH.Gatherer.FRProtocolSession} session
+ */
+export function enableAsyncStacks(session: LH.Gatherer.FRProtocolSession): Promise<() => Promise<void>>;
 //# sourceMappingURL=prepare.d.ts.map

package/core/gather/driver/prepare.js

@@ -22,17 +22,33 @@ async function enableAsyncStacks(session) {
     await session.sendCommand('Debugger.setAsyncCallStackDepth', {maxDepth: 8});
   };
 
-  // Resume any pauses that make it through `setSkipAllPauses`
-  session.on('Debugger.paused', () => session.sendCommand('Debugger.resume'));
+  /**
+   * Resume any pauses that make it through `setSkipAllPauses`
+   */
+  function onDebuggerPaused() {
+    session.sendCommand('Debugger.resume');
+  }
 
-  // `Debugger.setSkipAllPauses` is reset after every navigation, so retrigger it on main frame navigations.
-  // See https://bugs.chromium.org/p/chromium/issues/detail?id=990945&q=setSkipAllPauses&can=2
-  session.on('Page.frameNavigated', event => {
+  /**
+   * `Debugger.setSkipAllPauses` is reset after every navigation, so retrigger it on main frame navigations.
+   * See https://bugs.chromium.org/p/chromium/issues/detail?id=990945&q=setSkipAllPauses&can=2
+   * @param {LH.Crdp.Page.FrameNavigatedEvent} event
+   */
+  function onFrameNavigated(event) {
     if (event.frame.parentId) return;
     enable().catch(err => log.error('Driver', err));
-  });
+  }
+
+  session.on('Debugger.paused', onDebuggerPaused);
+  session.on('Page.frameNavigated', onFrameNavigated);
 
   await enable();
+
+  return async () => {
+    await session.sendCommand('Debugger.disable');
+    session.off('Debugger.paused', onDebuggerPaused);
+    session.off('Page.frameNavigated', onFrameNavigated);
+  };
 }
 
 /**
@@ -128,15 +144,12 @@ async function prepareThrottlingAndNetwork(session, settings, options) {
  * @param {LH.Gatherer.FRTransitionalDriver} driver
  * @param {LH.Config.Settings} settings
  */
-async function prepareDeviceEmulationAndAsyncStacks(driver, settings) {
+async function prepareDeviceEmulation(driver, settings) {
   // Enable network domain here so future calls to `emulate()` don't clear cache (https://github.com/GoogleChrome/lighthouse/issues/12631)
   await driver.defaultSession.sendCommand('Network.enable');
 
   // Emulate our target device screen and user agent.
   await emulation.emulate(driver.defaultSession, settings);
-
-  // Enable better stacks on network requests.
-  await enableAsyncStacks(driver.defaultSession);
 }
 
 /**
@@ -149,7 +162,7 @@ async function prepareTargetForTimespanMode(driver, settings) {
   const status = {msg: 'Preparing target for timespan mode', id: 'lh:prepare:timespanMode'};
   log.time(status);
 
-  await prepareDeviceEmulationAndAsyncStacks(driver, settings);
+  await prepareDeviceEmulation(driver, settings);
   await prepareThrottlingAndNetwork(driver.defaultSession, settings, {
     disableThrottling: false,
     blockedUrlPatterns: undefined,
@@ -171,7 +184,7 @@ async function prepareTargetForNavigationMode(driver, settings) {
   const status = {msg: 'Preparing target for navigation mode', id: 'lh:prepare:navigationMode'};
   log.time(status);
 
-  await prepareDeviceEmulationAndAsyncStacks(driver, settings);
+  await prepareDeviceEmulation(driver, settings);
 
   // Automatically handle any JavaScript dialogs to prevent a hung renderer.
   await dismissJavaScriptDialogs(driver.defaultSession);
@@ -227,4 +240,5 @@ export {
   prepareTargetForTimespanMode,
   prepareTargetForNavigationMode,
   prepareTargetForIndividualNavigation,
+  enableAsyncStacks,
 };

package/core/gather/gatherers/bf-cache-failures.js

@@ -9,6 +9,7 @@ import {waitForFrameNavigated, waitForLoadEvent} from '../driver/wait-for-condit
 import DevtoolsLog from './devtools-log.js';
 
 const FAILURE_EVENT_TIMEOUT = 100;
+const TEMP_PAGE_PAUSE_TIMEOUT = 100;
 
 class BFCacheFailures extends FRGatherer {
   /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
@@ -109,7 +110,9 @@ class BFCacheFailures extends FRGatherer {
     // https://github.com/GoogleChrome/lighthouse/issues/14665
     await Promise.all([
       session.sendCommand('Page.navigate', {url: 'chrome://terms'}),
-      waitForLoadEvent(session, 0).promise,
+      // DevTools e2e tests can sometimes fail on the next command if we progress too fast.
+      // The only reliable way to prevent this is to wait for an arbitrary period of time after load.
+      waitForLoadEvent(session, TEMP_PAGE_PAUSE_TIMEOUT).promise,
     ]);
 
     const [, frameNavigatedEvent] = await Promise.all([

package/core/gather/navigation-runner.js

@@ -227,6 +227,10 @@ async function _navigation(navigationContext) {
   };
 
   const setupResult = await _setupNavigation(navigationContext);
+
+  const disableAsyncStacks =
+    await prepare.enableAsyncStacks(navigationContext.driver.defaultSession);
+
   await collectPhaseArtifacts({phase: 'startInstrumentation', ...phaseState});
   await collectPhaseArtifacts({phase: 'startSensitiveInstrumentation', ...phaseState});
   const navigateResult = await _navigate(navigationContext);
@@ -244,6 +248,12 @@ async function _navigation(navigationContext) {
 
   await collectPhaseArtifacts({phase: 'stopSensitiveInstrumentation', ...phaseState});
   await collectPhaseArtifacts({phase: 'stopInstrumentation', ...phaseState});
+
+  // bf-cache-failures can emit `Page.frameNavigated` at the end of the run.
+  // This can cause us to issue protocol commands after the target closes.
+  // We should disable our `Page.frameNavigated` handlers before that.
+  await disableAsyncStacks();
+
   await _cleanupNavigation(navigationContext);
 
   return _computeNavigationResult(navigationContext, phaseState, setupResult, navigateResult);

package/core/gather/timespan-runner.js

@@ -9,7 +9,7 @@ import log from 'lighthouse-logger';
 import {Driver} from './driver.js';
 import {Runner} from '../runner.js';
 import {getEmptyArtifactState, collectPhaseArtifacts, awaitArtifacts} from './runner-helpers.js';
-import {prepareTargetForTimespanMode} from './driver/prepare.js';
+import {enableAsyncStacks, prepareTargetForTimespanMode} from './driver/prepare.js';
 import {initializeConfig} from '../config/config.js';
 import {getBaseArtifacts, finalizeArtifacts} from './base-artifacts.js';
 
@@ -44,6 +44,9 @@ async function startTimespanGather(page, options = {}) {
   };
 
   await prepareTargetForTimespanMode(driver, resolvedConfig.settings);
+
+  const disableAsyncStacks = await enableAsyncStacks(driver.defaultSession);
+
   await collectPhaseArtifacts({phase: 'startInstrumentation', ...phaseOptions});
   await collectPhaseArtifacts({phase: 'startSensitiveInstrumentation', ...phaseOptions});
 
@@ -58,6 +61,12 @@ async function startTimespanGather(page, options = {}) {
 
           await collectPhaseArtifacts({phase: 'stopSensitiveInstrumentation', ...phaseOptions});
           await collectPhaseArtifacts({phase: 'stopInstrumentation', ...phaseOptions});
+
+          // bf-cache-failures can emit `Page.frameNavigated` at the end of the run.
+          // This can cause us to issue protocol commands after the target closes.
+          // We should disable our `Page.frameNavigated` handlers before that.
+          await disableAsyncStacks();
+
           await collectPhaseArtifacts({phase: 'getArtifact', ...phaseOptions});
           await driver.disconnect();
 

package/core/legacy/gather/driver.d.ts

@@ -200,12 +200,13 @@ export class Driver implements LH.Gatherer.FRTransitionalDriver {
     /**
      * Begin recording devtools protocol messages.
      */
-    beginDevtoolsLog(): void;
+    beginDevtoolsLog(): Promise<void>;
+    _disableAsyncStacks: (() => Promise<void>) | undefined;
     /**
      * Stop recording to devtoolsLog and return log contents.
-     * @return {LH.DevtoolsLog}
+     * @return {Promise<LH.DevtoolsLog>}
      */
-    endDevtoolsLog(): LH.DevtoolsLog;
+    endDevtoolsLog(): Promise<LH.DevtoolsLog>;
     url(): Promise<string>;
 }
 import * as LH from "../../../types/lh.js";

package/core/legacy/gather/driver.js

@@ -16,6 +16,7 @@ import {fetchResponseBodyFromCache} from '../../gather/driver/network.js';
 import {DevtoolsMessageLog} from '../../gather/gatherers/devtools-log.js';
 import TraceGatherer from '../../gather/gatherers/trace.js';
 import {getBrowserVersion} from '../../gather/driver/environment.js';
+import {enableAsyncStacks} from '../../gather/driver/prepare.js';
 
 // Controls how long to wait for a response after sending a DevTools protocol command.
 const DEFAULT_PROTOCOL_TIMEOUT = 30000;
@@ -443,17 +444,19 @@ class Driver {
   /**
    * Begin recording devtools protocol messages.
    */
-  beginDevtoolsLog() {
+  async beginDevtoolsLog() {
+    this._disableAsyncStacks = await enableAsyncStacks(this);
     this._devtoolsLog.reset();
     this._devtoolsLog.beginRecording();
   }
 
   /**
    * Stop recording to devtoolsLog and return log contents.
-   * @return {LH.DevtoolsLog}
+   * @return {Promise<LH.DevtoolsLog>}
    */
-  endDevtoolsLog() {
+  async endDevtoolsLog() {
     this._devtoolsLog.endRecording();
+    await this._disableAsyncStacks?.();
     return this._devtoolsLog.messages;
   }
 

package/core/legacy/gather/gather-runner.js

@@ -235,7 +235,7 @@ class GatherRunner {
       id: `lh:gather:getDevtoolsLog`,
     };
     log.time(status);
-    const devtoolsLog = driver.endDevtoolsLog();
+    const devtoolsLog = await driver.endDevtoolsLog();
     const networkRecords = await NetworkRecords.request(devtoolsLog, passContext);
     log.timeEnd(status);
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "9.5.0-dev.20230201",
+  "version": "9.5.0-dev.20230202",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {