feat(nest): wire up orchestrion instrumentation

Add `'Nest'` to the set of integrations that are implemented using
Orchestrion, and which override a prior OTel based integration.

The integration swap is moved into the `_init` method in the Node SDK,
because the NestJS SDK (and other framework SDKs) will pass in its own
defaultIntegrations array, which would bypass the old swap location. Now
the swap is uniform for every framework SDK based on Node init, and
respects `defaultIntegrations: false`.

A new unit test is added that proves the opt-out leaves the defaults
untouched, and opt-in replaces the named OTel integration with channel
integrations.

Author: isaacs

packages/node/src/sdk/index.ts

@@ -30,32 +30,14 @@ export function getDefaultIntegrationsWithoutPerformance(): Integration[] {
 
 /** Get the default integrations for the Node SDK. */
 export function getDefaultIntegrations(options: Options): Integration[] {
-  const integrations: Integration[] = [
+  return [
     ...getDefaultIntegrationsWithoutPerformance(),
     // We only add performance integrations if tracing is enabled
     // Note that this means that without tracing enabled, e.g. `expressIntegration()` will not be added
     // This means that generally request isolation will work (because that is done by httpIntegration)
     // But `transactionName` will not be set automatically
     ...(hasSpansEnabled(options) ? getAutoPerformanceIntegrations() : []),
   ];
-
-  // When the app opted into diagnostics-channel injection (via
-  // `experimentalUseDiagnosticsChannelInjection()`) AND span recording is
-  // enabled, swap the channel-based integrations in place of OTel equivalents
-  // so the two don't both instrument the same library.
-  //
-  // Every channel-based integration we ship today is a 1:1 replacement for an
-  // OTel performance/tracing integration and produces nothing but spans (those
-  // only come from `getAutoPerformanceIntegrations()` above), so it's gated on
-  // span recording.
-  if (isDiagnosticsChannelInjectionEnabled() && hasSpansEnabled(options)) {
-    const diagnosticsChannelInjection = resolveDiagnosticsChannelInjection();
-    if (diagnosticsChannelInjection) {
-      const replaced = new Set(diagnosticsChannelInjection.replacedOtelIntegrationNames);
-      return [...integrations.filter(i => !replaced.has(i.name)), ...diagnosticsChannelInjection.integrations];
-    }
-  }
-  return integrations;
 }
 
 /**
@@ -77,8 +59,7 @@ function _init(
   // EXPERIMENTAL: diagnostics-channel injection, opted into via
   // `experimentalUseDiagnosticsChannelInjection()`. Gated on span recording to
   // match the OTel integrations it replaces. With tracing off there are no
-  // channel subscribers, so injecting is pointless work. `resolve...()` is
-  // memoized, so `getDefaultIntegrations()` (below) sees the same instance.
+  // channel subscribers, so injecting is pointless work.
   const diagnosticsChannelInjection =
     isDiagnosticsChannelInjectionEnabled() && hasSpansEnabled(options)
       ? resolveDiagnosticsChannelInjection()
@@ -90,10 +71,26 @@ function _init(
     diagnosticsChannelInjection.register();
   }
 
+  // Only use Node SDK defaults if none provided.
+  let defaultIntegrations = options.defaultIntegrations ?? getDefaultIntegrationsImpl(options);
+
+  // When opted into diagnostics-channel injection, swap the channel-based
+  // integrations in place of their OTel equivalents so the two don't both
+  // instrument the same library. Done here (rather than in
+  // `getDefaultIntegrations`) so it also covers framework SDKs (e.g.
+  // `@sentry/nestjs`) that pass their own `defaultIntegrations` array, and it
+  // respects `defaultIntegrations: false` (not an array -> left untouched).
+  if (diagnosticsChannelInjection && Array.isArray(defaultIntegrations)) {
+    const replaced = new Set(diagnosticsChannelInjection.replacedOtelIntegrationNames);
+    defaultIntegrations = [
+      ...defaultIntegrations.filter(integration => !replaced.has(integration.name)),
+      ...diagnosticsChannelInjection.integrations,
+    ];
+  }
+
   const client = initNodeCore({
     ...options,
-    // Only use Node SDK defaults if none provided
-    defaultIntegrations: options.defaultIntegrations ?? getDefaultIntegrationsImpl(options),
+    defaultIntegrations,
   });
 
   // Add Node SDK specific OpenTelemetry setup

packages/node/test/sdk/diagnosticsChannelInjection.test.ts

@@ -0,0 +1,87 @@
+import type { Integration } from '@sentry/core';
+import { debug } from '@sentry/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { init } from '../../src/sdk';
+import { setDiagnosticsChannelInjectionLoader } from '../../src/sdk/diagnosticsChannelInjection';
+import { cleanupOtel, resetGlobals } from '../helpers/mockSdkInit';
+
+// eslint-disable-next-line no-var
+declare var global: any;
+
+const PUBLIC_DSN = 'https://username@domain/123';
+
+function mockIntegration(name: string): Integration {
+  return { name, setupOnce: vi.fn() };
+}
+
+// These tests run in definition order: the first runs before any loader is set
+// (opt-out), the second sets it (opt-in). The module-level loader state is
+// isolated per test file by vitest, so it doesn't leak elsewhere.
+describe('diagnostics-channel injection integration swap', () => {
+  beforeEach(() => {
+    global.__SENTRY__ = {};
+    vi.spyOn(debug, 'enable').mockImplementation(() => undefined);
+  });
+
+  afterEach(() => {
+    cleanupOtel();
+    resetGlobals();
+    vi.clearAllMocks();
+  });
+
+  it('does not swap integrations when not opted in', () => {
+    // Distinct names from the opt-in test below: `@sentry/core` only runs
+    // `setupOnce` once per integration name per process, so reusing names across
+    // tests would suppress later calls.
+    const otelNest = mockIntegration('OptOutNest');
+    const http = mockIntegration('OptOutHttp');
+
+    init({
+      dsn: PUBLIC_DSN,
+      tracesSampleRate: 1,
+      skipOpenTelemetrySetup: true,
+      defaultIntegrations: [otelNest, http],
+    });
+
+    // No opt-in -> the supplied defaults are set up untouched.
+    expect(otelNest.setupOnce).toHaveBeenCalledTimes(1);
+    expect(http.setupOnce).toHaveBeenCalledTimes(1);
+  });
+
+  it('replaces the named OTel integrations with the channel integrations, even when defaultIntegrations are supplied by a framework SDK', () => {
+    const channelMysql = mockIntegration('Mysql');
+    const channelNest = mockIntegration('Nest');
+    const register = vi.fn();
+    const detect = vi.fn();
+    setDiagnosticsChannelInjectionLoader(() => ({
+      integrations: [channelMysql, channelNest],
+      replacedOtelIntegrationNames: ['Mysql', 'Nest'],
+      register,
+      detect,
+    }));
+
+    // Mimics `@sentry/nestjs`, which prepends its OTel `Nest` integration to
+    // its own `defaultIntegrations` array (so node's `getDefaultIntegrations`
+    // swap never sees it; swap must happen in `init`).
+    const otelNest = mockIntegration('Nest');
+    const http = mockIntegration('Http');
+
+    init({
+      dsn: PUBLIC_DSN,
+      tracesSampleRate: 1,
+      skipOpenTelemetrySetup: true,
+      defaultIntegrations: [otelNest, http],
+    });
+
+    // OTel 'Nest' filtered out, never set up.
+    expect(otelNest.setupOnce).not.toHaveBeenCalled();
+    // Channel replacements set up instead.
+    expect(channelNest.setupOnce).toHaveBeenCalledTimes(1);
+    expect(channelMysql.setupOnce).toHaveBeenCalledTimes(1);
+    // Unrelated default preserved.
+    expect(http.setupOnce).toHaveBeenCalledTimes(1);
+    // Hooks installed and detection ran once.
+    expect(register).toHaveBeenCalledTimes(1);
+    expect(detect).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -1,12 +1,10 @@
 import { lruMemoizerChannelIntegration } from '../integrations/tracing-channel/lru-memoizer';
 import { mysqlChannelIntegration } from '../integrations/tracing-channel/mysql';
+import { nestjsChannelIntegration } from '../integrations/tracing-channel/nestjs';
 import { postgresChannelIntegration } from '../integrations/tracing-channel/postgres';
 
 export { detectOrchestrionSetup, isOrchestrionInjected } from './detect';
-export { lruMemoizerChannelIntegration, mysqlChannelIntegration, postgresChannelIntegration };
-// Not part of `channelIntegrations` below: `Nest` isn't a `@sentry/node` default integration (it's added
-// by the standalone `@sentry/nestjs` SDK), so it's not swapped via the generic default-integration path.
-export { nestjsChannelIntegration } from '../integrations/tracing-channel/nestjs';
+export { lruMemoizerChannelIntegration, mysqlChannelIntegration, nestjsChannelIntegration, postgresChannelIntegration };
 
 /**
  * The canonical set of orchestrion diagnostics-channel integrations, keyed by their public
@@ -16,9 +14,14 @@ export { nestjsChannelIntegration } from '../integrations/tracing-channel/nestjs
  * opt-in helper (`experimentalUseDiagnosticsChannelInjection`) and its public
  * `diagnosticsChannelInjectionIntegrations()` map — picks it up automatically, so there's no separate
  * list to keep in sync.
+ *
+ * `Nest` is included even though it isn't a `@sentry/node` default integration: the swap runs in the Node
+ * SDK's `_init` over the *final* `defaultIntegrations`, so it also replaces the OTel `Nest` that
+ * `@sentry/nestjs` prepends to its own defaults.
  */
 export const channelIntegrations = {
   postgresIntegration: postgresChannelIntegration,
   mysqlIntegration: mysqlChannelIntegration,
   lruMemoizerIntegration: lruMemoizerChannelIntegration,
+  nestIntegration: nestjsChannelIntegration,
 } as const;