lighthouse 9.3.1 → 9.4.0

package/lighthouse-core/fraggle-rock/user-flow.js

@@ -54,11 +54,10 @@ class UserFlow {
   }
 
   /**
-   * @param {string} url
    * @param {StepOptions=} stepOptions
    */
-  _getNextNavigationOptions(url, stepOptions) {
-    const options = {url, ...this.options, ...stepOptions};
+  _getNextNavigationOptions(stepOptions) {
+    const options = {...this.options, ...stepOptions};
     const configContext = {...options.configContext};
     const settingsOverrides = {...configContext.settingsOverrides};
 
@@ -81,13 +80,16 @@ class UserFlow {
   }
 
   /**
-   * @param {string} url
+   * @param {LH.NavigationRequestor} requestor
    * @param {StepOptions=} stepOptions
    */
-  async navigate(url, stepOptions) {
+  async navigate(requestor, stepOptions) {
     if (this.currentTimespan) throw Error('Timespan already in progress');
 
-    const result = await navigation(this._getNextNavigationOptions(url, stepOptions));
+    const result = await navigation(
+      requestor,
+      this._getNextNavigationOptions(stepOptions)
+    );
     if (!result) throw Error('Navigation returned undefined');
 
     const providedName = stepOptions?.stepName;

package/lighthouse-core/gather/driver/navigation.js

@@ -78,12 +78,14 @@ function resolveWaitForFullyLoadedOptions(options) {
  * navigations.
  *
  * @param {LH.Gatherer.FRTransitionalDriver} driver
- * @param {string} url
+ * @param {LH.NavigationRequestor} requestor
  * @param {NavigationOptions} options
- * @return {Promise<{finalUrl: string, warnings: Array<LH.IcuMessage>}>}
+ * @return {Promise<{requestedUrl: string, finalUrl: string, warnings: Array<LH.IcuMessage>}>}
  */
-async function gotoURL(driver, url, options) {
-  const status = {msg: `Navigating to ${url}`, id: 'lh:driver:navigate'};
+async function gotoURL(driver, requestor, options) {
+  const status = typeof requestor === 'string' ?
+    {msg: `Navigating to ${requestor}`, id: 'lh:driver:navigate'} :
+    {msg: 'Navigating using a user defined function', id: 'lh:driver:navigate'};
   log.time(status);
 
   const session = driver.defaultSession;
@@ -94,9 +96,14 @@ async function gotoURL(driver, url, options) {
   await session.sendCommand('Page.enable');
   await session.sendCommand('Page.setLifecycleEventsEnabled', {enabled: true});
 
-  // No timeout needed for Page.navigate. See https://github.com/GoogleChrome/lighthouse/pull/6413
-  session.setNextProtocolTimeout(Infinity);
-  const waitforPageNavigateCmd = session.sendCommand('Page.navigate', {url});
+  let waitForNavigationTriggered;
+  if (typeof requestor === 'string') {
+    // No timeout needed for Page.navigate. See https://github.com/GoogleChrome/lighthouse/pull/6413
+    session.setNextProtocolTimeout(Infinity);
+    waitForNavigationTriggered = session.sendCommand('Page.navigate', {url: requestor});
+  } else {
+    waitForNavigationTriggered = requestor();
+  }
 
   const waitForNavigated = options.waitUntil.includes('navigated');
   const waitForLoad = options.waitUntil.includes('load');
@@ -119,10 +126,21 @@ async function gotoURL(driver, url, options) {
 
   const waitConditions = await Promise.all(waitConditionPromises);
   const timedOut = waitConditions.some(condition => condition.timedOut);
-  const finalUrl = (await networkMonitor.getFinalNavigationUrl()) || url;
+  const navigationUrls = await networkMonitor.getNavigationUrls();
+
+  let requestedUrl = navigationUrls.requestedUrl;
+  if (typeof requestor === 'string') {
+    if (requestor !== requestedUrl) {
+      log.error('Navigation', 'Provided URL did not match initial navigation URL');
+    }
+    requestedUrl = requestor;
+  }
+  if (!requestedUrl) throw Error('No navigations detected when running user defined requestor.');
+
+  const finalUrl = navigationUrls.finalUrl || requestedUrl;
 
   // Bring `Page.navigate` errors back into the promise chain. See https://github.com/GoogleChrome/lighthouse/pull/6739.
-  await waitforPageNavigateCmd;
+  await waitForNavigationTriggered;
   await networkMonitor.disable();
 
   if (options.debugNavigation) {
@@ -131,8 +149,9 @@ async function gotoURL(driver, url, options) {
 
   log.timeEnd(status);
   return {
+    requestedUrl,
     finalUrl,
-    warnings: getNavigationWarnings({timedOut, finalUrl, requestedUrl: url}),
+    warnings: getNavigationWarnings({timedOut, finalUrl, requestedUrl}),
   };
 }
 

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

@@ -133,18 +133,20 @@ class NetworkMonitor {
     this._sessions = new Map();
   }
 
-  /** @return {Promise<string | undefined>} */
-  async getFinalNavigationUrl() {
+  /** @return {Promise<{requestedUrl?: string, finalUrl?: string}>} */
+  async getNavigationUrls() {
     const frameNavigations = this._frameNavigations;
-    if (!frameNavigations.length) return undefined;
+    if (!frameNavigations.length) return {};
 
     const resourceTreeResponse = await this._session.sendCommand('Page.getResourceTree');
     const mainFrameId = resourceTreeResponse.frameTree.frame.id;
     const mainFrameNavigations = frameNavigations.filter(frame => frame.id === mainFrameId);
-    const finalNavigation = mainFrameNavigations[mainFrameNavigations.length - 1];
-    if (!finalNavigation) log.warn('NetworkMonitor', 'No detected navigations');
+    if (!mainFrameNavigations.length) log.warn('NetworkMonitor', 'No detected navigations');
 
-    return finalNavigation?.url;
+    return {
+      requestedUrl: mainFrameNavigations[0]?.url,
+      finalUrl: mainFrameNavigations[mainFrameNavigations.length - 1]?.url,
+    };
   }
 
   /**

package/lighthouse-core/gather/driver/prepare.js

@@ -71,17 +71,17 @@ async function dismissJavaScriptDialogs(session) {
 
 /**
  * @param {LH.Gatherer.FRProtocolSession} session
- * @param {{url: string}} navigation
+ * @param {string} url
  * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
  */
-async function resetStorageForNavigation(session, navigation) {
+async function resetStorageForUrl(session, url) {
   /** @type {Array<LH.IcuMessage>} */
   const warnings = [];
 
   // Reset the storage and warn if there appears to be other important data.
-  const warning = await storage.getImportantStorageWarning(session, navigation.url);
+  const warning = await storage.getImportantStorageWarning(session, url);
   if (warning) warnings.push(warning);
-  await storage.clearDataForOrigin(session, navigation.url);
+  await storage.clearDataForOrigin(session, url);
   await storage.clearBrowserCaches(session);
 
   return {warnings};
@@ -190,7 +190,7 @@ async function prepareTargetForNavigationMode(driver, settings) {
  *
  * @param {LH.Gatherer.FRProtocolSession} session
  * @param {LH.Config.Settings} settings
- * @param {Pick<LH.Config.NavigationDefn, 'disableThrottling'|'disableStorageReset'|'blockedUrlPatterns'> & {url: string}} navigation
+ * @param {Pick<LH.Config.NavigationDefn, 'disableThrottling'|'disableStorageReset'|'blockedUrlPatterns'> & {requestor: LH.NavigationRequestor}} navigation
  * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
  */
 async function prepareTargetForIndividualNavigation(session, settings, navigation) {
@@ -200,9 +200,15 @@ async function prepareTargetForIndividualNavigation(session, settings, navigatio
   /** @type {Array<LH.IcuMessage>} */
   const warnings = [];
 
-  const shouldResetStorage = !settings.disableStorageReset && !navigation.disableStorageReset;
+  const {requestor} = navigation;
+  const shouldResetStorage =
+    !settings.disableStorageReset &&
+    !navigation.disableStorageReset &&
+    // Without prior knowledge of the destination, we cannot know which URL to clear storage for.
+    typeof requestor === 'string';
   if (shouldResetStorage) {
-    const {warnings: storageWarnings} = await resetStorageForNavigation(session, navigation);
+    const requestedUrl = requestor;
+    const {warnings: storageWarnings} = await resetStorageForUrl(session, requestedUrl);
     warnings.push(...storageWarnings);
   }
 

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

@@ -114,7 +114,7 @@ function waitForFcp(session, pauseAfterFcpMs, maxWaitForFcpMs) {
  * `networkQuietThresholdMs` ms and a method to cancel internal network listeners/timeout.
  * @param {LH.Gatherer.FRProtocolSession} session
  * @param {NetworkMonitor} networkMonitor
- * @param {{networkQuietThresholdMs: number, busyEvent: NetworkMonitorEvent, idleEvent: NetworkMonitorEvent, isIdle(recorder: NetworkMonitor): boolean}} networkQuietOptions
+ * @param {{networkQuietThresholdMs: number, busyEvent: NetworkMonitorEvent, idleEvent: NetworkMonitorEvent, isIdle(recorder: NetworkMonitor): boolean, pretendDCLAlreadyFired?: boolean}} networkQuietOptions
  * @return {CancellableWait}
  */
 function waitForNetworkIdle(session, networkMonitor, networkQuietOptions) {
@@ -175,13 +175,20 @@ function waitForNetworkIdle(session, networkMonitor, networkQuietOptions) {
     networkMonitor.on('requestloaded', logStatus);
     networkMonitor.on(busyEvent, logStatus);
 
-    session.once('Page.domContentEventFired', domContentLoadedListener);
+    if (!networkQuietOptions.pretendDCLAlreadyFired) {
+      session.once('Page.domContentEventFired', domContentLoadedListener);
+    } else {
+      domContentLoadedListener();
+    }
+
     let canceled = false;
     cancel = () => {
       if (canceled) return;
       canceled = true;
-      idleTimeout && clearTimeout(idleTimeout);
-      session.off('Page.domContentEventFired', domContentLoadedListener);
+      if (idleTimeout) clearTimeout(idleTimeout);
+      if (!networkQuietOptions.pretendDCLAlreadyFired) {
+        session.off('Page.domContentEventFired', domContentLoadedListener);
+      }
       networkMonitor.removeListener(busyEvent, onBusy);
       networkMonitor.removeListener(idleEvent, onIdle);
       networkMonitor.removeListener('requeststarted', logStatus);

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

@@ -572,7 +572,7 @@ class GatherRunner {
       driver.defaultSession,
       passContext.settings,
       {
-        url: passContext.url,
+        requestor: passContext.url,
         disableStorageReset: !passConfig.useThrottling,
         disableThrottling: !passConfig.useThrottling,
         blockedUrlPatterns: passConfig.blockedUrlPatterns,

package/lighthouse-core/gather/gatherers/full-page-screenshot.js

@@ -5,11 +5,13 @@
  */
 'use strict';
 
-/* globals window document getBoundingClientRect */
+/* globals window document getBoundingClientRect requestAnimationFrame */
 
 const FRGatherer = require('../../fraggle-rock/gather/base-gatherer.js');
 const emulation = require('../../lib/emulation.js');
 const pageFunctions = require('../../lib/page-functions.js');
+const NetworkMonitor = require('../driver/network-monitor.js');
+const {waitForNetworkIdle} = require('../driver/wait-for-condition.js');
 
 // JPEG quality setting
 // Exploration and examples of reports using different quality settings: https://docs.google.com/document/d/1ZSffucIca9XDW2eEwfoevrk-OTl7WQFeMf0CgeJAA8M/edit#
@@ -25,7 +27,6 @@ function kebabCaseToCamelCase(str) {
 
 /* c8 ignore start */
 
-// eslint-disable-next-line no-inner-declarations
 function getObservedDeviceMetrics() {
   // Convert the Web API's kebab case (landscape-primary) to camel case (landscapePrimary).
   const screenOrientationType = kebabCaseToCamelCase(window.screen.orientation.type);
@@ -40,6 +41,12 @@ function getObservedDeviceMetrics() {
   };
 }
 
+function waitForDoubleRaf() {
+  return new Promise((resolve) => {
+    requestAnimationFrame(() => requestAnimationFrame(resolve));
+  });
+}
+
 /* c8 ignore stop */
 
 class FullPageScreenshot extends FRGatherer {
@@ -53,7 +60,7 @@ class FullPageScreenshot extends FRGatherer {
    * @return {Promise<number>}
    * @see https://bugs.chromium.org/p/chromium/issues/detail?id=770769
    */
-  async getMaxScreenshotHeight(context) {
+  async getMaxTextureSize(context) {
     return await context.driver.executionContext.evaluate(pageFunctions.getMaxTextureSize, {
       args: [],
       useIsolation: true,
@@ -67,7 +74,7 @@ class FullPageScreenshot extends FRGatherer {
    */
   async _takeScreenshot(context) {
     const session = context.driver.defaultSession;
-    const maxScreenshotHeight = await this.getMaxScreenshotHeight(context);
+    const maxTextureSize = await this.getMaxTextureSize(context);
     const metrics = await session.sendCommand('Page.getLayoutMetrics');
 
     // Width should match emulated width, without considering content overhang.
@@ -76,8 +83,19 @@ class FullPageScreenshot extends FRGatherer {
     // Note: If the page is zoomed, many assumptions fail.
     //
     // Height should be as tall as the content. So we use contentSize.height
-    const width = Math.min(metrics.layoutViewport.clientWidth, maxScreenshotHeight);
-    const height = Math.min(metrics.contentSize.height, maxScreenshotHeight);
+    const width = Math.min(metrics.layoutViewport.clientWidth, maxTextureSize);
+    const height = Math.min(metrics.contentSize.height, maxTextureSize);
+
+    // Setup network monitor before we change the viewport.
+    const networkMonitor = new NetworkMonitor(session);
+    const waitForNetworkIdleResult = waitForNetworkIdle(session, networkMonitor, {
+      pretendDCLAlreadyFired: true,
+      networkQuietThresholdMs: 1000,
+      busyEvent: 'network-critical-busy',
+      idleEvent: 'network-critical-idle',
+      isIdle: recorder => recorder.isCriticalIdle(),
+    });
+    await networkMonitor.enable();
 
     await session.sendCommand('Emulation.setDeviceMetricsOverride', {
       // If we're gathering with mobile screenEmulation on (overlay scrollbars, etc), continue to use that for this screenshot.
@@ -89,9 +107,17 @@ class FullPageScreenshot extends FRGatherer {
       screenOrientation: {angle: 0, type: 'portraitPrimary'},
     });
 
-    // TODO: elements collected earlier in gathering are likely to have been shifted by now.
-    // The lower in the page, the more likely (footer elements especially).
-    // https://github.com/GoogleChrome/lighthouse/issues/11118
+    // Now that the viewport is taller, give the page some time to fetch new resources that
+    // are now in view.
+    await Promise.race([
+      new Promise(resolve => setTimeout(resolve, 1000 * 5)),
+      waitForNetworkIdleResult.promise,
+    ]);
+    waitForNetworkIdleResult.cancel();
+    await networkMonitor.disable();
+
+    // Now that new resources are (probably) fetched, wait long enough for a layout.
+    await context.driver.executionContext.evaluate(waitForDoubleRaf, {args: []});
 
     const result = await session.sendCommand('Page.captureScreenshot', {
       format: 'jpeg',

package/lighthouse-core/gather/gatherers/inputs.js

@@ -0,0 +1,113 @@
+/**
+ * @license Copyright 2020 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';
+
+/* global getNodeDetails */
+
+const FRGatherer = require('../../fraggle-rock/gather/base-gatherer.js');
+const pageFunctions = require('../../lib/page-functions.js');
+
+/* eslint-env browser, node */
+
+/**
+ * @return {LH.Artifacts['Inputs']}
+ */
+/* c8 ignore start */
+function collectElements() {
+  /** @type {LH.Artifacts.InputElement[]} */
+  const inputArtifacts = [];
+  /** @type {Map<HTMLFormElement, LH.Artifacts.FormElement>} */
+  const formElToArtifact = new Map();
+  /** @type {Map<HTMLLabelElement, LH.Artifacts.LabelElement>} */
+  const labelElToArtifact = new Map();
+
+  /** @type {HTMLFormElement[]} */
+  // @ts-expect-error - put into scope via stringification
+  const formEls = getElementsInDocument('form'); // eslint-disable-line no-undef
+  for (const formEl of formEls) {
+    formElToArtifact.set(formEl, {
+      id: formEl.id,
+      name: formEl.name,
+      autocomplete: formEl.autocomplete,
+      // @ts-expect-error - getNodeDetails put into scope via stringification
+      node: getNodeDetails(formEl),
+    });
+  }
+
+  /** @type {HTMLLabelElement[]} */
+  // @ts-expect-error - put into scope via stringification
+  const labelEls = getElementsInDocument('label'); // eslint-disable-line no-undef
+  for (const labelEl of labelEls) {
+    labelElToArtifact.set(labelEl, {
+      for: labelEl.htmlFor,
+      // @ts-expect-error - getNodeDetails put into scope via stringification
+      node: getNodeDetails(labelEl),
+    });
+  }
+
+  /** @type {HTMLInputElement[]} */
+  // @ts-expect-error - put into scope via stringification
+  const inputEls = getElementsInDocument('textarea, input, select'); // eslint-disable-line no-undef
+  for (const inputEl of inputEls) {
+    // If the input element is in a form (either because an ancestor element is <form> or the
+    // form= attribute is associated with a <form> element's id), this will be set.
+    const parentFormEl = inputEl.form;
+    const parentFormIndex = parentFormEl ?
+      [...formElToArtifact.keys()].indexOf(parentFormEl) :
+      undefined;
+    const labelIndices = [...inputEl.labels || []].map((labelEl) => {
+      return [...labelElToArtifact.keys()].indexOf(labelEl);
+    });
+
+    inputArtifacts.push({
+      parentFormIndex,
+      labelIndices,
+      id: inputEl.id,
+      name: inputEl.name,
+      type: inputEl.type,
+      placeholder: inputEl instanceof HTMLSelectElement ? undefined : inputEl.placeholder,
+      autocomplete: {
+        property: inputEl.autocomplete,
+        attribute: inputEl.getAttribute('autocomplete'),
+        // Requires `--enable-features=AutofillShowTypePredictions`.
+        prediction: inputEl.getAttribute('autofill-prediction'),
+      },
+      // @ts-expect-error - getNodeDetails put into scope via stringification
+      node: getNodeDetails(inputEl),
+    });
+  }
+
+  return {
+    inputs: inputArtifacts,
+    forms: [...formElToArtifact.values()],
+    labels: [...labelElToArtifact.values()],
+  };
+}
+/* c8 ignore stop */
+
+class Inputs extends FRGatherer {
+  /** @type {LH.Gatherer.GathererMeta} */
+  meta = {
+    supportedModes: ['snapshot', 'navigation'],
+  };
+
+  /**
+   * @param {LH.Gatherer.FRTransitionalContext} passContext
+   * @return {Promise<LH.Artifacts['Inputs']>}
+   */
+  async getArtifact(passContext) {
+    return passContext.driver.executionContext.evaluate(collectElements, {
+      args: [],
+      useIsolation: true,
+      deps: [
+        pageFunctions.getElementsInDocumentString,
+        pageFunctions.getNodeDetailsString,
+      ],
+    });
+  }
+}
+
+module.exports = Inputs;

package/lighthouse-core/index.js

@@ -47,11 +47,11 @@ async function lighthouse(url, flags = {}, configJSON, userConnection) {
   const connection = userConnection || new ChromeProtocol(flags.port, flags.hostname);
 
   // kick off a lighthouse run
-  const gatherFn = () => {
+  const artifacts = await Runner.gather(() => {
     const requestedUrl = URL.normalizeUrl(url);
     return Runner._gatherArtifactsFromBrowser(requestedUrl, options, connection);
-  };
-  return Runner.run(gatherFn, options);
+  }, options);
+  return Runner.audit(artifacts, options);
 }
 
 /**

package/lighthouse-core/lib/page-functions.js

@@ -138,7 +138,17 @@ function getOuterHTMLSnippet(element, ignoreAttrs = [], snippetCharacterLimit =
         dirty = true;
       }
 
-      if (dirty) clone.setAttribute(attributeName, attributeValue);
+      if (dirty) {
+        // Style attributes can be blocked by the CSP if they are set via `setAttribute`.
+        // If we are trying to set the style attribute, use `el.style.cssText` instead.
+        // https://github.com/GoogleChrome/lighthouse/issues/13630
+        if (attributeName === 'style') {
+          const elementWithStyle = /** @type {HTMLElement} */ (clone);
+          elementWithStyle.style.cssText = attributeValue;
+        } else {
+          clone.setAttribute(attributeName, attributeValue);
+        }
+      }
       charCount += attributeName.length + attributeValue.length;
     }
 

package/lighthouse-core/lib/sentry.js

@@ -7,8 +7,10 @@
 
 const log = require('lighthouse-logger');
 
-/** @typedef {import('raven').CaptureOptions} CaptureOptions */
-/** @typedef {import('raven').ConstructorOptions} ConstructorOptions */
+/** @typedef {import('@sentry/node').Breadcrumb} Breadcrumb */
+/** @typedef {import('@sentry/node').NodeClient} NodeClient */
+/** @typedef {import('@sentry/node').NodeOptions} NodeOptions */
+/** @typedef {import('@sentry/node').Severity} Severity */
 
 const SENTRY_URL = 'https://a6bb0da87ee048cc9ae2a345fc09ab2e:63a7029f46f74265981b7e005e0f69f8@sentry.io/174697';
 
@@ -21,7 +23,7 @@ const SAMPLED_ERRORS = [
   // e.g.: {pattern: /No.*node with given id/, rate: 0.01},
 ];
 
-const noop = () => {};
+const noop = () => { };
 
 /**
  * A delegate for sentry so that environments without error reporting enabled will use
@@ -29,14 +31,14 @@ const noop = () => {};
  */
 const sentryDelegate = {
   init,
-  /** @type {(message: string, options?: CaptureOptions) => void} */
+  /** @type {(message: string, level?: Severity) => void} */
   captureMessage: noop,
-  /** @type {(breadcrumb: any) => void} */
+  /** @type {(breadcrumb: Breadcrumb) => void} */
   captureBreadcrumb: noop,
   /** @type {() => any} */
   getContext: noop,
-  /** @type {(error: Error, options?: CaptureOptions) => Promise<void>} */
-  captureException: async () => {},
+  /** @type {(error: Error, options: {level?: string, tags?: {[key: string]: any}, extra?: {[key: string]: any}}) => Promise<void>} */
+  captureException: async () => { },
   _shouldSample() {
     return SAMPLE_RATE >= Math.random();
   },
@@ -44,7 +46,7 @@ const sentryDelegate = {
 
 /**
  * When called, replaces noops with actual Sentry implementation.
- * @param {{url: string, flags: LH.CliFlags, environmentData: ConstructorOptions}} opts
+ * @param {{url: string, flags: LH.CliFlags, environmentData: NodeOptions}} opts
  */
 function init(opts) {
   // If error reporting is disabled, leave the functions as a noop
@@ -58,15 +60,25 @@ function init(opts) {
   }
 
   try {
-    const Sentry = require('raven');
-    const sentryConfig = Object.assign({}, opts.environmentData,
-      {captureUnhandledRejections: true});
-    Sentry.config(SENTRY_URL, sentryConfig).install();
+    const Sentry = require('@sentry/node');
+    Sentry.init({
+      ...opts.environmentData,
+      dsn: SENTRY_URL,
+    });
+
+    const extras = {
+      ...opts.flags.throttling,
+      channel: opts.flags.channel || 'cli',
+      url: opts.url,
+      formFactor: opts.flags.formFactor,
+      throttlingMethod: opts.flags.throttlingMethod,
+    };
+    Sentry.setExtras(extras);
 
     // Have each delegate function call the corresponding sentry function by default
     sentryDelegate.captureMessage = (...args) => Sentry.captureMessage(...args);
-    sentryDelegate.captureBreadcrumb = (...args) => Sentry.captureBreadcrumb(...args);
-    sentryDelegate.getContext = () => Sentry.getContext();
+    sentryDelegate.captureBreadcrumb = (...args) => Sentry.addBreadcrumb(...args);
+    sentryDelegate.getContext = () => extras;
 
     // Keep a record of exceptions per audit/gatherer so we can just report once
     const sentryExceptionCache = new Map();
@@ -107,21 +119,24 @@ function init(opts) {
         opts.tags.protocolMethod = err.protocolMethod;
       }
 
-      return new Promise(resolve => {
-        Sentry.captureException(err, opts, () => resolve());
+      Sentry.withScope(scope => {
+        if (opts.level) {
+          // @ts-expect-error - allow any string.
+          scope.setLevel(opts.level);
+        }
+        if (opts.tags) {
+          scope.setTags(opts.tags);
+        }
+        if (opts.extra) {
+          scope.setExtras(opts.extra);
+        }
+        Sentry.captureException(err);
       });
     };
-
-    const context = Object.assign({
-      url: opts.url,
-      formFactor: opts.flags.formFactor,
-      throttlingMethod: opts.flags.throttlingMethod,
-    }, opts.flags.throttling);
-    Sentry.mergeContext({extra: Object.assign({}, opts.environmentData.extra, context)});
   } catch (e) {
     log.warn(
       'sentry',
-      'Could not load raven library, errors will not be reported.'
+      'Could not load Sentry, errors will not be reported.'
     );
   }
 }