@netlify/build 35.13.8 → 35.14.0

package/lib/log/messages/core_steps.d.ts

@@ -2,6 +2,14 @@ export function logBundleResults({ logs, results }: {
     logs: any;
     results: import("@netlify/zip-it-and-ship-it").FunctionResult[];
 }): void;
+export function trackBundleResults({ results, systemLog }: {
+    results: import("@netlify/zip-it-and-ship-it").FunctionResult[];
+    systemLog: (...args: unknown[]) => void;
+}): {
+    bundlers: import("@netlify/zip-it-and-ship-it").NodeBundlerName[];
+    fallbackCount: number;
+    warningsCount: number;
+};
 export function logFunctionsNonExistingDir(logs: any, relativeFunctionsSrc: any): void;
 export function logFunctionsToBundle({ logs, userFunctions, userFunctionsSrc, userFunctionsSrcExists, internalFunctions, internalFunctionsSrc, frameworkFunctions, generatedFunctions, type, }: {
     logs: any;

package/lib/log/messages/core_steps.js

@@ -1,4 +1,6 @@
 import path from 'path';
+import { RUNTIME } from '@netlify/zip-it-and-ship-it';
+import { trace } from '@opentelemetry/api';
 import { log, logArray, logError, logErrorSubHeader, logWarningSubHeader } from '../logger.js';
 import { THEME } from '../theme.js';
 const logBundleResultFunctions = ({ functions, headerMessage, logs, error }) => {
@@ -12,7 +14,7 @@ const logBundleResultFunctions = ({ functions, headerMessage, logs, error }) =>
     logArray(logs, functionNames);
 };
 /**
- * Logs the result of bundling functions
+ * Logs the result of bundling functions (user facing)
  *
  * @param {object} options
  * @param {any} options.logs
@@ -44,6 +46,58 @@ export const logBundleResults = ({ logs, results = [] }) => {
         logModulesWithDynamicImports({ logs, modulesWithDynamicImports });
     }
 };
+/**
+ * Sibling of `logBundleResults`. Derives structured telemetry from the same
+ * `results` array and emits it to the system log and the active span. Returns
+ * summary stats the caller can use for metric tags.
+ *
+ * @param {object} options
+ * @param {import("@netlify/zip-it-and-ship-it").FunctionResult[]} options.results
+ * @param {(...args: unknown[]) => void} options.systemLog
+ * @returns {{
+ *   bundlers: import("@netlify/zip-it-and-ship-it").NodeBundlerName[],
+ *   fallbackCount: number,
+ *   warningsCount: number,
+ * }}
+ */
+export const trackBundleResults = ({ results = [], systemLog }) => {
+    // `bundlerErrors` is only set when the user requested `esbuild_zisi` (esbuild
+    // with zisi fallback), esbuild failed, and zisi succeeded. The final
+    // `bundler` reflects the fallback, so this is our "silent fallback" signal.
+    const perFunction = results.map((result) => ({
+        name: result.name,
+        runtime: result.runtime,
+        bundler: result.runtime === RUNTIME.JAVASCRIPT ? result.bundler : null,
+        hadFallback: (result.bundlerErrors?.length ?? 0) > 0,
+        hadWarnings: (result.bundlerWarnings?.length ?? 0) > 0,
+    }));
+    // Exclude both `null` (non-JS runtimes) and `undefined` (prebuilt `.zip`
+    // JS functions, which zip-it-and-ship-it passes through with no bundler).
+    const jsResults = perFunction.filter((p) => p.bundler != null);
+    const bundlers = [...new Set(jsResults.map((p) => p.bundler))];
+    const bundlerCounts = jsResults.reduce((acc, p) => ({ ...acc, [p.bundler]: (acc[p.bundler] ?? 0) + 1 }), {});
+    const fallbackCount = perFunction.filter((p) => p.hadFallback).length;
+    const warningsCount = perFunction.filter((p) => p.hadWarnings).length;
+    systemLog({
+        msg: 'Functions bundling completed',
+        bundlers,
+        bundlerCounts,
+        fallbackCount,
+        warningsCount,
+        functions: perFunction,
+    });
+    const span = trace.getActiveSpan();
+    if (span) {
+        span.setAttribute('build.execution.step.bundler', bundlers);
+        span.setAttribute('build.execution.step.functions_count', perFunction.length);
+        span.setAttribute('build.execution.step.bundler.fallback_count', fallbackCount);
+        span.setAttribute('build.execution.step.bundler.warnings_count', warningsCount);
+        for (const [bundler, count] of Object.entries(bundlerCounts)) {
+            span.setAttribute(`build.execution.step.bundler.${bundler}.count`, count);
+        }
+    }
+    return { bundlers, fallbackCount, warningsCount };
+};
 export const logFunctionsNonExistingDir = function (logs, relativeFunctionsSrc) {
     log(logs, `The Netlify Functions setting targets a non-existing directory: ${relativeFunctionsSrc}`);
 };

package/lib/plugins_core/functions/index.d.ts

@@ -1,40 +1,8 @@
 import { zipFunctions, type FunctionResult } from '@netlify/zip-it-and-ship-it';
+import type { CoreStepFunction } from '../types.js';
 export declare const bundleFunctions: {
     event: string;
-    coreStep: ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc, IS_LOCAL: isRunningLocally, FUNCTIONS_SRC: relativeFunctionsSrc, FUNCTIONS_DIST: relativeFunctionsDist, }, buildDir, branch, packagePath, logs, netlifyConfig, featureFlags, repositoryRoot, userNodeVersion, systemLog, returnValues, }: {
-        childEnv: any;
-        constants: {
-            INTERNAL_FUNCTIONS_SRC: any;
-            IS_LOCAL: any;
-            FUNCTIONS_SRC: any;
-            FUNCTIONS_DIST: any;
-        };
-        buildDir: any;
-        branch: any;
-        packagePath: any;
-        logs: any;
-        netlifyConfig: any;
-        featureFlags: any;
-        repositoryRoot: any;
-        userNodeVersion: any;
-        systemLog: any;
-        returnValues: any;
-    }) => Promise<{
-        tags?: undefined;
-        metrics?: undefined;
-    } | {
-        tags: {
-            bundler: ("zisi" | "nft" | "esbuild" | "none" | "esbuild_zisi")[];
-        };
-        metrics: {
-            type: string;
-            name: string;
-            value: number;
-            tags: {
-                type: string;
-            };
-        }[];
-    }>;
+    coreStep: CoreStepFunction;
     coreStepId: string;
     coreStepName: string;
     coreStepDescription: () => string;

package/lib/plugins_core/functions/index.js

@@ -1,20 +1,14 @@
 import { resolve } from 'path';
-import { RUNTIME, zipFunctions } from '@netlify/zip-it-and-ship-it';
+import { zipFunctions } from '@netlify/zip-it-and-ship-it';
 import { pathExists } from 'path-exists';
 import { addErrorInfo } from '../../error/info.js';
 import { log } from '../../log/logger.js';
 import { getGeneratedFunctions } from '../../steps/return_values.js';
-import { logBundleResults, logFunctionsNonExistingDir, logFunctionsToBundle } from '../../log/messages/core_steps.js';
+import { logBundleResults, logFunctionsNonExistingDir, logFunctionsToBundle, trackBundleResults, } from '../../log/messages/core_steps.js';
 import { FRAMEWORKS_API_FUNCTIONS_PATH } from '../../utils/frameworks_api.js';
 import { getZipError } from './error.js';
 import { getUserAndInternalFunctions, validateFunctionsSrc } from './utils.js';
 import { getZisiParameters } from './zisi.js';
-// Get a list of all unique bundlers in this run
-const getBundlers = (results = []) => 
-// using a Set to filter duplicates
-new Set(results
-    .map((bundle) => (bundle.runtime === RUNTIME.JAVASCRIPT ? bundle.bundler : null))
-    .filter(Boolean));
 // see https://docs.netlify.com/functions/trigger-on-events/#available-triggers
 const eventTriggeredFunctions = new Set([
     'deploy-building',
@@ -74,9 +68,9 @@ const zipFunctionsAndLogResults = async ({ branch, buildDir, childEnv, featureFl
             },
         }, functionsDist, zisiParameters);
         validateCustomRoutes(results);
-        const bundlers = Array.from(getBundlers(results));
         logBundleResults({ logs, results });
-        return { bundlers };
+        const summary = trackBundleResults({ results, systemLog });
+        return summary;
     }
     catch (error) {
         throw await getZipError(error, functionsSrc);
@@ -86,7 +80,7 @@ const zipFunctionsAndLogResults = async ({ branch, buildDir, childEnv, featureFl
 const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC: relativeInternalFunctionsSrc, IS_LOCAL: isRunningLocally, FUNCTIONS_SRC: relativeFunctionsSrc, FUNCTIONS_DIST: relativeFunctionsDist, }, buildDir, branch, packagePath, logs, netlifyConfig, featureFlags, repositoryRoot, userNodeVersion, systemLog, returnValues, }) {
     const functionsSrc = relativeFunctionsSrc === undefined ? undefined : resolve(buildDir, relativeFunctionsSrc);
     const functionsDist = resolve(buildDir, relativeFunctionsDist);
-    const internalFunctionsSrc = resolve(buildDir, relativeInternalFunctionsSrc);
+    const internalFunctionsSrc = resolve(buildDir, relativeInternalFunctionsSrc ?? '');
     const internalFunctionsSrcExists = await pathExists(internalFunctionsSrc);
     const frameworkFunctionsSrc = resolve(buildDir, packagePath || '', FRAMEWORKS_API_FUNCTIONS_PATH);
     const frameworkFunctionsSrcExists = await pathExists(frameworkFunctionsSrc);
@@ -123,7 +117,7 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
         generatedFunctions.length === 0) {
         return {};
     }
-    const { bundlers } = await zipFunctionsAndLogResults({
+    const { bundlers, fallbackCount, warningsCount } = await zipFunctionsAndLogResults({
         branch,
         buildDir,
         childEnv,
@@ -140,10 +134,14 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
         systemLog,
         generatedFunctions: generatedFunctions.map((func) => func.path),
     });
-    const metrics = getMetrics(internalFunctions, userFunctions);
+    const fallback = fallbackCount > 0 ? 'true' : 'false';
+    const warnings = warningsCount > 0 ? 'true' : 'false';
+    const metrics = getMetrics(internalFunctions, userFunctions, { bundlers, fallback, warnings });
     return {
         tags: {
             bundler: bundlers,
+            fallback,
+            warnings,
         },
         metrics,
     };
@@ -203,19 +201,19 @@ export const zipItAndShipIt = {
         return await zipFunctions(...args);
     },
 };
-const getMetrics = (internalFunctions, userFunctions) => {
+const getMetrics = (internalFunctions, userFunctions, { bundlers, fallback, warnings }) => {
     return [
         {
             type: 'increment',
             name: 'buildbot.build.functions',
             value: internalFunctions.length,
-            tags: { type: 'lambda:generated' },
+            tags: { type: 'lambda:generated', bundler: bundlers, fallback, warnings },
         },
         {
             type: 'increment',
             name: 'buildbot.build.functions',
             value: userFunctions.length,
-            tags: { type: 'lambda:user' },
+            tags: { type: 'lambda:user', bundler: bundlers, fallback, warnings },
         },
     ];
 };

package/lib/plugins_core/types.d.ts

@@ -1,7 +1,8 @@
 import { type DynamicMethods } from 'packages/js-client/lib/types.js';
-import { NetlifyPluginConstants } from '../core/constants.js';
-import { BufferedLogs } from '../log/logger.js';
-import { NetlifyConfig } from '../types/config/netlify_config.js';
+import type { NetlifyPluginConstants } from '../core/constants.js';
+import type { BufferedLogs } from '../log/logger.js';
+import type { NetlifyConfig } from '../types/config/netlify_config.js';
+import type { ReturnValue } from '../steps/return_values.js';
 type $TSFixme = any;
 export type CoreStepFunctionArgs = {
     /**
@@ -46,6 +47,9 @@ export type CoreStepFunctionArgs = {
         isSecret: boolean;
         scopes: string[];
     }[];
+    userNodeVersion?: string;
+    childEnv: $TSFixme;
+    returnValues: Record<string, ReturnValue>;
     buildbotServerSocket?: string;
     api: DynamicMethods;
 };

package/lib/types/config/functions.d.ts

@@ -1,9 +1,25 @@
 type GlobPattern = string;
 type FunctionsObject = {
+    /**
+     * marks the function as a [background function](https://docs.netlify.com/functions/background-functions/), which is invoked asynchronously and can run for up to 15 minutes.
+     */
+    background?: boolean;
     /**
      * a list of additional paths to include in the function bundle. Although our build system includes statically referenced files (like `import * from "./some-file.js"`) by default, `included_files` lets you specify additional files or directories and reference them dynamically in function code. You can use `*` to match any character or prefix an entry with `!` to exclude files. Paths are relative to the [base directory](https://docs.netlify.com/configure-builds/get-started/#definitions-1).
      */
     included_files?: string[];
+    /**
+     * the amount of memory allocated to the function, expressed either as a number of MB or as a string with a unit (e.g. `"2gb"`). Mutually exclusive with `vcpu`.
+     */
+    memory?: number | string;
+    /**
+     * the [region](https://docs.netlify.com/functions/optional-configuration/#region) the function should run in, identified by its airport code (e.g. `"cmh"`).
+     */
+    region?: string;
+    /**
+     * the number of vCPUs allocated to the function (between `0.5` and `2`). Mutually exclusive with `memory`.
+     */
+    vcpu?: number;
 } & ({
     /**
      * the function bundling method used in [`@netlify/zip-it-and-ship-it`](https://github.com/netlify/zip-it-and-ship-it).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "35.13.8",
+  "version": "35.14.0",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/index.js",
@@ -70,7 +70,7 @@
     "@netlify/blobs": "^10.4.4",
     "@netlify/cache-utils": "^6.0.5",
     "@netlify/config": "^24.6.0",
-    "@netlify/edge-bundler": "14.10.2",
+    "@netlify/edge-bundler": "14.10.3",
     "@netlify/functions-utils": "^6.2.34",
     "@netlify/git-utils": "^6.0.4",
     "@netlify/opentelemetry-utils": "^2.0.2",
@@ -152,5 +152,5 @@
   "engines": {
     "node": ">=18.14.0"
   },
-  "gitHead": "0e2b212c4ffae1e07159374df9991584e5b4bb0b"
+  "gitHead": "dc4e6c79ae03de4070f706c936ed7e177d8ffec3"
 }