fixup! feat(server-utils): Register orchestrion channel integrations via the global marker

Author: JPeer264

packages/server-utils/src/orchestrion/bundler/vite.ts

@@ -102,13 +102,26 @@ export function sentryOrchestrionPlugin(options: SentryOrchestrionPluginOptions
   const codeTransformerArray: UnknownPlugin[] = Array.isArray(codeTransformerPlugins)
     ? codeTransformerPlugins
     : [codeTransformerPlugins];
+  const serverCodeTransformerArray = codeTransformerArray.map(plugin => serverEnvironmentOnly(plugin));
   return [
     bundlerMarkerPlugin(),
     ...(options.registerIntegrations ? [registerIntegrationsPlugin()] : []),
-    ...codeTransformerArray,
+    ...serverCodeTransformerArray,
   ];
 }
 
+/** Keeps environment-aware Vite builds from transforming client bundles. */
+function serverEnvironmentOnly(plugin: UnknownPlugin): UnknownPlugin {
+  const applyToEnvironment = plugin.applyToEnvironment;
+  return {
+    ...plugin,
+    applyToEnvironment(this: unknown, environment: { config?: { consumer?: string } }): unknown {
+      if (environment.config?.consumer === 'client') return false;
+      return applyToEnvironment?.call(this, environment) ?? true;
+    },
+  };
+}
+
 /**
  * Builds the `injectDiagnostics` callback for the code transformer: it records
  * the packages the transformer actually transformed — and those whose transform
@@ -193,9 +206,10 @@ function registerIntegrationsPlugin(): UnknownPlugin {
 
   // `serve` (vite dev) vs `build`; drives entry detection in `transform`.
   let command = 'build';
-  // Dev only: environments the registration import has already been injected
-  // into, so each is injected exactly once (into its first source module).
-  const injectedServeEnvironments = new Set<string>();
+  // Dev only: records which source module receives registration in each
+  // environment. Re-transforming that module must inject again because HMR can
+  // start a fresh isolate from the newly transformed output.
+  const injectedServeModules = new Map<string, string>();
 
   function injectRegisterImport(code: string): { code: string; map: unknown } | null {
     if (code.includes(REGISTER_MODULE_ID)) return null;
@@ -252,8 +266,9 @@ function registerIntegrationsPlugin(): UnknownPlugin {
       // pre-bundled deps, node_modules source, and virtual modules so the import
       // lands in the user's entry, not an incidental early module.
       const environment = this?.environment?.name ?? '';
-      if (injectedServeEnvironments.has(environment)) return null;
       const cleanId = id.split('?')[0] ?? id;
+      const injectedModule = injectedServeModules.get(environment);
+      if (injectedModule && injectedModule !== cleanId) return null;
       if (
         id.startsWith('\0') ||
         cleanId.includes('/node_modules/') ||
@@ -263,7 +278,7 @@ function registerIntegrationsPlugin(): UnknownPlugin {
         return null;
       }
       const result = injectRegisterImport(code);
-      if (result) injectedServeEnvironments.add(environment);
+      if (result) injectedServeModules.set(environment, cleanId);
       return result;
     },
   };
@@ -276,9 +291,18 @@ function bundlerMarkerPlugin(): UnknownPlugin {
     '',
   ].join('\n');
 
+  let command = 'build';
+  const injectedServeModules = new Map<string, string>();
+
   return {
     name: 'sentry-orchestrion-marker',
     enforce: 'pre' as const,
+    applyToEnvironment(environment: { config?: { consumer?: string } }): boolean {
+      return environment.config?.consumer !== 'client';
+    },
+    configResolved(config: { command: string }): void {
+      command = config.command;
+    },
     config(): { ssr: { noExternal: string[] } } {
       // Force-bundle every instrumented package so the code transform actually
       // sees its source. Vite externalizes dependencies in SSR builds by
@@ -321,8 +345,35 @@ function bundlerMarkerPlugin(): UnknownPlugin {
         },
       };
     },
-    renderChunk(code: string, chunk: { isEntry: boolean }): { code: string; map: unknown } | null {
-      if (!chunk.isEntry) return null;
+    transform(
+      this: { environment?: { name?: string; config?: { consumer?: string } } } | undefined,
+      code: string,
+      id: string,
+    ): { code: string; map: unknown } | null {
+      if (command !== 'serve' || this?.environment?.config?.consumer === 'client') return null;
+      const cleanId = id.split('?')[0] ?? id;
+      const environment = this?.environment?.name ?? '';
+      const injectedModule = injectedServeModules.get(environment);
+      if (injectedModule && injectedModule !== cleanId) return null;
+      if (
+        id.startsWith('\0') ||
+        cleanId.includes('/node_modules/') ||
+        cleanId.includes('/.vite/') ||
+        !/\.[cm]?[jt]sx?$/.test(cleanId)
+      ) {
+        return null;
+      }
+      injectedServeModules.set(environment, cleanId);
+      const ms = new MagicString(code);
+      ms.prepend(banner);
+      return { code: ms.toString(), map: ms.generateMap({ hires: true }) };
+    },
+    renderChunk(
+      this: { environment?: { config?: { consumer?: string } } } | undefined,
+      code: string,
+      chunk: { isEntry: boolean },
+    ): { code: string; map: unknown } | null {
+      if (!chunk.isEntry || this?.environment?.config?.consumer === 'client') return null;
       // Prepend via magic-string so the entry chunk's sourcemap stays aligned —
       // returning `map: null` here would shift every mapping by the banner's
       // line count and misattribute server stack traces.

packages/server-utils/src/orchestrion/index.ts

@@ -93,6 +93,9 @@ export const channelIntegrations = {
  *
  * Names must match the `module.name` values in `SENTRY_INSTRUMENTATIONS` (the
  * `config/` files) — e.g. `postgresIntegration` covers both `pg` and `pg-pool`.
+ * Integrations for channels published natively by a library cannot use this
+ * transformed-module filter and need an explicit always-active representation
+ * before they can be added here.
  */
 const CHANNEL_INTEGRATION_MODULES: Record<keyof typeof channelIntegrations, string[]> = {
   postgresIntegration: ['pg', 'pg-pool'],
@@ -106,7 +109,7 @@ const CHANNEL_INTEGRATION_MODULES: Record<keyof typeof channelIntegrations, stri
   vercelAiIntegration: ['ai'],
   amqplibIntegration: ['amqplib'],
   hapiIntegration: ['@hapi/hapi'],
-  expressIntegration: ['express'],
+  expressIntegration: ['express', 'router'],
   graphqlIntegration: ['graphql'],
   kafkajsIntegration: ['kafkajs'],
 };

packages/server-utils/test/orchestrion/vite-plugin.test.ts

@@ -38,6 +38,39 @@ describe('sentryOrchestrionPlugin', () => {
     expect(marker.renderChunk('console.log("chunk");', { isEntry: false })).toBeNull();
   });
 
+  it('does not prepend the bundler marker to client chunks', () => {
+    const marker = getMarkerPlugin();
+    const clientContext = { environment: { config: { consumer: 'client' } } };
+
+    expect(marker.renderChunk.call(clientContext, 'console.log("app");', { isEntry: true })).toBeNull();
+  });
+
+  it('applies the marker and code transformer only to server environments', () => {
+    const plugins = sentryOrchestrionPlugin({ registerIntegrations: true });
+    const environmentPlugins = plugins.filter(
+      plugin => plugin.name === 'sentry-orchestrion-marker' || plugin.name === 'code-transformer',
+    );
+
+    expect(environmentPlugins.every(plugin => plugin.applyToEnvironment({ config: { consumer: 'server' } }))).toBe(
+      true,
+    );
+    expect(environmentPlugins.every(plugin => !plugin.applyToEnvironment({ config: { consumer: 'client' } }))).toBe(
+      true,
+    );
+  });
+
+  it('prepends the bundler marker during dev and reinjects it after entry HMR', () => {
+    const marker = getMarkerPlugin();
+    marker.configResolved({ command: 'serve' });
+    const context = { environment: { name: 'worker', config: { consumer: 'server' } } };
+
+    const initial = marker.transform.call(context, 'export default {};\n', '/app/src/index.ts');
+    const updated = marker.transform.call(context, 'export default { updated: true };\n', '/app/src/index.ts?t=123');
+
+    expect(initial?.code).toContain('globalThis.__SENTRY_ORCHESTRION__.bundler = true;');
+    expect(updated?.code).toContain('globalThis.__SENTRY_ORCHESTRION__.bundler = true;');
+  });
+
   describe('configEnvironment (dev dep-optimizer instrumentation)', () => {
     it('adds the esbuild transformer for server environments on classic Vite', () => {
       // No `meta.rolldownVersion` → esbuild-based optimizer.

packages/server-utils/test/orchestrion/vite-register-integrations.test.ts

@@ -156,6 +156,20 @@ describe('sentryOrchestrionPlugin — registerIntegrations', () => {
       expect(second).toBeNull();
     });
 
+    it('reinjects when HMR transforms the registered entry again', () => {
+      const plugin = makeServePlugin();
+      runTransform(plugin, 'export default {};\n', serveCtx({ name: 'worker' }), '/app/src/index.ts');
+
+      const updated = runTransform(
+        plugin,
+        'export default { updated: true };\n',
+        serveCtx({ name: 'worker' }),
+        '/app/src/index.ts?t=123',
+      );
+
+      expect(updated?.code).toContain(REGISTER_MODULE_ID);
+    });
+
     it('injects once per distinct environment', () => {
       const plugin = makeServePlugin();
       const worker = runTransform(plugin, 'export default {};\n', serveCtx({ name: 'worker' }), '/app/src/index.ts');