@netlify/build 29.7.2 → 29.9.0

package/lib/core/build.js

@@ -89,7 +89,7 @@ const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cached
     const pluginsOptions = addCorePlugins({ netlifyConfig, constants });
     // `errorParams` is purposely stateful
     Object.assign(errorParams, { netlifyConfig, pluginsOptions, siteInfo, childEnv, userNodeVersion });
-    const { pluginsOptions: pluginsOptionsA, netlifyConfig: netlifyConfigA, stepsCount, timers: timersB, configMutations, } = await runAndReportBuild({
+    const { pluginsOptions: pluginsOptionsA, netlifyConfig: netlifyConfigA, stepsCount, timers: timersB, configMutations, metrics, } = await runAndReportBuild({
         pluginsOptions,
         netlifyConfig,
         configOpts,
@@ -135,13 +135,14 @@ const tExecBuild = async function ({ config, defaultConfig, cachedConfig, cached
         stepsCount,
         timers: timersB,
         configMutations,
+        metrics,
     };
 };
 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, }) {
     try {
-        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, pluginsOptions: pluginsOptionsA, failedPlugins, timers: timersA, configMutations, } = await initAndRunBuild({
+        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, pluginsOptions: pluginsOptionsA, failedPlugins, timers: timersA, configMutations, metrics, } = await initAndRunBuild({
             pluginsOptions,
             netlifyConfig,
             configOpts,
@@ -215,6 +216,7 @@ export const runAndReportBuild = async function ({ pluginsOptions, netlifyConfig
             stepsCount,
             timers: timersA,
             configMutations,
+            metrics,
         };
     }
     catch (error) {
@@ -267,7 +269,7 @@ const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, configO
         quiet,
     });
     try {
-        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersC, configMutations, } = await runBuild({
+        const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersC, configMutations, metrics, } = await runBuild({
             childProcesses,
             pluginsOptions: pluginsOptionsA,
             netlifyConfig,
@@ -315,6 +317,7 @@ const initAndRunBuild = async function ({ pluginsOptions, netlifyConfig, configO
             failedPlugins,
             timers: timersC,
             configMutations,
+            metrics,
         };
     }
     finally {
@@ -343,7 +346,7 @@ const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig
         await doDryRun({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs });
         return { netlifyConfig };
     }
-    const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersB, configMutations, } = await runSteps({
+    const { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersB, configMutations, metrics, } = await runSteps({
         steps,
         buildbotServerSocket,
         events,
@@ -375,5 +378,13 @@ const runBuild = async function ({ childProcesses, pluginsOptions, netlifyConfig
         featureFlags,
         quiet,
     });
-    return { stepsCount, netlifyConfig: netlifyConfigA, statuses, failedPlugins, timers: timersB, configMutations };
+    return {
+        stepsCount,
+        netlifyConfig: netlifyConfigA,
+        statuses,
+        failedPlugins,
+        timers: timersB,
+        configMutations,
+        metrics,
+    };
 };

package/lib/core/main.js

@@ -5,6 +5,7 @@ import { logTimer, logBuildSuccess } from '../log/messages/core.js';
 import { trackBuildComplete } from '../telemetry/main.js';
 import { reportTimers } from '../time/report.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';
@@ -19,7 +20,7 @@ export default async function buildSite(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, } = await execBuild({
+        const { pluginsOptions, netlifyConfig: netlifyConfigA, siteInfo, userNodeVersion, stepsCount, timers, durationNs, configMutations, metrics, } = await execBuild({
             ...flagsA,
             buildId,
             systemLogFile,
@@ -41,6 +42,7 @@ export default async function buildSite(flags = {}) {
             durationNs,
             statsdOpts,
             systemLog,
+            metrics,
         });
         const { success, severityCode, status } = getSeverity('success');
         await telemetryReport({
@@ -80,13 +82,14 @@ export default async function buildSite(flags = {}) {
     }
 }
 // Logs and reports that a build successfully ended
-const handleBuildSuccess = async function ({ framework, dry, logs, timers, durationNs, statsdOpts, systemLog }) {
+const handleBuildSuccess = async function ({ framework, dry, logs, timers, durationNs, statsdOpts, systemLog, metrics, }) {
     if (dry) {
         return;
     }
     logBuildSuccess(logs);
     logTimer(logs, durationNs, 'Netlify Build', systemLog);
     await reportTimers(timers, statsdOpts, framework);
+    await reportMetrics(statsdOpts, metrics);
 };
 // Handles the calls and errors of telemetry reports
 const telemetryReport = async function ({ deployId, buildId, status, stepsCount, pluginsOptions, durationNs, siteInfo, telemetry, userNodeVersion, framework, testOpts, errorParams, }) {

package/lib/core/report_metrics.js

@@ -0,0 +1,17 @@
+import { closeClient, formatTags, startClient, validateStatsDOptions } from '../report/statsd.js';
+/**
+ * Record number of functions build and differentiate between autogenerated and user generated.
+ * Sends to statsd daemon.
+ */
+export const reportMetrics = async function (statsdOpts, metrics) {
+    if (!validateStatsDOptions(statsdOpts) || metrics.length === 0) {
+        return;
+    }
+    const client = await startClient(statsdOpts);
+    metrics.forEach((metric) => {
+        if (typeof client[metric.type] === 'function') {
+            client[metric.type](metric.name, metric.value, formatTags(metric.tags));
+        }
+    });
+    await closeClient(client);
+};

package/lib/plugins_core/edge_functions/index.js

@@ -43,14 +43,30 @@ const coreStep = async function ({ buildDir, constants: { EDGE_FUNCTIONS_DIST: d
             systemLogger: featureFlags.edge_functions_system_logger ? systemLog : undefined,
             internalSrcFolder: internalSrcPath,
         });
+        const metrics = getMetrics(manifest);
         systemLog('Edge Functions manifest:', manifest);
+        await validateEdgeFunctionsManifest(manifest, featureFlags);
+        return { metrics };
     }
     catch (error) {
         tagBundlingError(error);
         throw error;
     }
-    await validateEdgeFunctionsManifest({ buildDir, constants: { EDGE_FUNCTIONS_DIST: distDirectory }, featureFlags });
-    return {};
+};
+const getMetrics = (manifest) => {
+    const numGenEfs = Object.values(manifest.function_config).filter((config) => config.generator).length;
+    const allRoutes = [...manifest.routes, ...manifest.post_cache_routes];
+    const totalEfs = [];
+    allRoutes.forEach((route) => {
+        if (!totalEfs.some((func) => func === route.function)) {
+            totalEfs.push(route.function);
+        }
+    });
+    const numUserEfs = totalEfs.length - numGenEfs;
+    return [
+        { type: 'increment', name: 'buildbot.build.functions', value: numGenEfs, tags: { type: 'edge:generated' } },
+        { type: 'increment', name: 'buildbot.build.functions', value: numUserEfs, tags: { type: 'edge:user' } },
+    ];
 };
 // We run this core step if at least one of the functions directories (the
 // one configured by the user or the internal one) exists. We use a dynamic

package/lib/plugins_core/edge_functions/validate_manifest/validate_edge_functions_manifest.js

@@ -1,15 +1,8 @@
-import { promises as fs } from 'fs';
-import { join, resolve } from 'path';
 import { ManifestValidationError, validateManifest } from '@netlify/edge-bundler';
 import { tagBundlingError } from '../lib/error.js';
-export const validateEdgeFunctionsManifest = async function ({ buildDir, constants: { EDGE_FUNCTIONS_DIST: distDirectory }, featureFlags, }) {
-    const edgeFunctionsDistPath = resolve(buildDir, distDirectory);
-    const manifestPath = join(edgeFunctionsDistPath, 'manifest.json');
-    const data = await fs.readFile(manifestPath);
-    // @ts-expect-error TypeScript is not aware that parse can handle Buffer
-    const manifestData = JSON.parse(data);
+export const validateEdgeFunctionsManifest = async function (manifest, featureFlags) {
     try {
-        validateManifest(manifestData, featureFlags);
+        validateManifest(manifest, featureFlags);
     }
     catch (error) {
         if (error instanceof ManifestValidationError) {

package/lib/plugins_core/functions/index.js

@@ -79,10 +79,12 @@ const coreStep = async function ({ childEnv, constants: { INTERNAL_FUNCTIONS_SRC
         logs,
         repositoryRoot,
     });
+    const metrics = getMetrics(internalFunctions, userFunctions);
     return {
         tags: {
             bundler: bundlers,
         },
+        metrics,
     };
 };
 // We run this core step if at least one of the functions directories (the
@@ -115,3 +117,19 @@ export const zipItAndShipIt = {
         return await zipFunctions(...args);
     },
 };
+const getMetrics = (internalFunctions, userFunctions) => {
+    return [
+        {
+            type: 'increment',
+            name: 'buildbot.build.functions',
+            value: internalFunctions.length,
+            tags: { type: 'lambda:generated' },
+        },
+        {
+            type: 'increment',
+            name: 'buildbot.build.functions',
+            value: userFunctions.length,
+            tags: { type: 'lambda:user' },
+        },
+    ];
+};

package/lib/steps/core_step.js

@@ -6,7 +6,7 @@ export const fireCoreStep = async function ({ coreStep, coreStepId, coreStepName
     try {
         const configSideFiles = await listConfigSideFiles([headersPath, redirectsPath]);
         const childEnvA = setEnvChanges(envChanges, { ...childEnv });
-        const { newEnvChanges = {}, configMutations: newConfigMutations = [], tags, } = await coreStep({
+        const { newEnvChanges = {}, configMutations: newConfigMutations = [], tags, metrics, } = await coreStep({
             configPath,
             outputConfigPath,
             buildDir,
@@ -47,6 +47,7 @@ export const fireCoreStep = async function ({ coreStep, coreStepId, coreStepName
             headersPath: headersPathA,
             redirectsPath: redirectsPathA,
             tags,
+            metrics,
         };
     }
     catch (newError) {

package/lib/steps/return.js

@@ -2,7 +2,7 @@ import { logTimer } from '../log/messages/core.js';
 import { logStepSuccess } from '../log/messages/steps.js';
 import { handleStepError } from './error.js';
 // Retrieve the return value of a step
-export const getStepReturn = function ({ event, packageName, newError, newEnvChanges, newStatus, coreStep, coreStepName: timerName = `${packageName} ${event}`, childEnv, mode, api, errorMonitor, deployId, netlifyConfig, configMutations, headersPath, redirectsPath, logs, debug, timers, durationNs, testOpts, systemLog, quiet, }) {
+export const getStepReturn = function ({ event, packageName, newError, newEnvChanges, newStatus, coreStep, coreStepName: timerName = `${packageName} ${event}`, childEnv, mode, api, errorMonitor, deployId, netlifyConfig, configMutations, headersPath, redirectsPath, logs, debug, timers, durationNs, testOpts, systemLog, quiet, metrics, }) {
     if (newError !== undefined) {
         return handleStepError({
             event,
@@ -23,5 +23,5 @@ export const getStepReturn = function ({ event, packageName, newError, newEnvCha
         logStepSuccess(logs);
         logTimer(logs, durationNs, timerName, systemLog);
     }
-    return { newEnvChanges, netlifyConfig, configMutations, headersPath, redirectsPath, newStatus, timers };
+    return { newEnvChanges, netlifyConfig, configMutations, headersPath, redirectsPath, newStatus, timers, metrics };
 };

package/lib/steps/run_step.js

@@ -27,7 +27,7 @@ export const runStep = async function ({ event, childProcess, packageName, coreS
         logStepStart({ logs, event, packageName, coreStepDescription, index, 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, } = await fireStep({
+    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,
@@ -89,6 +89,7 @@ export const runStep = async function ({ event, childProcess, packageName, coreS
         testOpts,
         systemLog,
         quiet,
+        metrics,
     });
     return { ...newValues, newIndex: index + 1 };
 };

package/lib/steps/run_steps.js

@@ -8,8 +8,8 @@ import { runStep } from './run_step.js';
 // 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, }) {
-    const { index: stepsCount, error: errorA, netlifyConfig: netlifyConfigC, statuses: statusesB, failedPlugins: failedPluginsA, timers: timersC, configMutations: configMutationsB, } = await pReduce(steps, async ({ index, error, failedPlugins, envChanges, netlifyConfig: netlifyConfigA, configMutations, headersPath: headersPathA, redirectsPath: redirectsPathA, statuses, timers: timersA, }, { 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, } = await runStep({
+    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,
             childProcess,
             packageName,
@@ -69,6 +69,7 @@ export const runSteps = async function ({ steps, buildbotServerSocket, events, c
             redirectsPath: redirectsPathB,
             statuses: statusesA,
             timers: timersB,
+            metrics: [...metricsA, ...metricsB],
         };
     }, {
         index: 0,
@@ -80,6 +81,7 @@ export const runSteps = async function ({ steps, buildbotServerSocket, events, c
         redirectsPath,
         statuses: [],
         timers,
+        metrics: [],
     });
     // Instead of throwing any build failure right away, we wait for `onError`,
     // etc. to complete. This is why we are throwing only now.
@@ -94,5 +96,6 @@ export const runSteps = async function ({ steps, buildbotServerSocket, events, c
         failedPlugins: failedPluginsA,
         timers: timersC,
         configMutations: configMutationsB,
+        metrics: metricsC,
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/build",
-  "version": "29.7.2",
+  "version": "29.9.0",
   "description": "Netlify build module",
   "type": "module",
   "exports": "./lib/core/main.js",
@@ -147,5 +147,5 @@
       "module": "commonjs"
     }
   },
-  "gitHead": "7081ca94e87250bbcadbdf9a550b3d478b86c313"
+  "gitHead": "4eb3c1043739007bce796309e87b3db42d09a5f2"
 }