@@ -6,7 +6,7 @@
 
 Work in this release was contributed by @zkasuran. Thank you for your contribution!
 
-- **feat(nextjs)**: Browser pageloads of apps with `cacheComponents` enabled now connect to the server request again. The SDK stopped emitting `sentry-trace` meta tags for these apps because a cached shell could replay the trace of the request that rendered it to every later visitor. The server SDK now refuses to hand out trace context while Next.js prerenders a document, so cached shells never carry a trace, and a tag that is in the document was always rendered for the current request. This also covers ISR pages, which no longer need the client-side meta tag removal based on `generateStaticParams`; the `isrRoutes` field of the injected route manifest is gone.
+- **feat(nextjs)**: Browser pageloads of apps with `cacheComponents` enabled now connect to the server request again. The SDK stopped emitting `sentry-trace` meta tags for these apps because a cached shell could replay the trace of the request that rendered it to every later visitor. The server SDK now refuses to hand out trace context while Next.js prerenders a document, so cached shells never carry a trace, and a tag that is in the document was always rendered for the current request. The guard is part of the tracer provider and propagator the SDK registers, so it does not cover apps that set up OpenTelemetry themselves. This also covers ISR pages, which no longer need the client-side meta tag removal based on `generateStaticParams`; the `isrRoutes` field of the injected route manifest is gone.
 
 ## 11.5.0
 
 
@@ -176,13 +176,11 @@ export function init(options: NodeOptions): NodeClient | undefined {
     addNextjsServerSpanHooks(client);
   }
 
-  // Next.js reads the trace meta tags of a document through the global propagator. The Next.js-aware
-  // one refuses to hand out trace context while a shell is prerendered, so no cached shell can replay
-  // a trace to later visitors. The Node SDK only sets `traceProvider` when it registered its own
-  // tracer provider and propagator; when another OpenTelemetry setup (for example `@vercel/otel`)
-  // owns them, theirs stays in place.
+  // Next.js reads the trace meta tags of a document through the global propagator. Only the setup the
+  // Node SDK owns gets the Next.js-aware one; another OpenTelemetry setup (for example `@vercel/otel`)
+  // keeps its own tracer provider and propagator.
   if (client?.traceProvider) {
-    registerNextSentryPropagator();
+    registerNextSentryPropagator(client.traceProvider);
   }
 
   // On the client, not the global scope, so a later `init()` after
 
@@ -1,32 +1,59 @@
-import type { Context, TextMapSetter } from '@opentelemetry/api';
-import { propagation } from '@opentelemetry/api';
-import type { Span } from '@sentry/core';
-import { getActiveSpan, spanToJSON } from '@sentry/core';
+import type { Context, SpanOptions, TextMapSetter, Tracer, TracerProvider } from '@opentelemetry/api';
+import { context, createContextKey, propagation } from '@opentelemetry/api';
 import { SentryPropagator } from '@sentry/opentelemetry';
 import { ATTR_NEXT_SPAN_NAME, ATTR_NEXT_SPAN_TYPE } from '../common/nextSpanAttributes';
 
 const APP_RENDER_BODY_SPAN_TYPE = 'AppRender.getBodyResult';
 const PRERENDER_ROUTE_SPAN_NAME_PREFIX = 'prerender route';
 
+const PRERENDER_CONTEXT_KEY = createContextKey('sentry.nextjs.prerender');
+
 /**
- * Whether the span is the one Next.js wraps a prerender in. Next.js computes the `sentry-trace` and
- * `baggage` meta tags of a document inside that span, and a prerender produces a shell that is cached
- * and served to later visitors. A render for a request, including the resume of a prerendered shell,
- * computes the tags outside of it.
+ * Whether these are the start arguments of the span Next.js wraps a prerender in. Next.js computes the
+ * `sentry-trace` and `baggage` meta tags of a document inside that span, and a prerender produces a
+ * shell that is cached and served to later visitors. A render for a request, including the resume of
+ * a prerendered shell, computes the tags outside of it.
  */
-export function isPrerenderSpan(span: Span | undefined): boolean {
-  if (!span) {
-    return false;
-  }
-  const { attributes } = spanToJSON(span);
-  const spanName = attributes?.[ATTR_NEXT_SPAN_NAME];
+export function isPrerenderSpanStart(name: string, options: SpanOptions | undefined): boolean {
+  const attributes = options?.attributes;
+  const spanName = attributes?.[ATTR_NEXT_SPAN_NAME] ?? name;
   return (
     attributes?.[ATTR_NEXT_SPAN_TYPE] === APP_RENDER_BODY_SPAN_TYPE &&
     typeof spanName === 'string' &&
     spanName.startsWith(PRERENDER_ROUTE_SPAN_NAME_PREFIX)
   );
 }
 
+/** Whether the context belongs to a prerender started through a tracer of a wrapped provider. */
+export function isPrerenderContext(ctx: Context): boolean {
+  return ctx.getValue(PRERENDER_CONTEXT_KEY) === true;
+}
+
+/**
+ * Marks the context of a prerender span on the OpenTelemetry context rather than on the span. The
+ * context is inherited by everything that runs inside the prerender, and it exists even when the
+ * request is not sampled, in which case the prerender span is non-recording and carries no
+ * attributes to recognize it by.
+ */
+function wrapTracer(tracer: Tracer): Tracer {
+  return {
+    startSpan: (name, options, ctx) => tracer.startSpan(name, options, ctx),
+    startActiveSpan: (name: string, ...args: unknown[]) => {
+      const startActiveSpan = tracer.startActiveSpan.bind(tracer) as (name: string, ...args: unknown[]) => unknown;
+      const options = typeof args[0] === 'function' ? undefined : (args[0] as SpanOptions | undefined);
+      if (!isPrerenderSpanStart(name, options)) {
+        return startActiveSpan(name, ...args);
+      }
+
+      const explicitContext = args.length === 3 ? (args[1] as Context) : undefined;
+      if (explicitContext) {
+        return startActiveSpan(name, args[0], explicitContext.setValue(PRERENDER_CONTEXT_KEY, true), args[2]);
+      }
+      return context.with(context.active().setValue(PRERENDER_CONTEXT_KEY, true), () => startActiveSpan(name, ...args));
+    },
+  };
+}
+
 /**
  * A `SentryPropagator` that does not hand out trace context while Next.js prerenders a document.
  * Trace context baked into a prerendered shell would be replayed to every visitor the shell is
@@ -35,17 +62,30 @@ export function isPrerenderSpan(span: Span | undefined): boolean {
 export class NextSentryPropagator extends SentryPropagator {
   /** @inheritDoc */
   public inject(ctx: Context, carrier: unknown, setter: TextMapSetter): void {
-    if (isPrerenderSpan(getActiveSpan())) {
+    if (isPrerenderContext(ctx)) {
       return;
     }
     super.inject(ctx, carrier, setter);
   }
 }
 
 /**
- * Replaces the propagator the Node SDK registered with the Next.js-aware one.
+ * Makes the tracer provider the Node SDK registered mark prerenders on the OpenTelemetry context, and
+ * replaces the propagator it registered with one that hands out nothing on a marked context.
  */
-export function registerNextSentryPropagator(): void {
+export function registerNextSentryPropagator(provider: TracerProvider): void {
+  const wrappedTracers = new WeakMap<Tracer, Tracer>();
+  const getTracer = provider.getTracer.bind(provider);
+  provider.getTracer = (...args) => {
+    const tracer = getTracer(...args);
+    let wrapped = wrappedTracers.get(tracer);
+    if (!wrapped) {
+      wrapped = wrapTracer(tracer);
+      wrappedTracers.set(tracer, wrapped);
+    }
+    return wrapped;
+  };
+
   // The OpenTelemetry API refuses a second global propagator, so the one from the Node SDK setup has
   // to be unregistered first.
   propagation.disable();
 
@@ -1,97 +1,136 @@
-import { context, propagation } from '@opentelemetry/api';
+import { context, propagation, trace } from '@opentelemetry/api';
 import { getCurrentScope, setCurrentClient, startSpan } from '@sentry/core';
 import { NodeClient, getDefaultIntegrations } from '@sentry/node';
-import { SentryPropagator } from '@sentry/opentelemetry';
+import { SentryPropagator, SentryTracerProvider } from '@sentry/opentelemetry';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { ATTR_NEXT_SPAN_NAME, ATTR_NEXT_SPAN_TYPE } from '../../src/common/nextSpanAttributes';
 import {
   NextSentryPropagator,
-  isPrerenderSpan,
+  isPrerenderContext,
+  isPrerenderSpanStart,
   registerNextSentryPropagator,
 } from '../../src/server/nextSentryPropagator';
 
-function injectedKeys(propagator: SentryPropagator): string[] {
+const PRERENDER_SPAN_OPTIONS = {
+  attributes: {
+    [ATTR_NEXT_SPAN_TYPE]: 'AppRender.getBodyResult',
+    [ATTR_NEXT_SPAN_NAME]: 'prerender route (app) /[id]',
+  },
+};
+
+const RENDER_SPAN_OPTIONS = {
+  attributes: {
+    [ATTR_NEXT_SPAN_TYPE]: 'AppRender.getBodyResult',
+    [ATTR_NEXT_SPAN_NAME]: 'render route (app) /blocking',
+  },
+};
+
+function inject(): Record<string, string> {
   const carrier: Record<string, string> = {};
-  propagator.inject(context.active(), carrier, {
+  propagation.inject(context.active(), carrier, {
     set: (c, key, value) => ((c as Record<string, string>)[key] = value),
   });
-  return Object.keys(carrier);
+  return carrier;
 }
 
-describe('NextSentryPropagator', () => {
-  beforeEach(() => {
-    const client = new NodeClient({
-      dsn: 'https://public@dsn.ingest.sentry.io/1337',
-      tracesSampleRate: 1,
-      integrations: getDefaultIntegrations({}),
-      stackParser: () => [],
-      transport: () => ({ send: () => Promise.resolve({}), flush: () => Promise.resolve(true) }),
-    });
-    setCurrentClient(client);
-    client.init();
+function setup(tracesSampleRate: number): void {
+  const client = new NodeClient({
+    dsn: 'https://public@dsn.ingest.sentry.io/1337',
+    tracesSampleRate,
+    enableOpenTelemetrySetup: true,
+    integrations: getDefaultIntegrations({}),
+    stackParser: () => [],
+    transport: () => ({ send: () => Promise.resolve({}), flush: () => Promise.resolve(true) }),
   });
+  setCurrentClient(client);
+  client.init();
+
+  const provider = new SentryTracerProvider();
+  trace.setGlobalTracerProvider(provider);
+  propagation.setGlobalPropagator(new SentryPropagator());
+  registerNextSentryPropagator(provider);
+}
+
+describe('NextSentryPropagator', () => {
+  beforeEach(() => setup(1));
 
   afterEach(() => {
     getCurrentScope().setClient(undefined);
+    trace.disable();
+    context.disable();
+    propagation.disable();
     vi.restoreAllMocks();
   });
 
+  it('replaces the registered global propagator', () => {
+    const injectSpy = vi.spyOn(NextSentryPropagator.prototype, 'inject');
+    inject();
+    expect(injectSpy).toHaveBeenCalledTimes(1);
+  });
+
   it('hands out trace context while a route is rendered for a request', () => {
-    const propagator = new NextSentryPropagator();
-
-    startSpan(
-      {
-        name: 'render route (app) /blocking',
-        attributes: {
-          [ATTR_NEXT_SPAN_TYPE]: 'AppRender.getBodyResult',
-          [ATTR_NEXT_SPAN_NAME]: 'render route (app) /blocking',
-        },
-      },
-      span => {
-        expect(isPrerenderSpan(span)).toBe(false);
-        expect(injectedKeys(propagator)).toEqual(expect.arrayContaining(['sentry-trace', 'baggage']));
-      },
-    );
+    trace.getTracer('next.js').startActiveSpan('render route (app) /blocking', RENDER_SPAN_OPTIONS, span => {
+      expect(isPrerenderContext(context.active())).toBe(false);
+      expect(inject()).toEqual({
+        'sentry-trace': `${span.spanContext().traceId}-${span.spanContext().spanId}-1`,
+        baggage: expect.stringContaining('sentry-trace_id='),
+      });
+      span.end();
+    });
   });
 
   it('hands out nothing while a route is prerendered', () => {
-    const propagator = new NextSentryPropagator();
-
-    startSpan(
-      {
-        name: 'prerender route (app) /[id]',
-        attributes: {
-          [ATTR_NEXT_SPAN_TYPE]: 'AppRender.getBodyResult',
-          [ATTR_NEXT_SPAN_NAME]: 'prerender route (app) /[id]',
-        },
-      },
-      span => {
-        expect(isPrerenderSpan(span)).toBe(true);
-        expect(injectedKeys(propagator)).toEqual([]);
-      },
-    );
+    trace.getTracer('next.js').startActiveSpan('prerender route (app) /[id]', PRERENDER_SPAN_OPTIONS, span => {
+      expect(isPrerenderContext(context.active())).toBe(true);
+      expect(inject()).toEqual({});
+      span.end();
+    });
   });
 
-  it('does not mistake other Next.js spans for a prerender', () => {
-    startSpan(
-      {
-        name: 'prerender route (app) /x',
-        attributes: { [ATTR_NEXT_SPAN_TYPE]: 'NextNodeServer.getLayoutOrPageModule' },
-      },
-      span => expect(isPrerenderSpan(span)).toBe(false),
-    );
-    expect(isPrerenderSpan(undefined)).toBe(false);
+  it('hands out nothing inside a span nested in a prerender', () => {
+    trace.getTracer('next.js').startActiveSpan('prerender route (app) /[id]', PRERENDER_SPAN_OPTIONS, span => {
+      startSpan({ name: 'server component' }, () => {
+        expect(inject()).toEqual({});
+      });
+      span.end();
+    });
   });
 
-  it('replaces the registered global propagator', () => {
-    propagation.setGlobalPropagator(new SentryPropagator());
+  it('hands out nothing while a route is prerendered in an unsampled trace', () => {
+    setup(0);
 
-    registerNextSentryPropagator();
+    trace.getTracer('next.js').startActiveSpan('GET /[id]', span => {
+      expect(span.isRecording()).toBe(false);
+      expect(inject()['sentry-trace']).toMatch(/-0$/);
 
-    const carrier: Record<string, string> = {};
-    const injectSpy = vi.spyOn(NextSentryPropagator.prototype, 'inject');
-    propagation.inject(context.active(), carrier);
-    expect(injectSpy).toHaveBeenCalledTimes(1);
-    propagation.disable();
+      trace
+        .getTracer('next.js')
+        .startActiveSpan('prerender route (app) /[id]', PRERENDER_SPAN_OPTIONS, prerenderSpan => {
+          expect(prerenderSpan.isRecording()).toBe(false);
+          expect(inject()).toEqual({});
+          prerenderSpan.end();
+        });
+      span.end();
+    });
+  });
+
+  it('marks an explicitly passed context', () => {
+    trace
+      .getTracer('next.js')
+      .startActiveSpan('prerender route (app) /[id]', PRERENDER_SPAN_OPTIONS, context.active(), span => {
+        expect(isPrerenderContext(context.active())).toBe(true);
+        expect(inject()).toEqual({});
+        span.end();
+      });
+  });
+
+  it('does not mistake other Next.js spans for a prerender', () => {
+    expect(
+      isPrerenderSpanStart('prerender route (app) /x', {
+        attributes: { [ATTR_NEXT_SPAN_TYPE]: 'NextNodeServer.getLayoutOrPageModule' },
+      }),
+    ).toBe(false);
+    expect(isPrerenderSpanStart('prerender route (app) /x', undefined)).toBe(false);
+    expect(isPrerenderSpanStart('prerender route (app) /x', PRERENDER_SPAN_OPTIONS)).toBe(true);
   });
 });
@@ -71,15 +71,16 @@ describe('Server init()', () => {
 
   describe('trace propagator', () => {
     it('replaces the propagator when the Node SDK set up OpenTelemetry itself', () => {
+      const traceProvider = {};
       nodeInit.mockReturnValueOnce({
         on: vi.fn(),
         addEventProcessor: vi.fn(),
-        traceProvider: {},
+        traceProvider,
       } as unknown as ReturnType<typeof SentryNode.init>);
 
       init({});
 
-      expect(registerNextSentryPropagator).toHaveBeenCalledTimes(1);
+      expect(registerNextSentryPropagator).toHaveBeenCalledWith(traceProvider);
     });
 
     it('leaves a foreign OpenTelemetry setup alone', () => {