.

Author: alexander-alderman-webb

.github/workflows/test-integrations-misc.yml

@@ -74,6 +74,10 @@ jobs:
         run: |
           set -x # print commands that are executed
           ./scripts/runtox.sh "py${{ matrix.python-version }}-typer"
+      - name: Test integration_deactivation
+        run: |
+          set -x # print commands that are executed
+          ./scripts/runtox.sh "py${{ matrix.python-version }}-integration_deactivation"
       - name: Generate coverage XML (Python 3.6)
         if: ${{ !cancelled() && matrix.python-version == '3.6' }}
         run: |

scripts/populate_tox/package_dependencies.jsonl

@@ -64,6 +64,7 @@
     "aws_lambda",
     "cloud_resource_context",
     "common",
+    "integration_deactivation",
     "gcp",
     "gevent",
     "opentelemetry",

scripts/populate_tox/populate_tox.py

@@ -23,6 +23,9 @@ envlist =
     # === Gevent ===
     {py3.6,py3.8,py3.10,py3.11,py3.12}-gevent
 
+    # === Integration Deactivation ===
+    {py3.9,py3.10,py3.11,py3.12,py3.13,py3.14}-integration_deactivation
+
     # === Integrations ===
 
     # Asgi
@@ -88,6 +91,11 @@ deps =
     {py3.10,py3.11}-gevent: zope.event<5.0.0
     {py3.10,py3.11}-gevent: zope.interface<8.0
 
+    # === Integration Deactivation ===
+    integration_deactivation: openai
+    integration_deactivation: anthropic
+    integration_deactivation: langchain
+
     # === Integrations ===
 
     # Asgi
@@ -144,6 +152,7 @@ setenv =
     # TESTPATH definitions for test suites not managed by toxgen
     common: TESTPATH=tests
     gevent: TESTPATH=tests
+    integration_deactivation: TESTPATH=tests/test_ai_integration_deactivation.py
     asgi: TESTPATH=tests/integrations/asgi
     aws_lambda: TESTPATH=tests/integrations/aws_lambda
     cloud_resource_context: TESTPATH=tests/integrations/cloud_resource_context

scripts/populate_tox/releases.jsonl

@@ -154,6 +154,7 @@
         "pure_eval",
         "trytond",
         "typer",
+        "integration_deactivation",
     ],
 }
 

scripts/populate_tox/tox.jinja

@@ -27,6 +27,7 @@
     get_before_send_log,
     get_before_send_metric,
     has_logs_enabled,
+    has_metrics_enabled,
 )
 from sentry_sdk.serializer import serialize
 from sentry_sdk.tracing import trace
@@ -374,7 +375,9 @@ def _capture_envelope(envelope):
 
                 self.log_batcher = LogBatcher(capture_func=_capture_envelope)
 
-            self.metrics_batcher = MetricsBatcher(capture_func=_capture_envelope)
+            self.metrics_batcher = None
+            if has_metrics_enabled(self.options):
+                self.metrics_batcher = MetricsBatcher(capture_func=_capture_envelope)
 
             max_request_body_size = ("always", "never", "small", "medium")
             if self.options["max_request_body_size"] not in max_request_body_size:
@@ -975,7 +978,7 @@ def _capture_log(self, log):
 
     def _capture_metric(self, metric):
         # type: (Optional[Metric]) -> None
-        if metric is None:
+        if not has_metrics_enabled(self.options) or metric is None:
             return
 
         current_scope = sentry_sdk.get_current_scope()

scripts/split_tox_gh_actions/split_tox_gh_actions.py

@@ -706,6 +706,12 @@ class SPANDATA:
     Example: 6379
     """
 
+    NETWORK_TRANSPORT = "network.transport"
+    """
+    The transport protocol used for the network connection.
+    Example: "tcp", "udp", "unix"
+    """
+
     PROFILER_ID = "profiler_id"
     """
     Label identifying the profiler id that the span occurred in. This should be a string.
@@ -824,7 +830,7 @@ class SPANDATA:
     MCP_TRANSPORT = "mcp.transport"
     """
     The transport method used for MCP communication.
-    Example: "pipe" (stdio), "tcp" (HTTP/WebSocket/SSE)
+    Example: "http", "sse", "stdio"
     """
 
     MCP_SESSION_ID = "mcp.session.id"
@@ -1005,6 +1011,7 @@ def __init__(
         enable_logs=False,  # type: bool
         before_send_log=None,  # type: Optional[Callable[[Log, Hint], Optional[Log]]]
         trace_ignore_status_codes=frozenset(),  # type: AbstractSet[int]
+        enable_metrics=True,  # type: bool
         before_send_metric=None,  # type: Optional[Callable[[Metric, Hint], Optional[Metric]]]
     ):
         # type: (...) -> None

sentry_sdk/client.py

@@ -171,6 +171,11 @@ def iter_default_integrations(with_auto_enabling_integrations):
 }
 
 
+_INTEGRATION_DEACTIVATES = {
+    "langchain": {"openai", "anthropic"},
+}
+
+
 def setup_integrations(
     integrations,  # type: Sequence[Integration]
     with_defaults=True,  # type: bool
@@ -187,13 +192,24 @@ def setup_integrations(
 
     `disabled_integrations` takes precedence over `with_defaults` and
     `with_auto_enabling_integrations`.
+
+    Some integrations are designed to automatically deactivate other integrations
+    in order to avoid conflicts and prevent duplicate telemetry from being collected.
+    For example, enabling the `langchain` integration will auto-deactivate both the
+    `openai` and `anthropic` integrations.
+
+    Users can override this behavior by:
+      - Explicitly providing an integration in the `integrations=[]` list, or
+      - Disabling the higher-level integration via the `disabled_integrations` option.
     """
     integrations = dict(
         (integration.identifier, integration) for integration in integrations or ()
     )
 
     logger.debug("Setting up integrations (with default = %s)", with_defaults)
 
+    user_provided_integrations = set(integrations.keys())
+
     # Integrations that will not be enabled
     disabled_integrations = [
         integration if isinstance(integration, type) else type(integration)
@@ -212,6 +228,27 @@ def setup_integrations(
                 integrations[instance.identifier] = instance
                 used_as_default_integration.add(instance.identifier)
 
+    disabled_integration_identifiers = {
+        integration.identifier for integration in disabled_integrations
+    }
+
+    for integration, targets_to_deactivate in _INTEGRATION_DEACTIVATES.items():
+        if (
+            integration in integrations
+            and integration not in disabled_integration_identifiers
+        ):
+            for target in targets_to_deactivate:
+                if target not in user_provided_integrations:
+                    for cls in iter_default_integrations(True):
+                        if cls.identifier == target:
+                            if cls not in disabled_integrations:
+                                disabled_integrations.append(cls)
+                                logger.debug(
+                                    "Auto-deactivating %s integration because %s integration is active",
+                                    target,
+                                    integration,
+                                )
+
     for identifier, integration in integrations.items():
         with _installer_lock:
             if identifier not in _processed_integrations:

sentry_sdk/consts.py

@@ -56,34 +56,44 @@ def setup_once():
 def _get_request_context_data():
     # type: () -> tuple[Optional[str], Optional[str], str]
     """
-    Extract request ID, session ID, and transport type from the MCP request context.
+    Extract request ID, session ID, and MCP transport type from the request context.
 
     Returns:
-        Tuple of (request_id, session_id, transport).
+        Tuple of (request_id, session_id, mcp_transport).
         - request_id: May be None if not available
         - session_id: May be None if not available
-        - transport: "tcp" for HTTP-based, "pipe" for stdio
+        - mcp_transport: "http", "sse", "stdio"
     """
     request_id = None  # type: Optional[str]
     session_id = None  # type: Optional[str]
-    transport = "pipe"  # type: str
+    mcp_transport = "stdio"  # type: str
 
     try:
         ctx = request_ctx.get()
 
         if ctx is not None:
             request_id = ctx.request_id
             if hasattr(ctx, "request") and ctx.request is not None:
-                transport = "tcp"
                 request = ctx.request
-                if hasattr(request, "headers"):
+                # Detect transport type by checking request characteristics
+                if hasattr(request, "query_params") and request.query_params.get(
+                    "session_id"
+                ):
+                    # SSE transport uses query parameter
+                    mcp_transport = "sse"
+                    session_id = request.query_params.get("session_id")
+                elif hasattr(request, "headers") and request.headers.get(
+                    "mcp-session-id"
+                ):
+                    # StreamableHTTP transport uses header
+                    mcp_transport = "http"
                     session_id = request.headers.get("mcp-session-id")
 
     except LookupError:
-        # No request context available - default to pipe
+        # No request context available - default to stdio
         pass
 
-    return request_id, session_id, transport
+    return request_id, session_id, mcp_transport
 
 
 def _get_span_config(handler_type, item_name):
@@ -120,16 +130,20 @@ def _set_span_input_data(
     arguments,
     request_id,
     session_id,
-    transport,
+    mcp_transport,
 ):
     # type: (Any, str, str, str, dict[str, Any], Optional[str], Optional[str], str) -> None
     """Set input span data for MCP handlers."""
+
     # Set handler identifier
     span.set_data(span_data_key, handler_name)
     span.set_data(SPANDATA.MCP_METHOD_NAME, mcp_method_name)
 
-    # Set transport type
-    span.set_data(SPANDATA.MCP_TRANSPORT, transport)
+    # Set transport/MCP transport type
+    span.set_data(
+        SPANDATA.NETWORK_TRANSPORT, "pipe" if mcp_transport == "stdio" else "tcp"
+    )
+    span.set_data(SPANDATA.MCP_TRANSPORT, mcp_transport)
 
     # Set request_id if provided
     if request_id:
@@ -331,7 +345,7 @@ async def _async_handler_wrapper(handler_type, func, original_args):
         origin=MCPIntegration.origin,
     ) as span:
         # Get request ID, session ID, and transport from context
-        request_id, session_id, transport = _get_request_context_data()
+        request_id, session_id, mcp_transport = _get_request_context_data()
 
         # Set input span data
         _set_span_input_data(
@@ -342,7 +356,7 @@ async def _async_handler_wrapper(handler_type, func, original_args):
             arguments,
             request_id,
             session_id,
-            transport,
+            mcp_transport,
         )
 
         # For resources, extract and set protocol
@@ -396,7 +410,7 @@ def _sync_handler_wrapper(handler_type, func, original_args):
         origin=MCPIntegration.origin,
     ) as span:
         # Get request ID, session ID, and transport from context
-        request_id, session_id, transport = _get_request_context_data()
+        request_id, session_id, mcp_transport = _get_request_context_data()
 
         # Set input span data
         _set_span_input_data(
@@ -407,7 +421,7 @@ def _sync_handler_wrapper(handler_type, func, original_args):
             arguments,
             request_id,
             session_id,
-            transport,
+            mcp_transport,
         )
 
         # For resources, extract and set protocol