diff --git a/dev-packages/e2e-tests/test-applications/tanstackstart-react-static/tests/transaction.test.ts b/dev-packages/e2e-tests/test-applications/tanstackstart-react-static/tests/transaction.test.ts index dc5766d6c586..15ec0bd5c4b3 100644 --- a/dev-packages/e2e-tests/test-applications/tanstackstart-react-static/tests/transaction.test.ts +++ b/dev-packages/e2e-tests/test-applications/tanstackstart-react-static/tests/transaction.test.ts @@ -39,9 +39,7 @@ test('Sends a server function transaction with auto-instrumentation', async ({ p ); }); -test('Sends a server function transaction for a nested server function only if it is manually instrumented', async ({ - page, -}) => { +test('Sends a server function transaction for a nested server function', async ({ page }) => { const transactionEventPromise = waitForTransaction('tanstackstart-react-static', transactionEvent => { return ( transactionEvent?.contexts?.trace?.op === 'http.server' && @@ -90,19 +88,27 @@ test('Sends a server function transaction for a nested server function only if i ]), ); - // Verify that globalFunctionMiddleware and testNestedLog are sibling spans under the root - const functionMiddlewareSpan = transactionEvent?.spans?.find( - (span: { description?: string; origin?: string }) => - span.description === 'globalFunctionMiddleware' && span.origin === 'auto.middleware.tanstackstart', - ); - const nestedSpan = transactionEvent?.spans?.find( - (span: { description?: string; origin?: string }) => - span.description === 'testNestedLog' && span.origin === 'manual', + const outerSpan = transactionEvent?.spans?.find(span => span.description === 'GET /_serverFn/testNestedLog'); + const manualSpan = transactionEvent?.spans?.find( + span => span.description === 'testNestedLog' && span.origin === 'manual', ); - expect(functionMiddlewareSpan).toBeDefined(); - expect(nestedSpan).toBeDefined(); + expect(manualSpan?.parent_span_id).toBe(outerSpan?.span_id); - // Both spans should be siblings under the same parent (root transaction) - expect(nestedSpan?.parent_span_id).toBe(functionMiddlewareSpan?.parent_span_id); + // The server function called inside the manual span gets its own span + expect(transactionEvent?.spans).toEqual( + expect.arrayContaining([ + expect.objectContaining({ + description: 'GET /_serverFn/testLog', + origin: 'auto.function.tanstackstart.server', + parent_span_id: manualSpan?.span_id, + status: 'ok', + }), + expect.objectContaining({ + description: 'globalFunctionMiddleware', + origin: 'auto.middleware.tanstackstart', + parent_span_id: outerSpan?.span_id, + }), + ]), + ); }); diff --git a/dev-packages/e2e-tests/test-applications/tanstackstart-react/tests/transaction.test.ts b/dev-packages/e2e-tests/test-applications/tanstackstart-react/tests/transaction.test.ts index 0de6d3b9788a..eec99d1b98ae 100644 --- a/dev-packages/e2e-tests/test-applications/tanstackstart-react/tests/transaction.test.ts +++ b/dev-packages/e2e-tests/test-applications/tanstackstart-react/tests/transaction.test.ts @@ -1,5 +1,7 @@ import { expect, test } from '@playwright/test'; import { collectStreamedSpans, getSpanOp } from '@sentry-internal/test-utils'; +import { SENTRY_DESCRIPTION, SENTRY_OP, SENTRY_ORIGIN } from '@sentry/conventions/attributes'; +import { FUNCTION } from '@sentry/conventions/op'; function isServerFnSegment(span: Parameters[0]): boolean { return ( @@ -44,20 +46,17 @@ test('Sends a server function span with auto-instrumentation', async ({ page }) ); }); -test('Sends a server function span for a nested server function only if it is manually instrumented', async ({ - page, -}) => { +test('Sends a server function span for a nested server function', async ({ page }) => { + const isAutoSpan = (span: { name?: string; attributes: Record }, name: string) => + span.name === name && span.attributes[SENTRY_ORIGIN]?.value === 'auto.function.tanstackstart.server'; + const spansPromise = collectStreamedSpans( 'tanstackstart-react', spans => spans.some(isServerFnSegment) && - spans.some( - span => - span.name === 'testNestedLog' && - span.attributes['sentry.origin']?.value === 'auto.function.tanstackstart.server', - ) && - spans.some(span => span.name === 'testNestedLog') && - spans.some(span => span.name === 'globalFunctionMiddleware'), + spans.some(span => isAutoSpan(span, 'testNestedLog')) && + spans.some(span => isAutoSpan(span, 'testLog')) && + spans.some(span => span.name === 'testNestedLog' && span.attributes[SENTRY_ORIGIN]?.value === 'manual'), ); await page.goto('/test-serverFn'); @@ -68,43 +67,41 @@ test('Sends a server function span for a nested server function only if it is ma const spans = await spansPromise; - expect(spans).toEqual( - expect.arrayContaining([ - expect.objectContaining({ - name: 'testNestedLog', - status: 'ok', - attributes: expect.objectContaining({ - 'sentry.op': { type: 'string', value: 'function' }, - 'sentry.origin': { type: 'string', value: 'auto.function.tanstackstart.server' }, - 'sentry.description': { type: 'string', value: 'GET /_serverFn/testNestedLog' }, - 'tanstackstart.function.filename': { type: 'string', value: 'src/routes/test-serverFn.tsx' }, - }), - }), - ]), + const outerSpan = spans.find(span => isAutoSpan(span, 'testNestedLog')); + const manualSpan = spans.find( + span => span.name === 'testNestedLog' && span.attributes[SENTRY_ORIGIN]?.value === 'manual', ); + const nestedSpan = spans.find(span => isAutoSpan(span, 'testLog')); + + expect(outerSpan).toMatchObject({ + name: 'testNestedLog', + status: 'ok', + attributes: expect.objectContaining({ + [SENTRY_OP]: { type: 'string', value: FUNCTION }, + [SENTRY_DESCRIPTION]: { type: 'string', value: 'GET /_serverFn/testNestedLog' }, + 'tanstackstart.function.filename': { type: 'string', value: 'src/routes/test-serverFn.tsx' }, + }), + }); + expect(manualSpan).toMatchObject({ status: 'ok', parent_span_id: outerSpan?.span_id }); + expect(nestedSpan).toMatchObject({ + name: 'testLog', + status: 'ok', + parent_span_id: manualSpan?.span_id, + attributes: expect.objectContaining({ + [SENTRY_OP]: { type: 'string', value: FUNCTION }, + [SENTRY_DESCRIPTION]: { type: 'string', value: 'GET /_serverFn/testLog' }, + }), + }); expect(spans).toEqual( expect.arrayContaining([ expect.objectContaining({ - name: 'testNestedLog', - status: 'ok', + name: 'globalFunctionMiddleware', + parent_span_id: outerSpan?.span_id, attributes: expect.objectContaining({ - 'sentry.origin': { type: 'string', value: 'manual' }, + [SENTRY_ORIGIN]: { type: 'string', value: 'auto.middleware.tanstackstart' }, }), }), ]), ); - - const functionMiddlewareSpan = spans.find( - span => - span.name === 'globalFunctionMiddleware' && - span.attributes['sentry.origin']?.value === 'auto.middleware.tanstackstart', - ); - const nestedSpan = spans.find( - span => span.name === 'testNestedLog' && span.attributes['sentry.origin']?.value === 'manual', - ); - - expect(functionMiddlewareSpan).toBeDefined(); - expect(nestedSpan).toBeDefined(); - expect(nestedSpan?.parent_span_id).toBe(functionMiddlewareSpan?.parent_span_id); }); diff --git a/packages/tanstackstart-react/src/server/globalMiddleware.ts b/packages/tanstackstart-react/src/server/globalMiddleware.ts index 9a232041d245..da5d1d1597a7 100644 --- a/packages/tanstackstart-react/src/server/globalMiddleware.ts +++ b/packages/tanstackstart-react/src/server/globalMiddleware.ts @@ -1,11 +1,9 @@ import { addNonEnumerableProperty, captureException, - getActiveSpan, getClient, hasSpanStreamingEnabled, - spanToJSON, - updateSpanName, + startSpan, } from '@sentry/core'; import type { SentryGlobalFunctionMiddleware, SentryGlobalRequestMiddleware } from '../common/types'; import { SENTRY_INTERNAL } from './middleware'; @@ -13,9 +11,10 @@ import { CODE_FUNCTION_NAME, HTTP_REQUEST_METHOD, SENTRY_DESCRIPTION, - SENTRY_SEGMENT_NAME_SOURCE, + SENTRY_OP, SENTRY_ORIGIN, } from '@sentry/conventions/attributes'; +import { FUNCTION } from '@sentry/conventions/op'; type ServerFnMeta = { id?: string; @@ -37,48 +36,46 @@ function createSentryMiddlewareHandler(mechanismType: string) { } function createSentryFunctionMiddlewareHandler(mechanismType: string) { - return async function sentryFunctionMiddlewareHandler({ + return function sentryFunctionMiddlewareHandler({ next, serverFnMeta, + method = 'GET', }: { next: () => Promise; serverFnMeta?: ServerFnMeta; + method?: string; }): Promise { - const activeSpan = getActiveSpan(); - const spanData = activeSpan ? spanToJSON(activeSpan) : undefined; - if (activeSpan && spanData?.attributes[SENTRY_ORIGIN] === 'auto.function.tanstackstart.server') { - if (serverFnMeta?.name) { - // Read off the attribute rather than the span name, which is low cardinality with span streaming. - const method = (spanData.attributes[HTTP_REQUEST_METHOD] as string | undefined) || 'GET'; - const description = `${method} /_serverFn/${serverFnMeta.name}`; - const client = getClient(); - const hasSpanStreaming = !!client && hasSpanStreamingEnabled(client); + const functionName = serverFnMeta?.name || 'serverFn'; + const description = `${method} /_serverFn/${functionName}`; + const client = getClient(); + const hasSpanStreaming = !!client && hasSpanStreamingEnabled(client); + return startSpan( + { // With span streaming, a `function` span is named after the function it wraps. - updateSpanName(activeSpan, hasSpanStreaming ? serverFnMeta.name : description); - activeSpan.setAttribute(CODE_FUNCTION_NAME, serverFnMeta.name); - if (hasSpanStreaming) { - // Relay infers a `function` span's description from `code.function.name` alone. - activeSpan.setAttribute(SENTRY_DESCRIPTION, description); + name: hasSpanStreaming ? functionName : description, + attributes: { + [SENTRY_ORIGIN]: 'auto.function.tanstackstart.server', + [SENTRY_OP]: FUNCTION, + [CODE_FUNCTION_NAME]: functionName, + [HTTP_REQUEST_METHOD]: method, + // Relay infers a `function` span's description from `code.function.name` alone, which drops the path. + ...(hasSpanStreaming && { [SENTRY_DESCRIPTION]: description }), + ...(serverFnMeta?.id && { 'tanstackstart.function.id': serverFnMeta.id }), + ...(serverFnMeta?.filename && { 'tanstackstart.function.filename': serverFnMeta.filename }), + }, + }, + async () => { + try { + return await next(); + } catch (e) { + captureException(e, { + mechanism: { type: mechanismType, handled: false }, + }); + throw e; } - activeSpan.setAttribute(SENTRY_SEGMENT_NAME_SOURCE, 'route'); - } - if (serverFnMeta?.id) { - activeSpan.setAttribute('tanstackstart.function.id', serverFnMeta.id); - } - if (serverFnMeta?.filename) { - activeSpan.setAttribute('tanstackstart.function.filename', serverFnMeta.filename); - } - } - - try { - return await next(); - } catch (e) { - captureException(e, { - mechanism: { type: mechanismType, handled: false }, - }); - throw e; - } + }, + ); }; } @@ -98,7 +95,7 @@ export const sentryGlobalRequestMiddleware: SentryGlobalRequestMiddleware = { }; /** - * Global function middleware that captures errors from server function invocations. + * Global function middleware that creates a span for each server function invocation and captures its errors. * Should be added as the first entry in the `functionMiddleware` array of `createStart()`. */ export const sentryGlobalFunctionMiddleware: SentryGlobalFunctionMiddleware = { diff --git a/packages/tanstackstart-react/src/server/wrapFetchWithSentry.ts b/packages/tanstackstart-react/src/server/wrapFetchWithSentry.ts index 89cab78809a5..9691f030c835 100644 --- a/packages/tanstackstart-react/src/server/wrapFetchWithSentry.ts +++ b/packages/tanstackstart-react/src/server/wrapFetchWithSentry.ts @@ -1,14 +1,6 @@ -import { getClient, getTraceMetaTags, hasSpanStreamingEnabled } from '@sentry/core'; +import { getTraceMetaTags } from '@sentry/core'; import { flushIfServerless } from '@sentry/core/server'; -import { captureException, startSpan } from '@sentry/node'; -import { - CODE_FUNCTION_NAME, - HTTP_REQUEST_METHOD, - SENTRY_DESCRIPTION, - SENTRY_OP, - SENTRY_ORIGIN, -} from '@sentry/conventions/attributes'; -import { FUNCTION } from '@sentry/conventions/op'; +import { captureException } from '@sentry/node'; import { updateSpanWithRouteParametrization } from './routeParametrization'; declare const __SENTRY_ROUTE_PATTERNS__: string[] | undefined; @@ -148,32 +140,10 @@ export function wrapFetchWithSentry(serverEntry: ServerEntry): ServerEntry { const url = new URL(request.url); const method = request.method || 'GET'; - // instrument server functions - if (url.pathname.includes('_serverFn') || url.pathname.includes('createServerFn')) { - const client = getClient(); - const hasSpanStreaming = !!client && hasSpanStreamingEnabled(client); - const description = `${method} ${url.pathname}`; - - return await startSpan( - { - // With span streaming, a `function` span is named after the function it wraps. The - // request path carries the generated server function id, which is high cardinality. - name: hasSpanStreaming ? 'serverFn' : description, - attributes: { - [SENTRY_ORIGIN]: 'auto.function.tanstackstart.server', - [SENTRY_OP]: FUNCTION, - [CODE_FUNCTION_NAME]: 'serverFn', - // The global function middleware renames this span and needs the method, which it - // can no longer read off a low-cardinality span name. - [HTTP_REQUEST_METHOD]: method, - // Relay infers a `function` span's description from `code.function.name` alone, which drops the path. - ...(hasSpanStreaming && { [SENTRY_DESCRIPTION]: description }), - }, - }, - async () => { - return target.apply(thisArg, args); - }, - ); + // Server functions are neither routes nor pages: a splat route must not name their request, and their + // response gets no trace meta tags. Their span is created by `sentryGlobalFunctionMiddleware`. + if (url.pathname.includes('_serverFn')) { + return await target.apply(thisArg, args); } if (typeof __SENTRY_ROUTE_PATTERNS__ !== 'undefined') { diff --git a/packages/tanstackstart-react/test/server/globalMiddleware.test.ts b/packages/tanstackstart-react/test/server/globalMiddleware.test.ts index e0361e8afb33..32a523489853 100644 --- a/packages/tanstackstart-react/test/server/globalMiddleware.test.ts +++ b/packages/tanstackstart-react/test/server/globalMiddleware.test.ts @@ -1,9 +1,15 @@ import { afterEach, describe, expect, it, vi } from 'vitest'; +import { + CODE_FUNCTION_NAME, + HTTP_REQUEST_METHOD, + SENTRY_DESCRIPTION, + SENTRY_OP, + SENTRY_ORIGIN, +} from '@sentry/conventions/attributes'; +import { FUNCTION } from '@sentry/conventions/op'; const captureExceptionSpy = vi.fn(); -const updateSpanNameSpy = vi.fn(); -const getActiveSpanSpy = vi.fn<() => unknown>(() => undefined); -const spanToJSONSpy = vi.fn<() => { name: string; attributes: Record }>(); +const startSpanSpy = vi.fn((_: unknown, callback: () => unknown) => callback()); // Span streaming is the default trace lifecycle; `undefined` stands for a not-yet-initialized SDK. const getClientSpy = vi.fn<() => { getOptions: () => { traceLifecycle: string } } | undefined>(() => undefined); @@ -12,10 +18,8 @@ vi.mock('@sentry/core', async importOriginal => { return { ...original, captureException: (...args: unknown[]) => captureExceptionSpy(...args), - getActiveSpan: () => getActiveSpanSpy(), getClient: () => getClientSpy(), - spanToJSON: () => spanToJSONSpy(), - updateSpanName: (...args: unknown[]) => updateSpanNameSpy(...args), + startSpan: (options: unknown, callback: () => unknown) => startSpanSpy(options, callback), }; }); @@ -78,45 +82,75 @@ describe('sentryGlobalFunctionMiddleware', () => { expect((sentryGlobalFunctionMiddleware as unknown as Record)['__SENTRY_INTERNAL__']).toBe(true); }); - describe('server function span naming', () => { - const setUpActiveSpan = (): { setAttribute: ReturnType } => { - const span = { setAttribute: vi.fn() }; - getActiveSpanSpy.mockReturnValue(span); - spanToJSONSpy.mockReturnValue({ - name: 'GET /_serverFn/abc123', - attributes: { 'sentry.origin': 'auto.function.tanstackstart.server', 'http.request.method': 'GET' }, - }); - return span; - }; - + describe('server function span', () => { afterEach(() => { - getActiveSpanSpy.mockReturnValue(undefined); getClientSpy.mockReturnValue(undefined); }); it('names the span after the server function with span streaming', async () => { - const span = setUpActiveSpan(); getClientSpy.mockReturnValue({ getOptions: () => ({ traceLifecycle: 'stream' }) }); + const next = vi.fn().mockResolvedValue('ok'); const serverFn = sentryGlobalFunctionMiddleware.options.server!; - await serverFn({ next: vi.fn().mockResolvedValue('ok'), serverFnMeta: { name: 'testLog' } }); + const result = await serverFn({ + next, + method: 'POST', + serverFnMeta: { name: 'testLog', id: 'abc123', filename: 'src/routes/test.tsx' }, + }); - expect(updateSpanNameSpy).toHaveBeenCalledWith(span, 'testLog'); - expect(span.setAttribute).toHaveBeenCalledWith('code.function.name', 'testLog'); - expect(span.setAttribute).toHaveBeenCalledWith('sentry.description', 'GET /_serverFn/testLog'); + expect(result).toBe('ok'); + expect(next).toHaveBeenCalledTimes(1); + expect(startSpanSpy).toHaveBeenCalledWith( + { + name: 'testLog', + attributes: { + [SENTRY_ORIGIN]: 'auto.function.tanstackstart.server', + [SENTRY_OP]: FUNCTION, + [CODE_FUNCTION_NAME]: 'testLog', + [HTTP_REQUEST_METHOD]: 'POST', + [SENTRY_DESCRIPTION]: 'POST /_serverFn/testLog', + 'tanstackstart.function.id': 'abc123', + 'tanstackstart.function.filename': 'src/routes/test.tsx', + }, + }, + expect.any(Function), + ); }); it('keeps the request path in the span name without span streaming', async () => { - const span = setUpActiveSpan(); getClientSpy.mockReturnValue({ getOptions: () => ({ traceLifecycle: 'static' }) }); const serverFn = sentryGlobalFunctionMiddleware.options.server!; - await serverFn({ next: vi.fn().mockResolvedValue('ok'), serverFnMeta: { name: 'testLog' } }); + await serverFn({ next: vi.fn().mockResolvedValue('ok'), method: 'GET', serverFnMeta: { name: 'testLog' } }); - expect(updateSpanNameSpy).toHaveBeenCalledWith(span, 'GET /_serverFn/testLog'); // The resolved function name is useful in both lifecycles; only the description is a streaming workaround. - expect(span.setAttribute).toHaveBeenCalledWith('code.function.name', 'testLog'); - expect(span.setAttribute).not.toHaveBeenCalledWith('sentry.description', expect.anything()); + expect(startSpanSpy).toHaveBeenCalledWith( + { + name: 'GET /_serverFn/testLog', + attributes: { + [SENTRY_ORIGIN]: 'auto.function.tanstackstart.server', + [SENTRY_OP]: FUNCTION, + [CODE_FUNCTION_NAME]: 'testLog', + [HTTP_REQUEST_METHOD]: 'GET', + }, + }, + expect.any(Function), + ); + }); + + it('falls back to a generic name without server function metadata', async () => { + getClientSpy.mockReturnValue({ getOptions: () => ({ traceLifecycle: 'stream' }) }); + + const serverFn = sentryGlobalFunctionMiddleware.options.server!; + await serverFn({ next: vi.fn().mockResolvedValue('ok') }); + + expect(startSpanSpy).toHaveBeenCalledWith( + expect.objectContaining({ + name: 'serverFn', + attributes: expect.objectContaining({ [SENTRY_DESCRIPTION]: 'GET /_serverFn/serverFn' }), + }), + expect.any(Function), + ); }); }); }); diff --git a/packages/tanstackstart-react/test/server/wrapFetchWithSentry.test.ts b/packages/tanstackstart-react/test/server/wrapFetchWithSentry.test.ts index c606d6c017ab..20983ba61f92 100644 --- a/packages/tanstackstart-react/test/server/wrapFetchWithSentry.test.ts +++ b/packages/tanstackstart-react/test/server/wrapFetchWithSentry.test.ts @@ -1,6 +1,5 @@ import { afterEach, describe, expect, it, vi } from 'vitest'; -const startSpanSpy = vi.fn((_, callback) => callback()); const flushIfServerlessSpy = vi.fn().mockResolvedValue(undefined); const captureExceptionSpy = vi.fn(); @@ -9,7 +8,6 @@ vi.mock('@sentry/node', async importOriginal => { const original = await importOriginal(); return { ...original, - startSpan: (...args: unknown[]) => startSpanSpy(...args), captureException: (...args: unknown[]) => captureExceptionSpy(...args), }; }); @@ -20,15 +18,11 @@ const getTraceMetaTagsSpy = vi '', ); -// Span streaming is the default trace lifecycle; `undefined` stands for a not-yet-initialized SDK. -const getClientSpy = vi.fn<() => { getOptions: () => { traceLifecycle: string } } | undefined>(() => undefined); - vi.mock('@sentry/core', async importOriginal => { const original = await importOriginal(); return { ...original, getTraceMetaTags: () => getTraceMetaTagsSpy(), - getClient: () => getClientSpy(), }; }); @@ -46,8 +40,6 @@ const { wrapFetchWithSentry } = await import('../../src/server/wrapFetchWithSent describe('wrapFetchWithSentry', () => { afterEach(() => { vi.clearAllMocks(); - // `vi.clearAllMocks()` clears calls but not implementations, so this would leak into later tests. - getClientSpy.mockReturnValue(undefined); }); it('calls flushIfServerless after a regular request', async () => { @@ -78,48 +70,20 @@ describe('wrapFetchWithSentry', () => { }, ); - it('creates a function span for server function requests', async () => { - const mockResponse = new Response('ok'); + it('does not inject meta tags into server function responses', async () => { + const mockResponse = new Response('', { + headers: new Headers({ 'content-type': 'text/html; charset=utf-8' }), + }); const fetchFn = vi.fn().mockResolvedValue(mockResponse); const serverEntry = wrapFetchWithSentry({ fetch: fetchFn }); - const request = new Request('http://localhost:3000/_serverFn/abc123'); - await serverEntry.fetch(request); + const response = await serverEntry.fetch(new Request('http://localhost:3000/_serverFn/abc123')); - expect(startSpanSpy).toHaveBeenCalledWith( - expect.objectContaining({ - name: 'GET /_serverFn/abc123', - attributes: expect.objectContaining({ - 'sentry.op': 'function', - }), - }), - expect.any(Function), - ); + expect(response).toBe(mockResponse); expect(flushIfServerlessSpy).toHaveBeenCalledTimes(1); }); - it('keeps the server function path out of the span name with span streaming', async () => { - getClientSpy.mockReturnValue({ getOptions: () => ({ traceLifecycle: 'stream' }) }); - - const fetchFn = vi.fn().mockResolvedValue(new Response('ok')); - const serverEntry = wrapFetchWithSentry({ fetch: fetchFn }); - - await serverEntry.fetch(new Request('http://localhost:3000/_serverFn/abc123')); - - expect(startSpanSpy).toHaveBeenCalledWith( - expect.objectContaining({ - name: 'serverFn', - attributes: expect.objectContaining({ - 'sentry.op': 'function', - 'code.function.name': 'serverFn', - 'sentry.description': 'GET /_serverFn/abc123', - }), - }), - expect.any(Function), - ); - }); - it('injects meta tags into HTML responses', async () => { const mockResponse = new Response('', { headers: new Headers({ 'content-type': 'text/html; charset=utf-8' }),