update to catch within patch

Author: RulaKhaled

packages/core/src/integration.ts

@@ -24,11 +24,11 @@ const MARKED_DISABLED_INTEGRATIONS = new Set<string>();
  * @param integrationName The name(s) of the integration(s) to mark as disabled
  */
 export function _markIntegrationsDisabled(integrationName: string | string[]): void {
-  if (Array.isArray(integrationName)) {
-    integrationName.forEach(name => MARKED_DISABLED_INTEGRATIONS.add(name));
-  } else {
-    MARKED_DISABLED_INTEGRATIONS.add(integrationName);
-  }
+  const names = Array.isArray(integrationName) ? integrationName : [integrationName];
+  names.forEach(name => {
+    MARKED_DISABLED_INTEGRATIONS.add(name);
+    DEBUG_BUILD && debug.log(`Integration marked as disabled: ${name}`);
+  });
 }
 
 /**
@@ -160,11 +160,8 @@ export function setupIntegration(client: Client, integration: Integration, integ
 
   // `setupOnce` is only called the first time
   if (!installedIntegrations.includes(integration.name) && typeof integration.setupOnce === 'function') {
-    // Skip setup if integration is marked as disabled
-    if (!_isIntegrationMarkedDisabled(integration.name)) {
-      integration.setupOnce();
-      installedIntegrations.push(integration.name);
-    }
+    integration.setupOnce();
+    installedIntegrations.push(integration.name);
   }
 
   // `setup` is run for each client

packages/core/test/lib/integration.test.ts

@@ -11,7 +11,7 @@ import {
 } from '../../src/integration';
 import { setCurrentClient } from '../../src/sdk';
 import type { Integration } from '../../src/types-hoist/integration';
-import type { Options } from '../../src/types-hoist/options';
+import type { CoreOptions } from '../../src/types-hoist/options';
 import { debug } from '../../src/utils/debug-logger';
 import { getDefaultTestClientOptions, TestClient } from '../mocks/client';
 
@@ -40,8 +40,8 @@ class MockIntegration implements Integration {
 
 type TestCase = [
   string, // test name
-  Options['defaultIntegrations'], // default integrations
-  Options['integrations'], // user-provided integrations
+  CoreOptions['defaultIntegrations'], // default integrations
+  CoreOptions['integrations'], // user-provided integrations
   Array<string | string[]>, // expected results
 ];
 
@@ -694,124 +694,57 @@ describe('addIntegration', () => {
 
 describe('Integration marking system', () => {
   beforeEach(() => {
-    // Clear marks before each test
     _clearDisabledIntegrationsMarks();
-    // Reset installed integrations
     installedIntegrations.splice(0, installedIntegrations.length);
   });
 
   afterEach(() => {
-    // Clean up after tests
     _clearDisabledIntegrationsMarks();
   });
 
-  describe('_markIntegrationsDisabled', () => {
-    it('marks a single integration as disabled', () => {
-      _markIntegrationsDisabled('TestIntegration');
-      expect(_isIntegrationMarkedDisabled('TestIntegration')).toBe(true);
-    });
+  it('marks and checks single integration', () => {
+    expect(_isIntegrationMarkedDisabled('TestIntegration')).toBe(false);
 
-    it('marks multiple integrations as disabled using array', () => {
-      _markIntegrationsDisabled(['Integration1', 'Integration2', 'Integration3']);
-      expect(_isIntegrationMarkedDisabled('Integration1')).toBe(true);
-      expect(_isIntegrationMarkedDisabled('Integration2')).toBe(true);
-      expect(_isIntegrationMarkedDisabled('Integration3')).toBe(true);
-    });
+    _markIntegrationsDisabled('TestIntegration');
 
-    it('does not affect unmarked integrations', () => {
-      _markIntegrationsDisabled('Integration1');
-      expect(_isIntegrationMarkedDisabled('Integration1')).toBe(true);
-      expect(_isIntegrationMarkedDisabled('Integration2')).toBe(false);
-    });
+    expect(_isIntegrationMarkedDisabled('TestIntegration')).toBe(true);
   });
 
-  describe('_isIntegrationMarkedDisabled', () => {
-    it('returns false for integrations that are not marked', () => {
-      expect(_isIntegrationMarkedDisabled('SomeIntegration')).toBe(false);
-    });
+  it('marks and checks multiple integrations', () => {
+    _markIntegrationsDisabled(['OpenAI', 'Anthropic', 'GoogleGenAI']);
 
-    it('returns true for integrations that are marked', () => {
-      _markIntegrationsDisabled('MarkedIntegration');
-      expect(_isIntegrationMarkedDisabled('MarkedIntegration')).toBe(true);
-    });
+    expect(_isIntegrationMarkedDisabled('OpenAI')).toBe(true);
+    expect(_isIntegrationMarkedDisabled('Anthropic')).toBe(true);
+    expect(_isIntegrationMarkedDisabled('GoogleGenAI')).toBe(true);
+    expect(_isIntegrationMarkedDisabled('Other')).toBe(false);
   });
 
-  describe('_clearDisabledIntegrationsMarks', () => {
-    it('clears all marks', () => {
-      _markIntegrationsDisabled(['Integration1', 'Integration2']);
-      expect(_isIntegrationMarkedDisabled('Integration1')).toBe(true);
-      expect(_isIntegrationMarkedDisabled('Integration2')).toBe(true);
-
-      _clearDisabledIntegrationsMarks();
-
-      expect(_isIntegrationMarkedDisabled('Integration1')).toBe(false);
-      expect(_isIntegrationMarkedDisabled('Integration2')).toBe(false);
-    });
-
-    it('removes marked integrations from installedIntegrations list', () => {
-      // Simulate integrations being installed
-      installedIntegrations.push('Integration1', 'Integration2', 'Integration3');
-
-      // Mark some as disabled
-      _markIntegrationsDisabled(['Integration1', 'Integration3']);
-
-      // Clear should remove marked ones from installed list
-      _clearDisabledIntegrationsMarks();
+  it('clears marks and removes from installedIntegrations', () => {
+    // Simulate scenario: integrations installed, some marked for cleanup
+    installedIntegrations.push('LangChain', 'OpenAI', 'Anthropic', 'Normal');
+    _markIntegrationsDisabled(['OpenAI', 'Anthropic']);
 
-      expect(installedIntegrations).toEqual(['Integration2']);
-    });
-
-    it('preserves integrations that are not marked when clearing', () => {
-      installedIntegrations.push('Integration1', 'Integration2', 'Integration3');
-      _markIntegrationsDisabled('Integration2');
+    _clearDisabledIntegrationsMarks();
 
-      _clearDisabledIntegrationsMarks();
+    // Marks are cleared
+    expect(_isIntegrationMarkedDisabled('OpenAI')).toBe(false);
+    expect(_isIntegrationMarkedDisabled('Anthropic')).toBe(false);
 
-      expect(installedIntegrations).toEqual(['Integration1', 'Integration3']);
-    });
+    // Marked integrations removed from installed list (can setup again in new client)
+    expect(installedIntegrations).toEqual(['LangChain', 'Normal']);
   });
 
-  describe('setupIntegration with marked integrations', () => {
-    it('skips setupOnce for marked integrations', () => {
-      const client = getTestClient();
-      const integration = new MockIntegration('MarkedIntegration');
-
-      // Mark the integration as disabled before setup
-      _markIntegrationsDisabled('MarkedIntegration');
-
-      setupIntegration(client, integration, {});
-
-      // setupOnce should not be called
-      expect(integration.setupOnce).not.toHaveBeenCalled();
-      // Integration should not be in installed list
-      expect(installedIntegrations).not.toContain('MarkedIntegration');
-    });
-
-    it('calls setupOnce for non-marked integrations', () => {
-      const client = getTestClient();
-      const integration = new MockIntegration('NormalIntegration');
-
-      setupIntegration(client, integration, {});
+  it('handles multi-client scenario correctly', () => {
+    // First client with LangChain
+    installedIntegrations.push('LangChain', 'OpenAI');
+    _markIntegrationsDisabled('OpenAI');
+    expect(_isIntegrationMarkedDisabled('OpenAI')).toBe(true);
 
-      // setupOnce should be called
-      expect(integration.setupOnce).toHaveBeenCalledTimes(1);
-      // Integration should be in installed list
-      expect(installedIntegrations).toContain('NormalIntegration');
-    });
-
-    it('allows setup after clearing marks', () => {
-      const client = getTestClient();
-      const integration = new MockIntegration('TestIntegration');
-
-      // Mark, clear, then setup
-      _markIntegrationsDisabled('TestIntegration');
-      _clearDisabledIntegrationsMarks();
-
-      setupIntegration(client, integration, {});
+    // Second client initialization clears marks
+    _clearDisabledIntegrationsMarks();
 
-      // setupOnce should be called after marks are cleared
-      expect(integration.setupOnce).toHaveBeenCalledTimes(1);
-      expect(installedIntegrations).toContain('TestIntegration');
-    });
+    // OpenAI can be used standalone in second client
+    expect(_isIntegrationMarkedDisabled('OpenAI')).toBe(false);
+    expect(installedIntegrations).toEqual(['LangChain']); // OpenAI removed, can setup fresh
   });
 });

packages/node/src/integrations/tracing/anthropic-ai/instrumentation.ts

@@ -5,7 +5,13 @@ import {
   InstrumentationNodeModuleDefinition,
 } from '@opentelemetry/instrumentation';
 import type { AnthropicAiClient, AnthropicAiOptions } from '@sentry/core';
-import { getClient, instrumentAnthropicAiClient, SDK_VERSION } from '@sentry/core';
+import {
+  _isIntegrationMarkedDisabled,
+  ANTHROPIC_AI_INTEGRATION_NAME,
+  getClient,
+  instrumentAnthropicAiClient,
+  SDK_VERSION,
+} from '@sentry/core';
 
 const supportedVersions = ['>=0.19.2 <1.0.0'];
 
@@ -48,6 +54,12 @@ export class SentryAnthropicAiInstrumentation extends InstrumentationBase<Anthro
     const config = this.getConfig();
 
     const WrappedAnthropic = function (this: unknown, ...args: unknown[]) {
+      // Check if disabled at runtime (after module is loaded, in case LangChain marked it)
+      if (_isIntegrationMarkedDisabled(ANTHROPIC_AI_INTEGRATION_NAME)) {
+        // Return unwrapped instance - no instrumentation
+        return Reflect.construct(Original, args) as AnthropicAiClient;
+      }
+
       const instance = Reflect.construct(Original, args);
       const client = getClient();
       const defaultPii = Boolean(client?.getOptions().sendDefaultPii);

packages/node/src/integrations/tracing/google-genai/instrumentation.ts

@@ -6,7 +6,14 @@ import {
   InstrumentationNodeModuleFile,
 } from '@opentelemetry/instrumentation';
 import type { GoogleGenAIClient, GoogleGenAIOptions } from '@sentry/core';
-import { getClient, instrumentGoogleGenAIClient, replaceExports, SDK_VERSION } from '@sentry/core';
+import {
+  _isIntegrationMarkedDisabled,
+  getClient,
+  GOOGLE_GENAI_INTEGRATION_NAME,
+  instrumentGoogleGenAIClient,
+  replaceExports,
+  SDK_VERSION,
+} from '@sentry/core';
 
 const supportedVersions = ['>=0.10.0 <2'];
 
@@ -65,14 +72,18 @@ export class SentryGoogleGenAiInstrumentation extends InstrumentationBase<Google
     }
 
     const WrappedGoogleGenAI = function (this: unknown, ...args: unknown[]): GoogleGenAIClient {
+      // Check if disabled at runtime (after module is loaded, in case LangChain marked it)
+      if (_isIntegrationMarkedDisabled(GOOGLE_GENAI_INTEGRATION_NAME)) {
+        // Return unwrapped instance - no instrumentation
+        return Reflect.construct(Original, args) as GoogleGenAIClient;
+      }
+
       const instance = Reflect.construct(Original, args);
       const client = getClient();
       const defaultPii = Boolean(client?.getOptions().sendDefaultPii);
 
       const typedConfig = config;
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       const recordInputs = typedConfig?.recordInputs ?? defaultPii;
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
       const recordOutputs = typedConfig?.recordOutputs ?? defaultPii;
 
       return instrumentGoogleGenAIClient(instance, {

packages/node/src/integrations/tracing/langchain/instrumentation.ts

@@ -160,9 +160,7 @@ export class SentryLangChainInstrumentation extends InstrumentationBase<LangChai
 
     const config = this.getConfig();
 
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     const recordInputs = config?.recordInputs ?? defaultPii;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     const recordOutputs = config?.recordOutputs ?? defaultPii;
 
     // Create a shared handler instance

packages/node/src/integrations/tracing/openai/instrumentation.ts

@@ -5,7 +5,13 @@ import {
   InstrumentationNodeModuleDefinition,
 } from '@opentelemetry/instrumentation';
 import type { Integration, OpenAiClient, OpenAiOptions } from '@sentry/core';
-import { getClient, instrumentOpenAiClient, OPENAI_INTEGRATION_NAME, SDK_VERSION } from '@sentry/core';
+import {
+  _isIntegrationMarkedDisabled,
+  getClient,
+  instrumentOpenAiClient,
+  OPENAI_INTEGRATION_NAME,
+  SDK_VERSION,
+} from '@sentry/core';
 
 const supportedVersions = ['>=4.0.0 <6'];
 
@@ -56,6 +62,12 @@ export class SentryOpenAiInstrumentation extends InstrumentationBase<Instrumenta
     const Original = exports.OpenAI;
 
     const WrappedOpenAI = function (this: unknown, ...args: unknown[]) {
+      // Check if disabled at runtime (after module is loaded, in case LangChain marked it)
+      if (_isIntegrationMarkedDisabled(OPENAI_INTEGRATION_NAME)) {
+        // Return unwrapped instance - no instrumentation
+        return Reflect.construct(Original, args) as OpenAiClient;
+      }
+
       const instance = Reflect.construct(Original, args);
       const client = getClient();
       const integration = client?.getIntegrationByName<OpenAiIntegration>(OPENAI_INTEGRATION_NAME);