lighthouse 10.2.0-dev.20230529 → 10.2.0-dev.20230531

package/core/audits/audit.d.ts

@@ -149,9 +149,10 @@ export class Audit {
     /**
      * @param {typeof Audit} audit
      * @param {string | LH.IcuMessage} errorMessage
+     * @param {string=} errorStack
      * @return {LH.RawIcu<LH.Audit.Result>}
      */
-    static generateErrorAuditResult(audit: typeof Audit, errorMessage: string | LH.IcuMessage): LH.RawIcu<LH.Audit.Result>;
+    static generateErrorAuditResult(audit: typeof Audit, errorMessage: string | LH.IcuMessage, errorStack?: string | undefined): LH.RawIcu<LH.Audit.Result>;
     /**
      * @param {typeof Audit} audit
      * @param {LH.Audit.Product} product

package/core/audits/audit.js

@@ -348,12 +348,14 @@ class Audit {
   /**
    * @param {typeof Audit} audit
    * @param {string | LH.IcuMessage} errorMessage
+   * @param {string=} errorStack
    * @return {LH.RawIcu<LH.Audit.Result>}
    */
-  static generateErrorAuditResult(audit, errorMessage) {
+  static generateErrorAuditResult(audit, errorMessage, errorStack) {
     return Audit.generateAuditResult(audit, {
       score: null,
       errorMessage,
+      errorStack,
     });
   }
 
@@ -371,7 +373,7 @@ class Audit {
     let scoreDisplayMode = audit.meta.scoreDisplayMode || Audit.SCORING_MODES.BINARY;
 
     // But override if product contents require it.
-    if (product.errorMessage) {
+    if (product.errorMessage !== undefined) {
       // Error result.
       scoreDisplayMode = Audit.SCORING_MODES.ERROR;
     } else if (product.notApplicable) {
@@ -407,6 +409,7 @@ class Audit {
       displayValue: product.displayValue,
       explanation: product.explanation,
       errorMessage: product.errorMessage,
+      errorStack: product.errorStack,
       warnings: product.warnings,
 
       details: product.details,

package/core/audits/network-requests.js

@@ -8,6 +8,7 @@ import {Audit} from './audit.js';
 import UrlUtils from '../lib/url-utils.js';
 import {NetworkRecords} from '../computed/network-records.js';
 import {MainResource} from '../computed/main-resource.js';
+import {EntityClassification} from '../computed/entity-classification.js';
 
 class NetworkRequests extends Audit {
   /**
@@ -31,6 +32,8 @@ class NetworkRequests extends Audit {
   static async audit(artifacts, context) {
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const records = await NetworkRecords.request(devtoolsLog, context);
+    const classifiedEntities = await EntityClassification.request(
+      {URL: artifacts.URL, devtoolsLog}, context);
     const earliestRendererStartTime = records.reduce(
       (min, record) => Math.min(min, record.rendererStartTime),
       Infinity
@@ -61,6 +64,8 @@ class NetworkRequests extends Audit {
         ((record.frameId === mainFrameId) || undefined) :
         undefined;
 
+      const entity = classifiedEntities.entityByUrl.get(record.url);
+
       return {
         url: UrlUtils.elideDataURI(record.url),
         sessionTargetType: record.sessionTargetType,
@@ -77,6 +82,7 @@ class NetworkRequests extends Audit {
         priority: record.priority,
         isLinkPreload,
         experimentalFromMainFrame,
+        entity: entity?.name,
         lrEndTimeDeltaMs: endTimeDeltaMs, // Only exists on Lightrider runs
         lrTCPMs: TCPMs, // Only exists on Lightrider runs
         lrRequestMs: requestMs, // Only exists on Lightrider runs

package/core/gather/driver/execution-context.js

@@ -125,14 +125,22 @@ class ExecutionContext {
 
     this._session.setNextProtocolTimeout(timeout);
     const response = await this._session.sendCommand('Runtime.evaluate', evaluationParams);
-    if (response.exceptionDetails) {
+
+    const ex = response.exceptionDetails;
+    if (ex) {
       // An error occurred before we could even create a Promise, should be *very* rare.
       // Also occurs when the expression is not valid JavaScript.
-      const errorMessage = response.exceptionDetails.exception ?
-        response.exceptionDetails.exception.description :
-        response.exceptionDetails.text;
-      return Promise.reject(new Error(`Evaluation exception: ${errorMessage}`));
+      const elidedExpression = expression.replace(/\s+/g, ' ').substring(0, 100);
+      const messageLines = [
+        'Runtime.evaluate exception',
+        `Expression: ${elidedExpression}\n---- (elided)`,
+        !ex.stackTrace ? `Parse error at: ${ex.lineNumber + 1}:${ex.columnNumber + 1}` : null,
+        ex.exception?.description || ex.text,
+      ].filter(Boolean);
+      const evaluationError = new Error(messageLines.join('\n'));
+      return Promise.reject(evaluationError);
     }
+
     // Protocol should always return a 'result' object, but it is sometimes undefined.  See #6026.
     if (response.result === undefined) {
       return Promise.reject(

package/core/legacy/config/config.d.ts

@@ -77,7 +77,7 @@ export class LegacyResolvedConfig implements LH.Config.LegacyResolvedConfig {
      */
     static requireGatherers(passes: Array<Required<LH.Config.PassJson>> | null, configDir?: string | undefined): Promise<LegacyResolvedConfig['passes']>;
     /**
-     * @deprecated `Config.fromJson` should be used instead.
+     * @deprecated `LegacyResolvedConfig.fromJson` should be used instead.
      * @constructor
      * @param {LH.Config} config
      * @param {{settings: LH.Config.Settings, passes: ?LH.Config.Pass[], audits: ?LH.Config.AuditDefn[]}} opts

package/core/legacy/config/config.js

@@ -205,7 +205,7 @@ class LegacyResolvedConfig {
   }
 
   /**
-   * @deprecated `Config.fromJson` should be used instead.
+   * @deprecated `LegacyResolvedConfig.fromJson` should be used instead.
    * @constructor
    * @param {LH.Config} config
    * @param {{settings: LH.Config.Settings, passes: ?LH.Config.Pass[], audits: ?LH.Config.AuditDefn[]}} opts

package/core/lib/asset-saver.d.ts

@@ -98,4 +98,8 @@ export function stringifyReplacer(key: string, value: any): any;
  * @param {LH.Result.MeasureEntry[]} timings
  */
 export function normalizeTimingEntries(timings: LH.Result.MeasureEntry[]): void;
+/**
+ * @param {LH.Result} lhr
+ */
+export function elideAuditErrorStacks(lhr: LH.Result): void;
 //# sourceMappingURL=asset-saver.d.ts.map

package/core/lib/asset-saver.js

@@ -7,6 +7,7 @@
 import fs from 'fs';
 import path from 'path';
 import stream from 'stream';
+import url from 'url';
 
 import log from 'lighthouse-logger';
 
@@ -16,6 +17,7 @@ import {MetricTraceEvents} from './traces/metric-trace-events.js';
 import {NetworkAnalysis} from '../computed/network-analysis.js';
 import {LoadSimulator} from '../computed/load-simulator.js';
 import {LighthouseError} from '../lib/lh-error.js';
+import {LH_ROOT} from '../../root.js';
 
 const optionsFilename = 'options.json';
 const artifactsFilename = 'artifacts.json';
@@ -425,6 +427,22 @@ function normalizeTimingEntries(timings) {
   }
 }
 
+/**
+ * @param {LH.Result} lhr
+ */
+function elideAuditErrorStacks(lhr) {
+  const baseCallFrameUrl = url.pathToFileURL(LH_ROOT);
+  for (const auditResult of Object.values(lhr.audits)) {
+    if (auditResult.errorStack) {
+      auditResult.errorStack = auditResult.errorStack
+        // Make paths relative to the repo root.
+        .replaceAll(baseCallFrameUrl.pathname, '')
+        // Remove line/col info.
+        .replaceAll(/:\d+:\d+/g, '');
+    }
+  }
+}
+
 export {
   saveArtifacts,
   saveFlowArtifacts,
@@ -438,4 +456,5 @@ export {
   saveLanternNetworkData,
   stringifyReplacer,
   normalizeTimingEntries,
+  elideAuditErrorStacks,
 };

package/core/lib/lh-error.d.ts

@@ -8,20 +8,24 @@ export type LighthouseErrorDefinition = {
     lhrRuntimeError?: boolean | undefined;
 };
 export type SerializedLighthouseError = {
-    [p: string]: string | undefined;
     sentinel: '__LighthouseErrorSentinel';
     code: string;
     stack?: string | undefined;
+    cause?: unknown;
+    properties?: {
+        [p: string]: string | undefined;
+    } | undefined;
 };
 export type SerializedBaseError = {
     sentinel: '__ErrorSentinel';
     message: string;
     code?: string;
     stack?: string;
+    cause?: unknown;
 };
 /**
- * @typedef {{sentinel: '__LighthouseErrorSentinel', code: string, stack?: string, [p: string]: string|undefined}} SerializedLighthouseError
- * @typedef {{sentinel: '__ErrorSentinel', message: string, code?: string, stack?: string}} SerializedBaseError
+ * @typedef {{sentinel: '__LighthouseErrorSentinel', code: string, stack?: string, cause?: unknown, properties?: {[p: string]: string|undefined}}} SerializedLighthouseError
+ * @typedef {{sentinel: '__ErrorSentinel', message: string, code?: string, stack?: string, cause?: unknown}} SerializedBaseError
  */
 export class LighthouseError extends Error {
     /**
@@ -55,8 +59,9 @@ export class LighthouseError extends Error {
     /**
      * @param {LighthouseErrorDefinition} errorDefinition
      * @param {Record<string, string|undefined>=} properties
+     * @param {ErrorOptions=} options
      */
-    constructor(errorDefinition: LighthouseErrorDefinition, properties?: Record<string, string | undefined> | undefined);
+    constructor(errorDefinition: LighthouseErrorDefinition, properties?: Record<string, string | undefined> | undefined, options?: ErrorOptions | undefined);
     code: string;
     friendlyMessage: import("../index.js").IcuMessage;
     lhrRuntimeError: boolean;

package/core/lib/lh-error.js

@@ -107,17 +107,18 @@ const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
 const LHERROR_SENTINEL = '__LighthouseErrorSentinel';
 const ERROR_SENTINEL = '__ErrorSentinel';
 /**
- * @typedef {{sentinel: '__LighthouseErrorSentinel', code: string, stack?: string, [p: string]: string|undefined}} SerializedLighthouseError
- * @typedef {{sentinel: '__ErrorSentinel', message: string, code?: string, stack?: string}} SerializedBaseError
+ * @typedef {{sentinel: '__LighthouseErrorSentinel', code: string, stack?: string, cause?: unknown, properties?: {[p: string]: string|undefined}}} SerializedLighthouseError
+ * @typedef {{sentinel: '__ErrorSentinel', message: string, code?: string, stack?: string, cause?: unknown}} SerializedBaseError
  */
 
 class LighthouseError extends Error {
   /**
    * @param {LighthouseErrorDefinition} errorDefinition
    * @param {Record<string, string|undefined>=} properties
+   * @param {ErrorOptions=} options
    */
-  constructor(errorDefinition, properties) {
-    super(errorDefinition.code);
+  constructor(errorDefinition, properties, options) {
+    super(errorDefinition.code, options);
     this.name = 'LighthouseError';
     this.code = errorDefinition.code;
     // Add additional properties to be ICU replacements in the error string.
@@ -163,19 +164,20 @@ class LighthouseError extends Error {
     if (err instanceof LighthouseError) {
       // Remove class props so that remaining values were what was passed in as `properties`.
       // eslint-disable-next-line no-unused-vars
-      const {name, code, message, friendlyMessage, lhrRuntimeError, stack, ...properties} = err;
+      const {name, code, message, friendlyMessage, lhrRuntimeError, stack, cause, ...properties} = err;
 
       return {
         sentinel: LHERROR_SENTINEL,
         code,
         stack,
-        ...properties,
+        cause,
+        properties: /** @type {{ [p: string]: string | undefined }} */ (properties),
       };
     }
 
     // Unexpected errors won't be LighthouseErrors, but we want them serialized as well.
     if (err instanceof Error) {
-      const {message, stack} = err;
+      const {message, stack, cause} = err;
       // @ts-expect-error - code can be helpful for e.g. node errors, so preserve it if it's present.
       const code = err.code;
       return {
@@ -183,6 +185,7 @@ class LighthouseError extends Error {
         message,
         code,
         stack,
+        cause,
       };
     }
 
@@ -203,17 +206,18 @@ class LighthouseError extends Error {
       if (possibleError.sentinel === LHERROR_SENTINEL) {
         // Include sentinel in destructuring so it doesn't end up in `properties`.
         // eslint-disable-next-line no-unused-vars
-        const {sentinel, code, stack, ...properties} = /** @type {SerializedLighthouseError} */ (possibleError);
+        const {code, stack, cause, properties} = /** @type {SerializedLighthouseError} */ (possibleError);
         const errorDefinition = LighthouseError.errors[/** @type {keyof typeof ERRORS} */ (code)];
-        const lhError = new LighthouseError(errorDefinition, properties);
+        const lhError = new LighthouseError(errorDefinition, properties, {cause});
         lhError.stack = stack;
 
         return lhError;
       }
 
       if (possibleError.sentinel === ERROR_SENTINEL) {
-        const {message, code, stack} = /** @type {SerializedBaseError} */ (possibleError);
-        const error = new Error(message);
+        const {message, code, stack, cause} = /** @type {SerializedBaseError} */ (possibleError);
+        const opts = cause ? {cause} : undefined;
+        const error = new Error(message, opts);
         Object.assign(error, {code, stack});
         return error;
       }

package/core/runner.js

@@ -429,7 +429,7 @@ class Runner {
 
           // Create a friendlier display error and mark it as expected to avoid duplicates in Sentry
           const error = new LighthouseError(LighthouseError.errors.ERRORED_REQUIRED_ARTIFACT,
-              {artifactName, errorMessage: artifactError.message});
+              {artifactName, errorMessage: artifactError.message}, {cause: artifactError});
           // @ts-expect-error Non-standard property added to Error
           error.expected = true;
           throw error;
@@ -468,7 +468,9 @@ class Runner {
       Sentry.captureException(err, {tags: {audit: audit.meta.id}, level: 'error'});
       // Errors become error audit result.
       const errorMessage = err.friendlyMessage ? err.friendlyMessage : err.message;
-      auditResult = Audit.generateErrorAuditResult(audit, errorMessage);
+      // Prefer the stack trace closest to the error.
+      const stack = err.cause?.stack ?? err.stack;
+      auditResult = Audit.generateErrorAuditResult(audit, errorMessage, stack);
     }
 
     log.timeEnd(status);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lighthouse",
   "type": "module",
-  "version": "10.2.0-dev.20230529",
+  "version": "10.2.0-dev.20230531",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./core/index.js",
   "bin": {
@@ -179,7 +179,7 @@
     "rollup-plugin-terser": "^7.0.2",
     "tabulator-tables": "^4.9.3",
     "terser": "^5.3.8",
-    "testdouble": "^3.16.8",
+    "testdouble": "^3.17.2",
     "typed-query-selector": "^2.6.1",
     "typescript": "^5.0.4",
     "wait-for-expect": "^3.0.2",

package/tsconfig-base.json

@@ -11,7 +11,7 @@
     "outDir": ".tmp/tsbuildinfo/",
     "rootDir": ".",
 
-    "target": "es2020",
+    "target": "es2022",
     "module": "es2022",
     "moduleResolution": "node",
     "esModuleInterop": true,

package/types/audit.d.ts

@@ -75,6 +75,8 @@ declare module Audit {
     explanation?: string | IcuMessage;
     /** Error message from any exception thrown while running this audit. */
     errorMessage?: string | IcuMessage;
+    /** Error stack from any exception thrown while running this audit. */
+    errorStack?: string;
     warnings?: Array<string | IcuMessage>;
     /** Overrides scoreDisplayMode with notApplicable if set to true */
     notApplicable?: boolean;

package/types/lhr/audit-result.d.ts

@@ -39,6 +39,8 @@ export interface Result {
   explanation?: string;
   /** Error message from any exception thrown while running this audit. */
   errorMessage?: string;
+  /** Error stack from any exception thrown while running this audit. */
+  errorStack?: string;
   warnings?: string[];
   /** The scored value of the audit, provided in the range `0-1`, or null if `scoreDisplayMode` indicates not scored. */
   score: number|null;