9router-proxy 0.6.11 → 0.6.12

package/app/node_modules/next/dist/server/base-server.js

@@ -453,13 +453,24 @@ class Server {
         await this.prepare();
         const method = req.method.toUpperCase();
         const tracer = (0, _tracer.getTracer)();
-        const handleRequest = ()=>tracer.withPropagatedContext(req.headers, ()=>{
+        const handleRequest = ()=>{
+            // The render pass after a middleware invocation continues the trace
+            // context on the request, even when another span is active (e.g. a
+            // custom server or APM HTTP span). That is the context the
+            // middleware-invoke pass wrote onto the request, so the middleware span
+            // and the render are siblings under that pass's span, or a `traceparent`
+            // the middleware explicitly set as a request-header override.
+            const forcePropagation = !(0, _requestmeta.getRequestMeta)(req, 'middlewareInvoke') && (0, _requestmeta.getRequestMeta)(req, 'middlewareInvokeTraceparent') !== undefined;
+            // With forced propagation the active (host) span isn't the parent, so
+            // capture it before propagating to keep propagating `http.route` to it.
+            const hostSpan = forcePropagation ? tracer.getActiveScopeSpan() : undefined;
+            return tracer.withPropagatedContext(req.headers, ()=>{
                 // Capture the parent span before creating the handleRequest span.
                 // When deployed with an adapter, the platform's runtime may create its
                 // own OTEL HTTP server span before Next.js runs. We propagate http.route
                 // to this parent span so APM tools (e.g. Datadog) can derive the
                 // resource name correctly.
-                const parentSpan = tracer.getActiveScopeSpan();
+                const parentSpan = forcePropagation ? hostSpan : tracer.getActiveScopeSpan();
                 return tracer.trace(_constants1.BaseServerSpan.handleRequest, {
                     spanName: `${method}`,
                     kind: _tracer.SpanKind.SERVER,
@@ -467,7 +478,28 @@ class Server {
                         'http.method': method,
                         'http.target': req.url
                     }
-                }, async (span)=>this.handleRequestImpl(req, res, parsedUrl).finally(()=>{
+                }, async (span)=>{
+                    if ((0, _requestmeta.getRequestMeta)(req, 'middlewareInvoke')) {
+                        // When middleware lets the request continue, the router server
+                        // calls `handleRequest` twice: once to run middleware (this pass)
+                        // and once to render. Publish this span's W3C trace context on
+                        // the request, so the middleware span (including the Edge
+                        // sandbox, which extracts it from the request headers) and the
+                        // render pass are both children of this span (siblings) instead
+                        // of starting new traces.
+                        const traceContext = tracer.getTraceContextHeaders();
+                        if (traceContext) {
+                            Object.assign(req.headers, traceContext);
+                            if (!traceContext.tracestate) {
+                                // Don't pair this span's `traceparent` with a
+                                // `tracestate` of another trace context (e.g. an incoming
+                                // one, when a host span is this span's parent).
+                                delete req.headers.tracestate;
+                            }
+                            (0, _requestmeta.addRequestMeta)(req, 'middlewareInvokeTraceparent', traceContext.traceparent);
+                        }
+                    }
+                    return this.handleRequestImpl(req, res, parsedUrl).finally(()=>{
                         if (!span) return;
                         const isRSCRequest = (0, _requestmeta.getRequestMeta)(req, 'isRSCRequest') ?? false;
                         span.setAttributes({
@@ -509,8 +541,10 @@ class Server {
                         } else {
                             span.updateName(isRSCRequest ? `RSC ${method}` : `${method}`);
                         }
-                    }));
-            });
+                    });
+                });
+            }, undefined, forcePropagation);
+        };
         if (!(0, _spanstore.isRequestInsightsEnabled)()) {
             return handleRequest();
         }

package/app/node_modules/next/dist/server/config.js

@@ -1163,7 +1163,7 @@ async function applyModifyConfig(config, phase, silent, dir) {
             }
             config = await adapterMod.modifyConfig(config, {
                 phase,
-                nextVersion: "16.4.2",
+                nextVersion: "16.4.3",
                 projectDir: dir
             });
         }

package/app/node_modules/next/dist/server/dev/hot-reloader-turbopack.js

@@ -325,7 +325,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
     }
     const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
     const hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-        version: "16.4.2"
+        version: "16.4.3"
     });
     // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
     // of the current `next dev` invocation.
@@ -385,7 +385,7 @@ async function createHotReloaderTurbopack(opts, serverFields, distDir, resetFetc
         writeRoutesHashesManifest: false,
         currentNodeJsVersion,
         isPersistentCachingEnabled: (0, _utils2.isFileSystemCacheEnabledForDev)(opts.nextConfig),
-        nextVersion: "16.4.2",
+        nextVersion: "16.4.3",
         serverHmr: serverFastRefresh
     }, {
         turbopackMemoryEviction: opts.nextConfig.experimental.turbopackMemoryEvictionMode,

package/app/node_modules/next/dist/server/dev/hot-reloader-webpack.js

@@ -237,7 +237,7 @@ class HotReloaderWebpack {
         this.previewProps = previewProps;
         this.rewrites = rewrites;
         this.hotReloaderSpan = (0, _trace.trace)('hot-reloader', undefined, {
-            version: "16.4.2"
+            version: "16.4.3"
         });
         // Ensure the hotReloaderSpan is flushed immediately as it's the parentSpan for all processing
         // of the current `next dev` invocation.

package/app/node_modules/next/dist/server/lib/app-info-log.js

@@ -83,7 +83,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
 }
 function logStartInfo({ networkUrl, appUrl, envInfo, logBundler }) {
     const versionSuffix = logBundler ? ` (${(0, _bundler.bundlerName)((0, _bundler.getBundlerFromEnv)())})` : '';
-    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.4.2"}`))}${versionSuffix}`);
+    _log.bootstrap(`${(0, _picocolors.bold)((0, _picocolors.purple)(`${_log.prefixes.ready} Next.js ${"16.4.3"}`))}${versionSuffix}`);
     if (appUrl) {
         _log.bootstrap(`- Local:         ${appUrl}`);
     }

package/app/node_modules/next/dist/server/lib/dedupe-fetch.js

@@ -10,50 +10,8 @@ Object.defineProperty(exports, "createDedupeFetch", {
         return createDedupeFetch;
     }
 });
-const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
 const _cloneresponse = require("./clone-response");
 const _invarianterror = require("../../shared/lib/invariant-error");
-function _getRequireWildcardCache(nodeInterop) {
-    if (typeof WeakMap !== "function") return null;
-    var cacheBabelInterop = new WeakMap();
-    var cacheNodeInterop = new WeakMap();
-    return (_getRequireWildcardCache = function(nodeInterop) {
-        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-    })(nodeInterop);
-}
-function _interop_require_wildcard(obj, nodeInterop) {
-    if (!nodeInterop && obj && obj.__esModule) {
-        return obj;
-    }
-    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
-        return {
-            default: obj
-        };
-    }
-    var cache = _getRequireWildcardCache(nodeInterop);
-    if (cache && cache.has(obj)) {
-        return cache.get(obj);
-    }
-    var newObj = {
-        __proto__: null
-    };
-    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
-    for(var key in obj){
-        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
-            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
-            if (desc && (desc.get || desc.set)) {
-                Object.defineProperty(newObj, key, desc);
-            } else {
-                newObj[key] = obj[key];
-            }
-        }
-    }
-    newObj.default = obj;
-    if (cache) {
-        cache.set(obj, newObj);
-    }
-    return newObj;
-}
 const simpleCacheKey = '["GET",[],null,"follow",null,null,null,null]' // generateCacheKey(new Request('https://blank'));
 ;
 // Headers that should not affect deduplication
@@ -82,7 +40,10 @@ function generateCacheKey(request) {
     ]);
 }
 function createDedupeFetch(originalFetch) {
-    const getCacheEntries = _react.cache(// eslint-disable-next-line @typescript-eslint/no-unused-vars -- url is the cache key
+    // Importing the helper alone must not load the app-page runtime through
+    // the App Router's vendored React. Keep the same React instance when used.
+    const React = require('react');
+    const getCacheEntries = React.cache(// eslint-disable-next-line @typescript-eslint/no-unused-vars -- url is the cache key
     (url)=>[]);
     return function dedupeFetch(resource, options) {
         if (options && options.signal) {

package/app/node_modules/next/dist/server/lib/patch-fetch-symbol.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "NEXT_PATCH_SYMBOL", {
+    enumerable: true,
+    get: function() {
+        return NEXT_PATCH_SYMBOL;
+    }
+});
+const NEXT_PATCH_SYMBOL = Symbol.for('next-patch');
+
+//# sourceMappingURL=patch-fetch-symbol.js.map

package/app/node_modules/next/dist/server/lib/patch-fetch.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 0 && (module.exports = {
-    NEXT_PATCH_SYMBOL: null,
     createPatchedFetcher: null,
     patchFetch: null,
     validateRevalidate: null,
@@ -16,9 +15,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    NEXT_PATCH_SYMBOL: function() {
-        return NEXT_PATCH_SYMBOL;
-    },
     createPatchedFetcher: function() {
         return createPatchedFetcher;
     },
@@ -40,6 +36,7 @@ const _constants1 = require("../../lib/constants");
 const _dynamicrendering = require("../app-render/dynamic-rendering");
 const _dynamicrenderingutils = require("../dynamic-rendering-utils");
 const _dedupefetch = require("./dedupe-fetch");
+const _patchfetchsymbol = require("./patch-fetch-symbol");
 const _workunitasyncstorageexternal = require("../app-render/work-unit-async-storage.external");
 const _responsecache = require("../response-cache");
 const _cloneresponse = require("./clone-response");
@@ -74,9 +71,8 @@ const isEdgeRuntime = process.env.NEXT_RUNTIME === 'edge';
             return workUnitStore;
     }
 }
-const NEXT_PATCH_SYMBOL = Symbol.for('next-patch');
 function isFetchPatched() {
-    return globalThis[NEXT_PATCH_SYMBOL] === true;
+    return globalThis[_patchfetchsymbol.NEXT_PATCH_SYMBOL] === true;
 }
 function validateRevalidate(revalidateVal, route) {
     try {
@@ -999,7 +995,7 @@ function createPatchedFetcher(originFetch, { workAsyncStorage, workUnitAsyncStor
     patched.__nextPatched = true;
     patched.__nextGetStaticStore = ()=>workAsyncStorage;
     patched._nextOriginalFetch = originFetch;
-    globalThis[NEXT_PATCH_SYMBOL] = true;
+    globalThis[_patchfetchsymbol.NEXT_PATCH_SYMBOL] = true;
     // Assign the function name also as a name property, so that it's preserved
     // even when mangling is enabled.
     Object.defineProperty(patched, 'name', {

package/app/node_modules/next/dist/server/lib/router-server.js

@@ -45,7 +45,7 @@ const _detectdomainlocale = require("../../shared/lib/i18n/detect-domain-locale"
 const _mockrequest = require("./mock-request");
 const _hotreloadertypes = require("../dev/hot-reloader-types");
 const _normalizedassetprefix = require("../../shared/lib/normalized-asset-prefix");
-const _patchfetch = require("./patch-fetch");
+const _patchfetchsymbol = require("./patch-fetch-symbol");
 const _utils1 = require("./server-ipc/utils");
 const _blockcrosssitedev = require("./router-utils/block-cross-site-dev");
 const _shared = require("../../trace/shared");
@@ -164,7 +164,7 @@ async function initialize(opts) {
         const { setupDevBundler } = require('./router-utils/setup-dev-bundler');
         const resetFetch = ()=>{
             globalThis.fetch = originalFetch;
-            globalThis[_patchfetch.NEXT_PATCH_SYMBOL] = false;
+            globalThis[_patchfetchsymbol.NEXT_PATCH_SYMBOL] = false;
         };
         const setupDevBundlerSpan = opts.startServerSpan ? opts.startServerSpan.traceChild('setup-dev-bundler') : (0, _trace.trace)('setup-dev-bundler');
         // In development, it's always the complete config.
@@ -173,7 +173,7 @@ async function initialize(opts) {
         if (developmentConfig.experimental.agentUpgrade === 'security' || developmentConfig.experimental.agentUpgrade === 'latest' || developmentConfig.experimental.agentUpgrade === 'experimental-future' || process.env.__NEXT_AGENT_UPGRADE || process.env.__NEXT_AGENT_UPGRADE_FORCE_DEVTOOLS_FOR_TESTING === '1') {
             const { nudgeUpgrade, getUpgradeContext, assessUpgrade } = require('../../lib/upgrade/nudge');
             const upgradeContext = getUpgradeContext(developmentConfig);
-            const installedVersion = "16.4.2" || 'unknown';
+            const installedVersion = "16.4.3" || 'unknown';
             const policy = upgradeContext.experimental.agentUpgrade;
             const forced = process.env.__NEXT_AGENT_UPGRADE === policy;
             const forceDevToolsForTesting = process.env.__NEXT_AGENT_UPGRADE_FORCE_DEVTOOLS_FOR_TESTING === '1';

package/app/node_modules/next/dist/server/lib/router-utils/instrumentation-globals.external.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 0 && (module.exports = {
     ensureInstrumentationRegistered: null,
+    ensureInstrumentationRegisteredWithDeferredSpans: null,
     getInstrumentationModule: null,
     instrumentationOnRequestError: null
 });
@@ -17,6 +18,9 @@ _export(exports, {
     ensureInstrumentationRegistered: function() {
         return ensureInstrumentationRegistered;
     },
+    ensureInstrumentationRegisteredWithDeferredSpans: function() {
+        return ensureInstrumentationRegisteredWithDeferredSpans;
+    },
     getInstrumentationModule: function() {
         return getInstrumentationModule;
     },
@@ -42,7 +46,7 @@ function getInstrumentationTimestamp() {
     // Date.now() is treated as synchronous I/O while Cache Components render.
     return performance.timeOrigin + performance.now();
 }
-function traceBackdatedInstrumentationSpan(type, spanName, { startTime, endTime, error }) {
+function traceBackdatedInstrumentationSpan({ type, spanName, timing: { startTime, endTime, error } }) {
     (0, _tracer.getTracer)().trace(type, {
         spanName,
         startTime,
@@ -58,11 +62,24 @@ function traceBackdatedInstrumentationSpan(type, spanName, { startTime, endTime,
         });
     });
 }
-function traceInstrumentationModuleLoad() {
-    if (!instrumentationModuleLoadTiming) return;
+/**
+ * Takes the recorded timing of loading the instrumentation module, if not
+ * emitted yet, as a lifecycle span.
+ */ function takeInstrumentationModuleLoadSpan() {
+    if (!instrumentationModuleLoadTiming) return undefined;
     const timing = instrumentationModuleLoadTiming;
     instrumentationModuleLoadTiming = undefined;
-    traceBackdatedInstrumentationSpan(_constants1.InstrumentationSpan.loadModule, 'load instrumentation module', timing);
+    return {
+        type: _constants1.InstrumentationSpan.loadModule,
+        spanName: 'load instrumentation module',
+        timing
+    };
+}
+function traceInstrumentationModuleLoad() {
+    const span = takeInstrumentationModuleLoadSpan();
+    if (span) {
+        traceBackdatedInstrumentationSpan(span);
+    }
 }
 async function getInstrumentationModule(projectDir, distDir) {
     if (cachedInstrumentationModule) {
@@ -87,7 +104,17 @@ async function getInstrumentationModule(projectDir, distDir) {
     }
 }
 let instrumentationModulePromise = null;
-async function registerInstrumentation(projectDir, distDir) {
+/**
+ * Loads `instrumentation.ts` and calls its `register()`.
+ *
+ * Its lifecycle spans (`load instrumentation module`, `register
+ * instrumentation`) are backdated and emitted afterwards, since `register()`
+ * commonly installs the tracer provider. They are emitted right away in the
+ * active context, unless `deferredSpans` is given: then successfully completed
+ * steps are added to it instead, for the caller to emit in another context
+ * (the request that triggered registration). Failed steps are always emitted
+ * right away.
+ */ async function registerInstrumentation(projectDir, distDir, deferredSpans) {
     // Ensure registerInstrumentation is not called in production build
     if (process.env.NEXT_PHASE === 'phase-production-build') {
         return;
@@ -106,9 +133,11 @@ async function registerInstrumentation(projectDir, distDir) {
     if (instrumentation == null ? void 0 : instrumentation.register) {
         const startTime = getInstrumentationTimestamp();
         let error;
+        let registered = false;
         try {
             await instrumentation.register();
             (0, _instrumentationnodeextensions.afterRegistration)();
+            registered = true;
         } catch (err) {
             error = err;
             err.message = `An error occurred while loading instrumentation hook: ${err.message}`;
@@ -117,15 +146,35 @@ async function registerInstrumentation(projectDir, distDir) {
             const endTime = getInstrumentationTimestamp();
             // register() commonly installs the provider, so emit both lifecycle
             // spans afterward with their original timestamps.
-            traceInstrumentationModuleLoad();
-            traceBackdatedInstrumentationSpan(_constants1.InstrumentationSpan.register, 'register instrumentation', {
-                startTime,
-                endTime,
-                error
-            });
+            const spans = [
+                takeInstrumentationModuleLoadSpan(),
+                {
+                    type: _constants1.InstrumentationSpan.register,
+                    spanName: 'register instrumentation',
+                    timing: {
+                        startTime,
+                        endTime,
+                        error
+                    }
+                }
+            ].filter((span)=>span !== undefined);
+            // Only defer after a successful registration: a failing request has no
+            // request span to emit them in.
+            if (deferredSpans && registered) {
+                deferredSpans.push(...spans);
+            } else {
+                spans.forEach(traceBackdatedInstrumentationSpan);
+            }
         }
     } else {
-        traceInstrumentationModuleLoad();
+        const span = takeInstrumentationModuleLoadSpan();
+        if (span) {
+            if (deferredSpans) {
+                deferredSpans.push(span);
+            } else {
+                traceBackdatedInstrumentationSpan(span);
+            }
+        }
     }
 }
 async function instrumentationOnRequestError(projectDir, distDir, ...args) {
@@ -145,5 +194,21 @@ function ensureInstrumentationRegistered(projectDir, distDir) {
     }
     return registerInstrumentationPromise;
 }
+async function ensureInstrumentationRegisteredWithDeferredSpans(projectDir, distDir) {
+    if (registerInstrumentationPromise) {
+        await registerInstrumentationPromise;
+        return undefined;
+    }
+    const deferredSpans = [];
+    registerInstrumentationPromise = registerInstrumentation(projectDir, distDir, deferredSpans);
+    await registerInstrumentationPromise;
+    if (deferredSpans.length === 0) {
+        return undefined;
+    }
+    return ()=>{
+        // Emit at most once.
+        deferredSpans.splice(0).forEach(traceBackdatedInstrumentationSpan);
+    };
+}
 
 //# sourceMappingURL=instrumentation-globals.external.js.map

package/app/node_modules/next/dist/server/lib/start-server.js

@@ -174,7 +174,7 @@ async function getRequestHandlers({ dir, port, isDev, onDevServerCleanup, server
 async function startServer(serverOptions) {
     const { dir, isDev, hostname, minimalMode, allowRetry, keepAliveTimeout, selfSignedCertificate, serverFastRefresh } = serverOptions;
     let { port } = serverOptions;
-    process.title = `next-server (v${"16.4.2"})`;
+    process.title = `next-server (v${"16.4.3"})`;
     let handlersReady = ()=>{};
     let handlersError = ()=>{};
     let handlersPromise = new Promise((resolve, reject)=>{

package/app/node_modules/next/dist/server/lib/trace/constants.js

@@ -20,6 +20,7 @@ Object.defineProperty(exports, "__esModule", {
     MiddlewareSpan: null,
     NextNodeServerSpan: null,
     NextServerSpan: null,
+    NextSpan: null,
     NextVanillaSpanAllowlist: null,
     NodeSpan: null,
     RenderSpan: null,
@@ -68,6 +69,9 @@ _export(exports, {
     NextServerSpan: function() {
         return NextServerSpan;
     },
+    NextSpan: function() {
+        return NextSpan;
+    },
     NextVanillaSpanAllowlist: function() {
         return NextVanillaSpanAllowlist;
     },
@@ -216,8 +220,16 @@ var MiddlewareSpan = /*#__PURE__*/ function(MiddlewareSpan) {
     MiddlewareSpan["execute"] = "Middleware.execute";
     return MiddlewareSpan;
 }(MiddlewareSpan || {});
+var NextSpan = /*#__PURE__*/ function(NextSpan) {
+    // Root span inserted by the middleware adapter when the request has no
+    // trace context (separately invoked middleware without a parent), so the
+    // middleware and the render are siblings in one trace.
+    NextSpan["request"] = "Next.request";
+    return NextSpan;
+}(NextSpan || {});
 const NextVanillaSpanAllowlist = new Set([
     "Middleware.execute",
+    "Next.request",
     "BaseServer.handleRequest",
     "Render.getServerSideProps",
     "Render.getStaticProps",

package/app/node_modules/next/dist/server/lib/trace/tracer.js

@@ -7,7 +7,8 @@ Object.defineProperty(exports, "__esModule", {
     SpanKind: null,
     SpanStatusCode: null,
     getTracer: null,
-    isBubbledError: null
+    isBubbledError: null,
+    recordSpanError: null
 });
 function _export(target, all) {
     for(var name in all)Object.defineProperty(target, name, {
@@ -30,6 +31,9 @@ _export(exports, {
     },
     isBubbledError: function() {
         return isBubbledError;
+    },
+    recordSpanError: function() {
+        return recordSpanError;
     }
 });
 const _constants = require("./constants");
@@ -70,7 +74,7 @@ function isBubbledError(error) {
     if (typeof error !== 'object' || error === null) return false;
     return error instanceof BubbledError;
 }
-const closeSpanWithError = (span, error, endTime)=>{
+const recordSpanError = (span, error)=>{
     if (isBubbledError(error) && error.bubble) {
         span.setAttribute('next.bubble', true);
     } else {
@@ -83,6 +87,9 @@ const closeSpanWithError = (span, error, endTime)=>{
             message: error == null ? void 0 : error.message
         });
     }
+};
+const closeSpanWithError = (span, error, endTime)=>{
+    recordSpanError(span, error);
     span.end(endTime);
 };
 /** we use this map to propagate attributes from nested spans to the top span */ const rootSpanAttributesStore = new Map();
@@ -103,7 +110,7 @@ class NextTracerImpl {
    * Since wrap / trace can be defined in any place prior to actual trace subscriber initialization,
    * This should be lazily evaluated.
    */ getTracerInstance() {
-        return trace.getTracer('next.js', "16.4.2");
+        return trace.getTracer('next.js', "16.4.3");
     }
     isOpenTelemetryEnabled() {
         var _tracerProvider_getDelegate_constructor, _tracerProvider_getDelegate;
@@ -126,6 +133,26 @@ class NextTracerImpl {
         propagation.inject(activeContext, entries, clientTraceDataSetter);
         return entries;
     }
+    getTraceContextHeaders() {
+        const activeContext = context.active();
+        if (!trace.getSpanContext(activeContext) || !this.isOpenTelemetryEnabled()) {
+            return undefined;
+        }
+        const carrier = {};
+        propagation.inject(activeContext, carrier);
+        const { traceparent, tracestate } = carrier;
+        if (!traceparent) {
+            return undefined;
+        }
+        return {
+            traceparent,
+            tracestate
+        };
+    }
+    hasActiveSpanContext() {
+        const spanContext = trace.getSpanContext(context.active());
+        return Boolean(spanContext && trace.isSpanContextValid(spanContext));
+    }
     getActiveScopeSpan() {
         const localSpanRecorder = getLocalSpanRecorder();
         const activeLocalSpan = localSpanRecorder == null ? void 0 : localSpanRecorder.getActiveLocalSpan();
@@ -138,17 +165,6 @@ class NextTracerImpl {
         }
         return activeLocalSpan;
     }
-    /**
-   * Run `fn` with the active span cleared, so spans created inside become new
-   * roots (or parent to incoming propagated context). Used for in-process
-   * Node.js middleware so its span is a sibling of the request span, matching
-   * edge middleware which runs in a detached sandbox.
-   */ runWithDetachedContext(fn) {
-        if (!NEXT_OTEL_PERFORMANCE_PREFIX && !this.isOpenTelemetryEnabled()) {
-            return fn();
-        }
-        return context.with(ROOT_CONTEXT, fn);
-    }
     withPropagatedContext(carrier, fn, getter, force = false) {
         const activeContext = context.active();
         if (!NEXT_OTEL_PERFORMANCE_PREFIX && !this.isOpenTelemetryEnabled() && !trace.getSpanContext(activeContext)) {

package/app/node_modules/next/dist/server/next-server.js

@@ -1215,17 +1215,16 @@ class NextNodeServer extends _baseserver.default {
             ].includes(params.request.method) && Boolean(requestData.body);
             try {
                 // Node.js middleware runs in-process, inside the active
-                // `handleRequest` span. Detach that span so the middleware span
-                // becomes a sibling root (or parents to an incoming traceparent),
-                // matching edge middleware which runs in a detached sandbox.
-                result = await (0, _tracer.getTracer)().runWithDetachedContext(()=>adapterFn({
-                        handler: middlewareModule.proxy || middlewareModule.middleware || middlewareModule,
-                        request: {
-                            ...requestData,
-                            body: hasRequestBody ? requestData.body.cloneBodyStream() : undefined
-                        },
-                        page: 'middleware'
-                    }));
+                // `handleRequest` span, so the middleware span (and the trace context
+                // it forwards to the render) stays in the request's trace.
+                result = await adapterFn({
+                    handler: middlewareModule.proxy || middlewareModule.middleware || middlewareModule,
+                    request: {
+                        ...requestData,
+                        body: hasRequestBody ? requestData.body.cloneBodyStream() : undefined
+                    },
+                    page: 'middleware'
+                });
             } finally{
                 if (hasRequestBody) {
                     await requestData.body.finalize();