Only inject registration code. Don't inject tracing channels.

Author: timfish

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

@@ -1,6 +1,7 @@
 import type { CustomTransform } from '../apmTypes';
 import { parse } from 'meriyah';
 import { subscriberExportForModule } from '../config/channel-integration-definitions';
+import { MODULE_REGISTRATION_TRANSFORM } from '../config/registration-only';
 
 // Tracks Program nodes we already injected into, so a package with several
 // instrumented files (or several configs pointing at one file) is injected only
@@ -75,6 +76,10 @@ function moduleInjectedSnippet(
  * per file. Requires `@apm-js-collab/code-transformer` >= 0.18.1, where
  * built-ins dispatch through the override map and expose the originals on
  * `state.transforms.defaults`.
+ *
+ * Also carries the registration-only operator, which splices the same snippet
+ * without any channel injection — for library versions whose tracing channels
+ * are native.
  */
 export function moduleInjectedTransforms(
   // A function is read per injected file — the webpack/Turbopack loader uses it
@@ -83,15 +88,12 @@ export function moduleInjectedTransforms(
   // importing file's location).
   importSpecifier?: string | (() => string | undefined),
 ): Record<string, CustomTransform> {
-  const injectModuleInjected: CustomTransform = (state, program, parent, ancestry) => {
-    const { moduleType, module, transforms } = state as {
+  const spliceModuleInjected = (state: unknown, program: unknown): void => {
+    const { moduleType, module } = state as {
       moduleType?: string;
       module?: { name?: string };
-      transforms: { defaults: { tracingChannelImport: CustomTransform } };
     };
 
-    transforms.defaults.tracingChannelImport(state, program, parent, ancestry);
-
     const node = program as ProgramNode;
     if (injectedPrograms.has(node)) {
       return;
@@ -116,5 +118,25 @@ export function moduleInjectedTransforms(
     node.body.splice(directiveIndex + 1, 0, ...statements);
   };
 
-  return { tracingChannelImport: injectModuleInjected };
+  const injectModuleInjected: CustomTransform = (state, program, parent, ancestry) => {
+    const { transforms } = state as {
+      transforms: { defaults: { tracingChannelImport: CustomTransform } };
+    };
+
+    transforms.defaults.tracingChannelImport(state, program, parent, ancestry);
+    spliceModuleInjected(state, program);
+  };
+
+  // Operator for registration-only configs (`transform` field, see
+  // `config/registration-only.ts`): dispatched INSTEAD of `traceSync`, so no
+  // channel is declared and no function is wrapped. Their `astQuery: 'Program'`
+  // matches only the file root, so `node` is the Program itself.
+  const injectRegistrationOnly: CustomTransform = (state, node) => {
+    spliceModuleInjected(state, node);
+  };
+
+  return {
+    tracingChannelImport: injectModuleInjected,
+    [MODULE_REGISTRATION_TRANSFORM]: injectRegistrationOnly,
+  };
 }

packages/server-utils/src/orchestrion/config/ioredis.ts

@@ -3,10 +3,7 @@ import { getModuleNames } from './module-names';
 import { registrationOnly } from './registration-only';
 
 export const ioredisConfig = [
-  registrationOnly(
-    { name: 'ioredis', versionRange: '>=5.11.0', filePath: 'built/Redis.js' },
-    { className: 'Redis', methodName: 'connect' },
-  ),
+  registrationOnly({ name: 'ioredis', versionRange: '>=5.11.0', filePath: 'built/Redis.js' }),
   // ioredis `<5.11.0` (>=5.11.0 publishes its own `ioredis:*` diagnostics_channel)
   ...['lib/redis.js', 'built/redis.js', 'built/redis/index.js'].flatMap((filePath): InstrumentationConfig[] => [
     {

packages/server-utils/src/orchestrion/config/mongoose.ts

@@ -38,10 +38,7 @@ const CONTEXT_CAPTURE_QUERY_METHODS = [
 ] as const;
 
 export const mongooseConfig = [
-  registrationOnly(
-    { name: 'mongoose', versionRange: '>=9.7.0', filePath: 'lib/query.js' },
-    { expressionName: 'estimatedDocumentCount' },
-  ),
+  registrationOnly({ name: 'mongoose', versionRange: '>=9.7.0', filePath: 'lib/query.js' }),
   // Query execution
   // the span for most read/write operations. `op`, collection and model are
   // read off the `Query` at exec time.

packages/server-utils/src/orchestrion/config/mysql2.ts

@@ -22,10 +22,7 @@ import { registrationOnly } from './registration-only';
 // guard) — so `Auto` would crash streamed queries. `Callback` leaves that shape untouched (a rare,
 // row-streaming use that consumes the emitter's events), the tradeoff being it isn't traced.
 export const mysql2Config = [
-  registrationOnly(
-    { name: 'mysql2', versionRange: '>=3.20.0', filePath: 'lib/base/connection.js' },
-    { className: 'BaseConnection', methodName: 'pause' },
-  ),
+  registrationOnly({ name: 'mysql2', versionRange: '>=3.20.0', filePath: 'lib/base/connection.js' }),
   {
     channelName: 'query',
     module: { name: 'mysql2', versionRange: '>=1.4.2 <3.11.5', filePath: 'lib/connection.js' },

packages/server-utils/src/orchestrion/config/redis.ts

@@ -3,10 +3,7 @@ import { getModuleNames } from './module-names';
 import { registrationOnly } from './registration-only';
 
 export const redisConfig = [
-  registrationOnly(
-    { name: '@redis/client', versionRange: '>=5.12.0', filePath: 'dist/lib/client/index.js' },
-    { className: 'RedisClient', methodName: 'connect' },
-  ),
+  registrationOnly({ name: '@redis/client', versionRange: '>=5.12.0', filePath: 'dist/lib/client/index.js' }),
   // redis `>=2.6.0 <4` (standalone `redis`). `internal_send_command` is an
   // anonymous prototype assignment (`expressionName`); it settles via the nested
   // `command_obj.callback`, so `kind: 'Sync'` and the subscriber wraps that callback.

packages/server-utils/src/orchestrion/config/registration-only.ts

@@ -1,18 +1,30 @@
 import type { InstrumentationConfig } from '..';
 
 /**
- * Build a registration-only config for one file of a library.
- *
- * `functionQuery` takes the same shapes as a normal config (`functionName`,
- * `expressionName`, or `className` + `methodName`); the `kind` is fixed.
+ * Name of the custom transform (see `bundler/moduleInjectedTransform.ts`) that
+ * splices only the module-injected registration snippet — no channel machinery.
+ * Prefixed so it can never shadow a built-in operator (`traceSync`,
+ * `tracingChannelImport`, ...), which the custom-transforms map overrides by
+ * name.
  */
-export function registrationOnly(
-  module: { name: string; versionRange: string; filePath: string },
-  functionQuery: { functionName?: string; expressionName?: string; className?: string; methodName?: string },
-): InstrumentationConfig {
+export const MODULE_REGISTRATION_TRANSFORM = 'sentryModuleRegistration';
+
+/**
+ * Build a registration-only config for one file of a library whose tracing
+ * channels are native (published by the library itself): no channels are
+ * injected, but transforming the file registers the module's channel-subscriber
+ * integration at evaluation time. `astQuery: 'Program'` matches the file root
+ * unconditionally, so no anchor function inside the library needs to exist.
+ */
+export function registrationOnly(module: {
+  name: string;
+  versionRange: string;
+  filePath: string;
+}): InstrumentationConfig {
   return {
     channelName: 'module-registration',
     module,
-    functionQuery: { ...functionQuery, kind: 'Sync' },
-  } as InstrumentationConfig;
+    astQuery: 'Program',
+    transform: MODULE_REGISTRATION_TRANSFORM,
+  };
 }

packages/server-utils/src/orchestrion/config/vercel-ai.ts

@@ -4,7 +4,7 @@ import { registrationOnly } from './registration-only';
 
 export const vercelAiConfig = [
   ...['dist/index.js', 'dist/index.mjs'].map(filePath =>
-    registrationOnly({ name: 'ai', versionRange: '>=7.0.0', filePath }, { functionName: 'embedMany' }),
+    registrationOnly({ name: 'ai', versionRange: '>=7.0.0', filePath }),
   ),
   // Vercel AI v6: mirror the v7 native `ai:telemetry` channel by injecting
   // channels into the top-level entry points. `resolveLanguageModel` is wrapped

packages/server-utils/test/orchestrion/moduleInjectedTransform.test.ts

@@ -12,9 +12,9 @@ import { orchestrionTransformOptions } from '../../src/orchestrion/bundler/optio
 
 // The code transformer reads the instrumented package's version from its
 // on-disk `package.json`, so each test package needs a real directory.
-function makePackage(root: string, name: string, version: string, type?: 'module' | 'commonjs'): void {
+function makePackage(root: string, name: string, version: string, type?: 'module' | 'commonjs', subdir = 'lib'): void {
   const dir = join(root, 'node_modules', name);
-  mkdirSync(join(dir, 'lib'), { recursive: true });
+  mkdirSync(join(dir, subdir), { recursive: true });
   writeFileSync(join(dir, 'package.json'), JSON.stringify({ name, version, ...(type ? { type } : {}) }));
 }
 
@@ -44,6 +44,8 @@ describe('module-injected transform', () => {
     makePackage(root, 'mysql', '2.18.1', 'commonjs');
     makePackage(root, 'pg', '8.11.0', 'module');
     makePackage(root, 'my-lib', '1.0.0', 'commonjs');
+    makePackage(root, 'ioredis', '5.11.0', 'commonjs', 'built');
+    makePackage(root, 'ai', '7.0.0', 'module', 'dist');
   });
 
   afterAll(() => {
@@ -124,6 +126,38 @@ describe('module-injected transform', () => {
     expect(calls).toHaveLength(1);
   });
 
+  it('injects only the registration snippet for a CJS version with native channels', () => {
+    const t = createCodeTransformer(orchestrionTransformOptions({}));
+    // No anchor function present — registration must not depend on any library
+    // internals existing (`astQuery: 'Program'` matches the file root).
+    const code = "'use strict';\nclass Redis {}\nmodule.exports = Redis;\n";
+    const result = t.transform(code, join(root, 'node_modules/ioredis/built/Redis.js'));
+
+    expect(result).not.toBeNull();
+    expect(result!.code).toMatch(
+      /const\s*\{\s*orchestrionModuleInjected,\s*redisIntegration\s*\}\s*=\s*require\(["']@sentry\/server-utils\/orchestrion["']\)/,
+    );
+    expect(result!.code).toContain('orchestrionModuleInjected("ioredis", redisIntegration)');
+    // The library publishes its own channels, so nothing else is injected: no
+    // diagnostics_channel import, no channel declaration, no function wrapper.
+    expect(result!.code).not.toContain('diagnostics_channel');
+    expect(result!.code).not.toContain('tr_ch_apm');
+    expect(result!.code).toContain('class Redis');
+  });
+
+  it('injects only the registration snippet for an ESM version with native channels', () => {
+    const t = createCodeTransformer(orchestrionTransformOptions({}));
+    const result = t.transform('export const embed = () => {};\n', join(root, 'node_modules/ai/dist/index.mjs'));
+
+    expect(result).not.toBeNull();
+    expect(result!.code).toMatch(
+      /import\s*\{\s*orchestrionModuleInjected,\s*vercelAIIntegration\s*\}\s*from\s*["']@sentry\/server-utils\/orchestrion["']/,
+    );
+    expect(result!.code).toContain('orchestrionModuleInjected("ai", vercelAIIntegration)');
+    expect(result!.code).not.toContain('diagnostics_channel');
+    expect(result!.code).not.toContain('tr_ch_apm');
+  });
+
   it('honors a custom import specifier (Turbopack passes an absolute path)', () => {
     const t = createCodeTransformer({
       ...orchestrionTransformOptions({}),