@netlify/plugin-nextjs 5.4.0-canary-perf-debug.0 → 5.5.0

package/dist/run/handlers/cache.cjs

@@ -35,6 +35,8 @@ __export(cache_exports, {
 });
 module.exports = __toCommonJS(cache_exports);
 var import_node_buffer = require("node:buffer");
+var import_node_path = require("node:path");
+var import_posix = require("node:path/posix");
 
 // node_modules/@netlify/functions/dist/chunk-COIAWFHF.mjs
 var import_process = require("process");
@@ -94,7 +96,6 @@ var pipeline = (0, import_util.promisify)(import_stream.pipeline);
 // src/run/handlers/cache.cts
 var import_constants = require("next/dist/lib/constants.js");
 var import_regional_blob_store = require("../regional-blob-store.cjs");
-var import_systemlog = require("../systemlog.cjs");
 var import_request_context = require("./request-context.cjs");
 var import_tracer = require("./tracer.cjs");
 var NetlifyCacheHandler = class {
@@ -154,10 +155,58 @@ var NetlifyCacheHandler = class {
     }
     return restOfRouteValue;
   }
+  captureCacheTags(cacheValue, key) {
+    if (!cacheValue) {
+      return;
+    }
+    const requestContext = (0, import_request_context.getRequestContext)();
+    if (!requestContext) {
+      return;
+    }
+    if (requestContext.responseCacheTags) {
+      return;
+    }
+    if (cacheValue.kind === "PAGE" || cacheValue.kind === "APP_PAGE" || cacheValue.kind === "ROUTE") {
+      if (cacheValue.headers?.[import_constants.NEXT_CACHE_TAGS_HEADER]) {
+        const cacheTags = cacheValue.headers[import_constants.NEXT_CACHE_TAGS_HEADER].split(",");
+        requestContext.responseCacheTags = cacheTags;
+      } else if (cacheValue.kind === "PAGE" && typeof cacheValue.pageData === "object") {
+        const cacheTags = [`_N_T_${key === "/index" ? "/" : key}`];
+        requestContext.responseCacheTags = cacheTags;
+      }
+    }
+  }
+  async injectEntryToPrerenderManifest(key, revalidate) {
+    if (this.options.serverDistDir && (typeof revalidate === "number" || revalidate === false)) {
+      try {
+        const { loadManifest } = await import("next/dist/server/load-manifest.js");
+        const prerenderManifest = loadManifest(
+          (0, import_node_path.join)(this.options.serverDistDir, "..", "prerender-manifest.json")
+        );
+        try {
+          const { normalizePagePath } = await import("next/dist/shared/lib/page-path/normalize-page-path.js");
+          prerenderManifest.routes[key] = {
+            experimentalPPR: void 0,
+            dataRoute: (0, import_posix.join)("/_next/data", `${normalizePagePath(key)}.json`),
+            srcRoute: null,
+            // FIXME: provide actual source route, however, when dynamically appending it doesn't really matter
+            initialRevalidateSeconds: revalidate,
+            // Pages routes do not have a prefetch data route.
+            prefetchDataRoute: void 0
+          };
+        } catch {
+          const { SharedRevalidateTimings } = await import("next/dist/server/lib/incremental-cache/shared-revalidate-timings.js");
+          const sharedRevalidateTimings = new SharedRevalidateTimings(prerenderManifest);
+          sharedRevalidateTimings.set(key, revalidate);
+        }
+      } catch {
+      }
+    }
+  }
   async get(...args) {
     return this.tracer.withActiveSpan("get cache key", async (span) => {
       const [key, ctx = {}] = args;
-      import_systemlog.logger.debug(`[NetlifyCacheHandler.get]: ${key}`);
+      (0, import_request_context.getLogger)().debug(`[NetlifyCacheHandler.get]: ${key}`);
       const blobKey = await this.encodeBlobKey(key);
       span.setAttributes({ key, blobKey });
       const blob = await this.tracer.withActiveSpan("blobStore.get", async (blobGetSpan) => {
@@ -170,16 +219,13 @@ var NetlifyCacheHandler = class {
         span.addEvent("Cache miss", { key, blobKey });
         return null;
       }
-      if (process.env.NETLIFY_NEXT_PERF_DEBUG) {
-        const blobSize = JSON.stringify(blob).length;
-        span.addEvent(`Blob size ${blobSize}`);
-      }
       const staleByTags = await this.checkCacheEntryStaleByTags(blob, ctx.tags, ctx.softTags);
       if (staleByTags) {
         span.addEvent("Stale", { staleByTags });
         return null;
       }
       this.captureResponseCacheLastModified(blob, key, span);
+      this.captureCacheTags(blob.value, key);
       switch (blob.value?.kind) {
         case "FETCH":
           span.addEvent("FETCH", { lastModified: blob.lastModified, revalidate: ctx.revalidate });
@@ -198,33 +244,65 @@ var NetlifyCacheHandler = class {
             }
           };
         }
-        case "PAGE":
+        case "PAGE": {
           span.addEvent("PAGE", { lastModified: blob.lastModified });
+          const { revalidate, ...restOfPageValue } = blob.value;
+          await this.injectEntryToPrerenderManifest(key, revalidate);
           return {
             lastModified: blob.lastModified,
-            value: blob.value
+            value: restOfPageValue
+          };
+        }
+        case "APP_PAGE": {
+          span.addEvent("APP_PAGE", { lastModified: blob.lastModified });
+          const { revalidate, rscData, ...restOfPageValue } = blob.value;
+          await this.injectEntryToPrerenderManifest(key, revalidate);
+          return {
+            lastModified: blob.lastModified,
+            value: {
+              ...restOfPageValue,
+              rscData: rscData ? import_node_buffer.Buffer.from(rscData, "base64") : void 0
+            }
           };
+        }
         default:
           span.recordException(new Error(`Unknown cache entry kind: ${blob.value?.kind}`));
       }
       return null;
     });
   }
+  transformToStorableObject(data, context) {
+    if (data?.kind === "ROUTE") {
+      return {
+        ...data,
+        revalidate: context.revalidate,
+        body: data.body.toString("base64")
+      };
+    }
+    if (data?.kind === "PAGE") {
+      return {
+        ...data,
+        revalidate: context.revalidate
+      };
+    }
+    if (data?.kind === "APP_PAGE") {
+      return {
+        ...data,
+        revalidate: context.revalidate,
+        rscData: data.rscData?.toString("base64")
+      };
+    }
+    return data;
+  }
   async set(...args) {
     return this.tracer.withActiveSpan("set cache key", async (span) => {
       const [key, data, context] = args;
       const blobKey = await this.encodeBlobKey(key);
       const lastModified = Date.now();
       span.setAttributes({ key, lastModified, blobKey });
-      import_systemlog.logger.debug(`[NetlifyCacheHandler.set]: ${key}`);
-      const value = data?.kind === "ROUTE" ? (
-        // don't mutate data, as it's used for the initial response - instead create a new object
-        {
-          ...data,
-          revalidate: context.revalidate,
-          body: data.body.toString("base64")
-        }
-      ) : data;
+      (0, import_request_context.getLogger)().debug(`[NetlifyCacheHandler.set]: ${key}`);
+      const value = this.transformToStorableObject(data, context);
+      this.captureCacheTags(value, key);
       await this.blobStore.setJSON(blobKey, {
         lastModified,
         value
@@ -233,17 +311,28 @@ var NetlifyCacheHandler = class {
         const requestContext = (0, import_request_context.getRequestContext)();
         if (requestContext?.didPagesRouterOnDemandRevalidate) {
           const tag = `_N_T_${key === "/index" ? "/" : key}`;
-          import_systemlog.logger.debug(`Purging CDN cache for: [${tag}]`);
-          purgeCache({ tags: [tag] }).catch((error) => {
-            import_systemlog.logger.withError(error).error(`[NetlifyCacheHandler]: Purging the cache for tag ${tag} failed`);
-          });
+          (0, import_request_context.getLogger)().debug(`Purging CDN cache for: [${tag}]`);
+          requestContext.trackBackgroundWork(
+            purgeCache({ tags: [tag] }).catch((error) => {
+              (0, import_request_context.getLogger)().withError(error).error(`[NetlifyCacheHandler]: Purging the cache for tag ${tag} failed`);
+            })
+          );
         }
       }
     });
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   async revalidateTag(tagOrTags, ...args) {
-    import_systemlog.logger.withFields({ tagOrTags, args }).debug("NetlifyCacheHandler.revalidateTag");
+    const revalidateTagPromise = this.doRevalidateTag(tagOrTags, ...args);
+    const requestContext = (0, import_request_context.getRequestContext)();
+    if (requestContext) {
+      requestContext.trackBackgroundWork(revalidateTagPromise);
+    }
+    return revalidateTagPromise;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  async doRevalidateTag(tagOrTags, ...args) {
+    (0, import_request_context.getLogger)().withFields({ tagOrTags, args }).debug("NetlifyCacheHandler.revalidateTag");
     const tags = Array.isArray(tagOrTags) ? tagOrTags : [tagOrTags];
     const data = {
       revalidatedAt: Date.now()
@@ -253,12 +342,12 @@ var NetlifyCacheHandler = class {
         try {
           await this.blobStore.setJSON(await this.encodeBlobKey(tag), data);
         } catch (error) {
-          import_systemlog.logger.withError(error).log(`Failed to update tag manifest for ${tag}`);
+          (0, import_request_context.getLogger)().withError(error).log(`Failed to update tag manifest for ${tag}`);
         }
       })
     );
-    purgeCache({ tags }).catch((error) => {
-      import_systemlog.logger.withError(error).error(`[NetlifyCacheHandler]: Purging the cache for tags ${tags.join(", ")} failed`);
+    await purgeCache({ tags }).catch((error) => {
+      (0, import_request_context.getLogger)().withError(error).error(`[NetlifyCacheHandler]: Purging the cache for tags ${tags.join(", ")} failed`);
     });
   }
   resetRequestCache() {
@@ -271,7 +360,7 @@ var NetlifyCacheHandler = class {
     let cacheTags = [];
     if (cacheEntry.value?.kind === "FETCH") {
       cacheTags = [...tags, ...softTags];
-    } else if (cacheEntry.value?.kind === "PAGE" || cacheEntry.value?.kind === "ROUTE") {
+    } else if (cacheEntry.value?.kind === "PAGE" || cacheEntry.value?.kind === "APP_PAGE" || cacheEntry.value?.kind === "ROUTE") {
       cacheTags = cacheEntry.value.headers?.[import_constants.NEXT_CACHE_TAGS_HEADER]?.split(",") || [];
     } else {
       return false;

package/dist/run/handlers/request-context.cjs

@@ -21,21 +21,94 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var request_context_exports = {};
 __export(request_context_exports, {
   createRequestContext: () => createRequestContext,
+  getLogger: () => getLogger,
   getRequestContext: () => getRequestContext,
   runWithRequestContext: () => runWithRequestContext
 });
 module.exports = __toCommonJS(request_context_exports);
 var import_node_async_hooks = require("node:async_hooks");
-function createRequestContext(debug = false) {
+
+// node_modules/@netlify/functions/dist/chunk-HYMERDCV.mjs
+var import_process = require("process");
+var systemLogTag = "__nfSystemLog";
+var serializeError = (error) => {
+  const cause = error?.cause instanceof Error ? serializeError(error.cause) : error.cause;
+  return {
+    error: error.message,
+    error_cause: cause,
+    error_stack: error.stack
+  };
+};
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Debug"] = 1] = "Debug";
+  LogLevel2[LogLevel2["Log"] = 2] = "Log";
+  LogLevel2[LogLevel2["Error"] = 3] = "Error";
+  return LogLevel2;
+})(LogLevel || {});
+var SystemLogger = class _SystemLogger {
+  fields;
+  logLevel;
+  constructor(fields = {}, logLevel = 2) {
+    this.fields = fields;
+    this.logLevel = logLevel;
+  }
+  doLog(logger, message) {
+    if (import_process.env.NETLIFY_DEV && !import_process.env.NETLIFY_ENABLE_SYSTEM_LOGGING) {
+      return;
+    }
+    logger(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
+  }
+  log(message) {
+    if (this.logLevel > 2) {
+      return;
+    }
+    this.doLog(console.log, message);
+  }
+  debug(message) {
+    if (this.logLevel > 1) {
+      return;
+    }
+    this.doLog(console.debug, message);
+  }
+  error(message) {
+    if (this.logLevel > 3) {
+      return;
+    }
+    this.doLog(console.error, message);
+  }
+  withLogLevel(level) {
+    return new _SystemLogger(this.fields, level);
+  }
+  withFields(fields) {
+    return new _SystemLogger(
+      {
+        ...this.fields,
+        ...fields
+      },
+      this.logLevel
+    );
+  }
+  withError(error) {
+    const fields = error instanceof Error ? serializeError(error) : { error };
+    return this.withFields(fields);
+  }
+};
+var systemLogger = new SystemLogger();
+
+// src/run/handlers/request-context.cts
+function createRequestContext(request) {
   const backgroundWorkPromises = [];
   return {
-    debug,
+    captureServerTiming: request?.headers.has("x-next-debug-logging") ?? false,
     trackBackgroundWork: (promise) => {
       backgroundWorkPromises.push(promise);
     },
     get backgroundWorkPromise() {
       return Promise.allSettled(backgroundWorkPromises);
-    }
+    },
+    logger: systemLogger.withLogLevel(
+      request?.headers.has("x-nf-debug-logging") || request?.headers.has("x-next-debug-logging") ? LogLevel.Debug : LogLevel.Log
+    )
   };
 }
 var REQUEST_CONTEXT_GLOBAL_KEY = Symbol.for("nf-request-context-async-local-storage");
@@ -57,9 +130,13 @@ var getRequestContext = () => getRequestContextAsyncLocalStorage().getStore();
 function runWithRequestContext(requestContext, fn) {
   return getRequestContextAsyncLocalStorage().run(requestContext, fn);
 }
+function getLogger() {
+  return getRequestContext()?.logger ?? systemLogger;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createRequestContext,
+  getLogger,
   getRequestContext,
   runWithRequestContext
 });

package/dist/run/handlers/server.js

@@ -3091,7 +3091,6 @@ function toComputeResponse(res) {
 }
 
 // src/run/handlers/server.ts
-import { getTagsManifest } from "../config.js";
 import {
   adjustDateHeader,
   setCacheControlHeaders,
@@ -3100,13 +3099,11 @@ import {
   setVaryHeaders
 } from "../headers.js";
 import { nextResponseProxy } from "../revalidate.js";
-import { logger } from "../systemlog.cjs";
-import { createRequestContext, getRequestContext } from "./request-context.cjs";
+import { createRequestContext, getLogger, getRequestContext } from "./request-context.cjs";
 import { getTracer } from "./tracer.cjs";
 var nextImportPromise = import("../next.cjs");
 var nextHandler;
 var nextConfig;
-var tagsManifest;
 var disableFaultyTransferEncodingHandling = (res) => {
   const originalStoreHeader = res._storeHeader;
   res._storeHeader = function _storeHeader(firstLine, headers) {
@@ -3122,22 +3119,11 @@ var disableFaultyTransferEncodingHandling = (res) => {
 };
 var server_default = async (request, context) => {
   const tracer = getTracer();
-  const withPerfDebugSpan = process.env.NETLIFY_NEXT_PERF_DEBUG ? tracer.withActiveSpan.bind(tracer) : (_name, fn) => fn();
   if (!nextHandler) {
-    await tracer.withActiveSpan("initialize next server", async (span) => {
+    await tracer.withActiveSpan("initialize next server", async () => {
       const { getRunConfig, setRunConfig } = await import("../config.js");
       nextConfig = await getRunConfig();
       setRunConfig(nextConfig);
-      tagsManifest = await getTagsManifest();
-      span.setAttributes(
-        Object.entries(tagsManifest).reduce(
-          (acc, [key, value]) => {
-            acc[`tagsManifest.${key}`] = value;
-            return acc;
-          },
-          {}
-        )
-      );
       const { getMockedRequestHandlers } = await nextImportPromise;
       const url = new URL(request.url);
       [nextHandler] = await getMockedRequestHandlers({
@@ -3164,7 +3150,7 @@ var server_default = async (request, context) => {
     const requestContext = getRequestContext() ?? createRequestContext();
     const resProxy = nextResponseProxy(res, requestContext);
     const nextHandlerPromise = nextHandler(req, resProxy).catch((error) => {
-      logger.withError(error).error("next handler error");
+      getLogger().withError(error).error("next handler error");
       console.error(error);
       resProxy.statusCode = 500;
       span.setAttribute("http.status_code", 500);
@@ -3175,8 +3161,9 @@ var server_default = async (request, context) => {
       span.setAttribute("responseCacheKey", requestContext.responseCacheKey);
     }
     await adjustDateHeader({ headers: response.headers, request, span, tracer, requestContext });
-    setCacheControlHeaders(response.headers, request, requestContext);
-    setCacheTagsHeaders(response.headers, request, tagsManifest, requestContext);
+    const useDurableCache = context.flags.get("serverless_functions_nextjs_durable_cache_disable") !== true;
+    setCacheControlHeaders(response.headers, request, requestContext, useDurableCache);
+    setCacheTagsHeaders(response.headers, requestContext);
     setVaryHeaders(response.headers, request, nextConfig);
     setCacheStatusHeader(response.headers);
     if (response.status > 300 && response.status < 400 || response.status >= 500) {
@@ -3188,13 +3175,9 @@ var server_default = async (request, context) => {
     }
     const keepOpenUntilNextFullyRendered = new TransformStream({
       async flush() {
-        await withPerfDebugSpan("awaiting next handler", async () => {
-          await nextHandlerPromise;
-        });
+        await nextHandlerPromise;
         if (!context.waitUntil) {
-          await withPerfDebugSpan("awaiting background work", async () => {
-            await requestContext.backgroundWorkPromise;
-          });
+          await requestContext.backgroundWorkPromise;
         }
       }
     });

package/dist/run/handlers/tracer.cjs

@@ -856,7 +856,7 @@ function spanHook(span) {
     const meta = spanMeta.get(span);
     if (meta) {
       const requestContext = (0, import_request_context.getRequestContext)();
-      if (requestContext?.debug) {
+      if (requestContext?.captureServerTiming) {
         const duration = (typeof endTime === "number" ? endTime : performance.now()) - meta.start;
         const serverTiming = requestContext.serverTiming ?? "";
         const currentRequestSpanCounter = spanCounter.get(requestContext) ?? 1;

package/dist/run/handlers/tracing.js

@@ -25421,7 +25421,7 @@ var require_shimmer = __commonJS({
     function isFunction(funktion) {
       return typeof funktion === "function";
     }
-    var logger2 = console.error.bind(console);
+    var logger = console.error.bind(console);
     function defineProperty(obj, name2, value) {
       var enumerable = !!obj[name2] && obj.propertyIsEnumerable(name2);
       Object.defineProperty(obj, name2, {
@@ -25433,22 +25433,22 @@ var require_shimmer = __commonJS({
     }
     function shimmer(options) {
       if (options && options.logger) {
-        if (!isFunction(options.logger)) logger2("new logger isn't a function, not replacing");
-        else logger2 = options.logger;
+        if (!isFunction(options.logger)) logger("new logger isn't a function, not replacing");
+        else logger = options.logger;
       }
     }
     function wrap(nodule, name2, wrapper) {
       if (!nodule || !nodule[name2]) {
-        logger2("no original function " + name2 + " to wrap");
+        logger("no original function " + name2 + " to wrap");
         return;
       }
       if (!wrapper) {
-        logger2("no wrapper function");
-        logger2(new Error().stack);
+        logger("no wrapper function");
+        logger(new Error().stack);
         return;
       }
       if (!isFunction(nodule[name2]) || !isFunction(wrapper)) {
-        logger2("original object and wrapper must be functions");
+        logger("original object and wrapper must be functions");
         return;
       }
       var original = nodule[name2];
@@ -25463,14 +25463,14 @@ var require_shimmer = __commonJS({
     }
     function massWrap(nodules, names, wrapper) {
       if (!nodules) {
-        logger2("must provide one or more modules to patch");
-        logger2(new Error().stack);
+        logger("must provide one or more modules to patch");
+        logger(new Error().stack);
         return;
       } else if (!Array.isArray(nodules)) {
         nodules = [nodules];
       }
       if (!(names && Array.isArray(names))) {
-        logger2("must provide one or more functions to wrap on modules");
+        logger("must provide one or more functions to wrap on modules");
         return;
       }
       nodules.forEach(function(nodule) {
@@ -25481,26 +25481,26 @@ var require_shimmer = __commonJS({
     }
     function unwrap(nodule, name2) {
       if (!nodule || !nodule[name2]) {
-        logger2("no function to unwrap.");
-        logger2(new Error().stack);
+        logger("no function to unwrap.");
+        logger(new Error().stack);
         return;
       }
       if (!nodule[name2].__unwrap) {
-        logger2("no original to unwrap to -- has " + name2 + " already been unwrapped?");
+        logger("no original to unwrap to -- has " + name2 + " already been unwrapped?");
       } else {
         return nodule[name2].__unwrap();
       }
     }
     function massUnwrap(nodules, names) {
       if (!nodules) {
-        logger2("must provide one or more modules to patch");
-        logger2(new Error().stack);
+        logger("must provide one or more modules to patch");
+        logger(new Error().stack);
         return;
       } else if (!Array.isArray(nodules)) {
         nodules = [nodules];
       }
       if (!(names && Array.isArray(names))) {
-        logger2("must provide one or more functions to unwrap on modules");
+        logger("must provide one or more functions to unwrap on modules");
         return;
       }
       nodules.forEach(function(nodule) {
@@ -39342,12 +39342,12 @@ var require_logging = __commonJS({
         break;
       default:
     }
-    var getLogger = () => {
+    var getLogger2 = () => {
       return _logger;
     };
-    exports2.getLogger = getLogger;
-    var setLogger = (logger2) => {
-      _logger = logger2;
+    exports2.getLogger = getLogger2;
+    var setLogger = (logger) => {
+      _logger = logger;
     };
     exports2.setLogger = setLogger;
     var setLoggerVerbosity = (verbosity) => {
@@ -45546,7 +45546,24 @@ var require_parse = __commonJS({
           else
             target.push([start = parseId(next()), skip("to", true) ? parseId(next()) : start]);
         } while (skip(",", true));
-        skip(";");
+        var dummy = { options: void 0 };
+        dummy.setOption = function(name2, value) {
+          if (this.options === void 0) this.options = {};
+          this.options[name2] = value;
+        };
+        ifBlock(
+          dummy,
+          function parseRange_block(token3) {
+            if (token3 === "option") {
+              parseOption(dummy, token3);
+              skip(";");
+            } else
+              throw illegal(token3);
+          },
+          function parseRange_line() {
+            parseInlineOptions(dummy);
+          }
+        );
       }
       function parseNumber(token2, insideTryCatch) {
         var sign = 1;
@@ -56753,8 +56770,8 @@ var require_src31 = __commonJS({
       throw new Error("Not available in this library. Use @grpc/proto-loader and loadPackageDefinition instead");
     };
     exports2.load = load;
-    var setLogger = (logger2) => {
-      logging.setLogger(logger2);
+    var setLogger = (logger) => {
+      logging.setLogger(logger);
     };
     exports2.setLogger = setLogger;
     var setLogVerbosity = (verbosity) => {
@@ -67215,10 +67232,10 @@ var require_sdk = __commonJS({
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             new sdk_trace_base_1.BatchSpanProcessor(configuration.traceExporter)
           );
-          const spanProcessors2 = (_e = configuration.spanProcessors) !== null && _e !== void 0 ? _e : [spanProcessor];
+          const spanProcessors = (_e = configuration.spanProcessors) !== null && _e !== void 0 ? _e : [spanProcessor];
           this._tracerProviderConfig = {
             tracerConfig: tracerProviderConfig,
-            spanProcessors: spanProcessors2,
+            spanProcessors,
             contextManager: configuration.contextManager,
             textMapPropagator: configuration.textMapPropagator
           };
@@ -67365,60 +67382,20 @@ var import_resources = __toESM(require_src5(), 1);
 var import_sdk_node = __toESM(require_src36(), 1);
 var import_sdk_trace_node = __toESM(require_src20(), 1);
 var import_semantic_conventions = __toESM(require_src(), 1);
-import { logger } from "../systemlog.cjs";
+import { getLogger } from "./request-context.cjs";
 var {
   default: { version, name }
-} = await import("../../esm-chunks/package-NQYUR3EH.js");
-var spanProcessors = [];
-if (process.env.NETLIFY_OTLP_TRACE_EXPORTER_URL) {
-  spanProcessors.push(
-    new import_sdk_trace_node.SimpleSpanProcessor(
-      new import_exporter_trace_otlp_http.OTLPTraceExporter({
-        url: process.env.NETLIFY_OTLP_TRACE_EXPORTER_URL
-      })
-    )
-  );
-}
-if (process.env.NETLIFY_NEXT_PERF_DEBUG) {
-  class CompactConsoleExporter {
-    export(spans, resultCallback) {
-      return this._sendSpans(spans, resultCallback);
-    }
-    shutdown() {
-      this._sendSpans([]);
-      return this.forceFlush();
-    }
-    forceFlush() {
-      return Promise.resolve();
-    }
-    _sendSpans(spans, done) {
-      for (const span of spans) {
-        const startDate = new Date(span.startTime[0] * 10 ** 3 + span.startTime[1] / 10 ** 6);
-        const durationS = span.duration[0] + span.duration[1] / 10 ** 9;
-        console.log(
-          `[Trace ${span.spanContext().traceId}] ${`"${span.name}"`.padEnd(
-            60,
-            " "
-          )} start=${startDate.toISOString()} dur=${durationS.toFixed(3)}s${span.events.length === 0 ? "" : ` events=[${span.events.map(
-            (event) => `{ name="${event.name}", time=${new Date(
-              event.time[0] * 10 ** 3 + event.time[1] / 10 ** 6
-            ).toISOString()}}`
-          ).join(", ")}]`}`
-        );
-      }
-      if (done) {
-        return done({ code: 0 });
-      }
-    }
-  }
-  spanProcessors.push(new import_sdk_trace_node.SimpleSpanProcessor(new CompactConsoleExporter()));
-}
+} = await import("../../esm-chunks/package-C5ZXMRQF.js");
 var sdk = new import_sdk_node.NodeSDK({
   resource: new import_resources.Resource({
     [import_semantic_conventions.SEMRESATTRS_SERVICE_NAME]: name,
     [import_semantic_conventions.SEMRESATTRS_SERVICE_VERSION]: version
   }),
-  spanProcessors
+  spanProcessor: new import_sdk_trace_node.SimpleSpanProcessor(
+    new import_exporter_trace_otlp_http.OTLPTraceExporter({
+      url: process.env.NETLIFY_OTLP_TRACE_EXPORTER_URL
+    })
+  )
 });
 var tracing_default = sdk;
 process.on("SIGTERM", () => {
@@ -67426,7 +67403,7 @@ process.on("SIGTERM", () => {
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     () => {
     },
-    (error) => logger.withError(error).log("Error shutting down OpenTelemetry NodeSDK")
+    (error) => getLogger().withError(error).log("Error shutting down OpenTelemetry NodeSDK")
   ).finally(() => process.exit(0));
 });
 export {