delete continueTraceFromPropagationContext

Author: s1gr1d

packages/cloudflare/src/request.ts

@@ -4,7 +4,6 @@ import {
   captureException,
   continueTrace,
   flush,
-  getCurrentScope,
   getHttpSpanDetailsFromUrlObject,
   parseStringToURLObject,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
@@ -17,18 +16,7 @@ import { addCloudResourceContext, addCultureContext, addRequest } from './scope-
 import { init } from './sdk';
 
 interface RequestHandlerWrapperOptions {
-  options: CloudflareOptions & {
-    /**
-     * Enable or disable the automatic continuation of traces from the propagation context.
-     *
-     * When enabled, the SDK will continue a trace from the propagation context if it is present.
-     *
-     * When disabled, the SDK will fall back to the default case of continuing a trace from the request headers if they are present.
-     *
-     * @default false
-     */
-    continueTraceFromPropagationContext?: boolean;
-  };
+  options: CloudflareOptions;
   request: Request<unknown, IncomingRequestCfProperties<unknown>>;
   context: ExecutionContext;
 }
@@ -82,40 +70,25 @@ export function wrapRequestHandler(
       }
     }
 
-    // Check if we already have active trace data - if so, don't wrap with continueTrace
-    // This allows us to continue an existing trace from the parent context (e.g. in Nuxt)
-    const existingPropagationContext = getCurrentScope().getPropagationContext();
-    if (options.continueTraceFromPropagationContext && existingPropagationContext?.traceId) {
-      return startSpan({ name, attributes }, cloudflareStartSpanCallback(handler, context));
-    }
-
-    // No active trace, create one from headers
     return continueTrace(
       { sentryTrace: request.headers.get('sentry-trace') || '', baggage: request.headers.get('baggage') },
       () => {
         // Note: This span will not have a duration unless I/O happens in the handler. This is
         // because of how the cloudflare workers runtime works.
         // See: https://developers.cloudflare.com/workers/runtime-apis/performance/
-        return startSpan({ name, attributes }, cloudflareStartSpanCallback(handler, context));
+        return startSpan({ name, attributes }, async (span: Span) => {
+          try {
+            const res = await handler();
+            setHttpStatus(span, res.status);
+            return res;
+          } catch (e) {
+            captureException(e, { mechanism: { handled: false, type: 'cloudflare' } });
+            throw e;
+          } finally {
+            context?.waitUntil(flush(2000));
+          }
+        });
       },
     );
   });
 }
-
-function cloudflareStartSpanCallback(
-  handler: (...args: unknown[]) => Response | Promise<Response>,
-  context?: ExecutionContext,
-) {
-  return async (span: Span) => {
-    try {
-      const res = await handler();
-      setHttpStatus(span, res.status);
-      return res;
-    } catch (e) {
-      captureException(e, { mechanism: { handled: false, type: 'cloudflare' } });
-      throw e;
-    } finally {
-      context?.waitUntil(flush(2000));
-    }
-  };
-}

packages/cloudflare/test/request.test.ts

@@ -220,79 +220,6 @@ describe('withSentry', () => {
         trace_id: '12312012123120121231201212312012',
       });
     });
-
-    test('uses existing propagation context when continueTraceFromPropagationContext is enabled', async () => {
-      const mockGetCurrentScope = vi.spyOn(SentryCore, 'getCurrentScope').mockReturnValue({
-        // return an existing propagation context
-        getPropagationContext: () => ({
-          traceId: '12312012123120121231201212312012',
-          spanId: '1121201211212012',
-        }),
-      } as any);
-
-      const mockStartSpan = vi.spyOn(SentryCore, 'startSpan');
-      const mockContinueTrace = vi.spyOn(SentryCore, 'continueTrace');
-
-      const mockRequest = new Request('https://example.com') as any;
-      // Headers should be ignored when continuing from propagation context
-      mockRequest.headers.set('sentry-trace', '99999999999999999999999999999999-9999999999999999-1');
-
-      await wrapRequestHandler(
-        {
-          options: {
-            ...MOCK_OPTIONS,
-            continueTraceFromPropagationContext: true,
-          },
-          request: mockRequest,
-          context: createMockExecutionContext(),
-        },
-        () => new Response('test'),
-      );
-
-      // Should use startSpan directly instead of continueTrace
-      expect(mockStartSpan).toHaveBeenCalledTimes(1);
-      expect(mockContinueTrace).not.toHaveBeenCalled();
-
-      mockGetCurrentScope.mockRestore();
-      mockStartSpan.mockRestore();
-      mockContinueTrace.mockRestore();
-    });
-
-    test('falls back to header-based trace when continueTraceFromPropagationContext is disabled or no context exists', async () => {
-      const mockGetCurrentScope = vi.spyOn(SentryCore, 'getCurrentScope').mockReturnValue({
-        // return an existing propagation context
-        getPropagationContext: () => ({
-          traceId: '12312012123120121231201212312012',
-          spanId: '1121201211212012',
-        }),
-      } as any);
-
-      const mockContinueTrace = vi.spyOn(SentryCore, 'continueTrace').mockImplementation((_, callback) => {
-        return callback();
-      });
-
-      const mockRequest = new Request('https://example.com') as any;
-      mockRequest.headers.set('sentry-trace', '99999999999999999999999999999999-9999999999999999-1');
-
-      await wrapRequestHandler(
-        {
-          options: {
-            ...MOCK_OPTIONS,
-            continueTraceFromPropagationContext: false, // Explicitly disabled
-          },
-          request: mockRequest,
-          context: createMockExecutionContext(),
-        },
-        () => new Response('test'),
-      );
-
-      // Should use continueTrace even with existing propagation context when option is disabled
-      expect(mockContinueTrace).toHaveBeenCalledTimes(1);
-
-      mockGetCurrentScope.mockRestore();
-      mockContinueTrace.mockRestore();
-    });
-
     test('creates a span that wraps request handler', async () => {
       const mockRequest = new Request('https://example.com') as any;
       mockRequest.cf = {

packages/nuxt/src/runtime/plugins/sentry-cloudflare.server.ts

@@ -77,7 +77,7 @@ export const sentryCloudflareNitroPlugin =
       async apply(handlerTarget, handlerThisArg, handlerArgs: [string, unknown]) {
         setAsyncLocalStorageAsyncContextStrategy();
 
-        const sentryOptions = typeof optionsOrFn === 'function' ? optionsOrFn(nitroApp) : optionsOrFn;
+        const cloudflareOptions = typeof optionsOrFn === 'function' ? optionsOrFn(nitroApp) : optionsOrFn;
         const pathname = handlerArgs[0];
         const event = handlerArgs[1];
 
@@ -86,7 +86,7 @@ export const sentryCloudflareNitroPlugin =
           return handlerTarget.apply(handlerThisArg, handlerArgs);
         } else {
           const requestHandlerOptions = {
-            options: { ...sentryOptions, continueTraceFromPropagationContext: true },
+            options: cloudflareOptions,
             request: { ...event, url: `${event.protocol}//${event.host}${pathname}` },
             context: event.context.cloudflare.context,
           };
@@ -98,7 +98,7 @@ export const sentryCloudflareNitroPlugin =
 
             const traceData = getTraceData();
             if (traceData && Object.keys(traceData).length > 0) {
-              // Storing trace data in the event context for later use in HTML meta tags (enables correct connection of parent/child span relationships)
+              // Storing trace data in the event context for later use in HTML meta-tags (enables correct connection of parent/child span relationships)
               // @ts-expect-error Storing a new key in the event context
               event.context[TRACE_DATA_KEY] = traceData;
               logger.log('Stored trace data in the event context.');
@@ -116,8 +116,6 @@ export const sentryCloudflareNitroPlugin =
       },
     });
 
-    // fixme: multiple pageload spans in one trace
-
     // @ts-expect-error - 'render:html' is a valid hook name in the Nuxt context
     nitroApp.hooks.hook('render:html', (html: NuxtRenderHTMLContext, { event }: { event: H3Event }) => {
       const storedTraceData = event.context[TRACE_DATA_KEY] as ReturnType<typeof getTraceData> | undefined;