Merge branch 'master' into py-2322-port-event-processor-data-to-span-first-rme79

Author: ericapisani

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

@@ -32,7 +32,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.7","3.8","3.9","3.10","3.12","3.13","3.14","3.14t"]
+        python-version: ["3.7","3.8","3.10","3.12","3.13","3.14","3.14t"]
         # python3.6 reached EOL and is no longer being supported on
         # new versions of hosted runners on Github Actions
         # ubuntu-20.04 is the last version that supported python3.6

scripts/populate_tox/package_dependencies.jsonl

@@ -5,7 +5,6 @@
 """
 
 import sys
-import asyncio
 import inspect
 from copy import deepcopy
 from functools import partial
@@ -69,6 +68,13 @@
 TRANSACTION_STYLE_VALUES = ("endpoint", "url")
 
 
+# Vendored: https://github.com/Kludex/uvicorn/blob/b224045f5900b7f766743bcb16ba9fc3adea2606/uvicorn/_compat.py#L10-L13
+if sys.version_info >= (3, 14):
+    from inspect import iscoroutinefunction
+else:
+    from asyncio import iscoroutinefunction
+
+
 def _capture_exception(exc: "Any", mechanism_type: str = "asgi") -> None:
     event, hint = event_from_exception(
         exc,
@@ -87,10 +93,10 @@ def _looks_like_asgi3(app: "Any") -> bool:
     if inspect.isclass(app):
         return hasattr(app, "__await__")
     elif inspect.isfunction(app):
-        return asyncio.iscoroutinefunction(app)
+        return iscoroutinefunction(app)
     else:
         call = getattr(app, "__call__", None)  # noqa
-        return asyncio.iscoroutinefunction(call)
+        return iscoroutinefunction(call)
 
 
 class SentryAsgiMiddleware:

scripts/populate_tox/releases.jsonl

@@ -14,10 +14,12 @@
 )
 from sentry_sdk.integrations.celery.utils import _now_seconds_since_epoch
 from sentry_sdk.integrations.logging import ignore_logger
+from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.traces import StreamedSpan
 from sentry_sdk.tracing import BAGGAGE_HEADER_NAME, Span, TransactionSource
 from sentry_sdk.tracing_utils import Baggage, has_span_streaming_enabled
 from sentry_sdk.utils import (
+    SENSITIVE_DATA_SUBSTITUTE,
     capture_internal_exceptions,
     event_from_exception,
     reraise,
@@ -143,8 +145,12 @@ def event_processor(event: "Event", hint: "Hint") -> "Optional[Event]":
             extra = event.setdefault("extra", {})
             extra["celery-job"] = {
                 "task_name": task.name,
-                "args": args,
-                "kwargs": kwargs,
+                "args": (
+                    args if should_send_default_pii() else SENSITIVE_DATA_SUBSTITUTE
+                ),
+                "kwargs": (
+                    kwargs if should_send_default_pii() else SENSITIVE_DATA_SUBSTITUTE
+                ),
             }
 
         if "exc_info" in hint:

sentry_sdk/integrations/asgi.py

@@ -1,4 +1,4 @@
-import asyncio
+import sys
 from copy import deepcopy
 from functools import wraps
 
@@ -34,6 +34,13 @@
 _DEFAULT_TRANSACTION_NAME = "generic FastAPI request"
 
 
+# Vendored: https://github.com/Kludex/starlette/blob/0a29b5ccdcbd1285c75c4fdb5d62ae1d244a21b0/starlette/_utils.py#L11-L17
+if sys.version_info >= (3, 13):  # pragma: no cover
+    from inspect import iscoroutinefunction
+else:
+    from asyncio import iscoroutinefunction
+
+
 class FastApiIntegration(StarletteIntegration):
     identifier = "fastapi"
 
@@ -76,7 +83,7 @@ def _sentry_get_request_handler(*args: "Any", **kwargs: "Any") -> "Any":
         if (
             dependant
             and dependant.call is not None
-            and not asyncio.iscoroutinefunction(dependant.call)
+            and not iscoroutinefunction(dependant.call)
         ):
             old_call = dependant.call
 

sentry_sdk/integrations/celery/__init__.py

@@ -143,7 +143,8 @@ def graphql_span(
 
     _graphql_span = sentry_sdk.start_span(op=op, name=operation_name)
 
-    _graphql_span.set_data("graphql.document", source)
+    if should_send_default_pii():
+        _graphql_span.set_data("graphql.document", source)
     _graphql_span.set_data("graphql.operation.name", operation_name)
     _graphql_span.set_data("graphql.operation.type", operation_type)
 

sentry_sdk/integrations/fastapi.py

@@ -25,7 +25,7 @@ def __init__(
         self: "ServerInterceptor",
         find_name: "Callable[[ServicerContext], str] | None" = None,
     ) -> None:
-        self._find_method_name = find_name or self._find_name
+        self._custom_find_name = find_name
 
         super().__init__()
 
@@ -34,17 +34,21 @@ async def intercept_service(
         continuation: "Callable[[HandlerCallDetails], Awaitable[RpcMethodHandler]]",
         handler_call_details: "HandlerCallDetails",
     ) -> "Optional[Awaitable[RpcMethodHandler]]":
-        self._handler_call_details = handler_call_details
         handler = await continuation(handler_call_details)
         if handler is None:
             return None
 
+        method_name = handler_call_details.method
+        custom_find_name = self._custom_find_name
+
         if not handler.request_streaming and not handler.response_streaming:
             handler_factory = grpc.unary_unary_rpc_method_handler
 
             async def wrapped(request: "Any", context: "ServicerContext") -> "Any":
                 with sentry_sdk.isolation_scope():
-                    name = self._find_method_name(context)
+                    name = (
+                        custom_find_name(context) if custom_find_name else method_name
+                    )
                     if not name:
                         return await handler(request, context)
 
@@ -96,6 +100,3 @@ async def wrapped(request: "Any", context: "ServicerContext") -> "Any":  # type:
             request_deserializer=handler.request_deserializer,
             response_serializer=handler.response_serializer,
         )
-
-    def _find_name(self, context: "ServicerContext") -> str:
-        return self._handler_call_details.method

sentry_sdk/integrations/graphene.py

@@ -12,9 +12,11 @@
 from typing import TYPE_CHECKING
 
 import sentry_sdk
-from sentry_sdk.ai.utils import get_start_span_function
+from sentry_sdk.ai.utils import _set_span_data_attribute, get_start_span_function
 from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations import Integration, DidNotEnable
+from sentry_sdk.traces import StreamedSpan
+from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.utils import safe_serialize
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.integrations._wsgi_common import nullcontext
@@ -33,8 +35,10 @@
 
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Optional, Tuple, ContextManager
+    from typing import Any, Callable, Optional, Tuple, Union, ContextManager
 
+    from sentry_sdk.tracing import Span
+    from sentry_sdk.traces import StreamedSpan
     from starlette.types import Receive, Scope, Send  # type: ignore[import-not-found]
 
 
@@ -156,7 +160,7 @@ def _get_span_config(
 
 
 def _set_span_input_data(
-    span: "Any",
+    span: "Union[StreamedSpan, Span]",
     handler_name: str,
     span_data_key: str,
     mcp_method_name: str,
@@ -168,26 +172,28 @@ def _set_span_input_data(
     """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_span_data_attribute(span, span_data_key, handler_name)
+    _set_span_data_attribute(span, SPANDATA.MCP_METHOD_NAME, mcp_method_name)
 
     # Set transport/MCP transport type
-    span.set_data(
-        SPANDATA.NETWORK_TRANSPORT, "pipe" if mcp_transport == "stdio" else "tcp"
+    _set_span_data_attribute(
+        span,
+        SPANDATA.NETWORK_TRANSPORT,
+        "pipe" if mcp_transport == "stdio" else "tcp",
     )
-    span.set_data(SPANDATA.MCP_TRANSPORT, mcp_transport)
+    _set_span_data_attribute(span, SPANDATA.MCP_TRANSPORT, mcp_transport)
 
     # Set request_id if provided
     if request_id:
-        span.set_data(SPANDATA.MCP_REQUEST_ID, request_id)
+        _set_span_data_attribute(span, SPANDATA.MCP_REQUEST_ID, request_id)
 
     # Set session_id if provided
     if session_id:
-        span.set_data(SPANDATA.MCP_SESSION_ID, session_id)
+        _set_span_data_attribute(span, SPANDATA.MCP_SESSION_ID, session_id)
 
     # Set request arguments (excluding common request context objects)
     for k, v in arguments.items():
-        span.set_data(f"mcp.request.argument.{k}", safe_serialize(v))
+        _set_span_data_attribute(span, f"mcp.request.argument.{k}", safe_serialize(v))
 
 
 def _extract_tool_result_content(result: "Any") -> "Any":
@@ -231,7 +237,10 @@ def _extract_tool_result_content(result: "Any") -> "Any":
 
 
 def _set_span_output_data(
-    span: "Any", result: "Any", result_data_key: "Optional[str]", handler_type: str
+    span: "Union[StreamedSpan, Span]",
+    result: "Any",
+    result_data_key: "Optional[str]",
+    handler_type: str,
 ) -> None:
     """Set output span data for MCP handlers."""
     if result is None:
@@ -248,11 +257,17 @@ def _set_span_output_data(
     # For tools, extract the meaningful content
     if handler_type == "tool":
         extracted = _extract_tool_result_content(result)
-        if extracted is not None and should_include_data:
-            span.set_data(result_data_key, safe_serialize(extracted))
+        if (
+            extracted is not None
+            and should_include_data
+            and result_data_key is not None
+        ):
+            _set_span_data_attribute(span, result_data_key, safe_serialize(extracted))
             # Set content count if result is a dict
             if isinstance(extracted, dict):
-                span.set_data(SPANDATA.MCP_TOOL_RESULT_CONTENT_COUNT, len(extracted))
+                _set_span_data_attribute(
+                    span, SPANDATA.MCP_TOOL_RESULT_CONTENT_COUNT, len(extracted)
+                )
     elif handler_type == "prompt":
         # For prompts, count messages and set role/content only for single-message prompts
         try:
@@ -270,7 +285,9 @@ def _set_span_output_data(
 
             # Always set message count if we found messages
             if message_count > 0:
-                span.set_data(SPANDATA.MCP_PROMPT_RESULT_MESSAGE_COUNT, message_count)
+                _set_span_data_attribute(
+                    span, SPANDATA.MCP_PROMPT_RESULT_MESSAGE_COUNT, message_count
+                )
 
             # Only set role and content for single-message prompts if PII is allowed
             if message_count == 1 and should_include_data and messages:
@@ -283,7 +300,9 @@ def _set_span_output_data(
                     role = first_message["role"]
 
                 if role:
-                    span.set_data(SPANDATA.MCP_PROMPT_RESULT_MESSAGE_ROLE, role)
+                    _set_span_data_attribute(
+                        span, SPANDATA.MCP_PROMPT_RESULT_MESSAGE_ROLE, role
+                    )
 
                 # Extract content text
                 content_text = None
@@ -303,8 +322,8 @@ def _set_span_output_data(
                     elif isinstance(msg_content, str):
                         content_text = msg_content
 
-                if content_text:
-                    span.set_data(result_data_key, content_text)
+                if content_text and result_data_key is not None:
+                    _set_span_data_attribute(span, result_data_key, content_text)
         except Exception:
             # Silently ignore if we can't extract message info
             pass
@@ -434,14 +453,28 @@ async def _handler_wrapper(
     # Get request ID, session ID, and transport from context
     request_id, session_id, mcp_transport = _get_request_context_data()
 
+    span_streaming = has_span_streaming_enabled(sentry_sdk.get_client().options)
+
     # Start span and execute
     with isolation_scope_context:
         with current_scope_context:
-            with get_start_span_function()(
-                op=OP.MCP_SERVER,
-                name=span_name,
-                origin=MCPIntegration.origin,
-            ) as span:
+            span_mgr: "Union[Span, StreamedSpan]"
+            if span_streaming:
+                span_mgr = sentry_sdk.traces.start_span(
+                    name=span_name,
+                    attributes={
+                        "sentry.op": OP.MCP_SERVER,
+                        "sentry.origin": MCPIntegration.origin,
+                    },
+                )
+            else:
+                span_mgr = get_start_span_function()(
+                    op=OP.MCP_SERVER,
+                    name=span_name,
+                    origin=MCPIntegration.origin,
+                )
+
+            with span_mgr as span:
                 # Set input span data
                 _set_span_input_data(
                     span,
@@ -467,7 +500,9 @@ async def _handler_wrapper(
                     elif handler_name and "://" in handler_name:
                         protocol = handler_name.split("://")[0]
                     if protocol:
-                        span.set_data(SPANDATA.MCP_RESOURCE_PROTOCOL, protocol)
+                        _set_span_data_attribute(
+                            span, SPANDATA.MCP_RESOURCE_PROTOCOL, protocol
+                        )
 
                 try:
                     # Execute the async handler
@@ -481,7 +516,9 @@ async def _handler_wrapper(
                 except Exception as e:
                     # Set error flag for tools
                     if handler_type == "tool":
-                        span.set_data(SPANDATA.MCP_TOOL_RESULT_IS_ERROR, True)
+                        _set_span_data_attribute(
+                            span, SPANDATA.MCP_TOOL_RESULT_IS_ERROR, True
+                        )
                     sentry_sdk.capture_exception(e)
                     raise
 

sentry_sdk/integrations/grpc/aio/server.py

@@ -1,5 +1,6 @@
 import asyncio
 import inspect
+import sys
 from functools import wraps
 
 import sentry_sdk
@@ -100,15 +101,19 @@ async def sentry_patched_asgi_app(
 
 
 def patch_scaffold_route() -> None:
+    # Vendored: https://github.com/pallets/quart/blob/5817e983d0b586889337a596d674c0c246d68878/src/quart/app.py#L137-L140
+    if sys.version_info >= (3, 12):
+        iscoroutinefunction = inspect.iscoroutinefunction
+    else:
+        iscoroutinefunction = asyncio.iscoroutinefunction
+
     old_route = Scaffold.route
 
     def _sentry_route(*args: "Any", **kwargs: "Any") -> "Any":
         old_decorator = old_route(*args, **kwargs)
 
         def decorator(old_func: "Any") -> "Any":
-            if inspect.isfunction(old_func) and not asyncio.iscoroutinefunction(
-                old_func
-            ):
+            if inspect.isfunction(old_func) and not iscoroutinefunction(old_func):
 
                 @wraps(old_func)
                 @ensure_integration_enabled(QuartIntegration, old_func)