lighthouse 9.5.0-dev.20220606 → 9.5.0-dev.20220609

package/esm-utils.mjs

@@ -0,0 +1,40 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+'use strict';
+// TODO(esmodules): rename to .js when root is type: module
+
+import module from 'module';
+import url from 'url';
+import path from 'path';
+
+/**
+ * Commonjs equivalent of `require.resolve`.
+ * @param {string} packageName
+ */
+function resolveModulePath(packageName) {
+  const require = module.createRequire(import.meta.url);
+  return require.resolve(packageName);
+}
+
+/**
+ * @param {ImportMeta} importMeta
+ */
+function getModulePath(importMeta) {
+  return url.fileURLToPath(importMeta.url);
+}
+
+/**
+ * @param {ImportMeta} importMeta
+ */
+function getModuleDirectory(importMeta) {
+  return path.dirname(getModulePath(importMeta));
+}
+
+export {
+  resolveModulePath,
+  getModulePath,
+  getModuleDirectory,
+};

package/flow-report/tsconfig.json

@@ -1,8 +1,6 @@
 {
   "extends": "../tsconfig-base.json",
   "compilerOptions": {
-    "outDir": "../.tmp/tsbuildinfo/flow-report",
-
     // Limit to base JS and DOM defs.
     "lib": ["es2020", "dom", "dom.iterable"],
     // Selectively include types from node_modules/.

package/lighthouse-core/config/config.js

@@ -38,6 +38,7 @@ const BASE_ARTIFACT_BLANKS = {
   HostUserAgent: '',
   NetworkUserAgent: '',
   BenchmarkIndex: '',
+  BenchmarkIndexes: '',
   WebAppManifest: '',
   GatherContext: '',
   InstallabilityErrors: '',

package/lighthouse-core/fraggle-rock/config/filters.js

@@ -14,6 +14,7 @@ const baseArtifactKeySource = {
   fetchTime: '',
   LighthouseRunWarnings: '',
   BenchmarkIndex: '',
+  BenchmarkIndexes: '',
   settings: '',
   Timing: '',
   URL: '',

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

@@ -16,7 +16,7 @@ const throwNotConnectedFn = () => {
 };
 
 /** @type {LH.Gatherer.FRProtocolSession} */
-const defaultSession = {
+const throwingSession = {
   setTargetInfo: throwNotConnectedFn,
   hasNextProtocolTimeout: throwNotConnectedFn,
   getNextProtocolTimeout: throwNotConnectedFn,
@@ -26,8 +26,6 @@ const defaultSession = {
   off: throwNotConnectedFn,
   addProtocolMessageListener: throwNotConnectedFn,
   removeProtocolMessageListener: throwNotConnectedFn,
-  addSessionAttachedListener: throwNotConnectedFn,
-  removeSessionAttachedListener: throwNotConnectedFn,
   sendCommand: throwNotConnectedFn,
   dispose: throwNotConnectedFn,
 };
@@ -39,14 +37,12 @@ class Driver {
    */
   constructor(page) {
     this._page = page;
-    /** @type {LH.Gatherer.FRProtocolSession|undefined} */
-    this._session = undefined;
     /** @type {ExecutionContext|undefined} */
     this._executionContext = undefined;
     /** @type {Fetcher|undefined} */
     this._fetcher = undefined;
 
-    this.defaultSession = defaultSession;
+    this.defaultSession = throwingSession;
   }
 
   /** @return {LH.Gatherer.FRTransitionalDriver['executionContext']} */
@@ -68,20 +64,20 @@ class Driver {
 
   /** @return {Promise<void>} */
   async connect() {
-    if (this._session) return;
+    if (this.defaultSession !== throwingSession) return;
     const status = {msg: 'Connecting to browser', id: 'lh:driver:connect'};
     log.time(status);
     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.defaultSession = new ProtocolSession(session);
+    this._executionContext = new ExecutionContext(this.defaultSession);
+    this._fetcher = new Fetcher(this.defaultSession);
     log.timeEnd(status);
   }
 
   /** @return {Promise<void>} */
   async disconnect() {
-    if (!this._session) return;
-    await this._session.dispose();
+    if (this.defaultSession === throwingSession) return;
+    await this.defaultSession.dispose();
   }
 }
 

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

@@ -6,7 +6,6 @@
 'use strict';
 
 const LHError = require('../../lib/lh-error.js');
-const SessionEmitMonkeypatch = Symbol('monkeypatch');
 
 // Controls how long to wait for a response after sending a DevTools protocol command.
 const DEFAULT_PROTOCOL_TIMEOUT = 30000;
@@ -14,32 +13,23 @@ const DEFAULT_PROTOCOL_TIMEOUT = 30000;
 /** @implements {LH.Gatherer.FRProtocolSession} */
 class ProtocolSession {
   /**
-   * @param {LH.Puppeteer.CDPSession} session
+   * @param {LH.Puppeteer.CDPSession} cdpSession
    */
-  constructor(session) {
-    this._session = session;
+  constructor(cdpSession) {
+    this._cdpSession = cdpSession;
     /** @type {LH.Crdp.Target.TargetInfo|undefined} */
     this._targetInfo = undefined;
     /** @type {number|undefined} */
     this._nextProtocolTimeout = undefined;
     /** @type {WeakMap<any, any>} */
     this._callbackMap = new WeakMap();
+  }
 
-    // FIXME: Monkeypatch puppeteer to be able to listen to *all* protocol events.
-    // This patched method will now emit a copy of every event on `*`.
-    const originalEmit = session.emit;
-    // @ts-expect-error - Test for the monkeypatch.
-    if (originalEmit[SessionEmitMonkeypatch]) return;
-    session.emit = (method, ...args) => {
-      // OOPIF sessions need to emit their sessionId so downstream processors can recognize
-      // the target the event came from.
-      const sessionId = this._targetInfo && this._targetInfo.type === 'iframe' ?
-        this._targetInfo.targetId : undefined;
-      originalEmit.call(session, '*', {method, params: args[0], sessionId});
-      return originalEmit.call(session, method, ...args);
-    };
-    // @ts-expect-error - It's monkeypatching 🤷‍♂️.
-    session.emit[SessionEmitMonkeypatch] = true;
+  sessionId() {
+    return this._targetInfo && this._targetInfo.type === 'iframe' ?
+      // TODO: use this._session.id() for real session id.
+      this._targetInfo.targetId :
+      undefined;
   }
 
   /** @param {LH.Crdp.Target.TargetInfo} targetInfo */
@@ -75,7 +65,7 @@ class ProtocolSession {
    * @param {(...args: LH.CrdpEvents[E]) => void} callback
    */
   on(eventName, callback) {
-    this._session.on(eventName, /** @type {*} */ (callback));
+    this._cdpSession.on(eventName, /** @type {*} */ (callback));
   }
 
   /**
@@ -85,44 +75,35 @@ class ProtocolSession {
    * @param {(...args: LH.CrdpEvents[E]) => void} callback
    */
   once(eventName, callback) {
-    this._session.once(eventName, /** @type {*} */ (callback));
-  }
-
-  /**
-   * Bind to the puppeteer `sessionattached` listener and return an LH ProtocolSession.
-   * @param {(session: ProtocolSession) => void} callback
-   */
-  addSessionAttachedListener(callback) {
-    /** @param {LH.Puppeteer.CDPSession} session */
-    const listener = session => callback(new ProtocolSession(session));
-    this._callbackMap.set(callback, listener);
-    this._getConnection().on('sessionattached', listener);
-  }
-
-  /**
-   * Unbind to the puppeteer `sessionattached` listener.
-   * @param {(session: ProtocolSession) => void} callback
-   */
-  removeSessionAttachedListener(callback) {
-    const listener = this._callbackMap.get(callback);
-    if (!listener) return;
-    this._getConnection().off('sessionattached', listener);
+    this._cdpSession.once(eventName, /** @type {*} */ (callback));
   }
 
   /**
-   * Bind to our custom event that fires for *any* protocol event.
+   * Bind to puppeteer's '*' event that fires for *any* protocol event,
+   * and wrap it with data about the protocol message instead of just the event.
    * @param {(payload: LH.Protocol.RawEventMessage) => void} callback
    */
   addProtocolMessageListener(callback) {
-    this._session.on('*', /** @type {*} */ (callback));
+    /**
+     * @param {any} method
+     * @param {any} event
+     */
+    const listener = (method, event) => callback({
+      method,
+      params: event,
+      sessionId: this.sessionId(),
+    });
+    this._callbackMap.set(callback, listener);
+    this._cdpSession.on('*', /** @type {*} */ (listener));
   }
 
   /**
-   * Unbind to our custom event that fires for *any* protocol event.
    * @param {(payload: LH.Protocol.RawEventMessage) => void} callback
    */
   removeProtocolMessageListener(callback) {
-    this._session.off('*', /** @type {*} */ (callback));
+    const listener = this._callbackMap.get(callback);
+    if (!listener) return;
+    this._cdpSession.off('*', /** @type {*} */ (listener));
   }
 
   /**
@@ -132,7 +113,7 @@ class ProtocolSession {
    * @param {(...args: LH.CrdpEvents[E]) => void} callback
    */
   off(eventName, callback) {
-    this._session.off(eventName, /** @type {*} */ (callback));
+    this._cdpSession.off(eventName, /** @type {*} */ (callback));
   }
 
   /**
@@ -155,7 +136,7 @@ class ProtocolSession {
       }));
     });
 
-    const resultPromise = this._session.send(method, ...params);
+    const resultPromise = this._cdpSession.send(method, ...params);
     const resultWithTimeoutPromise = Promise.race([resultPromise, timeoutPromise]);
 
     return resultWithTimeoutPromise.finally(() => {
@@ -168,14 +149,8 @@ class ProtocolSession {
    * @return {Promise<void>}
    */
   async dispose() {
-    this._session.removeAllListeners();
-    await this._session.detach();
-  }
-
-  _getConnection() {
-    const connection = this._session.connection();
-    if (!connection) throw new Error('Connection has been closed.');
-    return connection;
+    this._cdpSession.removeAllListeners();
+    await this._cdpSession.detach();
   }
 }
 

package/lighthouse-core/gather/connections/cri.js

@@ -82,7 +82,8 @@ class CriConnection extends Connection {
    */
   _runJsonCommand(command) {
     return new Promise((resolve, reject) => {
-      const request = http.get({
+      const request = http.request({
+        method: 'PUT', // GET and POST are deprecated: https://crrev.com/c/3595822
         hostname: this.hostname,
         port: this.port,
         path: '/json/' + command,
@@ -109,6 +110,8 @@ class CriConnection extends Connection {
         });
       });
 
+      request.end();
+
       // This error handler is critical to ensuring Lighthouse exits cleanly even when Chrome crashes.
       // See https://github.com/GoogleChrome/lighthouse/pull/8583.
       request.on('error', reject);

package/lighthouse-core/gather/driver/network-monitor.js

@@ -90,7 +90,10 @@ class NetworkMonitor {
     this._frameNavigations = [];
     this._sessions = new Map();
     this._networkRecorder = new NetworkRecorder();
-    this._targetManager = new TargetManager(this._session);
+    /** @type {LH.Puppeteer.CDPSession} */
+    // @ts-expect-error - temporarily reach in to get CDPSession
+    const rootCdpSession = this._session._cdpSession;
+    this._targetManager = new TargetManager(rootCdpSession);
 
     /**
      * Reemit the same network recorder events.
@@ -103,13 +106,20 @@ class NetworkMonitor {
     };
 
     this._networkRecorder.on('requeststarted', reEmit('requeststarted'));
-    this._networkRecorder.on('requestloaded', reEmit('requestloaded'));
+    this._networkRecorder.on('requestfinished', reEmit('requestfinished'));
 
     this._session.on('Page.frameNavigated', this._onFrameNavigated);
-    this._targetManager.addTargetAttachedListener(this._onTargetAttached);
-
     await this._session.sendCommand('Page.enable');
-    await this._targetManager.enable();
+
+    // Legacy driver does its own target management.
+    // @ts-expect-error
+    const isLegacyRunner = Boolean(this._session._domainEnabledCounts);
+    if (isLegacyRunner) {
+      this._session.addProtocolMessageListener(this._onProtocolMessage);
+    } else {
+      this._targetManager.addTargetAttachedListener(this._onTargetAttached);
+      await this._targetManager.enable();
+    }
   }
 
   /**
@@ -119,13 +129,21 @@ class NetworkMonitor {
     if (!this._targetManager) return;
 
     this._session.off('Page.frameNavigated', this._onFrameNavigated);
-    this._targetManager.removeTargetAttachedListener(this._onTargetAttached);
 
-    for (const session of this._sessions.values()) {
-      session.removeProtocolMessageListener(this._onProtocolMessage);
-    }
+    // Legacy driver does its own target management.
+    // @ts-expect-error
+    const isLegacyRunner = Boolean(this._session._domainEnabledCounts);
+    if (isLegacyRunner) {
+      this._session.removeProtocolMessageListener(this._onProtocolMessage);
+    } else {
+      this._targetManager.removeTargetAttachedListener(this._onTargetAttached);
 
-    await this._targetManager.disable();
+      for (const session of this._sessions.values()) {
+        session.removeProtocolMessageListener(this._onProtocolMessage);
+      }
+
+      await this._targetManager.disable();
+    }
 
     this._frameNavigations = [];
     this._networkRecorder = undefined;

package/lighthouse-core/gather/driver/target-manager.js

@@ -11,21 +11,23 @@
   */
 
 const log = require('lighthouse-logger');
+const ProtocolSession = require('../../fraggle-rock/gather/session.js');
 
 /** @typedef {{target: LH.Crdp.Target.TargetInfo, session: LH.Gatherer.FRProtocolSession}} TargetWithSession */
 
 class TargetManager {
-  /** @param {LH.Gatherer.FRProtocolSession} session */
-  constructor(session) {
+  /** @param {LH.Puppeteer.CDPSession} cdpSession */
+  constructor(cdpSession) {
     this._enabled = false;
-    this._session = session;
+    this._rootCdpSession = cdpSession;
+
     /** @type {Array<(targetWithSession: TargetWithSession) => Promise<void>|void>} */
     this._listeners = [];
 
     this._onSessionAttached = this._onSessionAttached.bind(this);
 
     /** @type {Map<string, TargetWithSession>} */
-    this._targets = new Map();
+    this._targetIdToTargets = new Map();
 
     /** @param {LH.Crdp.Page.FrameNavigatedEvent} event */
     this._onFrameNavigated = async event => {
@@ -35,7 +37,7 @@ class TargetManager {
       // It's not entirely clear when this is necessary, but when the page switches processes on
       // navigating from about:blank to the `requestedUrl`, resetting `setAutoAttach` has been
       // necessary in the past.
-      await this._session.sendCommand('Target.setAutoAttach', {
+      await this._rootCdpSession.send('Target.setAutoAttach', {
         autoAttach: true,
         flatten: true,
         waitForDebuggerOnStart: true,
@@ -44,9 +46,11 @@ class TargetManager {
   }
 
   /**
-   * @param {LH.Gatherer.FRProtocolSession} session
+   * @param {LH.Puppeteer.CDPSession} cdpSession
    */
-  async _onSessionAttached(session) {
+  async _onSessionAttached(cdpSession) {
+    const session = new ProtocolSession(cdpSession);
+
     try {
       const target = await session.sendCommand('Target.getTargetInfo').catch(() => null);
       const targetType = target?.targetInfo?.type;
@@ -55,13 +59,13 @@ class TargetManager {
 
       const targetId = target.targetInfo.targetId;
       session.setTargetInfo(target.targetInfo);
-      if (this._targets.has(targetId)) return;
+      if (this._targetIdToTargets.has(targetId)) return;
 
       const targetName = target.targetInfo.url || target.targetInfo.targetId;
       log.verbose('target-manager', `target ${targetName} attached`);
 
       const targetWithSession = {target: target.targetInfo, session};
-      this._targets.set(targetId, targetWithSession);
+      this._targetIdToTargets.set(targetId, targetWithSession);
       for (const listener of this._listeners) await listener(targetWithSession);
 
       await session.sendCommand('Target.setAutoAttach', {
@@ -87,24 +91,32 @@ class TargetManager {
     if (this._enabled) return;
 
     this._enabled = true;
-    this._targets = new Map();
+    this._targetIdToTargets = new Map();
+
+    this._rootCdpSession.on('Page.frameNavigated', this._onFrameNavigated);
+
+    const rootConnection = this._rootCdpSession.connection();
+    if (!rootConnection) {
+      throw new Error('Connection has been closed.');
+    }
+    rootConnection.on('sessionattached', this._onSessionAttached);
 
-    this._session.on('Page.frameNavigated', this._onFrameNavigated);
-    this._session.addSessionAttachedListener(this._onSessionAttached);
+    await this._rootCdpSession.send('Page.enable');
 
-    await this._session.sendCommand('Page.enable');
-    await this._onSessionAttached(this._session);
+    // Start with the already attached root session.
+    await this._onSessionAttached(this._rootCdpSession);
   }
 
   /**
    * @return {Promise<void>}
    */
   async disable() {
-    this._session.off('Page.frameNavigated', this._onFrameNavigated);
-    this._session.removeSessionAttachedListener(this._onSessionAttached);
+    this._rootCdpSession.off('Page.frameNavigated', this._onFrameNavigated);
+    // No need to remove listener if connection is already closed.
+    this._rootCdpSession.connection()?.off('sessionattached', this._onSessionAttached);
 
     this._enabled = false;
-    this._targets = new Map();
+    this._targetIdToTargets = new Map();
   }
 
   /**

package/lighthouse-core/gather/driver/wait-for-condition.js

@@ -164,7 +164,8 @@ function waitForNetworkIdle(session, networkMonitor, networkQuietOptions) {
       const inflightRecords = networkMonitor.getInflightRequests();
       // If there are more than 20 inflight requests, load is still in full swing.
       // Wait until it calms down a bit to be a little less spammy.
-      if (inflightRecords.length < 20) {
+      if (log.isVerbose() && inflightRecords.length < 20 && inflightRecords.length > 0) {
+        log.verbose('waitFor', `=== Waiting on ${inflightRecords.length} requests to finish`);
         for (const record of inflightRecords) {
           log.verbose('waitFor', `Waiting on ${record.url.slice(0, 120)} to finish`);
         }
@@ -172,7 +173,7 @@ function waitForNetworkIdle(session, networkMonitor, networkQuietOptions) {
     };
 
     networkMonitor.on('requeststarted', logStatus);
-    networkMonitor.on('requestloaded', logStatus);
+    networkMonitor.on('requestfinished', logStatus);
     networkMonitor.on(busyEvent, logStatus);
 
     if (!networkQuietOptions.pretendDCLAlreadyFired) {
@@ -192,7 +193,7 @@ function waitForNetworkIdle(session, networkMonitor, networkQuietOptions) {
       networkMonitor.removeListener(busyEvent, onBusy);
       networkMonitor.removeListener(idleEvent, onIdle);
       networkMonitor.removeListener('requeststarted', logStatus);
-      networkMonitor.removeListener('requestloaded', logStatus);
+      networkMonitor.removeListener('requestfinished', logStatus);
       networkMonitor.removeListener(busyEvent, logStatus);
     };
   });

package/lighthouse-core/gather/driver.js

@@ -12,7 +12,7 @@ const {fetchResponseBodyFromCache} = require('../gather/driver/network.js');
 const EventEmitter = require('events').EventEmitter;
 
 const log = require('lighthouse-logger');
-const DevtoolsLog = require('./devtools-log.js');
+const DevtoolsMessageLog = require('./gatherers/devtools-log.js').DevtoolsMessageLog;
 const TraceGatherer = require('./gatherers/trace.js');
 
 // Pulled in for Connection type checking.
@@ -41,7 +41,7 @@ class Driver {
    * @private
    * Used to save network and lifecycle protocol traffic. Just Page and Network are needed.
    */
-  _devtoolsLog = new DevtoolsLog(/^(Page|Network)\./);
+  _devtoolsLog = new DevtoolsMessageLog(/^(Page|Network)\./);
 
   /**
    * @private
@@ -208,16 +208,6 @@ class Driver {
     // OOPIF handling in legacy driver is implicit.
   }
 
-  /** @param {(session: LH.Gatherer.FRProtocolSession) => void} callback */
-  addSessionAttachedListener(callback) { // eslint-disable-line no-unused-vars
-    // OOPIF handling in legacy driver is implicit.
-  }
-
-  /** @param {(session: LH.Gatherer.FRProtocolSession) => void} callback */
-  removeSessionAttachedListener(callback) { // eslint-disable-line no-unused-vars
-    // OOPIF handling in legacy driver is implicit.
-  }
-
   /**
    * Debounce enabling or disabling domains to prevent driver users from
    * stomping on each other. Maintains an internal count of the times a domain

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

@@ -20,6 +20,7 @@ const WebAppManifest = require('./gatherers/web-app-manifest.js');
 const InstallabilityErrors = require('./gatherers/installability-errors.js');
 const NetworkUserAgent = require('./gatherers/network-user-agent.js');
 const Stacks = require('./gatherers/stacks.js');
+const URL = require('../lib/url-shim.js');
 const {finalizeArtifacts} = require('../fraggle-rock/gather/base-artifacts.js');
 
 /** @typedef {import('../gather/driver.js')} Driver */
@@ -491,6 +492,20 @@ class GatherRunner {
       const baseArtifacts = await GatherRunner.initializeBaseArtifacts(options);
       baseArtifacts.BenchmarkIndex = await getBenchmarkIndex(driver.executionContext);
 
+      // Hack for running benchmarkIndex extra times.
+      // Add a `bidx=20` query param, eg: https://www.example.com/?bidx=50
+      const parsedUrl = URL.isValid(options.requestedUrl) && new URL(options.requestedUrl);
+      if (options.settings.channel === 'lr' && parsedUrl && parsedUrl.searchParams.has('bidx')) {
+        const bidxRunCount = parsedUrl.searchParams.get('bidx') || 0;
+        // Add the first bidx into the new set
+        const indexes = [baseArtifacts.BenchmarkIndex];
+        for (let i = 0; i < bidxRunCount; i++) {
+          const bidx = await getBenchmarkIndex(driver.executionContext);
+          indexes.push(bidx);
+        }
+        baseArtifacts.BenchmarkIndexes = indexes;
+      }
+
       await GatherRunner.setupDriver(driver, options);
 
       let isFirstPass = true;

package/lighthouse-core/gather/gatherers/devtools-log.js

@@ -12,7 +12,6 @@
  */
 
 const NetworkMonitor = require('../driver/network-monitor.js');
-const MessageLog = require('../devtools-log.js');
 const FRGatherer = require('../../fraggle-rock/gather/base-gatherer.js');
 
 class DevtoolsLog extends FRGatherer {
@@ -30,7 +29,7 @@ class DevtoolsLog extends FRGatherer {
     /** @type {NetworkMonitor|undefined} */
     this._networkMonitor = undefined;
 
-    this._messageLog = new MessageLog(/^(Page|Network)\./);
+    this._messageLog = new DevtoolsMessageLog(/^(Page|Network|Target|Runtime)\./);
 
     /** @param {LH.Protocol.RawEventMessage} e */
     this._onProtocolMessage = e => this._messageLog.record(e);
@@ -63,4 +62,59 @@ class DevtoolsLog extends FRGatherer {
   }
 }
 
+
+/**
+ * This class saves all protocol messages whose method match a particular
+ * regex filter. Used when saving assets for later analysis by another tool such as
+ * Webpagetest.
+ */
+class DevtoolsMessageLog {
+  /**
+   * @param {RegExp=} regexFilter
+   */
+  constructor(regexFilter) {
+    this._filter = regexFilter;
+
+    /** @type {LH.DevtoolsLog} */
+    this._messages = [];
+    this._isRecording = false;
+  }
+
+  /**
+   * @return {LH.DevtoolsLog}
+   */
+  get messages() {
+    return this._messages;
+  }
+
+  reset() {
+    this._messages = [];
+  }
+
+  beginRecording() {
+    this._isRecording = true;
+  }
+
+  endRecording() {
+    this._isRecording = false;
+  }
+
+  /**
+   * Records a message if method matches filter and recording has been started.
+   * @param {LH.Protocol.RawEventMessage} message
+   */
+  record(message) {
+    // We're not recording, skip the rest of the checks.
+    if (!this._isRecording) return;
+    // The event was likely an internal puppeteer method that uses Symbols.
+    if (typeof message.method !== 'string') return;
+    // The event didn't pass our filter, do not record it.
+    if (this._filter && !this._filter.test(message.method)) return;
+
+    // We passed all the checks, record the message.
+    this._messages.push(message);
+  }
+}
+
 module.exports = DevtoolsLog;
+module.exports.DevtoolsMessageLog = DevtoolsMessageLog;

package/lighthouse-core/lib/network-recorder.js

@@ -9,7 +9,7 @@ const log = require('lighthouse-logger');
 const NetworkRequest = require('./network-request.js');
 const EventEmitter = require('events').EventEmitter;
 
-/** @typedef {'requeststarted'|'requestloaded'} NetworkRecorderEvent */
+/** @typedef {'requeststarted'|'requestfinished'} NetworkRecorderEvent */
 
 class NetworkRecorder extends EventEmitter {
   /**
@@ -71,7 +71,7 @@ class NetworkRecorder extends EventEmitter {
    * @private
    */
   onRequestFinished(request) {
-    this.emit('requestloaded', request);
+    this.emit('requestfinished', request);
   }
 
   // The below methods proxy network data into the NetworkRequest object which mimics the

package/lighthouse-core/runner.js

@@ -95,6 +95,7 @@ class Runner {
           networkUserAgent: artifacts.NetworkUserAgent,
           hostUserAgent: artifacts.HostUserAgent,
           benchmarkIndex: artifacts.BenchmarkIndex,
+          benchmarkIndexes: artifacts.BenchmarkIndexes,
           credits,
         },
         audits: auditResultsById,