@netlify/build 29.12.8 → 29.14.0

package/lib/core/build.js

@@ -12,6 +12,7 @@ import { reportStatuses } from '../status/report.js';
 import { getDevSteps, getSteps } from '../steps/get.js';
 import { runSteps } from '../steps/run_steps.js';
 import { initTimers, measureDuration } from '../time/main.js';
+import { startTracing } from '../tracing/main.js';
 import { getConfigOpts, loadConfig } from './config.js';
 import { getConstants } from './constants.js';
 import { doDryRun } from './dry.js';
@@ -27,11 +28,12 @@ export const startBuild = function (flags) {
     if (!flags.quiet) {
         logBuildStart(logs);
     }
-    const { bugsnagKey, ...flagsA } = normalizeFlags(flags, logs);
-    const errorMonitor = startErrorMonitor({ flags: flagsA, logs, bugsnagKey });
+    const { bugsnagKey, tracing, ...flagsA } = normalizeFlags(flags, logs);
+    const errorMonitor = startErrorMonitor({ flags: { tracing, ...flagsA }, logs, bugsnagKey });
+    startTracing(tracing);
     return { ...flagsA, errorMonitor, logs, timers };
 };
-const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cachedConfigPath, outputConfigPath, cwd, repositoryRoot, apiHost, token, siteId, context, branch, baseRelDir, env: envOpt, debug, systemLogFile, verbose, nodePath, functionsDistDir, edgeFunctionsDistDir, cacheDir, dry, mode, offline, deployId, buildId, testOpts, errorMonitor, errorParams, logs, timers, buildbotServerSocket, sendStatus, saveConfig, featureFlags, timeline, devCommand, quiet, framework, }) {
+const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cachedConfigPath, outputConfigPath, cwd, repositoryRoot, apiHost, token, siteId, context, branch, baseRelDir, env: envOpt, debug, systemLogFile, verbose, nodePath, functionsDistDir, edgeFunctionsDistDir, cacheDir, dry, mode, offline, deployId, buildId, testOpts, errorMonitor, errorParams, logs, timers, buildbotServerSocket, sendStatus, saveConfig, featureFlags, timeline, devCommand, quiet, framework, explicitSecretKeys, }) {
     const configOpts = getConfigOpts({
         config,
         defaultConfig,
@@ -126,6 +128,7 @@ const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cached
         timeline,
         devCommand,
         quiet,
+        explicitSecretKeys,
     });
     return {
         pluginsOptions: pluginsOptionsA,
@@ -140,7 +143,7 @@ const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cached
 };
 export const execBuild = measureDuration(tExecBuild, 'total', { parentTag: 'build_site' });
 // Runs a build then report any plugin statuses
-export const runAndReportBuild = async function ({ pluginsOptions, netlifyConfig, configOpts, siteInfo, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, packageJson, userNodeVersion, childEnv, context, branch, buildbotServerSocket, constants, dry, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, timers, sendStatus, saveConfig, testOpts, featureFlags, timeline, devCommand, quiet, }) {
+export const runAndReportBuild = async function ({ pluginsOptions, netlifyConfig, configOpts, siteInfo, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, packageJson, userNodeVersion, childEnv, context, branch, buildbotServerSocket, constants, dry, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, timers, sendStatus, saveConfig, testOpts, featureFlags, timeline, devCommand, quiet, explicitSecretKeys, }) {
     try {
         const { stepsCount, netlifyConfig: netlifyConfigA, statuses, pluginsOptions: pluginsOptionsA, failedPlugins, timers: timersA, configMutations, metrics, } = await initAndRunBuild({
             pluginsOptions,
@@ -179,6 +182,7 @@ export const runAndReportBuild = async function ({ pluginsOptions, netlifyConfig
             timeline,
             devCommand,
             quiet,
+            explicitSecretKeys,
         });
         await Promise.all([
             reportStatuses({
@@ -239,7 +243,7 @@ export const runAndReportBuild = async function ({ pluginsOptions, netlifyConfig
     }
 };
 // Initialize plugin processes then runs a build
-const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, configOpts, siteInfo, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, packageJson, userNodeVersion, childEnv, context, branch, dry, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, sendStatus, saveConfig, timers, testOpts, buildbotServerSocket, constants, featureFlags, timeline, devCommand, quiet, }) {
+const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, configOpts, siteInfo, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, packageJson, userNodeVersion, childEnv, context, branch, dry, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, sendStatus, saveConfig, timers, testOpts, buildbotServerSocket, constants, featureFlags, timeline, devCommand, quiet, explicitSecretKeys, }) {
     const { pluginsOptions: pluginsOptionsA, timers: timersA } = await getPluginsOptions({
         pluginsOptions,
         netlifyConfig,
@@ -305,6 +309,7 @@ const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, configO
             timeline,
             devCommand,
             quiet,
+            explicitSecretKeys,
         });
         await Promise.all([
             warnOnMissingSideFiles({ buildDir, netlifyConfig: netlifyConfigA, logs }),
@@ -332,7 +337,7 @@ const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, configO
 };
 // Load plugin main files, retrieve their event handlers then runs them,
 // together with the build command
-const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig, configOpts, packageJson, configPath, outputConfigPath, userNodeVersion, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, childEnv, context, branch, dry, buildbotServerSocket, constants, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, timeline, devCommand, quiet, }) {
+const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig, configOpts, packageJson, configPath, outputConfigPath, userNodeVersion, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, childEnv, context, branch, dry, buildbotServerSocket, constants, mode, api, errorMonitor, deployId, errorParams, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, timeline, devCommand, quiet, explicitSecretKeys, }) {
     const { pluginsSteps, timers: timersA } = await loadPlugins({
         pluginsOptions,
         childProcesses,
@@ -379,6 +384,7 @@ const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig
         featureFlags,
         quiet,
         userNodeVersion,
+        explicitSecretKeys,
     });
     return {
         stepsCount,

package/lib/core/flags.js

@@ -189,6 +189,40 @@ Default: false`,
         describe: 'Statsd port',
         hidden: true,
     },
+    tracing: {
+        describe: 'Tracing related options',
+        hidden: true,
+    },
+    'tracing.enabled': {
+        boolean: true,
+        describe: 'Enable distributed tracing for build',
+        hidden: true,
+    },
+    'tracing.host': {
+        string: true,
+        describe: 'Traces backend host',
+        hidden: true,
+    },
+    'tracing.port': {
+        number: true,
+        describe: 'Traces backend port',
+        hidden: true,
+    },
+    'tracing.traceId': {
+        string: true,
+        describe: 'Trace ID used to stitch the emited traces to',
+        hidden: true,
+    },
+    'tracing.parentSpanId': {
+        string: true,
+        describe: 'Parent Span ID used to stitch the root parent span to',
+        hidden: true,
+    },
+    'tracing.traceFlags': {
+        number: true,
+        describe: 'Trace flags containing the trace settings for the given trace ID',
+        hidden: true,
+    },
     offline: {
         boolean: true,
         describe: `Do not send requests to the Netlify API to retrieve site settings.
@@ -203,4 +237,9 @@ Default: false`,
         describe: 'The sequence of lifecycle events to run',
         hidden: true,
     },
+    explicitSecretKeys: {
+        type: 'string',
+        describe: 'Env var keys that are marked as secret explicitly.',
+        hidden: true,
+    },
 };

package/lib/core/main.js

@@ -1,14 +1,17 @@
+import { trace } from '@opentelemetry/api';
 import { handleBuildError } from '../error/handle.js';
 import { reportError } from '../error/report.js';
 import { getSystemLogger } from '../log/logger.js';
 import { logTimer, logBuildSuccess } from '../log/messages/core.js';
 import { trackBuildComplete } from '../telemetry/main.js';
 import { reportTimers } from '../time/report.js';
+import { stopTracing, setMultiSpanAttributes } from '../tracing/main.js';
 import { execBuild, startBuild } from './build.js';
 import { reportMetrics } from './report_metrics.js';
 import { getSeverity } from './severity.js';
 export { startDev } from './dev.js';
 export { runCoreSteps } from '../steps/run_core_steps.js';
+const tracer = trace.getTracer('core');
 /**
  * Main entry point of Netlify Build.
  * Runs a builds and returns whether it succeeded or not.
@@ -19,67 +22,91 @@ export default async function buildSite(flags = {}) {
     const { errorMonitor, framework, mode, logs, debug, systemLogFile, testOpts, statsdOpts, dry, telemetry, buildId, deployId, ...flagsA } = startBuild(flags);
     const errorParams = { errorMonitor, mode, logs, debug, testOpts };
     const systemLog = getSystemLogger(logs, debug, systemLogFile);
-    try {
-        const { pluginsOptions, netlifyConfig: netlifyConfigA, siteInfo, userNodeVersion, stepsCount, timers, durationNs, configMutations, metrics, } = await execBuild({
-            ...flagsA,
-            buildId,
-            systemLogFile,
-            deployId,
-            dry,
-            errorMonitor,
-            mode,
-            logs,
-            debug,
-            testOpts,
-            errorParams,
-            framework,
-        });
-        await handleBuildSuccess({
-            framework,
-            dry,
-            logs,
-            timers,
-            durationNs,
-            statsdOpts,
-            systemLog,
-            metrics,
-        });
-        const { success, severityCode, status } = getSeverity('success');
-        await telemetryReport({
-            buildId,
-            deployId,
-            status,
-            stepsCount,
-            pluginsOptions,
-            durationNs,
-            siteInfo,
-            telemetry,
-            userNodeVersion,
-            framework,
-            testOpts,
-            errorParams,
-        });
-        return { success, severityCode, netlifyConfig: netlifyConfigA, logs, configMutations };
-    }
-    catch (error) {
-        const { severity } = await handleBuildError(error, errorParams);
-        const { pluginsOptions, siteInfo, userNodeVersion } = errorParams;
-        const { success, severityCode, status } = getSeverity(severity);
-        await telemetryReport({
-            buildId,
-            deployId,
-            status,
-            pluginsOptions,
-            siteInfo,
-            telemetry,
-            userNodeVersion,
-            framework,
-            testOpts,
-            errorParams,
-        });
-        await reportError(error, statsdOpts, framework);
-        return { success, severityCode, logs };
-    }
+    const attributes = {
+        'deploy.id': deployId,
+        'build.id': buildId,
+        'deploy.context': flagsA.context,
+        'site.id': flagsA.siteId,
+    };
+    const rootCtx = setMultiSpanAttributes(attributes);
+    return await tracer.startActiveSpan('exec-build', {}, rootCtx, async (span) => {
+        try {
+            const { pluginsOptions, netlifyConfig: netlifyConfigA, siteInfo, userNodeVersion, stepsCount, timers, durationNs, configMutations, metrics, } = await execBuild({
+                ...flagsA,
+                buildId,
+                systemLogFile,
+                deployId,
+                dry,
+                errorMonitor,
+                mode,
+                logs,
+                debug,
+                testOpts,
+                errorParams,
+                framework,
+            });
+            await handleBuildSuccess({
+                framework,
+                dry,
+                logs,
+                timers,
+                durationNs,
+                statsdOpts,
+                systemLog,
+                metrics,
+            });
+            const { success, severityCode, status } = getSeverity('success');
+            span.setAttributes({
+                'build.execution.success': success,
+                'build.execution.code': severityCode,
+                'build.execution.status': status,
+            });
+            await telemetryReport({
+                buildId,
+                deployId,
+                status,
+                stepsCount,
+                pluginsOptions,
+                durationNs,
+                siteInfo,
+                telemetry,
+                userNodeVersion,
+                framework,
+                testOpts,
+                errorParams,
+            });
+            return { success, severityCode, netlifyConfig: netlifyConfigA, logs, configMutations };
+        }
+        catch (error) {
+            const { severity } = await handleBuildError(error, errorParams);
+            const { pluginsOptions, siteInfo, userNodeVersion } = errorParams;
+            const { success, severityCode, status } = getSeverity(severity);
+            span.setAttributes({
+                'build.execution.success': success,
+                'build.execution.code': severityCode,
+                'build.execution.status': status,
+            });
+            await telemetryReport({
+                buildId,
+                deployId,
+                status,
+                pluginsOptions,
+                siteInfo,
+                telemetry,
+                userNodeVersion,
+                framework,
+                testOpts,
+                errorParams,
+            });
+            await reportError(error, statsdOpts, framework);
+            return { success, severityCode, logs };
+        }
+        finally {
+            span.end();
+            // Ensure we flush the resulting spans
+            await stopTracing();
+        }
+    });
 }
 // Logs and reports that a build successfully ended
 const handleBuildSuccess = async function ({ framework, dry, logs, timers, durationNs, statsdOpts, systemLog, metrics, }) {

package/lib/core/normalize_flags.js

@@ -7,6 +7,7 @@ const DEFAULT_EDGE_FUNCTIONS_DIST = '.netlify/edge-functions-dist/';
 const DEFAULT_FUNCTIONS_DIST = '.netlify/functions/';
 const DEFAULT_CACHE_DIR = '.netlify/cache/';
 const DEFAULT_STATSD_PORT = 8125;
+const DEFAULT_OTEL_TRACING_PORT = 4317;
 /** Normalize CLI flags  */
 export const normalizeFlags = function (flags, logs) {
     const rawFlags = removeFalsy(flags);
@@ -20,6 +21,7 @@ export const normalizeFlags = function (flags, logs) {
         ...rawFlags,
         ...telemetryFlag,
         statsdOpts: { ...defaultFlags.statsd, ...rawFlags.statsd },
+        tracingOpts: { ...defaultFlags.tracing, ...rawFlags.tracing },
         featureFlags: { ...defaultFlags.featureFlags, ...rawFlags.featureFlags },
     };
     const normalizedFlags = removeFalsy(mergedFlags);
@@ -51,6 +53,7 @@ const getDefaultFlags = function ({ env: envOpt = {} }, combinedEnv) {
         testOpts: {},
         featureFlags: DEFAULT_FEATURE_FLAGS,
         statsd: { port: DEFAULT_STATSD_PORT },
+        tracing: { enabled: false, port: DEFAULT_OTEL_TRACING_PORT },
         timeline: 'build',
         quiet: false,
     };

package/lib/core/types.js

@@ -5,4 +5,4 @@ export var SeverityCode;
     SeverityCode[SeverityCode["userError"] = 3] = "userError";
     SeverityCode[SeverityCode["pluginError"] = 4] = "pluginError";
     SeverityCode[SeverityCode["systemError"] = 5] = "systemError";
-})(SeverityCode = SeverityCode || (SeverityCode = {}));
+})(SeverityCode || (SeverityCode = {}));

package/lib/error/report.js

@@ -1,5 +1,6 @@
 import { isNetlifyMaintainedPlugin } from '../plugins/internal.js';
 import { closeClient, formatTags, normalizeTagName, startClient, validateStatsDOptions, } from '../report/statsd.js';
+import { addErrorToActiveSpan } from '../tracing/main.js';
 import { getErrorInfo } from './info.js';
 const TOP_PARENT_TAG = 'run_netlify_build';
 /**
@@ -7,6 +8,7 @@ const TOP_PARENT_TAG = 'run_netlify_build';
  * Sends to statsd daemon.
  */
 export const reportError = async function (error, statsdOpts, framework) {
+    addErrorToActiveSpan(error);
     if (!validateStatsDOptions(statsdOpts)) {
         return;
     }

package/lib/log/messages/config.js

@@ -49,6 +49,7 @@ const INTERNAL_FLAGS = [
     'cacheDir',
     'systemLogFile',
     'timeline',
+    'explicitSecretKeys',
 ];
 const HIDDEN_FLAGS = [...SECURE_FLAGS, ...TEST_FLAGS, ...INTERNAL_FLAGS];
 const HIDDEN_DEBUG_FLAGS = [...SECURE_FLAGS, ...TEST_FLAGS];

package/lib/steps/core_step.js

@@ -2,7 +2,7 @@ import { setEnvChanges } from '../env/changes.js';
 import { addErrorInfo, isBuildError } from '../error/info.js';
 import { updateNetlifyConfig, listConfigSideFiles } from './update_config.js';
 // Fire a core step
-export const fireCoreStep = async function ({ coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, constants, buildbotServerSocket, events, logs, nodePath, childEnv, context, branch, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, debug, systemLog, saveConfig, userNodeVersion, }) {
+export const fireCoreStep = async function ({ coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, constants, buildbotServerSocket, events, logs, nodePath, childEnv, context, branch, envChanges, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, debug, systemLog, saveConfig, userNodeVersion, explicitSecretKeys, }) {
     try {
         const configSideFiles = await listConfigSideFiles([headersPath, redirectsPath]);
         const childEnvA = setEnvChanges(envChanges, { ...childEnv });
@@ -28,6 +28,7 @@ export const fireCoreStep = async function ({ coreStep, coreStepId, coreStepName
             systemLog,
             saveConfig,
             userNodeVersion,
+            explicitSecretKeys,
         });
         const { netlifyConfig: netlifyConfigA, configMutations: configMutationsA, headersPath: headersPathA, redirectsPath: redirectsPathA, } = await updateNetlifyConfig({
             configOpts,

package/lib/steps/error.js

@@ -3,6 +3,7 @@ import { handleBuildError } from '../error/handle.js';
 import { getFullErrorInfo, parseErrorInfo } from '../error/parse/parse.js';
 import { serializeErrorStatus } from '../error/parse/serialize_status.js';
 import { isSoftFailEvent } from '../plugins/events.js';
+import { addErrorToActiveSpan } 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
@@ -11,6 +12,7 @@ import { isSoftFailEvent } from '../plugins/events.js';
 //    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
     if (coreStep !== undefined) {
         return { newError };

package/lib/steps/run_step.js

@@ -1,98 +1,120 @@
+import { trace } from '@opentelemetry/api';
 import { addMutableConstants } from '../core/constants.js';
 import { logStepStart } from '../log/messages/steps.js';
 import { runsAlsoOnBuildFailure, runsOnlyOnBuildFailure } from '../plugins/events.js';
 import { normalizeTagName } from '../report/statsd.js';
 import { measureDuration } from '../time/main.js';
+import { setMultiSpanAttributes } from '../tracing/main.js';
 import { fireCoreStep } from './core_step.js';
 import { firePluginStep } from './plugin.js';
 import { getStepReturn } from './return.js';
+const tracer = trace.getTracer('steps');
 // Run a step (core, build command or plugin)
-export const runStep = async function ({ event, childProcess, packageName, coreStep, coreStepId, coreStepName, coreStepDescription, pluginPackageJson, loadedFrom, origin, condition, configPath, outputConfigPath, buildDir, repositoryRoot, nodePath, index, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, mode, api, errorMonitor, deployId, errorParams, error, failedPlugins, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, quiet, userNodeVersion, }) {
-    const constantsA = await addMutableConstants({ constants, buildDir, netlifyConfig });
-    if (!(await shouldRunStep({
-        event,
-        packageName,
-        error,
-        failedPlugins,
-        netlifyConfig,
-        condition,
-        constants: constantsA,
-        buildbotServerSocket,
-        buildDir,
-        saveConfig,
-    }))) {
-        return {};
-    }
-    if (!quiet) {
-        logStepStart({ logs, event, packageName, coreStepDescription, error, netlifyConfig });
-    }
-    const fireStep = getFireStep(packageName, coreStepId, event);
-    const { newEnvChanges, netlifyConfig: netlifyConfigA = netlifyConfig, configMutations: configMutationsA = configMutations, headersPath: headersPathA = headersPath, redirectsPath: redirectsPathA = redirectsPath, newError, newStatus, timers: timersA, durationNs, metrics, } = await fireStep({
-        event,
-        childProcess,
-        packageName,
-        pluginPackageJson,
-        loadedFrom,
-        origin,
-        coreStep,
-        coreStepId,
-        coreStepName,
-        configPath,
-        outputConfigPath,
-        buildDir,
-        repositoryRoot,
-        nodePath,
-        childEnv,
-        context,
-        branch,
-        envChanges,
-        constants: constantsA,
-        steps,
-        buildbotServerSocket,
-        events,
-        error,
-        logs,
-        debug,
-        systemLog,
-        verbose,
-        saveConfig,
-        timers,
-        errorParams,
-        configOpts,
-        netlifyConfig,
-        configMutations,
-        headersPath,
-        redirectsPath,
-        featureFlags,
-        userNodeVersion,
-    });
-    const newValues = await getStepReturn({
-        event,
-        packageName,
-        newError,
-        newEnvChanges,
-        newStatus,
-        coreStep,
-        coreStepName,
-        childEnv,
-        mode,
-        api,
-        errorMonitor,
-        deployId,
-        netlifyConfig: netlifyConfigA,
-        configMutations: configMutationsA,
-        headersPath: headersPathA,
-        redirectsPath: redirectsPathA,
-        logs,
-        debug,
-        timers: timersA,
-        durationNs,
-        testOpts,
-        systemLog,
-        quiet,
-        metrics,
+export const runStep = async function ({ event, childProcess, packageName, coreStep, coreStepId, coreStepName, coreStepDescription, pluginPackageJson, loadedFrom, origin, condition, configPath, outputConfigPath, buildDir, repositoryRoot, nodePath, index, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, mode, api, errorMonitor, deployId, errorParams, error, failedPlugins, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, quiet, userNodeVersion, explicitSecretKeys, }) {
+    // Add relevant attributes to the upcoming span context
+    const attributes = {
+        'build.execution.step.name': coreStepName,
+        'build.execution.step.description': coreStepDescription,
+        'build.execution.step.package_name': packageName,
+        'build.execution.step.id': coreStepId,
+        'build.execution.step.loaded_from': loadedFrom,
+        'build.execution.step.origin': origin,
+        'build.execution.step.event': event,
+    };
+    const spanCtx = setMultiSpanAttributes(attributes);
+    return tracer.startActiveSpan(`run-step-${coreStepId}`, {}, spanCtx, async (span) => {
+        const constantsA = await addMutableConstants({ constants, buildDir, netlifyConfig });
+        const shouldRun = await shouldRunStep({
+            event,
+            packageName,
+            error,
+            failedPlugins,
+            netlifyConfig,
+            condition,
+            constants: constantsA,
+            buildbotServerSocket,
+            buildDir,
+            saveConfig,
+            explicitSecretKeys,
+        });
+        span.setAttribute('build.execution.step.should_run', shouldRun);
+        if (!shouldRun) {
+            span.end();
+            return {};
+        }
+        if (!quiet) {
+            logStepStart({ logs, event, packageName, coreStepDescription, error, netlifyConfig });
+        }
+        const fireStep = getFireStep(packageName, coreStepId, event);
+        const { newEnvChanges, netlifyConfig: netlifyConfigA = netlifyConfig, configMutations: configMutationsA = configMutations, headersPath: headersPathA = headersPath, redirectsPath: redirectsPathA = redirectsPath, newError, newStatus, timers: timersA, durationNs, metrics, } = await fireStep({
+            event,
+            childProcess,
+            packageName,
+            pluginPackageJson,
+            loadedFrom,
+            origin,
+            coreStep,
+            coreStepId,
+            coreStepName,
+            configPath,
+            outputConfigPath,
+            buildDir,
+            repositoryRoot,
+            nodePath,
+            childEnv,
+            context,
+            branch,
+            envChanges,
+            constants: constantsA,
+            steps,
+            buildbotServerSocket,
+            events,
+            error,
+            logs,
+            debug,
+            systemLog,
+            verbose,
+            saveConfig,
+            timers,
+            errorParams,
+            configOpts,
+            netlifyConfig,
+            configMutations,
+            headersPath,
+            redirectsPath,
+            featureFlags,
+            userNodeVersion,
+            explicitSecretKeys,
+        });
+        const newValues = await getStepReturn({
+            event,
+            packageName,
+            newError,
+            newEnvChanges,
+            newStatus,
+            coreStep,
+            coreStepName,
+            childEnv,
+            mode,
+            api,
+            errorMonitor,
+            deployId,
+            netlifyConfig: netlifyConfigA,
+            configMutations: configMutationsA,
+            headersPath: headersPathA,
+            redirectsPath: redirectsPathA,
+            logs,
+            debug,
+            timers: timersA,
+            durationNs,
+            testOpts,
+            systemLog,
+            quiet,
+            metrics,
+        });
+        span.end();
+        return { ...newValues, newIndex: index + 1 };
     });
-    return { ...newValues, newIndex: index + 1 };
 };
 // A plugin fails _without making the build fail_ when either:
 //   - using `utils.build.failPlugin()`
@@ -125,10 +147,10 @@ export const runStep = async function ({ event, childProcess, packageName, coreS
 // or available. However, one might be created by a build plugin, in which case,
 // those core plugins should be triggered. We use a dynamic `condition()` to
 // model this behavior.
-const shouldRunStep = async function ({ event, packageName, error, failedPlugins, netlifyConfig, condition, constants, buildbotServerSocket, buildDir, saveConfig, }) {
+const shouldRunStep = async function ({ event, packageName, error, failedPlugins, netlifyConfig, condition, constants, buildbotServerSocket, buildDir, saveConfig, explicitSecretKeys, }) {
     if (failedPlugins.includes(packageName) ||
         (condition !== undefined &&
-            !(await condition({ buildDir, constants, buildbotServerSocket, netlifyConfig, saveConfig })))) {
+            !(await condition({ buildDir, constants, buildbotServerSocket, netlifyConfig, saveConfig, explicitSecretKeys })))) {
         return false;
     }
     if (error !== undefined) {
@@ -144,7 +166,7 @@ const getFireStep = function (packageName, coreStepId, event) {
     const parentTag = normalizeTagName(packageName);
     return measureDuration(tFireStep, event, { parentTag, category: 'pluginEvent' });
 };
-const tFireStep = function ({ event, childProcess, packageName, pluginPackageJson, loadedFrom, origin, coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, nodePath, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, error, logs, debug, systemLog, verbose, saveConfig, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, userNodeVersion, }) {
+const tFireStep = function ({ event, childProcess, packageName, pluginPackageJson, loadedFrom, origin, coreStep, coreStepId, coreStepName, configPath, outputConfigPath, buildDir, repositoryRoot, nodePath, childEnv, context, branch, envChanges, constants, steps, buildbotServerSocket, events, error, logs, debug, systemLog, verbose, saveConfig, errorParams, configOpts, netlifyConfig, configMutations, headersPath, redirectsPath, featureFlags, userNodeVersion, explicitSecretKeys, }) {
     if (coreStep !== undefined) {
         return fireCoreStep({
             coreStep,
@@ -174,6 +196,7 @@ const tFireStep = function ({ event, childProcess, packageName, pluginPackageJso
             systemLog,
             saveConfig,
             userNodeVersion,
+            explicitSecretKeys,
         });
     }
     return firePluginStep({

package/lib/steps/run_steps.js

@@ -7,7 +7,7 @@ import { runStep } from './run_step.js';
 // list of `failedPlugins` (that ran `utils.build.failPlugin()`).
 // If an error arises, runs `onError` events.
 // Runs `onEnd` events at the end, whether an error was thrown or not.
-export const runSteps = async function ({ steps, buildbotServerSocket, events, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, childEnv, context, branch, constants, mode, api, errorMonitor, deployId, errorParams, netlifyConfig, configOpts, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, quiet, userNodeVersion, }) {
+export const runSteps = async function ({ steps, buildbotServerSocket, events, configPath, outputConfigPath, headersPath, redirectsPath, buildDir, repositoryRoot, nodePath, childEnv, context, branch, constants, mode, api, errorMonitor, deployId, errorParams, netlifyConfig, configOpts, logs, debug, systemLog, verbose, saveConfig, timers, testOpts, featureFlags, quiet, userNodeVersion, explicitSecretKeys, }) {
     const { index: stepsCount, error: errorA, netlifyConfig: netlifyConfigC, statuses: statusesB, failedPlugins: failedPluginsA, timers: timersC, configMutations: configMutationsB, metrics: metricsC, } = await pReduce(steps, async ({ index, error, failedPlugins, envChanges, netlifyConfig: netlifyConfigA, configMutations, headersPath: headersPathA, redirectsPath: redirectsPathA, statuses, timers: timersA, metrics: metricsA, }, { event, childProcess, packageName, coreStep, coreStepId, coreStepName, coreStepDescription, pluginPackageJson, loadedFrom, origin, condition, }) => {
         const { newIndex = index, newError = error, failedPlugin = [], newEnvChanges = {}, netlifyConfig: netlifyConfigB = netlifyConfigA, configMutations: configMutationsA = configMutations, headersPath: headersPathB = headersPathA, redirectsPath: redirectsPathB = redirectsPathA, newStatus, timers: timersB = timersA, metrics: metricsB = [], } = await runStep({
             event,
@@ -57,6 +57,7 @@ export const runSteps = async function ({ steps, buildbotServerSocket, events, c
             featureFlags,
             quiet,
             userNodeVersion,
+            explicitSecretKeys,
         });
         const statusesA = addStatus({ newStatus, statuses, event, packageName, pluginPackageJson });
         return {

package/lib/tracing/main.js

@@ -0,0 +1,52 @@
+import { HoneycombSDK } from '@honeycombio/opentelemetry-node';
+import { context, trace, propagation, SpanStatusCode } from '@opentelemetry/api';
+import { HttpInstrumentation } from '@opentelemetry/instrumentation-http';
+import { ROOT_PACKAGE_JSON } from '../utils/json.js';
+let sdk;
+/** Starts the tracing SDK, if there's already a tracing service this will be a no-op */
+export const startTracing = function (options) {
+    if (!options.enabled)
+        return;
+    if (sdk)
+        return;
+    sdk = new HoneycombSDK({
+        serviceName: ROOT_PACKAGE_JSON.name,
+        endpoint: `http://${options.host}:${options.port}`,
+        instrumentations: [new HttpInstrumentation()],
+    });
+    sdk.start();
+    // Sets the current trace ID and span ID based on the options received
+    // this is used as a way to propagate trace context from Buildbot
+    trace.setSpanContext(context.active(), {
+        traceId: options.traceId,
+        spanId: options.parentSpanId,
+        traceFlags: options.traceFlags,
+        isRemote: true,
+    });
+};
+/** Stops the tracing service if there's one running. This will flush any ongoing events */
+export const stopTracing = async function () {
+    if (!sdk)
+        return;
+    return sdk.shutdown();
+};
+/** Sets attributes to be propagated across child spans under the current context */
+export const setMultiSpanAttributes = function (attributes) {
+    const currentBaggage = propagation.getBaggage(context.active());
+    let baggage = currentBaggage === undefined ? propagation.createBaggage() : currentBaggage;
+    Object.entries(attributes).forEach((entry) => {
+        baggage = baggage.setEntry(entry[0], { value: entry[1] });
+    });
+    return propagation.setBaggage(context.active(), baggage);
+};
+/** Add error information to the current active span (if any) */
+export const addErrorToActiveSpan = function (error) {
+    const span = trace.getActiveSpan();
+    if (!span)
+        return;
+    span.recordException(error);
+    span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error.message,
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "29.12.8",
+  "version": "29.14.0",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/core/main.js",
@@ -64,6 +64,7 @@
   "license": "MIT",
   "dependencies": {
     "@bugsnag/js": "^7.0.0",
+    "@honeycombio/opentelemetry-node": "^0.4.0",
     "@netlify/cache-utils": "^5.1.5",
     "@netlify/config": "^20.5.1",
     "@netlify/edge-bundler": "8.16.2",
@@ -73,6 +74,8 @@
     "@netlify/plugins-list": "^6.68.0",
     "@netlify/run-utils": "^5.1.1",
     "@netlify/zip-it-and-ship-it": "9.10.0",
+    "@opentelemetry/api": "^1.4.1",
+    "@opentelemetry/instrumentation-http": "^0.40.0",
     "@sindresorhus/slugify": "^2.0.0",
     "ansi-escapes": "^6.0.0",
     "chalk": "^5.0.0",
@@ -146,5 +149,5 @@
       "module": "commonjs"
     }
   },
-  "gitHead": "d0f8ab39846e14532655694264da61301cd1d4c2"
+  "gitHead": "3ec21c7c8e5c221d96b32e739331dc44b18fe05c"
 }