@netlify/build 0.4.48 → 1.0.0-dl-test

package/lib/core/constants.js

@@ -0,0 +1,116 @@
+import { relative, normalize } from 'path';
+import { getCacheDir } from '@netlify/cache-utils';
+import mapObj from 'map-obj';
+import { pathExists } from 'path-exists';
+import { ROOT_PACKAGE_JSON } from '../utils/json.js';
+// Retrieve constants passed to plugins
+export const getConstants = async function ({ configPath, buildDir, functionsDistDir, edgeFunctionsDistDir, cacheDir, netlifyConfig, siteInfo: { id: siteId }, apiHost, token, mode, }) {
+    const isLocal = mode !== 'buildbot';
+    const normalizedCacheDir = getCacheDir({ cacheDir, cwd: buildDir });
+    const constants = {
+        // Path to the Netlify configuration file
+        CONFIG_PATH: configPath,
+        // The directory where built serverless functions are placed before deployment
+        FUNCTIONS_DIST: functionsDistDir,
+        // The directory where built Edge Functions are placed before deployment
+        EDGE_FUNCTIONS_DIST: edgeFunctionsDistDir,
+        // Path to the Netlify build cache folder
+        CACHE_DIR: normalizedCacheDir,
+        // Boolean indicating whether the build was run locally (Netlify CLI) or in the production CI
+        IS_LOCAL: isLocal,
+        // The version of Netlify Build
+        NETLIFY_BUILD_VERSION: ROOT_PACKAGE_JSON.version,
+        // The Netlify Site ID
+        SITE_ID: siteId,
+        // The Netlify API access token
+        NETLIFY_API_TOKEN: token,
+        // The Netlify API host
+        NETLIFY_API_HOST: apiHost,
+        // The directory where internal functions (i.e. generated programmatically
+        // via plugins or others) live
+        INTERNAL_FUNCTIONS_SRC: `${buildDir}/${INTERNAL_FUNCTIONS_SRC}`,
+        // The directory where internal Edge Functions (i.e. generated programmatically
+        // via plugins or others) live
+        INTERNAL_EDGE_FUNCTIONS_SRC: `${buildDir}/${INTERNAL_EDGE_FUNCTIONS_SRC}`,
+    };
+    const constantsA = await addMutableConstants({ constants, buildDir, netlifyConfig });
+    return constantsA;
+};
+const INTERNAL_EDGE_FUNCTIONS_SRC = '.netlify/edge-functions';
+const INTERNAL_FUNCTIONS_SRC = '.netlify/functions-internal';
+// Retrieve constants which might change during the build if a plugin modifies
+// `netlifyConfig` or creates some default directories.
+// Unlike readonly constants, this is called again before each build step.
+export const addMutableConstants = async function ({ constants, buildDir, netlifyConfig: { build: { publish, edge_functions: edgeFunctions }, functionsDirectory, }, }) {
+    const constantsA = {
+        ...constants,
+        // Directory that contains the deploy-ready HTML files and assets generated by the build
+        PUBLISH_DIR: publish,
+        // The directory where function source code lives
+        FUNCTIONS_SRC: functionsDirectory,
+        // The directory where Edge Functions source code lives
+        EDGE_FUNCTIONS_SRC: edgeFunctions,
+    };
+    const constantsB = await addDefaultConstants(constantsA, buildDir);
+    const constantsC = normalizeConstantsPaths(constantsB, buildDir);
+    return constantsC;
+};
+// Some `constants` have a default value when a specific file exists.
+// Those default values are assigned by `@netlify/config`. However, the build
+// command or plugins might create those specific files, in which case, the
+// related `constant` should be updated, unless the user has explicitly
+// configured it.
+const addDefaultConstants = async function (constants, buildDir) {
+    const newConstants = await Promise.all(DEFAULT_PATHS.map(({ constantName, defaultPath }) => addDefaultConstant({ constants, constantName, defaultPath, buildDir })));
+    return Object.assign({}, constants, ...newConstants);
+};
+// The current directory is the build directory, which is correct, so we don't
+// need to resolve paths
+const DEFAULT_PATHS = [
+    // @todo Remove once we drop support for the legacy default functions directory.
+    { constantName: 'FUNCTIONS_SRC', defaultPath: 'netlify-automatic-functions' },
+    { constantName: 'FUNCTIONS_SRC', defaultPath: 'netlify/functions' },
+    { constantName: 'EDGE_FUNCTIONS_SRC', defaultPath: 'netlify/edge-functions' },
+];
+const addDefaultConstant = async function ({ constants, constantName, defaultPath, buildDir }) {
+    // Configuration paths are relative to the build directory.
+    if (!isEmptyValue(constants[constantName]) || !(await pathExists(`${buildDir}/${defaultPath}`))) {
+        return {};
+    }
+    // However, the plugin child process' current directory is the build directory,
+    // so we can pass the relative path instead of the resolved absolute path.
+    return { [constantName]: defaultPath };
+};
+const normalizeConstantsPaths = function (constants, buildDir) {
+    return mapObj(constants, (key, path) => [key, normalizePath(path, buildDir, key)]);
+};
+// The current directory is `buildDir`. Most constants are inside this `buildDir`.
+// Instead of passing absolute paths, we pass paths relative to `buildDir`, so
+// that logs are less verbose.
+const normalizePath = function (path, buildDir, key) {
+    if (isEmptyValue(path) || !CONSTANT_PATHS.has(key)) {
+        return path;
+    }
+    const pathA = normalize(path);
+    if (pathA === buildDir) {
+        return '.';
+    }
+    if (pathA.startsWith(buildDir)) {
+        return relative(buildDir, pathA);
+    }
+    return pathA;
+};
+const isEmptyValue = function (path) {
+    return path === undefined || path === '';
+};
+const CONSTANT_PATHS = new Set([
+    'CONFIG_PATH',
+    'PUBLISH_DIR',
+    'FUNCTIONS_SRC',
+    'FUNCTIONS_DIST',
+    'INTERNAL_EDGE_FUNCTIONS_SRC',
+    'INTERNAL_FUNCTIONS_SRC',
+    'EDGE_FUNCTIONS_DIST',
+    'EDGE_FUNCTIONS_SRC',
+    'CACHE_DIR',
+]);

package/lib/core/dev.js

@@ -0,0 +1,27 @@
+import { handleBuildError } from '../error/handle.js';
+import { execBuild, startBuild } from './build.js';
+import { getSeverity } from './severity.js';
+export const startDev = async (devCommand, flags = {}) => {
+    const { errorMonitor, mode, logs, debug, testOpts, ...normalizedFlags } = startBuild(flags);
+    const errorParams = { errorMonitor, mode, logs, debug, testOpts };
+    try {
+        const { netlifyConfig: netlifyConfigA, configMutations } = await execBuild({
+            ...normalizedFlags,
+            errorMonitor,
+            errorParams,
+            mode,
+            logs,
+            debug,
+            testOpts,
+            timeline: 'dev',
+            devCommand,
+        });
+        const { success, severityCode } = getSeverity('success');
+        return { success, severityCode, netlifyConfig: netlifyConfigA, logs, configMutations };
+    }
+    catch (error) {
+        const { severity, message, stack } = await handleBuildError(error, errorParams);
+        const { success, severityCode } = getSeverity(severity);
+        return { success, severityCode, logs, error: { message, stack } };
+    }
+};

package/lib/core/dry.js

@@ -0,0 +1,21 @@
+import pFilter from 'p-filter';
+import { logDryRunStart, logDryRunStep, logDryRunEnd } from '../log/messages/dry.js';
+import { runsOnlyOnBuildFailure } from '../plugins/events.js';
+// If the `dry` flag is specified, do a dry run
+export const doDryRun = async function ({ buildDir, steps, netlifyConfig, constants, buildbotServerSocket, logs }) {
+    const successSteps = await pFilter(steps, ({ event, condition }) => shouldIncludeStep({ buildDir, event, condition, netlifyConfig, constants, buildbotServerSocket }));
+    const eventWidth = Math.max(...successSteps.map(getEventLength));
+    const stepsCount = successSteps.length;
+    logDryRunStart({ logs, eventWidth, stepsCount });
+    successSteps.forEach((step, index) => {
+        logDryRunStep({ logs, step, index, netlifyConfig, eventWidth, stepsCount });
+    });
+    logDryRunEnd(logs);
+};
+const shouldIncludeStep = async function ({ buildDir, event, condition, netlifyConfig, constants, buildbotServerSocket, }) {
+    return (!runsOnlyOnBuildFailure(event) &&
+        (condition === undefined || (await condition({ buildDir, constants, netlifyConfig, buildbotServerSocket }))));
+};
+const getEventLength = function ({ event }) {
+    return event.length;
+};

package/lib/core/feature_flags.js

@@ -0,0 +1,17 @@
+// From CLI `--featureFlags=a,b,c` to programmatic `{ a: true, b: true, c: true }`
+export const normalizeCliFeatureFlags = function (cliFeatureFlags) {
+    return Object.assign({}, ...cliFeatureFlags.split(',').filter(isNotEmpty).map(getFeatureFlag));
+};
+const isNotEmpty = function (name) {
+    return name.trim() !== '';
+};
+const getFeatureFlag = function (name) {
+    return { [name]: true };
+};
+// Default values for feature flags
+export const DEFAULT_FEATURE_FLAGS = {
+    buildbot_zisi_trace_nft: false,
+    buildbot_zisi_esbuild_parser: false,
+    edge_functions_cache_cli: false,
+    edge_functions_system_logger: false,
+};

package/lib/core/flags.js

@@ -0,0 +1,206 @@
+const jsonParse = function (value) {
+    return value === undefined ? undefined : JSON.parse(value);
+};
+// All CLI flags
+export const FLAGS = {
+    config: {
+        string: true,
+        describe: `Path to the configuration file.
+Defaults to any netlify.toml in the git repository root directory or the base directory`,
+    },
+    defaultConfig: {
+        string: true,
+        describe: `JSON configuration object containing default values.
+Each configuration default value is used unless overridden through the main configuration file.
+Default: none.`,
+        coerce: jsonParse,
+        hidden: true,
+    },
+    cachedConfig: {
+        string: true,
+        describe: `JSON configuration object returned by @netlify/config when --output=/ is used
+or when using @netlify/config programmatically.
+This is done as a performance optimization to cache the configuration loading logic.
+Default: none.`,
+        coerce: jsonParse,
+        hidden: true,
+    },
+    cachedConfigPath: {
+        string: true,
+        describe: `File path to the JSON configuration object returned by @netlify/config
+when --output=/path is used.
+This is done as a performance optimization to cache the configuration loading logic.
+Default: none.`,
+        hidden: true,
+    },
+    cwd: {
+        string: true,
+        describe: `Current directory. Used to retrieve the configuration file.
+Default: current directory`,
+    },
+    repositoryRoot: {
+        string: true,
+        describe: `Git repository root directory. Used to retrieve the configuration file.
+Default: automatically guessed`,
+    },
+    apiHost: {
+        string: true,
+        describe: `Netlify API endpoint.
+Default: automatically guessed`,
+    },
+    token: {
+        string: true,
+        describe: `Netlify API token for authentication.
+The NETLIFY_AUTH_TOKEN environment variable can be used as well.`,
+    },
+    siteId: {
+        string: true,
+        describe: `Netlify Site ID.`,
+    },
+    deployId: {
+        string: true,
+        describe: `Netlify Deploy ID.
+Default: automatically guessed`,
+    },
+    buildId: {
+        string: true,
+        describe: `Netlify Build ID.
+Default: automatically guessed`,
+    },
+    context: {
+        string: true,
+        describe: `Build context.
+Default: 'production'`,
+    },
+    branch: {
+        string: true,
+        describe: `Repository branch.
+Default: automatically guessed`,
+    },
+    framework: {
+        string: true,
+        describe: 'Front-end framework.',
+        hidden: true,
+    },
+    baseRelDir: {
+        boolean: true,
+        describe: `Feature flag meant for backward compatibility.
+When enabled, if the 'build.base' configuration property is defined, it is used
+to try to retrieve a second configuration file and discard the first one.
+Default: true`,
+        hidden: true,
+    },
+    dry: {
+        alias: 'dry-run',
+        boolean: true,
+        describe: `Run in dry mode, i.e. printing steps without executing them.
+Default: false`,
+    },
+    nodePath: {
+        string: true,
+        describe: `Path to the Node.js binary to use in the build command and plugins.
+Default: Current Node.js binary`,
+    },
+    functionsDistDir: {
+        string: true,
+        describe: `Path to the directory where packaged functions are kept.
+Default: automatically guessed`,
+        hidden: true,
+    },
+    edgeFunctionsDistDir: {
+        string: true,
+        describe: `Path to the directory where packaged Edge Functions are kept.
+Default: automatically guessed`,
+        hidden: true,
+    },
+    cacheDir: {
+        string: true,
+        describe: `Path to the cache directory.
+Default: .netlify/cache/`,
+        hidden: true,
+    },
+    buildbotServerSocket: {
+        string: true,
+        describe: `Path to the buildbot server socket. This is used to connect to the buildbot to trigger deploys.`,
+        hidden: true,
+    },
+    telemetry: {
+        boolean: true,
+        describe: `Enable telemetry.
+Default: false`,
+    },
+    mode: {
+        string: true,
+        describe: `Environment in which this is loaded. Can be:
+  - 'buildbot': within Netlify Buildbot
+  - 'cli': within Netlify CLI
+  - 'require': through import('@netlify/build')`,
+        hidden: true,
+    },
+    debug: {
+        boolean: true,
+        describe: 'Print user-facing debugging information',
+        hidden: true,
+    },
+    systemLogFile: {
+        type: 'number',
+        describe: 'File descriptor to where system logs should be piped',
+        hidden: true,
+    },
+    verbose: {
+        boolean: true,
+        describe: 'Print internal debugging information',
+        hidden: true,
+    },
+    sendStatus: {
+        boolean: true,
+        describe: 'Whether plugin statuses should be sent to the Netlify API',
+        hidden: true,
+    },
+    saveConfig: {
+        boolean: true,
+        describe: 'Whether configuration changes should be saved to netlify.toml',
+        hidden: true,
+    },
+    outputConfigPath: {
+        type: 'string',
+        describe: 'Path where to save the netlify.toml resulting from configuration changes. Only applicable if `saveConfig` is set. Defaults to "netlify.toml" in the root directory.',
+        hidden: true,
+    },
+    testOpts: {
+        describe: 'Options for testing only',
+        hidden: true,
+    },
+    featureFlags: {
+        describe: 'Comma-separated list of feature flags to enable unreleased features',
+        hidden: true,
+    },
+    statsd: {
+        describe: 'Statsd-related options, for performance measuring',
+        hidden: true,
+    },
+    'statsd.host': {
+        type: 'string',
+        describe: 'Statsd host',
+        hidden: true,
+    },
+    'statsd.port': {
+        type: 'number',
+        describe: 'Statsd port',
+        hidden: true,
+    },
+    offline: {
+        boolean: true,
+        describe: `Do not send requests to the Netlify API to retrieve site settings.
+Default: false`,
+    },
+    buffer: {
+        boolean: true,
+        describe: 'Buffer output instead of printing it',
+    },
+    timeline: {
+        string: true,
+        describe: 'The sequence of lifecycle events to run',
+        hidden: true,
+    },
+};

package/lib/core/lingering.js

@@ -0,0 +1,68 @@
+import psList from 'ps-list';
+import { logLingeringProcesses } from '../log/messages/core.js';
+// Print a warning when some build processes are still running.
+// We cannot rely on using the process tree:
+//  - This is because it is impossible to know whether a process was a child of
+//    another once its parent process has exited. When that happens, the s
+//    child becomes inherited by `init`, changing its `ppid`. The information
+//    about the original parent is then lost.
+//  - The only way to implement this would be to repeatedly list processes as
+//    the build command is ongoing. However, this would fail to detect processes
+//    spawned just before the build commands ends.
+// We cannot list processes before and after the build command and use the
+// difference.
+//  - This is because other processes (unrelated to @netlify/build) might be
+//    running at the same time. This includes OS background processes.
+// Therefore, we run this in a controlled environment only (the buildbot) and
+// exclude specific processes manually. This is a lesser evil, although still
+// quite hacky.
+export const warnOnLingeringProcesses = async function ({ mode, logs, testOpts: { silentLingeringProcesses = false }, }) {
+    if (mode !== 'buildbot' || silentLingeringProcesses) {
+        return;
+    }
+    const processes = await psList();
+    const commands = processes.map(getCommand).filter(isNotIgnoredCommand);
+    if (commands.length === 0) {
+        return;
+    }
+    logLingeringProcesses(logs, commands);
+};
+// `cmd` is only available on Unix. Unlike `name`, it includes the arguments.
+const getCommand = function ({ name, cmd = name }) {
+    return cmd;
+};
+// We ignore any command known to be internal to the buildbot.
+// We also ignore commands known not to complete properly in builds if they are
+// widely used.
+const isNotIgnoredCommand = function (command) {
+    return !IGNORED_COMMANDS.some((ignoredCommand) => matchesIgnoredCommand(command, ignoredCommand));
+};
+const matchesIgnoredCommand = function (command, ignoredCommand) {
+    if (typeof ignoredCommand === 'string') {
+        return command.includes(ignoredCommand);
+    }
+    return ignoredCommand.test(command);
+};
+const IGNORED_COMMANDS = [
+    // TODO: Those can most likely be removed
+    'ps',
+    'grep',
+    'bash',
+    // Internal buildbot commands
+    '[build]',
+    /buildbot.*\[node]/,
+    // buildbot's main Bash script
+    '/opt/build-bin/build',
+    // `@netlify/build` binary itself
+    'netlify-build',
+    // Plugin child processes spawned by @netlify/build
+    '@netlify/build',
+    // Shown for parent processes with currently running child processes.
+    // Happens on `ps` itself.
+    'defunct',
+    // Processes often left running. We should report those but don't because of
+    // how common those are in production builds
+    'gatsby-telemetry',
+    'jest-worker',
+    'broccoli-babel-transpiler',
+];

package/lib/core/main.js

@@ -0,0 +1,114 @@
+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 { 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';
+/**
+ * Main entry point of Netlify Build.
+ * Runs a builds and returns whether it succeeded or not.
+ *
+ * @param flags - build configuration CLI flags
+ */
+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 };
+    }
+}
+// Logs and reports that a build successfully ended
+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, }) {
+    try {
+        await trackBuildComplete({
+            deployId,
+            buildId,
+            status,
+            stepsCount,
+            pluginsOptions,
+            durationNs,
+            siteInfo,
+            telemetry,
+            userNodeVersion,
+            framework,
+            testOpts,
+        });
+    }
+    catch (error) {
+        await handleBuildError(error, errorParams);
+    }
+};

package/lib/core/missing_side_file.js

@@ -0,0 +1,17 @@
+import { relative } from 'path';
+import { pathExists } from 'path-exists';
+import { logMissingSideFile } from '../log/messages/core.js';
+// Some files like `_headers` and `_redirects` must be copied to the publishing
+// directory to be used in production. When those are present in the repository
+// but not in the publish directory, this most likely indicates that the build
+// command accidentally forgot to copy those. We then print a warning message.
+export const warnOnMissingSideFiles = async function ({ buildDir, netlifyConfig: { build: { publish }, }, logs, }) {
+    await Promise.all(SIDE_FILES.map((sideFile) => warnOnMissingSideFile({ logs, sideFile, buildDir, publish })));
+};
+const SIDE_FILES = ['_headers', '_redirects'];
+const warnOnMissingSideFile = async function ({ logs, sideFile, buildDir, publish }) {
+    if (!(await pathExists(`${buildDir}/${sideFile}`)) || (await pathExists(`${publish}/${sideFile}`))) {
+        return;
+    }
+    logMissingSideFile(logs, sideFile, relative(buildDir, publish));
+};

package/lib/core/normalize_flags.js

@@ -0,0 +1,62 @@
+import { env, execPath } from 'process';
+import { logFlags } from '../log/messages/config.js';
+import { removeFalsy } from '../utils/remove_falsy.js';
+import { DEFAULT_FEATURE_FLAGS } from './feature_flags.js';
+const REQUIRE_MODE = 'require';
+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;
+/** Normalize CLI flags  */
+export const normalizeFlags = function (flags, logs) {
+    const rawFlags = removeFalsy(flags);
+    // Combine the flags object env with the process.env
+    const combinedEnv = { ...env, ...rawFlags.env };
+    const defaultFlags = getDefaultFlags(rawFlags, combinedEnv);
+    // The telemetry flag requires specific logic to compute
+    const telemetryFlag = computeTelemetry(rawFlags, combinedEnv);
+    const mergedFlags = {
+        ...defaultFlags,
+        ...rawFlags,
+        ...telemetryFlag,
+        statsdOpts: { ...defaultFlags.statsd, ...rawFlags.statsd },
+        featureFlags: { ...defaultFlags.featureFlags, ...rawFlags.featureFlags },
+    };
+    const normalizedFlags = removeFalsy(mergedFlags);
+    if (!flags.quiet) {
+        logFlags(logs, rawFlags, normalizedFlags);
+    }
+    return normalizedFlags;
+};
+// Default values of CLI flags
+const getDefaultFlags = function ({ env: envOpt = {} }, combinedEnv) {
+    return {
+        env: envOpt,
+        nodePath: execPath,
+        token: combinedEnv.NETLIFY_AUTH_TOKEN,
+        mode: REQUIRE_MODE,
+        offline: false,
+        telemetry: false,
+        verbose: Boolean(combinedEnv.NETLIFY_BUILD_DEBUG),
+        functionsDistDir: DEFAULT_FUNCTIONS_DIST,
+        edgeFunctionsDistDir: DEFAULT_EDGE_FUNCTIONS_DIST,
+        cacheDir: DEFAULT_CACHE_DIR,
+        deployId: combinedEnv.DEPLOY_ID,
+        buildId: combinedEnv.BUILD_ID,
+        debug: Boolean(combinedEnv.NETLIFY_BUILD_DEBUG),
+        bugsnagKey: combinedEnv.BUGSNAG_KEY,
+        sendStatus: false,
+        saveConfig: false,
+        apiHost: 'api.netlify.com',
+        testOpts: {},
+        featureFlags: DEFAULT_FEATURE_FLAGS,
+        statsd: { port: DEFAULT_STATSD_PORT },
+        timeline: 'build',
+        quiet: false,
+    };
+};
+// Compute the telemetry flag, it's disabled by default, and we want to always disable it
+// if BUILD_TELEMETRY_DISABLED is passed.
+const computeTelemetry = function (flags, envOpts) {
+    return envOpts.BUILD_TELEMETRY_DISABLED ? { telemetry: false } : { telemetry: flags.telemetry };
+};

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);
+};