Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
23 changes: 21 additions & 2 deletions packages/next/src/server/base-server.ts
Original file line number Diff line number Diff line change
Expand Up @@ -903,8 +903,26 @@ export default abstract class Server<
'http.target': req.url,
},
},
async (span) =>
this.handleRequestImpl(req, res, parsedUrl).finally(() => {
async (span) => {
if (getRequestMeta(req, 'middlewareInvoke')) {
// When middleware lets the request continue, the router server
// calls `handleRequest` twice: once to run middleware (this pass)
// and once to render. Publish this span's W3C trace context on
// the request, so the middleware span (including the Edge
// sandbox, which extracts it from the request headers) is a
// child of this span instead of starting a new trace. The
// middleware forwards its own span's context to the render pass
// via request-header overrides, which replace this value; it
// only stays when there is no middleware span to forward (e.g.
// OpenTelemetry isn't registered in the Edge runtime), keeping
// the render in this trace.
const traceContext = tracer.getTraceContextHeaders()
if (traceContext) {
Object.assign(req.headers, traceContext)
}
}

return this.handleRequestImpl(req, res, parsedUrl).finally(() => {
if (!span) return

const isRSCRequest = getRequestMeta(req, 'isRSCRequest') ?? false
Expand Down Expand Up @@ -963,6 +981,7 @@ export default abstract class Server<
span.updateName(isRSCRequest ? `RSC ${method}` : `${method}`)
}
})
}
)
})

Expand Down
45 changes: 32 additions & 13 deletions packages/next/src/server/lib/trace/tracer.ts
Comment thread
vercel-fleet-prod[bot] marked this conversation as resolved.
Resolved
Original file line number Diff line number Diff line change
Expand Up @@ -178,6 +178,14 @@ interface NextTracer {
*/
getTracePropagationData(): ClientTraceDataEntry[]

/**
* Returns the W3C trace context (`traceparent` / `tracestate`) of the
* currently active context, as produced by the configured propagator.
* Returns `undefined` when OpenTelemetry is not enabled, no span context is
* active, or the propagator doesn't produce a `traceparent`.
*/
getTraceContextHeaders(): TraceContextHeaders | undefined

/**
* Executes a function with the given span set as the active span in the context.
* This allows child spans created within the function to automatically parent to this span.
Expand Down Expand Up @@ -211,6 +219,11 @@ export interface ClientTraceDataEntry {
value: string
}

export interface TraceContextHeaders {
traceparent: string
tracestate?: string
}

const clientTraceDataSetter: TextMapSetter<ClientTraceDataEntry[]> = {
set(carrier, key, value) {
carrier.push({
Expand Down Expand Up @@ -260,6 +273,25 @@ class NextTracerImpl implements NextTracer {
return entries
}

public getTraceContextHeaders(): TraceContextHeaders | undefined {
const activeContext = context.active()
if (
!trace.getSpanContext(activeContext) ||
!this.isOpenTelemetryEnabled()
) {
return undefined
}

const carrier: Record<string, string> = {}
propagation.inject(activeContext, carrier)

const { traceparent, tracestate } = carrier
if (!traceparent) {
return undefined
}
return tracestate ? { traceparent, tracestate } : { traceparent }
}

public getActiveScopeSpan(): Span | undefined {
const localSpanRecorder = getLocalSpanRecorder()
const activeLocalSpan = localSpanRecorder?.getActiveLocalSpan()
Expand All @@ -277,19 +309,6 @@ class NextTracerImpl implements NextTracer {
return activeLocalSpan
}

/**
* Run `fn` with the active span cleared, so spans created inside become new
* roots (or parent to incoming propagated context). Used for in-process
* Node.js middleware so its span is a sibling of the request span, matching
* edge middleware which runs in a detached sandbox.
*/
public runWithDetachedContext<T>(fn: () => T): T {
if (!NEXT_OTEL_PERFORMANCE_PREFIX && !this.isOpenTelemetryEnabled()) {
return fn()
}
return context.with(ROOT_CONTEXT, fn)
}

public withPropagatedContext<T, C>(
carrier: C,
fn: () => T,
Expand Down
33 changes: 15 additions & 18 deletions packages/next/src/server/next-server.ts
Original file line number Diff line number Diff line change
Expand Up @@ -1866,24 +1866,21 @@ export default class NextNodeServer extends BaseServer<

try {
// Node.js middleware runs in-process, inside the active
// `handleRequest` span. Detach that span so the middleware span
// becomes a sibling root (or parents to an incoming traceparent),
// matching edge middleware which runs in a detached sandbox.
result = await getTracer().runWithDetachedContext(() =>
adapterFn({
handler:
middlewareModule.proxy ||
middlewareModule.middleware ||
middlewareModule,
request: {
...requestData,
body: hasRequestBody
? requestData.body.cloneBodyStream()
: undefined,
},
page: 'middleware',
})
)
// `handleRequest` span, so the middleware span (and the trace context
// it forwards to the render) stays in the request's trace.
result = await adapterFn({
handler:
middlewareModule.proxy ||
middlewareModule.middleware ||
middlewareModule,
request: {
...requestData,
body: hasRequestBody
? requestData.body.cloneBodyStream()
: undefined,
},
page: 'middleware',
})
} finally {
if (hasRequestBody) {
await requestData.body.finalize()
Expand Down
30 changes: 29 additions & 1 deletion packages/next/src/server/web/adapter.ts
Original file line number Diff line number Diff line change
Expand Up @@ -30,10 +30,11 @@ import { workAsyncStorage } from '../app-render/work-async-storage.external'
import { InvariantError } from '../../shared/lib/invariant-error'
import type { ResolvedCacheLifeProfiles } from '../config-shared'
import { NEXT_ROUTER_PREFETCH_HEADER } from '../../client/components/app-router-headers'
import { getTracer } from '../lib/trace/tracer'
import { getTracer, type TraceContextHeaders } from '../lib/trace/tracer'
import type { TextMapGetter } from 'next/dist/compiled/@opentelemetry/api'
import { MiddlewareSpan } from '../lib/trace/constants'
import { CloseController } from './web-on-close'
import { forwardTraceContextToRequest } from './forward-trace-context'
import { getEdgePreviewProps } from './get-edge-preview-props'
import { getBuiltinRequestContext } from '../after/builtin-request-context'
import { getImplicitTags } from '../lib/implicit-tags'
Expand Down Expand Up @@ -266,6 +267,11 @@ export async function adapter(
})
let response
let cookiesFromResponse
// The middleware span's trace context to forward to the downstream request
// (see `forwardTraceContextToRequest`), and the request headers as the
// middleware received them.
let forwardedTraceContext: TraceContextHeaders | undefined
let forwardedRequestHeaders: Headers | undefined

response = await propagator(request, () => {
// we only care to make async storage available for middleware
Expand Down Expand Up @@ -293,6 +299,16 @@ export async function adapter(
},
},
async () => {
// Forward the middleware span's own context, so the render is always
// nested inside the middleware span, whatever the middleware span is
// parented to (an incoming `traceparent`, a host span, next-server's
// `handleRequest` span, or nothing).
forwardedTraceContext = getTracer().getTraceContextHeaders()
if (forwardedTraceContext) {
// Snapshot before the handler can mutate `request.headers`.
forwardedRequestHeaders = new Headers(request.headers)
}

try {
const onUpdateCookies = (cookies: Array<string>) => {
cookiesFromResponse = cookies
Expand Down Expand Up @@ -520,6 +536,18 @@ export async function adapter(

const finalResponse = response ? response : NextResponse.next()

if (forwardedRequestHeaders) {
// Nest the downstream request (render) inside the middleware span. Every
// host applies these request-header overrides to the render, including
// next-server's router server, so this works whether or not the host
// invokes the middleware separately from the render.
forwardTraceContextToRequest(
finalResponse.headers,
forwardedRequestHeaders,
forwardedTraceContext
)
}

// Flight headers are not overridable / removable so they are applied at the end.
const middlewareOverrideHeaders = finalResponse.headers.get(
'x-middleware-override-headers'
Expand Down
163 changes: 163 additions & 0 deletions packages/next/src/server/web/forward-trace-context.test.ts
Original file line number Diff line number Diff line change
@@ -0,0 +1,163 @@
import { forwardTraceContextToRequest } from './forward-trace-context'
import { NextResponse } from './spec-extension/response'

const TRACEPARENT = '00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01'
const TRACESTATE = 'vendor=value'

function requestOverrides(headers: Headers) {
const list = headers.get('x-middleware-override-headers')
if (list === null) return undefined
return Object.fromEntries(
list
.split(',')
.filter(Boolean)
.map((key) => [key, headers.get(`x-middleware-request-${key}`)])
)
}

describe('forwardTraceContextToRequest', () => {
const requestHeaders = () =>
new Headers({ accept: 'text/html', cookie: 'a=b', 'x-custom': 'custom' })

it('lists every request header plus the trace context without user overrides', () => {
const response = NextResponse.next()
forwardTraceContextToRequest(response.headers, requestHeaders(), {
traceparent: TRACEPARENT,
tracestate: TRACESTATE,
})

expect(requestOverrides(response.headers)).toEqual({
accept: 'text/html',
cookie: 'a=b',
'x-custom': 'custom',
traceparent: TRACEPARENT,
tracestate: TRACESTATE,
})
})

it('replaces a traceparent the middleware received when there are no user overrides', () => {
const headers = requestHeaders()
headers.set(
'traceparent',
'00-11111111111111111111111111111111-2222222222222222-01'
)
const response = NextResponse.next()
forwardTraceContextToRequest(response.headers, headers, {
traceparent: TRACEPARENT,
})

const overrides = requestOverrides(response.headers)!
expect(overrides.traceparent).toBe(TRACEPARENT)
expect(
response.headers
.get('x-middleware-override-headers')!
.split(',')
.filter((key) => key === 'traceparent')
).toHaveLength(1)
})

it('works for rewrites', () => {
const response = NextResponse.rewrite(new URL('https://example.com/other'))
forwardTraceContextToRequest(response.headers, requestHeaders(), {
traceparent: TRACEPARENT,
})

expect(requestOverrides(response.headers)?.traceparent).toBe(TRACEPARENT)
})

it('only appends the trace context to existing user overrides', () => {
const userHeaders = new Headers({ 'x-user': 'user' })
const response = NextResponse.next({ request: { headers: userHeaders } })
forwardTraceContextToRequest(response.headers, requestHeaders(), {
traceparent: TRACEPARENT,
tracestate: TRACESTATE,
})

expect(requestOverrides(response.headers)).toEqual({
'x-user': 'user',
traceparent: TRACEPARENT,
tracestate: TRACESTATE,
})
})

it('keeps a traceparent explicitly set by the user', () => {
const userTraceparent =
'00-33333333333333333333333333333333-4444444444444444-01'
const response = NextResponse.next({
request: { headers: new Headers({ traceparent: userTraceparent }) },
})
forwardTraceContextToRequest(response.headers, requestHeaders(), {
traceparent: TRACEPARENT,
tracestate: TRACESTATE,
})

expect(requestOverrides(response.headers)).toEqual({
traceparent: userTraceparent,
tracestate: TRACESTATE,
})
})

it('replaces trace context headers copied unchanged into user overrides', () => {
const receivedTraceparent =
'00-11111111111111111111111111111111-2222222222222222-01'
const received = requestHeaders()
received.set('traceparent', receivedTraceparent)
received.set('tracestate', 'received=1')
// The common `new Headers(request.headers)` pattern copies the received
// trace context into the overrides without choosing it.
const userHeaders = new Headers(received)
userHeaders.set('x-user', 'user')
const response = NextResponse.next({ request: { headers: userHeaders } })
forwardTraceContextToRequest(response.headers, received, {
traceparent: TRACEPARENT,
tracestate: TRACESTATE,
})

const overrides = requestOverrides(response.headers)!
expect(overrides.traceparent).toBe(TRACEPARENT)
expect(overrides.tracestate).toBe(TRACESTATE)
expect(overrides['x-user']).toBe('user')
expect(
response.headers
.get('x-middleware-override-headers')!
.split(',')
.filter((key) => key === 'traceparent' || key === 'tracestate')
).toEqual(['traceparent', 'tracestate'])
})

it('treats an empty user override list like no overrides', () => {
const response = NextResponse.next({ request: { headers: new Headers() } })
expect(response.headers.get('x-middleware-override-headers')).toBe('')
forwardTraceContextToRequest(response.headers, requestHeaders(), {
traceparent: TRACEPARENT,
})

expect(requestOverrides(response.headers)).toEqual({
accept: 'text/html',
cookie: 'a=b',
'x-custom': 'custom',
traceparent: TRACEPARENT,
})
})

it('does nothing without a trace context', () => {
const response = NextResponse.next()
forwardTraceContextToRequest(response.headers, requestHeaders(), undefined)

expect(requestOverrides(response.headers)).toBeUndefined()
expect([...response.headers.keys()]).toEqual(['x-middleware-next'])
})

it.each([
['a redirect', () => NextResponse.redirect('https://example.com/')],
['a direct response', () => new NextResponse('hello')],
])('does nothing for %s', (_, createResponse) => {
const response = createResponse()
const before = [...response.headers.entries()]
forwardTraceContextToRequest(response.headers, requestHeaders(), {
traceparent: TRACEPARENT,
})

expect([...response.headers.entries()]).toEqual(before)
})
})
Loading
Loading