@netlify/build 29.26.3 → 29.26.4

package/lib/core/dev.d.ts

@@ -10,8 +10,8 @@ export function startDev(devCommand: any, flags?: {}): Promise<{
     severityCode: number;
     logs: import("../log/logger.js").BufferedLogs | undefined;
     error: {
-        message: any;
-        stack: any;
+        message: string;
+        stack: string;
     };
     netlifyConfig?: undefined;
     configMutations?: undefined;

package/lib/error/handle.d.ts

@@ -1,17 +1,2 @@
 import { ErrorParam } from '../core/types.js';
-export declare const handleBuildError: (error: Error, { errorMonitor, netlifyConfig, childEnv, logs, debug, testOpts }: ErrorParam) => Promise<{
-    message: any;
-    stack: any;
-    errorProps: any;
-    errorInfo: any;
-    type: any;
-    severity: any;
-    title: any;
-    group: any;
-    stackType: any;
-    locationType: any;
-    showInBuildLog: any;
-    showErrorProps: any;
-    rawStack: any;
-    errorMetadata: any;
-}>;
+export declare const handleBuildError: (error: Error, { errorMonitor, netlifyConfig, childEnv, logs, debug, testOpts }: ErrorParam) => Promise<import("./types.js").BasicErrorInfo>;

package/lib/error/info.d.ts

@@ -1,6 +1,6 @@
-export function addDefaultErrorInfo(error: any, info: any): void;
-export function addErrorInfo(error: any, info: any): void;
-export function getErrorInfo(error: any): any[];
-export function changeErrorType(error: any, oldType: any, newType: any): void;
-export function isBuildError(error: any): boolean;
-export const CUSTOM_ERROR_KEY: "customErrorInfo";
+export declare const addDefaultErrorInfo: (error: any, info: any) => void;
+export declare const addErrorInfo: (error: any, info: any) => void;
+export declare const getErrorInfo: (error: any) => any[];
+export declare const changeErrorType: (error: any, oldType: any, newType: any) => void;
+export declare const isBuildError: (error: any) => boolean;
+export declare const CUSTOM_ERROR_KEY = "customErrorInfo";

package/lib/error/parse/location.d.ts

@@ -1,5 +1,5 @@
-export function getLocationInfo({ stack, location, locationType }: {
+export declare const getLocationInfo: ({ stack, location, locationType }: {
     stack: any;
     location: any;
     locationType: any;
-}): any;
+}) => any;

package/lib/error/parse/parse.d.ts

@@ -1,39 +1,7 @@
-export function getFullErrorInfo({ error, colors, debug }: {
+import type { BuildError, BasicErrorInfo } from '../types.js';
+export declare const getFullErrorInfo: ({ error, colors, debug }: {
     error: any;
     colors: any;
     debug: any;
-}): {
-    title: any;
-    message: any;
-    tsConfigInfo: any;
-    pluginInfo: string | undefined;
-    locationInfo: any;
-    errorProps: string | undefined;
-    errorMetadata: any;
-    stack: any;
-    errorInfo: any;
-    type: any;
-    severity: any;
-    group: any;
-    stackType: any;
-    locationType: any;
-    showInBuildLog: any;
-    showErrorProps: any;
-    rawStack: any;
-};
-export function parseErrorInfo(error: any): {
-    message: any;
-    stack: any;
-    errorProps: any;
-    errorInfo: any;
-    type: any;
-    severity: any;
-    title: any;
-    group: any;
-    stackType: any;
-    locationType: any;
-    showInBuildLog: any;
-    showErrorProps: any;
-    rawStack: any;
-    errorMetadata: any;
-};
+}) => BuildError;
+export declare const parseErrorInfo: (error: Error) => BasicErrorInfo;

package/lib/error/parse/parse.js

@@ -1,6 +1,6 @@
 import { serializeObject } from '../../log/serialize.js';
 import { getErrorInfo } from '../info.js';
-import { getTypeInfo } from '../type.js';
+import { getTypeInfo } from '../types.js';
 import { getLocationInfo } from './location.js';
 import { normalizeError } from './normalize.js';
 import { getPluginInfo } from './plugin.js';
@@ -9,9 +9,12 @@ import { getStackInfo } from './stack.js';
 // Add additional type-specific error information
 export const getFullErrorInfo = function ({ error, colors, debug }) {
     const basicErrorInfo = parseErrorInfo(error);
-    const { message, stack, errorProps, errorInfo, errorInfo: { location = {}, plugin = {}, tsConfig }, severity, title, stackType, locationType, showErrorProps, rawStack, errorMetadata, } = basicErrorInfo;
+    const { message, stack, errorProps, errorInfo, severity, title, stackType, locationType, showErrorProps, rawStack, errorMetadata, } = basicErrorInfo;
+    const { location = {}, plugin = {}, tsConfig } = errorInfo;
     const titleA = getTitle(title, errorInfo);
     const { message: messageA, stack: stackA } = getStackInfo({ message, stack, stackType, rawStack, severity, debug });
+    // FIXME here location should be PluginLocation type, but I'm affraid to mess up the current
+    // getPluginInfo behaviour by running a type check
     const pluginInfo = getPluginInfo(plugin, location);
     const tsConfigInfo = getTsConfigInfo(tsConfig);
     const locationInfo = getLocationInfo({ stack: stackA, location, locationType });

package/lib/error/parse/plugin.d.ts

@@ -1,9 +1,19 @@
-export function getPluginInfo({ pluginPackageJson }: {
+export declare const getPluginInfo: ({ pluginPackageJson }: {
     pluginPackageJson?: {} | undefined;
 }, { packageName, loadedFrom }: {
     packageName: any;
     loadedFrom: any;
-}): string | undefined;
-export function getHomepage(pluginPackageJson?: {}, { loadedFrom }?: {
-    loadedFrom: any;
-}): any;
+}) => string | undefined;
+type pkgJSONData = {
+    name?: string;
+    bugs?: {
+        url?: string;
+    };
+    repository?: {
+        url?: string;
+    };
+};
+export declare const getHomepage: (pluginPackageJson?: pkgJSONData, { loadedFrom }?: {
+    loadedFrom?: string | undefined;
+}) => string | undefined;
+export {};

package/lib/error/parse/plugin.js

@@ -19,7 +19,7 @@ const serializeField = function ({ name, getField, pluginPackageJson, packageNam
     return `${nameA}${field}`;
 };
 const NAME_PADDING = 16;
-const getPackage = function (pluginPackageJson, { packageName }) {
+const getPackage = function (_, { packageName }) {
     return packageName;
 };
 const getVersion = function ({ version }) {

package/lib/error/parse/serialize_log.d.ts

@@ -1,14 +1,7 @@
-export function serializeLogError({ fullErrorInfo: { title, severity, message, pluginInfo, locationInfo, tsConfigInfo, errorProps }, }: {
-    fullErrorInfo: {
-        title: any;
-        severity: any;
-        message: any;
-        pluginInfo: any;
-        locationInfo: any;
-        tsConfigInfo: any;
-        errorProps: any;
-    };
-}): {
-    title: any;
+import type { BuildError } from '../types.js';
+export declare const serializeLogError: ({ fullErrorInfo: { title, severity, message, pluginInfo, locationInfo, tsConfigInfo, errorProps }, }: {
+    fullErrorInfo: BuildError;
+}) => {
+    title: string | (import("../types.js").TitleFunction & string);
     body: any;
 };

package/lib/error/types.d.ts

@@ -0,0 +1,170 @@
+import { Attributes } from '@opentelemetry/api';
+export type BuildError = Omit<BasicErrorInfo, 'errorProps'> & {
+    title: string;
+    pluginInfo?: string;
+    locationInfo?: string;
+    errorProps?: string;
+};
+export type BasicErrorInfo = {
+    message: string;
+    stack: string;
+    severity: string;
+    type: ErrorTypes;
+    errorInfo: ErrorInfo;
+    errorProps: Record<string, unknown>;
+    errorMetadata: any;
+    tsConfigInfo?: any;
+} & ErrorType;
+/**
+ * Error severity groups the errors emitted by build and used to translate to exit code via SEVERITY_MAP
+ */
+declare enum ErrorSeverity {
+    /**
+     * build success
+     */
+    success = "success",
+    /**
+     * not an error, e.g. build cancellation
+     */
+    none = "none",
+    /**
+     * user error
+     */
+    info = "info",
+    /**
+     * community plugin error
+     */
+    warning = "warning",
+    /**
+     * system error, including core plugin error
+     */
+    error = "Error"
+}
+/**
+ * How the stack trace should appear in the build error logs
+ */
+declare enum StackType {
+    /**
+     * not printed
+     */
+    none = "none",
+    /**
+     * printed as is
+     */
+    stack = "stack",
+    /**
+     * printed as is, but taken from `error.message`. Used when `error.stack` is not being correct due to the error being passed between different processes.
+     */
+    message = "message"
+}
+type GroupFunction = ({ location }: {
+    location: ErrorLocation;
+}) => string;
+export type TitleFunction = ({ location }: {
+    location: ErrorLocation;
+}) => string;
+export type ErrorInfo = {
+    plugin?: any;
+    tsConfig?: any;
+    location: ErrorLocation;
+};
+export type BuildCommandLocation = {
+    buildCommand: string;
+    buildCommandOrigin: string;
+};
+export declare const isBuildCommandLocation: (location?: ErrorLocation) => location is BuildCommandLocation;
+export type FunctionsBundlingLocation = {
+    functionName: string;
+    functionType: string;
+};
+export declare const isFunctionsBundlingLocation: (location?: ErrorLocation) => location is FunctionsBundlingLocation;
+export type CoreStepLocation = {
+    coreStepName: string;
+};
+export declare const isCoreStepLocation: (location?: ErrorLocation) => location is CoreStepLocation;
+export type PluginLocation = {
+    event: string;
+    packageName: string;
+    loadedFrom: string;
+    origin: string;
+    input?: string;
+};
+export declare const isPluginLocation: (location?: ErrorLocation) => location is PluginLocation;
+export type APILocation = {
+    endpoint: string;
+    parameters?: any;
+};
+export declare const isAPILocation: (location?: ErrorLocation) => location is APILocation;
+export type ErrorLocation = BuildCommandLocation | FunctionsBundlingLocation | CoreStepLocation | PluginLocation | APILocation;
+/**
+ * Given a BuildError, extract the relevant trace attributes to add to the on-going Span
+ */
+export declare const buildErrorToTracingAttributes: (error: BuildError | BasicErrorInfo) => Attributes;
+/**
+ * Retrieve error-type specific information
+ */
+export declare const getTypeInfo: ({ type }: {
+    type: any;
+}) => any;
+/**
+ * Interface for build error types
+ */
+export interface ErrorType {
+    /**
+     *  main title shown in build error logs and in the UI (statuses)
+     */
+    title: TitleFunction | string;
+    /**
+     *  retrieve a human-friendly location of the error, printed
+     */
+    locationType?: string;
+    /**
+     *  `true` when the `Error` instance static properties
+     */
+    showErrorProps?: boolean;
+    /**
+     *  `true` when the stack trace should be cleaned up
+     */
+    rawStack?: boolean;
+    /**
+     *  `true` when we want this error to show in build logs (defaults to true)
+     */
+    showInBuildLog?: boolean;
+    /**
+     *  main title shown in Bugsnag. Also used to group errors together in Bugsnag, combined with `error.message`. Defaults to `title`.
+     */
+    group?: GroupFunction;
+    /**
+     *  error severity (also used by Bugsnag)
+     */
+    severity: keyof typeof ErrorSeverity;
+    /**
+     *  how the stack trace should appear in build error logs
+     */
+    stackType: keyof typeof StackType;
+}
+declare const ErrorTypeMap: {
+    /**
+     * Plugin called `utils.build.cancelBuild()`
+     */
+    readonly cancelBuild: "cancelBuild";
+    readonly resolveConfig: "resolveConfig";
+    readonly dependencies: "dependencies";
+    readonly pluginInput: "pluginInput";
+    readonly pluginUnsupportedVersion: "pluginUnsupportedVersion";
+    readonly buildCommand: "buildCommand";
+    readonly functionsBundling: "functionsBundling";
+    readonly secretScanningFoundSecrets: "secretScanningFoundSecrets";
+    readonly failPlugin: "failPlugin";
+    readonly failBuild: "failBuild";
+    readonly pluginValidation: "pluginValidation";
+    readonly pluginInternal: "pluginInternal";
+    readonly ipc: "ipc";
+    readonly corePlugin: "corePlugin";
+    readonly coreStep: "coreStep";
+    readonly api: "api";
+    readonly exception: "exception";
+    readonly telemetry: "telemetry";
+};
+type ErrorTypes = keyof typeof ErrorTypeMap;
+export {};

package/lib/error/types.js

@@ -0,0 +1,338 @@
+/**
+ * Error severity groups the errors emitted by build and used to translate to exit code via SEVERITY_MAP
+ */
+var ErrorSeverity;
+(function (ErrorSeverity) {
+    /**
+     * build success
+     */
+    ErrorSeverity["success"] = "success";
+    /**
+     * not an error, e.g. build cancellation
+     */
+    ErrorSeverity["none"] = "none";
+    /**
+     * user error
+     */
+    ErrorSeverity["info"] = "info";
+    /**
+     * community plugin error
+     */
+    ErrorSeverity["warning"] = "warning";
+    /**
+     * system error, including core plugin error
+     */
+    ErrorSeverity["error"] = "Error";
+})(ErrorSeverity || (ErrorSeverity = {}));
+/**
+ * How the stack trace should appear in the build error logs
+ */
+var StackType;
+(function (StackType) {
+    /**
+     * not printed
+     */
+    StackType["none"] = "none";
+    /**
+     * printed as is
+     */
+    StackType["stack"] = "stack";
+    /**
+     * printed as is, but taken from `error.message`. Used when `error.stack` is not being correct due to the error being passed between different processes.
+     */
+    StackType["message"] = "message";
+})(StackType || (StackType = {}));
+export const isBuildCommandLocation = function (location) {
+    const buildLocation = location;
+    return typeof buildLocation?.buildCommand === 'string' && typeof buildLocation?.buildCommandOrigin === 'string';
+};
+export const isFunctionsBundlingLocation = function (location) {
+    const bundlingLocation = location;
+    return typeof bundlingLocation?.functionName === 'string' && typeof bundlingLocation?.functionType === 'string';
+};
+export const isCoreStepLocation = function (location) {
+    return typeof location?.coreStepName === 'string';
+};
+export const isPluginLocation = function (location) {
+    const pluginLocation = location;
+    return (typeof pluginLocation?.event === 'string' &&
+        typeof pluginLocation?.packageName === 'string' &&
+        typeof pluginLocation?.loadedFrom === 'string');
+};
+export const isAPILocation = function (location) {
+    return typeof location?.endpoint === 'string';
+};
+const buildErrorAttributePrefix = 'build.error';
+const errorLocationToTracingAttributes = function (location) {
+    const locationAttributePrefix = `${buildErrorAttributePrefix}.location`;
+    if (isBuildCommandLocation(location)) {
+        return {
+            [`${locationAttributePrefix}.command`]: location.buildCommand,
+            [`${locationAttributePrefix}.command_origin`]: location.buildCommandOrigin,
+        };
+    }
+    if (isPluginLocation(location)) {
+        return {
+            [`${locationAttributePrefix}.plugin.event`]: location.event,
+            [`${locationAttributePrefix}.plugin.package_name`]: location.packageName,
+            [`${locationAttributePrefix}.plugin.loaded_from`]: location.loadedFrom,
+            [`${locationAttributePrefix}.plugin.origin`]: location.origin,
+        };
+    }
+    if (isFunctionsBundlingLocation(location)) {
+        return {
+            [`${locationAttributePrefix}.function.type`]: location.functionType,
+            [`${locationAttributePrefix}.function.name`]: location.functionName,
+        };
+    }
+    if (isCoreStepLocation(location)) {
+        return {
+            [`${locationAttributePrefix}.core_step.name`]: location.coreStepName,
+        };
+    }
+    if (isAPILocation(location)) {
+        return {
+            [`${locationAttributePrefix}.api.endpoint`]: location.endpoint,
+        };
+    }
+    return {};
+};
+/**
+ * Given a BuildError, extract the relevant trace attributes to add to the on-going Span
+ */
+export const buildErrorToTracingAttributes = function (error) {
+    const attributes = {};
+    // Check we're not adding undefined values
+    if (error?.severity)
+        attributes[`${buildErrorAttributePrefix}.severity`] = error.severity;
+    if (error?.type)
+        attributes[`${buildErrorAttributePrefix}.type`] = error.type;
+    if (error?.locationType)
+        attributes[`${buildErrorAttributePrefix}.location.type`] = error.locationType;
+    return {
+        ...attributes,
+        ...errorLocationToTracingAttributes(error.errorInfo?.location),
+    };
+};
+/**
+ * Retrieve error-type specific information
+ */
+export const getTypeInfo = function ({ type }) {
+    const typeA = TYPES[type] === undefined ? DEFAULT_TYPE : type;
+    return { type: typeA, ...TYPES[typeA] };
+};
+const ErrorTypeMap = {
+    /**
+     * Plugin called `utils.build.cancelBuild()`
+     */
+    cancelBuild: 'cancelBuild',
+    resolveConfig: 'resolveConfig',
+    dependencies: 'dependencies',
+    pluginInput: 'pluginInput',
+    pluginUnsupportedVersion: 'pluginUnsupportedVersion',
+    buildCommand: 'buildCommand',
+    functionsBundling: 'functionsBundling',
+    secretScanningFoundSecrets: 'secretScanningFoundSecrets',
+    failPlugin: 'failPlugin',
+    failBuild: 'failBuild',
+    pluginValidation: 'pluginValidation',
+    pluginInternal: 'pluginInternal',
+    ipc: 'ipc',
+    corePlugin: 'corePlugin',
+    coreStep: 'coreStep',
+    api: 'api',
+    exception: 'exception',
+    telemetry: 'telemetry',
+};
+/**
+ * List of error types, and their related properties
+ * New error types should be added to Bugsnag since we use it for automated
+ * monitoring (through its Slack integration). The steps in Bugsnag are:
+ *  - Create a new bookmark. Try to re-use the search filter of an existing
+ *    bookmark with a similar error type, but only changing the `errorClass`.
+ *    Make sure to check the box "Share with my team".
+ *  - Add the `errorClass` to the search filter of either the "All warnings" or
+ *    "All errors" bookmark depending on whether we should get notified on Slack
+ *    for new errors of that type. You must use the bookmark menu action "Update
+ *    with current filters"
+ *
+ */
+const TYPES = {
+    /**
+     * Plugin called `utils.build.cancelBuild()`
+     */
+    cancelBuild: {
+        title: ({ location: { packageName } }) => `Build canceled by ${packageName}`,
+        stackType: 'stack',
+        locationType: 'buildFail',
+        severity: 'none',
+    },
+    /**
+     * User configuration error (`@netlify/config`, wrong Node.js version)
+     */
+    resolveConfig: {
+        title: 'Configuration error',
+        stackType: 'none',
+        severity: 'info',
+    },
+    /**
+     * Error while installing user packages (missing plugins, local plugins or functions dependencies)
+     */
+    dependencies: {
+        title: 'Dependencies installation error',
+        stackType: 'none',
+        severity: 'info',
+    },
+    /**
+     * User misconfigured a plugin
+     */
+    pluginInput: {
+        title: ({ location: { packageName, input } }) => `Plugin "${packageName}" invalid input "${input}"`,
+        stackType: 'none',
+        locationType: 'buildFail',
+        severity: 'info',
+    },
+    /**
+     * User package.json sets an unsupported plugin version
+     */
+    pluginUnsupportedVersion: {
+        title: 'Unsupported plugin version detected',
+        stackType: 'none',
+        severity: 'info',
+    },
+    /**
+     * `build.command` non-0 exit code
+     */
+    buildCommand: {
+        title: '"build.command" failed',
+        group: ({ location: { buildCommand } }) => buildCommand,
+        stackType: 'message',
+        locationType: 'buildCommand',
+        severity: 'info',
+    },
+    /**
+     * User error during Functions bundling
+     */
+    functionsBundling: {
+        title: ({ location: { functionName, functionType } }) => {
+            if (functionType === 'edge') {
+                return 'Bundling of edge function failed';
+            }
+            return `Bundling of function "${functionName}" failed`;
+        },
+        group: ({ location: { functionType = 'serverless' } }) => `Bundling of ${functionType} function failed`,
+        stackType: 'none',
+        locationType: 'functionsBundling',
+        severity: 'info',
+    },
+    /**
+     * Error from the secret scanning core step
+     */
+    secretScanningFoundSecrets: {
+        title: 'Secrets scanning detected secrets in files during build.',
+        stackType: 'none',
+        severity: 'info',
+    },
+    /**
+     * Plugin called `utils.build.failBuild()`
+     */
+    failBuild: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" failed`,
+        stackType: 'stack',
+        locationType: 'buildFail',
+        severity: 'info',
+    },
+    /**
+     * Plugin called `utils.build.failPlugin()`
+     */
+    failPlugin: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" failed`,
+        stackType: 'stack',
+        locationType: 'buildFail',
+        severity: 'info',
+    },
+    /**
+     * Plugin has an invalid shape
+     */
+    pluginValidation: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'stack',
+        locationType: 'buildFail',
+        severity: 'warning',
+    },
+    /**
+     * Plugin threw an uncaught exception
+     */
+    pluginInternal: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        locationType: 'buildFail',
+        severity: 'warning',
+    },
+    /**
+     * Bug while orchestrating child processes
+     */
+    ipc: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'none',
+        locationType: 'buildFail',
+        severity: 'warning',
+    },
+    /**
+     * Core plugin internal error
+     */
+    corePlugin: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        locationType: 'buildFail',
+        severity: 'error',
+    },
+    /**
+     * Core step internal error
+     */
+    coreStep: {
+        title: ({ location: { coreStepName } }) => `Internal error during "${coreStepName}"`,
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        locationType: 'coreStep',
+        severity: 'error',
+    },
+    /**
+     * Request error when `@netlify/build` was calling Netlify API
+     */
+    api: {
+        title: ({ location: { endpoint } }) => `API error on "${endpoint}"`,
+        stackType: 'message',
+        showErrorProps: true,
+        locationType: 'api',
+        severity: 'error',
+    },
+    /**
+     * `@netlify/build` threw an uncaught exception
+     */
+    exception: {
+        title: 'Core internal error',
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        severity: 'error',
+    },
+    /**
+     * Errors related with the telemetry output
+     */
+    telemetry: {
+        showInBuildLog: false,
+        title: 'Telemetry error',
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        severity: 'error',
+    },
+};
+// When no error type matches, it's an uncaught exception, i.e. a bug
+const DEFAULT_TYPE = 'exception';

package/lib/log/messages/core_steps.js

@@ -93,5 +93,5 @@ export const logSecretsScanFailBuildMessage = function ({ logs, scanResults, gro
     });
     logError(logs, `\nTo prevent exposing secrets, the build will fail until these secret values are not found in build output or repo files.`);
     logError(logs, `If these are expected, use SECRETS_SCAN_OMIT_PATHS, SECRETS_SCAN_OMIT_KEYS, or SECRETS_SCAN_ENABLED to prevent detecting.`);
-    logError(logs, `See the Netlify Docs for more information on secrets scanning.`);
+    logError(logs, `For more information on secrets scanning, see the Netlify Docs: https://ntl.fyi/configure-secrets-scanning`);
 };

package/lib/tracing/main.js

@@ -4,6 +4,7 @@ import { context, trace, propagation, SpanStatusCode, diag, DiagLogLevel } from
 import { parseKeyPairsIntoRecord } from '@opentelemetry/core/build/src/baggage/utils.js';
 import { isBuildError } from '../error/info.js';
 import { parseErrorInfo } from '../error/parse/parse.js';
+import { buildErrorToTracingAttributes } from '../error/types.js';
 import { ROOT_PACKAGE_JSON } from '../utils/json.js';
 let sdk;
 /** Given a simple logging function return a `DiagLogger`. Used to setup our system logger as the diag logger.*/
@@ -82,10 +83,10 @@ export const addErrorToActiveSpan = function (error) {
     if (!span)
         return;
     if (isBuildError(error)) {
-        const { severity, type } = parseErrorInfo(error);
-        if (severity == 'none')
+        const buildError = parseErrorInfo(error);
+        if (buildError.severity == 'none')
             return;
-        span.setAttributes({ severity, type });
+        span.setAttributes(buildErrorToTracingAttributes(buildError));
     }
     span.recordException(error);
     span.setStatus({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "29.26.3",
+  "version": "29.26.4",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -146,5 +146,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "fd75258a36e9e47aeed8d1099f6c9f87d2957328"
+  "gitHead": "7b23feab14bc8f97de9a9aa1133782a8319b3731"
 }

package/lib/error/type.d.ts

@@ -1,3 +0,0 @@
-export function getTypeInfo({ type }: {
-    type: any;
-}): any;

package/lib/error/type.js

@@ -1,182 +0,0 @@
-// Retrieve error-type specific information
-export const getTypeInfo = function ({ type }) {
-    const typeA = TYPES[type] === undefined ? DEFAULT_TYPE : type;
-    return { type: typeA, ...TYPES[typeA] };
-};
-// List of error types, and their related properties
-// Related to build error logs:
-//  - `showInBuildLog`: `true` when we want this error to show in build logs (defaults to true)
-//  - `title`: main title shown in build error logs and in the UI (statuses)
-//  - `locationType`: retrieve a human-friendly location of the error, printed
-//    in build error logs
-//  - `showErrorProps`: `true` when the `Error` instance static properties
-//    should be printed in build error logs. Only useful when the `Error`
-//    instance was not created by us.
-//  - `rawStack`: `true` when the stack trace should be cleaned up
-//  - `stackType`: how the stack trace should appear in build error logs:
-//      - `none`: not printed
-//      - `stack`: printed as is
-//      - `message`: printed as is, but taken from `error.message`.
-//        Used when `error.stack` is not being correct due to the error being
-//        passed between different processes.
-//  - `severity`: error severity (also used by Bugsnag):
-//      - `success`: build success
-//      - `none`: not an error, e.g. build cancellation
-//      - `info`: user error
-//      - `warning`: community plugin error
-//      - `error`: system error, including core plugin error
-// Related to Bugsnag:
-//  - `group`: main title shown in Bugsnag. Also used to group errors together
-//    in Bugsnag, combined with `error.message`.
-//    Defaults to `title`.
-// New error types should be added to Bugsnag since we use it for automated
-// monitoring (through its Slack integration). The steps in Bugsnag are:
-//  - Create a new bookmark. Try to re-use the search filter of an existing
-//    bookmark with a similar error type, but only changing the `errorClass`.
-//    Make sure to check the box "Share with my team".
-//  - Add the `errorClass` to the search filter of either the "All warnings" or
-//    "All errors" bookmark depending on whether we should get notified on Slack
-//    for new errors of that type. You must use the bookmark menu action "Update
-//    with current filters"
-const TYPES = {
-    // Plugin called `utils.build.cancelBuild()`
-    cancelBuild: {
-        title: ({ location: { packageName } }) => `Build canceled by ${packageName}`,
-        stackType: 'stack',
-        locationType: 'buildFail',
-        severity: 'none',
-    },
-    // User configuration error (`@netlify/config`, wrong Node.js version)
-    resolveConfig: {
-        title: 'Configuration error',
-        stackType: 'none',
-        severity: 'info',
-    },
-    // Error while installing user packages (missing plugins, local plugins or functions dependencies)
-    dependencies: {
-        title: 'Dependencies installation error',
-        stackType: 'none',
-        severity: 'info',
-    },
-    // User misconfigured a plugin
-    pluginInput: {
-        title: ({ location: { packageName, input } }) => `Plugin "${packageName}" invalid input "${input}"`,
-        stackType: 'none',
-        locationType: 'buildFail',
-        severity: 'info',
-    },
-    // User package.json sets an unsupported plugin version
-    pluginUnsupportedVersion: {
-        title: 'Unsupported plugin version detected',
-        stackType: 'none',
-        severity: 'info',
-    },
-    // `build.command` non-0 exit code
-    buildCommand: {
-        title: '"build.command" failed',
-        group: ({ location: { buildCommand } }) => buildCommand,
-        stackType: 'message',
-        locationType: 'buildCommand',
-        severity: 'info',
-    },
-    // User error during Functions bundling
-    functionsBundling: {
-        title: ({ location: { functionName, functionType } }) => {
-            if (functionType === 'edge') {
-                return 'Bundling of edge function failed';
-            }
-            return `Bundling of function "${functionName}" failed`;
-        },
-        group: ({ location: { functionType = 'serverless' } }) => `Bundling of ${functionType} function failed`,
-        stackType: 'none',
-        locationType: 'functionsBundling',
-        severity: 'info',
-    },
-    secretScanningFoundSecrets: {
-        title: 'Secrets scanning detected secrets in files during build.',
-        stackType: 'none',
-        severity: 'info',
-    },
-    // Plugin called `utils.build.failBuild()`
-    failBuild: {
-        title: ({ location: { packageName } }) => `Plugin "${packageName}" failed`,
-        stackType: 'stack',
-        locationType: 'buildFail',
-        severity: 'info',
-    },
-    // Plugin called `utils.build.failPlugin()`
-    failPlugin: {
-        title: ({ location: { packageName } }) => `Plugin "${packageName}" failed`,
-        stackType: 'stack',
-        locationType: 'buildFail',
-        severity: 'info',
-    },
-    // Plugin has an invalid shape
-    pluginValidation: {
-        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
-        stackType: 'stack',
-        locationType: 'buildFail',
-        severity: 'warning',
-    },
-    // Plugin threw an uncaught exception
-    pluginInternal: {
-        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
-        stackType: 'stack',
-        showErrorProps: true,
-        rawStack: true,
-        locationType: 'buildFail',
-        severity: 'warning',
-    },
-    // Bug while orchestrating child processes
-    ipc: {
-        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
-        stackType: 'none',
-        locationType: 'buildFail',
-        severity: 'warning',
-    },
-    // Core plugin internal error
-    corePlugin: {
-        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
-        stackType: 'stack',
-        showErrorProps: true,
-        rawStack: true,
-        locationType: 'buildFail',
-        severity: 'error',
-    },
-    // Core step internal error
-    coreStep: {
-        title: ({ location: { coreStepName } }) => `Internal error during "${coreStepName}"`,
-        stackType: 'stack',
-        showErrorProps: true,
-        rawStack: true,
-        locationType: 'coreStep',
-        severity: 'error',
-    },
-    // Request error when `@netlify/build` was calling Netlify API
-    api: {
-        title: ({ location: { endpoint } }) => `API error on "${endpoint}"`,
-        stackType: 'message',
-        showErrorProps: true,
-        locationType: 'api',
-        severity: 'error',
-    },
-    // `@netlify/build` threw an uncaught exception
-    exception: {
-        title: 'Core internal error',
-        stackType: 'stack',
-        showErrorProps: true,
-        rawStack: true,
-        severity: 'error',
-    },
-    // Errors related with the telemetry output
-    telemetry: {
-        showInBuildLog: false,
-        title: 'Telemetry error',
-        stackType: 'stack',
-        showErrorProps: true,
-        rawStack: true,
-        severity: 'error',
-    },
-};
-// When no error type matches, it's an uncaught exception, i.e. a bug
-const DEFAULT_TYPE = 'exception';