fix(cloudflare): Add late channel integrations for SDKs that extend the defaults

The Nuxt and SvelteKit Cloudflare SDKs build `defaultIntegrations` from
the Cloudflare defaults and pass the list to the SDK. Since the SDK
treats any `defaultIntegrations` list as an opt-out, it did not add the
channel integration of a module that loads after `init()`, such as the
`mysql` driver in a route chunk. The `nuxt-4-cloudflare` and
`sveltekit-cloudflare-pages` E2E tests then got no db spans and timed
out.

The new internal option `extendsDefaultIntegrations` tells the SDK that
the list extends the defaults, so it adds late integrations again. The
user's `integrations` function still filters them. Nuxt and SvelteKit
set the option only when they build the list. A list that the user
passes still turns off late integrations.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: isaacs

packages/cloudflare/src/baseSdk.ts

@@ -107,9 +107,10 @@ export function initWithDefaultIntegrations(
     return cached;
   }
 
-  // `false` or a custom list turns off the SDK defaults, late-loaded ones included.
-  const usesSdkDefaults = options.defaultIntegrations === undefined;
-  if (usesSdkDefaults) {
+  // `false` or a custom list turns off the SDK defaults, late-loaded ones
+  // included, unless an SDK built the list from the defaults.
+  const usesSdkDefaults = options.defaultIntegrations === undefined || !!options.extendsDefaultIntegrations;
+  if (options.defaultIntegrations === undefined) {
     options.defaultIntegrations = getDefaultIntegrationsImpl(options);
   }
 

packages/cloudflare/src/client.ts

@@ -351,6 +351,16 @@ interface BaseCloudflareOptions {
    */
   enableDedupe?: boolean;
 
+  /**
+   * @ignore Used internally by SDKs that build `defaultIntegrations` from the Cloudflare defaults.
+   * @hidden Used internally by SDKs that build `defaultIntegrations` from the Cloudflare defaults.
+   *
+   * Marks the `defaultIntegrations` list as an extension of the SDK defaults, so the SDK also adds
+   * the integrations of instrumented modules that load after `init()`.
+   * @default false
+   */
+  extendsDefaultIntegrations?: boolean;
+
   /**
    * The Cloudflare SDK is not OpenTelemetry native. By default (`false`) it does not set up a tracer
    * provider; spans are emitted via the SDK's own instrumentation and scopes are isolated with

packages/cloudflare/test/sdk.test.ts

@@ -524,6 +524,29 @@ describe('getDefaultIntegrations', () => {
       expect(client?.getIntegrationByName('Mysql')).toBeUndefined();
     });
 
+    test('adds it when a custom defaultIntegrations list extends the SDK defaults', async () => {
+      resetSdk();
+      const client = init({ dsn: DSN, defaultIntegrations: [], extendsDefaultIntegrations: true });
+
+      await loadMysqlLate(client);
+
+      expect(client?.getIntegrationByName('Mysql')).toBeDefined();
+    });
+
+    test('does not add it when the integrations function filtered it out of a list that extends the SDK defaults', async () => {
+      resetSdk();
+      const client = init({
+        dsn: DSN,
+        defaultIntegrations: [],
+        extendsDefaultIntegrations: true,
+        integrations: defaults => defaults.filter(integration => integration.name !== 'Mysql'),
+      });
+
+      await loadMysqlLate(client);
+
+      expect(client?.getIntegrationByName('Mysql')).toBeUndefined();
+    });
+
     test.each([
       ['false', false as const],
       ['a custom list', [] as Integration[]],

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

@@ -71,7 +71,11 @@ export const sentryCloudflareNitroPlugin =
           const requestHandlerOptions = {
             // `wrapRequestHandler` only sets up the integrations that work without `nodejs_compat`.
             // Nitro's Cloudflare presets require the flag anyway, so opt into the full set.
-            options: { defaultIntegrations: getDefaultIntegrations(cloudflareOptions), ...cloudflareOptions },
+            options: {
+              defaultIntegrations: getDefaultIntegrations(cloudflareOptions),
+              extendsDefaultIntegrations: cloudflareOptions.defaultIntegrations === undefined,
+              ...cloudflareOptions,
+            },
             request,
             context: getCloudflareProperties(event).context,
           };

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

@@ -0,0 +1,56 @@
+import type { CloudflareOptions } from '@sentry/cloudflare';
+import { wrapRequestHandler } from '@sentry/cloudflare/request';
+import type { NitroApp } from 'nitropack';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { sentryCloudflareNitroPlugin } from '../../../src/runtime/plugins/sentry-cloudflare.server';
+
+vi.mock('@sentry/cloudflare/request', () => ({
+  wrapRequestHandler: vi.fn((_options: unknown, callback: () => unknown) => callback()),
+}));
+
+const DSN = 'https://public@dsn.ingest.sentry.io/1337';
+
+async function handleRequest(options: CloudflareOptions): Promise<void> {
+  const nitroApp = { localFetch: vi.fn(), hooks: { hook: vi.fn() } } as unknown as NitroApp;
+  sentryCloudflareNitroPlugin(options)(nitroApp);
+
+  const event = {
+    protocol: 'https:',
+    host: 'example.com',
+    method: 'GET',
+    headers: {},
+    context: { cf: {}, cloudflare: { context: {} } },
+  };
+  await nitroApp.localFetch('/api/db-mysql', event as unknown as RequestInit);
+}
+
+describe('sentryCloudflareNitroPlugin', () => {
+  beforeEach(() => {
+    vi.mocked(wrapRequestHandler).mockClear();
+  });
+
+  it('passes a defaultIntegrations list that extends the SDK defaults', async () => {
+    await handleRequest({ dsn: DSN });
+
+    expect(wrapRequestHandler).toHaveBeenCalledWith(
+      expect.objectContaining({
+        options: expect.objectContaining({
+          defaultIntegrations: expect.any(Array),
+          extendsDefaultIntegrations: true,
+        }),
+      }),
+      expect.any(Function),
+    );
+  });
+
+  it('does not mark a defaultIntegrations list the user passed as extending the SDK defaults', async () => {
+    await handleRequest({ dsn: DSN, defaultIntegrations: [] });
+
+    expect(wrapRequestHandler).toHaveBeenCalledWith(
+      expect.objectContaining({
+        options: expect.objectContaining({ defaultIntegrations: [], extendsDefaultIntegrations: false }),
+      }),
+      expect.any(Function),
+    );
+  });
+});

packages/sveltekit/src/worker/cloudflare.ts

@@ -23,6 +23,7 @@ export function initCloudflareSentryHandle(options: CloudflareOptions): Handle {
       rewriteFramesIntegration(),
       svelteKitSpansIntegration(),
     ],
+    extendsDefaultIntegrations: options.defaultIntegrations === undefined,
     // SvelteKit emits its own OpenTelemetry spans (Kit tracing), so, like the Node SvelteKit SDK, it
     // defaults to registering the tracer provider instead of inheriting Cloudflare's no-provider default.
     // Only the `init`-backed wrapper from the main entry point honors this; `@sentry/cloudflare/request`

packages/sveltekit/test/worker/cloudflare.test.ts

@@ -63,7 +63,11 @@ describe('initCloudflareSentryHandle', () => {
       {
         // SvelteKit emits its own OpenTelemetry spans, so it opts into the tracer provider rather than
         // inheriting Cloudflare's no-provider default.
-        options: expect.objectContaining({ dsn: options.dsn, enableOpenTelemetrySetup: true }),
+        options: expect.objectContaining({
+          dsn: options.dsn,
+          enableOpenTelemetrySetup: true,
+          extendsDefaultIntegrations: true,
+        }),
         request,
         context,
         captureErrors: false,
@@ -74,6 +78,25 @@ describe('initCloudflareSentryHandle', () => {
     expect(resolve).toHaveBeenCalledTimes(1);
   });
 
+  it('does not mark a defaultIntegrations list the user passed as extending the SDK defaults', async () => {
+    const { options, event, resolve } = getHandlerInput();
+
+    // @ts-expect-error - resolving an empty object is enough for this test
+    vi.mocked(wrapRequestHandler).mockImplementationOnce((_, cb) => cb());
+
+    const handle = initCloudflareSentryHandle({ ...options, defaultIntegrations: [] });
+
+    // @ts-expect-error - only passing a partial event object
+    await handle({ event, resolve });
+
+    expect(wrapRequestHandler).toHaveBeenCalledWith(
+      expect.objectContaining({
+        options: expect.objectContaining({ defaultIntegrations: [], extendsDefaultIntegrations: false }),
+      }),
+      expect.any(Function),
+    );
+  });
+
   it('adds flag to skip request isolation in subsequent sentry handler', async () => {
     const { options, event, resolve } = getHandlerInput();
     const locals = {};