Unverified Commit bc8bf60a authored by Josh Story's avatar Josh Story Committed by GitHub

Scope client component loading metrics to HTML renders (#99322)

## Summary

To measure how client component loading affects HTML render performance,
replace telemetry based on process-global counters and incoming
request-body completion. Those boundaries mixed overlapping renders and
measured a lifecycle unrelated to HTML production.

Scope the counters and reporting context to each HTML-producing render.
Start tracking before SSR, finish dynamic measurements at React
readiness (Node `onAllReady` / Web `allReady`), and finish prerendering
when the prerender operation returns. Preparation, action execution, and
dedicated Flight rendering do not start tracking. DATA-only resumes
finish tracking locally without waiting for output; an empty tracker
emits no span. HTML rendered after a form action is still measured.

Already-started loads may settle and report afterward without keeping
the response open. Preserve the first-write performance snapshot, but
remove metrics stream wrapping and binding. This advances the larger
effort to remove req/res lifecycle assumptions from App Router rendering
without adding telemetry to `after()`.

Behavioral tests cover overlapping renders in both completion orders,
HTML after a form POST, enhanced actions that only produce Flight, and
HTML readiness while unused Flight content remains blocked.

## Verification

- Confirmed both new boundary regressions failed before the runtime
change.
- Five behavioral metrics cases pass in development and production with
both Turbopack and Webpack.
- Full production Turbopack instrumentation suite: 109 passed, 13
existing skips.
- Focused logger/response-piping units: 11 passed. Full repository
build, package/root types, scoped Prettier, ESLint, and diff checks
pass.
- A broader unit run passed 3,065 tests but hit three macOS `/var`
versus `/private/var` assertions in unchanged TypeScript CLI tests.

Existing Node response-disconnect propagation to upstream SSR is
unchanged; this PR does not claim to fix cancellation.

<!-- NEXT_JS_LLM -->
parent b829c618
...@@ -13,6 +13,7 @@ import { workAsyncStorageInstance } from './work-async-storage-instance' with { ...@@ -13,6 +13,7 @@ import { workAsyncStorageInstance } from './work-async-storage-instance' with {
import type { LazyResult } from '../lib/lazy-result' import type { LazyResult } from '../lib/lazy-result'
import type { DigestedError } from './create-error-handler' import type { DigestedError } from './create-error-handler'
import type { ActionRevalidationKind } from '../../shared/lib/action-revalidation-kind' import type { ActionRevalidationKind } from '../../shared/lib/action-revalidation-kind'
import type { ClientComponentLoadTracker } from '../client-component-renderer-logger'
export interface WorkStore { export interface WorkStore {
/** /**
...@@ -101,6 +102,7 @@ export interface WorkStore { ...@@ -101,6 +102,7 @@ export interface WorkStore {
fetchMetrics?: FetchMetrics fetchMetrics?: FetchMetrics
shouldTrackFetchMetrics: boolean shouldTrackFetchMetrics: boolean
clientComponentLoadTracker: ClientComponentLoadTracker | undefined
/** /**
* Tracks pending `"use cache"` invocations within the current request scope, * Tracks pending `"use cache"` invocations within the current request scope,
......
...@@ -147,6 +147,7 @@ function createWorkStoreImpl( ...@@ -147,6 +147,7 @@ function createWorkStoreImpl(
refreshTagsByCacheKind: createRefreshTagsByCacheKind(), refreshTagsByCacheKind: createRefreshTagsByCacheKind(),
runInCleanSnapshot: createSnapshot(), runInCleanSnapshot: createSnapshot(),
shouldTrackFetchMetrics, shouldTrackFetchMetrics,
clientComponentLoadTracker: undefined,
reactServerErrorsByDigest: new Map(), reactServerErrorsByDigest: new Map(),
} }
......
import type { AppPageModule } from './route-modules/app-page/module' 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 export type ClientComponentLoaderMetrics = {
let clientComponentLoadStart = 0 clientComponentLoadStart: number
let clientComponentLoadEnd = 0 clientComponentLoadEnd: number
let clientComponentLoadTimes = 0 clientComponentLoadTimes: number
let clientComponentLoadCount = 0 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<ClientComponentLoaderMetrics | undefined>
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( export function wrapClientComponentLoader(
ComponentMod: AppPageModule, ComponentMod: AppPageModule
isTracingEnabled: boolean
): AppPageModule['__next_app__'] { ): AppPageModule['__next_app__'] {
if ( if (!('performance' in globalThis)) {
!('performance' in globalThis) ||
(!process.env.NEXT_OTEL_PERFORMANCE_PREFIX && !isTracingEnabled)
) {
return ComponentMod.__next_app__ return ComponentMod.__next_app__
} }
return { return {
require: (...args) => { require: (...args) => {
const startTime = performance.now() const tracker = workAsyncStorage.getStore()?.clientComponentLoadTracker
if (tracker === undefined || tracker.isSealed()) {
if (clientComponentLoadStart === 0) { return ComponentMod.__next_app__.require(...args)
clientComponentLoadStart = startTime
} }
const startTime = performance.now()
tracker.beginRequire(startTime)
try { try {
clientComponentLoadCount += 1
return ComponentMod.__next_app__.require(...args) return ComponentMod.__next_app__.require(...args)
} finally { } finally {
const endTime = performance.now() tracker.finishRequire(startTime, performance.now())
clientComponentLoadEnd = endTime
clientComponentLoadTimes += endTime - startTime
} }
}, },
loadChunk: (...args) => { 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) { const startTime = performance.now()
clientComponentLoadStart = startTime tracker.beginChunk(startTime)
let result: ReturnType<AppPageModule['__next_app__']['loadChunk']>
try {
result = ComponentMod.__next_app__.loadChunk(...args)
} catch (error) {
tracker.finishChunk(startTime, performance.now())
throw error
} }
const result = ComponentMod.__next_app__.loadChunk(...args) // React can depend on the original promise identity.
// 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.
const onSettled = () => { const onSettled = () => {
const endTime = performance.now() tracker.finishChunk(startTime, performance.now())
clientComponentLoadEnd = endTime
clientComponentLoadTimes += endTime - startTime
} }
result.then(onSettled, onSettled) result.then(onSettled, onSettled)
return result return result
...@@ -57,22 +153,15 @@ export function wrapClientComponentLoader( ...@@ -57,22 +153,15 @@ export function wrapClientComponentLoader(
export function getClientComponentLoaderMetrics( export function getClientComponentLoaderMetrics(
options: { reset?: boolean } = {} options: { reset?: boolean } = {}
) { ): ClientComponentLoaderMetrics | undefined {
const metrics = const workStore = workAsyncStorage.getStore()
clientComponentLoadStart === 0 const tracker = workStore?.clientComponentLoadTracker
? undefined const metrics = tracker?.snapshot()
: {
clientComponentLoadStart, if (options.reset && workStore) {
clientComponentLoadEnd, // Pending settlements still hold their original tracker. Detaching it only
clientComponentLoadTimes, // affects subsequent reads and loads in this render.
clientComponentLoadCount, workStore.clientComponentLoadTracker = undefined
}
if (options.reset) {
clientComponentLoadStart = 0
clientComponentLoadEnd = 0
clientComponentLoadTimes = 0
clientComponentLoadCount = 0
} }
return metrics return metrics
......
...@@ -217,6 +217,7 @@ function buildProbeWorkStore(msg: ProbeMessage): WorkStore { ...@@ -217,6 +217,7 @@ function buildProbeWorkStore(msg: ProbeMessage): WorkStore {
refreshTagsByCacheKind: new Map(), refreshTagsByCacheKind: new Map(),
runInCleanSnapshot: createSnapshot(), runInCleanSnapshot: createSnapshot(),
shouldTrackFetchMetrics: false, shouldTrackFetchMetrics: false,
clientComponentLoadTracker: undefined,
reactServerErrorsByDigest: new Map(), reactServerErrorsByDigest: new Map(),
afterContext, afterContext,
cacheComponentsEnabled: true, cacheComponentsEnabled: true,
......
...@@ -7,11 +7,12 @@ import type { AddressInfo } from 'node:net' ...@@ -7,11 +7,12 @@ import type { AddressInfo } from 'node:net'
import { EventEmitter } from 'node:events' import { EventEmitter } from 'node:events'
import http from 'node:http' import http from 'node:http'
import zlib from 'node:zlib' import zlib from 'node:zlib'
import { Readable } from 'node:stream' import { PassThrough, Readable } from 'node:stream'
import { promisify } from 'node:util' import { promisify } from 'node:util'
import setupCompression from 'next/dist/compiled/compression' import setupCompression from 'next/dist/compiled/compression'
import { pipeNodeReadableToNodeResponse } from './pipe-readable' import { pipeNodeReadableToNodeResponse } from './pipe-readable'
import { ClientComponentLoadTracker } from './client-component-renderer-logger'
const gunzip = promisify(zlib.gunzip) const gunzip = promisify(zlib.gunzip)
...@@ -173,3 +174,105 @@ describe('pipeNodeReadableToNodeResponse', () => { ...@@ -173,3 +174,105 @@ describe('pipeNodeReadableToNodeResponse', () => {
expect(decompressed.every((byte) => byte === FILL)).toBe(true) 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<void>((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<void>((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<Uint8Array>({
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 }
)
}
)
})
...@@ -8,7 +8,7 @@ import { ...@@ -8,7 +8,7 @@ import {
import { createPromiseWithResolvers } from '../shared/lib/promise-with-resolvers' import { createPromiseWithResolvers } from '../shared/lib/promise-with-resolvers'
import { getTracer } from './lib/trace/tracer' import { getTracer } from './lib/trace/tracer'
import { NextNodeServerSpan } from './lib/trace/constants' 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' } { export function isAbortError(e: any): e is Error & { name: 'AbortError' } {
return e?.name === 'AbortError' || e?.name === ResponseAbortedName return e?.name === 'AbortError' || e?.name === ResponseAbortedName
...@@ -19,7 +19,8 @@ const HAS_CLIENT_COMPONENT_METRICS_ENABLED = ...@@ -19,7 +19,8 @@ const HAS_CLIENT_COMPONENT_METRICS_ENABLED =
function createWriterFromResponse( function createWriterFromResponse(
res: ServerResponse, res: ServerResponse,
waitUntilForEnd?: Promise<unknown> waitUntilForEnd?: Promise<unknown>,
clientComponentLoadTracker?: ClientComponentLoadTracker
): WritableStream<Uint8Array> { ): WritableStream<Uint8Array> {
let started = false let started = false
...@@ -55,7 +56,7 @@ function createWriterFromResponse( ...@@ -55,7 +56,7 @@ function createWriterFromResponse(
started = true started = true
if (HAS_CLIENT_COMPONENT_METRICS_ENABLED) { if (HAS_CLIENT_COMPONENT_METRICS_ENABLED) {
const metrics = getClientComponentLoaderMetrics() const metrics = clientComponentLoadTracker?.snapshot()
if (metrics) { if (metrics) {
performance.measure( performance.measure(
`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-client-component-loading`, `${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-client-component-loading`,
...@@ -124,7 +125,8 @@ function createWriterFromResponse( ...@@ -124,7 +125,8 @@ function createWriterFromResponse(
export async function pipeToNodeResponse( export async function pipeToNodeResponse(
readable: ReadableStream<Uint8Array>, readable: ReadableStream<Uint8Array>,
res: ServerResponse, res: ServerResponse,
waitUntilForEnd?: Promise<unknown> waitUntilForEnd?: Promise<unknown>,
clientComponentLoadTracker?: ClientComponentLoadTracker
) { ) {
try { try {
// If the response has already errored, then just return now. // If the response has already errored, then just return now.
...@@ -135,7 +137,11 @@ export async function pipeToNodeResponse( ...@@ -135,7 +137,11 @@ export async function pipeToNodeResponse(
// client disconnects. // client disconnects.
const controller = createAbortController(res) const controller = createAbortController(res)
const writer = createWriterFromResponse(res, waitUntilForEnd) const writer = createWriterFromResponse(
res,
waitUntilForEnd,
clientComponentLoadTracker
)
await readable.pipeTo(writer, { signal: controller.signal }) await readable.pipeTo(writer, { signal: controller.signal })
} catch (err: any) { } catch (err: any) {
...@@ -149,7 +155,8 @@ export async function pipeToNodeResponse( ...@@ -149,7 +155,8 @@ export async function pipeToNodeResponse(
export async function pipeNodeReadableToNodeResponse( export async function pipeNodeReadableToNodeResponse(
readable: Readable, readable: Readable,
res: ServerResponse, res: ServerResponse,
waitUntilForEnd?: Promise<unknown> waitUntilForEnd?: Promise<unknown>,
clientComponentLoadTracker?: ClientComponentLoadTracker
) { ) {
try { try {
const { errored, destroyed } = res const { errored, destroyed } = res
...@@ -201,7 +208,7 @@ export async function pipeNodeReadableToNodeResponse( ...@@ -201,7 +208,7 @@ export async function pipeNodeReadableToNodeResponse(
'performance' in globalThis && 'performance' in globalThis &&
process.env.NEXT_OTEL_PERFORMANCE_PREFIX process.env.NEXT_OTEL_PERFORMANCE_PREFIX
) { ) {
const metrics = getClientComponentLoaderMetrics() const metrics = clientComponentLoadTracker?.snapshot()
if (metrics) { if (metrics) {
performance.measure( performance.measure(
`${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-client-component-loading`, `${process.env.NEXT_OTEL_PERFORMANCE_PREFIX}:next-client-component-loading`,
......
...@@ -3,6 +3,7 @@ import type { Readable } from 'stream' ...@@ -3,6 +3,7 @@ import type { Readable } from 'stream'
import type { CacheControl } from './lib/cache-control' import type { CacheControl } from './lib/cache-control'
import type { FetchMetrics } from './base-http' import type { FetchMetrics } from './base-http'
import type { PrefetchHints } from '../shared/lib/app-router-types' import type { PrefetchHints } from '../shared/lib/app-router-types'
import type { ClientComponentLoadTracker } from './client-component-renderer-logger'
import { import {
chainStreams, chainStreams,
...@@ -31,6 +32,8 @@ type ContentTypeOption = ...@@ -31,6 +32,8 @@ type ContentTypeOption =
| typeof TEXT_PLAIN_CONTENT_TYPE_HEADER // For simplified errors | typeof TEXT_PLAIN_CONTENT_TYPE_HEADER // For simplified errors
export type AppPageRenderResultMetadata = { export type AppPageRenderResultMetadata = {
/** Request-local metrics for the first response write. Never cache this. */
clientComponentLoadTracker?: ClientComponentLoadTracker
flightData?: Buffer flightData?: Buffer
cacheControl?: CacheControl cacheControl?: CacheControl
staticBailoutInfo?: { staticBailoutInfo?: {
...@@ -431,9 +434,19 @@ export default class RenderResult< ...@@ -431,9 +434,19 @@ export default class RenderResult<
!Array.isArray(this.response) && !Array.isArray(this.response) &&
isNodeReadable(this.response) isNodeReadable(this.response)
) { ) {
await pipeNodeReadableToNodeResponse(this.response, res, this.waitUntil) await pipeNodeReadableToNodeResponse(
this.response,
res,
this.waitUntil,
this.metadata.clientComponentLoadTracker
)
return return
} }
await pipeToNodeResponse(this.readable, res, this.waitUntil) await pipeToNodeResponse(
this.readable,
res,
this.waitUntil,
this.metadata.clientComponentLoadTracker
)
} }
} }
const forceFlushKey = Symbol.for('opentelemetry.test/forceFlush')
export const runtime = 'nodejs'
export async function POST() {
const flush = (
globalThis as typeof globalThis &
Record<symbol, (() => Promise<void>) | undefined>
)[forceFlushKey]
if (!flush) {
return new Response('OpenTelemetry test flush hook is unavailable', {
status: 503,
})
}
await flush()
return new Response(null, { status: 204 })
}
'use client'
export default function ActionOnlyClient() {
return <span>Action-only client component</span>
}
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 (
<>
<EarlyClient />
<LateClient />
<p id="action-result">{marker}</p>
<form action={setMarker}>
<input type="hidden" name="marker" value="action-completed" />
<button type="submit">Run action</button>
</form>
</>
)
}
'use client'
await Promise.resolve()
export default function AsyncClient() {
return <span id="unused-client">unused client component</span>
}
'use client'
import { useState, type ReactNode } from 'react'
export default function InitiallyClosedPanel({
children,
}: {
children: ReactNode
}) {
const [open, setOpen] = useState(false)
return (
<section id="closed-panel">
<button type="button" onClick={() => setOpen(true)}>
Open
</button>
{open ? children : 'closed'}
</section>
)
}
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 <AsyncClient />
}
export default async function Page({
searchParams,
}: {
searchParams: Promise<{ id?: string }>
}) {
const { id } = await searchParams
if (!id) throw new Error('Missing details gate id')
return (
<InitiallyClosedPanel>
<Suspense fallback={<span id="details-fallback">waiting</span>}>
<SlowDetails id={id} />
</Suspense>
</InitiallyClosedPanel>
)
}
'use client'
export default function EarlyClient() {
return <span id="early-client">early client component</span>
}
'use client'
export default function ExtraLateClient() {
return <span id="extra-late-client">extra late client component</span>
}
'use client'
export default function LateClient() {
return <span id="late-client">late client component</span>
}
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 (
<>
<LateClient />
{extra && <ExtraLateClient />}
</>
)
}
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 (
<>
<EarlyClient />
<Suspense fallback={<span id="waiting">waiting</span>}>
<GatedContent id={id} extra={extra} />
</Suspense>
</>
)
}
...@@ -28,6 +28,7 @@ import { ...@@ -28,6 +28,7 @@ import {
import { SavedSpan } from './constants' import { SavedSpan } from './constants'
const customKey = Symbol.for('opentelemetry.test/custom') const customKey = Symbol.for('opentelemetry.test/custom')
const forceFlushKey = Symbol.for('opentelemetry.test/forceFlush')
const serializeSpan = (span: ReadableSpan): SavedSpan => ({ const serializeSpan = (span: ReadableSpan): SavedSpan => ({
runtime: process.env.NEXT_RUNTIME, runtime: process.env.NEXT_RUNTIME,
...@@ -46,12 +47,26 @@ const serializeSpan = (span: ReadableSpan): SavedSpan => ({ ...@@ -46,12 +47,26 @@ const serializeSpan = (span: ReadableSpan): SavedSpan => ({
}) })
class TestExporter implements SpanExporter { class TestExporter implements SpanExporter {
private pendingExports = new Set<Promise<void>>()
constructor(private port: number) {} constructor(private port: number) {}
async export( export(
spans: ReadableSpan[], spans: ReadableSpan[],
resultCallback: (result: ExportResult) => void 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<void> {
try { try {
const response = await fetch(`http://localhost:${this.port}`, { const response = await fetch(`http://localhost:${this.port}`, {
method: 'POST', method: 'POST',
...@@ -82,6 +97,12 @@ class TestExporter implements SpanExporter { ...@@ -82,6 +97,12 @@ class TestExporter implements SpanExporter {
shutdown(): Promise<void> { shutdown(): Promise<void> {
return Promise.resolve() return Promise.resolve()
} }
async forceFlush(): Promise<void> {
// 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 = () => { export const register = () => {
...@@ -107,6 +128,9 @@ export const register = () => { ...@@ -107,6 +128,9 @@ export const register = () => {
propagators: [new CustomPropagator(), new W3CTraceContextPropagator()], propagators: [new CustomPropagator(), new W3CTraceContextPropagator()],
}), }),
}) })
;(globalThis as typeof globalThis & Record<symbol, () => Promise<void>>)[
forceFlushKey
] = () => provider.forceFlush()
} }
class CustomPropagator implements TextMapPropagator { class CustomPropagator implements TextMapPropagator {
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment