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 extra late client component +} 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('') + } + + function loadingSpans(traceId: string): SavedSpan[] { + return getCollector() + .getSpans() + .filter( + (span) => + span.traceId === traceId && + span.attributes?.['next.span_type'] === + 'NextNodeServer.clientComponentLoading' + ) + } + + async function expectNoLoadingSpanWhileBlocked(traceId: string) { + // Flush in-flight exports before making a negative assertion. + const response = await next.fetch( + '/api/app/test/client-component-flush', + { method: 'POST' } + ) + expect(response.status).toBe(204) + expect(loadingSpans(traceId)).toEqual([]) + } + + async function loadCount(traceId: string): Promise { + return retry(() => { + const spans = loadingSpans(traceId) + expect(spans).toHaveLength(1) + const requestSpans = getCollector() + .getSpans() + .filter( + (span) => + span.traceId === traceId && + span.attributes?.['next.span_type'] === + 'BaseServer.handleRequest' + ) + expect(requestSpans).toHaveLength(1) + expect(spans[0].parentId).toBe(requestSpans[0].id) + const count = spans[0].attributes?.[ + 'next.clientComponentLoadCount' + ] as number + expect(count).toBeGreaterThan(0) + return count + }) + } + + async function renderBaseline(extra: boolean): Promise { + const traceId = newTraceId() + const id = `baseline-${traceId}` + const response = await openPage({ id, traceId, extra }) + releaseGate(id) + await finishPage(response, extra) + return loadCount(traceId) + } + + it.each(['a', 'b'] as const)( + 'keeps overlapping render metrics when %s finishes first', + async (finishFirst) => { + // Warm both module sets before measuring the sequential baselines. + await renderBaseline(false) + await renderBaseline(true) + const normalCount = await renderBaseline(false) + const extraCount = await renderBaseline(true) + expect(extraCount).toBeGreaterThan(normalCount) + + const traceA = newTraceId() + const traceB = newTraceId() + const responseA = await openPage({ id: 'a', traceId: traceA }) + const responseB = await openPage({ + id: 'b', + traceId: traceB, + extra: true, + }) + await expectNoLoadingSpanWhileBlocked(traceA) + await expectNoLoadingSpanWhileBlocked(traceB) + + const requests = { + a: { + id: 'a', + response: responseA, + traceId: traceA, + count: normalCount, + extra: false, + }, + b: { + id: 'b', + response: responseB, + traceId: traceB, + count: extraCount, + extra: true, + }, + } + const first = requests[finishFirst] + const second = requests[finishFirst === 'a' ? 'b' : 'a'] + + releaseGate(first.id) + await finishPage(first.response, first.extra) + expect(await loadCount(first.traceId)).toBe(first.count) + + expect(pendingGates.has(second.id)).toBe(true) + await expectNoLoadingSpanWhileBlocked(second.traceId) + releaseGate(second.id) + await finishPage(second.response, second.extra) + expect(await loadCount(second.traceId)).toBe(second.count) + } + ) + + const actionPath = '/app/test/client-component-action' + + async function getActionPage(traceId: string) { + const $ = await next.render$(actionPath, undefined, { + headers: { traceparent: traceparent(traceId) }, + }) + expect($('#action-result').text()).toBe('none') + return { $, count: await loadCount(traceId) } + } + + it('reports HTML loading after a form POST and leaves the next GET unchanged', async () => { + await getActionPage(newTraceId()) + const { $, count: baseline } = await getActionPage(newTraceId()) + const form = $('form').first() + expect(form.length).toBe(1) + const formData = new FormData() + form.find('input[type="hidden"]').each((_, input) => { + const name = $(input).attr('name') + if (name) formData.append(name, $(input).attr('value') ?? '') + }) + formData.set('marker', 'action-completed') + + const actionTrace = newTraceId() + const response = await next.fetch(actionPath, { + method: 'POST', + headers: { + traceparent: traceparent(actionTrace), + origin: new URL(next.url).origin, + }, + body: formData, + }) + expect(response.status).toBe(200) + expect(await response.text()).toContain( + '

action-completed

' + ) + await retry(() => { + expect( + getCollector() + .getSpans() + .filter( + (span) => + span.traceId === actionTrace && + span.name === 'test.serverActionCompleted' + ) + ).toHaveLength(1) + }) + await loadCount(actionTrace) + + const { count: nextGetCount } = await getActionPage(newTraceId()) + expect(nextGetCount).toBe(baseline) + }) + + it('does not report HTML loading metrics for an enhanced Server Action', async () => { + const browser = await next.browser(actionPath) + expect(await browser.elementByCss('#action-result').text()).toBe('none') + + // Flush the initial document's metrics before measuring the action. + const flush = async () => { + const response = await next.fetch( + '/api/app/test/client-component-flush', + { method: 'POST' } + ) + expect(response.status).toBe(204) + } + await flush() + getCollector().reset() + + await browser.elementByCss('button[type="submit"]').click() + await retry(async () => { + expect(await browser.elementByCss('#action-result').text()).toBe( + 'action-completed' + ) + }) + await flush() + const actionRequest = await retry(() => { + const requests = getCollector() + .getSpans() + .filter( + (span) => + span.attributes?.['http.method'] === 'POST' && + span.attributes?.['http.target'] === actionPath && + span.attributes?.['next.span_type'] === + 'BaseServer.handleRequest' + ) + expect(requests).toHaveLength(1) + return requests[0] + }) + await retry(() => { + expect( + getCollector() + .getSpans() + .filter( + (span) => + span.traceId === actionRequest.traceId && + span.name === 'test.serverActionCompleted' + ) + ).toHaveLength(1) + }) + expect(loadingSpans(actionRequest.traceId)).toEqual([]) + }) + + it('reports HTML loading before unused delayed Flight content finishes', async () => { + const traceId = newTraceId() + const id = `html-boundary-${traceId}` + const responsePromise = next.fetch( + `/app/test/client-component-html-boundary?id=${id}`, + { headers: { traceparent: traceparent(traceId) } } + ) + await gateArrivals.waitFor([id]) + const response = await responsePromise + expect(response.status).toBe(200) + + const flush = async () => { + const result = await next.fetch( + '/api/app/test/client-component-flush', + { method: 'POST' } + ) + expect(result.status).toBe(204) + } + await flush() + + let html: string + let earlySpan: SavedSpan | undefined + try { + // The closed panel lets HTML finish even though its unused Flight + // child remains behind the gate. + await retry(() => { + const renderSpans = getCollector() + .getSpans() + .filter( + (span) => + span.traceId === traceId && + span.attributes?.['next.span_type'] === + 'AppRender.getBodyResult' + ) + expect(renderSpans).toHaveLength(1) + const spans = loadingSpans(traceId) + expect(spans).toHaveLength(1) + earlySpan = spans[0] + }) + expect(pendingGates.has(id)).toBe(true) + } finally { + releaseGate(id) + html = await response.text() + } + + expect(html).toContain('id="closed-panel"') + expect(html).toContain('closed') + expect(html).not.toContain('id="unused-client"') + expect(earlySpan).toBeDefined() + await flush() + expect(loadingSpans(traceId)).toEqual([earlySpan]) + }) + }) + } + // Edge runtime is currently not implemented in custom-entrypoint-server.ts const itEdge = useDirectEntrypointHandler ? it.skip : it @@ -197,6 +524,15 @@ describe.each( traceId: env.span.traceId, parentId: env.span.rootParentId, spans: [ + { + attributes: { + 'next.clientComponentLoadCount': isNextDev ? 8 : 7, + 'next.span_type': 'NextNodeServer.clientComponentLoading', + }, + kind: 0, + name: 'NextNodeServer.clientComponentLoading', + status: { code: 0 }, + }, { name: 'render route (app) /app/[param]/rsc-fetch', attributes: { @@ -277,18 +613,6 @@ describe.each( kind: 0, status: { code: 0 }, }, - { - attributes: { - 'next.clientComponentLoadCount': isNextDev ? 8 : 7, - 'next.span_type': - 'NextNodeServer.clientComponentLoading', - }, - kind: 0, - name: 'NextNodeServer.clientComponentLoading', - status: { - code: 0, - }, - }, { name: 'start response', attributes: { @@ -894,6 +1218,15 @@ describe.each( traceId: env.span.traceId, parentId: env.span.rootParentId, spans: [ + { + attributes: { + 'next.clientComponentLoadCount': isNextDev ? 12 : 10, + 'next.span_type': 'NextNodeServer.clientComponentLoading', + }, + kind: 0, + name: 'NextNodeServer.clientComponentLoading', + status: { code: 0 }, + }, { name: 'render route (app) /app/[param]/rsc-fetch/error', attributes: { @@ -961,18 +1294,6 @@ describe.each( kind: 0, status: { code: 0 }, }, - { - attributes: { - 'next.clientComponentLoadCount': isNextDev ? 12 : 10, - 'next.span_type': - 'NextNodeServer.clientComponentLoading', - }, - kind: 0, - name: 'NextNodeServer.clientComponentLoading', - status: { - code: 0, - }, - }, { name: 'start response', attributes: { @@ -1027,6 +1348,15 @@ describe.each( traceId: env.span.traceId, parentId: env.span.rootParentId, spans: [ + { + attributes: { + 'next.clientComponentLoadCount': isNextDev ? 9 : 8, + 'next.span_type': 'NextNodeServer.clientComponentLoading', + }, + kind: 0, + name: 'NextNodeServer.clientComponentLoading', + status: { code: 0 }, + }, { name: 'render route (app) /app/[param]/loading/error', attributes: { @@ -1089,18 +1419,6 @@ describe.each( kind: 0, status: { code: 0 }, }, - { - attributes: { - 'next.clientComponentLoadCount': isNextDev ? 9 : 8, - 'next.span_type': - 'NextNodeServer.clientComponentLoading', - }, - kind: 0, - name: 'NextNodeServer.clientComponentLoading', - status: { - code: 0, - }, - }, { name: 'start response', attributes: { @@ -1485,6 +1803,16 @@ describe.each( }, ...(isNextDev ? [ + { + name: 'NextNodeServer.clientComponentLoading', + attributes: { + 'next.clientComponentLoadCount': expect.any(Number), + 'next.span_type': + 'NextNodeServer.clientComponentLoading', + }, + kind: 0, + status: { code: 0 }, + }, { name: 'render route (app) /_not-found', attributes: { @@ -2176,6 +2504,9 @@ describe('opentelemetry with disabled fetch tracing', () => { traceId: '[trace-id]', parentId: undefined, spans: [ + { + name: 'NextNodeServer.clientComponentLoading', + }, { name: 'render route (app) /app/[param]/rsc-fetch', spans: [ @@ -2196,9 +2527,6 @@ describe('opentelemetry with disabled fetch tracing', () => { { name: 'generateMetadata /app/[param]/rsc-fetch/page', }, - { - name: 'NextNodeServer.clientComponentLoading', - }, { name: 'start response', }, @@ -2266,6 +2594,15 @@ describe('opentelemetry with custom server', () => { kind: 1, status: { code: 0 }, spans: [ + { + attributes: { + 'next.clientComponentLoadCount': isNextDev ? 8 : 7, + 'next.span_type': 'NextNodeServer.clientComponentLoading', + }, + kind: 0, + name: 'NextNodeServer.clientComponentLoading', + status: { code: 0 }, + }, { name: 'render route (app) /app/[param]/rsc-fetch', attributes: { @@ -2342,17 +2679,6 @@ describe('opentelemetry with custom server', () => { kind: 0, status: { code: 0 }, }, - { - attributes: { - 'next.clientComponentLoadCount': isNextDev ? 8 : 7, - 'next.span_type': 'NextNodeServer.clientComponentLoading', - }, - kind: 0, - name: 'NextNodeServer.clientComponentLoading', - status: { - code: 0, - }, - }, { name: 'start response', attributes: { 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, + }, +}