fix(node-core): Read `__SENTRY_SERVER_MODULES__` lazily so Turbopack injection is honored by sergical · Pull Request #21339 · getsentry/sentry-javascript

sergical · 2026-06-04T19:18:01Z

Summary

Fixes the root cause behind #19147. On Next.js 16 / Turbopack production builds (e.g. Vercel), modulesIntegration returns no injected modules, which silently disables every module-detection-based auto integration — vercelAIIntegration, openAIIntegration, anthropicAIIntegration, googleGenAIIntegration, langChainIntegration, langGraphIntegration — and leaves event.modules missing server dependencies. The result users see: raw ai.* spans (op: default) instead of gen_ai.*.

Root cause

packages/node-core/src/integrations/modules.ts captured the injected value into a module-level const at evaluation time:

constSERVER_MODULES=typeof__SENTRY_SERVER_MODULES__==='undefined' ? {} : __SENTRY_SERVER_MODULES__;

The two bundlers inject __SENTRY_SERVER_MODULES__ differently:

webpack replaces the bare token with a literal at build time via DefinePlugin → available the moment this module evaluates. ✅
Turbopack (added in fix(nextjs): Populate __SENTRY_SERVER_MODULES__ in Turbopack #19231) assigns globalThis.__SENTRY_SERVER_MODULES__ at runtime, via a value-injection loader on instrumentation.*.

The catch: the instrumentation.* file's ESM imports are hoisted above the injected assignment. Verified in a real Turbopack build (.next/server/chunks/[root-of-the-server]__*.js):

769449,e=>{"use strict";varr=e.i(298962);// import @sentry/* — evaluates modules.ts (SERVER_MODULES captured = {})asyncfunctions(){awaite.A(145684)}// register()globalThis.__SENTRY_SERVER_MODULES__={/* …deps… */}// injection runs AFTER the import}

So @sentry/node-core/modules evaluates before the global is assigned, and the const is frozen as {}. The other two sources in collectModules() also come up empty on a bundled server (no full-dependency package.json at process.cwd(); ai is bundled so it's not in require.cache, and the server is ESM not CJS). Net: getModules().ai is undefined → shouldForceIntegration returns false → addVercelAiProcessors never attaches.

Why #19231 didn't catch it

#19231 was unit-tested at the config-generation layer (asserting the value-injection rule is emitted). The nextjs-16 AI E2E that asserts gen_ai.* spans passes for the wrong reason — it runs next startlocally, where getModulesFromPackageJson() reads process.cwd()/package.json (present, lists ai) and masks the broken SERVER_MODULES path. On Vercel that fallback is empty, so detection fails.

Fix

Read the value lazily (per call) instead of capturing it at module-eval time, and support both injection styles:

functiongetServerModules(): Record<string,string>{if(typeof__SENTRY_SERVER_MODULES__!=='undefined')return__SENTRY_SERVER_MODULES__;// webpackreturn(GLOBAL_OBJas ...).__SENTRY_SERVER_MODULES__??{};// turbopack}

By the time getModules() is first called (during integration afterAllSetup, i.e. after register() → Sentry.init()), the instrumentation module body has fully executed and the global is set. webpack is unaffected (token still replaced).

Regression test

packages/node-core/test/integrations/modules.test.ts re-imports the module with no global set (mirroring Turbopack), then assigns globalThis.__SENTRY_SERVER_MODULES__after import and asserts getModules() reflects it. This fails on the previous code and passes with the fix.

Blast radius

Low. webpack path unchanged; Turbopack now honored; event.modules restored on Turbopack. Re-enables all module-detection-based auto integrations on Next.js 16 without requiring vercelAIIntegration({ force: true }).

Follow-up (separate)

The existing nextjs-16 AI E2E should be hardened so it can't pass via the process.cwd() package.json fallback — e.g. a --turbopack build variant run from a working directory whose package.json does not list the AI SDK, asserting gen_ai.* spans still appear. Happy to do this in a follow-up.

🤖 Generated with Claude Code

…jection is honored `modulesIntegration` captured `__SENTRY_SERVER_MODULES__` into a module-level `const` at evaluation time. That works for webpack (DefinePlugin replaces the token with a literal at build time) but not for Turbopack: the value-injection loader assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, and the instrumentation file's ESM imports are hoisted above that assignment — so this module evaluates before the global is set and the capture is always empty. As a result, on Next.js 16 / Turbopack production builds (e.g. Vercel) every module-detection-based auto integration silently never activates (vercelAI, openAI, anthropic, googleGenAI, langChain, langGraph), and `event.modules` is missing server dependencies. Read the value lazily instead: prefer the build-time-replaced token (webpack), then fall back to `GLOBAL_OBJ.__SENTRY_SERVER_MODULES__` (Turbopack). Adds a regression test that fails when the value is captured at module-eval time. Ref: #19147 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

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

s1gr1d

Looks good to me - thanks for the fix. I checked the test and it would fail with the old behavior so this should help us protect against regressions in the future.

s1gr1d · 2026-06-08T09:11:45Z

+ * Reads the modules that were injected at build time into `__SENTRY_SERVER_MODULES__`
+ * (e.g. by the Next.js SDK, to work around not having access to these at runtime).
+ *
+ * This MUST be read lazily (on every call) rather than captured once at module-evaluation
+ * time, because the two supported bundlers inject the value differently:
+ * - webpack replaces the `__SENTRY_SERVER_MODULES__` token with a literal via `DefinePlugin`
+ * (available as soon as this module is evaluated).
+ * - Turbopack assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, from a value-injection
+ * loader applied to `instrumentation.*`. The instrumentation file's ESM imports are hoisted
+ * above that assignment, so this module is evaluated *before* the global is set. A
+ * module-level `const` capture would therefore always be empty under Turbopack, silently
+ * disabling every module-detection-based auto integration (Vercel AI, OpenAI, Anthropic,
+ * Google GenAI, LangChain, LangGraph). See getsentry/sentry-javascript#19147.


Maybe this comment can be shortened a bit as it's very exhaustive.

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

…opack-server-modules # Conflicts: # CHANGELOG.md

Lms24 · 2026-06-09T08:21:58Z

For posterity, because it took quite some time to figure out what this PR actually fixes:

Fixes a timing issue when reading the build-time-injected __SENTRY_SERVER_MODULES__ constant in NextJS 16 Turbopack. Reading the constant at import time is too early, since the value is only populated later. This fix delays the reading to event processing time of modulesIntegration.
This fixes two issues:
- vercelAiIntegration can now correctly force-initialize, since it queries the available modules from modulesIntegration (vercelAIIntegration doesn't activate on Vercel deployments without force: true #19147)
- event.modules is now populated correctly

sergical · 2026-06-04T19:18:01Z

Summary

Fixes the root cause behind #19147. On Next.js 16 / Turbopack production builds (e.g. Vercel), modulesIntegration returns no injected modules, which silently disables every module-detection-based auto integration — vercelAIIntegration, openAIIntegration, anthropicAIIntegration, googleGenAIIntegration, langChainIntegration, langGraphIntegration — and leaves event.modules missing server dependencies. The result users see: raw ai.* spans (op: default) instead of gen_ai.*.

Root cause

packages/node-core/src/integrations/modules.ts captured the injected value into a module-level const at evaluation time:

constSERVER_MODULES=typeof__SENTRY_SERVER_MODULES__==='undefined' ? {} : __SENTRY_SERVER_MODULES__;

The two bundlers inject __SENTRY_SERVER_MODULES__ differently:

webpack replaces the bare token with a literal at build time via DefinePlugin → available the moment this module evaluates. ✅
Turbopack (added in fix(nextjs): Populate __SENTRY_SERVER_MODULES__ in Turbopack #19231) assigns globalThis.__SENTRY_SERVER_MODULES__ at runtime, via a value-injection loader on instrumentation.*.

The catch: the instrumentation.* file's ESM imports are hoisted above the injected assignment. Verified in a real Turbopack build (.next/server/chunks/[root-of-the-server]__*.js):

769449,e=>{"use strict";varr=e.i(298962);// import @sentry/* — evaluates modules.ts (SERVER_MODULES captured = {})asyncfunctions(){awaite.A(145684)}// register()globalThis.__SENTRY_SERVER_MODULES__={/* …deps… */}// injection runs AFTER the import}

So @sentry/node-core/modules evaluates before the global is assigned, and the const is frozen as {}. The other two sources in collectModules() also come up empty on a bundled server (no full-dependency package.json at process.cwd(); ai is bundled so it's not in require.cache, and the server is ESM not CJS). Net: getModules().ai is undefined → shouldForceIntegration returns false → addVercelAiProcessors never attaches.

Why #19231 didn't catch it

#19231 was unit-tested at the config-generation layer (asserting the value-injection rule is emitted). The nextjs-16 AI E2E that asserts gen_ai.* spans passes for the wrong reason — it runs next startlocally, where getModulesFromPackageJson() reads process.cwd()/package.json (present, lists ai) and masks the broken SERVER_MODULES path. On Vercel that fallback is empty, so detection fails.

Fix

Read the value lazily (per call) instead of capturing it at module-eval time, and support both injection styles:

functiongetServerModules(): Record<string,string>{if(typeof__SENTRY_SERVER_MODULES__!=='undefined')return__SENTRY_SERVER_MODULES__;// webpackreturn(GLOBAL_OBJas ...).__SENTRY_SERVER_MODULES__??{};// turbopack}

By the time getModules() is first called (during integration afterAllSetup, i.e. after register() → Sentry.init()), the instrumentation module body has fully executed and the global is set. webpack is unaffected (token still replaced).

Regression test

packages/node-core/test/integrations/modules.test.ts re-imports the module with no global set (mirroring Turbopack), then assigns globalThis.__SENTRY_SERVER_MODULES__after import and asserts getModules() reflects it. This fails on the previous code and passes with the fix.

Blast radius

Low. webpack path unchanged; Turbopack now honored; event.modules restored on Turbopack. Re-enables all module-detection-based auto integrations on Next.js 16 without requiring vercelAIIntegration({ force: true }).

Follow-up (separate)

The existing nextjs-16 AI E2E should be hardened so it can't pass via the process.cwd() package.json fallback — e.g. a --turbopack build variant run from a working directory whose package.json does not list the AI SDK, asserting gen_ai.* spans still appear. Happy to do this in a follow-up.

🤖 Generated with Claude Code

…jection is honored `modulesIntegration` captured `__SENTRY_SERVER_MODULES__` into a module-level `const` at evaluation time. That works for webpack (DefinePlugin replaces the token with a literal at build time) but not for Turbopack: the value-injection loader assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, and the instrumentation file's ESM imports are hoisted above that assignment — so this module evaluates before the global is set and the capture is always empty. As a result, on Next.js 16 / Turbopack production builds (e.g. Vercel) every module-detection-based auto integration silently never activates (vercelAI, openAI, anthropic, googleGenAI, langChain, langGraph), and `event.modules` is missing server dependencies. Read the value lazily instead: prefer the build-time-replaced token (webpack), then fall back to `GLOBAL_OBJ.__SENTRY_SERVER_MODULES__` (Turbopack). Adds a regression test that fails when the value is captured at module-eval time. Ref: #19147 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

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

s1gr1d

Looks good to me - thanks for the fix. I checked the test and it would fail with the old behavior so this should help us protect against regressions in the future.

s1gr1d · 2026-06-08T09:11:45Z

+ * Reads the modules that were injected at build time into `__SENTRY_SERVER_MODULES__`
+ * (e.g. by the Next.js SDK, to work around not having access to these at runtime).
+ *
+ * This MUST be read lazily (on every call) rather than captured once at module-evaluation
+ * time, because the two supported bundlers inject the value differently:
+ * - webpack replaces the `__SENTRY_SERVER_MODULES__` token with a literal via `DefinePlugin`
+ * (available as soon as this module is evaluated).
+ * - Turbopack assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, from a value-injection
+ * loader applied to `instrumentation.*`. The instrumentation file's ESM imports are hoisted
+ * above that assignment, so this module is evaluated *before* the global is set. A
+ * module-level `const` capture would therefore always be empty under Turbopack, silently
+ * disabling every module-detection-based auto integration (Vercel AI, OpenAI, Anthropic,
+ * Google GenAI, LangChain, LangGraph). See getsentry/sentry-javascript#19147.


Maybe this comment can be shortened a bit as it's very exhaustive.

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

…opack-server-modules # Conflicts: # CHANGELOG.md

Lms24 · 2026-06-09T08:21:58Z

For posterity, because it took quite some time to figure out what this PR actually fixes:

Fixes a timing issue when reading the build-time-injected __SENTRY_SERVER_MODULES__ constant in NextJS 16 Turbopack. Reading the constant at import time is too early, since the value is only populated later. This fix delays the reading to event processing time of modulesIntegration.
This fixes two issues:
- vercelAiIntegration can now correctly force-initialize, since it queries the available modules from modulesIntegration (vercelAIIntegration doesn't activate on Vercel deployments without force: true #19147)
- event.modules is now populated correctly

sergical · 2026-06-04T19:18:01Z

Summary

Fixes the root cause behind #19147. On Next.js 16 / Turbopack production builds (e.g. Vercel), modulesIntegration returns no injected modules, which silently disables every module-detection-based auto integration — vercelAIIntegration, openAIIntegration, anthropicAIIntegration, googleGenAIIntegration, langChainIntegration, langGraphIntegration — and leaves event.modules missing server dependencies. The result users see: raw ai.* spans (op: default) instead of gen_ai.*.

Root cause

packages/node-core/src/integrations/modules.ts captured the injected value into a module-level const at evaluation time:

constSERVER_MODULES=typeof__SENTRY_SERVER_MODULES__==='undefined' ? {} : __SENTRY_SERVER_MODULES__;

The two bundlers inject __SENTRY_SERVER_MODULES__ differently:

webpack replaces the bare token with a literal at build time via DefinePlugin → available the moment this module evaluates. ✅
Turbopack (added in fix(nextjs): Populate __SENTRY_SERVER_MODULES__ in Turbopack #19231) assigns globalThis.__SENTRY_SERVER_MODULES__ at runtime, via a value-injection loader on instrumentation.*.

The catch: the instrumentation.* file's ESM imports are hoisted above the injected assignment. Verified in a real Turbopack build (.next/server/chunks/[root-of-the-server]__*.js):

769449,e=>{"use strict";varr=e.i(298962);// import @sentry/* — evaluates modules.ts (SERVER_MODULES captured = {})asyncfunctions(){awaite.A(145684)}// register()globalThis.__SENTRY_SERVER_MODULES__={/* …deps… */}// injection runs AFTER the import}

So @sentry/node-core/modules evaluates before the global is assigned, and the const is frozen as {}. The other two sources in collectModules() also come up empty on a bundled server (no full-dependency package.json at process.cwd(); ai is bundled so it's not in require.cache, and the server is ESM not CJS). Net: getModules().ai is undefined → shouldForceIntegration returns false → addVercelAiProcessors never attaches.

Why #19231 didn't catch it

#19231 was unit-tested at the config-generation layer (asserting the value-injection rule is emitted). The nextjs-16 AI E2E that asserts gen_ai.* spans passes for the wrong reason — it runs next startlocally, where getModulesFromPackageJson() reads process.cwd()/package.json (present, lists ai) and masks the broken SERVER_MODULES path. On Vercel that fallback is empty, so detection fails.

Fix

Read the value lazily (per call) instead of capturing it at module-eval time, and support both injection styles:

functiongetServerModules(): Record<string,string>{if(typeof__SENTRY_SERVER_MODULES__!=='undefined')return__SENTRY_SERVER_MODULES__;// webpackreturn(GLOBAL_OBJas ...).__SENTRY_SERVER_MODULES__??{};// turbopack}

By the time getModules() is first called (during integration afterAllSetup, i.e. after register() → Sentry.init()), the instrumentation module body has fully executed and the global is set. webpack is unaffected (token still replaced).

Regression test

packages/node-core/test/integrations/modules.test.ts re-imports the module with no global set (mirroring Turbopack), then assigns globalThis.__SENTRY_SERVER_MODULES__after import and asserts getModules() reflects it. This fails on the previous code and passes with the fix.

Blast radius

Low. webpack path unchanged; Turbopack now honored; event.modules restored on Turbopack. Re-enables all module-detection-based auto integrations on Next.js 16 without requiring vercelAIIntegration({ force: true }).

Follow-up (separate)

The existing nextjs-16 AI E2E should be hardened so it can't pass via the process.cwd() package.json fallback — e.g. a --turbopack build variant run from a working directory whose package.json does not list the AI SDK, asserting gen_ai.* spans still appear. Happy to do this in a follow-up.

🤖 Generated with Claude Code

…jection is honored `modulesIntegration` captured `__SENTRY_SERVER_MODULES__` into a module-level `const` at evaluation time. That works for webpack (DefinePlugin replaces the token with a literal at build time) but not for Turbopack: the value-injection loader assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, and the instrumentation file's ESM imports are hoisted above that assignment — so this module evaluates before the global is set and the capture is always empty. As a result, on Next.js 16 / Turbopack production builds (e.g. Vercel) every module-detection-based auto integration silently never activates (vercelAI, openAI, anthropic, googleGenAI, langChain, langGraph), and `event.modules` is missing server dependencies. Read the value lazily instead: prefer the build-time-replaced token (webpack), then fall back to `GLOBAL_OBJ.__SENTRY_SERVER_MODULES__` (Turbopack). Adds a regression test that fails when the value is captured at module-eval time. Ref: #19147 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

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

s1gr1d

Looks good to me - thanks for the fix. I checked the test and it would fail with the old behavior so this should help us protect against regressions in the future.

s1gr1d · 2026-06-08T09:11:45Z

+ * Reads the modules that were injected at build time into `__SENTRY_SERVER_MODULES__`
+ * (e.g. by the Next.js SDK, to work around not having access to these at runtime).
+ *
+ * This MUST be read lazily (on every call) rather than captured once at module-evaluation
+ * time, because the two supported bundlers inject the value differently:
+ * - webpack replaces the `__SENTRY_SERVER_MODULES__` token with a literal via `DefinePlugin`
+ * (available as soon as this module is evaluated).
+ * - Turbopack assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, from a value-injection
+ * loader applied to `instrumentation.*`. The instrumentation file's ESM imports are hoisted
+ * above that assignment, so this module is evaluated *before* the global is set. A
+ * module-level `const` capture would therefore always be empty under Turbopack, silently
+ * disabling every module-detection-based auto integration (Vercel AI, OpenAI, Anthropic,
+ * Google GenAI, LangChain, LangGraph). See getsentry/sentry-javascript#19147.


Maybe this comment can be shortened a bit as it's very exhaustive.

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

…opack-server-modules # Conflicts: # CHANGELOG.md

Lms24 · 2026-06-09T08:21:58Z

For posterity, because it took quite some time to figure out what this PR actually fixes:

Fixes a timing issue when reading the build-time-injected __SENTRY_SERVER_MODULES__ constant in NextJS 16 Turbopack. Reading the constant at import time is too early, since the value is only populated later. This fix delays the reading to event processing time of modulesIntegration.
This fixes two issues:
- vercelAiIntegration can now correctly force-initialize, since it queries the available modules from modulesIntegration (vercelAIIntegration doesn't activate on Vercel deployments without force: true #19147)
- event.modules is now populated correctly

sergical · 2026-06-04T19:18:01Z

Summary

Fixes the root cause behind #19147. On Next.js 16 / Turbopack production builds (e.g. Vercel), modulesIntegration returns no injected modules, which silently disables every module-detection-based auto integration — vercelAIIntegration, openAIIntegration, anthropicAIIntegration, googleGenAIIntegration, langChainIntegration, langGraphIntegration — and leaves event.modules missing server dependencies. The result users see: raw ai.* spans (op: default) instead of gen_ai.*.

Root cause

packages/node-core/src/integrations/modules.ts captured the injected value into a module-level const at evaluation time:

constSERVER_MODULES=typeof__SENTRY_SERVER_MODULES__==='undefined' ? {} : __SENTRY_SERVER_MODULES__;

The two bundlers inject __SENTRY_SERVER_MODULES__ differently:

webpack replaces the bare token with a literal at build time via DefinePlugin → available the moment this module evaluates. ✅
Turbopack (added in fix(nextjs): Populate __SENTRY_SERVER_MODULES__ in Turbopack #19231) assigns globalThis.__SENTRY_SERVER_MODULES__ at runtime, via a value-injection loader on instrumentation.*.

The catch: the instrumentation.* file's ESM imports are hoisted above the injected assignment. Verified in a real Turbopack build (.next/server/chunks/[root-of-the-server]__*.js):

769449,e=>{"use strict";varr=e.i(298962);// import @sentry/* — evaluates modules.ts (SERVER_MODULES captured = {})asyncfunctions(){awaite.A(145684)}// register()globalThis.__SENTRY_SERVER_MODULES__={/* …deps… */}// injection runs AFTER the import}

So @sentry/node-core/modules evaluates before the global is assigned, and the const is frozen as {}. The other two sources in collectModules() also come up empty on a bundled server (no full-dependency package.json at process.cwd(); ai is bundled so it's not in require.cache, and the server is ESM not CJS). Net: getModules().ai is undefined → shouldForceIntegration returns false → addVercelAiProcessors never attaches.

Why #19231 didn't catch it

#19231 was unit-tested at the config-generation layer (asserting the value-injection rule is emitted). The nextjs-16 AI E2E that asserts gen_ai.* spans passes for the wrong reason — it runs next startlocally, where getModulesFromPackageJson() reads process.cwd()/package.json (present, lists ai) and masks the broken SERVER_MODULES path. On Vercel that fallback is empty, so detection fails.

Fix

Read the value lazily (per call) instead of capturing it at module-eval time, and support both injection styles:

functiongetServerModules(): Record<string,string>{if(typeof__SENTRY_SERVER_MODULES__!=='undefined')return__SENTRY_SERVER_MODULES__;// webpackreturn(GLOBAL_OBJas ...).__SENTRY_SERVER_MODULES__??{};// turbopack}

By the time getModules() is first called (during integration afterAllSetup, i.e. after register() → Sentry.init()), the instrumentation module body has fully executed and the global is set. webpack is unaffected (token still replaced).

Regression test

packages/node-core/test/integrations/modules.test.ts re-imports the module with no global set (mirroring Turbopack), then assigns globalThis.__SENTRY_SERVER_MODULES__after import and asserts getModules() reflects it. This fails on the previous code and passes with the fix.

Blast radius

Low. webpack path unchanged; Turbopack now honored; event.modules restored on Turbopack. Re-enables all module-detection-based auto integrations on Next.js 16 without requiring vercelAIIntegration({ force: true }).

Follow-up (separate)

The existing nextjs-16 AI E2E should be hardened so it can't pass via the process.cwd() package.json fallback — e.g. a --turbopack build variant run from a working directory whose package.json does not list the AI SDK, asserting gen_ai.* spans still appear. Happy to do this in a follow-up.

🤖 Generated with Claude Code

…jection is honored `modulesIntegration` captured `__SENTRY_SERVER_MODULES__` into a module-level `const` at evaluation time. That works for webpack (DefinePlugin replaces the token with a literal at build time) but not for Turbopack: the value-injection loader assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, and the instrumentation file's ESM imports are hoisted above that assignment — so this module evaluates before the global is set and the capture is always empty. As a result, on Next.js 16 / Turbopack production builds (e.g. Vercel) every module-detection-based auto integration silently never activates (vercelAI, openAI, anthropic, googleGenAI, langChain, langGraph), and `event.modules` is missing server dependencies. Read the value lazily instead: prefer the build-time-replaced token (webpack), then fall back to `GLOBAL_OBJ.__SENTRY_SERVER_MODULES__` (Turbopack). Adds a regression test that fails when the value is captured at module-eval time. Ref: #19147 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

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

s1gr1d

Looks good to me - thanks for the fix. I checked the test and it would fail with the old behavior so this should help us protect against regressions in the future.

s1gr1d · 2026-06-08T09:11:45Z

+ * Reads the modules that were injected at build time into `__SENTRY_SERVER_MODULES__`
+ * (e.g. by the Next.js SDK, to work around not having access to these at runtime).
+ *
+ * This MUST be read lazily (on every call) rather than captured once at module-evaluation
+ * time, because the two supported bundlers inject the value differently:
+ * - webpack replaces the `__SENTRY_SERVER_MODULES__` token with a literal via `DefinePlugin`
+ * (available as soon as this module is evaluated).
+ * - Turbopack assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, from a value-injection
+ * loader applied to `instrumentation.*`. The instrumentation file's ESM imports are hoisted
+ * above that assignment, so this module is evaluated *before* the global is set. A
+ * module-level `const` capture would therefore always be empty under Turbopack, silently
+ * disabling every module-detection-based auto integration (Vercel AI, OpenAI, Anthropic,
+ * Google GenAI, LangChain, LangGraph). See getsentry/sentry-javascript#19147.


Maybe this comment can be shortened a bit as it's very exhaustive.

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

…opack-server-modules # Conflicts: # CHANGELOG.md

Lms24 · 2026-06-09T08:21:58Z

For posterity, because it took quite some time to figure out what this PR actually fixes:

Fixes a timing issue when reading the build-time-injected __SENTRY_SERVER_MODULES__ constant in NextJS 16 Turbopack. Reading the constant at import time is too early, since the value is only populated later. This fix delays the reading to event processing time of modulesIntegration.
This fixes two issues:
- vercelAiIntegration can now correctly force-initialize, since it queries the available modules from modulesIntegration (vercelAIIntegration doesn't activate on Vercel deployments without force: true #19147)
- event.modules is now populated correctly

sergical · 2026-06-04T19:18:01Z

Summary

Fixes the root cause behind #19147. On Next.js 16 / Turbopack production builds (e.g. Vercel), modulesIntegration returns no injected modules, which silently disables every module-detection-based auto integration — vercelAIIntegration, openAIIntegration, anthropicAIIntegration, googleGenAIIntegration, langChainIntegration, langGraphIntegration — and leaves event.modules missing server dependencies. The result users see: raw ai.* spans (op: default) instead of gen_ai.*.

Root cause

packages/node-core/src/integrations/modules.ts captured the injected value into a module-level const at evaluation time:

constSERVER_MODULES=typeof__SENTRY_SERVER_MODULES__==='undefined' ? {} : __SENTRY_SERVER_MODULES__;

The two bundlers inject __SENTRY_SERVER_MODULES__ differently:

webpack replaces the bare token with a literal at build time via DefinePlugin → available the moment this module evaluates. ✅
Turbopack (added in fix(nextjs): Populate __SENTRY_SERVER_MODULES__ in Turbopack #19231) assigns globalThis.__SENTRY_SERVER_MODULES__ at runtime, via a value-injection loader on instrumentation.*.

The catch: the instrumentation.* file's ESM imports are hoisted above the injected assignment. Verified in a real Turbopack build (.next/server/chunks/[root-of-the-server]__*.js):

769449,e=>{"use strict";varr=e.i(298962);// import @sentry/* — evaluates modules.ts (SERVER_MODULES captured = {})asyncfunctions(){awaite.A(145684)}// register()globalThis.__SENTRY_SERVER_MODULES__={/* …deps… */}// injection runs AFTER the import}

So @sentry/node-core/modules evaluates before the global is assigned, and the const is frozen as {}. The other two sources in collectModules() also come up empty on a bundled server (no full-dependency package.json at process.cwd(); ai is bundled so it's not in require.cache, and the server is ESM not CJS). Net: getModules().ai is undefined → shouldForceIntegration returns false → addVercelAiProcessors never attaches.

Why #19231 didn't catch it

#19231 was unit-tested at the config-generation layer (asserting the value-injection rule is emitted). The nextjs-16 AI E2E that asserts gen_ai.* spans passes for the wrong reason — it runs next startlocally, where getModulesFromPackageJson() reads process.cwd()/package.json (present, lists ai) and masks the broken SERVER_MODULES path. On Vercel that fallback is empty, so detection fails.

Fix

Read the value lazily (per call) instead of capturing it at module-eval time, and support both injection styles:

functiongetServerModules(): Record<string,string>{if(typeof__SENTRY_SERVER_MODULES__!=='undefined')return__SENTRY_SERVER_MODULES__;// webpackreturn(GLOBAL_OBJas ...).__SENTRY_SERVER_MODULES__??{};// turbopack}

By the time getModules() is first called (during integration afterAllSetup, i.e. after register() → Sentry.init()), the instrumentation module body has fully executed and the global is set. webpack is unaffected (token still replaced).

Regression test

packages/node-core/test/integrations/modules.test.ts re-imports the module with no global set (mirroring Turbopack), then assigns globalThis.__SENTRY_SERVER_MODULES__after import and asserts getModules() reflects it. This fails on the previous code and passes with the fix.

Blast radius

Low. webpack path unchanged; Turbopack now honored; event.modules restored on Turbopack. Re-enables all module-detection-based auto integrations on Next.js 16 without requiring vercelAIIntegration({ force: true }).

Follow-up (separate)

The existing nextjs-16 AI E2E should be hardened so it can't pass via the process.cwd() package.json fallback — e.g. a --turbopack build variant run from a working directory whose package.json does not list the AI SDK, asserting gen_ai.* spans still appear. Happy to do this in a follow-up.

🤖 Generated with Claude Code

…jection is honored `modulesIntegration` captured `__SENTRY_SERVER_MODULES__` into a module-level `const` at evaluation time. That works for webpack (DefinePlugin replaces the token with a literal at build time) but not for Turbopack: the value-injection loader assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, and the instrumentation file's ESM imports are hoisted above that assignment — so this module evaluates before the global is set and the capture is always empty. As a result, on Next.js 16 / Turbopack production builds (e.g. Vercel) every module-detection-based auto integration silently never activates (vercelAI, openAI, anthropic, googleGenAI, langChain, langGraph), and `event.modules` is missing server dependencies. Read the value lazily instead: prefer the build-time-replaced token (webpack), then fall back to `GLOBAL_OBJ.__SENTRY_SERVER_MODULES__` (Turbopack). Adds a regression test that fails when the value is captured at module-eval time. Ref: #19147 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

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

s1gr1d

Looks good to me - thanks for the fix. I checked the test and it would fail with the old behavior so this should help us protect against regressions in the future.

s1gr1d · 2026-06-08T09:11:45Z

+ * Reads the modules that were injected at build time into `__SENTRY_SERVER_MODULES__`
+ * (e.g. by the Next.js SDK, to work around not having access to these at runtime).
+ *
+ * This MUST be read lazily (on every call) rather than captured once at module-evaluation
+ * time, because the two supported bundlers inject the value differently:
+ * - webpack replaces the `__SENTRY_SERVER_MODULES__` token with a literal via `DefinePlugin`
+ * (available as soon as this module is evaluated).
+ * - Turbopack assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, from a value-injection
+ * loader applied to `instrumentation.*`. The instrumentation file's ESM imports are hoisted
+ * above that assignment, so this module is evaluated *before* the global is set. A
+ * module-level `const` capture would therefore always be empty under Turbopack, silently
+ * disabling every module-detection-based auto integration (Vercel AI, OpenAI, Anthropic,
+ * Google GenAI, LangChain, LangGraph). See getsentry/sentry-javascript#19147.


Maybe this comment can be shortened a bit as it's very exhaustive.

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

…opack-server-modules # Conflicts: # CHANGELOG.md

Lms24 · 2026-06-09T08:21:58Z

For posterity, because it took quite some time to figure out what this PR actually fixes:

Fixes a timing issue when reading the build-time-injected __SENTRY_SERVER_MODULES__ constant in NextJS 16 Turbopack. Reading the constant at import time is too early, since the value is only populated later. This fix delays the reading to event processing time of modulesIntegration.
This fixes two issues:
- vercelAiIntegration can now correctly force-initialize, since it queries the available modules from modulesIntegration (vercelAIIntegration doesn't activate on Vercel deployments without force: true #19147)
- event.modules is now populated correctly

sergical · 2026-06-04T19:18:01Z

Summary

Fixes the root cause behind #19147. On Next.js 16 / Turbopack production builds (e.g. Vercel), modulesIntegration returns no injected modules, which silently disables every module-detection-based auto integration — vercelAIIntegration, openAIIntegration, anthropicAIIntegration, googleGenAIIntegration, langChainIntegration, langGraphIntegration — and leaves event.modules missing server dependencies. The result users see: raw ai.* spans (op: default) instead of gen_ai.*.

Root cause

packages/node-core/src/integrations/modules.ts captured the injected value into a module-level const at evaluation time:

constSERVER_MODULES=typeof__SENTRY_SERVER_MODULES__==='undefined' ? {} : __SENTRY_SERVER_MODULES__;

The two bundlers inject __SENTRY_SERVER_MODULES__ differently:

webpack replaces the bare token with a literal at build time via DefinePlugin → available the moment this module evaluates. ✅
Turbopack (added in fix(nextjs): Populate __SENTRY_SERVER_MODULES__ in Turbopack #19231) assigns globalThis.__SENTRY_SERVER_MODULES__ at runtime, via a value-injection loader on instrumentation.*.

The catch: the instrumentation.* file's ESM imports are hoisted above the injected assignment. Verified in a real Turbopack build (.next/server/chunks/[root-of-the-server]__*.js):

769449,e=>{"use strict";varr=e.i(298962);// import @sentry/* — evaluates modules.ts (SERVER_MODULES captured = {})asyncfunctions(){awaite.A(145684)}// register()globalThis.__SENTRY_SERVER_MODULES__={/* …deps… */}// injection runs AFTER the import}

So @sentry/node-core/modules evaluates before the global is assigned, and the const is frozen as {}. The other two sources in collectModules() also come up empty on a bundled server (no full-dependency package.json at process.cwd(); ai is bundled so it's not in require.cache, and the server is ESM not CJS). Net: getModules().ai is undefined → shouldForceIntegration returns false → addVercelAiProcessors never attaches.

Why #19231 didn't catch it

#19231 was unit-tested at the config-generation layer (asserting the value-injection rule is emitted). The nextjs-16 AI E2E that asserts gen_ai.* spans passes for the wrong reason — it runs next startlocally, where getModulesFromPackageJson() reads process.cwd()/package.json (present, lists ai) and masks the broken SERVER_MODULES path. On Vercel that fallback is empty, so detection fails.

Fix

Read the value lazily (per call) instead of capturing it at module-eval time, and support both injection styles:

functiongetServerModules(): Record<string,string>{if(typeof__SENTRY_SERVER_MODULES__!=='undefined')return__SENTRY_SERVER_MODULES__;// webpackreturn(GLOBAL_OBJas ...).__SENTRY_SERVER_MODULES__??{};// turbopack}

By the time getModules() is first called (during integration afterAllSetup, i.e. after register() → Sentry.init()), the instrumentation module body has fully executed and the global is set. webpack is unaffected (token still replaced).

Regression test

packages/node-core/test/integrations/modules.test.ts re-imports the module with no global set (mirroring Turbopack), then assigns globalThis.__SENTRY_SERVER_MODULES__after import and asserts getModules() reflects it. This fails on the previous code and passes with the fix.

Blast radius

Low. webpack path unchanged; Turbopack now honored; event.modules restored on Turbopack. Re-enables all module-detection-based auto integrations on Next.js 16 without requiring vercelAIIntegration({ force: true }).

Follow-up (separate)

The existing nextjs-16 AI E2E should be hardened so it can't pass via the process.cwd() package.json fallback — e.g. a --turbopack build variant run from a working directory whose package.json does not list the AI SDK, asserting gen_ai.* spans still appear. Happy to do this in a follow-up.

🤖 Generated with Claude Code

…jection is honored `modulesIntegration` captured `__SENTRY_SERVER_MODULES__` into a module-level `const` at evaluation time. That works for webpack (DefinePlugin replaces the token with a literal at build time) but not for Turbopack: the value-injection loader assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, and the instrumentation file's ESM imports are hoisted above that assignment — so this module evaluates before the global is set and the capture is always empty. As a result, on Next.js 16 / Turbopack production builds (e.g. Vercel) every module-detection-based auto integration silently never activates (vercelAI, openAI, anthropic, googleGenAI, langChain, langGraph), and `event.modules` is missing server dependencies. Read the value lazily instead: prefer the build-time-replaced token (webpack), then fall back to `GLOBAL_OBJ.__SENTRY_SERVER_MODULES__` (Turbopack). Adds a regression test that fails when the value is captured at module-eval time. Ref: #19147 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

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

s1gr1d

Looks good to me - thanks for the fix. I checked the test and it would fail with the old behavior so this should help us protect against regressions in the future.

s1gr1d · 2026-06-08T09:11:45Z

+ * Reads the modules that were injected at build time into `__SENTRY_SERVER_MODULES__`
+ * (e.g. by the Next.js SDK, to work around not having access to these at runtime).
+ *
+ * This MUST be read lazily (on every call) rather than captured once at module-evaluation
+ * time, because the two supported bundlers inject the value differently:
+ * - webpack replaces the `__SENTRY_SERVER_MODULES__` token with a literal via `DefinePlugin`
+ * (available as soon as this module is evaluated).
+ * - Turbopack assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, from a value-injection
+ * loader applied to `instrumentation.*`. The instrumentation file's ESM imports are hoisted
+ * above that assignment, so this module is evaluated *before* the global is set. A
+ * module-level `const` capture would therefore always be empty under Turbopack, silently
+ * disabling every module-detection-based auto integration (Vercel AI, OpenAI, Anthropic,
+ * Google GenAI, LangChain, LangGraph). See getsentry/sentry-javascript#19147.


Maybe this comment can be shortened a bit as it's very exhaustive.

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

…opack-server-modules # Conflicts: # CHANGELOG.md

Lms24 · 2026-06-09T08:21:58Z

For posterity, because it took quite some time to figure out what this PR actually fixes:

Fixes a timing issue when reading the build-time-injected __SENTRY_SERVER_MODULES__ constant in NextJS 16 Turbopack. Reading the constant at import time is too early, since the value is only populated later. This fix delays the reading to event processing time of modulesIntegration.
This fixes two issues:
- vercelAiIntegration can now correctly force-initialize, since it queries the available modules from modulesIntegration (vercelAIIntegration doesn't activate on Vercel deployments without force: true #19147)
- event.modules is now populated correctly

sergical · 2026-06-04T19:18:01Z

Summary

Fixes the root cause behind #19147. On Next.js 16 / Turbopack production builds (e.g. Vercel), modulesIntegration returns no injected modules, which silently disables every module-detection-based auto integration — vercelAIIntegration, openAIIntegration, anthropicAIIntegration, googleGenAIIntegration, langChainIntegration, langGraphIntegration — and leaves event.modules missing server dependencies. The result users see: raw ai.* spans (op: default) instead of gen_ai.*.

Root cause

packages/node-core/src/integrations/modules.ts captured the injected value into a module-level const at evaluation time:

constSERVER_MODULES=typeof__SENTRY_SERVER_MODULES__==='undefined' ? {} : __SENTRY_SERVER_MODULES__;

The two bundlers inject __SENTRY_SERVER_MODULES__ differently:

webpack replaces the bare token with a literal at build time via DefinePlugin → available the moment this module evaluates. ✅
Turbopack (added in fix(nextjs): Populate __SENTRY_SERVER_MODULES__ in Turbopack #19231) assigns globalThis.__SENTRY_SERVER_MODULES__ at runtime, via a value-injection loader on instrumentation.*.

The catch: the instrumentation.* file's ESM imports are hoisted above the injected assignment. Verified in a real Turbopack build (.next/server/chunks/[root-of-the-server]__*.js):

769449,e=>{"use strict";varr=e.i(298962);// import @sentry/* — evaluates modules.ts (SERVER_MODULES captured = {})asyncfunctions(){awaite.A(145684)}// register()globalThis.__SENTRY_SERVER_MODULES__={/* …deps… */}// injection runs AFTER the import}

So @sentry/node-core/modules evaluates before the global is assigned, and the const is frozen as {}. The other two sources in collectModules() also come up empty on a bundled server (no full-dependency package.json at process.cwd(); ai is bundled so it's not in require.cache, and the server is ESM not CJS). Net: getModules().ai is undefined → shouldForceIntegration returns false → addVercelAiProcessors never attaches.

Why #19231 didn't catch it

#19231 was unit-tested at the config-generation layer (asserting the value-injection rule is emitted). The nextjs-16 AI E2E that asserts gen_ai.* spans passes for the wrong reason — it runs next startlocally, where getModulesFromPackageJson() reads process.cwd()/package.json (present, lists ai) and masks the broken SERVER_MODULES path. On Vercel that fallback is empty, so detection fails.

Fix

Read the value lazily (per call) instead of capturing it at module-eval time, and support both injection styles:

functiongetServerModules(): Record<string,string>{if(typeof__SENTRY_SERVER_MODULES__!=='undefined')return__SENTRY_SERVER_MODULES__;// webpackreturn(GLOBAL_OBJas ...).__SENTRY_SERVER_MODULES__??{};// turbopack}

By the time getModules() is first called (during integration afterAllSetup, i.e. after register() → Sentry.init()), the instrumentation module body has fully executed and the global is set. webpack is unaffected (token still replaced).

Regression test

packages/node-core/test/integrations/modules.test.ts re-imports the module with no global set (mirroring Turbopack), then assigns globalThis.__SENTRY_SERVER_MODULES__after import and asserts getModules() reflects it. This fails on the previous code and passes with the fix.

Blast radius

Low. webpack path unchanged; Turbopack now honored; event.modules restored on Turbopack. Re-enables all module-detection-based auto integrations on Next.js 16 without requiring vercelAIIntegration({ force: true }).

Follow-up (separate)

The existing nextjs-16 AI E2E should be hardened so it can't pass via the process.cwd() package.json fallback — e.g. a --turbopack build variant run from a working directory whose package.json does not list the AI SDK, asserting gen_ai.* spans still appear. Happy to do this in a follow-up.

🤖 Generated with Claude Code

…jection is honored `modulesIntegration` captured `__SENTRY_SERVER_MODULES__` into a module-level `const` at evaluation time. That works for webpack (DefinePlugin replaces the token with a literal at build time) but not for Turbopack: the value-injection loader assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, and the instrumentation file's ESM imports are hoisted above that assignment — so this module evaluates before the global is set and the capture is always empty. As a result, on Next.js 16 / Turbopack production builds (e.g. Vercel) every module-detection-based auto integration silently never activates (vercelAI, openAI, anthropic, googleGenAI, langChain, langGraph), and `event.modules` is missing server dependencies. Read the value lazily instead: prefer the build-time-replaced token (webpack), then fall back to `GLOBAL_OBJ.__SENTRY_SERVER_MODULES__` (Turbopack). Adds a regression test that fails when the value is captured at module-eval time. Ref: #19147 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

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

s1gr1d

Looks good to me - thanks for the fix. I checked the test and it would fail with the old behavior so this should help us protect against regressions in the future.

s1gr1d · 2026-06-08T09:11:45Z

+ * Reads the modules that were injected at build time into `__SENTRY_SERVER_MODULES__`
+ * (e.g. by the Next.js SDK, to work around not having access to these at runtime).
+ *
+ * This MUST be read lazily (on every call) rather than captured once at module-evaluation
+ * time, because the two supported bundlers inject the value differently:
+ * - webpack replaces the `__SENTRY_SERVER_MODULES__` token with a literal via `DefinePlugin`
+ * (available as soon as this module is evaluated).
+ * - Turbopack assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, from a value-injection
+ * loader applied to `instrumentation.*`. The instrumentation file's ESM imports are hoisted
+ * above that assignment, so this module is evaluated *before* the global is set. A
+ * module-level `const` capture would therefore always be empty under Turbopack, silently
+ * disabling every module-detection-based auto integration (Vercel AI, OpenAI, Anthropic,
+ * Google GenAI, LangChain, LangGraph). See getsentry/sentry-javascript#19147.


Maybe this comment can be shortened a bit as it's very exhaustive.

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

…opack-server-modules # Conflicts: # CHANGELOG.md

Lms24 · 2026-06-09T08:21:58Z

For posterity, because it took quite some time to figure out what this PR actually fixes:

Fixes a timing issue when reading the build-time-injected __SENTRY_SERVER_MODULES__ constant in NextJS 16 Turbopack. Reading the constant at import time is too early, since the value is only populated later. This fix delays the reading to event processing time of modulesIntegration.
This fixes two issues:
- vercelAiIntegration can now correctly force-initialize, since it queries the available modules from modulesIntegration (vercelAIIntegration doesn't activate on Vercel deployments without force: true #19147)
- event.modules is now populated correctly

sergical · 2026-06-04T19:18:01Z

Summary

Fixes the root cause behind #19147. On Next.js 16 / Turbopack production builds (e.g. Vercel), modulesIntegration returns no injected modules, which silently disables every module-detection-based auto integration — vercelAIIntegration, openAIIntegration, anthropicAIIntegration, googleGenAIIntegration, langChainIntegration, langGraphIntegration — and leaves event.modules missing server dependencies. The result users see: raw ai.* spans (op: default) instead of gen_ai.*.

Root cause

packages/node-core/src/integrations/modules.ts captured the injected value into a module-level const at evaluation time:

constSERVER_MODULES=typeof__SENTRY_SERVER_MODULES__==='undefined' ? {} : __SENTRY_SERVER_MODULES__;

The two bundlers inject __SENTRY_SERVER_MODULES__ differently:

webpack replaces the bare token with a literal at build time via DefinePlugin → available the moment this module evaluates. ✅
Turbopack (added in fix(nextjs): Populate __SENTRY_SERVER_MODULES__ in Turbopack #19231) assigns globalThis.__SENTRY_SERVER_MODULES__ at runtime, via a value-injection loader on instrumentation.*.

The catch: the instrumentation.* file's ESM imports are hoisted above the injected assignment. Verified in a real Turbopack build (.next/server/chunks/[root-of-the-server]__*.js):

769449,e=>{"use strict";varr=e.i(298962);// import @sentry/* — evaluates modules.ts (SERVER_MODULES captured = {})asyncfunctions(){awaite.A(145684)}// register()globalThis.__SENTRY_SERVER_MODULES__={/* …deps… */}// injection runs AFTER the import}

So @sentry/node-core/modules evaluates before the global is assigned, and the const is frozen as {}. The other two sources in collectModules() also come up empty on a bundled server (no full-dependency package.json at process.cwd(); ai is bundled so it's not in require.cache, and the server is ESM not CJS). Net: getModules().ai is undefined → shouldForceIntegration returns false → addVercelAiProcessors never attaches.

Why #19231 didn't catch it

#19231 was unit-tested at the config-generation layer (asserting the value-injection rule is emitted). The nextjs-16 AI E2E that asserts gen_ai.* spans passes for the wrong reason — it runs next startlocally, where getModulesFromPackageJson() reads process.cwd()/package.json (present, lists ai) and masks the broken SERVER_MODULES path. On Vercel that fallback is empty, so detection fails.

Fix

Read the value lazily (per call) instead of capturing it at module-eval time, and support both injection styles:

functiongetServerModules(): Record<string,string>{if(typeof__SENTRY_SERVER_MODULES__!=='undefined')return__SENTRY_SERVER_MODULES__;// webpackreturn(GLOBAL_OBJas ...).__SENTRY_SERVER_MODULES__??{};// turbopack}

By the time getModules() is first called (during integration afterAllSetup, i.e. after register() → Sentry.init()), the instrumentation module body has fully executed and the global is set. webpack is unaffected (token still replaced).

Regression test

packages/node-core/test/integrations/modules.test.ts re-imports the module with no global set (mirroring Turbopack), then assigns globalThis.__SENTRY_SERVER_MODULES__after import and asserts getModules() reflects it. This fails on the previous code and passes with the fix.

Blast radius

Low. webpack path unchanged; Turbopack now honored; event.modules restored on Turbopack. Re-enables all module-detection-based auto integrations on Next.js 16 without requiring vercelAIIntegration({ force: true }).

Follow-up (separate)

The existing nextjs-16 AI E2E should be hardened so it can't pass via the process.cwd() package.json fallback — e.g. a --turbopack build variant run from a working directory whose package.json does not list the AI SDK, asserting gen_ai.* spans still appear. Happy to do this in a follow-up.

🤖 Generated with Claude Code

…jection is honored `modulesIntegration` captured `__SENTRY_SERVER_MODULES__` into a module-level `const` at evaluation time. That works for webpack (DefinePlugin replaces the token with a literal at build time) but not for Turbopack: the value-injection loader assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, and the instrumentation file's ESM imports are hoisted above that assignment — so this module evaluates before the global is set and the capture is always empty. As a result, on Next.js 16 / Turbopack production builds (e.g. Vercel) every module-detection-based auto integration silently never activates (vercelAI, openAI, anthropic, googleGenAI, langChain, langGraph), and `event.modules` is missing server dependencies. Read the value lazily instead: prefer the build-time-replaced token (webpack), then fall back to `GLOBAL_OBJ.__SENTRY_SERVER_MODULES__` (Turbopack). Adds a regression test that fails when the value is captured at module-eval time. Ref: #19147 Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

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

s1gr1d

Looks good to me - thanks for the fix. I checked the test and it would fail with the old behavior so this should help us protect against regressions in the future.

s1gr1d · 2026-06-08T09:11:45Z

+ * Reads the modules that were injected at build time into `__SENTRY_SERVER_MODULES__`
+ * (e.g. by the Next.js SDK, to work around not having access to these at runtime).
+ *
+ * This MUST be read lazily (on every call) rather than captured once at module-evaluation
+ * time, because the two supported bundlers inject the value differently:
+ * - webpack replaces the `__SENTRY_SERVER_MODULES__` token with a literal via `DefinePlugin`
+ * (available as soon as this module is evaluated).
+ * - Turbopack assigns `globalThis.__SENTRY_SERVER_MODULES__` at runtime, from a value-injection
+ * loader applied to `instrumentation.*`. The instrumentation file's ESM imports are hoisted
+ * above that assignment, so this module is evaluated *before* the global is set. A
+ * module-level `const` capture would therefore always be empty under Turbopack, silently
+ * disabling every module-detection-based auto integration (Vercel AI, OpenAI, Anthropic,
+ * Google GenAI, LangChain, LangGraph). See getsentry/sentry-javascript#19147.


Maybe this comment can be shortened a bit as it's very exhaustive.

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

…opack-server-modules # Conflicts: # CHANGELOG.md

Lms24 · 2026-06-09T08:21:58Z

For posterity, because it took quite some time to figure out what this PR actually fixes:

Fixes a timing issue when reading the build-time-injected __SENTRY_SERVER_MODULES__ constant in NextJS 16 Turbopack. Reading the constant at import time is too early, since the value is only populated later. This fix delays the reading to event processing time of modulesIntegration.
This fixes two issues:
- vercelAiIntegration can now correctly force-initialize, since it queries the available modules from modulesIntegration (vercelAIIntegration doesn't activate on Vercel deployments without force: true #19147)
- event.modules is now populated correctly

sergical requested a review from a team as a code owner June 4, 2026 19:18

sergical requested review from JPeer264 and andreiborza and removed request for a teamJune 4, 2026 19:18

docs(changelog): add entry for#21339
48dbf6f
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

sergical mentioned this pull request Jun 4, 2026
vercelAIIntegration doesn't activate on Vercel deployments without force: true #19147
Closed

sergical requested a review from logaretm June 4, 2026 21:10

style(node-core): Apply oxfmt formatting to modules.ts
7682515
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

s1gr1d requested a review from nicohrubec June 8, 2026 07:22

s1gr1d approved these changes Jun 8, 2026
View reviewed changes

sergicaland others added 2 commits June 8, 2026 06:20

docs(node-core): Shorten getServerModules comment per review
b236477
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Merge remote-tracking branch 'origin/develop' into fix/node-core-turb…
53832d7
…opack-server-modules # Conflicts: # CHANGELOG.md

sergical enabled auto-merge (squash) June 8, 2026 10:31

sergical merged commit 99988a8 into developJun 8, 2026
191 of 192 checks passed

sergical deleted the fix/node-core-turbopack-server-modules branch June 8, 2026 10:47

sentry-release-botBot mentioned this pull request Jun 9, 2026
publish: getsentry/sentry-javascript@10.57.0 getsentry/publish#8495
Closed
48 tasks