@netlify/build 29.28.0 → 29.28.2

package/lib/core/flags.d.ts

@@ -169,6 +169,11 @@ export const FLAGS: {
         describe: string;
         hidden: boolean;
     };
+    'tracing.preloadingEnabled': {
+        boolean: boolean;
+        describe: string;
+        hidden: boolean;
+    };
     'tracing.apiKey': {
         string: boolean;
         describe: string;

package/lib/core/flags.js

@@ -202,6 +202,11 @@ Default: false`,
         describe: 'Enable distributed tracing for build',
         hidden: true,
     },
+    'tracing.preloadingEnabled': {
+        boolean: true,
+        describe: 'Enable distributed tracing for build via module preloading, to be removed once fully rolled out',
+        hidden: true,
+    },
     'tracing.apiKey': {
         string: true,
         describe: 'API Key for the tracing backend provider',

package/lib/core/normalize_flags.js

@@ -58,6 +58,7 @@ const getDefaultFlags = function ({ env: envOpt = {} }, combinedEnv) {
         // honeycomb directly - https://github.com/honeycombio/honeycomb-opentelemetry-node/issues/201
         tracing: {
             enabled: false,
+            preloadingEnabled: false,
             apiKey: '-',
             // defaults to always sample
             sampleRate: 1,

package/lib/core/types.d.ts

@@ -76,6 +76,7 @@ export type ErrorParam = {
 };
 export type TracingOptions = {
     enabled: boolean;
+    preloadingEnabled: boolean;
     httpProtocol: string;
     host: string;
     port: number;

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

@@ -1,16 +1,13 @@
-export function serializeErrorStatus({ fullErrorInfo: { title, message, locationInfo, errorProps, errorMetadata }, state, }: {
-    fullErrorInfo: {
-        title: any;
-        message: any;
-        locationInfo: any;
-        errorProps: any;
-        errorMetadata: any;
-    };
-    state: any;
-}): {
-    state: any;
-    title: any;
-    summary: any;
+import type { BuildError } from '../types.js';
+type ErrorState = 'failed_build' | 'failed_plugin' | 'canceled_build';
+export declare const serializeErrorStatus: ({ fullErrorInfo: { title, message, locationInfo, errorProps, errorMetadata }, state, }: {
+    fullErrorInfo: BuildError;
+    state: ErrorState;
+}) => {
+    state: ErrorState;
+    title: string | (import("../types.js").TitleFunction & string);
+    summary: string;
     text: string | undefined;
     extraData: any;
 };
+export {};

package/lib/error/parse/serialize_status.js

@@ -1,4 +1,4 @@
-// Serialize an error object to `statuses` properties
+/* Serialize an error object to `statuses` properties */
 export const serializeErrorStatus = function ({ fullErrorInfo: { title, message, locationInfo, errorProps, errorMetadata }, state, }) {
     const text = getText({ locationInfo, errorProps });
     return { state, title, summary: message, text, extraData: errorMetadata };

package/lib/error/types.d.ts

@@ -165,10 +165,11 @@ declare const ErrorTypeMap: {
     readonly pluginInternal: "pluginInternal";
     readonly ipc: "ipc";
     readonly corePlugin: "corePlugin";
+    readonly trustedPlugin: "trustedPlugin";
     readonly coreStep: "coreStep";
     readonly api: "api";
     readonly exception: "exception";
     readonly telemetry: "telemetry";
 };
-type ErrorTypes = keyof typeof ErrorTypeMap;
+export type ErrorTypes = keyof typeof ErrorTypeMap;
 export {};

package/lib/error/types.js

@@ -141,6 +141,7 @@ const ErrorTypeMap = {
     pluginInternal: 'pluginInternal',
     ipc: 'ipc',
     corePlugin: 'corePlugin',
+    trustedPlugin: 'trustedPlugin',
     coreStep: 'coreStep',
     api: 'api',
     exception: 'exception',
@@ -293,6 +294,17 @@ const TYPES = {
         locationType: 'buildFail',
         severity: 'error',
     },
+    /**
+     * Trusted plugin internal error (all of our `@netlify/*` plugins).
+     */
+    trustedPlugin: {
+        title: ({ location: { packageName } }) => `Plugin "${packageName}" internal error`,
+        stackType: 'stack',
+        showErrorProps: true,
+        rawStack: true,
+        locationType: 'buildFail',
+        severity: 'error',
+    },
     /**
      * Core step internal error
      */

package/lib/plugins/spawn.js

@@ -31,10 +31,14 @@ const startPlugin = async function ({ pluginDir, nodePath, buildDir, childEnv, s
         preferLocal: true,
         localDir: pluginDir,
         nodePath,
+        // make sure we don't pass build's node cli properties for now (e.g. --import)
+        nodeOptions: [],
         execPath: nodePath,
         env: childEnv,
         extendEnv: false,
-        stdio: isTrustedPlugin(pluginPackageJson) && systemLogFile ? ['pipe', 'pipe', 'pipe', 'ipc', systemLogFile] : undefined,
+        stdio: isTrustedPlugin(pluginPackageJson?.name) && systemLogFile
+            ? ['pipe', 'pipe', 'pipe', 'ipc', systemLogFile]
+            : undefined,
     });
     try {
         await getEventFromChild(childProcess, 'ready');

package/lib/steps/error.d.ts

@@ -1,4 +1,14 @@
-export function handleStepError({ event, newError, childEnv, mode, api, errorMonitor, deployId, coreStep, netlifyConfig, logs, debug, testOpts, }: {
+import { ErrorTypes } from '../error/types.js';
+/**
+ * Handle build command errors and plugin errors:
+ *  - usually, propagate the error to make the build stop.
+ *  - `utils.build.cancelBuild()` also cancels the build by calling the API
+ *  - `utils.build.failPlugin()` or post-deploy errors do not make the build
+ *    stop, but are still reported, and prevent future events from the same
+ *    plugin.
+ * This also computes error statuses that are sent to the API.
+ */
+export declare const handleStepError: ({ event, newError, childEnv, mode, api, errorMonitor, deployId, coreStep, netlifyConfig, logs, debug, testOpts, }: {
     event: any;
     newError: any;
     childEnv: any;
@@ -11,38 +21,36 @@ export function handleStepError({ event, newError, childEnv, mode, api, errorMon
     logs: any;
     debug: any;
     testOpts: any;
-}): Promise<{
-    failedPlugin: any[];
+}) => Promise<{
+    failedPlugin: string[];
     newStatus: {
-        state: any;
-        title: any;
-        summary: any;
+        state: "failed_build" | "failed_plugin" | "canceled_build";
+        title: string | (import("../error/types.js").TitleFunction & string);
+        summary: string;
         text: string | undefined;
         extraData: any;
     };
 }> | Promise<{
     newError: any;
     newStatus: {
-        state: any;
-        title: any;
-        summary: any;
+        state: "failed_build" | "failed_plugin" | "canceled_build";
+        title: string | (import("../error/types.js").TitleFunction & string);
+        summary: string;
         text: string | undefined;
         extraData: any;
     };
 }> | {
     newError: any;
     newStatus: {
-        state: any;
-        title: any;
-        summary: any;
+        state: "failed_build" | "failed_plugin" | "canceled_build";
+        title: string | (import("../error/types.js").TitleFunction & string);
+        summary: string;
         text: string | undefined;
         extraData: any;
     };
 } | {
     newError: any;
 };
-export function getPluginErrorType(error: any, loadedFrom: any): {
-    type?: undefined;
-} | {
-    type: string;
+export declare const getPluginErrorType: (error: Error, loadedFrom: string, packageName?: string) => {
+    type?: ErrorTypes;
 };

package/lib/steps/error.js

@@ -2,15 +2,19 @@ import { cancelBuild } from '../error/cancel.js';
 import { handleBuildError } from '../error/handle.js';
 import { getFullErrorInfo, parseErrorInfo } from '../error/parse/parse.js';
 import { serializeErrorStatus } from '../error/parse/serialize_status.js';
+import { isPluginLocation } from '../error/types.js';
 import { isSoftFailEvent } from '../plugins/events.js';
 import { addErrorToActiveSpan, addEventToActiveSpan } from '../tracing/main.js';
-// Handle build command errors and plugin errors:
-//  - usually, propagate the error to make the build stop.
-//  - `utils.build.cancelBuild()` also cancels the build by calling the API
-//  - `utils.build.failPlugin()` or post-deploy errors do not make the build
-//    stop, but are still reported, and prevent future events from the same
-//    plugin.
-// This also computes error statuses that are sent to the API.
+import { isTrustedPlugin } from './plugin.js';
+/**
+ * Handle build command errors and plugin errors:
+ *  - usually, propagate the error to make the build stop.
+ *  - `utils.build.cancelBuild()` also cancels the build by calling the API
+ *  - `utils.build.failPlugin()` or post-deploy errors do not make the build
+ *    stop, but are still reported, and prevent future events from the same
+ *    plugin.
+ * This also computes error statuses that are sent to the API.
+ */
 export const handleStepError = function ({ event, newError, childEnv, mode, api, errorMonitor, deployId, coreStep, netlifyConfig, logs, debug, testOpts, }) {
     addErrorToActiveSpan(newError);
     // Core steps do not report error statuses
@@ -18,7 +22,7 @@ export const handleStepError = function ({ event, newError, childEnv, mode, api,
         return { newError };
     }
     const fullErrorInfo = getFullErrorInfo({ error: newError, colors: false, debug });
-    const { errorInfo: { location: { packageName } = {} }, message, title, type, } = fullErrorInfo;
+    const { errorInfo, message, title, type } = fullErrorInfo;
     if (type === 'failPlugin' || isSoftFailEvent(event)) {
         return handleFailPlugin({
             fullErrorInfo,
@@ -36,32 +40,40 @@ export const handleStepError = function ({ event, newError, childEnv, mode, api,
         const cancellationAttributes = {
             'build.cancellation.title': title,
             'build.cancellation.message': message,
-            'build.cancellation.packageName': packageName,
         };
+        if (isPluginLocation(errorInfo.location)) {
+            cancellationAttributes['build.cancellation.packageName'] = errorInfo.location.packageName;
+        }
         addEventToActiveSpan('build.cancelled', cancellationAttributes);
         return handleCancelBuild({ fullErrorInfo, newError, api, deployId });
     }
     return handleFailBuild({ fullErrorInfo, newError });
 };
-// On `utils.build.failPlugin()` or during `onSuccess` or `onEnd`
-const handleFailPlugin = async function ({ fullErrorInfo, fullErrorInfo: { errorInfo: { location: { packageName } = {} }, }, newError, childEnv, mode, errorMonitor, netlifyConfig, logs, debug, testOpts, }) {
+/* On `utils.build.failPlugin()` or during `onSuccess` or `onEnd` */
+const handleFailPlugin = async function ({ fullErrorInfo, newError, childEnv, mode, errorMonitor, netlifyConfig, logs, debug, testOpts, }) {
     const newStatus = serializeErrorStatus({ fullErrorInfo, state: 'failed_plugin' });
     await handleBuildError(newError, { errorMonitor, netlifyConfig, childEnv, mode, logs, debug, testOpts });
-    return { failedPlugin: [packageName], newStatus };
+    // TODO we should probably use type guard here, but due to the way we build these errorInfo objects I'm not 100%
+    // confident we have all the properties currently required by the type
+    const location = fullErrorInfo.errorInfo.location;
+    return { failedPlugin: [location.packageName], newStatus };
 };
-// On `utils.build.cancelBuild()`
+/* On `utils.build.cancelBuild()` */
 const handleCancelBuild = async function ({ fullErrorInfo, newError, api, deployId }) {
     const newStatus = serializeErrorStatus({ fullErrorInfo, state: 'canceled_build' });
     await cancelBuild({ api, deployId });
     return { newError, newStatus };
 };
-// On `utils.build.failBuild()` or uncaught exception
+/* On `utils.build.failBuild()` or uncaught exception */
 const handleFailBuild = function ({ fullErrorInfo, newError }) {
     const newStatus = serializeErrorStatus({ fullErrorInfo, state: 'failed_build' });
     return { newError, newStatus };
 };
-// Unlike community plugins, core plugin bugs should be handled as system errors
-export const getPluginErrorType = function (error, loadedFrom) {
+/* Unlike community plugins, core plugin and trusted plugin bugs should be handled as system errors */
+export const getPluginErrorType = function (error, loadedFrom, packageName) {
+    if (isTrustedPluginBug(error, packageName)) {
+        return { type: 'trustedPlugin' };
+    }
     if (!isCorePluginBug(error, loadedFrom)) {
         return {};
     }
@@ -71,3 +83,7 @@ const isCorePluginBug = function (error, loadedFrom) {
     const { severity } = parseErrorInfo(error);
     return severity === 'warning' && loadedFrom === 'core';
 };
+const isTrustedPluginBug = function (error, packageName) {
+    const { severity } = parseErrorInfo(error);
+    return severity === 'warning' && isTrustedPlugin(packageName);
+};

package/lib/steps/plugin.d.ts

@@ -1,4 +1,4 @@
-export function isTrustedPlugin(pluginPackageJson: any): any;
+export function isTrustedPlugin(packageName: any): any;
 export function firePluginStep({ event, childProcess, packageName, packagePath, pluginPackageJson, loadedFrom, origin, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, constants, steps, error, logs, featureFlags, debug, verbose, }: {
     event: any;
     childProcess: any;

package/lib/steps/plugin.js

@@ -5,7 +5,7 @@ import { callChild } from '../plugins/ipc.js';
 import { getSuccessStatus } from '../status/success.js';
 import { getPluginErrorType } from './error.js';
 import { updateNetlifyConfig, listConfigSideFiles } from './update_config.js';
-export const isTrustedPlugin = (pluginPackageJson) => pluginPackageJson?.name?.startsWith('@netlify/');
+export const isTrustedPlugin = (packageName) => packageName?.startsWith('@netlify/');
 // Fire a plugin step
 export const firePluginStep = async function ({ event, childProcess, packageName, packagePath, pluginPackageJson, loadedFrom, origin, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, constants, steps, error, logs, featureFlags, debug, verbose, }) {
     const listeners = pipePluginOutput(childProcess, logs);
@@ -18,7 +18,7 @@ export const firePluginStep = async function ({ event, childProcess, packageName
                 event,
                 error,
                 envChanges,
-                featureFlags: isTrustedPlugin(pluginPackageJson) ? featureFlags : undefined,
+                featureFlags: isTrustedPlugin(pluginPackageJson?.name) ? featureFlags : undefined,
                 netlifyConfig,
                 constants,
             },
@@ -49,7 +49,7 @@ export const firePluginStep = async function ({ event, childProcess, packageName
         };
     }
     catch (newError) {
-        const errorType = getPluginErrorType(newError, loadedFrom);
+        const errorType = getPluginErrorType(newError, loadedFrom, packageName);
         addErrorInfo(newError, {
             ...errorType,
             plugin: { pluginPackageJson, packageName },

package/lib/steps/return.d.ts

@@ -24,20 +24,20 @@ export function getStepReturn({ event, packageName, newError, newEnvChanges, new
     quiet: any;
     metrics: any;
 }): Promise<{
-    failedPlugin: any[];
+    failedPlugin: string[];
     newStatus: {
-        state: any;
-        title: any;
-        summary: any;
+        state: "failed_build" | "failed_plugin" | "canceled_build";
+        title: string | (import("../error/types.js").TitleFunction & string);
+        summary: string;
         text: string | undefined;
         extraData: any;
     };
 }> | Promise<{
     newError: any;
     newStatus: {
-        state: any;
-        title: any;
-        summary: any;
+        state: "failed_build" | "failed_plugin" | "canceled_build";
+        title: string | (import("../error/types.js").TitleFunction & string);
+        summary: string;
         text: string | undefined;
         extraData: any;
     };

package/lib/tracing/main.d.ts

@@ -1,18 +1,29 @@
+import { Context } from '@opentelemetry/api';
 import type { TracingOptions } from '../core/types.js';
+/**
+ * Gets the global context to be used when initialising our root span
+ * TODO this will move to a shared package (opentelemetry-utils) to scope the usage of this global property there
+ */
+export declare const getGlobalContext: () => Context;
+/**
+ * Sets global context to be used when initialising our root span
+ * TODO this will move to a shared package (opentelemetry-utils) to scope the usage of this global property there
+ */
+export declare const setGlobalContext: (ctx: Context) => void;
 /** Starts the tracing SDK, if there's already a tracing service this will be a no-op */
-export declare const startTracing: (options: TracingOptions, logger: (...args: any[]) => void) => import("@opentelemetry/api").Context | undefined;
+export declare const startTracing: (options: TracingOptions, logger: (...args: any[]) => void) => Context | undefined;
 /** Stops the tracing service if there's one running. This will flush any ongoing events */
 export declare const stopTracing: () => Promise<void>;
 /** Sets attributes to be propagated across child spans under the current active context */
 export declare const setMultiSpanAttributes: (attributes: {
     [key: string]: string;
-}) => import("@opentelemetry/api").Context;
+}) => Context;
 /** Add error information to the current active span (if any) */
 export declare const addErrorToActiveSpan: (error: Error) => void;
 export declare const addEventToActiveSpan: (eventName: string, attributes?: {
     [key: string]: string;
 } | undefined) => void;
-export declare const loadBaggageFromFile: (baggageFilePath: string) => import("@opentelemetry/api").Context;
+export declare const loadBaggageFromFile: (baggageFilePath: string) => Context;
 /** Attributes used for the root span of our execution */
 export type RootExecutionAttributes = {
     'build.id': string;

package/lib/tracing/main.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { HoneycombSDK } from '@honeycombio/opentelemetry-node';
-import { context, trace, propagation, SpanStatusCode, diag, DiagLogLevel } from '@opentelemetry/api';
+import { context, trace, propagation, SpanStatusCode, diag, DiagLogLevel, } from '@opentelemetry/api';
 import { parseKeyPairsIntoRecord } from '@opentelemetry/core/build/src/baggage/utils.js';
 import { isBuildError } from '../error/info.js';
 import { parseErrorInfo } from '../error/parse/parse.js';
@@ -22,8 +22,30 @@ const getOtelLogger = function (logger) {
         warn: otelLogger,
     };
 };
+/**
+ * Gets the global context to be used when initialising our root span
+ * TODO this will move to a shared package (opentelemetry-utils) to scope the usage of this global property there
+ */
+export const getGlobalContext = function () {
+    if (global['NETLIFY_GLOBAL_CONTEXT'] === undefined) {
+        return context.active();
+    }
+    return global['NETLIFY_GLOBAL_CONTEXT'];
+};
+/**
+ * Sets global context to be used when initialising our root span
+ * TODO this will move to a shared package (opentelemetry-utils) to scope the usage of this global property there
+ */
+export const setGlobalContext = function (ctx) {
+    global['NETLIFY_GLOBAL_CONTEXT'] = ctx;
+};
 /** Starts the tracing SDK, if there's already a tracing service this will be a no-op */
 export const startTracing = function (options, logger) {
+    // As we roll out the new way to initialise the SDK, if we detect preloading is enabled,
+    // it means we're using `@netlify/opentelemetry-sdk-setup` so we must get the initial context from the global store
+    if (options.preloadingEnabled) {
+        return getGlobalContext();
+    }
     if (!options.enabled)
         return;
     if (sdk)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "29.28.0",
+  "version": "29.28.2",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -70,11 +70,11 @@
     "@netlify/config": "^20.10.0",
     "@netlify/edge-bundler": "10.1.3",
     "@netlify/framework-info": "^9.8.10",
-    "@netlify/functions-utils": "^5.2.41",
+    "@netlify/functions-utils": "^5.2.42",
     "@netlify/git-utils": "^5.1.1",
     "@netlify/plugins-list": "^6.72.0",
     "@netlify/run-utils": "^5.1.1",
-    "@netlify/zip-it-and-ship-it": "9.26.2",
+    "@netlify/zip-it-and-ship-it": "9.26.4",
     "@opentelemetry/api": "^1.4.1",
     "@opentelemetry/core": "^1.17.1",
     "@sindresorhus/slugify": "^2.0.0",
@@ -140,11 +140,19 @@
     "process-exists": "^5.0.0",
     "sinon": "^13.0.0",
     "tmp-promise": "^3.0.2",
-    "tsd": "^0.28.0",
+    "tsd": "^0.29.0",
     "yarn": "^1.22.4"
   },
+  "peerDependencies": {
+    "@netlify/opentelemetry-sdk-setup": "^1.0.1"
+  },
+  "peerDependenciesMeta": {
+    "@netlify/opentelemetry-sdk-setup": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "4731f03bc8ba9cc1a8e42f95777ed24497c727b5"
+  "gitHead": "db2b375439203dc1c7ec1e68b24b8460c8f0ffc3"
 }