@netlify/build 29.36.6 → 29.37.0

package/lib/core/build.js

@@ -350,7 +350,13 @@ const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, configO
         // the build is finished. The exception is when running in the dev timeline
         // since those are long-running events by nature.
         if (timeline !== 'dev') {
-            stopPlugins(childProcesses);
+            await stopPlugins({
+                childProcesses,
+                pluginOptions: pluginsOptionsA,
+                netlifyConfig,
+                logs,
+                verbose,
+            });
         }
     }
 };

package/lib/plugins/child/main.js

@@ -1,6 +1,6 @@
 import { setInspectColors } from '../../log/colors.js';
-import { sendEventToParent, getEventsFromParent } from '../ipc.js';
-import { handleProcessErrors, handleError } from './error.js';
+import { getEventsFromParent, sendEventToParent } from '../ipc.js';
+import { handleError, handleProcessErrors } from './error.js';
 import { load } from './load.js';
 import { run } from './run.js';
 // Boot plugin child process.
@@ -33,5 +33,20 @@ const handleEvent = async function ({ callId, eventName, payload, state, state:
         await handleError(error, verbose);
     }
 };
-const EVENTS = { load, run };
+const EVENTS = {
+    load,
+    run,
+    // async shutdown hook to stop tracing reliably
+    shutdown: async () => {
+        try {
+            const { stopTracing } = await import('@netlify/opentelemetry-sdk-setup');
+            await stopTracing();
+        }
+        catch {
+            // noop as the opentelemetry-sdk-setup is an optional dependency
+            // and might not be present in the CLI
+        }
+        return { context: {} };
+    },
+};
 bootPlugin();

package/lib/plugins/child/run.d.ts

@@ -1,10 +1,11 @@
-export function run({ event, error, constants, envChanges, featureFlags, netlifyConfig }: {
+export function run({ event, error, constants, envChanges, featureFlags, netlifyConfig, otelCarrier }: {
     event: any;
     error: any;
     constants: any;
     envChanges: any;
     featureFlags: any;
     netlifyConfig: any;
+    otelCarrier: any;
 }, { methods, inputs, packageJson, verbose }: {
     methods: any;
     inputs: any;

package/lib/plugins/child/run.js

@@ -1,30 +1,36 @@
+import { getGlobalContext, setGlobalContext } from '@netlify/opentelemetry-utils';
+import { context, propagation } from '@opentelemetry/api';
 import { getNewEnvChanges, setEnvChanges } from '../../env/changes.js';
-import { logPluginMethodStart, logPluginMethodEnd } from '../../log/messages/ipc.js';
+import { logPluginMethodEnd, logPluginMethodStart } from '../../log/messages/ipc.js';
 import { cloneNetlifyConfig, getConfigMutations } from './diff.js';
 import { getSystemLog } from './systemLog.js';
 import { getUtils } from './utils.js';
-// Run a specific plugin event handler
-export const run = async function ({ event, error, constants, envChanges, featureFlags, netlifyConfig }, { methods, inputs, packageJson, verbose }) {
-    const method = methods[event];
-    const runState = {};
-    const systemLog = getSystemLog();
-    const utils = getUtils({ event, constants, runState });
-    const netlifyConfigCopy = cloneNetlifyConfig(netlifyConfig);
-    const runOptions = {
-        utils,
-        constants,
-        inputs,
-        netlifyConfig: netlifyConfigCopy,
-        packageJson,
-        error,
-        featureFlags,
-        systemLog,
-    };
-    const envBefore = setEnvChanges(envChanges);
-    logPluginMethodStart(verbose);
-    await method(runOptions);
-    logPluginMethodEnd(verbose);
-    const newEnvChanges = getNewEnvChanges(envBefore, netlifyConfig, netlifyConfigCopy);
-    const configMutations = getConfigMutations(netlifyConfig, netlifyConfigCopy, event);
-    return { ...runState, newEnvChanges, configMutations };
+/** Run a specific plugin event handler */
+export const run = async function ({ event, error, constants, envChanges, featureFlags, netlifyConfig, otelCarrier }, { methods, inputs, packageJson, verbose }) {
+    setGlobalContext(propagation.extract(context.active(), otelCarrier));
+    // set the global context for the plugin run
+    return context.with(getGlobalContext(), async () => {
+        const method = methods[event];
+        const runState = {};
+        const systemLog = getSystemLog();
+        const utils = getUtils({ event, constants, runState });
+        const netlifyConfigCopy = cloneNetlifyConfig(netlifyConfig);
+        const runOptions = {
+            utils,
+            constants,
+            inputs,
+            netlifyConfig: netlifyConfigCopy,
+            packageJson,
+            error,
+            featureFlags,
+            systemLog,
+        };
+        const envBefore = setEnvChanges(envChanges);
+        logPluginMethodStart(verbose);
+        await method(runOptions);
+        logPluginMethodEnd(verbose);
+        const newEnvChanges = getNewEnvChanges(envBefore, netlifyConfig, netlifyConfigCopy);
+        const configMutations = getConfigMutations(netlifyConfig, netlifyConfigCopy, event);
+        return { ...runState, newEnvChanges, configMutations };
+    });
 };

package/lib/plugins/node_version.d.ts

@@ -6,6 +6,7 @@ export type PluginsOptions = {
     loadedFrom: PluginsLoadedFrom;
     origin: 'config' | string;
     inputs: Record<string, any>;
+    pluginPackageJson?: Record<string, any>;
 };
 /**
  * Local plugins and `package.json`-installed plugins use user's preferred Node.js version if higher than our minimum

package/lib/plugins/node_version.js

@@ -41,9 +41,9 @@ const addPluginNodeVersion = async function ({ featureFlags, pluginOptions, plug
         !semver.satisfies(userNodeVersion, UPCOMING_MINIMUM_REQUIRED_NODE_VERSION)) {
         logWarningSubHeader(logs, `Warning: Starting January 30, 2024 plugin "${packageName}" will be executed with Node.js version 20.`);
         logWarning(logs, `  We're upgrading our system node version on that day, which means the plugin cannot be executed with your defined Node.js version ${userNodeVersion}.
-        
+
   Please make sure your plugin supports being run on Node.js 20.
-  
+
   Read more about our minimum required version in our ${link('forums announcement', 'https://answers.netlify.com/t/build-plugin-update-system-node-js-version-upgrade-to-20/108633')}`);
         if (pluginPath) {
             const pluginDir = dirname(pluginPath);
@@ -70,7 +70,7 @@ const addPluginNodeVersion = async function ({ featureFlags, pluginOptions, plug
     }
     logWarningSubHeader(logs, `Warning: ${packageName} will be executed with Node.js version ${currentNodeVersion}`);
     logWarning(logs, `  The plugin cannot be executed with your defined Node.js version ${userNodeVersion}
-  
+
   Read more about our minimum required version in our ${link('forums announcement', 'https://answers.netlify.com/t/build-plugins-dropping-support-for-node-js-12/79421')}`);
     return systemNode;
 };

package/lib/plugins/spawn.d.ts

@@ -1,2 +1,14 @@
+import { ExecaChildProcess } from 'execa';
+import { NetlifyConfig } from '../index.js';
+import { BufferedLogs } from '../log/logger.js';
+import { PluginsOptions } from './node_version.js';
 export declare const startPlugins: any;
-export declare const stopPlugins: (childProcesses: any) => void;
+export declare const stopPlugins: ({ childProcesses, logs, verbose, pluginOptions, netlifyConfig, }: {
+    logs: BufferedLogs;
+    verbose: boolean;
+    childProcesses: {
+        childProcess: ExecaChildProcess;
+    }[];
+    pluginOptions: PluginsOptions[];
+    netlifyConfig: NetlifyConfig;
+}) => Promise<void>;

package/lib/plugins/spawn.js

@@ -1,12 +1,16 @@
-import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import { fileURLToPath, pathToFileURL } from 'url';
+import { trace } from '@opentelemetry/api';
 import { execaNode } from 'execa';
+import { gte } from 'semver';
 import { addErrorInfo } from '../error/info.js';
-import { logRuntime, logLoadingPlugins, logOutdatedPlugins, logIncompatiblePlugins, logLoadingIntegration, } from '../log/messages/compatibility.js';
+import { logIncompatiblePlugins, logLoadingIntegration, logLoadingPlugins, logOutdatedPlugins, logRuntime, } from '../log/messages/compatibility.js';
 import { isTrustedPlugin } from '../steps/plugin.js';
 import { measureDuration } from '../time/main.js';
-import { getEventFromChild } from './ipc.js';
+import { callChild, getEventFromChild } from './ipc.js';
 import { getSpawnInfo } from './options.js';
 const CHILD_MAIN_FILE = fileURLToPath(new URL('child/main.js', import.meta.url));
+const require = createRequire(import.meta.url);
 // Start child processes used by all plugins
 // We fire plugins through child processes so that:
 //  - each plugin is sandboxed, e.g. cannot access/modify its parent `process`
@@ -21,20 +25,47 @@ const tStartPlugins = async function ({ pluginsOptions, buildDir, childEnv, logs
     }
     logOutdatedPlugins(logs, pluginsOptions);
     logIncompatiblePlugins(logs, pluginsOptions);
-    const childProcesses = await Promise.all(pluginsOptions.map(({ pluginDir, nodePath, pluginPackageJson }) => startPlugin({ pluginDir, nodePath, buildDir, childEnv, systemLogFile, pluginPackageJson })));
+    const childProcesses = await Promise.all(pluginsOptions.map(({ pluginDir, nodePath, nodeVersion, pluginPackageJson }) => startPlugin({ pluginDir, nodePath, nodeVersion, buildDir, childEnv, systemLogFile, pluginPackageJson })));
     return { childProcesses };
 };
 export const startPlugins = measureDuration(tStartPlugins, 'start_plugins');
-const startPlugin = async function ({ pluginDir, nodePath, buildDir, childEnv, systemLogFile, pluginPackageJson }) {
-    const childProcess = execaNode(CHILD_MAIN_FILE, [], {
+const startPlugin = async function ({ pluginDir, nodeVersion, nodePath, buildDir, childEnv, systemLogFile, pluginPackageJson, }) {
+    const ctx = trace.getActiveSpan()?.spanContext();
+    // the baggage will be passed to the child process when sending the run event
+    const args = [
+        ...process.argv.filter((arg) => arg.startsWith('--tracing')),
+        `--tracing.traceId=${ctx?.traceId}`,
+        `--tracing.parentSpanId=${ctx?.spanId}`,
+        `--tracing.traceFlags=${ctx?.traceFlags}`,
+        `--tracing.enabled=${!!isTrustedPlugin(pluginPackageJson?.name)}`,
+    ];
+    const nodeOptions = [];
+    // the sdk setup is a optional dependency that might not exist
+    // only use it if it exists
+    try {
+        // the --import preloading is only available in node 18.18.0 and above
+        // plugins that run on a lower node version will not be able to be instrumented with opentelemetry
+        if (gte(nodeVersion, '18.18.0')) {
+            const entry = require.resolve('@netlify/opentelemetry-sdk-setup/bin.js');
+            // on windows only file:// urls are allowed
+            nodeOptions.push('--import', pathToFileURL(entry).toString());
+        }
+    }
+    catch {
+        // noop
+    }
+    const childProcess = execaNode(CHILD_MAIN_FILE, args, {
         cwd: buildDir,
         preferLocal: true,
         localDir: pluginDir,
         nodePath,
-        // make sure we don't pass build's node cli properties for now (e.g. --import)
-        nodeOptions: [],
+        nodeOptions,
         execPath: nodePath,
-        env: childEnv,
+        env: {
+            ...childEnv,
+            OTEL_SERVICE_NAME: pluginPackageJson?.name,
+            OTEL_SERVICE_VERSION: pluginPackageJson?.version,
+        },
         extendEnv: false,
         stdio: isTrustedPlugin(pluginPackageJson?.name) && systemLogFile
             ? ['pipe', 'pipe', 'pipe', 'ipc', systemLogFile]
@@ -51,11 +82,28 @@ const startPlugin = async function ({ pluginDir, nodePath, buildDir, childEnv, s
     }
 };
 // Stop all plugins child processes
-export const stopPlugins = function (childProcesses) {
-    childProcesses.forEach(stopPlugin);
+export const stopPlugins = async function ({ childProcesses, logs, verbose, pluginOptions, netlifyConfig, }) {
+    await Promise.all(childProcesses.map(({ childProcess }, index) => {
+        return stopPlugin({ childProcess, verbose, logs, pluginOptions: pluginOptions[index], netlifyConfig });
+    }));
 };
-const stopPlugin = function ({ childProcess }) {
+const stopPlugin = async function ({ childProcess, logs, pluginOptions: { packageName, inputs, pluginPath, pluginPackageJson: packageJson = {} }, netlifyConfig, verbose, }) {
     if (childProcess.connected) {
+        // reliable stop tracing inside child processes
+        await callChild({
+            childProcess,
+            eventName: 'shutdown',
+            payload: {
+                packageName,
+                pluginPath,
+                inputs,
+                packageJson,
+                verbose,
+                netlifyConfig,
+            },
+            logs,
+            verbose,
+        });
         childProcess.disconnect();
     }
     childProcess.kill();

package/lib/plugins_core/build_command.js

@@ -1,36 +1,45 @@
 import { platform } from 'process';
+import { trace } from '@opentelemetry/api';
+import { wrapTracer } from '@opentelemetry/api/experimental';
 import { execa } from 'execa';
 import { addErrorInfo } from '../error/info.js';
 import { getBuildCommandDescription } from '../log/description.js';
 import { logBuildCommandStart } from '../log/messages/steps.js';
 import { getBuildCommandStdio, handleBuildCommandOutput } from '../log/stream.js';
+const tracer = wrapTracer(trace.getTracer('build-command'));
 // Fire `build.command`
 const coreStep = async function ({ configPath, buildDir, nodePath, childEnv, logs, netlifyConfig: { build: { command: buildCommand, commandOrigin: buildCommandOrigin }, }, }) {
-    logBuildCommandStart(logs, buildCommand);
-    const stdio = getBuildCommandStdio(logs);
-    const childProcess = execa(buildCommand, {
-        shell: SHELL,
-        cwd: buildDir,
-        preferLocal: true,
-        execPath: nodePath,
-        env: childEnv,
-        extendEnv: false,
-        stdio,
+    return tracer.withActiveSpan('build.command', async (span) => {
+        span.setAttributes({
+            'build.command.origin': buildCommandOrigin,
+            'build.cwd': buildDir,
+        });
+        logBuildCommandStart(logs, buildCommand);
+        const stdio = getBuildCommandStdio(logs);
+        const childProcess = execa(buildCommand, {
+            shell: SHELL,
+            cwd: buildDir,
+            preferLocal: true,
+            execPath: nodePath,
+            env: childEnv,
+            extendEnv: false,
+            stdio,
+        });
+        try {
+            const buildCommandOutput = await childProcess;
+            handleBuildCommandOutput(buildCommandOutput, logs);
+            return {};
+        }
+        catch (error) {
+            // In our test environment we use `stdio: 'pipe'` on the build command, meaning our `stdout/stderr` output are
+            // buffered and consequently added to `error.message`. To avoid this and end up with duplicated output in our
+            // logs/snapshots we need to rely on `error.shortMessage`.
+            error.message = error.shortMessage;
+            handleBuildCommandOutput(error, logs);
+            addErrorInfo(error, { type: 'buildCommand', location: { buildCommand, buildCommandOrigin, configPath } });
+            throw error;
+        }
     });
-    try {
-        const buildCommandOutput = await childProcess;
-        handleBuildCommandOutput(buildCommandOutput, logs);
-        return {};
-    }
-    catch (error) {
-        // In our test environment we use `stdio: 'pipe'` on the build command, meaning our `stdout/stderr` output are
-        // buffered and consequently added to `error.message`. To avoid this and end up with duplicated output in our
-        // logs/snapshots we need to rely on `error.shortMessage`.
-        error.message = error.shortMessage;
-        handleBuildCommandOutput(error, logs);
-        addErrorInfo(error, { type: 'buildCommand', location: { buildCommand, buildCommandOrigin, configPath } });
-        throw error;
-    }
 };
 // We use Bash on Unix and `cmd.exe` on Windows
 const SHELL = platform === 'win32' ? true : 'bash';

package/lib/steps/plugin.js

@@ -1,3 +1,4 @@
+import { context, propagation } from '@opentelemetry/api';
 import { addErrorInfo } from '../error/info.js';
 import { logStepCompleted } from '../log/messages/ipc.js';
 import { pipePluginOutput, unpipePluginOutput } from '../log/stream.js';
@@ -9,6 +10,8 @@ export const isTrustedPlugin = (packageName) => packageName?.startsWith('@netlif
 // 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, systemLog, featureFlags, debug, verbose, }) {
     const listeners = pipePluginOutput(childProcess, logs);
+    const otelCarrier = {};
+    propagation.inject(context.active(), otelCarrier);
     try {
         const configSideFiles = await listConfigSideFiles([headersPath, redirectsPath]);
         const { newEnvChanges, configMutations: newConfigMutations, status, } = await callChild({
@@ -21,6 +24,7 @@ export const firePluginStep = async function ({ event, childProcess, packageName
                 featureFlags: isTrustedPlugin(pluginPackageJson?.name) ? featureFlags : undefined,
                 netlifyConfig,
                 constants,
+                otelCarrier,
             },
             logs,
             verbose,

package/lib/steps/run_step.js

@@ -22,9 +22,13 @@ export const runStep = async function ({ event, childProcess, packageName, coreS
         'build.execution.step.origin': origin,
         'build.execution.step.event': event,
     };
+    if (pluginPackageJson?.name && pluginPackageJson?.version) {
+        attributes['build.execution.step.plugin_name'] = pluginPackageJson.name;
+        attributes['build.execution.step.plugin_version'] = pluginPackageJson.version;
+    }
     const spanCtx = setMultiSpanAttributes(attributes);
     // If there's no `coreStepId` then this is a plugin execution
-    const spanName = `run-step-${coreStepId || 'plugin'}`;
+    const spanName = `run-step-${coreStepId || `plugin-${event}`}`;
     return tracer.startActiveSpan(spanName, {}, spanCtx, async (span) => {
         const constantsA = await addMutableConstants({ constants, buildDir, netlifyConfig });
         const shouldRun = await shouldRunStep({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "29.36.6",
+  "version": "29.37.0",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -75,7 +75,7 @@
     "@netlify/framework-info": "^9.8.11",
     "@netlify/functions-utils": "^5.2.51",
     "@netlify/git-utils": "^5.1.1",
-    "@netlify/opentelemetry-utils": "^1.0.3",
+    "@netlify/opentelemetry-utils": "^1.1.0",
     "@netlify/plugins-list": "^6.75.0",
     "@netlify/run-utils": "^5.1.1",
     "@netlify/zip-it-and-ship-it": "9.29.2",
@@ -127,8 +127,8 @@
   },
   "devDependencies": {
     "@netlify/nock-udp": "^3.1.2",
-    "@opentelemetry/api": "^1.7.0",
-    "@opentelemetry/sdk-trace-base": "^1.18.1",
+    "@opentelemetry/api": "~1.8.0",
+    "@opentelemetry/sdk-trace-base": "~1.22.0",
     "@types/node": "^14.18.53",
     "@vitest/coverage-c8": "^0.33.0",
     "atob": "^2.1.2",
@@ -153,8 +153,8 @@
     "yarn": "^1.22.4"
   },
   "peerDependencies": {
-    "@netlify/opentelemetry-sdk-setup": "^1.0.5",
-    "@opentelemetry/api": "^1.7.0"
+    "@netlify/opentelemetry-sdk-setup": "^1.1.0",
+    "@opentelemetry/api": "~1.8.0"
   },
   "peerDependenciesMeta": {
     "@netlify/opentelemetry-sdk-setup": {
@@ -164,5 +164,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "1cee56d47237e07daa078e8149c411aa346bc8e1"
+  "gitHead": "058943be167177f38fc6a02f7da00a18d72f2d89"
 }