merge master

Author: alexander-alderman-webb

sentry_sdk/integrations/mcp.py

@@ -24,6 +24,11 @@
 except ImportError:
     raise DidNotEnable("MCP SDK not installed")
 
+try:
+    from fastmcp import FastMCP  # type: ignore[import-not-found]
+except ImportError:
+    FastMCP = None
+
 
 if TYPE_CHECKING:
     from typing import Any, Callable, Optional
@@ -50,6 +55,9 @@ def setup_once() -> None:
         """
         _patch_lowlevel_server()
 
+        if FastMCP is not None:
+            _patch_fastmcp()
+
 
 def _get_request_context_data() -> "tuple[Optional[str], Optional[str], str]":
     """
@@ -280,26 +288,53 @@ def _set_span_output_data(
 
 
 def _prepare_handler_data(
-    handler_type: str, original_args: "tuple[Any, ...]"
+    handler_type: str,
+    original_args: "tuple[Any, ...]",
+    original_kwargs: "Optional[dict[str, Any]]" = None,
 ) -> "tuple[str, dict[str, Any], str, str, str, Optional[str]]":
     """
     Prepare common handler data for both async and sync wrappers.
 
     Returns:
         Tuple of (handler_name, arguments, span_data_key, span_name, mcp_method_name, result_data_key)
     """
+    original_kwargs = original_kwargs or {}
+
     # Extract handler-specific data based on handler type
     if handler_type == "tool":
-        handler_name = original_args[0]  # tool_name
-        arguments = original_args[1] if len(original_args) > 1 else {}
+        if original_args:
+            handler_name = original_args[0]
+        elif original_kwargs.get("name"):
+            handler_name = original_kwargs["name"]
+
+        arguments = {}
+        if len(original_args) > 1:
+            arguments = original_args[1]
+        elif original_kwargs.get("arguments"):
+            arguments = original_kwargs["arguments"]
+
     elif handler_type == "prompt":
-        handler_name = original_args[0]  # name
-        arguments = original_args[1] if len(original_args) > 1 else {}
+        if original_args:
+            handler_name = original_args[0]
+        elif original_kwargs.get("name"):
+            handler_name = original_kwargs["name"]
+
+        arguments = {}
+        if len(original_args) > 1:
+            arguments = original_args[1]
+        elif original_kwargs.get("arguments"):
+            arguments = original_kwargs["arguments"]
+
         # Include name in arguments dict for span data
         arguments = {"name": handler_name, **(arguments or {})}
+
     else:  # resource
-        uri = original_args[0]
-        handler_name = str(uri) if uri else "unknown"
+        handler_name = "unknown"
+        if original_args:
+            handler_name = str(original_args[0])
+        elif original_kwargs.get("uri"):
+            handler_name = str(original_kwargs["uri"])
+
         arguments = {}
 
     # Get span configuration
@@ -318,7 +353,11 @@ def _prepare_handler_data(
 
 
 async def _async_handler_wrapper(
-    handler_type: str, func: "Callable[..., Any]", original_args: "tuple[Any, ...]"
+    handler_type: str,
+    func: "Callable[..., Any]",
+    original_args: "tuple[Any, ...]",
+    original_kwargs: "Optional[dict[str, Any]]" = None,
+    self: "Optional[Any]" = None,
 ) -> "Any":
     """
     Async wrapper for MCP handlers.
@@ -327,15 +366,20 @@ async def _async_handler_wrapper(
         handler_type: "tool", "prompt", or "resource"
         func: The async handler function to wrap
         original_args: Original arguments passed to the handler
+        original_kwargs: Original keyword arguments passed to the handler
+        self: Optional instance for bound methods
     """
+    if original_kwargs is None:
+        original_kwargs = {}
+
     (
         handler_name,
         arguments,
         span_data_key,
         span_name,
         mcp_method_name,
         result_data_key,
-    ) = _prepare_handler_data(handler_type, original_args)
+    ) = _prepare_handler_data(handler_type, original_args, original_kwargs)
 
     # Start span and execute
     with get_start_span_function()(
@@ -360,7 +404,11 @@ async def _async_handler_wrapper(
 
         # For resources, extract and set protocol
         if handler_type == "resource":
-            uri = original_args[0]
+            if original_args:
+                uri = original_args[0]
+            else:
+                uri = original_kwargs.get("uri")
+
             protocol = None
             if hasattr(uri, "scheme"):
                 protocol = uri.scheme
@@ -371,7 +419,9 @@ async def _async_handler_wrapper(
 
         try:
             # Execute the async handler
-            result = await func(*original_args)
+            if self is not None:
+                original_args = (self, *original_args)
+            result = await func(*original_args, **original_kwargs)
         except Exception as e:
             # Set error flag for tools
             if handler_type == "tool":
@@ -566,3 +616,48 @@ def patched_read_resource(
         )(func)
 
     Server.read_resource = patched_read_resource
+
+
+def _patch_fastmcp():
+    # type: () -> None
+    """
+    Patches the standalone fastmcp package's FastMCP class.
+
+    The standalone fastmcp package (v2.14.0+) registers its own handlers for
+    prompts and resources directly, bypassing the Server decorators we patch.
+    This function patches the _get_prompt_mcp and _read_resource_mcp methods
+    to add instrumentation for those handlers.
+    """
+    if hasattr(FastMCP, "_get_prompt_mcp"):
+        original_get_prompt_mcp = FastMCP._get_prompt_mcp
+
+        @wraps(original_get_prompt_mcp)
+        async def patched_get_prompt_mcp(
+            self: "Any", *args: "Any", **kwargs: "Any"
+        ) -> "Any":
+            return await _async_handler_wrapper(
+                "prompt",
+                original_get_prompt_mcp,
+                args,
+                kwargs,
+                self,
+            )
+
+        FastMCP._get_prompt_mcp = patched_get_prompt_mcp
+
+    if hasattr(FastMCP, "_read_resource_mcp"):
+        original_read_resource_mcp = FastMCP._read_resource_mcp
+
+        @wraps(original_read_resource_mcp)
+        async def patched_read_resource_mcp(
+            self: "Any", *args: "Any", **kwargs: "Any"
+        ) -> "Any":
+            return await _async_handler_wrapper(
+                "resource",
+                original_read_resource_mcp,
+                args,
+                kwargs,
+                self,
+            )
+
+        FastMCP._read_resource_mcp = patched_read_resource_mcp

sentry_sdk/integrations/otlp.py

@@ -1,7 +1,12 @@
-from sentry_sdk import get_client
+from sentry_sdk import get_client, capture_event
 from sentry_sdk.integrations import Integration, DidNotEnable
 from sentry_sdk.scope import register_external_propagation_context
-from sentry_sdk.utils import logger, Dsn
+from sentry_sdk.utils import (
+    Dsn,
+    logger,
+    event_from_exception,
+    capture_internal_exceptions,
+)
 from sentry_sdk.consts import VERSION, EndpointType
 from sentry_sdk.tracing_utils import Baggage
 from sentry_sdk.tracing import (
@@ -11,7 +16,7 @@
 
 try:
     from opentelemetry.propagate import set_global_textmap
-    from opentelemetry.sdk.trace import TracerProvider
+    from opentelemetry.sdk.trace import TracerProvider, Span
     from opentelemetry.sdk.trace.export import BatchSpanProcessor
     from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 
@@ -82,6 +87,38 @@ def setup_otlp_traces_exporter(dsn: "Optional[str]" = None) -> None:
     tracer_provider.add_span_processor(span_processor)
 
 
+_sentry_patched_exception = False
+
+
+def setup_capture_exceptions() -> None:
+    """
+    Intercept otel's Span.record_exception to automatically capture those exceptions in Sentry.
+    """
+    global _sentry_patched_exception
+    _original_record_exception = Span.record_exception
+
+    if _sentry_patched_exception:
+        return
+
+    def _sentry_patched_record_exception(
+        self: "Span", exception: "BaseException", *args: "Any", **kwargs: "Any"
+    ) -> None:
+        otlp_integration = get_client().get_integration(OTLPIntegration)
+        if otlp_integration and otlp_integration.capture_exceptions:
+            with capture_internal_exceptions():
+                event, hint = event_from_exception(
+                    exception,
+                    client_options=get_client().options,
+                    mechanism={"type": OTLPIntegration.identifier, "handled": False},
+                )
+                capture_event(event, hint=hint)
+
+        _original_record_exception(self, exception, *args, **kwargs)
+
+    Span.record_exception = _sentry_patched_record_exception  # type: ignore[method-assign]
+    _sentry_patched_exception = True
+
+
 class SentryOTLPPropagator(SentryPropagator):
     """
     We need to override the inject of the older propagator since that
@@ -136,13 +173,28 @@ def _to_traceparent(span_context: "SpanContext") -> str:
 
 
 class OTLPIntegration(Integration):
+    """
+    Automatically setup OTLP ingestion from the DSN.
+
+    :param setup_otlp_traces_exporter: Automatically configure an Exporter to send OTLP traces from the DSN, defaults to True.
+        Set to False if using a custom collector or to setup the TracerProvider manually.
+    :param setup_propagator: Automatically configure the Sentry Propagator for Distributed Tracing, defaults to True.
+        Set to False to configure propagators manually or to disable propagation.
+    :param capture_exceptions: Intercept and capture exceptions on the OpenTelemetry Span in Sentry as well, defaults to False.
+        Set to True to turn on capturing but be aware that since Sentry captures most exceptions, duplicate exceptions might be dropped by DedupeIntegration in many cases.
+    """
+
     identifier = "otlp"
 
     def __init__(
-        self, setup_otlp_traces_exporter: bool = True, setup_propagator: bool = True
+        self,
+        setup_otlp_traces_exporter: bool = True,
+        setup_propagator: bool = True,
+        capture_exceptions: bool = False,
     ) -> None:
         self.setup_otlp_traces_exporter = setup_otlp_traces_exporter
         self.setup_propagator = setup_propagator
+        self.capture_exceptions = capture_exceptions
 
     @staticmethod
     def setup_once() -> None:
@@ -161,3 +213,5 @@ def setup_once_with_options(
             logger.debug("[OTLP] Setting up propagator for distributed tracing")
             # TODO-neel better propagator support, chain with existing ones if possible instead of replacing
             set_global_textmap(SentryOTLPPropagator())
+
+        setup_capture_exceptions()