From b114f7cffb2c12744c8eead7660da06a6a4adc8a Mon Sep 17 00:00:00 2001
From: Jamiboy Mohammad
Date: Tue, 29 Sep 2026 05:47:26 -0700
Subject: [PATCH 1/3] test: enable deploy coverage for five verified suites
(#99193)
## Summary
Enable deploy testing for five suites: middleware page extensions, mixed
proxy page extensions, false aliases, CSS module ordering, and
conflicting service worker registrations. Their deploy-mode assertions
check served responses, browser-rendered styles, or a specific remote
build failure.
## Verification
The retained changes passed [Turbopack deploy
CI](https://github.com/vercel/next.js/actions/runs/36188078111) at
`293d58d`, including cache-components jobs. Webpack deploy behavior
remains unverified.
Local formatting and ESLint checks passed. The four restored files match
the PR base exactly, and the five retained files are unchanged. A full
local bootstrap could not complete because this worktree lacks
package-level dependencies (`microbundle`).
---------
Co-authored-by: Claude Opus 5
---
.../middleware-page-extensions.test.ts | 1 -
.../proxy-mixed-page-extensions.test.ts | 1 -
.../service-worker-multiple.test.ts | 7 +------
.../turbopack-resolve-alias-false.test.ts | 1 -
test/e2e/css-features/css-modules-ordering.test.ts | 6 ------
5 files changed, 1 insertion(+), 15 deletions(-)
diff --git a/test/e2e/app-dir/middleware-page-extensions/middleware-page-extensions.test.ts b/test/e2e/app-dir/middleware-page-extensions/middleware-page-extensions.test.ts
index 2c32a6b1777b..17787ae62978 100644
--- a/test/e2e/app-dir/middleware-page-extensions/middleware-page-extensions.test.ts
+++ b/test/e2e/app-dir/middleware-page-extensions/middleware-page-extensions.test.ts
@@ -4,7 +4,6 @@ import { retry } from 'next-test-utils'
describe('middleware-page-extensions', () => {
const { next } = nextTestSetup({
files: __dirname,
- skipDeployment: true,
})
it('should execute middleware.page.ts and set custom header', async () => {
diff --git a/test/e2e/app-dir/proxy-mixed-page-extensions/proxy-mixed-page-extensions.test.ts b/test/e2e/app-dir/proxy-mixed-page-extensions/proxy-mixed-page-extensions.test.ts
index 5d46b4fa3539..b2c9339910bd 100644
--- a/test/e2e/app-dir/proxy-mixed-page-extensions/proxy-mixed-page-extensions.test.ts
+++ b/test/e2e/app-dir/proxy-mixed-page-extensions/proxy-mixed-page-extensions.test.ts
@@ -3,7 +3,6 @@ import { nextTestSetup } from 'e2e-utils'
describe('proxy-mixed-page-extensions', () => {
const { next } = nextTestSetup({
files: __dirname,
- skipDeployment: true,
})
it('should detect proxy.page.tsx when pageExtensions mixes compound and simple', async () => {
diff --git a/test/e2e/app-dir/service-worker-multiple/service-worker-multiple.test.ts b/test/e2e/app-dir/service-worker-multiple/service-worker-multiple.test.ts
index e2617e4f20f1..be1c4bc4c1b2 100644
--- a/test/e2e/app-dir/service-worker-multiple/service-worker-multiple.test.ts
+++ b/test/e2e/app-dir/service-worker-multiple/service-worker-multiple.test.ts
@@ -5,17 +5,12 @@ import { retry } from 'next-test-utils'
;(process.env.IS_TURBOPACK_TEST ? describe : describe.skip)(
'app dir - service worker (multiple registrations error)',
() => {
- const { next, skipped, isNextDev } = nextTestSetup({
+ const { next, isNextDev } = nextTestSetup({
files: __dirname,
skipStart: true,
// This test asserts a build failure.
- skipDeployment: true,
})
- if (skipped) {
- return
- }
-
it('errors when different service worker files are registered', async () => {
// In production `next.start()` runs the build, which fails. In dev the server
// boots and the failure surfaces when the registering page is compiled.
diff --git a/test/e2e/app-dir/turbopack-resolve-alias-false/turbopack-resolve-alias-false.test.ts b/test/e2e/app-dir/turbopack-resolve-alias-false/turbopack-resolve-alias-false.test.ts
index 7939c4142985..d0661684682f 100644
--- a/test/e2e/app-dir/turbopack-resolve-alias-false/turbopack-resolve-alias-false.test.ts
+++ b/test/e2e/app-dir/turbopack-resolve-alias-false/turbopack-resolve-alias-false.test.ts
@@ -4,7 +4,6 @@ describe('resolve-alias-false', () => {
const isTurbopack = Boolean(process.env.IS_TURBOPACK_TEST)
const { next } = nextTestSetup({
files: __dirname,
- skipDeployment: true,
})
describe('ESM static imports', () => {
diff --git a/test/e2e/css-features/css-modules-ordering.test.ts b/test/e2e/css-features/css-modules-ordering.test.ts
index cbeee12246a5..4715d0d95dd4 100644
--- a/test/e2e/css-features/css-modules-ordering.test.ts
+++ b/test/e2e/css-features/css-modules-ordering.test.ts
@@ -22,7 +22,6 @@ describe('Basic CSS Modules Ordering', () => {
useLightningcss: true,
},
},
- skipDeployment: true,
})
async function checkGreenButton(browser: Playwright) {
@@ -92,7 +91,6 @@ describe('Basic CSS Modules Ordering', () => {
useLightningcss: false,
},
},
- skipDeployment: true,
})
async function checkGreenButton(browser: Playwright) {
@@ -163,7 +161,6 @@ describe('Ordering with Global CSS and Modules', () => {
useLightningcss: true,
},
},
- skipDeployment: true,
})
;(isNextDev ? it : it.skip)(
@@ -252,7 +249,6 @@ describe('Ordering with Global CSS and Modules', () => {
useLightningcss: false,
},
},
- skipDeployment: true,
})
;(isNextDev ? it : it.skip)(
@@ -347,7 +343,6 @@ describe('CSS Modules Composes Ordering', () => {
useLightningcss: true,
},
},
- skipDeployment: true,
})
async function checkBlackTitle(browser: Playwright) {
@@ -507,7 +502,6 @@ describe('CSS Modules Composes Ordering', () => {
useLightningcss: false,
},
},
- skipDeployment: true,
})
async function checkBlackTitle(browser: Playwright) {
From b829c6189bc3af485cb92f0c3f3d09bf81a8e6fe Mon Sep 17 00:00:00 2001
From: Jamiboy Mohammad
Date: Tue, 29 Sep 2026 05:47:55 -0700
Subject: [PATCH 2/3] fix: preserve HTTP status codes during prerendering
(#99078)
## Summary
Set the correct HTTP status and redirect location when a prerendered
page throws `notFound()`, `unauthorized()`, `forbidden()`, `redirect()`,
or `permanentRedirect()` inside Suspense. Preserve the prerendered
layout and Suspense fallback so the client can recover at the
appropriate error boundary.
Redirects take precedence over HTTP access fallbacks. Among access
fallbacks, or among redirects, the first observed error wins. The HTML
error callback and prerender recovery catch share this rule, so a later
fatal not-found error cannot overwrite an already captured redirect. The
catch still classifies its own error independently of the selected
response.
Request-time streaming behavior is unchanged. A dynamic not-found after
`connection()` can still return 200. The custom error UI itself is not
prerendered and remains a follow-up.
Related:
[NAR-435](https://linear.app/vercel/issue/NAR-435/set-status-code-on-prerendered-output-whenever-notfound-or-redirect).
## Verification
- All 57 production Turbopack tests pass with Cache Components enabled
and disabled, with `__NEXT_EXPERIMENTAL_STRICT_ROUTE_TYPES=true`. This
includes 44 ordered-error cases covering sibling Suspense boundaries and
the outer recovery catch, status/location consistency, and preserved
layout/fallback HTML.
- Removing the precedence fix causes 22 regression cases to fail.
- All 36 existing on-demand prerender recovery tests pass with Cache
Components enabled: `NEXT_SKIP_ISOLATE=1 NEXT_TELEMETRY_DISABLED=1
__NEXT_EXPERIMENTAL_STRICT_ROUTE_TYPES=true __NEXT_CACHE_COMPONENTS=true
pnpm test-start-turbo
test/e2e/app-dir/on-demand-prerender-error-boundary/on-demand-prerender-error-boundary.test.ts`.
- Dev gate verified: all 57 tests are skipped.
- Local tests used the installed SWC canary.38 binary with Next.js
canary.42 and emitted a version mismatch warning. Deploy mode was not
run locally.
---------
Co-authored-by: Jamiboy Mohammad <2085704+jamiboym@users.noreply.github.com>
---
.../next/src/server/app-render/app-render.tsx | 86 ++++++----
...on-demand-prerender-error-boundary.test.ts | 2 +-
.../app/layout.tsx | 7 +
.../app/not-found.tsx | 3 +
.../[first]/[second]/[boundary]/page.tsx | 29 ++++
.../app/precedence/http-error.tsx | 77 +++++++++
.../with-suspense/dynamic-not-found/page.tsx | 7 +
.../app/with-suspense/forbidden/page.tsx | 5 +
.../app/with-suspense/layout.tsx | 12 ++
.../app/with-suspense/not-found.tsx | 1 +
.../app/with-suspense/not-found/page.tsx | 5 +
.../with-suspense/permanent-redirect/page.tsx | 5 +
.../app/with-suspense/redirect/page.tsx | 5 +
.../app/with-suspense/unauthorized/page.tsx | 5 +
.../app/without-suspense/forbidden/page.tsx | 5 +
.../app/without-suspense/not-found/page.tsx | 5 +
.../permanent-redirect/page.tsx | 5 +
.../app/without-suspense/redirect/page.tsx | 5 +
.../without-suspense/unauthorized/page.tsx | 5 +
.../index.test.ts | 150 ++++++++++++++++++
.../next.config.js | 6 +
21 files changed, 396 insertions(+), 34 deletions(-)
create mode 100644 test/e2e/prerendered-http-status-codes/app/layout.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/not-found.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/precedence/[first]/[second]/[boundary]/page.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/precedence/http-error.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/with-suspense/dynamic-not-found/page.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/with-suspense/forbidden/page.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/with-suspense/layout.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/with-suspense/not-found.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/with-suspense/not-found/page.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/with-suspense/permanent-redirect/page.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/with-suspense/redirect/page.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/with-suspense/unauthorized/page.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/without-suspense/forbidden/page.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/without-suspense/not-found/page.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/without-suspense/permanent-redirect/page.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/without-suspense/redirect/page.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/app/without-suspense/unauthorized/page.tsx
create mode 100644 test/e2e/prerendered-http-status-codes/index.test.ts
create mode 100644 test/e2e/prerendered-http-status-codes/next.config.js
diff --git a/packages/next/src/server/app-render/app-render.tsx b/packages/next/src/server/app-render/app-render.tsx
index 81bd6b2b7475..e6b3684af2b5 100644
--- a/packages/next/src/server/app-render/app-render.tsx
+++ b/packages/next/src/server/app-render/app-render.tsx
@@ -9062,7 +9062,7 @@ async function prerenderToStream(
}
}
const allCapturedErrors: Array = []
- const htmlRendererErrorHandler = createHTMLErrorHandler(
+ const captureHTMLError = createHTMLErrorHandler(
process.env.NODE_ENV === 'development',
isBuildTimePrerendering,
ctx.renderOpts.experimental.reactBrowserBailout,
@@ -9101,6 +9101,47 @@ async function prerenderToStream(
let prerenderStore: PrerenderStore | null = null
+ let capturedHTTPErrorType: 'access-fallback' | 'redirect' | undefined
+
+ // Redirects take precedence over access fallbacks. Within each category, the
+ // first error wins. Always return the current error's type, even if it does
+ // not change the response, so the recovery catch can recognize HTTP errors.
+ function setHTTPAccessFallbackOrRedirectStatus(
+ err: unknown
+ ): MetadataErrorType | 'redirect' | undefined {
+ if (isHTTPAccessFallbackError(err)) {
+ const statusCode = getAccessFallbackHTTPStatus(err)
+ if (capturedHTTPErrorType === undefined) {
+ capturedHTTPErrorType = 'access-fallback'
+ res.statusCode = statusCode
+ metadata.statusCode = statusCode
+ }
+ return getAccessFallbackErrorTypeByStatus(statusCode)
+ } else if (isRedirectError(err)) {
+ if (capturedHTTPErrorType !== 'redirect') {
+ capturedHTTPErrorType = 'redirect'
+ res.statusCode = getRedirectStatusCodeFromError(err)
+ metadata.statusCode = res.statusCode
+ setHeader(
+ 'location',
+ addPathPrefix(getURLFromRedirectError(err), basePath)
+ )
+ }
+ return 'redirect'
+ }
+ }
+
+ // React can complete a prerender after an HTTP access fallback or redirect
+ // error is thrown inside a Suspense boundary. Update the response while
+ // preserving the prerendered content outside the boundary.
+ const htmlRendererErrorHandler: typeof captureHTMLError = (
+ err,
+ errorInfo
+ ) => {
+ setHTTPAccessFallbackOrRedirectStatus(err)
+ return captureHTMLError(err, errorInfo)
+ }
+
try {
if (cacheComponents) {
const partialPrefetching =
@@ -10323,34 +10364,19 @@ async function prerenderToStream(
)
}
- let errorType: MetadataErrorType | 'redirect' | undefined
- const isHTTPAccessFallback = isHTTPAccessFallbackError(err)
- const isRedirect = isRedirectError(err)
+ const errorType = setHTTPAccessFallbackOrRedirectStatus(err)
- if (isHTTPAccessFallback) {
- res.statusCode = getAccessFallbackHTTPStatus(err)
- metadata.statusCode = res.statusCode
- errorType = getAccessFallbackErrorTypeByStatus(res.statusCode)
- } else if (isRedirect) {
- errorType = 'redirect'
- res.statusCode = getRedirectStatusCodeFromError(err)
- metadata.statusCode = res.statusCode
-
- const redirectUrl = addPathPrefix(getURLFromRedirectError(err), basePath)
-
- setHeader('location', redirectUrl)
- } else {
+ if (errorType === undefined) {
res.statusCode = 500
metadata.statusCode = res.statusCode
- }
- if (
- cacheComponents &&
- !isHTTPAccessFallback &&
- !isRedirect &&
- (isBuildTimePrerendering || reactServerPrerenderResultIsDynamic === null)
- ) {
- throw reactServerErrorsByDigest.get((err as any)?.digest) ?? err
+ if (
+ cacheComponents &&
+ (isBuildTimePrerendering ||
+ reactServerPrerenderResultIsDynamic === null)
+ ) {
+ throw reactServerErrorsByDigest.get((err as any)?.digest) ?? err
+ }
}
const [errorPreinitScripts, errorBootstrapScript] = getRequiredScripts(
@@ -10636,10 +10662,7 @@ async function prerenderToStream(
originalFlightPrerenderResult.consume()
errorServerResult.consume()
return {
- error:
- isHTTPAccessFallback || isRedirect
- ? undefined
- : { thrownValue: err },
+ error: errorType !== undefined ? undefined : { thrownValue: err },
digestErrorsMap: reactServerErrorsByDigest,
ssrErrors: allCapturedErrors,
stream: await continueDynamicPrerender(errorHtmlStream, {
@@ -10712,10 +10735,7 @@ async function prerenderToStream(
errorServerResult.consume()
return {
- error:
- isHTTPAccessFallback || isRedirect
- ? undefined
- : { thrownValue: err },
+ error: errorType !== undefined ? undefined : { thrownValue: err },
digestErrorsMap: reactServerErrorsByDigest,
ssrErrors: allCapturedErrors,
stream,
diff --git a/test/e2e/app-dir/on-demand-prerender-error-boundary/on-demand-prerender-error-boundary.test.ts b/test/e2e/app-dir/on-demand-prerender-error-boundary/on-demand-prerender-error-boundary.test.ts
index a748afb9c83c..5bab035f4d9d 100644
--- a/test/e2e/app-dir/on-demand-prerender-error-boundary/on-demand-prerender-error-boundary.test.ts
+++ b/test/e2e/app-dir/on-demand-prerender-error-boundary/on-demand-prerender-error-boundary.test.ts
@@ -249,7 +249,7 @@ describe('on-demand-prerender-error-boundary', () => {
['healthy', 200, 'Healthy page'],
['suspense-error', 500, 'Partial prerender error boundary'],
['error', 500, 'Partial prerender error boundary'],
- ['suspense-missing', 200, 'Partial prerender not-found boundary'],
+ ['suspense-missing', 404, 'Partial prerender not-found boundary'],
['missing', 404, 'Partial prerender not-found boundary'],
] as const) {
it(`resumes ${slug} with the current request outside the page boundary`, async () => {
diff --git a/test/e2e/prerendered-http-status-codes/app/layout.tsx b/test/e2e/prerendered-http-status-codes/app/layout.tsx
new file mode 100644
index 000000000000..c7295294439d
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/layout.tsx
@@ -0,0 +1,7 @@
+export default function Layout({ children }: { children: React.ReactNode }) {
+ return (
+
+ {children}
+
+ )
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/not-found.tsx b/test/e2e/prerendered-http-status-codes/app/not-found.tsx
new file mode 100644
index 000000000000..10d2c5540148
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/not-found.tsx
@@ -0,0 +1,3 @@
+export default function NotFound() {
+ return This page could not be found.
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/precedence/[first]/[second]/[boundary]/page.tsx b/test/e2e/prerendered-http-status-codes/app/precedence/[first]/[second]/[boundary]/page.tsx
new file mode 100644
index 000000000000..08c1fd168a85
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/precedence/[first]/[second]/[boundary]/page.tsx
@@ -0,0 +1,29 @@
+import { HTTPErrorPair } from '../../../http-error'
+
+export function generateStaticParams() {
+ const errors = [
+ 'not-found',
+ 'unauthorized',
+ 'forbidden',
+ 'redirect',
+ 'permanent-redirect',
+ ]
+ return errors.flatMap((first) =>
+ errors.flatMap((second) =>
+ ['suspense', 'root'].map((boundary) => ({ first, second, boundary }))
+ )
+ )
+}
+
+export default async function Page({
+ params,
+}: {
+ params: Promise<{
+ first: string
+ second: string
+ boundary: string
+ }>
+}) {
+ const { first, second, boundary } = await params
+ return
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/precedence/http-error.tsx b/test/e2e/prerendered-http-status-codes/app/precedence/http-error.tsx
new file mode 100644
index 000000000000..a8ef0b16cf11
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/precedence/http-error.tsx
@@ -0,0 +1,77 @@
+'use client'
+
+import { Suspense, use } from 'react'
+import {
+ forbidden,
+ notFound,
+ permanentRedirect,
+ redirect,
+ unauthorized,
+} from 'next/navigation'
+
+function throwHTTPError(type: string, destination: string) {
+ switch (type) {
+ case 'not-found':
+ return notFound()
+ case 'unauthorized':
+ return unauthorized()
+ case 'forbidden':
+ return forbidden()
+ case 'redirect':
+ return redirect(destination)
+ case 'permanent-redirect':
+ return permanentRedirect(destination)
+ default:
+ throw new Error(`Unknown HTTP error type: ${type}`)
+ }
+}
+
+function FirstError({ type, onError }: { type: string; onError: () => void }) {
+ try {
+ return throwHTTPError(type, '/first')
+ } finally {
+ onError()
+ }
+}
+
+function SecondError({ type, after }: { type: string; after: Promise }) {
+ use(after)
+ return throwHTTPError(type, '/second')
+}
+
+export function HTTPErrorPair({
+ first,
+ second,
+ boundary,
+}: {
+ first: string
+ second: string
+ boundary: string
+}) {
+ let resolveFirstError: () => void
+ const firstError = new Promise((resolve) => {
+ resolveFirstError = resolve
+ })
+ // Prerendering can defer Suspense children until after the shell. Wait for
+ // the first error before rendering the second, even when it is in the shell.
+ // The promise belongs to this render, so routes and prerender passes do not
+ // share state. Its continuation runs after React handles the first error.
+ const secondError =
+
+ return (
+ <>
+ HTTP error precedence
+ First fallback
}>
+ resolveFirstError()} />
+
+ {boundary === 'suspense' ? (
+ Second fallback}>
+ {secondError}
+
+ ) : (
+ // Exercise the recovery catch as well as the HTML error callback.
+ secondError
+ )}
+ >
+ )
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/with-suspense/dynamic-not-found/page.tsx b/test/e2e/prerendered-http-status-codes/app/with-suspense/dynamic-not-found/page.tsx
new file mode 100644
index 000000000000..4f49a0306e94
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/with-suspense/dynamic-not-found/page.tsx
@@ -0,0 +1,7 @@
+import { notFound } from 'next/navigation'
+import { connection } from 'next/server'
+
+export default async function Page() {
+ await connection()
+ return notFound()
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/with-suspense/forbidden/page.tsx b/test/e2e/prerendered-http-status-codes/app/with-suspense/forbidden/page.tsx
new file mode 100644
index 000000000000..44e9d5125be5
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/with-suspense/forbidden/page.tsx
@@ -0,0 +1,5 @@
+import { forbidden } from 'next/navigation'
+
+export default async function Page() {
+ return forbidden()
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/with-suspense/layout.tsx b/test/e2e/prerendered-http-status-codes/app/with-suspense/layout.tsx
new file mode 100644
index 000000000000..c7ba4f6b0472
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/with-suspense/layout.tsx
@@ -0,0 +1,12 @@
+import { Suspense } from 'react'
+
+export default function Layout({ children }: { children: React.ReactNode }) {
+ return (
+ <>
+ Shared layout
+ Loading...}>
+ {children}
+
+ >
+ )
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/with-suspense/not-found.tsx b/test/e2e/prerendered-http-status-codes/app/with-suspense/not-found.tsx
new file mode 100644
index 000000000000..c84212429120
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/with-suspense/not-found.tsx
@@ -0,0 +1 @@
+export { default } from '../not-found'
diff --git a/test/e2e/prerendered-http-status-codes/app/with-suspense/not-found/page.tsx b/test/e2e/prerendered-http-status-codes/app/with-suspense/not-found/page.tsx
new file mode 100644
index 000000000000..d46715b608a9
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/with-suspense/not-found/page.tsx
@@ -0,0 +1,5 @@
+import { notFound } from 'next/navigation'
+
+export default async function Page() {
+ return notFound()
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/with-suspense/permanent-redirect/page.tsx b/test/e2e/prerendered-http-status-codes/app/with-suspense/permanent-redirect/page.tsx
new file mode 100644
index 000000000000..d3ae176d201c
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/with-suspense/permanent-redirect/page.tsx
@@ -0,0 +1,5 @@
+import { permanentRedirect } from 'next/navigation'
+
+export default async function Page() {
+ return permanentRedirect('/')
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/with-suspense/redirect/page.tsx b/test/e2e/prerendered-http-status-codes/app/with-suspense/redirect/page.tsx
new file mode 100644
index 000000000000..49166697ee09
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/with-suspense/redirect/page.tsx
@@ -0,0 +1,5 @@
+import { redirect } from 'next/navigation'
+
+export default async function Page() {
+ return redirect('/')
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/with-suspense/unauthorized/page.tsx b/test/e2e/prerendered-http-status-codes/app/with-suspense/unauthorized/page.tsx
new file mode 100644
index 000000000000..912addd1d8ca
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/with-suspense/unauthorized/page.tsx
@@ -0,0 +1,5 @@
+import { unauthorized } from 'next/navigation'
+
+export default async function Page() {
+ return unauthorized()
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/without-suspense/forbidden/page.tsx b/test/e2e/prerendered-http-status-codes/app/without-suspense/forbidden/page.tsx
new file mode 100644
index 000000000000..44e9d5125be5
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/without-suspense/forbidden/page.tsx
@@ -0,0 +1,5 @@
+import { forbidden } from 'next/navigation'
+
+export default async function Page() {
+ return forbidden()
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/without-suspense/not-found/page.tsx b/test/e2e/prerendered-http-status-codes/app/without-suspense/not-found/page.tsx
new file mode 100644
index 000000000000..d46715b608a9
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/without-suspense/not-found/page.tsx
@@ -0,0 +1,5 @@
+import { notFound } from 'next/navigation'
+
+export default async function Page() {
+ return notFound()
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/without-suspense/permanent-redirect/page.tsx b/test/e2e/prerendered-http-status-codes/app/without-suspense/permanent-redirect/page.tsx
new file mode 100644
index 000000000000..d3ae176d201c
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/without-suspense/permanent-redirect/page.tsx
@@ -0,0 +1,5 @@
+import { permanentRedirect } from 'next/navigation'
+
+export default async function Page() {
+ return permanentRedirect('/')
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/without-suspense/redirect/page.tsx b/test/e2e/prerendered-http-status-codes/app/without-suspense/redirect/page.tsx
new file mode 100644
index 000000000000..49166697ee09
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/without-suspense/redirect/page.tsx
@@ -0,0 +1,5 @@
+import { redirect } from 'next/navigation'
+
+export default async function Page() {
+ return redirect('/')
+}
diff --git a/test/e2e/prerendered-http-status-codes/app/without-suspense/unauthorized/page.tsx b/test/e2e/prerendered-http-status-codes/app/without-suspense/unauthorized/page.tsx
new file mode 100644
index 000000000000..912addd1d8ca
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/app/without-suspense/unauthorized/page.tsx
@@ -0,0 +1,5 @@
+import { unauthorized } from 'next/navigation'
+
+export default async function Page() {
+ return unauthorized()
+}
diff --git a/test/e2e/prerendered-http-status-codes/index.test.ts b/test/e2e/prerendered-http-status-codes/index.test.ts
new file mode 100644
index 000000000000..9a80965c36b6
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/index.test.ts
@@ -0,0 +1,150 @@
+import { nextTestSetup } from 'e2e-utils'
+import { load } from 'cheerio'
+
+// These status assertions require production prerendering. In dev, pages are
+// rendered on request and Suspense may stream a 200 before an HTTP error occurs.
+// @force-gate !dev
+describe('prerendered-http-status-codes', () => {
+ const { next } = nextTestSetup({
+ files: __dirname,
+ })
+
+ it('returns 200 when notFound() runs after connection() inside Suspense, then shows the not-found UI', async () => {
+ const { browser, response } = await next.browserWithResponse(
+ '/with-suspense/dynamic-not-found'
+ )
+ try {
+ expect(response.status()).toBe(200)
+ expect(await browser.elementByCss('#not-found').text()).toBe(
+ 'This page could not be found.'
+ )
+ } finally {
+ await browser.close()
+ }
+ })
+
+ describe.each(['suspense', 'root'])(
+ 'HTTP error precedence with the second error caught at %s',
+ (boundary) => {
+ async function expectResponse(
+ first: string,
+ second: string,
+ status: number,
+ location: string | null = null
+ ) {
+ const response = await next.fetch(
+ `/precedence/${first}/${second}/${boundary}`,
+ {
+ headers: { Accept: 'text/html' },
+ redirect: 'manual',
+ }
+ )
+
+ expect(response.status).toBe(status)
+ expect(response.headers.get('location')).toBe(location)
+ expect(response.headers.get('content-type')).toContain('text/html')
+ if (boundary === 'suspense') {
+ const $ = load(await response.text())
+ expect($('#precedence-layout').text()).toBe('HTTP error precedence')
+ expect($('#first-fallback').text()).toBe('First fallback')
+ expect($('#second-fallback').text()).toBe('Second fallback')
+ }
+ }
+
+ it.each([
+ ['not-found', 'unauthorized', 404],
+ ['not-found', 'forbidden', 404],
+ ['unauthorized', 'not-found', 401],
+ ['unauthorized', 'forbidden', 401],
+ ['forbidden', 'not-found', 403],
+ ['forbidden', 'unauthorized', 403],
+ ])('keeps the first access fallback: %s before %s', expectResponse)
+
+ describe.each([
+ { redirect: 'redirect', status: 307 },
+ { redirect: 'permanent-redirect', status: 308 },
+ ])('$redirect', ({ redirect, status }) => {
+ it.each(['not-found', 'unauthorized', 'forbidden'])(
+ 'overrides an earlier %s',
+ async (fallback) => {
+ await expectResponse(fallback, redirect, status, '/second')
+ }
+ )
+
+ it.each(['not-found', 'unauthorized', 'forbidden'])(
+ 'takes precedence over a later %s',
+ async (fallback) => {
+ await expectResponse(redirect, fallback, status, '/first')
+ }
+ )
+
+ it.each(['redirect', 'permanent-redirect'])(
+ 'keeps its status and location when followed by %s',
+ async (second) => {
+ await expectResponse(redirect, second, status, '/first')
+ }
+ )
+ })
+ }
+ )
+
+ describe.each(['with-suspense', 'without-suspense'])('%s', (variant) => {
+ it.each([
+ { route: 'unauthorized', status: 401 },
+ { route: 'forbidden', status: 403 },
+ { route: 'not-found', status: 404 },
+ ])(
+ 'returns $status for the $route HTML response',
+ async ({ route, status }) => {
+ const response = await next.fetch(`/${variant}/${route}`, {
+ headers: { Accept: 'text/html' },
+ })
+
+ expect(response.headers.get('content-type')).toContain('text/html')
+ expect(response.status).toBe(status)
+ if (variant === 'with-suspense') {
+ const $ = load(await response.text())
+ expect($('#layout').text()).toBe('Shared layout')
+ expect($('#suspense-fallback').text()).toBe('Loading...')
+ }
+ }
+ )
+
+ it('shows the custom not-found UI in the browser', async () => {
+ const browser = await next.browser(`/${variant}/not-found`)
+ try {
+ expect(await browser.elementByCss('#not-found').text()).toBe(
+ 'This page could not be found.'
+ )
+ if (variant === 'with-suspense') {
+ expect(await browser.elementByCss('#layout').text()).toBe(
+ 'Shared layout'
+ )
+ expect(
+ await browser.hasElementByCssSelector('#suspense-fallback')
+ ).toBe(false)
+ }
+ } finally {
+ await browser.close()
+ }
+ })
+
+ it.each([
+ { route: 'redirect', status: 307 },
+ { route: 'permanent-redirect', status: 308 },
+ ])('returns $status and location for $route', async ({ route, status }) => {
+ const response = await next.fetch(`/${variant}/${route}`, {
+ headers: { Accept: 'text/html' },
+ redirect: 'manual',
+ })
+
+ expect(response.status).toBe(status)
+ expect(response.headers.get('location')).toBe('/')
+ if (variant === 'with-suspense') {
+ const $ = load(await response.text())
+ expect($('#layout').text()).toBe('Shared layout')
+ expect($('#suspense-fallback').text()).toBe('Loading...')
+ }
+ })
+ })
+})
diff --git a/test/e2e/prerendered-http-status-codes/next.config.js b/test/e2e/prerendered-http-status-codes/next.config.js
new file mode 100644
index 000000000000..4d92a15c171c
--- /dev/null
+++ b/test/e2e/prerendered-http-status-codes/next.config.js
@@ -0,0 +1,6 @@
+/** @type {import('next').NextConfig} */
+module.exports = {
+ experimental: {
+ authInterrupts: true,
+ },
+}
From bc8bf60a350071dc192c454674eab3574db8b50c Mon Sep 17 00:00:00 2001
From: Josh Story
Date: Tue, 29 Sep 2026 07:52:47 -0700
Subject: [PATCH 3/3] Scope client component loading metrics to HTML renders
(#99322)
## Summary
To measure how client component loading affects HTML render performance,
replace telemetry based on process-global counters and incoming
request-body completion. Those boundaries mixed overlapping renders and
measured a lifecycle unrelated to HTML production.
Scope the counters and reporting context to each HTML-producing render.
Start tracking before SSR, finish dynamic measurements at React
readiness (Node `onAllReady` / Web `allReady`), and finish prerendering
when the prerender operation returns. Preparation, action execution, and
dedicated Flight rendering do not start tracking. DATA-only resumes
finish tracking locally without waiting for output; an empty tracker
emits no span. HTML rendered after a form action is still measured.
Already-started loads may settle and report afterward without keeping
the response open. Preserve the first-write performance snapshot, but
remove metrics stream wrapping and binding. This advances the larger
effort to remove req/res lifecycle assumptions from App Router rendering
without adding telemetry to `after()`.
Behavioral tests cover overlapping renders in both completion orders,
HTML after a form POST, enhanced actions that only produce Flight, and
HTML readiness while unused Flight content remains blocked.
## Verification
- Confirmed both new boundary regressions failed before the runtime
change.
- Five behavioral metrics cases pass in development and production with
both Turbopack and Webpack.
- Full production Turbopack instrumentation suite: 109 passed, 13
existing skips.
- Focused logger/response-piping units: 11 passed. Full repository
build, package/root types, scoped Prettier, ESLint, and diff checks
pass.
- A broader unit run passed 3,065 tests but hit three macOS `/var`
versus `/private/var` assertions in unchanged TypeScript CLI tests.
Existing Node response-disconnect propagation to upstream SSR is
unchanged; this PR does not claim to fix cancellation.
---
.../next/src/server/app-render/app-render.tsx | 315 ++++++++-----
.../app-render/work-async-storage.external.ts | 2 +
.../src/server/async-storage/work-store.ts | 1 +
.../client-component-renderer-logger.test.ts | 392 ++++++++++------
.../client-component-renderer-logger.ts | 177 ++++++--
.../src/server/dev/use-cache-probe-worker.ts | 1 +
.../next/src/server/pipe-readable.test.ts | 105 ++++-
packages/next/src/server/pipe-readable.ts | 21 +-
packages/next/src/server/render-result.ts | 17 +-
.../[param]/client-component-flush/route.ts | 18 +
.../action-only-client.tsx | 5 +
.../[param]/client-component-action/page.tsx | 39 ++
.../async-client.tsx | 7 +
.../initially-closed-panel.tsx | 19 +
.../client-component-html-boundary/page.tsx | 28 ++
.../client-component-loading/early-client.tsx | 5 +
.../extra-late-client.tsx | 5 +
.../client-component-loading/late-client.tsx | 5 +
.../[param]/client-component-loading/page.tsx | 45 ++
.../instrumentation/instrumentation-test.ts | 28 +-
.../instrumentation/opentelemetry.test.ts | 426 ++++++++++++++++--
21 files changed, 1309 insertions(+), 352 deletions(-)
create mode 100644 test/e2e/opentelemetry/instrumentation/app/api/app/[param]/client-component-flush/route.ts
create mode 100644 test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-action/action-only-client.tsx
create mode 100644 test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-action/page.tsx
create mode 100644 test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-html-boundary/async-client.tsx
create mode 100644 test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-html-boundary/initially-closed-panel.tsx
create mode 100644 test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-html-boundary/page.tsx
create mode 100644 test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/early-client.tsx
create mode 100644 test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/extra-late-client.tsx
create mode 100644 test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/late-client.tsx
create mode 100644 test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/page.tsx
diff --git a/packages/next/src/server/app-render/app-render.tsx b/packages/next/src/server/app-render/app-render.tsx
index e6b3684af2b5..9b0a4749f54b 100644
--- a/packages/next/src/server/app-render/app-render.tsx
+++ b/packages/next/src/server/app-render/app-render.tsx
@@ -213,7 +213,7 @@ import {
} from './dynamic-rendering'
import { logBuildDebugHint } from './blocking-route-messages'
import {
- getClientComponentLoaderMetrics,
+ ClientComponentLoadTracker,
wrapClientComponentLoader,
} from '../client-component-renderer-logger'
import { isNodeNextRequest, isNodeNextResponse } from '../base-http/helpers'
@@ -2590,7 +2590,7 @@ export type BinaryStreamOf = AnyStream
/**
* Extracted to a separate function to prevent V8 from retaining the entire
- * `prepareAppPageRender` closure scope through globalThis.__next_require__.
+ * the render initialization scope through globalThis.__next_require__.
* V8 shares a single Context object per scope for all closures; by creating
* these closures in their own function scope, the globalThis references only
* retain `instrumented` and `cacheComponents`, not request-specific data like
@@ -2598,10 +2598,9 @@ export type BinaryStreamOf = AnyStream
*/
function installGlobalModuleLoadingHandlers(
ComponentMod: AppPageModule,
- cacheComponents: boolean,
- isTracingEnabled: boolean
+ cacheComponents: boolean
) {
- const instrumented = wrapClientComponentLoader(ComponentMod, isTracingEnabled)
+ const instrumented = wrapClientComponentLoader(ComponentMod)
// When we are prerendering if there is a cacheSignal for tracking
// cache reads we track calls to `loadChunk` and `require`. This allows us
@@ -2686,6 +2685,55 @@ const generatePrerenderRequestId: GenerateRequestId = async (req) => {
).toString('hex')
}
+function initializeClientComponentLoadTracking(
+ renderOpts: RenderOpts,
+ workStore: WorkStore
+): ClientComponentLoadTracker | undefined {
+ if (!renderOpts.ComponentMod.__next_app__) return undefined
+
+ // Capture the request's span before the HTML render creates its own span.
+ const parentSpan = getTracer().getActiveScopeSpan()
+ const isTracingEnabled = parentSpan?.isRecording() ?? false
+
+ let tracker: ClientComponentLoadTracker | undefined
+ if (
+ 'performance' in globalThis &&
+ (process.env.NEXT_OTEL_PERFORMANCE_PREFIX || isTracingEnabled)
+ ) {
+ tracker = new ClientComponentLoadTracker((metrics) => {
+ if (
+ process.env.NEXT_RUNTIME !== 'edge' &&
+ isTracingEnabled &&
+ metrics &&
+ metrics.clientComponentLoadEnd >= metrics.clientComponentLoadStart
+ ) {
+ getTracer()
+ .startSpan(NextNodeServerSpan.clientComponentLoading, {
+ parentSpan,
+ startTime: metrics.clientComponentLoadStart,
+ attributes: {
+ 'next.clientComponentLoadCount': metrics.clientComponentLoadCount,
+ 'next.span_type': NextNodeServerSpan.clientComponentLoading,
+ },
+ })
+ .end(metrics.clientComponentLoadEnd)
+ }
+ })
+ workStore.clientComponentLoadTracker = tracker
+ }
+ return tracker
+}
+
+function finishClientComponentLoadTrackingOnReady(
+ tracker: ClientComponentLoadTracker | undefined,
+ allReady: Promise
+) {
+ if (tracker) {
+ const finish = () => tracker.finish()
+ void allReady.then(finish, finish)
+ }
+}
+
async function prepareAppPageRender(
req: BaseNextRequest,
res: BaseNextResponse,
@@ -2723,18 +2771,6 @@ async function prepareAppPageRender(
setIsrStatus,
} = renderOpts
- // We need to expose the bundled `require` API globally for
- // react-server-dom-webpack. This is a hack until we find a better way.
- if (ComponentMod.__next_app__) {
- const isTracingEnabled =
- getTracer().getActiveScopeSpan()?.isRecording() ?? false
- installGlobalModuleLoadingHandlers(
- ComponentMod,
- cacheComponents,
- isTracingEnabled
- )
- }
-
if (process.env.__NEXT_DEV_SERVER && setIsrStatus && !cacheComponents) {
// Reset the ISR status at start of request.
const { pathname } = new URL(req.url || '/', 'http://n')
@@ -2756,27 +2792,6 @@ async function prepareAppPageRender(
// report them at that time.
workStore.shouldTrackFetchMetrics = false
})
-
- req.originalRequest.on('end', () => {
- if ('performance' in globalThis) {
- const metrics = getClientComponentLoaderMetrics({ reset: true })
- if (
- metrics &&
- metrics.clientComponentLoadEnd >= metrics.clientComponentLoadStart
- ) {
- getTracer()
- .startSpan(NextNodeServerSpan.clientComponentLoading, {
- startTime: metrics.clientComponentLoadStart,
- attributes: {
- 'next.clientComponentLoadCount':
- metrics.clientComponentLoadCount,
- 'next.span_type': NextNodeServerSpan.clientComponentLoading,
- },
- })
- .end(metrics.clientComponentLoadEnd)
- }
- }
- })
}
const metadata: AppPageRenderResultMetadata = {
@@ -2914,14 +2929,21 @@ async function prerenderAppPage({
prerenderToStream
)
- const response = await prerenderToStreamWithTracing(
- req,
- res,
- ctx,
- metadata,
- loaderTree,
- fallbackRouteParams
- )
+ const tracker = initializeClientComponentLoadTracking(renderOpts, workStore)
+ metadata.clientComponentLoadTracker = tracker
+ let response: PrerenderToStreamResult
+ try {
+ response = await prerenderToStreamWithTracing(
+ req,
+ res,
+ ctx,
+ metadata,
+ loaderTree,
+ fallbackRouteParams
+ )
+ } finally {
+ tracker?.finish()
+ }
// If we're debugging partial prerendering, print all the dynamic API accesses
// that occurred during the render.
@@ -3145,7 +3167,12 @@ async function renderAppPage(
)
} else {
// MARK: RSC dynamic
- return generateDynamicFlightRenderResult(req, ctx, requestStore)
+ return generateDynamicFlightRenderResult(
+ req,
+ ctx,
+ requestStore,
+ undefined
+ )
}
}
}
@@ -3171,23 +3198,35 @@ async function renderAppPage(
const notFoundLoaderTree = createNotFoundLoaderTree(loaderTree)
res.statusCode = 404
metadata.statusCode = 404
- const stream = await renderToStream(
- requestStore,
- req,
- res,
- ctx,
- notFoundLoaderTree,
- formState,
- postponedState,
- metadata,
- undefined, // Prevent restartable-render behavior in dev + Cache Components mode
- stagedFallbackParams
+ const tracker = initializeClientComponentLoadTracking(
+ renderOpts,
+ workStore
)
+ metadata.clientComponentLoadTracker = tracker
+ try {
+ const stream = await renderToStream(
+ requestStore,
+ req,
+ res,
+ ctx,
+ notFoundLoaderTree,
+ formState,
+ postponedState,
+ metadata,
+ undefined, // Prevent restartable-render behavior in dev + Cache Components mode
+ stagedFallbackParams,
+ tracker
+ )
- return new RenderResult(stream, {
- metadata,
- contentType: HTML_CONTENT_TYPE_HEADER,
- })
+ return new RenderResult(stream, {
+ metadata,
+ contentType: HTML_CONTENT_TYPE_HEADER,
+ })
+ } catch (renderError) {
+ // Failed setup may never reach the SSR readiness callback.
+ tracker?.finish()
+ throw renderError
+ }
} else if (actionRequestResult.type === 'done') {
if (actionRequestResult.result) {
actionRequestResult.result.assignMetadata(metadata)
@@ -3206,66 +3245,76 @@ async function renderAppPage(
contentType: HTML_CONTENT_TYPE_HEADER,
}
- const stream = await renderToStream(
- // NOTE: in Cache Components (dev), if the render is restarted, it will use a different requestStore
- // than the one that we're passing in here.
- requestStore,
- req,
- res,
- ctx,
- loaderTree,
- formState,
- postponedState,
- metadata,
- // If we're rendering HTML after an action, we don't want restartable-render behavior
- // because the result should be dynamic, like it is in prod.
- // Also, the request store might have been mutated by the action (e.g. enabling draftMode)
- // and we currently we don't copy changes over when creating a new store,
- // so the restarted render wouldn't be correct.
- didExecuteServerAction ? undefined : createRequestStore,
- stagedFallbackParams
- )
-
- // Forward an invalid-dynamic-usage error recorded by `'use cache'` only
- // when userland caught it (try/catch around the cache call). If userland
- // didn't catch, the rejection propagated into the React render, and React's
- // `serverComponentsErrorHandler` already stamped a digest on the error and
- // emitted it as a Flight error chunk — surfacing it again here would
- // duplicate the entry in the dev overlay.
- //
- // The cacheComponents paths forward this themselves via
- // `runValidationInDev` and the validation-skipped fallback in
- // `generateDynamicFlightRenderResultWithStagesInDev`. Here we cover the
- // non-cacheComponents dev path where neither runs.
- if (
- process.env.__NEXT_DEV_SERVER &&
- !cacheComponents &&
- workStore.invalidDynamicUsageError &&
- !(workStore.invalidDynamicUsageError as { digest?: unknown }).digest
- ) {
- void logMessagesAndSendErrorsToBrowser(
- [workStore.invalidDynamicUsageError],
- ctx
+ const tracker = initializeClientComponentLoadTracking(renderOpts, workStore)
+ metadata.clientComponentLoadTracker = tracker
+ try {
+ const stream = await renderToStream(
+ // NOTE: in Cache Components (dev), if the render is restarted, it will use a different requestStore
+ // than the one that we're passing in here.
+ requestStore,
+ req,
+ res,
+ ctx,
+ loaderTree,
+ formState,
+ postponedState,
+ metadata,
+ // If we're rendering HTML after an action, we don't want restartable-render behavior
+ // because the result should be dynamic, like it is in prod.
+ // Also, the request store might have been mutated by the action (e.g. enabling draftMode)
+ // and we currently we don't copy changes over when creating a new store,
+ // so the restarted render wouldn't be correct.
+ didExecuteServerAction ? undefined : createRequestStore,
+ stagedFallbackParams,
+ tracker
)
- }
- // If we have pending revalidates, wait until they are all resolved.
- const maybeRevalidatesPromise = executeRevalidates(workStore)
- if (maybeRevalidatesPromise !== false) {
- const revalidatesPromise = maybeRevalidatesPromise.finally(() => {
- if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
- console.log('pending revalidates promise finished for:', url.href)
+ // Forward an invalid-dynamic-usage error recorded by `'use cache'` only
+ // when userland caught it (try/catch around the cache call). If userland
+ // didn't catch, the rejection propagated into the React render, and React's
+ // `serverComponentsErrorHandler` already stamped a digest on the error and
+ // emitted it as a Flight error chunk — surfacing it again here would
+ // duplicate the entry in the dev overlay.
+ //
+ // The cacheComponents paths forward this themselves via
+ // `runValidationInDev` and the validation-skipped fallback in
+ // `generateDynamicFlightRenderResultWithStagesInDev`. Here we cover the
+ // non-cacheComponents dev path where neither runs.
+ if (
+ process.env.__NEXT_DEV_SERVER &&
+ !cacheComponents &&
+ workStore.invalidDynamicUsageError &&
+ !(workStore.invalidDynamicUsageError as { digest?: unknown }).digest
+ ) {
+ void logMessagesAndSendErrorsToBrowser(
+ [workStore.invalidDynamicUsageError],
+ ctx
+ )
+ }
+
+ // If we have pending revalidates, wait until they are all resolved.
+ const maybeRevalidatesPromise = executeRevalidates(workStore)
+ if (maybeRevalidatesPromise !== false) {
+ const revalidatesPromise = maybeRevalidatesPromise.finally(() => {
+ if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
+ console.log('pending revalidates promise finished for:', url.href)
+ }
+ })
+ if (renderOpts.waitUntil) {
+ renderOpts.waitUntil(revalidatesPromise)
+ } else {
+ options.waitUntil = revalidatesPromise
}
- })
- if (renderOpts.waitUntil) {
- renderOpts.waitUntil(revalidatesPromise)
- } else {
- options.waitUntil = revalidatesPromise
}
- }
- // Create the new render result for the response.
- return new RenderResult(stream, options)
+ // Create the new render result for the response.
+ return new RenderResult(stream, options)
+ } catch (renderError) {
+ // Returning a stream may precede SSR readiness, which finishes success.
+ // Only failures finish here; a finally would seal successful renders early.
+ tracker?.finish()
+ throw renderError
+ }
}
async function renderToHTMLOrFlightImpl(
@@ -3284,6 +3333,12 @@ async function renderToHTMLOrFlightImpl(
fallbackRouteParams: OpaqueFallbackRouteParams | null,
routeMatch: RouteMatch
) {
+ if (renderOpts.ComponentMod.__next_app__) {
+ installGlobalModuleLoadingHandlers(
+ renderOpts.ComponentMod,
+ renderOpts.cacheComponents
+ )
+ }
const prepared = await prepareAppPageRender(
req,
res,
@@ -3325,6 +3380,12 @@ async function prerenderToHTMLOrFlightImpl(
fallbackRouteParams: OpaqueFallbackRouteParams | null,
routeMatch: RouteMatch
) {
+ if (renderOpts.ComponentMod.__next_app__) {
+ installGlobalModuleLoadingHandlers(
+ renderOpts.ComponentMod,
+ renderOpts.cacheComponents
+ )
+ }
const isRoutePPREnabled = renderOpts.experimental.isRoutePPREnabled === true
const prepared = await prepareAppPageRender(
req,
@@ -3611,7 +3672,8 @@ async function renderToStream(
postponedState: PostponedState | null,
metadata: AppPageRenderResultMetadata,
createRequestStore: (() => RequestStore) | undefined,
- stagedFallbackParams: OpaqueFallbackRouteParams | null
+ stagedFallbackParams: OpaqueFallbackRouteParams | null,
+ tracker: ClientComponentLoadTracker | undefined
): Promise {
/* eslint-disable @next/internal/no-ambiguous-jsx -- React Client */
// MARK: renderToStream setup
@@ -4188,6 +4250,7 @@ async function renderToStream(
// End the span since there's no async rendering in this path
if (renderSpan.isRecording()) renderSpan.end()
+ tracker?.finish()
return chainStreams(
inlinedDataStream,
createDocumentClosingStream()
@@ -4223,7 +4286,11 @@ async function renderToStream(
resumeToFizzStream,
resumeAppElement,
postponed,
- { onError: htmlRendererErrorHandler, nonce }
+ {
+ onError: htmlRendererErrorHandler,
+ onAllReady: tracker ? () => tracker.finish() : undefined,
+ nonce,
+ }
)
// End the render span only after React completed rendering (including anything inside Suspense boundaries)
@@ -4270,6 +4337,7 @@ async function renderToStream(
const fizzOptions = {
onError: htmlRendererErrorHandler,
+ onAllReady: tracker ? () => tracker.finish() : undefined,
nonce,
onHeaders: (headers: { [header: string]: string }) => {
for (const key in headers) {
@@ -4329,6 +4397,7 @@ async function renderToStream(
// End the span since there's no async rendering in this path
if (renderSpan.isRecording()) renderSpan.end()
+ tracker?.finish()
return chainStreams(
inlinedDataStream,
createDocumentClosingStream()
@@ -4371,6 +4440,7 @@ async function renderToStream(
allReady.finally(() => {
if (renderSpan.isRecording()) renderSpan.end()
})
+ finishClientComponentLoadTrackingOnReady(tracker, allReady)
return await continueDynamicHTMLResumeWeb(htmlStream, {
delayDataUntilFirstHtmlChunk:
@@ -4433,6 +4503,7 @@ async function renderToStream(
allReady.finally(() => {
if (renderSpan.isRecording()) renderSpan.end()
})
+ finishClientComponentLoadTrackingOnReady(tracker, allReady)
return await continueFizzStream(htmlStream, {
inlinedDataStream: createWebInlinedDataStream(
@@ -4587,6 +4658,7 @@ async function renderToStream(
bootstrapScriptContent: errorBootstrapScriptContent,
bootstrapScripts: [errorBootstrapScript],
formState,
+ onAllReady: tracker ? () => tracker.finish() : undefined,
},
{ waitForAllReady }
)
@@ -4689,6 +4761,7 @@ async function renderToStream(
errorAllReady.finally(() => {
if (renderSpan.isRecording()) renderSpan.end()
})
+ finishClientComponentLoadTrackingOnReady(tracker, errorAllReady)
return await continueFizzStream(errorHtmlStream, {
inlinedDataStream: createWebInlinedDataStream(
@@ -6814,6 +6887,7 @@ function buildDevValidationWorkStore(
refreshTagsByCacheKind: new Map(),
runInCleanSnapshot: createSnapshot(),
shouldTrackFetchMetrics: false,
+ clientComponentLoadTracker: undefined,
reactServerErrorsByDigest: new Map(),
afterContext: noopAfterContext,
// Dev validation only ever runs under Cache Components.
@@ -6861,7 +6935,7 @@ export async function runValidationInDevFromSnapshot(
// so `react-server-dom-*` can resolve client references during the validation
// prerenders, exactly as the main render does after loading its module.
if (componentMod.__next_app__) {
- installGlobalModuleLoadingHandlers(componentMod, true, false)
+ installGlobalModuleLoadingHandlers(componentMod, true)
}
// `requestFallbackRouteParams` reproduces `ctx.getDynamicParamFromSegment`
@@ -8626,6 +8700,7 @@ async function validateInstantConfigInBuildWithSample(
refreshTagsByCacheKind: new Map(),
runInCleanSnapshot: outerWorkStore.runInCleanSnapshot,
shouldTrackFetchMetrics: false,
+ clientComponentLoadTracker: undefined,
reactServerErrorsByDigest: new Map(),
}
diff --git a/packages/next/src/server/app-render/work-async-storage.external.ts b/packages/next/src/server/app-render/work-async-storage.external.ts
index 218c351334e3..e40abca737f4 100644
--- a/packages/next/src/server/app-render/work-async-storage.external.ts
+++ b/packages/next/src/server/app-render/work-async-storage.external.ts
@@ -13,6 +13,7 @@ import { workAsyncStorageInstance } from './work-async-storage-instance' with {
import type { LazyResult } from '../lib/lazy-result'
import type { DigestedError } from './create-error-handler'
import type { ActionRevalidationKind } from '../../shared/lib/action-revalidation-kind'
+import type { ClientComponentLoadTracker } from '../client-component-renderer-logger'
export interface WorkStore {
/**
@@ -101,6 +102,7 @@ export interface WorkStore {
fetchMetrics?: FetchMetrics
shouldTrackFetchMetrics: boolean
+ clientComponentLoadTracker: ClientComponentLoadTracker | undefined
/**
* Tracks pending `"use cache"` invocations within the current request scope,
diff --git a/packages/next/src/server/async-storage/work-store.ts b/packages/next/src/server/async-storage/work-store.ts
index c6b405609fd0..cc55a395e1d5 100644
--- a/packages/next/src/server/async-storage/work-store.ts
+++ b/packages/next/src/server/async-storage/work-store.ts
@@ -147,6 +147,7 @@ function createWorkStoreImpl(
refreshTagsByCacheKind: createRefreshTagsByCacheKind(),
runInCleanSnapshot: createSnapshot(),
shouldTrackFetchMetrics,
+ clientComponentLoadTracker: undefined,
reactServerErrorsByDigest: new Map(),
}
diff --git a/packages/next/src/server/client-component-renderer-logger.test.ts b/packages/next/src/server/client-component-renderer-logger.test.ts
index 5447ffef70d2..35b84a6338c9 100644
--- a/packages/next/src/server/client-component-renderer-logger.test.ts
+++ b/packages/next/src/server/client-component-renderer-logger.test.ts
@@ -1,8 +1,14 @@
+import { AsyncLocalStorage } from 'async_hooks'
import type { AppPageModule } from './route-modules/app-page/module'
-import {
- getClientComponentLoaderMetrics,
- wrapClientComponentLoader,
-} from './client-component-renderer-logger'
+import type { WorkStore } from './app-render/work-async-storage.external'
+
+type LoggerMod = typeof import('./client-component-renderer-logger')
+type WASMod = typeof import('./app-render/work-async-storage.external')
+
+let ClientComponentLoadTracker: LoggerMod['ClientComponentLoadTracker']
+let getClientComponentLoaderMetrics: LoggerMod['getClientComponentLoaderMetrics']
+let wrapClientComponentLoader: LoggerMod['wrapClientComponentLoader']
+let workAsyncStorage: WASMod['workAsyncStorage']
function createComponentModule(
require: (
@@ -17,121 +23,213 @@ function createComponentModule(
} as unknown as AppPageModule
}
+function createTrackedWorkStore(
+ page: string = '/test/page',
+ route: string = '/test'
+): WorkStore {
+ return {
+ page,
+ route,
+ clientComponentLoadTracker: new ClientComponentLoadTracker(),
+ } as WorkStore
+}
+
+function runWithTrackedWorkStore(fn: () => T): T {
+ return workAsyncStorage.run(createTrackedWorkStore(), fn)
+}
+
describe('client component renderer logger', () => {
+ beforeAll(async () => {
+ // AsyncLocalStorage must be available before workAsyncStorage is imported.
+ // @ts-expect-error
+ globalThis.AsyncLocalStorage = AsyncLocalStorage
+
+ const logger = await import('./client-component-renderer-logger')
+ ClientComponentLoadTracker = logger.ClientComponentLoadTracker
+ getClientComponentLoaderMetrics = logger.getClientComponentLoaderMetrics
+ wrapClientComponentLoader = logger.wrapClientComponentLoader
+ const workStorage = await import('./app-render/work-async-storage.external')
+ workAsyncStorage = workStorage.workAsyncStorage
+ })
+
afterEach(() => {
getClientComponentLoaderMetrics({ reset: true })
jest.restoreAllMocks()
})
- it('tracks elapsed boundaries separately from sequential load time', () => {
- jest
- .spyOn(performance, 'now')
- .mockReturnValueOnce(100)
- .mockReturnValueOnce(110)
- .mockReturnValueOnce(150)
- .mockReturnValueOnce(160)
+ it('tracks elapsed boundaries separately from sequential load time', () =>
+ runWithTrackedWorkStore(() => {
+ jest
+ .spyOn(performance, 'now')
+ .mockReturnValueOnce(100)
+ .mockReturnValueOnce(110)
+ .mockReturnValueOnce(150)
+ .mockReturnValueOnce(160)
- const loader = wrapClientComponentLoader(
- createComponentModule(
- () => undefined,
- async () => undefined
- ),
- true
- )
+ const loader = wrapClientComponentLoader(
+ createComponentModule(
+ () => undefined,
+ async () => undefined
+ )
+ )
- loader.require('first')
- loader.require('second')
+ loader.require('first')
+ loader.require('second')
- expect(getClientComponentLoaderMetrics()).toEqual({
- clientComponentLoadStart: 100,
- clientComponentLoadEnd: 160,
- clientComponentLoadTimes: 20,
- clientComponentLoadCount: 2,
- })
- })
+ expect(getClientComponentLoaderMetrics()).toEqual({
+ clientComponentLoadStart: 100,
+ clientComponentLoadEnd: 160,
+ clientComponentLoadTimes: 20,
+ clientComponentLoadCount: 2,
+ })
+ }))
- it('preserves accumulated load time for nested requires', () => {
- jest
- .spyOn(performance, 'now')
- .mockReturnValueOnce(100)
- .mockReturnValueOnce(110)
- .mockReturnValueOnce(120)
- .mockReturnValueOnce(130)
+ it('preserves accumulated load time for nested requires', () =>
+ runWithTrackedWorkStore(() => {
+ jest
+ .spyOn(performance, 'now')
+ .mockReturnValueOnce(100)
+ .mockReturnValueOnce(110)
+ .mockReturnValueOnce(120)
+ .mockReturnValueOnce(130)
- let loader: AppPageModule['__next_app__']
- loader = wrapClientComponentLoader(
- createComponentModule(
- (id) => {
- if (id === 'outer') {
- loader.require('inner')
- }
- },
- async () => undefined
- ),
- true
- )
+ let loader: AppPageModule['__next_app__']
+ loader = wrapClientComponentLoader(
+ createComponentModule(
+ (id) => {
+ if (id === 'outer') {
+ loader.require('inner')
+ }
+ },
+ async () => undefined
+ )
+ )
- loader.require('outer')
+ loader.require('outer')
- expect(getClientComponentLoaderMetrics()).toEqual({
- clientComponentLoadStart: 100,
- clientComponentLoadEnd: 130,
- clientComponentLoadTimes: 40,
- clientComponentLoadCount: 2,
- })
- })
+ expect(getClientComponentLoaderMetrics()).toEqual({
+ clientComponentLoadStart: 100,
+ clientComponentLoadEnd: 130,
+ clientComponentLoadTimes: 40,
+ clientComponentLoadCount: 2,
+ })
+ }))
- it('tracks the last settlement across overlapping chunk loads', async () => {
- jest
- .spyOn(performance, 'now')
- .mockReturnValueOnce(100)
- .mockReturnValueOnce(110)
- .mockReturnValueOnce(130)
- .mockReturnValueOnce(170)
-
- let resolveFirst!: () => void
- let resolveSecond!: () => void
- const first = new Promise((resolve) => {
- resolveFirst = resolve
- })
- const second = new Promise((resolve) => {
- resolveSecond = resolve
- })
- const loader = wrapClientComponentLoader(
- createComponentModule(
- () => undefined,
- (id) => (id === 'first' ? first : second)
- ),
- true
- )
+ it('tracks the last settlement across overlapping chunk loads', () =>
+ runWithTrackedWorkStore(async () => {
+ jest
+ .spyOn(performance, 'now')
+ .mockReturnValueOnce(100)
+ .mockReturnValueOnce(110)
+ .mockReturnValueOnce(130)
+ .mockReturnValueOnce(170)
- expect(loader.loadChunk('first')).toBe(first)
- expect(loader.loadChunk('second')).toBe(second)
+ let resolveFirst!: () => void
+ let resolveSecond!: () => void
+ const first = new Promise((resolve) => {
+ resolveFirst = resolve
+ })
+ const second = new Promise((resolve) => {
+ resolveSecond = resolve
+ })
+ const loader = wrapClientComponentLoader(
+ createComponentModule(
+ () => undefined,
+ (id) => (id === 'first' ? first : second)
+ )
+ )
- resolveSecond()
- await second
- expect(getClientComponentLoaderMetrics()).toEqual({
- clientComponentLoadStart: 100,
- clientComponentLoadEnd: 130,
- clientComponentLoadTimes: 20,
- clientComponentLoadCount: 0,
- })
+ expect(loader.loadChunk('first')).toBe(first)
+ expect(loader.loadChunk('second')).toBe(second)
- resolveFirst()
- await first
- expect(getClientComponentLoaderMetrics()).toEqual({
- clientComponentLoadStart: 100,
- clientComponentLoadEnd: 170,
- clientComponentLoadTimes: 90,
- clientComponentLoadCount: 0,
- })
- })
+ resolveSecond()
+ await second
+ expect(getClientComponentLoaderMetrics()).toEqual({
+ clientComponentLoadStart: 100,
+ clientComponentLoadEnd: 130,
+ clientComponentLoadTimes: 20,
+ clientComponentLoadCount: 0,
+ })
- it('leaves the end boundary unset while a chunk load is pending', async () => {
+ resolveFirst()
+ await first
+ expect(getClientComponentLoaderMetrics()).toEqual({
+ clientComponentLoadStart: 100,
+ clientComponentLoadEnd: 170,
+ clientComponentLoadTimes: 90,
+ clientComponentLoadCount: 0,
+ })
+ }))
+
+ it('leaves the end boundary unset while a chunk load is pending', () =>
+ runWithTrackedWorkStore(async () => {
+ jest
+ .spyOn(performance, 'now')
+ .mockReturnValueOnce(100)
+ .mockReturnValueOnce(150)
+
+ let resolveChunk!: () => void
+ const chunk = new Promise((resolve) => {
+ resolveChunk = resolve
+ })
+ const loader = wrapClientComponentLoader(
+ createComponentModule(
+ () => undefined,
+ () => chunk
+ )
+ )
+
+ expect(loader.loadChunk('pending')).toBe(chunk)
+ expect(getClientComponentLoaderMetrics()).toEqual({
+ clientComponentLoadStart: 100,
+ clientComponentLoadEnd: 0,
+ clientComponentLoadTimes: 0,
+ clientComponentLoadCount: 0,
+ })
+
+ resolveChunk()
+ await chunk
+ expect(getClientComponentLoaderMetrics()).toEqual({
+ clientComponentLoadStart: 100,
+ clientComponentLoadEnd: 150,
+ clientComponentLoadTimes: 50,
+ clientComponentLoadCount: 0,
+ })
+ }))
+
+ it('tracks rejected chunk loads without changing the returned promise', () =>
+ runWithTrackedWorkStore(async () => {
+ jest
+ .spyOn(performance, 'now')
+ .mockReturnValueOnce(100)
+ .mockReturnValueOnce(150)
+
+ const error = new Error('chunk failed')
+ const chunk = Promise.reject(error)
+ const loader = wrapClientComponentLoader(
+ createComponentModule(
+ () => undefined,
+ () => chunk
+ )
+ )
+
+ expect(loader.loadChunk('rejected')).toBe(chunk)
+ await expect(chunk).rejects.toBe(error)
+ expect(getClientComponentLoaderMetrics()).toEqual({
+ clientComponentLoadStart: 100,
+ clientComponentLoadEnd: 150,
+ clientComponentLoadTimes: 50,
+ clientComponentLoadCount: 0,
+ })
+ }))
+
+ it('attributes a pending chunk to its render while another render runs', async () => {
jest
.spyOn(performance, 'now')
.mockReturnValueOnce(100)
- .mockReturnValueOnce(150)
+ .mockReturnValueOnce(200)
+ .mockReturnValueOnce(220)
+ .mockReturnValueOnce(300)
let resolveChunk!: () => void
const chunk = new Promise((resolve) => {
@@ -141,50 +239,92 @@ describe('client component renderer logger', () => {
createComponentModule(
() => undefined,
() => chunk
- ),
- true
+ )
)
+ const firstWorkStore = createTrackedWorkStore('/first/page', '/first')
+ const secondWorkStore = createTrackedWorkStore('/second/page', '/second')
+ expect(
+ workAsyncStorage.run(firstWorkStore, () => loader.loadChunk('first'))
+ ).toBe(chunk)
- expect(loader.loadChunk('pending')).toBe(chunk)
- expect(getClientComponentLoaderMetrics()).toEqual({
- clientComponentLoadStart: 100,
- clientComponentLoadEnd: 0,
- clientComponentLoadTimes: 0,
- clientComponentLoadCount: 0,
- })
-
+ workAsyncStorage.run(secondWorkStore, () => loader.require('second'))
resolveChunk()
await chunk
- expect(getClientComponentLoaderMetrics()).toEqual({
+
+ expect(
+ workAsyncStorage.run(firstWorkStore, () =>
+ getClientComponentLoaderMetrics()
+ )
+ ).toEqual({
clientComponentLoadStart: 100,
- clientComponentLoadEnd: 150,
- clientComponentLoadTimes: 50,
+ clientComponentLoadEnd: 300,
+ clientComponentLoadTimes: 200,
clientComponentLoadCount: 0,
})
+ expect(
+ workAsyncStorage.run(secondWorkStore, () =>
+ getClientComponentLoaderMetrics()
+ )
+ ).toEqual({
+ clientComponentLoadStart: 200,
+ clientComponentLoadEnd: 220,
+ clientComponentLoadTimes: 20,
+ clientComponentLoadCount: 1,
+ })
})
- it('tracks rejected chunk loads without changing the returned promise', async () => {
- jest
- .spyOn(performance, 'now')
- .mockReturnValueOnce(100)
- .mockReturnValueOnce(150)
+ it('finishes once and ignores loads started afterward', async () => {
+ const report = jest.fn()
+ const tracker = new ClientComponentLoadTracker(report)
+ tracker.beginRequire(100)
+ tracker.finishRequire(100, 120)
+ tracker.finish()
+ tracker.finish()
- const error = new Error('chunk failed')
- const chunk = Promise.reject(error)
+ const workStore = createTrackedWorkStore()
+ workStore.clientComponentLoadTracker = tracker
const loader = wrapClientComponentLoader(
createComponentModule(
() => undefined,
- () => chunk
- ),
- true
+ async () => undefined
+ )
)
+ workAsyncStorage.run(workStore, () => loader.require('after-finish'))
+ await Promise.resolve()
- expect(loader.loadChunk('rejected')).toBe(chunk)
- await expect(chunk).rejects.toBe(error)
- expect(getClientComponentLoaderMetrics()).toEqual({
+ expect(report).toHaveBeenCalledTimes(1)
+ expect(report).toHaveBeenCalledWith({
clientComponentLoadStart: 100,
- clientComponentLoadEnd: 150,
- clientComponentLoadTimes: 50,
+ clientComponentLoadEnd: 120,
+ clientComponentLoadTimes: 20,
+ clientComponentLoadCount: 1,
+ })
+ })
+
+ it('reports once after every pending chunk settles', async () => {
+ let resolveReport!: () => void
+ const reported = new Promise((resolve) => {
+ resolveReport = resolve
+ })
+ const report = jest.fn(() => resolveReport())
+ const tracker = new ClientComponentLoadTracker(report)
+ tracker.beginChunk(100)
+ tracker.beginChunk(110)
+ tracker.finish()
+ await Promise.resolve()
+ expect(report).not.toHaveBeenCalled()
+
+ tracker.finishChunk(110, 130)
+ await Promise.resolve()
+ expect(report).not.toHaveBeenCalled()
+
+ tracker.finishChunk(100, 170)
+ await reported
+ expect(report).toHaveBeenCalledTimes(1)
+ expect(report).toHaveBeenCalledWith({
+ clientComponentLoadStart: 100,
+ clientComponentLoadEnd: 170,
+ clientComponentLoadTimes: 90,
clientComponentLoadCount: 0,
})
})
diff --git a/packages/next/src/server/client-component-renderer-logger.ts b/packages/next/src/server/client-component-renderer-logger.ts
index 961afa5730e9..1270159da8fb 100644
--- a/packages/next/src/server/client-component-renderer-logger.ts
+++ b/packages/next/src/server/client-component-renderer-logger.ts
@@ -1,53 +1,149 @@
import type { AppPageModule } from './route-modules/app-page/module'
+import { workAsyncStorage } from './app-render/work-async-storage.external'
-// Combined load times for loading client components
-let clientComponentLoadStart = 0
-let clientComponentLoadEnd = 0
-let clientComponentLoadTimes = 0
-let clientComponentLoadCount = 0
+export type ClientComponentLoaderMetrics = {
+ clientComponentLoadStart: number
+ clientComponentLoadEnd: number
+ clientComponentLoadTimes: number
+ clientComponentLoadCount: number
+}
+
+/** Metrics owned by one render, including chunks that settle after rendering. */
+export class ClientComponentLoadTracker {
+ private clientComponentLoadStart = 0
+ private clientComponentLoadEnd = 0
+ private clientComponentLoadTimes = 0
+ private clientComponentLoadCount = 0
+ private hasLoads = false
+ private pending = 0
+ private sealed = false
+ private resolveCompletion:
+ | ((metrics: ClientComponentLoaderMetrics | undefined) => void)
+ | undefined = undefined
+
+ constructor(
+ private readonly report: (
+ metrics: ClientComponentLoaderMetrics | undefined
+ ) => void = () => {}
+ ) {}
+
+ isSealed(): boolean {
+ return this.sealed
+ }
+
+ beginRequire(startTime: number): void {
+ this.recordStart(startTime)
+ this.clientComponentLoadCount++
+ this.pending++
+ }
+
+ finishRequire(startTime: number, endTime: number): void {
+ this.recordSettlement(startTime, endTime)
+ }
+
+ beginChunk(startTime: number): void {
+ this.recordStart(startTime)
+ this.pending++
+ }
+
+ finishChunk(startTime: number, endTime: number): void {
+ this.recordSettlement(startTime, endTime)
+ }
+
+ snapshot(): ClientComponentLoaderMetrics | undefined {
+ if (!this.hasLoads) {
+ return undefined
+ }
+
+ return {
+ clientComponentLoadStart: this.clientComponentLoadStart,
+ clientComponentLoadEnd: this.clientComponentLoadEnd,
+ clientComponentLoadTimes: this.clientComponentLoadTimes,
+ clientComponentLoadCount: this.clientComponentLoadCount,
+ }
+ }
+
+ /** Stop accepting new loads and report after any in-flight loads settle. */
+ finish(): void {
+ if (this.sealed) return
+ this.sealed = true
+ let completion: Promise
+ if (this.pending === 0) {
+ completion = Promise.resolve(this.snapshot())
+ } else {
+ completion = new Promise((resolve) => {
+ this.resolveCompletion = resolve
+ })
+ }
+
+ // Telemetry is best-effort and must not keep the response open or mask a
+ // render error, including when reporting fails.
+ void completion.then(this.report).catch((error) => {
+ console.error('Failed to report client component loading metrics:', error)
+ })
+ }
+
+ private recordStart(startTime: number): void {
+ if (!this.hasLoads) {
+ this.hasLoads = true
+ this.clientComponentLoadStart = startTime
+ }
+ }
+
+ private recordSettlement(startTime: number, endTime: number): void {
+ this.clientComponentLoadEnd = endTime
+ this.clientComponentLoadTimes += endTime - startTime
+ this.pending--
+
+ if (this.sealed && this.pending === 0 && this.resolveCompletion) {
+ const resolve = this.resolveCompletion
+ this.resolveCompletion = undefined
+ resolve(this.snapshot())
+ }
+ }
+}
export function wrapClientComponentLoader(
- ComponentMod: AppPageModule,
- isTracingEnabled: boolean
+ ComponentMod: AppPageModule
): AppPageModule['__next_app__'] {
- if (
- !('performance' in globalThis) ||
- (!process.env.NEXT_OTEL_PERFORMANCE_PREFIX && !isTracingEnabled)
- ) {
+ if (!('performance' in globalThis)) {
return ComponentMod.__next_app__
}
return {
require: (...args) => {
- const startTime = performance.now()
-
- if (clientComponentLoadStart === 0) {
- clientComponentLoadStart = startTime
+ const tracker = workAsyncStorage.getStore()?.clientComponentLoadTracker
+ if (tracker === undefined || tracker.isSealed()) {
+ return ComponentMod.__next_app__.require(...args)
}
+ const startTime = performance.now()
+ tracker.beginRequire(startTime)
try {
- clientComponentLoadCount += 1
return ComponentMod.__next_app__.require(...args)
} finally {
- const endTime = performance.now()
- clientComponentLoadEnd = endTime
- clientComponentLoadTimes += endTime - startTime
+ tracker.finishRequire(startTime, performance.now())
}
},
loadChunk: (...args) => {
- const startTime = performance.now()
+ const tracker = workAsyncStorage.getStore()?.clientComponentLoadTracker
+ if (tracker === undefined || tracker.isSealed()) {
+ return ComponentMod.__next_app__.loadChunk(...args)
+ }
- if (clientComponentLoadStart === 0) {
- clientComponentLoadStart = startTime
+ const startTime = performance.now()
+ tracker.beginChunk(startTime)
+ let result: ReturnType
+ try {
+ result = ComponentMod.__next_app__.loadChunk(...args)
+ } catch (error) {
+ tracker.finishChunk(startTime, performance.now())
+ throw error
}
- const result = ComponentMod.__next_app__.loadChunk(...args)
- // Avoid wrapping `loadChunk`'s result in an extra promise in case something like React depends on its identity.
- // We only need to know when it's settled.
+ // React can depend on the original promise identity.
const onSettled = () => {
- const endTime = performance.now()
- clientComponentLoadEnd = endTime
- clientComponentLoadTimes += endTime - startTime
+ tracker.finishChunk(startTime, performance.now())
}
result.then(onSettled, onSettled)
return result
@@ -57,22 +153,15 @@ export function wrapClientComponentLoader(
export function getClientComponentLoaderMetrics(
options: { reset?: boolean } = {}
-) {
- const metrics =
- clientComponentLoadStart === 0
- ? undefined
- : {
- clientComponentLoadStart,
- clientComponentLoadEnd,
- clientComponentLoadTimes,
- clientComponentLoadCount,
- }
-
- if (options.reset) {
- clientComponentLoadStart = 0
- clientComponentLoadEnd = 0
- clientComponentLoadTimes = 0
- clientComponentLoadCount = 0
+): ClientComponentLoaderMetrics | undefined {
+ const workStore = workAsyncStorage.getStore()
+ const tracker = workStore?.clientComponentLoadTracker
+ const metrics = tracker?.snapshot()
+
+ if (options.reset && workStore) {
+ // Pending settlements still hold their original tracker. Detaching it only
+ // affects subsequent reads and loads in this render.
+ workStore.clientComponentLoadTracker = undefined
}
return metrics
diff --git a/packages/next/src/server/dev/use-cache-probe-worker.ts b/packages/next/src/server/dev/use-cache-probe-worker.ts
index 53542471ed73..894b92d5a73f 100644
--- a/packages/next/src/server/dev/use-cache-probe-worker.ts
+++ b/packages/next/src/server/dev/use-cache-probe-worker.ts
@@ -217,6 +217,7 @@ function buildProbeWorkStore(msg: ProbeMessage): WorkStore {
refreshTagsByCacheKind: new Map(),
runInCleanSnapshot: createSnapshot(),
shouldTrackFetchMetrics: false,
+ clientComponentLoadTracker: undefined,
reactServerErrorsByDigest: new Map(),
afterContext,
cacheComponentsEnabled: true,
diff --git a/packages/next/src/server/pipe-readable.test.ts b/packages/next/src/server/pipe-readable.test.ts
index 3841f3838383..7b8c7fbf825b 100644
--- a/packages/next/src/server/pipe-readable.test.ts
+++ b/packages/next/src/server/pipe-readable.test.ts
@@ -7,11 +7,12 @@ import type { AddressInfo } from 'node:net'
import { EventEmitter } from 'node:events'
import http from 'node:http'
import zlib from 'node:zlib'
-import { Readable } from 'node:stream'
+import { PassThrough, Readable } from 'node:stream'
import { promisify } from 'node:util'
import setupCompression from 'next/dist/compiled/compression'
import { pipeNodeReadableToNodeResponse } from './pipe-readable'
+import { ClientComponentLoadTracker } from './client-component-renderer-logger'
const gunzip = promisify(zlib.gunzip)
@@ -173,3 +174,105 @@ describe('pipeNodeReadableToNodeResponse', () => {
expect(decompressed.every((byte) => byte === FILL)).toBe(true)
})
})
+
+describe('client component loading measurement at first write', () => {
+ let server: http.Server | undefined
+ let measure: jest.SpyInstance
+ let pipe: typeof import('./pipe-readable')
+ const previousPrefix = process.env.NEXT_OTEL_PERFORMANCE_PREFIX
+
+ beforeAll(() => {
+ process.env.NEXT_OTEL_PERFORMANCE_PREFIX = 'test'
+ jest.isolateModules(() => {
+ pipe = require('./pipe-readable') as typeof import('./pipe-readable')
+ })
+ })
+
+ afterAll(() => {
+ if (previousPrefix === undefined) {
+ delete process.env.NEXT_OTEL_PERFORMANCE_PREFIX
+ } else {
+ process.env.NEXT_OTEL_PERFORMANCE_PREFIX = previousPrefix
+ }
+ })
+
+ beforeEach(() => {
+ measure = jest.spyOn(performance, 'measure').mockImplementation(() => {
+ return {} as PerformanceMeasure
+ })
+ })
+
+ afterEach(async () => {
+ measure.mockRestore()
+ if (server) {
+ server.closeAllConnections()
+ await new Promise((resolve) => server!.close(() => resolve()))
+ server = undefined
+ }
+ })
+
+ it.each(['web', 'node'] as const)(
+ 'measures the explicit %s tracker when the first chunk is written',
+ async (streamKind) => {
+ const tracker = new ClientComponentLoadTracker()
+ tracker.beginRequire(100)
+ tracker.finishRequire(100, 115)
+ tracker.beginRequire(150)
+ tracker.finishRequire(150, 160)
+ tracker.beginChunk(200)
+ const firstWrite = new Promise((resolve) => {
+ measure.mockImplementation(() => {
+ resolve()
+ return {} as PerformanceMeasure
+ })
+ })
+
+ function loadAfterFirstWrite() {
+ tracker.beginRequire(300)
+ tracker.finishRequire(300, 330)
+ }
+
+ server = http.createServer((_req, res) => {
+ if (streamKind === 'web') {
+ const readable = new ReadableStream({
+ start(controller) {
+ setImmediate(() => {
+ tracker.finishChunk(200, 250)
+ controller.enqueue(new TextEncoder().encode('hello'))
+ void firstWrite.then(() => {
+ loadAfterFirstWrite()
+ controller.enqueue(new TextEncoder().encode(' world'))
+ controller.close()
+ })
+ })
+ },
+ })
+ void pipe
+ .pipeToNodeResponse(readable, res, undefined, tracker)
+ .catch((error) => res.destroy(error))
+ } else {
+ const readable = new PassThrough()
+ void pipe
+ .pipeNodeReadableToNodeResponse(readable, res, undefined, tracker)
+ .catch((error) => res.destroy(error))
+ setImmediate(() => {
+ tracker.finishChunk(200, 250)
+ readable.write('hello')
+ void firstWrite.then(() => {
+ loadAfterFirstWrite()
+ readable.end(' world')
+ })
+ })
+ }
+ })
+
+ const url = await listen(server)
+ expect(await (await fetch(url)).text()).toBe('hello world')
+ expect(measure).toHaveBeenCalledTimes(1)
+ expect(measure).toHaveBeenCalledWith(
+ 'test:next-client-component-loading',
+ { start: 100, end: 175 }
+ )
+ }
+ )
+})
diff --git a/packages/next/src/server/pipe-readable.ts b/packages/next/src/server/pipe-readable.ts
index 7ea7efd14296..fae3320983c1 100644
--- a/packages/next/src/server/pipe-readable.ts
+++ b/packages/next/src/server/pipe-readable.ts
@@ -8,7 +8,7 @@ import {
import { createPromiseWithResolvers } from '../shared/lib/promise-with-resolvers'
import { getTracer } from './lib/trace/tracer'
import { NextNodeServerSpan } from './lib/trace/constants'
-import { getClientComponentLoaderMetrics } from './client-component-renderer-logger'
+import type { ClientComponentLoadTracker } from './client-component-renderer-logger'
export function isAbortError(e: any): e is Error & { name: 'AbortError' } {
return e?.name === 'AbortError' || e?.name === ResponseAbortedName
@@ -19,7 +19,8 @@ const HAS_CLIENT_COMPONENT_METRICS_ENABLED =
function createWriterFromResponse(
res: ServerResponse,
- waitUntilForEnd?: Promise
+ waitUntilForEnd?: Promise,
+ clientComponentLoadTracker?: ClientComponentLoadTracker
): WritableStream {
let started = false
@@ -55,7 +56,7 @@ function createWriterFromResponse(
started = true
if (HAS_CLIENT_COMPONENT_METRICS_ENABLED) {
- const metrics = getClientComponentLoaderMetrics()
+ const metrics = clientComponentLoadTracker?.snapshot()
if (metrics) {
performance.measure(
`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-client-component-loading`,
@@ -124,7 +125,8 @@ function createWriterFromResponse(
export async function pipeToNodeResponse(
readable: ReadableStream,
res: ServerResponse,
- waitUntilForEnd?: Promise
+ waitUntilForEnd?: Promise,
+ clientComponentLoadTracker?: ClientComponentLoadTracker
) {
try {
// If the response has already errored, then just return now.
@@ -135,7 +137,11 @@ export async function pipeToNodeResponse(
// client disconnects.
const controller = createAbortController(res)
- const writer = createWriterFromResponse(res, waitUntilForEnd)
+ const writer = createWriterFromResponse(
+ res,
+ waitUntilForEnd,
+ clientComponentLoadTracker
+ )
await readable.pipeTo(writer, { signal: controller.signal })
} catch (err: any) {
@@ -149,7 +155,8 @@ export async function pipeToNodeResponse(
export async function pipeNodeReadableToNodeResponse(
readable: Readable,
res: ServerResponse,
- waitUntilForEnd?: Promise
+ waitUntilForEnd?: Promise,
+ clientComponentLoadTracker?: ClientComponentLoadTracker
) {
try {
const { errored, destroyed } = res
@@ -201,7 +208,7 @@ export async function pipeNodeReadableToNodeResponse(
'performance' in globalThis &&
process.env.NEXT_OTEL_PERFORMANCE_PREFIX
) {
- const metrics = getClientComponentLoaderMetrics()
+ const metrics = clientComponentLoadTracker?.snapshot()
if (metrics) {
performance.measure(
`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-client-component-loading`,
diff --git a/packages/next/src/server/render-result.ts b/packages/next/src/server/render-result.ts
index 6edac6fb001c..08f04fd42403 100644
--- a/packages/next/src/server/render-result.ts
+++ b/packages/next/src/server/render-result.ts
@@ -3,6 +3,7 @@ import type { Readable } from 'stream'
import type { CacheControl } from './lib/cache-control'
import type { FetchMetrics } from './base-http'
import type { PrefetchHints } from '../shared/lib/app-router-types'
+import type { ClientComponentLoadTracker } from './client-component-renderer-logger'
import {
chainStreams,
@@ -31,6 +32,8 @@ type ContentTypeOption =
| typeof TEXT_PLAIN_CONTENT_TYPE_HEADER // For simplified errors
export type AppPageRenderResultMetadata = {
+ /** Request-local metrics for the first response write. Never cache this. */
+ clientComponentLoadTracker?: ClientComponentLoadTracker
flightData?: Buffer
cacheControl?: CacheControl
staticBailoutInfo?: {
@@ -431,9 +434,19 @@ export default class RenderResult<
!Array.isArray(this.response) &&
isNodeReadable(this.response)
) {
- await pipeNodeReadableToNodeResponse(this.response, res, this.waitUntil)
+ await pipeNodeReadableToNodeResponse(
+ this.response,
+ res,
+ this.waitUntil,
+ this.metadata.clientComponentLoadTracker
+ )
return
}
- await pipeToNodeResponse(this.readable, res, this.waitUntil)
+ await pipeToNodeResponse(
+ this.readable,
+ res,
+ this.waitUntil,
+ this.metadata.clientComponentLoadTracker
+ )
}
}
diff --git a/test/e2e/opentelemetry/instrumentation/app/api/app/[param]/client-component-flush/route.ts b/test/e2e/opentelemetry/instrumentation/app/api/app/[param]/client-component-flush/route.ts
new file mode 100644
index 000000000000..7c2422936d1e
--- /dev/null
+++ b/test/e2e/opentelemetry/instrumentation/app/api/app/[param]/client-component-flush/route.ts
@@ -0,0 +1,18 @@
+const forceFlushKey = Symbol.for('opentelemetry.test/forceFlush')
+
+export const runtime = 'nodejs'
+
+export async function POST() {
+ const flush = (
+ globalThis as typeof globalThis &
+ Record Promise) | undefined>
+ )[forceFlushKey]
+ if (!flush) {
+ return new Response('OpenTelemetry test flush hook is unavailable', {
+ status: 503,
+ })
+ }
+
+ await flush()
+ return new Response(null, { status: 204 })
+}
diff --git a/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-action/action-only-client.tsx b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-action/action-only-client.tsx
new file mode 100644
index 000000000000..f4f88642c1d4
--- /dev/null
+++ b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-action/action-only-client.tsx
@@ -0,0 +1,5 @@
+'use client'
+
+export default function ActionOnlyClient() {
+ return Action-only client component
+}
diff --git a/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-action/page.tsx b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-action/page.tsx
new file mode 100644
index 000000000000..57785dccfa08
--- /dev/null
+++ b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-action/page.tsx
@@ -0,0 +1,39 @@
+import { trace } from '@opentelemetry/api'
+import { cookies } from 'next/headers'
+import EarlyClient from '../client-component-loading/early-client'
+import LateClient from '../client-component-loading/late-client'
+import ActionOnlyClient from './action-only-client'
+
+export default async function Page() {
+ const marker =
+ (await cookies()).get('client-component-action-marker')?.value ?? 'none'
+ const capturedClient = ActionOnlyClient
+
+ async function setMarker(formData: FormData) {
+ 'use server'
+ if (!capturedClient) {
+ throw new Error('Missing captured client component')
+ }
+ const value = formData.get('marker')
+ if (typeof value !== 'string') {
+ throw new Error('Missing action marker')
+ }
+ ;(await cookies()).set('client-component-action-marker', value)
+ trace
+ .getTracer('client-component-loading-test')
+ .startSpan('test.serverActionCompleted')
+ .end()
+ }
+
+ return (
+ <>
+
+
+ {marker}
+
+ >
+ )
+}
diff --git a/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-html-boundary/async-client.tsx b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-html-boundary/async-client.tsx
new file mode 100644
index 000000000000..7cce51bfcbb9
--- /dev/null
+++ b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-html-boundary/async-client.tsx
@@ -0,0 +1,7 @@
+'use client'
+
+await Promise.resolve()
+
+export default function AsyncClient() {
+ return unused client component
+}
diff --git a/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-html-boundary/initially-closed-panel.tsx b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-html-boundary/initially-closed-panel.tsx
new file mode 100644
index 000000000000..53df58f11238
--- /dev/null
+++ b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-html-boundary/initially-closed-panel.tsx
@@ -0,0 +1,19 @@
+'use client'
+
+import { useState, type ReactNode } from 'react'
+
+export default function InitiallyClosedPanel({
+ children,
+}: {
+ children: ReactNode
+}) {
+ const [open, setOpen] = useState(false)
+ return (
+
+
+ {open ? children : 'closed'}
+
+ )
+}
diff --git a/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-html-boundary/page.tsx b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-html-boundary/page.tsx
new file mode 100644
index 000000000000..03b0e8c9dac9
--- /dev/null
+++ b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-html-boundary/page.tsx
@@ -0,0 +1,28 @@
+import { Suspense } from 'react'
+import AsyncClient from './async-client'
+import InitiallyClosedPanel from './initially-closed-panel'
+
+async function SlowDetails({ id }: { id: string }) {
+ const response = await fetch(
+ `http://localhost:${process.env.TEST_CLIENT_COMPONENT_GATE_PORT}/?key=${id}`,
+ { cache: 'no-store' }
+ )
+ if (!response.ok) throw new Error('Details gate failed')
+ return
+}
+
+export default async function Page({
+ searchParams,
+}: {
+ searchParams: Promise<{ id?: string }>
+}) {
+ const { id } = await searchParams
+ if (!id) throw new Error('Missing details gate id')
+ return (
+
+ waiting}>
+
+
+
+ )
+}
diff --git a/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/early-client.tsx b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/early-client.tsx
new file mode 100644
index 000000000000..4865d72e2b71
--- /dev/null
+++ b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/early-client.tsx
@@ -0,0 +1,5 @@
+'use client'
+
+export default function EarlyClient() {
+ return early client component
+}
diff --git a/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/extra-late-client.tsx b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/extra-late-client.tsx
new file mode 100644
index 000000000000..8d9721a5a2bb
--- /dev/null
+++ b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/extra-late-client.tsx
@@ -0,0 +1,5 @@
+'use client'
+
+export default function ExtraLateClient() {
+ return
+}
diff --git a/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/late-client.tsx b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/late-client.tsx
new file mode 100644
index 000000000000..88774c50e06f
--- /dev/null
+++ b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/late-client.tsx
@@ -0,0 +1,5 @@
+'use client'
+
+export default function LateClient() {
+ return late client component
+}
diff --git a/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/page.tsx b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/page.tsx
new file mode 100644
index 000000000000..3ce1cd10f688
--- /dev/null
+++ b/test/e2e/opentelemetry/instrumentation/app/app/[param]/client-component-loading/page.tsx
@@ -0,0 +1,45 @@
+import { Suspense } from 'react'
+import EarlyClient from './early-client'
+import ExtraLateClient from './extra-late-client'
+import LateClient from './late-client'
+
+async function GatedContent({ id, extra }: { id: string; extra: boolean }) {
+ const response = await fetch(
+ `http://localhost:${process.env.TEST_CLIENT_COMPONENT_GATE_PORT}/?key=${id}`,
+ { cache: 'no-store' }
+ )
+ if (!response.ok) {
+ throw new Error(`Gate request failed: ${response.status}`)
+ }
+
+ return (
+ <>
+
+ {extra && }
+ >
+ )
+}
+
+export default async function Page({
+ searchParams,
+}: {
+ searchParams: Promise<{ [key: string]: string | string[] | undefined }>
+}) {
+ const { id, variant } = await searchParams
+ if (typeof id !== 'string') {
+ throw new Error('Missing client component gate id')
+ }
+ if (variant !== undefined && variant !== 'extra') {
+ throw new Error('Invalid client component loading variant')
+ }
+ const extra = variant === 'extra'
+
+ return (
+ <>
+
+ waiting}>
+
+
+ >
+ )
+}
diff --git a/test/e2e/opentelemetry/instrumentation/instrumentation-test.ts b/test/e2e/opentelemetry/instrumentation/instrumentation-test.ts
index ed6c721e2572..44f5416d98a0 100644
--- a/test/e2e/opentelemetry/instrumentation/instrumentation-test.ts
+++ b/test/e2e/opentelemetry/instrumentation/instrumentation-test.ts
@@ -28,6 +28,7 @@ import {
import { SavedSpan } from './constants'
const customKey = Symbol.for('opentelemetry.test/custom')
+const forceFlushKey = Symbol.for('opentelemetry.test/forceFlush')
const serializeSpan = (span: ReadableSpan): SavedSpan => ({
runtime: process.env.NEXT_RUNTIME,
@@ -46,12 +47,26 @@ const serializeSpan = (span: ReadableSpan): SavedSpan => ({
})
class TestExporter implements SpanExporter {
+ private pendingExports = new Set>()
+
constructor(private port: number) {}
- async export(
+ export(
spans: ReadableSpan[],
resultCallback: (result: ExportResult) => void
- ) {
+ ): void {
+ const pending = this.exportSpans(spans, resultCallback)
+ this.pendingExports.add(pending)
+ void pending.then(
+ () => this.pendingExports.delete(pending),
+ () => this.pendingExports.delete(pending)
+ )
+ }
+
+ private async exportSpans(
+ spans: ReadableSpan[],
+ resultCallback: (result: ExportResult) => void
+ ): Promise {
try {
const response = await fetch(`http://localhost:${this.port}`, {
method: 'POST',
@@ -82,6 +97,12 @@ class TestExporter implements SpanExporter {
shutdown(): Promise {
return Promise.resolve()
}
+
+ async forceFlush(): Promise {
+ // SimpleSpanProcessor does not await ordinary exports in forceFlush, so
+ // drain this test exporter's pending HTTP requests explicitly.
+ await Promise.all(this.pendingExports)
+ }
}
export const register = () => {
@@ -107,6 +128,9 @@ export const register = () => {
propagators: [new CustomPropagator(), new W3CTraceContextPropagator()],
}),
})
+ ;(globalThis as typeof globalThis & Record Promise>)[
+ forceFlushKey
+ ] = () => provider.forceFlush()
}
class CustomPropagator implements TextMapPropagator {
diff --git a/test/e2e/opentelemetry/instrumentation/opentelemetry.test.ts b/test/e2e/opentelemetry/instrumentation/opentelemetry.test.ts
index 4c0da98eaf0f..f21973194c13 100644
--- a/test/e2e/opentelemetry/instrumentation/opentelemetry.test.ts
+++ b/test/e2e/opentelemetry/instrumentation/opentelemetry.test.ts
@@ -1,5 +1,7 @@
import { FileRef, isNextDev, isNextStart, nextTestSetup } from 'e2e-utils'
import { retry } from 'next-test-utils'
+import { createTestDataServer } from 'test-data-service/writer'
+import { createTestLog } from 'test-log'
import { NEXT_RSC_UNION_QUERY } from 'next/dist/client/components/app-router-headers'
import path from 'path'
@@ -15,6 +17,7 @@ const COLLECTOR_PORT = 9001
const ROUTE_PREPARATION_COLLECTOR_PORT = 9002
const INSTRUMENTATION_STARTUP_COLLECTOR_PORT = 9003
const APP_ROUTE_MODULE_LOADING_COLLECTOR_PORT = 9004
+const CLIENT_COMPONENT_GATE_PORT = 9005
type NextInstance = ReturnType['next']
@@ -54,6 +57,7 @@ function setup({ useDirectEntrypointHandler, useNodeMiddleware }) {
? {
env: {
TEST_OTEL_COLLECTOR_PORT: String(COLLECTOR_PORT),
+ TEST_CLIENT_COMPONENT_GATE_PORT: String(CLIENT_COMPONENT_GATE_PORT),
NEXT_TELEMETRY_DISABLED: '1',
},
}
@@ -147,6 +151,329 @@ describe.each(
expect(response.headers.get('connection')).toBe('close')
})
+ // The custom entrypoint server has an explicit route table and does not
+ // include this streamed page.
+ if (!useDirectEntrypointHandler) {
+ describe('client component loading across streamed renders', () => {
+ const pendingGates = new Map void>()
+ const gateServer = createTestDataServer((id, response) => {
+ pendingGates.set(id, () => response.resolve())
+ gateArrivals.log(id)
+ })
+ let gateArrivals = createTestLog()
+ let traceNumber = 0
+
+ function newTraceId() {
+ return (++traceNumber).toString(16).padStart(32, '0')
+ }
+
+ function traceparent(traceId: string) {
+ return `00-${traceId}-${'1'.repeat(16)}-01`
+ }
+
+ beforeAll(() => gateServer.listen(CLIENT_COMPONENT_GATE_PORT))
+ beforeEach(() => {
+ gateArrivals = createTestLog()
+ })
+ afterEach(() => {
+ for (const release of pendingGates.values()) release()
+ pendingGates.clear()
+ })
+ afterAll(() => gateServer.close())
+
+ function releaseGate(id: string) {
+ const gate = pendingGates.get(id)
+ expect(gate).toBeDefined()
+ pendingGates.delete(id)
+ gate!()
+ }
+
+ async function openPage({
+ id,
+ traceId,
+ extra = false,
+ }: {
+ id: string
+ traceId: string
+ extra?: boolean
+ }) {
+ const responsePromise = next.fetch(
+ `/app/test/client-component-loading?id=${id}${extra ? '&variant=extra' : ''}`,
+ { headers: { traceparent: traceparent(traceId) } }
+ )
+ await gateArrivals.waitFor([id])
+ const response = await responsePromise
+ expect(response.status).toBe(200)
+ return response
+ }
+
+ async function finishPage(response: Response, extra = false) {
+ const html = await response.text()
+ expect(html).toContain('')
+ expect(html).toContain('')
+ if (extra) expect(html).toContain('