merge master

Author: alexander-alderman-webb

.claude/settings.json

@@ -30,11 +30,15 @@
       "Bash(mv:*)",
       "Bash(source .venv/bin/activate)",
       "Bash(source tox.venv/bin/activate:*)",
+      "Bash(source .tox/*/bin/activate:*)",
       "Bash(tox:*)",
       "Bash(tox.venv/bin/tox:*)",
       "Bash(.tox/*/bin/python:*)",
       "Bash(.tox/*/bin/pytest:*)",
-      "Bash(.tox/*/bin/ruff:*)"
+      "Bash(.tox/*/bin/ruff:*)",
+      "Bash(ruff format:*)",
+      "Bash(ruff check:*)",
+      "Bash(mypy:*)"
     ],
     "deny": []
   }

sentry_sdk/integrations/huey.py

@@ -34,6 +34,13 @@
 except ImportError:
     raise DidNotEnable("Huey is not installed")
 
+try:
+    from huey.api import chord as HueyChord
+    from huey.api import group as HueyGroup
+except ImportError:
+    HueyChord = None
+    HueyGroup = None
+
 
 HUEY_CONTROL_FLOW_EXCEPTIONS = (CancelExecution, RetryTask, TaskLockedException)
 
@@ -53,22 +60,37 @@ def patch_enqueue() -> None:
 
     @ensure_integration_enabled(HueyIntegration, old_enqueue)
     def _sentry_enqueue(
-        self: "Huey", task: "Task"
+        self: "Huey", item: "Union[Task, HueyGroup, HueyChord]"
     ) -> "Optional[Union[Result, ResultGroup]]":
+        if HueyChord is not None and isinstance(item, HueyChord):
+            span_name = "Huey Chord"
+        elif HueyGroup is not None and isinstance(item, HueyGroup):
+            span_name = "Huey Task Group"
+        else:
+            span_name = item.name
+
         with sentry_sdk.start_span(
             op=OP.QUEUE_SUBMIT_HUEY,
-            name=task.name,
+            name=span_name,
             origin=HueyIntegration.origin,
         ):
-            if not isinstance(task, PeriodicTask):
+            if (
+                not isinstance(item, PeriodicTask)
+                and not (HueyGroup is not None and isinstance(item, HueyGroup))
+                and not (HueyChord is not None and isinstance(item, HueyChord))
+            ):
                 # Attach trace propagation data to task kwargs. We do
                 # not do this for periodic tasks, as these don't
                 # really have an originating transaction.
-                task.kwargs["sentry_headers"] = {
+                # Additionally, we do not do this for Huey groups or chords, as enqueue will
+                # recursively call this method for each task within the list, resulting
+                # in the trace propagation data being attached to each task individually
+                # (which we want)
+                item.kwargs["sentry_headers"] = {
                     BAGGAGE_HEADER_NAME: get_baggage(),
                     SENTRY_TRACE_HEADER_NAME: get_traceparent(),
                 }
-            return old_enqueue(self, task)
+            return old_enqueue(self, item)
 
     Huey.enqueue = _sentry_enqueue
 

sentry_sdk/integrations/openai_agents/spans/ai_client.py

@@ -5,7 +5,6 @@
 
 from ..consts import SPAN_ORIGIN
 from ..utils import (
-    _create_mcp_execute_tool_spans,
     _set_agent_data,
     _set_input_data,
     _set_output_data,
@@ -55,7 +54,6 @@ def update_ai_client_span(
 
     if hasattr(response, "output") and response.output:
         _set_output_data(span, response)
-        _create_mcp_execute_tool_spans(span, response)
 
     if response_model is not None:
         span.set_data(SPANDATA.GEN_AI_RESPONSE_MODEL, response_model)

sentry_sdk/integrations/openai_agents/utils.py

@@ -14,7 +14,7 @@
     set_data_normalized,
     truncate_and_annotate_messages,
 )
-from sentry_sdk.consts import OP, SPANDATA, SPANSTATUS
+from sentry_sdk.consts import SPANDATA
 from sentry_sdk.integrations import DidNotEnable
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.utils import event_from_exception, safe_serialize
@@ -215,25 +215,3 @@ def _set_output_data(span: "sentry_sdk.tracing.Span", result: "Any") -> None:
         set_data_normalized(
             span, SPANDATA.GEN_AI_RESPONSE_TEXT, output_messages["response"]
         )
-
-
-def _create_mcp_execute_tool_spans(
-    span: "sentry_sdk.tracing.Span", result: "agents.Result"
-) -> None:
-    for output in result.output:
-        if output.__class__.__name__ == "McpCall":
-            with sentry_sdk.start_span(
-                op=OP.GEN_AI_EXECUTE_TOOL,
-                name=f"execute_tool {output.name}",
-                start_timestamp=span.start_timestamp,
-            ) as execute_tool_span:
-                execute_tool_span.set_data(SPANDATA.GEN_AI_TOOL_NAME, output.name)
-                if should_send_default_pii():
-                    execute_tool_span.set_data(
-                        SPANDATA.GEN_AI_TOOL_INPUT, output.arguments
-                    )
-                    execute_tool_span.set_data(
-                        SPANDATA.GEN_AI_TOOL_OUTPUT, output.output
-                    )
-                if output.error:
-                    execute_tool_span.set_status(SPANSTATUS.INTERNAL_ERROR)

sentry_sdk/integrations/sanic.py

@@ -6,11 +6,14 @@
 
 import sentry_sdk
 from sentry_sdk import continue_trace
-from sentry_sdk.consts import OP
+from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations import DidNotEnable, Integration, _check_minimum_version
 from sentry_sdk.integrations._wsgi_common import RequestExtractor, _filter_headers
 from sentry_sdk.integrations.logging import ignore_logger
+from sentry_sdk.scope import should_send_default_pii
+from sentry_sdk.traces import SegmentSource, StreamedSpan
 from sentry_sdk.tracing import TransactionSource
+from sentry_sdk.tracing_utils import has_span_streaming_enabled
 from sentry_sdk.utils import (
     CONTEXTVARS_ERROR_MESSAGE,
     HAS_REAL_CONTEXTVARS,
@@ -165,23 +168,43 @@ async def _context_enter(request: "Request") -> None:
     if not request.ctx._sentry_do_integration:
         return
 
+    client = sentry_sdk.get_client()
+    is_span_streaming_enabled = has_span_streaming_enabled(client.options)
+
     weak_request = weakref.ref(request)
     request.ctx._sentry_scope = sentry_sdk.isolation_scope()
     scope = request.ctx._sentry_scope.__enter__()
     scope.clear_breadcrumbs()
     scope.add_event_processor(_make_request_processor(weak_request))
 
-    transaction = continue_trace(
-        dict(request.headers),
-        op=OP.HTTP_SERVER,
-        # Unless the request results in a 404 error, the name and source will get overwritten in _set_transaction
-        name=request.path,
-        source=TransactionSource.URL,
-        origin=SanicIntegration.origin,
-    )
-    request.ctx._sentry_transaction = sentry_sdk.start_transaction(
-        transaction
-    ).__enter__()
+    if is_span_streaming_enabled:
+        sentry_sdk.traces.continue_trace(dict(request.headers))
+        scope.set_custom_sampling_context({"sanic_request": request})
+
+        span = sentry_sdk.traces.start_span(
+            # Unless the request results in a 404 error, the name and source
+            # will get overwritten in _set_transaction
+            name=request.path,
+            attributes={
+                "sentry.op": OP.HTTP_SERVER,
+                "sentry.origin": SanicIntegration.origin,
+                "sentry.span.source": SegmentSource.URL.value,
+            },
+            parent_span=None,
+        )
+        request.ctx._sentry_root_span = span
+    else:
+        transaction = continue_trace(
+            dict(request.headers),
+            op=OP.HTTP_SERVER,
+            # Unless the request results in a 404 error, the name and source will get overwritten in _set_transaction
+            name=request.path,
+            source=TransactionSource.URL,
+            origin=SanicIntegration.origin,
+        )
+        request.ctx._sentry_root_span = sentry_sdk.start_transaction(
+            transaction
+        ).__enter__()
 
 
 async def _context_exit(
@@ -198,12 +221,24 @@ async def _context_exit(
         # This capture_internal_exceptions block has been intentionally nested here, so that in case an exception
         # happens while trying to end the transaction, we still attempt to exit the hub.
         with capture_internal_exceptions():
-            request.ctx._sentry_transaction.set_http_status(response_status)
-            request.ctx._sentry_transaction.sampled &= (
-                isinstance(integration, SanicIntegration)
-                and response_status not in integration._unsampled_statuses
-            )
-            request.ctx._sentry_transaction.__exit__(None, None, None)
+            span = request.ctx._sentry_root_span
+            if isinstance(span, StreamedSpan):
+                with capture_internal_exceptions():
+                    for attr, value in _get_request_attributes(request).items():
+                        span.set_attribute(attr, value)
+                if response_status is not None:
+                    span.set_attribute(SPANDATA.HTTP_STATUS_CODE, response_status)
+                    span.status = "error" if response_status >= 400 else "ok"
+
+                span.end()
+            else:
+                span.set_http_status(response_status)
+                span.sampled &= (
+                    isinstance(integration, SanicIntegration)
+                    and response_status not in integration._unsampled_statuses
+                )
+
+                span.__exit__(None, None, None)
 
         request.ctx._sentry_scope.__exit__(None, None, None)
 
@@ -315,6 +350,36 @@ def _capture_exception(exception: "Union[ExcInfo, BaseException]") -> None:
         sentry_sdk.capture_event(event, hint=hint)
 
 
+def _get_request_attributes(request: "Request") -> "Dict[str, Any]":
+    """
+    Return span attributes related to the HTTP request from a Sanic request.
+    """
+    attributes = {}  # type: Dict[str, Any]
+
+    if request.method:
+        attributes[SPANDATA.HTTP_REQUEST_METHOD] = request.method.upper()
+
+    headers = _filter_headers(dict(request.headers), use_annotated_value=False)
+    for header, value in headers.items():
+        attributes[f"{SPANDATA.HTTP_REQUEST_HEADER}.{header.lower()}"] = value
+
+    urlparts = urlsplit(request.url)
+
+    if urlparts.query:
+        attributes[SPANDATA.HTTP_QUERY] = urlparts.query
+
+    attributes[SPANDATA.URL_FULL] = request.url
+
+    if urlparts.scheme:
+        attributes[SPANDATA.NETWORK_PROTOCOL_NAME] = urlparts.scheme
+
+    if should_send_default_pii() and request.remote_addr:
+        attributes[SPANDATA.CLIENT_ADDRESS] = request.remote_addr
+        attributes[SPANDATA.USER_IP_ADDRESS] = request.remote_addr
+
+    return attributes
+
+
 def _make_request_processor(weak_request: "Callable[[], Request]") -> "EventProcessor":
     def sanic_processor(event: "Event", hint: "Optional[Hint]") -> "Optional[Event]":
         try: