feat(node): move dc integration swap to _init

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,31 @@ 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.
+  //
+  // Only when there's a non-empty default set to swap:
+  // `defaultIntegrations: false` (not an array) and `[]` /
+  // `initWithoutDefaultIntegrations()` (explicitly no defaults) are left
+  // untouched, as appending channel integrations there would resurrect
+  // defaults the caller opted out of.
+  if (diagnosticsChannelInjection && Array.isArray(defaultIntegrations) && defaultIntegrations.length > 0) {
+    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,117 @@
+import type { Integration } from '@sentry/core';
+import { debug } from '@sentry/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { init, initWithoutDefaultIntegrations } 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);
+  });
+
+  it('does not add channel integrations when defaults are explicitly empty', () => {
+    const channelEmptyMysql = mockIntegration('EmptyMysql');
+    setDiagnosticsChannelInjectionLoader(() => ({
+      integrations: [channelEmptyMysql],
+      replacedOtelIntegrationNames: ['EmptyMysql'],
+      register: vi.fn(),
+      detect: vi.fn(),
+    }));
+
+    // `defaultIntegrations: []` opts out of all defaults; the swap must not
+    // resurrect them by appending the channel integrations.
+    init({ dsn: PUBLIC_DSN, tracesSampleRate: 1, skipOpenTelemetrySetup: true, defaultIntegrations: [] });
+
+    expect(channelEmptyMysql.setupOnce).not.toHaveBeenCalled();
+  });
+
+  it('does not add channel integrations to initWithoutDefaultIntegrations()', () => {
+    const channelNoDefaults = mockIntegration('NoDefaultsMysql');
+    setDiagnosticsChannelInjectionLoader(() => ({
+      integrations: [channelNoDefaults],
+      replacedOtelIntegrationNames: ['NoDefaultsMysql'],
+      register: vi.fn(),
+      detect: vi.fn(),
+    }));
+
+    initWithoutDefaultIntegrations({ dsn: PUBLIC_DSN, tracesSampleRate: 1, skipOpenTelemetrySetup: true });
+
+    expect(channelNoDefaults.setupOnce).not.toHaveBeenCalled();
+  });
+});