@netlify/plugin-nextjs 5.0.0-rc.5 → 5.0.0-rc.7

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

@@ -26,8 +26,10 @@ __export(request_context_exports, {
 });
 module.exports = __toCommonJS(request_context_exports);
 var import_node_async_hooks = require("node:async_hooks");
-function createRequestContext() {
-  return {};
+function createRequestContext(debug = false) {
+  return {
+    debug
+  };
 }
 var REQUEST_CONTEXT_GLOBAL_KEY = Symbol.for("nf-request-context-async-local-storage");
 var requestContextAsyncLocalStorage;

package/dist/run/handlers/server.js

@@ -4,11 +4,6 @@
         return createRequire(import.meta.url);
       })();
     
-import {
-  SpanStatusCode,
-  init_esm,
-  trace
-} from "../../esm-chunks/chunk-GQ6KIYPX.js";
 import {
   nextResponseProxy
 } from "../../esm-chunks/chunk-RL4K4CVH.js";
@@ -25,7 +20,7 @@ import {
   setCacheStatusHeader,
   setCacheTagsHeaders,
   setVaryHeaders
-} from "../../esm-chunks/chunk-637Y3P2U.js";
+} from "../../esm-chunks/chunk-M2ZKGJAI.js";
 import "../../esm-chunks/chunk-TYCYFZ22.js";
 import {
   __commonJS,
@@ -3262,8 +3257,9 @@ function toComputeResponse(res) {
 }
 
 // src/run/handlers/server.ts
-init_esm();
-import { createRequestContext, runWithRequestContext } from "./request-context.cjs";
+import { createRequestContext, getRequestContext } from "./request-context.cjs";
+import { getTracer } from "./tracer.cjs";
+var nextImportPromise = import("../next.cjs");
 var nextHandler;
 var nextConfig;
 var tagsManifest;
@@ -3281,20 +3277,23 @@ var disableFaultyTransferEncodingHandling = (res) => {
   };
 };
 var server_default = async (request) => {
-  const tracer = trace.getTracer("Next.js Runtime");
+  const tracer = getTracer();
   if (!nextHandler) {
-    await tracer.startActiveSpan("initialize next server", async (span) => {
+    await tracer.withActiveSpan("initialize next server", async (span) => {
       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 }),
+          (acc, [key, value]) => {
+            acc[`tagsManifest.${key}`] = value;
+            return acc;
+          },
           {}
         )
       );
-      const { getMockedRequestHandlers } = await import("../next.cjs");
+      const { getMockedRequestHandlers } = await nextImportPromise;
       const url = new URL(request.url);
       [nextHandler] = await getMockedRequestHandlers({
         port: Number(url.port) || 443,
@@ -3302,30 +3301,30 @@ var server_default = async (request) => {
         dir: process.cwd(),
         isDev: false
       });
-      span.end();
     });
   }
-  return await tracer.startActiveSpan("generate response", async (span) => {
+  return await tracer.withActiveSpan("generate response", async (span) => {
     const { req, res } = toReqRes(request);
-    const requestContext = createRequestContext();
+    Object.defineProperty(req, "connection", {
+      get() {
+        return {};
+      }
+    });
+    Object.defineProperty(req, "socket", {
+      get() {
+        return {};
+      }
+    });
     disableFaultyTransferEncodingHandling(res);
+    const requestContext = getRequestContext() ?? createRequestContext();
     const resProxy = nextResponseProxy(res, requestContext);
-    const nextHandlerPromise = runWithRequestContext(
-      requestContext,
-      () => nextHandler(req, resProxy).catch((error) => {
-        import_internal.systemLogger.withError(error).error("next handler error");
-        console.error(error);
-        resProxy.statusCode = 500;
-        span.recordException(error);
-        span.setAttribute("http.status_code", 500);
-        span.setStatus({
-          code: SpanStatusCode.ERROR,
-          message: error instanceof Error ? error.message : String(error)
-        });
-        span.end();
-        resProxy.end("Internal Server Error");
-      })
-    );
+    const nextHandlerPromise = nextHandler(req, resProxy).catch((error) => {
+      import_internal.systemLogger.withError(error).error("next handler error");
+      console.error(error);
+      resProxy.statusCode = 500;
+      span.setAttribute("http.status_code", 500);
+      resProxy.end("Internal Server Error");
+    });
     const response = await toComputeResponse(resProxy);
     if (requestContext.responseCacheKey) {
       span.setAttribute("responseCacheKey", requestContext.responseCacheKey);
@@ -3337,14 +3336,11 @@ var server_default = async (request) => {
     setCacheStatusHeader(response.headers);
     if (response.status > 300 && response.status < 400 || response.status >= 500) {
       const body = await response.text();
-      span.end();
       return new Response(body || null, response);
     }
     const keepOpenUntilNextFullyRendered = new TransformStream({
       flush() {
-        return nextHandlerPromise.then(() => {
-          span.end();
-        });
+        return nextHandlerPromise;
       }
     });
     return new Response(response.body?.pipeThrough(keepOpenUntilNextFullyRendered), response);