@netlify/zip-it-and-ship-it 15.0.1 → 15.1.0

package/dist/runtimes/node/bundlers/esbuild/plugin_native_modules.js

@@ -7,7 +7,7 @@ const packageFilter = /^([^./]*)$/;
 const packageName = /^([^@][^/]*|@[^/]*\/[^/]+)(?:\/|$)/;
 const findNativeModule = (packageJsonPath, cache) => {
     if (cache[packageJsonPath] === undefined) {
-        cache[packageJsonPath] = readPackageJson(packageJsonPath).then((data) => [Boolean(isNativeModule(data)), data], () => [undefined, {}]);
+        cache[packageJsonPath] = readPackageJson(packageJsonPath).then((data) => [isNativeModule(data), data], () => [undefined, {}]);
     }
     return cache[packageJsonPath];
 };

package/dist/runtimes/node/bundlers/index.d.ts

@@ -1,6 +1,6 @@
 import { FunctionConfig } from '../../../config.js';
 import { FeatureFlags } from '../../../feature_flags.js';
-import { NodeBundler, NodeBundlerName } from './types.js';
+import type { BundlerReason, NodeBundler, NodeBundlerName } from './types.js';
 export declare const getBundler: (name: NodeBundlerName) => NodeBundler;
 export declare const getBundlerName: ({ config: { nodeBundler }, extension, featureFlags, mainFile, runtimeAPIVersion, }: {
     config: FunctionConfig;
@@ -8,4 +8,7 @@ export declare const getBundlerName: ({ config: { nodeBundler }, extension, feat
     featureFlags: FeatureFlags;
     mainFile: string;
     runtimeAPIVersion: number;
-}) => Promise<NodeBundlerName>;
+}) => Promise<{
+    name: NodeBundlerName;
+    reason: BundlerReason;
+}>;

package/dist/runtimes/node/bundlers/index.js

@@ -4,7 +4,7 @@ import { MODULE_FILE_EXTENSION } from '../utils/module_format.js';
 import esbuildBundler from './esbuild/index.js';
 import nftBundler from './nft/index.js';
 import noBundler from './none/index.js';
-import { NODE_BUNDLER } from './types.js';
+import { BUNDLER_REASON, NODE_BUNDLER } from './types.js';
 import zisiBundler from './zisi/index.js';
 export const getBundler = (name) => {
     switch (name) {
@@ -25,10 +25,12 @@ export const getBundlerName = async ({ config: { nodeBundler }, extension, featu
     // For V2 functions, we force the bundler to NFT. The only exception is when
     // a `none` override was provided.
     if (runtimeAPIVersion === 2) {
-        return nodeBundler === NODE_BUNDLER.NONE ? NODE_BUNDLER.NONE : NODE_BUNDLER.NFT;
+        return nodeBundler === NODE_BUNDLER.NONE
+            ? { name: NODE_BUNDLER.NONE, reason: BUNDLER_REASON.NoneOverride }
+            : { name: NODE_BUNDLER.NFT, reason: BUNDLER_REASON.V2Default };
     }
     if (nodeBundler) {
-        return nodeBundler;
+        return { name: nodeBundler, reason: BUNDLER_REASON.ConfigOverride };
     }
     return await getDefaultBundler({ extension, featureFlags, mainFile });
 };
@@ -37,14 +39,16 @@ const ESBUILD_EXTENSIONS = new Set(['.mjs', '.ts', '.tsx', '.cts', '.mts']);
 // esbuild is the only option.
 const getDefaultBundler = async ({ extension, featureFlags, mainFile, }) => {
     if (extension === MODULE_FILE_EXTENSION.MJS && featureFlags.zisi_pure_esm_mjs) {
-        return NODE_BUNDLER.NFT;
+        return { name: NODE_BUNDLER.NFT, reason: BUNDLER_REASON.MjsPureEsm };
     }
     if (ESBUILD_EXTENSIONS.has(extension)) {
-        return NODE_BUNDLER.ESBUILD;
+        return { name: NODE_BUNDLER.ESBUILD, reason: BUNDLER_REASON.EsbuildExtension };
     }
     if (featureFlags.traceWithNft) {
-        return NODE_BUNDLER.NFT;
+        return { name: NODE_BUNDLER.NFT, reason: BUNDLER_REASON.FlagForcedNft };
     }
     const functionIsESM = extname(mainFile) !== MODULE_FILE_EXTENSION.CJS && (await detectEsModule({ mainFile }));
-    return functionIsESM ? NODE_BUNDLER.NFT : NODE_BUNDLER.ZISI;
+    return functionIsESM
+        ? { name: NODE_BUNDLER.NFT, reason: BUNDLER_REASON.EsmDefault }
+        : { name: NODE_BUNDLER.ZISI, reason: BUNDLER_REASON.ZisiDefault };
 };

package/dist/runtimes/node/bundlers/types.d.ts

@@ -4,6 +4,7 @@ import type { FunctionConfig } from '../../../config.js';
 import type { FeatureFlags } from '../../../feature_flags.js';
 import type { FunctionSource } from '../../../function.js';
 import type { RuntimeCache } from '../../../utils/cache.js';
+import type { ObjectValues } from '../../../types/utils.js';
 import { Logger } from '../../../utils/logger.js';
 import type { ModuleFormat } from '../utils/module_format.js';
 export declare const NODE_BUNDLER: {
@@ -21,6 +22,17 @@ export declare const nodeBundler: z.ZodNativeEnum<{
     readonly NONE: "none";
 }>;
 export type NodeBundlerName = z.infer<typeof nodeBundler>;
+export declare const BUNDLER_REASON: {
+    readonly ConfigOverride: "config-override";
+    readonly NoneOverride: "none-override";
+    readonly V2Default: "v2-nft";
+    readonly MjsPureEsm: "mjs-pure-esm";
+    readonly EsbuildExtension: "esbuild-ext";
+    readonly EsmDefault: "esm-default";
+    readonly FlagForcedNft: "flag-forced-nft";
+    readonly ZisiDefault: "zisi-default";
+};
+export type BundlerReason = ObjectValues<typeof BUNDLER_REASON>;
 type BundlerWarning = Message;
 type CleanupFunction = () => Promise<void>;
 export type NativeNodeModules = Record<string, Record<string, string | undefined>>;

package/dist/runtimes/node/bundlers/types.js

@@ -7,3 +7,14 @@ export const NODE_BUNDLER = {
     NONE: 'none',
 };
 export const nodeBundler = z.nativeEnum(NODE_BUNDLER);
+/* Why a bundler was used to bundle a given function */
+export const BUNDLER_REASON = {
+    ConfigOverride: 'config-override', // explicit `config.nodeBundler`
+    NoneOverride: 'none-override', // explicit `config.nodeBundler === 'none'`
+    V2Default: 'v2-nft', // runtimeAPIVersion === 2 forces nft
+    MjsPureEsm: 'mjs-pure-esm', // `.mjs` + `zisi_pure_esm_mjs`
+    EsbuildExtension: 'esbuild-ext', // `.ts`/`.tsx`/`.cts`/`.mts`/`.mjs`
+    EsmDefault: 'esm-default', // detected ESM `.js` → nft
+    FlagForcedNft: 'flag-forced-nft', // `traceWithNft` flipped a CJS function to nft
+    ZisiDefault: 'zisi-default', // CJS `.js`, `traceWithNft` flag off
+};

package/dist/runtimes/node/bundlers/zisi/resolve.js

@@ -1,10 +1,7 @@
 import { createRequire } from 'module';
 import { findUp } from 'find-up';
 import { pathExists } from 'path-exists';
-// @ts-expect-error doesnt export async
 import { async as asyncResolve } from 'resolve';
-// The types do not include the mjs api of resolve
-const resolveLib = asyncResolve;
 const require = createRequire(import.meta.url);
 const BACKSLASH_REGEXP = /\\/g;
 // Find the path to a module's `package.json`
@@ -39,7 +36,7 @@ export const resolvePackage = async function (moduleName, baseDirs) {
 //   https://github.com/browserify/resolve/issues/151#issuecomment-368210310
 const resolvePathPreserveSymlinksForDir = function (path, basedir) {
     return new Promise((resolve, reject) => {
-        resolveLib(path, { basedir, preserveSymlinks: true }, (error, resolvedLocation) => {
+        asyncResolve(path, { basedir, preserveSymlinks: true }, (error, resolvedLocation) => {
             if (error || resolvedLocation === undefined) {
                 return reject(error);
             }

package/dist/runtimes/node/index.js

@@ -1,5 +1,7 @@
 import { dirname, extname, join } from 'path';
 import { copyFile } from 'copy-file';
+import { trace } from '@opentelemetry/api';
+import { wrapTracer } from '@opentelemetry/api/experimental';
 import { INVOCATION_MODE } from '../../function.js';
 import { Priority } from '../../priority.js';
 import { getTrafficRulesConfig } from '../../rate_limit.js';
@@ -12,12 +14,14 @@ import { augmentFunctionConfig, parseFile } from './in_source_config/index.js';
 import { MODULE_FORMAT, MODULE_FILE_EXTENSION } from './utils/module_format.js';
 import { getNodeRuntime, getNodeRuntimeForV2 } from './utils/node_runtime.js';
 import { createAliases as createPluginsModulesPathAliases, getPluginsModulesPath } from './utils/plugin_modules_path.js';
+import { getBundleResultSpanAttributes, getFunctionBundleSpanAttributes } from './utils/span_attributes.js';
 import { zipNodeJs } from './utils/zip.js';
+import { getArchiveSize } from '../../utils/archive_size.js';
 // A proxy for the `getSrcFiles` that calls `getSrcFiles` on the bundler
 const getSrcFilesWithBundler = async (parameters) => {
     const { config, extension, featureFlags, mainFile, runtimeAPIVersion, srcDir } = parameters;
     const pluginsModulesPath = await getPluginsModulesPath(srcDir);
-    const bundlerName = await getBundlerName({
+    const { name: bundlerName } = await getBundlerName({
         config,
         extension,
         featureFlags,
@@ -28,7 +32,7 @@ const getSrcFilesWithBundler = async (parameters) => {
     const result = await bundler.getSrcFiles({ ...parameters, pluginsModulesPath });
     return result.srcFiles;
 };
-const zipFunction = async function ({ archiveFormat, basePath, branch, cache, config = {}, destFolder, extension, featureFlags, filename, isInternal, logger, mainFile, name, repositoryRoot, runtime, srcDir, srcPath, stat, }) {
+const zipFunction = async function ({ archiveFormat, basePath, branch, cache, config = {}, destFolder, extension, featureFlags, filename, isInternal, logger, mainFile, name, repositoryRoot, runtime, span, srcDir, srcPath, stat, }) {
     // If the file is a zip, we assume the function is bundled and ready to go.
     // We simply copy it to the destination path with no further processing.
     if (extension === '.zip') {
@@ -50,13 +54,23 @@ const zipFunction = async function ({ archiveFormat, basePath, branch, cache, co
     const staticAnalysisResult = await parseFile(mainFile, { functionName: name });
     const runtimeAPIVersion = staticAnalysisResult.runtimeAPIVersion === 2 ? 2 : 1;
     const mergedConfig = augmentFunctionConfig(mainFile, config, staticAnalysisResult.config);
-    const bundlerName = await getBundlerName({
+    const { name: bundlerName, reason: bundlerReason } = await getBundlerName({
         config: mergedConfig,
         extension,
         featureFlags,
         mainFile,
         runtimeAPIVersion,
     });
+    const generator = mergedConfig?.generator || getInternalValue(isInternal);
+    span?.setAttributes(getFunctionBundleSpanAttributes({
+        featureFlags,
+        name,
+        generator,
+        runtimeName: runtime.name,
+        runtimeAPIVersion,
+        bundlerName,
+        bundlerReason,
+    }));
     const bundler = getBundler(bundlerName);
     const { aliases = new Map(), cleanupFunction, basePath: basePathFromBundler, bundlerWarnings, includedFiles, inputs, mainFile: finalMainFile = mainFile, moduleFormat, nativeNodeModules, rewrites = new Map(), srcFiles, } = await bundler.bundle({
         basePath,
@@ -82,7 +96,6 @@ const zipFunction = async function ({ archiveFormat, basePath, branch, cache, co
     // common path prefix and that will break module resolution, as the modules
     // will no longer be inside a `node_modules` directory.
     const finalBasePath = isInPluginsModulesPath ? basePath : basePathFromBundler;
-    const generator = mergedConfig?.generator || getInternalValue(isInternal);
     const zipResult = await zipNodeJs({
         aliases,
         archiveFormat,
@@ -129,6 +142,7 @@ const zipFunction = async function ({ archiveFormat, basePath, branch, cache, co
     return {
         bootstrapVersion: zipResult.bootstrapVersion,
         bundler: bundlerName,
+        bundlerReason,
         bundlerWarnings,
         config: mergedConfig,
         displayName: mergedConfig?.name,
@@ -150,24 +164,42 @@ const zipFunction = async function ({ archiveFormat, basePath, branch, cache, co
     };
 };
 const zipWithFunctionWithFallback = async ({ config = {}, ...parameters }) => {
-    // If a specific JS bundler version is specified, we'll use it.
-    if (config.nodeBundler !== NODE_BUNDLER.ESBUILD_ZISI) {
-        return zipFunction({ ...parameters, config });
-    }
-    // Otherwise, we'll try to bundle with esbuild and, if that fails, fallback
-    // to zisi.
-    try {
-        return await zipFunction({ ...parameters, config: { ...config, nodeBundler: NODE_BUNDLER.ESBUILD } });
-    }
-    catch (esbuildError) {
+    const tracer = wrapTracer(trace.getTracer('zip-it-and-ship-it'));
+    return tracer.withActiveSpan('function.bundle', async (span) => {
+        // If a specific JS bundler version is specified, we'll use it.
+        if (config.nodeBundler !== NODE_BUNDLER.ESBUILD_ZISI) {
+            const result = await zipFunction({ ...parameters, config, span });
+            await trackBundlerResult(span, result);
+            return result;
+        }
+        // Otherwise, we'll try to bundle with esbuild and, if that fails, fallback
+        // to zisi.
         try {
-            const data = await zipFunction({ ...parameters, config: { ...config, nodeBundler: NODE_BUNDLER.ZISI } });
-            return { ...data, bundlerErrors: esbuildError.errors };
+            const result = await zipFunction({
+                ...parameters,
+                config: { ...config, nodeBundler: NODE_BUNDLER.ESBUILD },
+                span,
+            });
+            await trackBundlerResult(span, result);
+            return result;
         }
-        catch {
-            throw esbuildError;
+        catch (esbuildError) {
+            try {
+                const data = await zipFunction({ ...parameters, config: { ...config, nodeBundler: NODE_BUNDLER.ZISI }, span });
+                const result = { ...data, bundlerErrors: esbuildError.errors };
+                await trackBundlerResult(span, result);
+                span.recordException(esbuildError);
+                return result;
+            }
+            catch (zisiError) {
+                span.recordException(zisiError);
+                throw esbuildError;
+            }
         }
-    }
+    });
+};
+const trackBundlerResult = async (span, result) => {
+    span.setAttributes(getBundleResultSpanAttributes(result, await getArchiveSize(result.path)));
 };
 const runtime = {
     findFunctionsInPaths,

package/dist/runtimes/node/parser/exports.js

@@ -202,9 +202,9 @@ const parsePrimitive = (exp) => {
 const getExportsFromBindings = (specifiers, name, getAllBindings) => {
     const specifier = specifiers.find((node) => isNamedExport(node, name));
     // If there's no named export with the given name, check if there's a default
-    if (!specifier || specifier.type !== 'ExportSpecifier') {
+    if (specifier?.type !== 'ExportSpecifier') {
         const defaultExport = specifiers.find((node) => isDefaultExport(node));
-        if (defaultExport && defaultExport.type === 'ExportSpecifier') {
+        if (defaultExport?.type === 'ExportSpecifier') {
             const binding = getAllBindings().get(defaultExport.local.name);
             if (binding?.type === 'ArrowFunctionExpression' ||
                 binding?.type === 'FunctionDeclaration' ||
@@ -229,7 +229,7 @@ const getCJSDefaultExpression = (node) => {
 // Resolves the expression for `export { x as default }` by looking up `x` in bindings.
 const getESMReexportedDefaultExpression = (node, getAllBindings) => {
     const defaultSpecifier = node.specifiers.find((spec) => spec.type === 'ExportSpecifier' && spec.exported.type === 'Identifier' && spec.exported.name === 'default');
-    if (defaultSpecifier && defaultSpecifier.type === 'ExportSpecifier') {
+    if (defaultSpecifier?.type === 'ExportSpecifier') {
         return getAllBindings().get(defaultSpecifier.local.name);
     }
     return undefined;

package/dist/runtimes/node/parser/helpers.js

@@ -22,7 +22,7 @@ export const isModuleExports = (node, dotExpression = ['module', 'exports']) =>
     node.expression.left.type === 'MemberExpression' &&
     isDotExpression(node.expression.left, dotExpression);
 export const isRequire = (node, requirePath) => {
-    if (!node || node.type !== 'CallExpression') {
+    if (node?.type !== 'CallExpression') {
         return false;
     }
     const { arguments: args, callee } = node;

package/dist/runtimes/node/parser/imports.js

@@ -16,7 +16,7 @@ const getImportsFromCJS = (node, importPath) => {
     }
     const { declarations } = node;
     const requireDeclaration = declarations.find((declaration) => declaration.type === 'VariableDeclarator' && isRequire(declaration.init, importPath));
-    if (requireDeclaration === undefined || requireDeclaration.id.type !== 'ObjectPattern') {
+    if (requireDeclaration?.id.type !== 'ObjectPattern') {
         return [];
     }
     const imports = requireDeclaration.id.properties

package/dist/runtimes/node/utils/span_attributes.d.ts

@@ -0,0 +1,14 @@
+import type { Attributes } from '@opentelemetry/api';
+import type { FeatureFlags } from '../../../feature_flags.js';
+import type { ZipFunctionResult } from '../../runtime.js';
+import type { BundlerReason, NodeBundlerName } from '../bundlers/types.js';
+export declare const getFunctionBundleSpanAttributes: ({ featureFlags, name, generator, runtimeName, runtimeAPIVersion, bundlerName, bundlerReason, }: {
+    featureFlags: FeatureFlags;
+    name: string;
+    generator: string | undefined;
+    runtimeName: string;
+    runtimeAPIVersion: number;
+    bundlerName: NodeBundlerName;
+    bundlerReason: BundlerReason;
+}) => Attributes;
+export declare const getBundleResultSpanAttributes: (result: ZipFunctionResult, sizeBytes: number | undefined) => Attributes;

package/dist/runtimes/node/utils/span_attributes.js

@@ -0,0 +1,16 @@
+/* Span attributes describing a function and how it is bundled */
+export const getFunctionBundleSpanAttributes = ({ featureFlags, name, generator, runtimeName, runtimeAPIVersion, bundlerName, bundlerReason, }) => ({
+    feature_flags: JSON.stringify(featureFlags),
+    'function.name': name,
+    'function.generator': generator,
+    'function.runtime': runtimeName,
+    'function.runtime_api_version': runtimeAPIVersion,
+    'bundler.name': bundlerName,
+    'bundler.reason': bundlerReason,
+});
+/* Span attributes known only once bundling has finished */
+export const getBundleResultSpanAttributes = (result, sizeBytes) => ({
+    'bundler.warnings_count': result.bundlerWarnings?.length ?? 0,
+    'bundler.errors_count': result.bundlerErrors?.length ?? 0,
+    'bundle.size_bytes': sizeBytes,
+});

package/dist/runtimes/runtime.d.ts

@@ -1,3 +1,4 @@
+import type { Span } from '@opentelemetry/api';
 import type { ArchiveFormat } from '../archive.js';
 import type { FunctionConfig } from '../config.js';
 import type { FeatureFlags } from '../feature_flags.js';
@@ -7,7 +8,7 @@ import type { TrafficRules } from '../rate_limit.js';
 import { ObjectValues } from '../types/utils.js';
 import type { RuntimeCache } from '../utils/cache.js';
 import { Logger } from '../utils/logger.js';
-import type { NodeBundlerName } from './node/bundlers/types.js';
+import type { BundlerReason, NodeBundlerName } from './node/bundlers/types.js';
 import type { StaticAnalysisResult } from './node/in_source_config/index.js';
 export declare const RUNTIME: {
     readonly GO: "go";
@@ -34,6 +35,7 @@ export type GetSrcFilesFunction = (args: {
 } & FunctionSource) => Promise<string[]>;
 export interface ZipFunctionResult {
     bundler?: NodeBundlerName;
+    bundlerReason?: BundlerReason;
     bundlerErrors?: object[];
     bundlerWarnings?: object[];
     config: FunctionConfig;
@@ -64,6 +66,7 @@ export type ZipFunction = (args: {
     isInternal: boolean;
     logger: Logger;
     repositoryRoot?: string;
+    span?: Span;
 } & FunctionSource) => Promise<ZipFunctionResult>;
 export interface Runtime {
     findFunctionsInPaths: FindFunctionsInPathsFunction;

package/dist/utils/archive_size.d.ts

@@ -1,2 +1,27 @@
 import type { FunctionArchive } from '../function.js';
-export declare const addArchiveSize: (result: FunctionArchive) => Promise<FunctionArchive>;
+export declare const getArchiveSize: (path: string) => Promise<number | undefined>;
+export declare const addArchiveSize: (result: FunctionArchive) => Promise<{
+    size: number | undefined;
+    bundler?: import("../main.js").NodeBundlerName;
+    bundlerReason?: import("../runtimes/node/bundlers/types.js").BundlerReason;
+    bundlerErrors?: object[];
+    bundlerWarnings?: object[];
+    config: import("../config.js").FunctionConfig;
+    displayName?: string;
+    generator?: string;
+    timeout?: number;
+    inputs?: string[];
+    includedFiles?: string[];
+    invocationMode?: import("../function.js").InvocationMode;
+    outputModuleFormat?: import("../main.js").ModuleFormat;
+    nativeNodeModules?: object;
+    path: string;
+    priority?: number;
+    trafficRules?: import("../rate_limit.js").TrafficRules;
+    runtimeVersion?: string;
+    staticAnalysisResult?: import("../runtimes/node/in_source_config/index.js").StaticAnalysisResult;
+    entryFilename: string;
+    mainFile: string;
+    name: string;
+    runtime: import("../runtimes/runtime.js").Runtime;
+}>;

package/dist/utils/archive_size.js

@@ -2,11 +2,14 @@ import { promises as fs } from 'fs';
 import { extname } from 'path';
 // Returns the input object with an additional `size` property containing the
 // size of the file at `path` when it is a ZIP archive.
-export const addArchiveSize = async (result) => {
-    const { path } = result;
+export const getArchiveSize = async (path) => {
     if (extname(path) !== '.zip') {
-        return result;
+        return;
     }
     const { size } = await fs.stat(path);
+    return size;
+};
+export const addArchiveSize = async (result) => {
+    const size = await getArchiveSize(result.path);
     return { ...result, size };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/zip-it-and-ship-it",
-  "version": "15.0.1",
+  "version": "15.1.0",
   "description": "Zip it and ship it",
   "main": "./dist/main.js",
   "type": "module",
@@ -45,6 +45,7 @@
     "@babel/types": "^7.28.5",
     "@netlify/binary-info": "^1.0.0",
     "@netlify/serverless-functions-api": "2.16.0",
+    "@opentelemetry/api": "~1.8.0",
     "@vercel/nft": "0.29.4",
     "archiver": "^7.0.0",
     "common-path-prefix": "^3.0.0",
@@ -76,9 +77,10 @@
   },
   "devDependencies": {
     "@netlify/types": "2.7.0",
+    "@opentelemetry/sdk-trace-base": "~1.24.0",
     "@types/archiver": "6.0.4",
     "@types/is-ci": "3.0.4",
-    "@types/node": "20.19.33",
+    "@types/node": "^22.12.0",
     "@types/normalize-path": "3.0.2",
     "@types/resolve": "1.20.6",
     "@types/semver": "7.7.1",
@@ -100,5 +102,5 @@
   "engines": {
     "node": ">=22.12.0"
   },
-  "gitHead": "fea99309ebbb7fb595311ccbab6c6a91c4a9eb87"
+  "gitHead": "677f1bd6db4429d70ce3d207f00c7d603ae2d1bf"
 }