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

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)