@netlify/build 29.42.6 → 29.44.0

package/lib/core/build.js

@@ -382,6 +382,8 @@ const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig
         debug,
         verbose,
         netlifyConfig,
+        featureFlags,
+        systemLog,
     });
     const { steps, events } = timeline === 'dev' ? getDevSteps(devCommand, pluginsSteps, eventHandlers) : getSteps(pluginsSteps, eventHandlers);
     if (dry) {

package/lib/core/feature_flags.js

@@ -17,4 +17,5 @@ export const DEFAULT_FEATURE_FLAGS = {
     edge_functions_system_logger: false,
     netlify_build_reduced_output: false,
     netlify_build_updated_plugin_compatibility: false,
+    netlify_build_plugin_system_log: false,
 };

package/lib/log/output_flusher.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 import { Transform } from 'stream';
+import type { StandardStreams } from './stream.js';
 declare const flusherSymbol: unique symbol;
 /**
  * Utility class for conditionally rendering certain output only if additional
@@ -21,4 +22,5 @@ export declare class OutputFlusherTransform extends Transform {
     constructor(flusher: OutputFlusher);
     _transform(chunk: any, _: string, callback: () => void): void;
 }
+export declare const getStandardStreams: (outputFlusher?: OutputFlusher) => StandardStreams;
 export {};

package/lib/log/output_flusher.js

@@ -1,3 +1,4 @@
+import { stdout, stderr } from 'process';
 import { Transform } from 'stream';
 const flusherSymbol = Symbol.for('@netlify/output-gate');
 /**
@@ -35,3 +36,16 @@ export class OutputFlusherTransform extends Transform {
         callback();
     }
 }
+export const getStandardStreams = (outputFlusher) => {
+    if (!outputFlusher) {
+        return {
+            stdout,
+            stderr,
+        };
+    }
+    return {
+        outputFlusher,
+        stdout: new OutputFlusherTransform(outputFlusher).pipe(stdout),
+        stderr: new OutputFlusherTransform(outputFlusher).pipe(stderr),
+    };
+};

package/lib/log/stream.d.ts

@@ -1,10 +1,23 @@
-export function getBuildCommandStdio(logs: any): "pipe" | "inherit";
-export function handleBuildCommandOutput({ stdout: commandStdout, stderr: commandStderr }: {
-    stdout: any;
-    stderr: any;
-}, logs: any): void;
-export function pipePluginOutput(childProcess: any, logs: any, outputFlusher: any): void | {
-    stdoutListener: any;
-    stderrListener: any;
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { ChildProcess } from '../plugins/spawn.js';
+import { Logs } from './logger.js';
+import type { OutputFlusher } from './output_flusher.js';
+export type StandardStreams = {
+    stderr: NodeJS.WriteStream;
+    stdout: NodeJS.WriteStream;
+    outputFlusher?: OutputFlusher;
 };
-export function unpipePluginOutput(childProcess: any, logs: any, listeners: any): Promise<void>;
+type LogsListener = (logs: string[], outputFlusher: OutputFlusher | undefined, chunk: Buffer) => void;
+type LogsListeners = {
+    stderrListener: LogsListener;
+    stdoutListener: LogsListener;
+};
+export declare const getBuildCommandStdio: (logs: Logs) => "pipe" | "inherit";
+export declare const handleBuildCommandOutput: ({ stdout: commandStdout, stderr: commandStderr }: {
+    stdout: string;
+    stderr: string;
+}, logs: Logs) => void;
+export declare const pipePluginOutput: (childProcess: ChildProcess, logs: Logs, standardStreams: StandardStreams) => void | LogsListeners;
+export declare const unpipePluginOutput: (childProcess: ChildProcess, logs: Logs, listeners: LogsListeners, standardStreams: StandardStreams) => Promise<void>;
+export {};

package/lib/log/stream.js

@@ -1,7 +1,5 @@
-import { stdout, stderr } from 'process';
 import { promisify } from 'util';
 import { logsAreBuffered } from './logger.js';
-import { OutputFlusherTransform } from './output_flusher.js';
 // TODO: replace with `timers/promises` after dropping Node < 15.0.0
 const pSetTimeout = promisify(setTimeout);
 // We try to use `stdio: inherit` because it keeps `stdout/stderr` as `TTY`,
@@ -29,41 +27,36 @@ const pushBuildCommandOutput = function (output, logsArray) {
     logsArray.push(output);
 };
 // Start plugin step output
-export const pipePluginOutput = function (childProcess, logs, outputFlusher) {
+export const pipePluginOutput = function (childProcess, logs, standardStreams) {
     if (!logsAreBuffered(logs)) {
-        return streamOutput(childProcess, outputFlusher);
+        return streamOutput(childProcess, standardStreams);
     }
-    return pushOutputToLogs(childProcess, logs, outputFlusher);
+    return pushOutputToLogs(childProcess, logs, standardStreams.outputFlusher);
 };
 // Stop streaming/buffering plugin step output
-export const unpipePluginOutput = async function (childProcess, logs, listeners) {
+export const unpipePluginOutput = async function (childProcess, logs, listeners, standardStreams) {
     // Let `childProcess` `stdout` and `stderr` flush before stopping redirecting
     await pSetTimeout(0);
     if (!logsAreBuffered(logs)) {
-        return unstreamOutput(childProcess);
+        return unstreamOutput(childProcess, standardStreams);
     }
-    unpushOutputToLogs(childProcess, logs, listeners);
+    unpushOutputToLogs(childProcess, listeners.stdoutListener, listeners.stderrListener);
 };
 // Usually, we stream stdout/stderr because it is more efficient
-const streamOutput = function (childProcess, outputFlusher) {
-    if (outputFlusher) {
-        childProcess.stdout.pipe(new OutputFlusherTransform(outputFlusher)).pipe(stdout);
-        childProcess.stderr.pipe(new OutputFlusherTransform(outputFlusher)).pipe(stderr);
-        return;
-    }
-    childProcess.stdout.pipe(stdout);
-    childProcess.stderr.pipe(stderr);
+const streamOutput = function (childProcess, standardStreams) {
+    childProcess.stdout?.pipe(standardStreams.stdout);
+    childProcess.stderr?.pipe(standardStreams.stderr);
 };
-const unstreamOutput = function (childProcess) {
-    childProcess.stdout.unpipe(stdout);
-    childProcess.stderr.unpipe(stderr);
+const unstreamOutput = function (childProcess, standardStreams) {
+    childProcess.stdout?.unpipe(standardStreams.stdout);
+    childProcess.stderr?.unpipe(standardStreams.stderr);
 };
 // In tests, we push to the `logs` array instead
 const pushOutputToLogs = function (childProcess, logs, outputFlusher) {
     const stdoutListener = logsListener.bind(null, logs.stdout, outputFlusher);
     const stderrListener = logsListener.bind(null, logs.stderr, outputFlusher);
-    childProcess.stdout.on('data', stdoutListener);
-    childProcess.stderr.on('data', stderrListener);
+    childProcess.stdout?.on('data', stdoutListener);
+    childProcess.stderr?.on('data', stderrListener);
     return { stdoutListener, stderrListener };
 };
 const logsListener = function (logs, outputFlusher, chunk) {
@@ -72,7 +65,7 @@ const logsListener = function (logs, outputFlusher, chunk) {
     }
     logs.push(chunk.toString().trimEnd());
 };
-const unpushOutputToLogs = function (childProcess, logs, { stdoutListener, stderrListener }) {
-    childProcess.stdout.removeListener('data', stdoutListener);
-    childProcess.stderr.removeListener('data', stderrListener);
+const unpushOutputToLogs = function (childProcess, stdoutListener, stderrListener) {
+    childProcess.stdout?.removeListener('data', stdoutListener);
+    childProcess.stderr?.removeListener('data', stderrListener);
 };

package/lib/plugins/load.d.ts

@@ -1,4 +1,4 @@
-export function loadPlugins({ pluginsOptions, childProcesses, packageJson, timers, logs, debug, verbose, netlifyConfig, }: {
+export function loadPlugins({ pluginsOptions, childProcesses, packageJson, timers, logs, debug, verbose, netlifyConfig, featureFlags, systemLog, }: {
     pluginsOptions: any;
     childProcesses: any;
     packageJson: any;
@@ -7,4 +7,6 @@ export function loadPlugins({ pluginsOptions, childProcesses, packageJson, timer
     debug: any;
     verbose: any;
     netlifyConfig: any;
+    featureFlags: any;
+    systemLog: any;
 }): Promise<any>;

package/lib/plugins/load.js

@@ -1,16 +1,39 @@
+import { promisify } from 'util';
 import { addErrorInfo } from '../error/info.js';
 import { addPluginLoadErrorStatus } from '../status/load_error.js';
 import { measureDuration } from '../time/main.js';
 import { callChild } from './ipc.js';
+const pSetTimeout = promisify(setTimeout);
 // Retrieve all plugins steps
 // Can use either a module name or a file path to the plugin.
-export const loadPlugins = async function ({ pluginsOptions, childProcesses, packageJson, timers, logs, debug, verbose, netlifyConfig, }) {
+export const loadPlugins = async function ({ pluginsOptions, childProcesses, packageJson, timers, logs, debug, verbose, netlifyConfig, featureFlags, systemLog, }) {
     return pluginsOptions.length === 0
         ? { pluginsSteps: [], timers }
-        : await loadAllPlugins({ pluginsOptions, childProcesses, packageJson, timers, logs, debug, verbose, netlifyConfig });
+        : await loadAllPlugins({
+            pluginsOptions,
+            childProcesses,
+            packageJson,
+            timers,
+            logs,
+            debug,
+            verbose,
+            netlifyConfig,
+            featureFlags,
+            systemLog,
+        });
 };
-const tLoadAllPlugins = async function ({ pluginsOptions, childProcesses, packageJson, logs, debug, verbose, netlifyConfig, }) {
-    const pluginsSteps = await Promise.all(pluginsOptions.map((pluginOptions, index) => loadPlugin(pluginOptions, { childProcesses, index, packageJson, logs, debug, verbose, netlifyConfig })));
+const tLoadAllPlugins = async function ({ pluginsOptions, childProcesses, packageJson, logs, debug, verbose, netlifyConfig, featureFlags, systemLog, }) {
+    const pluginsSteps = await Promise.all(pluginsOptions.map((pluginOptions, index) => loadPlugin(pluginOptions, {
+        childProcesses,
+        index,
+        packageJson,
+        logs,
+        debug,
+        verbose,
+        netlifyConfig,
+        featureFlags,
+        systemLog,
+    })));
     const pluginsStepsA = pluginsSteps.flat();
     return { pluginsSteps: pluginsStepsA };
 };
@@ -18,9 +41,19 @@ const tLoadAllPlugins = async function ({ pluginsOptions, childProcesses, packag
 const loadAllPlugins = measureDuration(tLoadAllPlugins, 'load_plugins');
 // Retrieve plugin steps for one plugin.
 // Do it by executing the plugin `load` event handler.
-const loadPlugin = async function ({ packageName, pluginPackageJson, pluginPackageJson: { version } = {}, pluginPath, inputs, loadedFrom, origin }, { childProcesses, index, packageJson, logs, debug, verbose, netlifyConfig }) {
+const loadPlugin = async function ({ packageName, pluginPackageJson, pluginPackageJson: { version } = {}, pluginPath, inputs, loadedFrom, origin }, { childProcesses, index, packageJson, logs, debug, verbose, netlifyConfig, featureFlags, systemLog }) {
     const { childProcess } = childProcesses[index];
     const loadEvent = 'load';
+    // A buffer for any data piped into the child process' stderr. We'll pipe
+    // this to system logs if we fail to load the plugin.
+    const bufferedStdErr = [];
+    let bufferedStdListener;
+    if (featureFlags.netlify_build_plugin_system_log && childProcess.stderr) {
+        bufferedStdListener = (data) => {
+            bufferedStdErr.push(data.toString().trimEnd());
+        };
+        childProcess.stderr.on('data', bufferedStdListener);
+    }
     try {
         const { events } = await callChild({
             childProcess,
@@ -40,6 +73,13 @@ const loadPlugin = async function ({ packageName, pluginPackageJson, pluginPacka
         return pluginSteps;
     }
     catch (error) {
+        if (featureFlags.netlify_build_plugin_system_log) {
+            // Wait for stderr to be flushed.
+            await pSetTimeout(0);
+            bufferedStdErr.forEach((line) => {
+                systemLog(line);
+            });
+        }
         addErrorInfo(error, {
             plugin: { packageName, pluginPackageJson },
             location: { event: loadEvent, packageName, loadedFrom, origin },
@@ -47,4 +87,9 @@ const loadPlugin = async function ({ packageName, pluginPackageJson, pluginPacka
         addPluginLoadErrorStatus({ error, packageName, version, debug });
         throw error;
     }
+    finally {
+        if (bufferedStdListener) {
+            childProcess.stderr.removeListener('data', bufferedStdListener);
+        }
+    }
 };

package/lib/plugins/spawn.d.ts

@@ -2,6 +2,7 @@ import { ExecaChildProcess } from 'execa';
 import { NetlifyConfig } from '../index.js';
 import { BufferedLogs } from '../log/logger.js';
 import { PluginsOptions } from './node_version.js';
+export type ChildProcess = ExecaChildProcess<string>;
 export declare const startPlugins: any;
 export declare const stopPlugins: ({ childProcesses, logs, verbose, pluginOptions, netlifyConfig, }: {
     logs: BufferedLogs;

package/lib/steps/plugin.js

@@ -2,6 +2,7 @@ import { context, propagation } from '@opentelemetry/api';
 import { addErrorInfo } from '../error/info.js';
 import { addOutputFlusher } from '../log/logger.js';
 import { logStepCompleted } from '../log/messages/ipc.js';
+import { getStandardStreams } from '../log/output_flusher.js';
 import { pipePluginOutput, unpipePluginOutput } from '../log/stream.js';
 import { callChild } from '../plugins/ipc.js';
 import { getSuccessStatus } from '../status/success.js';
@@ -10,10 +11,11 @@ import { updateNetlifyConfig, listConfigSideFiles } from './update_config.js';
 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, outputFlusher, systemLog, featureFlags, debug, verbose, }) {
-    const listeners = pipePluginOutput(childProcess, logs, outputFlusher);
+    const standardStreams = getStandardStreams(outputFlusher);
+    const listeners = pipePluginOutput(childProcess, logs, standardStreams);
     const otelCarrier = {};
     propagation.inject(context.active(), otelCarrier);
-    const logsA = addOutputFlusher(logs, outputFlusher);
+    const logsA = outputFlusher ? addOutputFlusher(logs, outputFlusher) : logs;
     try {
         const configSideFiles = await listConfigSideFiles([headersPath, redirectsPath]);
         const { newEnvChanges, configMutations: newConfigMutations, status, } = await callChild({
@@ -28,7 +30,7 @@ export const firePluginStep = async function ({ event, childProcess, packageName
                 constants,
                 otelCarrier,
             },
-            logs,
+            logs: logsA,
             verbose,
         });
         const { netlifyConfig: netlifyConfigA, configMutations: configMutationsA, headersPath: headersPathA, redirectsPath: redirectsPathA, } = await updateNetlifyConfig({
@@ -66,7 +68,7 @@ export const firePluginStep = async function ({ event, childProcess, packageName
         return { newError };
     }
     finally {
-        await unpipePluginOutput(childProcess, logs, listeners);
+        await unpipePluginOutput(childProcess, logs, listeners, standardStreams);
         logStepCompleted(logs, verbose);
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "29.42.6",
+  "version": "29.44.0",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -165,5 +165,5 @@
   "engines": {
     "node": "^14.16.0 || >=16.0.0"
   },
-  "gitHead": "be380af1c62fd62a202bbca551a30f290b0d3f99"
+  "gitHead": "bd868b81a1ead42e337bea8bebfee0d51307e078"
 }