feat(nextjs): Extract tracing logic from server component wrapper templates

dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/(nested-layout)/nested-layout/[dynamic]/layout.tsx

@@ -0,0 +1,12 @@
+import { PropsWithChildren } from 'react';
+
+export const dynamic = 'force-dynamic';
+
+export default function Layout({ children }: PropsWithChildren<{}>) {
+ return (
+ <div>
+ <p>DynamicLayout</p>
+ {children}
+ </div>
+ );
+}

dev-packages/e2e-tests/test-applications/nextjs-app-dir/app/(nested-layout)/nested-layout/[dynamic]/page.tsx

@@ -0,0 +1,15 @@
+export const dynamic = 'force-dynamic';
+
+export default async function Page() {
+ return (
+ <div>
+ <p>Dynamic Page</p>
+ </div>
+ );
+}
+
+export async function generateMetadata() {
+ return {
+ title: 'I am dynamic page generated metadata',
+ };
+}

dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/connected-servercomponent-trace.test.ts

@@ -1,5 +1,6 @@
 import { expect, test } from '@playwright/test';
 import { waitForTransaction } from '@sentry-internal/test-utils';
+import { isNext13 } from './nextjsVersion';
 
 test('Will create a transaction with spans for every server component and metadata generation functions when visiting a page', async ({
  page,
@@ -14,8 +15,49 @@ test('Will create a transaction with spans for every server component and metada
  return span.description;
  });
 
- expect(spanDescriptions).toContainEqual('Layout Server Component (/(nested-layout)/nested-layout)');
- expect(spanDescriptions).toContainEqual('Layout Server Component (/(nested-layout))');
- expect(spanDescriptions).toContainEqual('Page Server Component (/(nested-layout)/nested-layout)');
+ expect(spanDescriptions).toContainEqual('render route (app) /nested-layout');
+ expect(spanDescriptions).toContainEqual('generateMetadata /(nested-layout)/nested-layout/page');
  expect(spanDescriptions).toContainEqual('Page.generateMetadata (/(nested-layout)/nested-layout)');
+
+ // Next.js 13 has limited OTEL support for server components, so we don't expect to see the following spans
+ if (!isNext13) {
+ expect(spanDescriptions).toContainEqual('resolve page components');
+ expect(spanDescriptions).toContainEqual('build component tree');
+ expect(spanDescriptions).toContainEqual('resolve root layout server component');
+ expect(spanDescriptions).toContainEqual('resolve layout server component "(nested-layout)"');
+ expect(spanDescriptions).toContainEqual('resolve layout server component "nested-layout"');
+ expect(spanDescriptions).toContainEqual('resolve page server component "/nested-layout"');
+ expect(spanDescriptions).toContainEqual('start response');
+ }
+});
+
+test('Will create a transaction with spans for every server component and metadata generation functions when visiting a dynamic page', async ({
+ page,
+}) => {
+ const serverTransactionEventPromise = waitForTransaction('nextjs-app-dir', async transactionEvent => {
+ console.log(transactionEvent?.transaction);
+ return transactionEvent?.transaction === 'GET /nested-layout/[dynamic]';
+ });
+
+ await page.goto('/nested-layout/123');
+
+ const spanDescriptions = (await serverTransactionEventPromise).spans?.map(span => {
+ return span.description;
+ });
+
+ expect(spanDescriptions).toContainEqual('render route (app) /nested-layout/[dynamic]');
+ expect(spanDescriptions).toContainEqual('generateMetadata /(nested-layout)/nested-layout/[dynamic]/page');
+ expect(spanDescriptions).toContainEqual('Page.generateMetadata (/(nested-layout)/nested-layout/[dynamic])');
+
+ // Next.js 13 has limited OTEL support for server components, so we don't expect to see the following spans
+ if (!isNext13) {
+ expect(spanDescriptions).toContainEqual('resolve page components');
+ expect(spanDescriptions).toContainEqual('build component tree');
+ expect(spanDescriptions).toContainEqual('resolve root layout server component');
+ expect(spanDescriptions).toContainEqual('resolve layout server component "(nested-layout)"');
+ expect(spanDescriptions).toContainEqual('resolve layout server component "nested-layout"');
+ expect(spanDescriptions).toContainEqual('resolve layout server component "[dynamic]"');
+ expect(spanDescriptions).toContainEqual('resolve page server component "/nested-layout/[dynamic]"');
+ expect(spanDescriptions).toContainEqual('start response');
+ }
 });

dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/nextjsVersion.ts

@@ -0,0 +1,6 @@
+const packageJson = require('../package.json');
+const nextjsVersion = packageJson.dependencies.next;
+const nextjsMajor = Number(nextjsVersion.split('.')[0]);
+
+export const isNext13 = !isNaN(nextjsMajor) && nextjsMajor === 13;
+export const nextjsMajorVersion = nextjsMajor;

dev-packages/e2e-tests/test-applications/nextjs-app-dir/tests/server-components.test.ts

@@ -1,5 +1,6 @@
 import { expect, test } from '@playwright/test';
 import { waitForError, waitForTransaction } from '@sentry-internal/test-utils';
+import { isNext13 } from './nextjsVersion';
 
 test('Sends a transaction for a request to app router', async ({ page }) => {
  const serverComponentTransactionPromise = waitForTransaction('nextjs-app-dir', transactionEvent => {
@@ -70,19 +71,29 @@ test('Should set a "not_found" status on a server component span when notFound()
 
  const transactionEvent = await serverComponentTransactionPromise;
 
- // Transaction should have status ok, because the http status is ok, but the server component span should be not_found
+ // Transaction should have status ok, because the http status is ok, but the render component span should be not_found
  expect(transactionEvent.contexts?.trace?.status).toBe('ok');
  expect(transactionEvent.spans).toContainEqual(
  expect.objectContaining({
- description: 'Page Server Component (/server-component/not-found)',
- op: 'function.nextjs',
+ description: 'render route (app) /server-component/not-found',
  status: 'not_found',
- data: expect.objectContaining({
- 'sentry.nextjs.ssr.function.type': 'Page',
- 'sentry.nextjs.ssr.function.route': '/server-component/not-found',
- }),
  }),
  );
+
+ // Next.js 13 has limited OTEL support for server components, so we don't expect to see the following span
+ if (!isNext13) {
+ // Page server component span should have the right name and attributes
+ expect(transactionEvent.spans).toContainEqual(
+ expect.objectContaining({
+ description: 'resolve page server component "/server-component/not-found"',
+ op: 'function.nextjs',
+ data: expect.objectContaining({
+ 'sentry.nextjs.ssr.function.type': 'Page',
+ 'sentry.nextjs.ssr.function.route': '/server-component/not-found',
+ }),
+ }),
+ );
+ }
 });
 
 test('Should capture an error and transaction for a app router page', async ({ page }) => {
@@ -102,20 +113,30 @@ test('Should capture an error and transaction for a app router page', async ({ p
  // Error event should have the right transaction name
  expect(errorEvent.transaction).toBe(`Page Server Component (/server-component/faulty)`);
 
- // Transaction should have status ok, because the http status is ok, but the server component span should be internal_error
+ // Transaction should have status ok, because the http status is ok, but the render component span should be internal_error
  expect(transactionEvent.contexts?.trace?.status).toBe('ok');
  expect(transactionEvent.spans).toContainEqual(
  expect.objectContaining({
- description: 'Page Server Component (/server-component/faulty)',
- op: 'function.nextjs',
+ description: 'render route (app) /server-component/faulty',
  status: 'internal_error',
- data: expect.objectContaining({
- 'sentry.nextjs.ssr.function.type': 'Page',
- 'sentry.nextjs.ssr.function.route': '/server-component/faulty',
- }),
  }),
  );
 
+ // Next.js 13 has limited OTEL support for server components, so we don't expect to see the following span
+ if (!isNext13) {
+ // The page server component span should have the right name and attributes
+ expect(transactionEvent.spans).toContainEqual(
+ expect.objectContaining({
+ description: 'resolve page server component "/server-component/faulty"',
+ op: 'function.nextjs',
+ data: expect.objectContaining({
+ 'sentry.nextjs.ssr.function.type': 'Page',
+ 'sentry.nextjs.ssr.function.route': '/server-component/faulty',
+ }),
+ }),
+ );
+ }
+
  expect(errorEvent.tags?.['my-isolated-tag']).toBe(true);
  expect(errorEvent.tags?.['my-global-scope-isolated-tag']).not.toBeDefined();
  expect(transactionEvent.tags?.['my-isolated-tag']).toBe(true);

packages/nextjs/src/common/nextSpanAttributes.ts

@@ -1,3 +1,5 @@
 export const ATTR_NEXT_SPAN_TYPE = 'next.span_type';
 export const ATTR_NEXT_SPAN_NAME = 'next.span_name';
 export const ATTR_NEXT_ROUTE = 'next.route';
+export const ATTR_NEXT_SPAN_DESCRIPTION = 'next.span_description';
+export const ATTR_NEXT_SEGMENT = 'next.segment';

packages/nextjs/src/common/utils/tracingUtils.ts

@@ -1,10 +1,23 @@
-import type { PropagationContext } from '@sentry/core';
-import { debug, getActiveSpan, getRootSpan, GLOBAL_OBJ, Scope, spanToJSON, startNewTrace } from '@sentry/core';
+import { ATTR_HTTP_ROUTE } from '@opentelemetry/semantic-conventions';
+import type { PropagationContext, Span, SpanAttributes } from '@sentry/core';
+import {
+ debug,
+ getActiveSpan,
+ getRootSpan,
+ GLOBAL_OBJ,
+ Scope,
+ SEMANTIC_ATTRIBUTE_SENTRY_OP,
+ spanToJSON,
+ startNewTrace,
+} from '@sentry/core';
 import { DEBUG_BUILD } from '../debug-build';
+import { ATTR_NEXT_SEGMENT, ATTR_NEXT_SPAN_NAME, ATTR_NEXT_SPAN_TYPE } from '../nextSpanAttributes';
 import { TRANSACTION_ATTR_SHOULD_DROP_TRANSACTION } from '../span-attributes-with-logic-attached';
 
 const commonPropagationContextMap = new WeakMap<object, PropagationContext>();
 
+const PAGE_SEGMENT = '__PAGE__';
+
 /**
  * Takes a shared (garbage collectable) object between resources, e.g. a headers object shared between Next.js server components and returns a common propagation context.
  *
@@ -108,3 +121,61 @@ export function dropNextjsRootContext(): void {
  }
  }
 }
+
+/**
+ * Checks if the span is a resolve segment span.
+ * @param spanAttributes The attributes of the span to check.
+ * @returns True if the span is a resolve segment span, false otherwise.
+ */
+export function isResolveSegmentSpan(spanAttributes: SpanAttributes): boolean {
+ return (
+ spanAttributes[ATTR_NEXT_SPAN_TYPE] === 'NextNodeServer.getLayoutOrPageModule' &&
+ spanAttributes[ATTR_NEXT_SPAN_NAME] === 'resolve segment modules' &&
+ typeof spanAttributes[ATTR_NEXT_SEGMENT] === 'string'
+ );
+}
+
+/**
+ * Returns the enhanced name for a resolve segment span.
+ * @param segment The segment of the resolve segment span.
+ * @param route The route of the resolve segment span.
+ * @returns The enhanced name for the resolve segment span.
+ */
+export function getEnhancedResolveSegmentSpanName({ segment, route }: { segment: string; route: string }): string {
+ if (segment === PAGE_SEGMENT) {
+ return `resolve page server component "${route}"`;
+ }
+
+ if (segment === '') {
+ return 'resolve root layout server component';
+ }
+
+ return `resolve layout server component "${segment}"`;
+}
+
+/**
+ * Maybe enhances the span name for a resolve segment span.
+ * If the span is not a resolve segment span, this function does nothing.
+ * @param activeSpan The active span.
+ * @param spanAttributes The attributes of the span to check.
+ * @param rootSpanAttributes The attributes of the according root span.
+ */
+export function maybeEnhanceServerComponentSpanName(
+ activeSpan: Span,
+ spanAttributes: SpanAttributes,
+ rootSpanAttributes: SpanAttributes,
+): void {
+ if (!isResolveSegmentSpan(spanAttributes)) {
+ return;
+ }
+
+ const segment = spanAttributes[ATTR_NEXT_SEGMENT] as string;
+ const route = rootSpanAttributes[ATTR_HTTP_ROUTE];
+ const enhancedName = getEnhancedResolveSegmentSpanName({ segment, route: typeof route === 'string' ? route : '' });
+ activeSpan.updateName(enhancedName);
+ activeSpan.setAttributes({
+ 'sentry.nextjs.ssr.function.type': segment === PAGE_SEGMENT ? 'Page' : 'Layout',
+ 'sentry.nextjs.ssr.function.route': route,
+ });
+ activeSpan.setAttribute(SEMANTIC_ATTRIBUTE_SENTRY_OP, 'function.nextjs');
+}