Unverified Commit ebecaf52 authored by vercel-fleet-prod[bot]'s avatar vercel-fleet-prod[bot] Committed by GitHub

Show React server timings in Request Insights

Co-authored-by: 's avatarDavid Ilie <david@davidilie.com>
Co-authored-by: 's avatarWill Binns-Smith <755844+wbinnssmith@users.noreply.github.com>
parent 8d4175c9
...@@ -724,6 +724,71 @@ ...@@ -724,6 +724,71 @@
font-size: var(--size-13); font-size: var(--size-13);
} }
.request-insights-react-pass + .request-insights-react-pass {
border-top: 1px solid var(--color-gray-400);
}
.request-insights-react-toggle {
display: flex;
align-items: center;
justify-content: space-between;
gap: 12px;
width: 100%;
padding: 10px 4px;
border: 0;
background: transparent;
color: var(--color-gray-1000);
font: inherit;
font-size: var(--size-13);
text-align: left;
cursor: pointer;
}
.request-insights-react-toggle:hover {
background: var(--color-gray-200);
}
.request-insights-react-toggle:focus-visible {
outline: 2px solid var(--color-blue-700);
outline-offset: -2px;
border-radius: 4px;
}
.request-insights-react-pass-label {
display: flex;
align-items: center;
gap: 8px;
}
.request-insights-react-chevron {
display: inline-block;
font-size: 18px;
line-height: 1;
}
.request-insights-react-toggle[aria-expanded='true']
.request-insights-react-chevron {
transform: rotate(90deg);
}
.request-insights-react-pass .request-insights-section {
padding: 8px 4px;
border-bottom: 0;
}
.request-insights-span-row[data-react-kind='component']
.request-insights-span-marker,
.request-insights-span-row[data-react-kind='component']
.request-insights-span-bar {
background: var(--color-purple-800);
}
.request-insights-span-row[data-react-kind='await']
.request-insights-span-marker,
.request-insights-span-row[data-react-kind='await'] .request-insights-span-bar {
background: var(--color-amber-800);
}
.request-insights-trace-viewport { .request-insights-trace-viewport {
overflow-x: auto; overflow-x: auto;
} }
......
...@@ -11,6 +11,7 @@ import { ...@@ -11,6 +11,7 @@ import {
isPageLoadRequest, isPageLoadRequest,
} from './request-list' } from './request-list'
import { import {
getReactTimingGroups,
getTraceItems, getTraceItems,
getTraceNavigationIndex, getTraceNavigationIndex,
getTracePosition, getTracePosition,
...@@ -34,6 +35,191 @@ function createRequest( ...@@ -34,6 +35,191 @@ function createRequest(
} }
describe('request insights trace viewer', () => { describe('request insights trace viewer', () => {
it('groups React intervals by pass and environment without summing overlapping work', () => {
const request = createRequest({
spans: [
...[
['a', 'first', 'Server', 105, 80, 'component'],
['b', 'first', 'Server', 115, 60, 'component'],
['c', 'first', 'Server', 120, 40, 'await'],
['d', 'second', 'Server', 110, 5, 'component'],
['e', 'first', 'Prerender', 100, 4, 'component'],
].map(([id, pass, environment, start, duration, kind]) => ({
name: `ReactServerComponents.${kind}`,
spanId: String(id),
parentSpanId: 'shared-parent',
startTime: Number(start),
durationMs: Number(duration),
attributes: {
'next.span_type': `ReactServerComponents.${kind}`,
'next.rsc.render_id': pass,
'next.rsc.environment': environment,
},
})),
{ name: 'GET', spanId: 'request', startTime: 100, durationMs: 100 },
],
})
const items = getTraceItems(request, false)
const original = structuredClone(items)
const groups = getReactTimingGroups(items)
expect(groups).toHaveLength(3)
expect(groups.map((group) => group.environment)).toEqual([
'Prerender',
'Server',
'Server',
])
expect(groups[1]).toMatchObject({
range: { startTime: 105, durationMs: 80 },
components: [
expect.objectContaining({ spanId: 'a', depth: 0 }),
expect.objectContaining({ spanId: 'b', depth: 0 }),
],
awaits: [expect.objectContaining({ spanId: 'c', depth: 0 })],
})
expect(groups[2].components.map((item) => item.spanId)).toEqual(['d'])
expect(items).toEqual(original)
})
it('shows React intervals with their recorded names and parents by default', () => {
const request = createRequest({
spans: [
{
name: 'render route',
spanId: 'render',
startTime: 100,
durationMs: 80,
attributes: { 'next.span_type': 'AppRender.getBodyResult' },
},
{
name: 'ReactServerComponents.component',
spanId: 'component',
parentSpanId: 'render',
startTime: 105,
durationMs: 2,
attributes: {
'next.span_type': 'ReactServerComponents.component',
'next.span_name': 'RecentOrdersPanel',
'next.rsc.kind': 'component',
'next.rsc.environment': 'Server',
'next.rsc.source.file': 'file:///project/.next/server/app.js',
'next.rsc.source.line': 12,
'next.rsc.source.column': 7,
'next.rsc.source.name': 'Page',
'next.rsc.component_path': 'Page › RecentOrdersPanel',
},
},
{
name: 'ReactServerComponents.await',
spanId: 'await',
parentSpanId: 'render',
startTime: 108,
durationMs: 60,
attributes: {
'next.span_type': 'ReactServerComponents.await',
'next.span_name': 'await readRecentOrders',
'next.rsc.kind': 'await',
},
},
],
})
expect(getTraceItems(request, false)).toEqual([
expect.objectContaining({ spanId: 'render', depth: 0 }),
expect.objectContaining({
label: 'RecentOrdersPanel',
fullLabel: 'RecentOrdersPanel · React render interval · Server',
reactTiming: expect.objectContaining({
componentPath: 'Page › RecentOrdersPanel',
source: {
file: 'file:///project/.next/server/app.js',
line1: 12,
column1: 7,
methodName: 'Page',
arguments: [],
},
}),
category: 'application',
parentSpanId: 'render',
durationMs: 2,
depth: 1,
}),
expect.objectContaining({
label: 'await readRecentOrders',
fullLabel: 'await readRecentOrders · React await interval',
category: 'application',
parentSpanId: 'render',
durationMs: 60,
depth: 1,
}),
])
})
it.each([true, false])(
'shows incomplete renders without making an interval, with earlier intervals: %s',
(includeInterval) => {
const request = createRequest({
spans: [
...(includeInterval
? ['Server', 'Cache'].map((environment) => ({
name: 'ReactServerComponents.component',
startTime: 100,
durationMs: 0,
attributes: {
'next.span_type': 'ReactServerComponents.component',
'next.rsc.render_id': 'first',
'next.rsc.environment': environment,
},
}))
: []),
{
name: 'ReactServerComponents.incomplete',
startTime: 100,
durationMs: 0,
attributes: {
'next.span_type': 'ReactServerComponents.incomplete',
'next.rsc.render_id': 'first',
'next.rsc.incomplete_reason': 'budget',
},
},
],
})
const groups = getReactTimingGroups(getTraceItems(request, false))
expect(groups).toHaveLength(includeInterval ? 2 : 1)
for (const group of groups) {
expect(group.incompleteReason).toBe('budget')
expect(group.components).toHaveLength(includeInterval ? 1 : 0)
expect(group.awaits).toHaveLength(0)
}
}
)
it('does not associate incomplete metadata with unrelated legacy renders', () => {
const request = createRequest({
spans: [
{
name: 'ReactServerComponents.component',
startTime: 100,
durationMs: 1,
attributes: { 'next.span_type': 'ReactServerComponents.component' },
},
{
name: 'ReactServerComponents.incomplete',
startTime: 100,
durationMs: 0,
attributes: {
'next.span_type': 'ReactServerComponents.incomplete',
'next.rsc.incomplete_reason': 'budget',
},
},
],
})
const groups = getReactTimingGroups(getTraceItems(request, false))
expect(groups).toHaveLength(2)
expect(groups[0].incompleteReason).toBeUndefined()
expect(groups[1].incompleteReason).toBe('budget')
expect(groups[1].components).toEqual([])
})
it('moves the active trace row without leaving the listbox', () => { it('moves the active trace row without leaving the listbox', () => {
expect(getTraceNavigationIndex(0, 3, 'ArrowDown')).toBe(1) expect(getTraceNavigationIndex(0, 3, 'ArrowDown')).toBe(1)
expect(getTraceNavigationIndex(2, 3, 'ArrowDown')).toBe(2) expect(getTraceNavigationIndex(2, 3, 'ArrowDown')).toBe(2)
......
...@@ -3,6 +3,7 @@ import type { ...@@ -3,6 +3,7 @@ import type {
RequestInsightFetch, RequestInsightFetch,
RequestInsightSpan, RequestInsightSpan,
} from '../../../shared/request-insights' } from '../../../shared/request-insights'
import type { StackFrame } from '../../../shared/stack-frame'
import { getFetchUrlPresentation } from './fetch-label' import { getFetchUrlPresentation } from './fetch-label'
export type TraceItem = { export type TraceItem = {
...@@ -10,6 +11,14 @@ export type TraceItem = { ...@@ -10,6 +11,14 @@ export type TraceItem = {
spanId?: string spanId?: string
parentSpanId?: string parentSpanId?: string
spanType?: string spanType?: string
reactTiming?: {
kind: 'component' | 'await' | 'incomplete'
incompleteReason?: string
renderId?: string
environment: string
source?: StackFrame
componentPath?: string
}
category: 'nextjs' | 'application' category: 'nextjs' | 'application'
label: string label: string
fullLabel?: string fullLabel?: string
...@@ -25,6 +34,80 @@ export type TraceRange = { ...@@ -25,6 +34,80 @@ export type TraceRange = {
durationMs: number durationMs: number
} }
export type ReactTimingGroup = {
id: string
renderId?: string
incompleteReason?: string
environment: string
range: TraceRange
components: TraceItem[]
awaits: TraceItem[]
}
export function getReactTimingGroups(items: TraceItem[]): ReactTimingGroup[] {
const groups = new Map<string, ReactTimingGroup>()
const incomplete: TraceItem[] = []
for (const item of items) {
if (!item.reactTiming) continue
const { renderId, environment, kind } = item.reactTiming
if (kind === 'incomplete') {
incomplete.push(item)
continue
}
// Older session records have no render ID. Keep those intervals separate
// rather than inferring render passes from a shared parent or timestamp.
const id = JSON.stringify([renderId ?? item.id, environment])
let group = groups.get(id)
const endTime = item.startTime + (item.durationMs ?? 0)
if (!group) {
group = {
id,
renderId,
environment,
range: { startTime: item.startTime, durationMs: item.durationMs ?? 0 },
components: [],
awaits: [],
}
groups.set(id, group)
} else {
const end = Math.max(
endTime,
group.range.startTime + group.range.durationMs
)
group.range.startTime = Math.min(group.range.startTime, item.startTime)
group.range.durationMs = end - group.range.startTime
}
// These records are intervals, not an inclusive component ownership tree.
const interval = { ...item, depth: 0 }
if (kind === 'component') group.components.push(interval)
else group.awaits.push(interval)
}
for (const item of incomplete) {
const { renderId, incompleteReason } = item.reactTiming!
let found = false
for (const group of groups.values()) {
if (renderId !== undefined && group.renderId === renderId) {
group.incompleteReason = incompleteReason
found = true
}
}
if (!found) {
groups.set(item.id, {
id: item.id,
renderId,
incompleteReason,
environment: '',
range: { startTime: item.startTime, durationMs: 0 },
components: [],
awaits: [],
})
}
}
return [...groups.values()].sort(
(a, b) => a.range.startTime - b.range.startTime
)
}
export function getTraceNavigationIndex( export function getTraceNavigationIndex(
currentIndex: number, currentIndex: number,
itemCount: number, itemCount: number,
...@@ -54,6 +137,9 @@ export function getTraceNavigationIndex( ...@@ -54,6 +137,9 @@ export function getTraceNavigationIndex(
type UnnestedTraceItem = Omit<TraceItem, 'depth'> type UnnestedTraceItem = Omit<TraceItem, 'depth'>
const FETCH_SPAN_TYPE = 'AppRender.fetch' const FETCH_SPAN_TYPE = 'AppRender.fetch'
const REACT_COMPONENT_SPAN_TYPE = 'ReactServerComponents.component'
const REACT_AWAIT_SPAN_TYPE = 'ReactServerComponents.await'
const REACT_INCOMPLETE_SPAN_TYPE = 'ReactServerComponents.incomplete'
const LOAD_COMPONENTS_SPAN_TYPE = 'LoadComponents.loadComponents' const LOAD_COMPONENTS_SPAN_TYPE = 'LoadComponents.loadComponents'
const MIDDLEWARE_SPAN_TYPE = 'Middleware.execute' const MIDDLEWARE_SPAN_TYPE = 'Middleware.execute'
const DEFAULT_VISIBLE_SPAN_TYPES = new Set([ const DEFAULT_VISIBLE_SPAN_TYPES = new Set([
...@@ -81,6 +167,9 @@ const DEFAULT_VISIBLE_SPAN_TYPES = new Set([ ...@@ -81,6 +167,9 @@ const DEFAULT_VISIBLE_SPAN_TYPES = new Set([
'AppRender.instantInsights.staticShell', 'AppRender.instantInsights.staticShell',
'AppRender.instantInsights.validate', 'AppRender.instantInsights.validate',
FETCH_SPAN_TYPE, FETCH_SPAN_TYPE,
REACT_COMPONENT_SPAN_TYPE,
REACT_AWAIT_SPAN_TYPE,
REACT_INCOMPLETE_SPAN_TYPE,
'NextNodeServer.waitForFirstResponseChunk', 'NextNodeServer.waitForFirstResponseChunk',
'NextNodeServer.startResponse', 'NextNodeServer.startResponse',
'Render.getServerSideProps', 'Render.getServerSideProps',
...@@ -188,14 +277,74 @@ function getSpanTraceItem( ...@@ -188,14 +277,74 @@ function getSpanTraceItem(
index: number index: number
): UnnestedTraceItem { ): UnnestedTraceItem {
const type = span.attributes?.['next.span_type'] const type = span.attributes?.['next.span_type']
const owner = span.attributes?.['next.rsc.owner']
const label =
getSpanLabel(span) +
(type === REACT_AWAIT_SPAN_TYPE && typeof owner === 'string' && owner
? ` · ${owner}`
: '')
const reactTiming =
type === REACT_COMPONENT_SPAN_TYPE
? 'React render interval'
: type === REACT_AWAIT_SPAN_TYPE
? 'React await interval'
: type === REACT_INCOMPLETE_SPAN_TYPE
? 'Incomplete React timing recording'
: undefined
const environment = span.attributes?.['next.rsc.environment']
const renderId = span.attributes?.['next.rsc.render_id']
const componentPath = span.attributes?.['next.rsc.component_path']
const incompleteReason = span.attributes?.['next.rsc.incomplete_reason']
const file = span.attributes?.['next.rsc.source.file']
const line1 = span.attributes?.['next.rsc.source.line']
const column1 = span.attributes?.['next.rsc.source.column']
const methodName = span.attributes?.['next.rsc.source.name']
const source =
typeof file === 'string' &&
file.length > 0 &&
file.length <= 2048 &&
typeof line1 === 'number' &&
Number.isSafeInteger(line1) &&
line1 > 0 &&
typeof column1 === 'number' &&
Number.isSafeInteger(column1) &&
column1 > 0
? {
file,
line1,
column1,
methodName: typeof methodName === 'string' ? methodName : '',
arguments: [],
}
: undefined
return { return {
id: `span:${span.spanId ?? index}:${span.startTime}`, id: `span:${span.spanId ?? index}:${span.startTime}`,
spanId: span.spanId, spanId: span.spanId,
parentSpanId: span.parentSpanId, parentSpanId: span.parentSpanId,
spanType: typeof type === 'string' ? type : undefined, spanType: typeof type === 'string' ? type : undefined,
reactTiming: reactTiming
? {
source,
componentPath:
typeof componentPath === 'string' ? componentPath : undefined,
kind:
type === REACT_COMPONENT_SPAN_TYPE
? 'component'
: type === REACT_AWAIT_SPAN_TYPE
? 'await'
: 'incomplete',
incompleteReason:
typeof incompleteReason === 'string' ? incompleteReason : undefined,
renderId: typeof renderId === 'string' ? renderId : undefined,
environment: typeof environment === 'string' ? environment : '',
}
: undefined,
category: getSpanCategory(span), category: getSpanCategory(span),
label: getSpanLabel(span), label,
fullLabel: reactTiming
? `${label} · ${reactTiming}${typeof environment === 'string' && environment ? ` · ${environment}` : ''}${environment === 'Cache' ? ' · May include replayed timings from cached output' : ''}`
: undefined,
startTime: span.startTime, startTime: span.startTime,
durationMs: span.durationMs, durationMs: span.durationMs,
status: span.status ?? 'pending', status: span.status ?? 'pending',
...@@ -372,7 +521,12 @@ function getSpanCategory(span: RequestInsightSpan): 'nextjs' | 'application' { ...@@ -372,7 +521,12 @@ function getSpanCategory(span: RequestInsightSpan): 'nextjs' | 'application' {
return category return category
} }
if (span.attributes?.['next.span_type'] === FETCH_SPAN_TYPE) { const type = span.attributes?.['next.span_type']
if (
type === FETCH_SPAN_TYPE ||
type === REACT_COMPONENT_SPAN_TYPE ||
type === REACT_AWAIT_SPAN_TYPE
) {
return 'application' return 'application'
} }
...@@ -383,10 +537,14 @@ function getSpanCategory(span: RequestInsightSpan): 'nextjs' | 'application' { ...@@ -383,10 +537,14 @@ function getSpanCategory(span: RequestInsightSpan): 'nextjs' | 'application' {
function getSpanLabel(span: RequestInsightSpan): string { function getSpanLabel(span: RequestInsightSpan): string {
const explicitName = span.attributes?.['next.span_name'] const explicitName = span.attributes?.['next.span_name']
const type = span.attributes?.['next.span_type']
const name = const name =
typeof explicitName === 'string' && explicitName.trim().length > 0 typeof explicitName === 'string' && explicitName.trim().length > 0
? explicitName ? explicitName
: span.name : span.name
if (type === REACT_COMPONENT_SPAN_TYPE || type === REACT_AWAIT_SPAN_TYPE) {
return name
}
const displayName = name const displayName = name
.replace(FIZZ_WORD, 'HTML') .replace(FIZZ_WORD, 'HTML')
.replace(FLIGHT_WORD, 'RSC') .replace(FLIGHT_WORD, 'RSC')
......
import { useCallback } from 'react' import { useCallback } from 'react'
export function useOpenInEditor({ type EditorLocation = {
file,
line1,
column1,
}: {
file?: string | null file?: string | null
line1?: number | null line1?: number | null
column1?: number | null column1?: number | null
} = {}) { }
const openInEditor = useCallback(() => {
if (file == null || line1 == null || column1 == null) return export async function openInEditor({ file, line1, column1 }: EditorLocation) {
if (file == null || line1 == null || column1 == null) return
const params = new URLSearchParams({
file,
line1: String(line1),
column1: String(column1),
})
const response = await self.fetch(
`${process.env.__NEXT_ROUTER_BASEPATH || ''}/__nextjs_launch-editor?${params}`
)
if (!response.ok) throw new Error('Failed to open source in editor')
}
const params = new URLSearchParams() export function useOpenInEditor({ file, line1, column1 }: EditorLocation = {}) {
params.append('file', file) const handleOpenInEditor = useCallback(() => {
params.append('line1', String(line1)) if (file == null || line1 == null || column1 == null) return
params.append('column1', String(column1))
self openInEditor({ file, line1, column1 }).catch((cause) => {
.fetch( console.error(
`${ `Failed to open file "${file} (${line1}:${column1})" in your editor. Cause:`,
process.env.__NEXT_ROUTER_BASEPATH || '' cause
}/__nextjs_launch-editor?${params.toString()}`
)
.then(
() => {},
(cause) => {
console.error(
`Failed to open file "${file} (${line1}:${column1})" in your editor. Cause:`,
cause
)
}
) )
})
}, [file, line1, column1]) }, [file, line1, column1])
return openInEditor return handleOpenInEditor
} }
...@@ -67,7 +67,7 @@ import { ...@@ -67,7 +67,7 @@ import {
renderToNodeFizzStream, renderToNodeFizzStream,
createNodeInlinedDataStream, createNodeInlinedDataStream,
} from './stream-ops' } from './stream-ops'
import type { AnyStream } from './stream-ops' import type { AnyStream, FlightRenderOptions } from './stream-ops'
import { createRenderInBrowserAbortSignal } from './render-in-browser' import { createRenderInBrowserAbortSignal } from './render-in-browser'
import { getInstantTestBootstrapScriptContent } from './instant-test-bootstrap' import { getInstantTestBootstrapScriptContent } from './instant-test-bootstrap'
import { stripInternalQueries } from '../internal-utils' import { stripInternalQueries } from '../internal-utils'
...@@ -998,6 +998,7 @@ async function generateDynamicFlightRenderResult( ...@@ -998,6 +998,7 @@ async function generateDynamicFlightRenderResult(
temporaryReferences: options?.temporaryReferences, temporaryReferences: options?.temporaryReferences,
filterStackFrame, filterStackFrame,
debugChannel: debugChannel?.serverSide, debugChannel: debugChannel?.serverSide,
localRenderTiming: debugChannel?.localRenderTiming,
signal: requestAbortSignal, signal: requestAbortSignal,
} }
) )
...@@ -1034,6 +1035,7 @@ async function generateDynamicFlightRenderResult( ...@@ -1034,6 +1035,7 @@ async function generateDynamicFlightRenderResult(
temporaryReferences: options?.temporaryReferences, temporaryReferences: options?.temporaryReferences,
filterStackFrame, filterStackFrame,
debugChannel: debugChannel?.serverSide, debugChannel: debugChannel?.serverSide,
localRenderTiming: debugChannel?.localRenderTiming,
signal: requestAbortSignal, signal: requestAbortSignal,
} }
) )
...@@ -1269,17 +1271,11 @@ async function spawnRuntimePrefetchWithFilledCaches( ...@@ -1269,17 +1271,11 @@ async function spawnRuntimePrefetchWithFilledCaches(
} }
} }
type RenderToReadableStreamServerOptions = NonNullable<
Parameters<
(typeof import('react-server-dom-webpack/server.node'))['renderToReadableStream']
>[2]
>
async function stagedRenderWithoutCachesInDevNode( async function stagedRenderWithoutCachesInDevNode(
ctx: AppRenderContext, ctx: AppRenderContext,
requestStore: RequestStore, requestStore: RequestStore,
getPayload: (requestStore: RequestStore) => Promise<RSCPayload>, getPayload: (requestStore: RequestStore) => Promise<RSCPayload>,
options: Omit<RenderToReadableStreamServerOptions, 'environmentName'> options: Omit<FlightRenderOptions, 'environmentName'>
) { ) {
// We're rendering while bypassing caches, // We're rendering while bypassing caches,
// so we have no hope of showing a useful runtime stage. // so we have no hope of showing a useful runtime stage.
...@@ -1546,6 +1542,7 @@ async function generateDynamicFlightRenderResultWithStagesInDev( ...@@ -1546,6 +1542,7 @@ async function generateDynamicFlightRenderResultWithStagesInDev(
onError: onError, onError: onError,
filterStackFrame, filterStackFrame,
debugChannel: debugChannel?.serverSide, debugChannel: debugChannel?.serverSide,
localRenderTiming: debugChannel?.localRenderTiming,
} }
) )
} }
...@@ -1653,7 +1650,7 @@ async function generateRuntimePrefetchResult( ...@@ -1653,7 +1650,7 @@ async function generateRuntimePrefetchResult(
requestStore.draftMode, requestStore.draftMode,
onError, onError,
staleTimeIterable, staleTimeIterable,
debugChannel?.serverSide debugChannel
) )
applyMetadataFromPrerenderResult(response, metadata, workStore) applyMetadataFromPrerenderResult(response, metadata, workStore)
...@@ -1850,7 +1847,7 @@ async function finalRuntimeServerPrerender( ...@@ -1850,7 +1847,7 @@ async function finalRuntimeServerPrerender(
draftMode: PrerenderStoreModernRuntime['draftMode'], draftMode: PrerenderStoreModernRuntime['draftMode'],
onError: (err: unknown) => string | undefined, onError: (err: unknown) => string | undefined,
staleTimeIterable: StaleTimeIterable, staleTimeIterable: StaleTimeIterable,
debugChannel: RenderToReadableStreamServerOptions['debugChannel'] debugChannel: DebugChannelPair | undefined
) { ) {
const { implicitTags, renderOpts } = ctx const { implicitTags, renderOpts } = ctx
const { ComponentMod, experimental, isDebugDynamicAccesses } = renderOpts const { ComponentMod, experimental, isDebugDynamicAccesses } = renderOpts
...@@ -1965,14 +1962,16 @@ async function finalRuntimeServerPrerender( ...@@ -1965,14 +1962,16 @@ async function finalRuntimeServerPrerender(
let stream = workUnitAsyncStorage.run( let stream = workUnitAsyncStorage.run(
finalServerPrerenderStore, finalServerPrerenderStore,
ComponentMod.renderToReadableStream, renderToWebFlightStream,
ComponentMod,
finalRSCPayload, finalRSCPayload,
clientModules, clientModules,
{ {
filterStackFrame, filterStackFrame,
onError, onError,
signal: finalServerController.signal, signal: finalServerController.signal,
debugChannel, debugChannel: debugChannel?.serverSide,
localRenderTiming: debugChannel?.localRenderTiming,
} }
) )
...@@ -3826,6 +3825,7 @@ async function renderToStream( ...@@ -3826,6 +3825,7 @@ async function renderToStream(
onError: serverComponentsErrorHandler, onError: serverComponentsErrorHandler,
filterStackFrame, filterStackFrame,
debugChannel: debugChannel?.serverSide, debugChannel: debugChannel?.serverSide,
localRenderTiming: debugChannel?.localRenderTiming,
} }
) )
reactServerResult = new ReactServerResult(serverStream) reactServerResult = new ReactServerResult(serverStream)
...@@ -4026,6 +4026,7 @@ async function renderToStream( ...@@ -4026,6 +4026,7 @@ async function renderToStream(
filterStackFrame, filterStackFrame,
onError: serverComponentsErrorHandler, onError: serverComponentsErrorHandler,
debugChannel: debugChannel?.serverSide, debugChannel: debugChannel?.serverSide,
localRenderTiming: debugChannel?.localRenderTiming,
} }
) )
) )
...@@ -4068,6 +4069,7 @@ async function renderToStream( ...@@ -4068,6 +4069,7 @@ async function renderToStream(
filterStackFrame, filterStackFrame,
onError: serverComponentsErrorHandler, onError: serverComponentsErrorHandler,
debugChannel: debugChannel?.serverSide, debugChannel: debugChannel?.serverSide,
localRenderTiming: debugChannel?.localRenderTiming,
} }
) )
) )
...@@ -5681,6 +5683,7 @@ async function streamStagedRenderInDev({ ...@@ -5681,6 +5683,7 @@ async function streamStagedRenderInDev({
startTime, startTime,
filterStackFrame, filterStackFrame,
debugChannel: debugChannel?.serverSide, debugChannel: debugChannel?.serverSide,
localRenderTiming: debugChannel?.localRenderTiming,
signal: requestAbortSignal, signal: requestAbortSignal,
} }
) as Readable ) as Readable
...@@ -5852,6 +5855,7 @@ async function renderWithWarmCachesForValidationInDev( ...@@ -5852,6 +5855,7 @@ async function renderWithWarmCachesForValidationInDev(
startTime, startTime,
filterStackFrame, filterStackFrame,
debugChannel: debugChannel?.serverSide, debugChannel: debugChannel?.serverSide,
localRenderTiming: debugChannel?.localRenderTiming,
signal: validationAbortSignal, signal: validationAbortSignal,
} }
) as Readable ) as Readable
...@@ -5983,6 +5987,7 @@ async function prerenderWithWarmCachesForStaticValidationInDev( ...@@ -5983,6 +5987,7 @@ async function prerenderWithWarmCachesForStaticValidationInDev(
startTime, startTime,
filterStackFrame, filterStackFrame,
debugChannel: debugChannel?.serverSide, debugChannel: debugChannel?.serverSide,
localRenderTiming: debugChannel?.localRenderTiming,
} }
) as Readable ) as Readable
......
...@@ -5,6 +5,7 @@ ...@@ -5,6 +5,7 @@
import { PassThrough, Writable, type Readable } from 'node:stream' import { PassThrough, Writable, type Readable } from 'node:stream'
import type { DebugChannelServer } from './debug-channel-server.web' import type { DebugChannelServer } from './debug-channel-server.web'
import type { LocalRenderTiming } from '../lib/trace/react-render-timing'
export { createWebDebugChannel } from './debug-channel-server.web' export { createWebDebugChannel } from './debug-channel-server.web'
...@@ -16,6 +17,7 @@ export { createWebDebugChannel } from './debug-channel-server.web' ...@@ -16,6 +17,7 @@ export { createWebDebugChannel } from './debug-channel-server.web'
export type NodeDebugChannelPair = { export type NodeDebugChannelPair = {
serverSide: DebugChannelServer serverSide: DebugChannelServer
clientSide: { readable: Readable } clientSide: { readable: Readable }
localRenderTiming?: LocalRenderTiming
} }
/** /**
...@@ -24,6 +26,14 @@ export type NodeDebugChannelPair = { ...@@ -24,6 +26,14 @@ export type NodeDebugChannelPair = {
* which expects debugChannel to be a Node.js stream with a .write() method. * which expects debugChannel to be a Node.js stream with a .write() method.
*/ */
export function createNodeDebugChannel(): NodeDebugChannelPair { export function createNodeDebugChannel(): NodeDebugChannelPair {
let localRenderTiming: LocalRenderTiming | undefined
if (process.env.__NEXT_DEV_SERVER) {
const { createLocalRenderTiming } =
require('../lib/trace/react-render-timing') as typeof import('../lib/trace/react-render-timing')
localRenderTiming = createLocalRenderTiming()
} else {
localRenderTiming = undefined
}
// The readable side is a PassThrough that the client reads from. The // The readable side is a PassThrough that the client reads from. The
// server-side write target is a separate, write-only Writable that forwards // server-side write target is a separate, write-only Writable that forwards
// into it rather than the PassThrough itself: React's renderToPipeableStream // into it rather than the PassThrough itself: React's renderToPipeableStream
...@@ -42,15 +52,24 @@ export function createNodeDebugChannel(): NodeDebugChannelPair { ...@@ -42,15 +52,24 @@ export function createNodeDebugChannel(): NodeDebugChannelPair {
const writable = new Writable({ const writable = new Writable({
write(chunk, encoding, callback) { write(chunk, encoding, callback) {
localRenderTiming?.readDebugChunk(chunk)
passthrough.write(chunk, encoding, callback) passthrough.write(chunk, encoding, callback)
}, },
final(callback) { final(callback) {
localRenderTiming?.finishDebug()
passthrough.end(callback) passthrough.end(callback)
}, },
}) })
writable.once('close', () => {
if (!writable.writableFinished) localRenderTiming?.abort()
})
passthrough.once('close', () => {
if (!passthrough.readableEnded) localRenderTiming?.abort()
})
return { return {
serverSide: writable, serverSide: writable,
clientSide: { readable: passthrough }, clientSide: { readable: passthrough },
localRenderTiming,
} }
} }
...@@ -4,10 +4,12 @@ ...@@ -4,10 +4,12 @@
*/ */
import type { AnyStream } from './app-render-prerender-utils' import type { AnyStream } from './app-render-prerender-utils'
import type { LocalRenderTiming } from '../lib/trace/react-render-timing'
export type DebugChannelPair = { export type DebugChannelPair = {
serverSide: DebugChannelServer serverSide: DebugChannelServer
clientSide: DebugChannelClient clientSide: DebugChannelClient
localRenderTiming?: LocalRenderTiming
} }
export type DebugChannelServer = any export type DebugChannelServer = any
...@@ -22,29 +24,44 @@ type DebugChannelClient = { ...@@ -22,29 +24,44 @@ type DebugChannelClient = {
* which expects debugChannel = { writable: WritableStream }. * which expects debugChannel = { writable: WritableStream }.
*/ */
export function createWebDebugChannel(): DebugChannelPair { export function createWebDebugChannel(): DebugChannelPair {
let localRenderTiming: LocalRenderTiming | undefined
if (process.env.__NEXT_DEV_SERVER && process.env.NEXT_RUNTIME !== 'edge') {
const { createLocalRenderTiming } =
require('../lib/trace/react-render-timing') as typeof import('../lib/trace/react-render-timing')
localRenderTiming = createLocalRenderTiming()
} else {
localRenderTiming = undefined
}
let readableController: ReadableStreamDefaultController | undefined let readableController: ReadableStreamDefaultController | undefined
const clientSideReadable = new ReadableStream<Uint8Array>({ const clientSideReadable = new ReadableStream<Uint8Array>({
start(controller) { start(controller) {
readableController = controller readableController = controller
}, },
cancel() {
localRenderTiming?.abort()
},
}) })
return { return {
serverSide: { serverSide: {
writable: new WritableStream<Uint8Array>({ writable: new WritableStream<Uint8Array>({
write(chunk) { write(chunk) {
localRenderTiming?.readDebugChunk(chunk)
readableController?.enqueue(chunk) readableController?.enqueue(chunk)
}, },
close() { close() {
localRenderTiming?.finishDebug()
readableController?.close() readableController?.close()
}, },
abort(err) { abort(err) {
localRenderTiming?.abort()
readableController?.error(err) readableController?.error(err)
}, },
}), }),
}, },
clientSide: { readable: clientSideReadable }, clientSide: { readable: clientSideReadable },
localRenderTiming,
} }
} }
......
...@@ -547,6 +547,7 @@ export function renderToNodeFlightStream( ...@@ -547,6 +547,7 @@ export function renderToNodeFlightStream(
opts: FlightRenderOptions opts: FlightRenderOptions
): AnyStream { ): AnyStream {
if (!ComponentMod.renderToPipeableStream) { if (!ComponentMod.renderToPipeableStream) {
opts.localRenderTiming?.abort()
throw new Error('renderToPipeableStream is not implemented') throw new Error('renderToPipeableStream is not implemented')
} }
...@@ -555,32 +556,64 @@ export function renderToNodeFlightStream( ...@@ -555,32 +556,64 @@ export function renderToNodeFlightStream(
// the returned pipeable ourselves when it fires. We drop the listener when // the returned pipeable ourselves when it fires. We drop the listener when
// the passthrough closes so a finished render's `pipeable` isn't retained by // the passthrough closes so a finished render's `pipeable` isn't retained by
// the request signal, which can outlive it. // the request signal, which can outlive it.
const { signal, ...renderOptions } = opts ?? {} const { signal, localRenderTiming, ...renderOptions } = opts ?? {}
const pt = new PassThrough() localRenderTiming?.start()
const pipeable = ComponentMod.renderToPipeableStream!( const pt = localRenderTiming
payload, ? new Transform({
clientModules, transform(chunk, _encoding, callback) {
renderOptions localRenderTiming.readFlightChunk(chunk)
) callback(null, chunk)
},
flush(callback) {
localRenderTiming.finishFlight()
callback()
},
})
: new PassThrough()
let pipeable: ReturnType<
NonNullable<FlightComponentMod['renderToPipeableStream']>
>
try {
pipeable = ComponentMod.renderToPipeableStream(
payload,
clientModules,
renderOptions
)
} catch (error) {
localRenderTiming?.abort()
pt.destroy()
throw error
}
// If the destination is destroyed before the render ended, React aborts with a // If the destination is destroyed before the render ended, React aborts with a
// generic "The destination stream closed early." error that `onError` can't // generic "The destination stream closed early." error that `onError` can't
// tell apart from a real render error. Abort first with the reason we already // tell apart from a real render error. Abort first with the reason we already
// know; the listener is registered before piping so it runs before React's. // know; the listener is registered before piping so it runs before React's.
pt.once('close', () => { pt.once('close', () => {
if (!pt.writableEnded) { if (!pt.writableFinished) {
localRenderTiming?.abort()
pipeable.abort(new ResponseAborted()) pipeable.abort(new ResponseAborted())
} }
}) })
pipeable.pipe(pt) try {
pipeable.pipe(pt)
} catch (error) {
localRenderTiming?.abort()
pt.destroy()
throw error
}
if (signal) { if (signal) {
if (signal.aborted) { if (signal.aborted) {
localRenderTiming?.abort()
pipeable.abort(signal.reason) pipeable.abort(signal.reason)
} else { } else {
const onAbort = () => pipeable.abort(signal.reason) const onAbort = () => {
localRenderTiming?.abort()
pipeable.abort(signal.reason)
}
signal.addEventListener('abort', onAbort, { once: true }) signal.addEventListener('abort', onAbort, { once: true })
pt.on('close', () => signal.removeEventListener('abort', onAbort)) pt.on('close', () => signal.removeEventListener('abort', onAbort))
} }
......
...@@ -11,6 +11,7 @@ import type { PostponedState, PrerenderOptions } from 'react-dom/static' ...@@ -11,6 +11,7 @@ import type { PostponedState, PrerenderOptions } from 'react-dom/static'
import { resume, renderToReadableStream } from 'react-dom/server' import { resume, renderToReadableStream } from 'react-dom/server'
import { prerender } from 'react-dom/static' import { prerender } from 'react-dom/static'
import type { renderToReadableStream as flightRenderToReadableStream } from 'react-server-dom-webpack/server' import type { renderToReadableStream as flightRenderToReadableStream } from 'react-server-dom-webpack/server'
import type { LocalRenderTiming } from '../lib/trace/react-render-timing'
import { import {
renderToInitialFizzStream, renderToInitialFizzStream,
...@@ -80,7 +81,7 @@ export type FlightClientModules = Parameters<FlightRenderToReadableStream>[1] ...@@ -80,7 +81,7 @@ export type FlightClientModules = Parameters<FlightRenderToReadableStream>[1]
*/ */
export type FlightRenderOptions = NonNullable< export type FlightRenderOptions = NonNullable<
Parameters<FlightRenderToReadableStream>[2] Parameters<FlightRenderToReadableStream>[2]
> > & { localRenderTiming?: LocalRenderTiming }
export type FizzStreamResult = { export type FizzStreamResult = {
stream: AnyStream stream: AnyStream
...@@ -252,7 +253,74 @@ export function renderToWebFlightStream( ...@@ -252,7 +253,74 @@ export function renderToWebFlightStream(
clientModules: FlightClientModules, clientModules: FlightClientModules,
opts: FlightRenderOptions opts: FlightRenderOptions
): AnyStream { ): AnyStream {
return ComponentMod.renderToReadableStream(payload, clientModules, opts) const { localRenderTiming, ...renderOptions } = opts
localRenderTiming?.start()
let stream: ReadableStream<Uint8Array>
try {
stream = ComponentMod.renderToReadableStream(
payload,
clientModules,
renderOptions
)
} catch (error) {
localRenderTiming?.abort()
throw error
}
if (!localRenderTiming) return stream
let reader: ReadableStreamDefaultReader<Uint8Array>
try {
reader = stream.getReader()
} catch (error) {
localRenderTiming.abort()
throw error
}
const signal = renderOptions.signal
const onAbort = () => localRenderTiming.abort()
if (signal?.aborted) onAbort()
else signal?.addEventListener('abort', onAbort, { once: true })
let closed = false
function release() {
signal?.removeEventListener('abort', onAbort)
reader.releaseLock()
}
return new ReadableStream<Uint8Array>(
{
async pull(controller) {
try {
const result = await reader.read()
if (closed) return
if (result.done) {
closed = true
localRenderTiming.finishFlight()
release()
controller.close()
} else {
localRenderTiming.readFlightChunk(result.value)
controller.enqueue(result.value)
}
} catch (error) {
if (closed) return
closed = true
localRenderTiming.abort()
release()
controller.error(error)
}
},
async cancel(reason) {
if (closed) return
closed = true
localRenderTiming.abort()
try {
await reader.cancel(reason)
} finally {
release()
}
},
},
{ highWaterMark: 0 }
)
} }
export async function streamToString(stream: AnyStream): Promise<string> { export async function streamToString(stream: AnyStream): Promise<string> {
......
This diff is collapsed.
This diff is collapsed.
import { getTracer } from './tracer'
import {
captureLocalSpanContext,
createLocalSpanId,
} from './local-span-recorder'
import {
captureLocalSpanRecorder,
isLocalSpanRecordingEnabled,
} from './span-store'
import { createReactTimingCollector } from './react-debug-timing'
import { warnOnce } from '../../../build/output/log'
export type LocalRenderTiming = NonNullable<
ReturnType<typeof createLocalRenderTiming>
>
export function createLocalRenderTiming() {
if (!isLocalSpanRecordingEnabled()) return undefined
let collector: ReturnType<typeof createReactTimingCollector> | undefined
let flightFinished = false
let debugFinished = false
let closed = false
function finish() {
if (flightFinished && debugFinished) {
closed = true
collector?.finish()
collector = undefined
}
}
return {
start() {
if (closed || collector) return
try {
const span = getTracer().getActiveScopeSpan()
const parent = span?.spanContext()
if (!parent) return
const context = captureLocalSpanContext(parent)
const record = captureLocalSpanRecorder()
const renderId = createLocalSpanId(parent.spanId)
const startTime = performance.timeOrigin + performance.now()
collector = createReactTimingCollector(
(timings) => {
record(
timings.map((timing) => ({
...context,
name: `ReactServerComponents.${timing.kind}`,
spanId: createLocalSpanId(parent.spanId),
timestamp: timing.startTime + timing.durationMs,
startTime: timing.startTime,
durationMs: timing.durationMs,
status: 'ok',
attributes: {
'next.span_type': `ReactServerComponents.${timing.kind}`,
'next.span_name':
timing.kind === 'component'
? `render ${timing.name}`
: `await ${timing.name}`,
'next.span_category': 'application',
'next.rsc.kind': timing.kind,
'next.rsc.render_id': renderId,
'next.rsc.environment': timing.environment,
...(timing.source
? {
'next.rsc.source.file': timing.source.file,
'next.rsc.source.line': timing.source.line,
'next.rsc.source.column': timing.source.column,
'next.rsc.source.name': timing.source.methodName,
}
: {}),
...(timing.ownerName
? { 'next.rsc.owner': timing.ownerName }
: {}),
...(timing.componentPath
? { 'next.rsc.component_path': timing.componentPath }
: {}),
'next.rsc.timing':
timing.kind === 'component' ? 'render-interval' : 'await',
},
}))
)
},
(reason) => {
record([
{
...context,
name: 'ReactServerComponents.incomplete',
spanId: createLocalSpanId(parent.spanId),
timestamp: startTime,
startTime,
durationMs: 0,
status: 'ok',
attributes: {
'next.span_type': 'ReactServerComponents.incomplete',
'next.rsc.render_id': renderId,
'next.rsc.incomplete_reason': reason,
},
},
])
warnOnce(
reason === 'budget'
? 'React render timing collection reached its diagnostic budget. Request Insights shows only the recorded intervals.'
: 'Some React render timings could not be decoded. Request Insights shows only the recorded intervals.'
)
}
)
} catch {
closed = true
}
},
readFlightChunk(chunk: Uint8Array | string) {
collector?.readFlightChunk(chunk)
},
readDebugChunk(chunk: Uint8Array | string) {
collector?.readDebugChunk(chunk)
},
finishFlight() {
flightFinished = true
finish()
},
finishDebug() {
debugFinished = true
finish()
},
abort() {
closed = true
collector?.abort()
collector = undefined
},
}
}
...@@ -24,6 +24,10 @@ import { ...@@ -24,6 +24,10 @@ import {
StaleRequestInsightsHistoryCursorError, StaleRequestInsightsHistoryCursorError,
} from './request-insights-journal' } from './request-insights-journal'
import { recordSpan } from './span-store' import { recordSpan } from './span-store'
import { createLocalRenderTiming } from './react-render-timing'
import { registerLocalSpanRecorder } from './local-span-recorder'
import { AppRenderSpan } from './constants'
import { getTracer } from './tracer'
import { import {
resolveRequestInsightsIdentity, resolveRequestInsightsIdentity,
runWithRequestInsightsIdentity, runWithRequestInsightsIdentity,
...@@ -895,6 +899,102 @@ describe('request insights', () => { ...@@ -895,6 +899,102 @@ describe('request insights', () => {
} }
}) })
it('journals captured React intervals after completion and live eviction', async () => {
process.env.__NEXT_REQUEST_INSIGHTS = 'true'
registerLocalSpanRecorder()
const distDir = await mkdtemp(path.join(tmpdir(), 'request-insights-'))
const identity = {
requestId: 'react-stream',
htmlRequestId: 'react-stream',
url: '/react-timings',
}
try {
await initializeRequestInsightsJournal(distDir)
configureJournalProvider(distDir)
startRequestInsight(identity)
let render!: NonNullable<ReturnType<typeof createLocalRenderTiming>>
let parentSpanId!: string
runWithRequestInsightsIdentity(identity, () =>
getTracer().trace(AppRenderSpan.renderToReadableStream, (span) => {
parentSpanId = span!.spanContext().spanId
render = createLocalRenderTiming()!
render.start()
})
)
completeRequestInsight(identity)
const completed = getRequestInsightsSnapshot().requests[0]
const responseTiming = {
startTime: completed.startTime,
durationMs: completed.durationMs,
}
render.readFlightChunk('0:D"$1"\n0:D"$2"\n0:D"$3"\n')
render.readDebugChunk(
':N1000\n1:{"time":2}\n2:{"name":"Page","env":"Server","owner":"$5","stack":[["Layout","file:///app/layout.tsx",12,7]]}\n3:{"time":5}\n5:{"name":"Layout"}\n'
)
await Promise.resolve()
expect(getRequestInsightsSnapshot().requests[0]).toMatchObject({
...responseTiming,
spans: expect.arrayContaining([
expect.objectContaining({ name: 'ReactServerComponents.component' }),
]),
})
for (let i = 0; i < MAX_LIVE_COMPLETED_REQUEST_INSIGHTS; i++) {
const other = { requestId: `other-${i}` }
startRequestInsight(other)
recordSpan({ name: 'GET /', ...other })
completeRequestInsight(other)
}
render.readFlightChunk('f:D"$1"\nf:D"$2"\nf:D"$3"\n')
render.readDebugChunk('4:{"name":"' + 'x'.repeat(1024 * 1024))
render.finishFlight()
render.finishDebug()
const [stored] = await readRequestInsightsJournal(distDir, identity)
expect(stored).toMatchObject(responseTiming)
const intervals = stored.spans.filter(
(span) => span.name === 'ReactServerComponents.component'
)
expect(intervals).toHaveLength(2)
expect(stored.spans).toEqual(
expect.arrayContaining([
expect.objectContaining({
name: 'ReactServerComponents.incomplete',
parentSpanId,
attributes: expect.objectContaining({
'next.rsc.render_id':
intervals[0].attributes!['next.rsc.render_id'],
'next.rsc.incomplete_reason': 'budget',
}),
}),
])
)
for (const interval of intervals) {
expect(interval).toMatchObject({
parentSpanId,
durationMs: 3,
attributes: {
'next.rsc.source.file': 'file:///app/layout.tsx',
'next.rsc.source.line': 12,
'next.rsc.source.column': 7,
'next.rsc.source.name': 'Layout',
'next.rsc.component_path': 'Layout › Page',
},
})
}
expect(intervals[0].spanId).not.toBe(intervals[1].spanId)
expect(
getRequestInsightsSnapshot().requests.some(
(request) => request.requestId === identity.requestId
)
).toBe(false)
} finally {
await resetRequestInsightsJournalForTest()
await rm(distDir, { recursive: true, force: true })
}
})
it.each([false, true])( it.each([false, true])(
'keeps a complete request when a late update rotates the journal, archived: %s', 'keeps a complete request when a late update rotates the journal, archived: %s',
async (archive) => { async (archive) => {
......
...@@ -99,6 +99,17 @@ const SAFE_SPAN_ATTRIBUTE_KEYS = new Set([ ...@@ -99,6 +99,17 @@ const SAFE_SPAN_ATTRIBUTE_KEYS = new Set([
'next.route', 'next.route',
'next.request_insights.omitted_spans', 'next.request_insights.omitted_spans',
'next.rsc', 'next.rsc',
'next.rsc.kind',
'next.rsc.render_id',
'next.rsc.incomplete_reason',
'next.rsc.owner',
'next.rsc.component_path',
'next.rsc.environment',
'next.rsc.timing',
'next.rsc.source.file',
'next.rsc.source.line',
'next.rsc.source.column',
'next.rsc.source.name',
'next.segment', 'next.segment',
'next.span_category', 'next.span_category',
'next.span_name', 'next.span_name',
......
import { randomUUID } from 'node:crypto'
import { Suspense } from 'react'
import { cacheLife } from 'next/cache'
import { connection } from 'next/server'
function CachedLeaf({ generation }: { generation: string }) {
return <p id="cached-generation">{generation}</p>
}
async function CachedTree() {
'use cache'
cacheLife('hours')
return <CachedLeaf generation={randomUUID()} />
}
async function RequestContent() {
await connection()
return <CachedTree />
}
export default function Page() {
return (
<Suspense fallback={<p>Loading</p>}>
<RequestContent />
</Suspense>
)
}
export default function Page() { function Greeting() {
return <p>hello world</p> return <p>hello world</p>
} }
export default function Page() {
return <Greeting />
}
import { nextTestSetup } from 'e2e-utils' import { nextTestSetup } from 'e2e-utils'
import { createServer } from 'http' import { createServer } from 'http'
import type { AddressInfo } from 'net' import type { AddressInfo } from 'net'
import { import { retry, waitForNoRedbox } from 'next-test-utils'
retry,
toggleDevToolsIndicatorPopover,
waitForNoRedbox,
} from 'next-test-utils'
import { MAX_LIVE_COMPLETED_REQUEST_INSIGHTS } from 'next/dist/shared/lib/request-insights' import { MAX_LIVE_COMPLETED_REQUEST_INSIGHTS } from 'next/dist/shared/lib/request-insights'
type RequestInsight = { type RequestInsight = {
...@@ -50,6 +46,172 @@ describe('request insights', () => { ...@@ -50,6 +46,172 @@ describe('request insights', () => {
files: __dirname, files: __dirname,
}) })
it('expands React timings separately and preserves span inspection', async () => {
const editorRequests: URL[] = []
let mappingRequests = 0
const browser = await next.browser('/', {
async beforePageLoad(page) {
await page.route('**/__nextjs_launch-editor**', async (route) => {
editorRequests.push(new URL(route.request().url()))
await route.fulfill({ status: 204 })
})
page.on('request', (request) => {
if (request.url().includes('/__nextjs_original-stack-frames'))
mappingRequests++
})
},
})
await openRequestInsightsPanel(browser)
const group = browser
.locator('nextjs-portal .request-insights-react-toggle')
.first()
const intervals = browser.locator(
'nextjs-portal [data-react-kind="component"]'
)
await retry(async () => {
expect(await group.getAttribute('aria-expanded')).toBe('false')
})
expect(await intervals.count()).toBe(0)
const mainRows = await browser
.locator('nextjs-portal .request-insights-span-row')
.count()
await group.click()
await retry(async () => {
expect(await intervals.count()).toBeGreaterThan(0)
})
const greeting = browser.locator(
'nextjs-portal [data-react-kind="component"]:has-text("render Greeting")'
)
expect(mappingRequests).toBe(0)
await greeting.locator('[data-react-source-link]').click()
await retry(async () => {
expect(editorRequests).toHaveLength(1)
})
expect(editorRequests[0].searchParams.get('file')).toMatch(
/app\/page\.tsx$/
)
expect(editorRequests[0].searchParams.get('line1')).toBe('6')
expect(
Number(editorRequests[0].searchParams.get('column1'))
).toBeGreaterThan(0)
await greeting.click({ button: 'right' })
await browser
.locator('nextjs-portal .request-insights-context-menu')
.getByText('Open render location', { exact: true })
.click()
await retry(async () => {
expect(editorRequests).toHaveLength(2)
})
expect(editorRequests[1].search).toBe(editorRequests[0].search)
await browser
.locator(
'nextjs-portal .request-insights-react-pass .request-insights-trace-rows'
)
.focus()
await browser.keydown('Enter')
await retry(async () => {
expect(editorRequests).toHaveLength(3)
})
expect(editorRequests[2].search).toBe(editorRequests[0].search)
const interval = intervals.first()
const spanId = await interval.getAttribute('data-trace-item-id')
await interval.hover()
await retry(async () => {
expect(
await browser
.locator('nextjs-portal .request-insights-trace-tooltip')
.isVisible()
).toBe(true)
})
await interval.click({ button: 'right' })
const menu = browser.locator('nextjs-portal .request-insights-context-menu')
await retry(async () => {
expect(await menu.innerText()).toContain('Copy span ID')
expect(await menu.innerText()).toContain('Copy agent prompt')
expect(await menu.innerText()).toContain(spanId!.split(':')[1])
})
await browser
.locator('nextjs-portal .request-insights-context-backdrop')
.click({ position: { x: 10, y: 10 } })
await retry(async () => {
expect(await menu.count()).toBe(0)
})
await group.click()
await retry(async () => {
expect(await intervals.count()).toBe(0)
expect(
await browser
.locator('nextjs-portal .request-insights-span-row')
.count()
).toBe(mainRows)
})
})
it('keeps cached React intervals without counting them as new executions', async () => {
const first = await next.render$('/cached-timings')
const generation = first('#cached-generation').text()
expect(generation).not.toBe('')
const before = await next
.fetch('/_next/development/request-insights')
.then((response) => response.json())
const coldRequest = before.requests.find(
(request: RequestInsight) =>
request.kind !== 'instant-insights' &&
request.route === '/cached-timings'
) as RequestInsight | undefined
expect(coldRequest).toBeDefined()
expect(coldRequest!.spans).toEqual(
expect.arrayContaining([
expect.objectContaining({
attributes: expect.objectContaining({
'next.span_type': 'ReactServerComponents.component',
'next.span_name': 'render CachedTree',
'next.rsc.environment': 'Server',
}),
}),
])
)
expect(
coldRequest!.spans.filter(
(span) => span.name === 'ReactServerComponents.incomplete'
)
).toEqual([])
const existing = new Set(
before.requests.map((request: RequestInsight) => request.requestId)
)
const second = await next.render$('/cached-timings')
expect(second('#cached-generation').text()).toBe(generation)
await retry(async () => {
const snapshot = await next
.fetch('/_next/development/request-insights')
.then((response) => response.json())
const request = snapshot.requests.find(
(request: RequestInsight) =>
!existing.has(request.requestId) &&
request.kind !== 'instant-insights' &&
request.route === '/cached-timings'
) as RequestInsight | undefined
expect(request).toBeDefined()
expect(request!.spans).toEqual(
expect.arrayContaining([
expect.objectContaining({
attributes: expect.objectContaining({
'next.span_type': 'ReactServerComponents.component',
'next.span_name': 'render CachedLeaf',
'next.rsc.environment': 'Cache',
}),
}),
])
)
expect(
request!.spans.some(
(span) => span.name === 'ReactServerComponents.incomplete'
)
).toBe(false)
})
})
function createRequest(index: number, fetchCount = 0): RequestInsight { function createRequest(index: number, fetchCount = 0): RequestInsight {
return { return {
requestId: `request-${index}`, requestId: `request-${index}`,
...@@ -72,7 +234,7 @@ describe('request insights', () => { ...@@ -72,7 +234,7 @@ describe('request insights', () => {
async function openRequestInsightsPanel( async function openRequestInsightsPanel(
browser: Awaited<ReturnType<typeof next.browser>> browser: Awaited<ReturnType<typeof next.browser>>
) { ) {
await toggleDevToolsIndicatorPopover(browser) await browser.locator('nextjs-portal #next-logo').click()
await browser.elementByCss('[data-request-insights]').click() await browser.elementByCss('[data-request-insights]').click()
await browser.waitForElementByCss('.request-insights-list-toolbar') await browser.waitForElementByCss('.request-insights-list-toolbar')
// The panel selector menu stays mounted for its exit animation and its // The panel selector menu stays mounted for its exit animation and its
...@@ -152,6 +314,15 @@ describe('request insights', () => { ...@@ -152,6 +314,15 @@ describe('request insights', () => {
}) })
it('keeps outer server and app render spans on the same request', async () => { it('keeps outer server and app render spans on the same request', async () => {
const existingRequestIds = new Set(
(
(await next
.fetch('/_next/development/request-insights')
.then((response) => response.json())) as {
requests: RequestInsight[]
}
).requests.map((request) => request.requestId)
)
await next.render('/') await next.render('/')
await retry(async () => { await retry(async () => {
...@@ -161,7 +332,10 @@ describe('request insights', () => { ...@@ -161,7 +332,10 @@ describe('request insights', () => {
requests: RequestInsight[] requests: RequestInsight[]
} }
const pageRequests = snapshot.requests.filter( const pageRequests = snapshot.requests.filter(
(request) => request.route === '/' (request) =>
!existingRequestIds.has(request.requestId) &&
request.kind !== 'instant-insights' &&
request.route === '/'
) )
const requestsWithRelevantSpans = pageRequests.filter((request) => const requestsWithRelevantSpans = pageRequests.filter((request) =>
request.spans.some((span) => { request.spans.some((span) => {
......
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