sentry-sdk 3.0.0a4__py2.py3-none-any.whl → 3.0.0a6__py2.py3-none-any.whl

sentry_sdk/integrations/anthropic.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 from functools import wraps
+import json
 from typing import TYPE_CHECKING
 
 import sentry_sdk
 from sentry_sdk.ai.monitoring import record_token_usage
+from sentry_sdk.ai.utils import set_data_normalized
 from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations import _check_minimum_version, DidNotEnable, Integration
 from sentry_sdk.scope import should_send_default_pii
@@ -11,9 +13,15 @@ from sentry_sdk.utils import (
     capture_internal_exceptions,
     event_from_exception,
     package_version,
+    safe_serialize,
 )
 
 try:
+    try:
+        from anthropic import NOT_GIVEN
+    except ImportError:
+        NOT_GIVEN = None
+
     from anthropic.resources import AsyncMessages, Messages
 
     if TYPE_CHECKING:
@@ -51,7 +59,10 @@ def _capture_exception(exc: Any) -> None:
     sentry_sdk.capture_event(event, hint=hint)
 
 
-def _calculate_token_usage(result: Messages, span: Span) -> None:
+def _get_token_usage(result: Messages) -> tuple[int, int]:
+    """
+    Get token usage from the Anthropic response.
+    """
     input_tokens = 0
     output_tokens = 0
     if hasattr(result, "usage"):
@@ -61,40 +72,18 @@ def _calculate_token_usage(result: Messages, span: Span) -> None:
         if hasattr(usage, "output_tokens") and isinstance(usage.output_tokens, int):
             output_tokens = usage.output_tokens
 
-    total_tokens = input_tokens + output_tokens
-
-    record_token_usage(
-        span,
-        input_tokens=input_tokens,
-        output_tokens=output_tokens,
-        total_tokens=total_tokens,
-    )
-
-
-def _get_responses(content: list[Any]) -> list[dict[str, Any]]:
-    """
-    Get JSON of a Anthropic responses.
-    """
-    responses = []
-    for item in content:
-        if hasattr(item, "text"):
-            responses.append(
-                {
-                    "type": item.type,
-                    "text": item.text,
-                }
-            )
-    return responses
+    return input_tokens, output_tokens
 
 
 def _collect_ai_data(
     event: MessageStreamEvent,
+    model: str | None,
     input_tokens: int,
     output_tokens: int,
     content_blocks: list[str],
-) -> tuple[int, int, list[str]]:
+) -> tuple[str | None, int, int, list[str]]:
     """
-    Count token usage and collect content blocks from the AI streaming response.
+    Collect model information, token usage, and collect content blocks from the AI streaming response.
     """
     with capture_internal_exceptions():
         if hasattr(event, "type"):
@@ -102,6 +91,7 @@ def _collect_ai_data(
                 usage = event.message.usage
                 input_tokens += usage.input_tokens
                 output_tokens += usage.output_tokens
+                model = event.message.model or model
             elif event.type == "content_block_start":
                 pass
             elif event.type == "content_block_delta":
@@ -114,34 +104,80 @@ def _collect_ai_data(
             elif event.type == "message_delta":
                 output_tokens += event.usage.output_tokens
 
-    return input_tokens, output_tokens, content_blocks
+    return model, input_tokens, output_tokens, content_blocks
 
 
-def _add_ai_data_to_span(
+def _set_input_data(
+    span: Span, kwargs: dict[str, Any], integration: AnthropicIntegration
+) -> None:
+    """
+    Set input data for the span based on the provided keyword arguments for the anthropic message creation.
+    """
+    messages = kwargs.get("messages")
+    if (
+        messages is not None
+        and len(messages) > 0
+        and should_send_default_pii()
+        and integration.include_prompts
+    ):
+        set_data_normalized(
+            span, SPANDATA.GEN_AI_REQUEST_MESSAGES, safe_serialize(messages)
+        )
+
+    set_data_normalized(
+        span, SPANDATA.GEN_AI_RESPONSE_STREAMING, kwargs.get("stream", False)
+    )
+
+    kwargs_keys_to_attributes = {
+        "max_tokens": SPANDATA.GEN_AI_REQUEST_MAX_TOKENS,
+        "model": SPANDATA.GEN_AI_REQUEST_MODEL,
+        "temperature": SPANDATA.GEN_AI_REQUEST_TEMPERATURE,
+        "top_k": SPANDATA.GEN_AI_REQUEST_TOP_K,
+        "top_p": SPANDATA.GEN_AI_REQUEST_TOP_P,
+    }
+    for key, attribute in kwargs_keys_to_attributes.items():
+        value = kwargs.get(key)
+        if value is not NOT_GIVEN and value is not None:
+            set_data_normalized(span, attribute, value)
+
+    # Input attributes: Tools
+    tools = kwargs.get("tools")
+    if tools is not NOT_GIVEN and tools is not None and len(tools) > 0:
+        set_data_normalized(
+            span, SPANDATA.GEN_AI_REQUEST_AVAILABLE_TOOLS, safe_serialize(tools)
+        )
+
+
+def _set_output_data(
     span: Span,
     integration: AnthropicIntegration,
+    model: str | None,
     input_tokens: int,
     output_tokens: int,
-    content_blocks: list[str],
+    content_blocks: list[Any],
+    finish_span: bool = False,
 ) -> None:
     """
-    Add token usage and content blocks from the AI streaming response to the span.
-    """
-    with capture_internal_exceptions():
-        if should_send_default_pii() and integration.include_prompts:
-            complete_message = "".join(content_blocks)
-            span.set_attribute(
-                SPANDATA.AI_RESPONSES,
-                [{"type": "text", "text": complete_message}],
-            )
-        total_tokens = input_tokens + output_tokens
-        record_token_usage(
+    Set output data for the span based on the AI response."""
+    span.set_attribute(SPANDATA.GEN_AI_RESPONSE_MODEL, model)
+    if should_send_default_pii() and integration.include_prompts:
+        set_data_normalized(
             span,
-            input_tokens=input_tokens,
-            output_tokens=output_tokens,
-            total_tokens=total_tokens,
+            SPANDATA.GEN_AI_RESPONSE_TEXT,
+            json.dumps(content_blocks),
+            unpack=False,
         )
-        span.set_attribute(SPANDATA.AI_STREAMING, True)
+
+    record_token_usage(
+        span,
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+    )
+
+    # TODO: GEN_AI_RESPONSE_TOOL_CALLS ?
+
+    if finish_span:
+        span.__exit__(None, None, None)
 
 
 def _sentry_patched_create_common(f: Any, *args: Any, **kwargs: Any) -> Any:
@@ -157,70 +193,94 @@ def _sentry_patched_create_common(f: Any, *args: Any, **kwargs: Any) -> Any:
     except TypeError:
         return f(*args, **kwargs)
 
+    model = kwargs.get("model", "")
+
     span = sentry_sdk.start_span(
-        op=OP.ANTHROPIC_MESSAGES_CREATE,
-        description="Anthropic messages create",
+        op=OP.GEN_AI_CHAT,
+        name=f"chat {model}".strip(),
         origin=AnthropicIntegration.origin,
         only_as_child_span=True,
     )
     span.__enter__()
 
-    result = yield f, args, kwargs
+    _set_input_data(span, kwargs, integration)
 
-    # add data to span and finish it
-    messages = list(kwargs["messages"])
-    model = kwargs.get("model")
+    result = yield f, args, kwargs
 
     with capture_internal_exceptions():
-        span.set_attribute(SPANDATA.AI_MODEL_ID, model)
-        span.set_attribute(SPANDATA.AI_STREAMING, False)
-
-        if should_send_default_pii() and integration.include_prompts:
-            span.set_attribute(SPANDATA.AI_INPUT_MESSAGES, messages)
-
         if hasattr(result, "content"):
-            if should_send_default_pii() and integration.include_prompts:
-                span.set_attribute(
-                    SPANDATA.AI_RESPONSES, _get_responses(result.content)
-                )
-            _calculate_token_usage(result, span)
-            span.__exit__(None, None, None)
+            input_tokens, output_tokens = _get_token_usage(result)
+
+            content_blocks = []
+            for content_block in result.content:
+                if hasattr(content_block, "to_dict"):
+                    content_blocks.append(content_block.to_dict())
+                elif hasattr(content_block, "model_dump"):
+                    content_blocks.append(content_block.model_dump())
+                elif hasattr(content_block, "text"):
+                    content_blocks.append({"type": "text", "text": content_block.text})
+
+            _set_output_data(
+                span=span,
+                integration=integration,
+                model=getattr(result, "model", None),
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                content_blocks=content_blocks,
+                finish_span=True,
+            )
 
         # Streaming response
         elif hasattr(result, "_iterator"):
             old_iterator = result._iterator
 
             def new_iterator() -> Iterator[MessageStreamEvent]:
+                model = None
                 input_tokens = 0
                 output_tokens = 0
                 content_blocks: list[str] = []
 
                 for event in old_iterator:
-                    input_tokens, output_tokens, content_blocks = _collect_ai_data(
-                        event, input_tokens, output_tokens, content_blocks
+                    model, input_tokens, output_tokens, content_blocks = (
+                        _collect_ai_data(
+                            event, model, input_tokens, output_tokens, content_blocks
+                        )
                     )
                     yield event
 
-                _add_ai_data_to_span(
-                    span, integration, input_tokens, output_tokens, content_blocks
+                _set_output_data(
+                    span=span,
+                    integration=integration,
+                    model=model,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    content_blocks=[{"text": "".join(content_blocks), "type": "text"}],
+                    finish_span=True,
                 )
-                span.__exit__(None, None, None)
 
             async def new_iterator_async() -> AsyncIterator[MessageStreamEvent]:
+                model = None
                 input_tokens = 0
                 output_tokens = 0
                 content_blocks: list[str] = []
 
                 async for event in old_iterator:
-                    input_tokens, output_tokens, content_blocks = _collect_ai_data(
-                        event, input_tokens, output_tokens, content_blocks
+                    model, input_tokens, output_tokens, content_blocks = (
+                        _collect_ai_data(
+                            event, model, input_tokens, output_tokens, content_blocks
+                        )
                     )
                     yield event
 
-                _add_ai_data_to_span(
-                    span, integration, input_tokens, output_tokens, content_blocks
+                _set_output_data(
+                    span=span,
+                    integration=integration,
+                    model=model,
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    content_blocks=[{"text": "".join(content_blocks), "type": "text"}],
+                    finish_span=True,
                 )
-                span.__exit__(None, None, None)
 
             if str(type(result._iterator)) == "<class 'async_generator'>":
                 result._iterator = new_iterator_async()

sentry_sdk/integrations/asgi.py

@@ -105,6 +105,7 @@ class SentryAsgiMiddleware:
         mechanism_type: str = "asgi",
         span_origin: Optional[str] = None,
         http_methods_to_capture: Tuple[str, ...] = DEFAULT_HTTP_METHODS_TO_CAPTURE,
+        asgi_version: Optional[int] = None,
     ) -> None:
         """
         Instrument an ASGI application with Sentry. Provides HTTP/websocket
@@ -142,10 +143,16 @@ class SentryAsgiMiddleware:
         self.app = app
         self.http_methods_to_capture = http_methods_to_capture
 
-        if _looks_like_asgi3(app):
+        if asgi_version is None:
+            if _looks_like_asgi3(app):
+                asgi_version = 3
+            else:
+                asgi_version = 2
+
+        if asgi_version == 3:
             self.__call__: Callable[..., Any] = self._run_asgi3
-        else:
-            self.__call__ = self._run_asgi2
+        elif asgi_version == 2:
+            self.__call__: Callable[..., Any] = self._run_asgi2  # type: ignore
 
     def _capture_lifespan_exception(self, exc: Exception) -> None:
         """Capture exceptions raise in application lifespan handlers.
@@ -299,12 +306,6 @@ class SentryAsgiMiddleware:
             event["transaction"] = name
             event["transaction_info"] = {"source": source}
 
-            logger.debug(
-                "[ASGI] Set transaction name and source in event_processor: '%s' / '%s'",
-                event["transaction"],
-                event["transaction_info"]["source"],
-            )
-
         return event
 
     # Helper functions.

sentry_sdk/integrations/asyncio.py

@@ -4,7 +4,13 @@ import sys
 import sentry_sdk
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations import Integration, DidNotEnable
-from sentry_sdk.utils import event_from_exception, logger, reraise
+from sentry_sdk.utils import (
+    event_from_exception,
+    logger,
+    reraise,
+    is_internal_task,
+)
+from sentry_sdk.transport import AsyncHttpTransport
 
 try:
     import asyncio
@@ -29,6 +35,72 @@ def get_name(coro: Any) -> str:
     )
 
 
+def patch_loop_close() -> None:
+    """Patch loop.close to flush pending events before shutdown."""
+    # Atexit shutdown hook happens after the event loop is closed.
+    # Therefore, it is necessary to patch the loop.close method to ensure
+    # that pending events are flushed before the interpreter shuts down.
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        # No running loop → cannot patch now
+        return
+
+    if getattr(loop, "_sentry_flush_patched", False):
+        return
+
+    async def _flush() -> None:
+        client = sentry_sdk.get_client()
+        if not client:
+            return
+
+        try:
+            if not isinstance(client.transport, AsyncHttpTransport):
+                return
+
+            await client.close_async()
+        except Exception:
+            logger.warning("Sentry flush failed during loop shutdown", exc_info=True)
+
+    orig_close = loop.close
+
+    def _patched_close() -> None:
+        try:
+            loop.run_until_complete(_flush())
+        finally:
+            orig_close()
+
+    loop.close = _patched_close  # type: ignore
+    loop._sentry_flush_patched = True  # type: ignore
+
+
+def _create_task_with_factory(
+    orig_task_factory: Any,
+    loop: asyncio.AbstractEventLoop,
+    coro: Coroutine[Any, Any, Any],
+    **kwargs: Any,
+) -> asyncio.Task[Any]:
+    task = None
+
+    # Trying to use user set task factory (if there is one)
+    if orig_task_factory:
+        task = orig_task_factory(loop, coro, **kwargs)
+
+    if task is None:
+        # The default task factory in `asyncio` does not have its own function
+        # but is just a couple of lines in `asyncio.base_events.create_task()`
+        # Those lines are copied here.
+
+        # WARNING:
+        # If the default behavior of the task creation in asyncio changes,
+        # this will break!
+        task = Task(coro, loop=loop, **kwargs)
+        if task._source_traceback:  # type: ignore
+            del task._source_traceback[-1]  # type: ignore
+
+    return task
+
+
 def patch_asyncio() -> None:
     orig_task_factory = None
     try:
@@ -41,6 +113,14 @@ def patch_asyncio() -> None:
             **kwargs: Any,
         ) -> asyncio.Future[Any]:
 
+            # Check if this is an internal Sentry task
+            is_internal = is_internal_task()
+
+            if is_internal:
+                return _create_task_with_factory(
+                    orig_task_factory, loop, coro, **kwargs
+                )
+
             async def _task_with_sentry_span_creation() -> Any:
                 result = None
 
@@ -58,25 +138,9 @@ def patch_asyncio() -> None:
 
                 return result
 
-            task = None
-
-            # Trying to use user set task factory (if there is one)
-            if orig_task_factory:
-                task = orig_task_factory(
-                    loop, _task_with_sentry_span_creation(), **kwargs
-                )
-
-            if task is None:
-                # The default task factory in `asyncio` does not have its own function
-                # but is just a couple of lines in `asyncio.base_events.create_task()`
-                # Those lines are copied here.
-
-                # WARNING:
-                # If the default behavior of the task creation in asyncio changes,
-                # this will break!
-                task = Task(_task_with_sentry_span_creation(), loop=loop, **kwargs)
-                if task._source_traceback:  # type: ignore
-                    del task._source_traceback[-1]  # type: ignore
+            task = _create_task_with_factory(
+                orig_task_factory, loop, _task_with_sentry_span_creation(), **kwargs
+            )
 
             # Set the task name to include the original coroutine's name
             try:
@@ -124,3 +188,4 @@ class AsyncioIntegration(Integration):
     @staticmethod
     def setup_once() -> None:
         patch_asyncio()
+        patch_loop_close()

sentry_sdk/integrations/clickhouse_driver.py

@@ -13,7 +13,8 @@ from sentry_sdk.utils import (
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import ParamSpec, Callable, Any, Dict, TypeVar
+    from collections.abc import Iterator
+    from typing import Any, ParamSpec, Callable, TypeVar
 
     P = ParamSpec("P")
     T = TypeVar("T")
@@ -40,9 +41,7 @@ class ClickhouseDriverIntegration(Integration):
         )
 
         # If the query contains parameters then the send_data function is used to send those parameters to clickhouse
-        clickhouse_driver.client.Client.send_data = _wrap_send_data(
-            clickhouse_driver.client.Client.send_data
-        )
+        _wrap_send_data()
 
         # Every query ends either with the Client's `receive_end_of_query` (no result expected)
         # or its `receive_result` (result expected)
@@ -134,36 +133,64 @@ def _wrap_end(f: Callable[P, T]) -> Callable[P, T]:
     return _inner_end
 
 
-def _wrap_send_data(f: Callable[P, T]) -> Callable[P, T]:
-    def _inner_send_data(*args: P.args, **kwargs: P.kwargs) -> T:
-        client = args[0]
-        if not isinstance(client, clickhouse_driver.client.Client):
-            return f(*args, **kwargs)
+def _wrap_send_data() -> None:
+    original_send_data = clickhouse_driver.client.Client.send_data
+
+    def _inner_send_data(
+        self: clickhouse_driver.client.Client,
+        sample_block: Any,
+        data: Any,
+        types_check: bool = False,
+        columnar: bool = False,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        span = getattr(self.connection, "_sentry_span", None)
+        if span is None:
+            return original_send_data(
+                self, sample_block, data, types_check, columnar, *args, **kwargs
+            )
 
-        connection = client.connection
-        span = getattr(connection, "_sentry_span", None)
+        db_data = _get_db_data(self.connection)
+        _set_on_span(span, db_data)
 
-        if span is not None:
-            data = _get_db_data(connection)
-            _set_on_span(span, data)
+        saved_db_data: dict[str, Any] = getattr(self.connection, "_sentry_db_data", {})
+        db_params: list[Any] = saved_db_data.get("db.params") or []
+
+        if should_send_default_pii():
+            if isinstance(data, (list, tuple)):
+                db_params.extend(data)
+
+            else:  # data is a generic iterator
+                orig_data = data
+
+                # Wrap the generator to add items to db.params as they are yielded.
+                # This allows us to send the params to Sentry without needing to allocate
+                # memory for the entire generator at once.
+                def wrapped_generator() -> "Iterator[Any]":
+                    for item in orig_data:
+                        db_params.append(item)
+                        yield item
+
+                # Replace the original iterator with the wrapped one.
+                data = wrapped_generator()
+
+        rv = original_send_data(
+            self, sample_block, data, types_check, columnar, *args, **kwargs
+        )
 
-            if should_send_default_pii():
-                saved_db_data: dict[str, Any] = getattr(
-                    connection, "_sentry_db_data", {}
-                )
-                db_params: list[Any] = saved_db_data.get("db.params") or []
-                db_params_data = args[2]
-                if isinstance(db_params_data, list):
-                    db_params.extend(db_params_data)
-                saved_db_data["db.params"] = db_params
-                span.set_attribute("db.params", _serialize_span_attribute(db_params))
+        if should_send_default_pii() and db_params:
+            # need to do this after the original function call to make sure
+            # db_params is populated correctly
+            saved_db_data["db.params"] = db_params
+            span.set_attribute("db.params", _serialize_span_attribute(db_params))
 
-        return f(*args, **kwargs)
+        return rv
 
-    return _inner_send_data
+    clickhouse_driver.client.Client.send_data = _inner_send_data
 
 
-def _get_db_data(connection: clickhouse_driver.connection.Connection) -> Dict[str, str]:
+def _get_db_data(connection: clickhouse_driver.connection.Connection) -> dict[str, str]:
     return {
         SPANDATA.DB_SYSTEM: "clickhouse",
         SPANDATA.SERVER_ADDRESS: connection.host,
@@ -173,6 +200,6 @@ def _get_db_data(connection: clickhouse_driver.connection.Connection) -> Dict[st
     }
 
 
-def _set_on_span(span: Span, data: Dict[str, Any]) -> None:
+def _set_on_span(span: Span, data: dict[str, Any]) -> None:
     for key, value in data.items():
         span.set_attribute(key, _serialize_span_attribute(value))

sentry_sdk/integrations/fastapi.py

@@ -7,10 +7,7 @@ import sentry_sdk
 from sentry_sdk.consts import SOURCE_FOR_STYLE, TransactionSource
 from sentry_sdk.integrations import DidNotEnable
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.utils import (
-    transaction_from_function,
-    logger,
-)
+from sentry_sdk.utils import transaction_from_function
 
 from typing import TYPE_CHECKING
 
@@ -67,9 +64,6 @@ def _set_transaction_name_and_source(
         source = SOURCE_FOR_STYLE[transaction_style]
 
     scope.set_transaction_name(name, source=source)
-    logger.debug(
-        "[FastAPI] Set transaction name and source on scope: %s / %s", name, source
-    )
 
 
 def patch_get_request_handler() -> None:

sentry_sdk/integrations/gnu_backtrace.py

@@ -12,13 +12,16 @@ if TYPE_CHECKING:
     from typing import Any
     from sentry_sdk._types import Event
 
-
-FUNCTION_RE = r"[^@]+?)\s+@\s+0x[0-9a-fA-F]+"
+# function is everything between index at @
+# and then we match on the @ plus the hex val
+FUNCTION_RE = r"[^@]+?"
+HEX_ADDRESS = r"\s+@\s+0x[0-9a-fA-F]+"
 
 FRAME_RE = r"""
-^(?P<index>\d+)\.\s+(?P<function>{FUNCTION_RE}\s+in\s+(?P<package>.+)$
+^(?P<index>\d+)\.\s+(?P<function>{FUNCTION_RE}){HEX_ADDRESS}(?:\s+in\s+(?P<package>.+))?$
 """.format(
     FUNCTION_RE=FUNCTION_RE,
+    HEX_ADDRESS=HEX_ADDRESS,
 )
 
 FRAME_RE = re.compile(FRAME_RE, re.MULTILINE | re.VERBOSE)