diff --git a/packages/next/src/server/app-render/app-render.tsx b/packages/next/src/server/app-render/app-render.tsx
index 81bd6b2b7475..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(),
}
@@ -9062,7 +9137,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 +9176,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 +10439,19 @@ async function prerenderToStream(
)
}
- let errorType: MetadataErrorType | 'redirect' | undefined
- const isHTTPAccessFallback = isHTTPAccessFallbackError(err)
- const isRedirect = isRedirectError(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)
+ const errorType = setHTTPAccessFallbackOrRedirectStatus(err)
- 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 +10737,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 +10810,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/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/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/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/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) {
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('
}>
+ 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,
+ },
+}