sdk

Author: chargome

packages/astro/package.json

@@ -60,6 +60,7 @@
     "@sentry/core": "10.67.0",
     "@sentry/conventions": "^0.16.0",
     "@sentry/node": "10.67.0",
+    "@sentry/server-utils": "10.67.0",
     "@sentry/bundler-plugins": "10.67.0"
   },
   "devDependencies": {

packages/astro/src/integration/cloudflare.ts

@@ -4,7 +4,7 @@ import { builtinModules } from 'module';
 // Derived from Astro's own config type rather than imported from `vite` directly: Astro bundles its
 // own Vite version, which differs across the Astro majors we support. A plugin typed against any
 // single Vite version is not assignable to `updateConfig({ vite: { plugins } })` for the others.
-type VitePlugin = Extract<NonNullable<NonNullable<AstroConfig['vite']>['plugins']>[number], { name: string }>;
+export type VitePlugin = Extract<NonNullable<NonNullable<AstroConfig['vite']>['plugins']>[number], { name: string }>;
 
 // Build a set of all Node.js built-in module names, including both
 // bare names (e.g. "fs") and "node:" prefixed names (e.g. "node:fs").

packages/astro/src/integration/index.ts

@@ -1,8 +1,10 @@
 import { sentryVitePlugin } from '@sentry/bundler-plugins/vite';
+import { sentryOrchestrionPlugin } from '@sentry/server-utils/orchestrion/vite';
 import type { AstroConfig, AstroIntegration, AstroIntegrationLogger } from 'astro';
 import * as fs from 'fs';
 import { createRequire } from 'module';
 import * as path from 'path';
+import type { VitePlugin } from './cloudflare';
 import { sentryCloudflareNodeWarningPlugin, sentryCloudflareVitePlugin } from './cloudflare';
 import { buildClientSnippet, buildSdkInitFileImportSnippet, buildServerSnippet } from './snippets';
 import type { SentryOptions } from './types';
@@ -34,6 +36,7 @@ export const sentryAstro = (options: SentryOptions = {}): AstroIntegration => {
           sourcemaps,
           // todo(v11): Extract `release` build time option here - cannot be done currently, because it conflicts with the `DeprecatedRuntimeOptions` type
           // release,
+          buildTimeInstrumentation,
           bundleSizeOptimizations,
           applicationKey,
           unstable_sentryVitePluginOptions,
@@ -167,6 +170,15 @@ export const sentryAstro = (options: SentryOptions = {}): AstroIntegration => {
         const isCloudflare = config?.adapter?.name?.startsWith('@astrojs/cloudflare');
         const isCloudflareWorkers = isCloudflare && !isCloudflarePages();
 
+        // TODO: Cloudflare/workerd needs different wiring — skipped for now.
+        if (sdkEnabled.server && !isCloudflare) {
+          updateConfig({
+            vite: {
+              plugins: [sentryOrchestrionPlugin({ buildTimeInstrumentation }) as VitePlugin],
+            },
+          });
+        }
+
         if (isCloudflare) {
           try {
             const _require = createRequire(`${process.cwd()}/`);

packages/astro/test/integration/index.test.ts

@@ -10,6 +10,26 @@ vi.mock('@sentry/bundler-plugins/vite', () => ({
   sentryVitePlugin: vi.fn(args => sentryVitePluginSpy(args)),
 }));
 
+// Stub the orchestrion plugin so these stay pure wiring tests (no apm code transformer pulled in).
+// Mirror the real plugin's contract: `buildTimeInstrumentation: false` yields the inert variant.
+const orchestrionVite = vi.fn((options?: { buildTimeInstrumentation?: boolean }) => ({
+  name: options?.buildTimeInstrumentation === false ? 'sentry-orchestrion-disabled' : 'sentry-orchestrion-vite',
+}));
+vi.mock('@sentry/server-utils/orchestrion/vite', () => ({
+  sentryOrchestrionPlugin: (options?: { buildTimeInstrumentation?: boolean }) => orchestrionVite(options),
+}));
+
+// The cloudflare adapter path resolves `@sentry/cloudflare` via `createRequire` and calls
+// `process.exit(1)` when it's missing. Stub the resolver so it always "finds" the package,
+// keeping these tests hermetic regardless of what's installed in `node_modules`.
+vi.mock('module', async requireActual => {
+  const actual = await requireActual<any>();
+  return {
+    ...actual,
+    createRequire: () => ({ resolve: () => '@sentry/cloudflare' }),
+  };
+});
+
 process.env = {
   ...process.env,
   SENTRY_AUTH_TOKEN: 'my-token',
@@ -23,7 +43,7 @@ const config = {
 } as AstroConfig;
 
 const baseConfigHookObject = {
-  logger: { warn: vi.fn(), info: vi.fn() },
+  logger: { warn: vi.fn(), info: vi.fn(), error: vi.fn() },
   addMiddleware: vi.fn(),
 };
 
@@ -46,7 +66,8 @@ describe('sentryAstro integration', () => {
     // @ts-expect-error - the hook exists and we only need to pass what we actually use
     await integration.hooks['astro:config:setup']({ ...baseConfigHookObject, updateConfig, injectScript, config });
 
-    expect(updateConfig).toHaveBeenCalledTimes(1);
+    // one call for the sourcemaps vite plugin, one for the orchestrion plugin
+    expect(updateConfig).toHaveBeenCalledTimes(2);
     expect(updateConfig).toHaveBeenCalledWith({
       vite: {
         build: {
@@ -55,6 +76,11 @@ describe('sentryAstro integration', () => {
         plugins: ['sentryVitePlugin'],
       },
     });
+    expect(updateConfig).toHaveBeenCalledWith({
+      vite: {
+        plugins: [{ name: 'sentry-orchestrion-vite' }],
+      },
+    });
 
     expect(sentryVitePluginSpy).toHaveBeenCalledTimes(1);
     expect(sentryVitePluginSpy).toHaveBeenCalledWith(
@@ -294,7 +320,13 @@ describe('sentryAstro integration', () => {
     // @ts-expect-error - the hook exists and we only need to pass what we actually use
     await integration.hooks['astro:config:setup']({ ...baseConfigHookObject, updateConfig, injectScript, config });
 
-    expect(updateConfig).toHaveBeenCalledTimes(0);
+    // only the orchestrion plugin is wired, no sourcemaps plugin
+    expect(updateConfig).toHaveBeenCalledTimes(1);
+    expect(updateConfig).toHaveBeenCalledWith({
+      vite: {
+        plugins: [{ name: 'sentry-orchestrion-vite' }],
+      },
+    });
     expect(sentryVitePluginSpy).toHaveBeenCalledTimes(0);
   });
 
@@ -307,7 +339,13 @@ describe('sentryAstro integration', () => {
     // @ts-expect-error - the hook exists and we only need to pass what we actually use
     await integration.hooks['astro:config:setup']({ ...baseConfigHookObject, updateConfig, injectScript, config });
 
-    expect(updateConfig).toHaveBeenCalledTimes(0);
+    // only the orchestrion plugin is wired, no sourcemaps plugin
+    expect(updateConfig).toHaveBeenCalledTimes(1);
+    expect(updateConfig).toHaveBeenCalledWith({
+      vite: {
+        plugins: [{ name: 'sentry-orchestrion-vite' }],
+      },
+    });
     expect(sentryVitePluginSpy).toHaveBeenCalledTimes(0);
   });
 
@@ -318,11 +356,12 @@ describe('sentryAstro integration', () => {
     // @ts-expect-error - the hook exists and we only need to pass what we actually use
     await integration.hooks['astro:config:setup']({ ...baseConfigHookObject, updateConfig, injectScript, config });
 
-    expect(updateConfig).toHaveBeenCalledTimes(1);
+    // one call for the sourcemaps vite plugin, one for the orchestrion plugin
+    expect(updateConfig).toHaveBeenCalledTimes(2);
     expect(sentryVitePluginSpy).toHaveBeenCalledTimes(1);
   });
 
-  it("doesn't add the Vite plugin in dev mode", async () => {
+  it("doesn't add the sourcemaps Vite plugin in dev mode", async () => {
     const integration = sentryAstro({
       sourceMapsUploadOptions: { enabled: true },
     });
@@ -337,7 +376,13 @@ describe('sentryAstro integration', () => {
       command: 'dev',
     });
 
-    expect(updateConfig).toHaveBeenCalledTimes(0);
+    // the sourcemaps plugin is skipped in dev, but the orchestrion plugin is still wired
+    expect(updateConfig).toHaveBeenCalledTimes(1);
+    expect(updateConfig).toHaveBeenCalledWith({
+      vite: {
+        plugins: [{ name: 'sentry-orchestrion-vite' }],
+      },
+    });
     expect(sentryVitePluginSpy).toHaveBeenCalledTimes(0);
   });
 
@@ -348,12 +393,84 @@ describe('sentryAstro integration', () => {
 
     expect(integration.hooks['astro:config:setup']).toBeDefined();
     // @ts-expect-error - the hook exists and we only need to pass what we actually use
-    await integration.hooks['astro:config:setup']({ updateConfig, injectScript, config });
+    await integration.hooks['astro:config:setup']({ ...baseConfigHookObject, updateConfig, injectScript, config });
 
+    // neither the sourcemaps nor the orchestrion plugin should be wired
     expect(updateConfig).toHaveBeenCalledTimes(0);
+    expect(orchestrionVite).not.toHaveBeenCalled();
     expect(sentryVitePluginSpy).toHaveBeenCalledTimes(0);
   });
 
+  it('adds the orchestrion plugin by default', async () => {
+    const integration = sentryAstro({});
+
+    expect(integration.hooks['astro:config:setup']).toBeDefined();
+    // @ts-expect-error - the hook exists and we only need to pass what we actually use
+    await integration.hooks['astro:config:setup']({ ...baseConfigHookObject, updateConfig, injectScript, config });
+
+    expect(orchestrionVite).toHaveBeenCalledWith({ buildTimeInstrumentation: undefined });
+    expect(updateConfig).toHaveBeenCalledWith({
+      vite: {
+        plugins: [{ name: 'sentry-orchestrion-vite' }],
+      },
+    });
+  });
+
+  it('adds an inert orchestrion plugin when `buildTimeInstrumentation` is `false`', async () => {
+    const integration = sentryAstro({ buildTimeInstrumentation: false });
+
+    expect(integration.hooks['astro:config:setup']).toBeDefined();
+    // @ts-expect-error - the hook exists and we only need to pass what we actually use
+    await integration.hooks['astro:config:setup']({ ...baseConfigHookObject, updateConfig, injectScript, config });
+
+    expect(orchestrionVite).toHaveBeenCalledWith({ buildTimeInstrumentation: false });
+    expect(updateConfig).toHaveBeenCalledWith({
+      vite: {
+        plugins: [{ name: 'sentry-orchestrion-disabled' }],
+      },
+    });
+  });
+
+  it("doesn't add the orchestrion plugin for the cloudflare adapter", async () => {
+    const integration = sentryAstro({});
+
+    const cloudflareConfig = { ...config, adapter: { name: '@astrojs/cloudflare' } } as AstroConfig;
+
+    expect(integration.hooks['astro:config:setup']).toBeDefined();
+    // @ts-expect-error - the hook exists and we only need to pass what we actually use
+    await integration.hooks['astro:config:setup']({
+      ...baseConfigHookObject,
+      updateConfig,
+      injectScript,
+      config: cloudflareConfig,
+    });
+
+    expect(orchestrionVite).not.toHaveBeenCalled();
+    expect(updateConfig).not.toHaveBeenCalledWith({
+      vite: {
+        plugins: [{ name: 'sentry-orchestrion-vite' }],
+      },
+    });
+  });
+
+  it("doesn't warn about deprecated options when `buildTimeInstrumentation` is set", async () => {
+    const integration = sentryAstro({ buildTimeInstrumentation: false });
+
+    const logger = { warn: vi.fn(), info: vi.fn() };
+
+    expect(integration.hooks['astro:config:setup']).toBeDefined();
+    // @ts-expect-error - the hook exists and we only need to pass what we actually use
+    await integration.hooks['astro:config:setup']({
+      ...baseConfigHookObject,
+      updateConfig,
+      injectScript,
+      config,
+      logger,
+    });
+
+    expect(logger.warn).not.toHaveBeenCalledWith(expect.stringContaining('buildTimeInstrumentation'));
+  });
+
   it.each([{}, { enabled: true }])('injects client and server init scripts', async options => {
     const integration = sentryAstro(options);