update names

Author: RulaKhaled

packages/core/src/index.ts

@@ -60,10 +60,9 @@ export {
   addIntegration,
   defineIntegration,
   installedIntegrations,
-  disableIntegrations,
-  isIntegrationDisabled,
-  enableIntegration,
-  clearDisabledIntegrations,
+  _markIntegrationsDisabled,
+  _isIntegrationMarkedDisabled,
+  _clearDisabledIntegrationsMarks,
 } from './integration';
 export { applyScopeDataToEvent, mergeScopeData } from './utils/applyScopeDataToEvent';
 export { prepareEvent } from './utils/prepareEvent';

packages/core/src/integration.ts

@@ -9,62 +9,55 @@ import { debug } from './utils/debug-logger';
 export const installedIntegrations: string[] = [];
 
 /**
- * Registry to track disabled integrations.
+ * Registry to track integrations marked as disabled.
  * This is used to prevent duplicate instrumentation when higher-level integrations
  * (like LangChain) already instrument the underlying libraries (like OpenAI, Anthropic, etc.)
  */
-const DISABLED_INTEGRATIONS = new Set<string>();
+const MARKED_DISABLED_INTEGRATIONS = new Set<string>();
 
 /**
  * Mark one or more integrations as disabled to prevent their instrumentation from being set up.
- * @param integrationName The name(s) of the integration(s) to disable
+ * This should be called during an integration's setupOnce() phase.
+ * The marked integrations will be skipped when their own setupOnce() is called.
+ *
+ * @internal This is an internal API for coordination between integrations, not for public use.
+ * @param integrationName The name(s) of the integration(s) to mark as disabled
  */
-export function disableIntegrations(integrationName: string | string[]): void {
+export function _markIntegrationsDisabled(integrationName: string | string[]): void {
   if (Array.isArray(integrationName)) {
-    integrationName.forEach(name => DISABLED_INTEGRATIONS.add(name));
+    integrationName.forEach(name => MARKED_DISABLED_INTEGRATIONS.add(name));
   } else {
-    DISABLED_INTEGRATIONS.add(integrationName);
+    MARKED_DISABLED_INTEGRATIONS.add(integrationName);
   }
 }
 
 /**
- * Check if an integration has been disabled.
+ * Check if an integration has been marked as disabled.
+ *
+ * @internal This is an internal API for coordination between integrations, not for public use.
  * @param integrationName The name of the integration to check
- * @returns true if the integration is disabled
- */
-export function isIntegrationDisabled(integrationName: string): boolean {
-  return DISABLED_INTEGRATIONS.has(integrationName);
-}
-
-/**
- * Remove one or more integrations from the disabled list.
- * @param integrationName The name(s) of the integration(s) to enable
+ * @returns true if the integration is marked as disabled
  */
-export function enableIntegration(integrationName: string | string[]): void {
-  if (Array.isArray(integrationName)) {
-    integrationName.forEach(name => DISABLED_INTEGRATIONS.delete(name));
-  } else {
-    DISABLED_INTEGRATIONS.delete(integrationName);
-  }
+export function _isIntegrationMarkedDisabled(integrationName: string): boolean {
+  return MARKED_DISABLED_INTEGRATIONS.has(integrationName);
 }
 
 /**
- * Clear all disabled integrations.
- * This is automatically called during Sentry.init() to ensure a clean state.
+ * Clear all integration marks and remove marked integrations from the installed list.
+ * This is automatically called at the start of Sentry.init() to ensure a clean state
+ * between different client initializations.
  *
- * This also removes the disabled integrations from the global installedIntegrations list,
+ * This also removes the marked integrations from the global installedIntegrations list,
  * allowing them to run setupOnce() again if they're included in a new client.
+ *
+ * @internal This is an internal API for coordination between integrations, not for public use.
  */
-export function clearDisabledIntegrations(): void {
-  // Remove disabled integrations from the installed list so they can setup again
-  DISABLED_INTEGRATIONS.forEach(integrationName => {
-    const index = installedIntegrations.indexOf(integrationName);
-    if (index !== -1) {
-      installedIntegrations.splice(index, 1);
-    }
-  });
+export function _clearDisabledIntegrationsMarks(): void {
+  // Remove marked integrations from the installed list so they can setup again
+  const filtered = installedIntegrations.filter(integration => !MARKED_DISABLED_INTEGRATIONS.has(integration));
+  installedIntegrations.splice(0, installedIntegrations.length, ...filtered);
 
-  DISABLED_INTEGRATIONS.clear();
+  MARKED_DISABLED_INTEGRATIONS.clear();
 }
 
 /** Map of integrations assigned to a client */
@@ -166,9 +159,9 @@ export function setupIntegration(client: Client, integration: Integration, integ
   integrationIndex[integration.name] = integration;
 
   // `setupOnce` is only called the first time
-  if (installedIntegrations.indexOf(integration.name) === -1 && typeof integration.setupOnce === 'function') {
-    // Skip setup if integration is disabled
-    if (!isIntegrationDisabled(integration.name)) {
+  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);
     }

packages/node-core/src/index.ts

@@ -113,7 +113,6 @@ export {
   captureSession,
   endSession,
   addIntegration,
-  disableIntegrations,
   startSpan,
   startSpanManual,
   startInactiveSpan,

packages/node-core/src/sdk/client.ts

@@ -5,9 +5,9 @@ import { registerInstrumentations } from '@opentelemetry/instrumentation';
 import type { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
 import type { DynamicSamplingContext, Scope, ServerRuntimeClientOptions, TraceContext } from '@sentry/core';
 import {
+  _clearDisabledIntegrationsMarks,
   _INTERNAL_flushLogsBuffer,
   applySdkMetadata,
-  clearDisabledIntegrations,
   debug,
   SDK_VERSION,
   ServerRuntimeClient,
@@ -154,10 +154,10 @@ export class NodeClient extends ServerRuntimeClient<NodeClientOptions> {
 
   /** @inheritDoc */
   protected _setupIntegrations(): void {
-    // Clear disabled integrations before setting up integrations
+    // Clear integration marks before setting up integrations
     // This ensures that integrations work correctly when not all default integrations are used
-    // (e.g., when LangChain disables OpenAI, but a subsequent client doesn't use LangChain)
-    clearDisabledIntegrations();
+    // (e.g., when LangChain marks OpenAI as disabled, but a subsequent client doesn't use LangChain)
+    _clearDisabledIntegrationsMarks();
     super._setupIntegrations();
   }
 

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

@@ -1,8 +1,8 @@
 import type { IntegrationFn, LangChainOptions } from '@sentry/core';
 import {
+  _markIntegrationsDisabled,
   ANTHROPIC_AI_INTEGRATION_NAME,
   defineIntegration,
-  disableIntegrations,
   GOOGLE_GENAI_INTEGRATION_NAME,
   LANGCHAIN_INTEGRATION_NAME,
   OPENAI_INTEGRATION_NAME,
@@ -19,9 +19,13 @@ const _langChainIntegration = ((options: LangChainOptions = {}) => {
   return {
     name: LANGCHAIN_INTEGRATION_NAME,
     setupOnce() {
-      // Disable AI provider integrations to prevent duplicate spans
+      // Mark AI provider integrations as disabled to prevent duplicate spans
       // LangChain integration handles instrumentation for all underlying AI providers
-      disableIntegrations([OPENAI_INTEGRATION_NAME, ANTHROPIC_AI_INTEGRATION_NAME, GOOGLE_GENAI_INTEGRATION_NAME]);
+      _markIntegrationsDisabled([
+        OPENAI_INTEGRATION_NAME,
+        ANTHROPIC_AI_INTEGRATION_NAME,
+        GOOGLE_GENAI_INTEGRATION_NAME,
+      ]);
 
       instrumentLangChain(options);
     },
@@ -36,9 +40,9 @@ const _langChainIntegration = ((options: LangChainOptions = {}) => {
  * When configured, this integration automatically instruments LangChain runnable instances
  * to capture telemetry data by injecting Sentry callback handlers into all LangChain calls.
  *
- * **Important:** This integration automatically disables the OpenAI, Anthropic, and Google GenAI
- * integrations to prevent duplicate spans when using LangChain with these providers. LangChain
- * handles the instrumentation for all underlying AI providers.
+ * **Important:** This integration automatically marks the OpenAI, Anthropic, and Google GenAI
+ * integrations as disabled to prevent duplicate spans when using LangChain with these providers.
+ * LangChain handles the instrumentation for all underlying AI providers.
  *
  * @example
  * ```javascript