feat(cloudflare): Wrap vinext Worker entries with @sentry/nextjs/cloudflare

`sentryCloudflareVitePlugin` wrapped the Worker entry of a vinext app with
`withSentry` of `@sentry/cloudflare`, so the app sent Cloudflare data but no
Next.js spans. In a build with the vinext plugins, the generated code now
imports from `@sentry/nextjs/cloudflare` when it resolves from the entry.
Other builds, and vinext builds without `@sentry/nextjs`, keep
`@sentry/cloudflare`. Vite throws instead of returning `null` when
`@sentry/nextjs` is installed in a version without the `./cloudflare` entry,
so a throw of the resolve counts as unresolved.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: JPeer264

packages/cloudflare/src/vite/autoInstrument.ts

@@ -15,17 +15,39 @@ function normalizePath(path: string): string {
 // `.html`, … — sharing the entry's basename must never be treated as the entry.
 const JS_EXTENSION_REGEX = /\.[cm]?[jt]sx?$/;
 
+// Re-exports everything the generated code uses, and adds the Next.js span handling and OpenTelemetry context.
+const NEXTJS_CLOUDFLARE_MODULE = '@sentry/nextjs/cloudflare';
+
+/**
+ * Whether `@sentry/nextjs/cloudflare` resolves from `importer`. Vite throws instead of returning `null` when
+ * `@sentry/nextjs` is installed in a version without that entry.
+ */
+async function resolvesNextjsCloudflare(resolver: ModuleResolver, importer: string): Promise<boolean> {
+  try {
+    return !!(await resolver.resolve?.(NEXTJS_CLOUDFLARE_MODULE, importer));
+  } catch {
+    return false;
+  }
+}
+
 export function sentryCloudflareAutoInstrumentPlugin(options: { wranglerConfigPath?: string } = {}) {
   let wranglerConfig: WranglerConfig | undefined;
   let entryFilePath: string | undefined;
 
   let optionsFn = ENV_FALLBACK_OPTIONS_FN;
   let optionsImport: string | undefined;
+  let isVinext = false;
 
   return {
     name: 'sentry-cloudflare-auto-instrument',
 
-    configResolved(config: { root: string; logger?: { warn(msg: string): void } }): void {
+    configResolved(config: {
+      root: string;
+      plugins?: readonly { name?: string }[];
+      logger?: { warn(msg: string): void };
+    }): void {
+      isVinext = config.plugins?.some(plugin => plugin.name?.startsWith('vinext:')) ?? false;
+
       const result = resolveWranglerConfig(config.root, options.wranglerConfigPath);
       if (!result) {
         // An explicit path that fails is a misconfiguration worth naming;
@@ -119,6 +141,10 @@ export function sentryCloudflareAutoInstrumentPlugin(options: { wranglerConfigPa
             })
           : undefined;
 
+      // A vinext app with `@sentry/nextjs` installed gets `withSentry` of `@sentry/nextjs/cloudflare`.
+      const sentryModule =
+        isVinext && (await resolvesNextjsCloudflare(this, normalizedId)) ? NEXTJS_CLOUDFLARE_MODULE : undefined;
+
       // No registration import is injected here: the orchestrion plugin's
       // subscribe-injection makes each bundled package self-register its channel
       // subscriber on the global marker, so wrapping the entry with `withSentry`
@@ -129,6 +155,7 @@ export function sentryCloudflareAutoInstrumentPlugin(options: { wranglerConfigPa
         optionsFn,
         optionsImport,
         sameWorkerBindings: wranglerConfig.sameWorkerBindings,
+        sentryModule,
       });
 
       const wrappedClasses = result?.wrappedClasses ?? new Set<string>();

packages/cloudflare/src/vite/transform.ts

@@ -114,6 +114,8 @@ export interface TransformContext {
   optionsFn: string;
   /** Import statement prepended when `optionsFn` references a separate module. */
   optionsImport?: string;
+  /** Module the generated code imports `withSentry` and the class wrappers from. Defaults to `@sentry/cloudflare`. */
+  sentryModule?: string;
   /** @see {@link import('./wranglerConfig').WranglerConfig.sameWorkerBindings} */
   sameWorkerBindings?: readonly SameWorkerBinding[];
 }
@@ -198,7 +200,7 @@ export function applyAutoInstrumentTransforms(
     ms.prepend(buildMergedOptionsDeclaration(sameWorkerBindings, ctx.optionsFn, state));
   }
   if (ctx.optionsImport) ms.prepend(ctx.optionsImport);
-  ms.prepend("import * as __SENTRY__ from '@sentry/cloudflare';\n");
+  ms.prepend(`import * as __SENTRY__ from '${ctx.sentryModule ?? '@sentry/cloudflare'}';\n`);
 
   return {
     code: ms.toString(),

packages/cloudflare/test/vite/autoInstrument.test.ts

@@ -55,6 +55,80 @@ describe('sentryCloudflareAutoInstrumentPlugin', () => {
     expect(result.code).toContain('__SENTRY__.withSentry(');
   });
 
+  it('wraps the entry with `@sentry/nextjs/cloudflare` in a vinext build', async () => {
+    const dir = writeTempDir({ 'wrangler.toml': 'main = "src/index.ts"' });
+    const plugin = sentryCloudflareAutoInstrumentPlugin();
+    plugin.configResolved({ root: dir, plugins: [{ name: 'vinext:config' }] });
+
+    const code = 'export default { fetch() { return new Response("ok"); } };';
+    const result = await plugin.transform.call(
+      {
+        parse: (c: string) => parseJS(c),
+        resolve: async (source: string) => (source === '@sentry/nextjs/cloudflare' ? { id: source } : null),
+      },
+      code,
+      join(dir, 'src/index.ts'),
+    );
+
+    expect(result.code).toContain("import * as __SENTRY__ from '@sentry/nextjs/cloudflare';");
+    expect(result.code).toContain('__SENTRY__.withSentry(');
+  });
+
+  it('wraps the entry with `@sentry/cloudflare` when `@sentry/nextjs/cloudflare` resolves outside a vinext build', async () => {
+    const dir = writeTempDir({ 'wrangler.toml': 'main = "src/index.ts"' });
+    const plugin = sentryCloudflareAutoInstrumentPlugin();
+    plugin.configResolved({ root: dir, plugins: [{ name: 'vite:react' }] });
+
+    const code = 'export default { fetch() { return new Response("ok"); } };';
+    const result = await plugin.transform.call(
+      {
+        parse: (c: string) => parseJS(c),
+        resolve: async (source: string) => (source === '@sentry/nextjs/cloudflare' ? { id: source } : null),
+      },
+      code,
+      join(dir, 'src/index.ts'),
+    );
+
+    expect(result.code).toContain("import * as __SENTRY__ from '@sentry/cloudflare';");
+  });
+
+  it('wraps the entry with `@sentry/cloudflare` in a vinext build without `@sentry/nextjs`', async () => {
+    const dir = writeTempDir({ 'wrangler.toml': 'main = "src/index.ts"' });
+    const plugin = sentryCloudflareAutoInstrumentPlugin();
+    plugin.configResolved({ root: dir, plugins: [{ name: 'vinext:config' }] });
+
+    const code = 'export default { fetch() { return new Response("ok"); } };';
+    const result = await plugin.transform.call(
+      { parse: (c: string) => parseJS(c), resolve: async () => null },
+      code,
+      join(dir, 'src/index.ts'),
+    );
+
+    expect(result.code).toContain("import * as __SENTRY__ from '@sentry/cloudflare';");
+  });
+
+  it('wraps the entry with `@sentry/cloudflare` in a vinext build with an `@sentry/nextjs` without the `./cloudflare` entry', async () => {
+    const dir = writeTempDir({ 'wrangler.toml': 'main = "src/index.ts"' });
+    const plugin = sentryCloudflareAutoInstrumentPlugin();
+    plugin.configResolved({ root: dir, plugins: [{ name: 'vinext:config' }] });
+
+    const code = 'export default { fetch() { return new Response("ok"); } };';
+    const result = await plugin.transform.call(
+      {
+        parse: (c: string) => parseJS(c),
+        resolve: async () => {
+          throw new Error(
+            '"./cloudflare" is not exported under the conditions ["workerd"] from package @sentry/nextjs',
+          );
+        },
+      },
+      code,
+      join(dir, 'src/index.ts'),
+    );
+
+    expect(result.code).toContain("import * as __SENTRY__ from '@sentry/cloudflare';");
+  });
+
   it('leaves an already-manually-wrapped entry untouched', async () => {
     const { transform: tx, entryPath } = createPlugin('main = "src/index.ts"');