sentry-sdk 2.27.0__py2.py3-none-any.whl → 3.0.0a1__py2.py3-none-any.whl

sentry_sdk/integrations/arq.py

@@ -5,7 +5,7 @@ from sentry_sdk.consts import OP, SPANSTATUS
 from sentry_sdk.integrations import _check_minimum_version, DidNotEnable, Integration
 from sentry_sdk.integrations.logging import ignore_logger
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.tracing import Transaction, TransactionSource
+from sentry_sdk.tracing import TransactionSource
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     ensure_integration_enabled,
@@ -37,6 +37,8 @@ if TYPE_CHECKING:
 
 ARQ_CONTROL_FLOW_EXCEPTIONS = (JobExecutionFailed, Retry, RetryJob)
 
+DEFAULT_TRANSACTION_NAME = "unknown arq task"
+
 
 class ArqIntegration(Integration):
     identifier = "arq"
@@ -76,7 +78,10 @@ def patch_enqueue_job():
             return await old_enqueue_job(self, function, *args, **kwargs)
 
         with sentry_sdk.start_span(
-            op=OP.QUEUE_SUBMIT_ARQ, name=function, origin=ArqIntegration.origin
+            op=OP.QUEUE_SUBMIT_ARQ,
+            name=function,
+            origin=ArqIntegration.origin,
+            only_if_parent=True,
         ):
             return await old_enqueue_job(self, function, *args, **kwargs)
 
@@ -96,18 +101,24 @@ def patch_run_job():
 
         with sentry_sdk.isolation_scope() as scope:
             scope._name = "arq"
+            scope.set_transaction_name(
+                DEFAULT_TRANSACTION_NAME,
+                source=TransactionSource.TASK,
+            )
             scope.clear_breadcrumbs()
 
-            transaction = Transaction(
-                name="unknown arq task",
-                status="ok",
+            with sentry_sdk.start_span(
                 op=OP.QUEUE_TASK_ARQ,
+                name=DEFAULT_TRANSACTION_NAME,
                 source=TransactionSource.TASK,
                 origin=ArqIntegration.origin,
-            )
+            ) as span:
+                return_value = await old_run_job(self, job_id, score)
+
+                if span.status is None:
+                    span.set_status(SPANSTATUS.OK)
 
-            with sentry_sdk.start_transaction(transaction):
-                return await old_run_job(self, job_id, score)
+                return return_value
 
     Worker.run_job = _sentry_run_job
 
@@ -116,12 +127,12 @@ def _capture_exception(exc_info):
     # type: (ExcInfo) -> None
     scope = sentry_sdk.get_current_scope()
 
-    if scope.transaction is not None:
+    if scope.root_span is not None:
         if exc_info[0] in ARQ_CONTROL_FLOW_EXCEPTIONS:
-            scope.transaction.set_status(SPANSTATUS.ABORTED)
+            scope.root_span.set_status(SPANSTATUS.ABORTED)
             return
 
-        scope.transaction.set_status(SPANSTATUS.INTERNAL_ERROR)
+        scope.root_span.set_status(SPANSTATUS.INTERNAL_ERROR)
 
     event, hint = event_from_exception(
         exc_info,
@@ -138,8 +149,8 @@ def _make_event_processor(ctx, *args, **kwargs):
 
         with capture_internal_exceptions():
             scope = sentry_sdk.get_current_scope()
-            if scope.transaction is not None:
-                scope.transaction.name = ctx["job_name"]
+            if scope.root_span is not None:
+                scope.root_span.name = ctx["job_name"]
                 event["transaction"] = ctx["job_name"]
 
             tags = event.setdefault("tags", {})

sentry_sdk/integrations/asgi.py

@@ -10,25 +10,22 @@ from copy import deepcopy
 from functools import partial
 
 import sentry_sdk
-from sentry_sdk.api import continue_trace
-from sentry_sdk.consts import OP
+from sentry_sdk.consts import OP, SOURCE_FOR_STYLE, TransactionSource
 
 from sentry_sdk.integrations._asgi_common import (
     _get_headers,
+    _get_query,
     _get_request_data,
     _get_url,
 )
 from sentry_sdk.integrations._wsgi_common import (
     DEFAULT_HTTP_METHODS_TO_CAPTURE,
-    nullcontext,
+    _request_headers_to_span_attributes,
 )
 from sentry_sdk.sessions import track_session
-from sentry_sdk.tracing import (
-    SOURCE_FOR_STYLE,
-    TransactionSource,
-)
 from sentry_sdk.utils import (
     ContextVar,
+    capture_internal_exceptions,
     event_from_exception,
     HAS_REAL_CONTEXTVARS,
     CONTEXTVARS_ERROR_MESSAGE,
@@ -36,7 +33,6 @@ from sentry_sdk.utils import (
     transaction_from_function,
     _get_installed_modules,
 )
-from sentry_sdk.tracing import Transaction
 
 from typing import TYPE_CHECKING
 
@@ -56,6 +52,14 @@ _DEFAULT_TRANSACTION_NAME = "generic ASGI request"
 
 TRANSACTION_STYLE_VALUES = ("endpoint", "url")
 
+ASGI_SCOPE_PROPERTY_TO_ATTRIBUTE = {
+    "http_version": "network.protocol.version",
+    "method": "http.request.method",
+    "path": "url.path",
+    "scheme": "url.scheme",
+    "type": "network.protocol.name",
+}
+
 
 def _capture_exception(exc, mechanism_type="asgi"):
     # type: (Any, str) -> None
@@ -100,7 +104,7 @@ class SentryAsgiMiddleware:
         unsafe_context_data=False,  # type: bool
         transaction_style="endpoint",  # type: str
         mechanism_type="asgi",  # type: str
-        span_origin="manual",  # type: str
+        span_origin=None,  # type: Optional[str]
         http_methods_to_capture=DEFAULT_HTTP_METHODS_TO_CAPTURE,  # type: Tuple[str, ...]
     ):
         # type: (...) -> None
@@ -157,24 +161,40 @@ class SentryAsgiMiddleware:
         # type: (Any, Any, Any) -> Any
         return await self._run_app(scope, receive, send, asgi_version=3)
 
+    async def _run_original_app(self, scope, receive, send, asgi_version):
+        # type: (Any, Any, Any, Any, int) -> Any
+        try:
+            if asgi_version == 2:
+                return await self.app(scope)(receive, send)
+            else:
+                return await self.app(scope, receive, send)
+
+        except Exception as exc:
+            _capture_exception(exc, mechanism_type=self.mechanism_type)
+            raise exc from None
+
     async def _run_app(self, scope, receive, send, asgi_version):
         # type: (Any, Any, Any, Any, int) -> Any
         is_recursive_asgi_middleware = _asgi_middleware_applied.get(False)
         is_lifespan = scope["type"] == "lifespan"
         if is_recursive_asgi_middleware or is_lifespan:
-            try:
-                if asgi_version == 2:
-                    return await self.app(scope)(receive, send)
-                else:
-                    return await self.app(scope, receive, send)
-
-            except Exception as exc:
-                _capture_exception(exc, mechanism_type=self.mechanism_type)
-                raise exc from None
+            return await self._run_original_app(scope, receive, send, asgi_version)
 
         _asgi_middleware_applied.set(True)
         try:
             with sentry_sdk.isolation_scope() as sentry_scope:
+                (
+                    transaction_name,
+                    transaction_source,
+                ) = self._get_transaction_name_and_source(
+                    self.transaction_style,
+                    scope,
+                )
+                sentry_scope.set_transaction_name(
+                    transaction_name,
+                    source=transaction_source,
+                )
+
                 with track_session(sentry_scope, session_mode="request"):
                     sentry_scope.clear_breadcrumbs()
                     sentry_scope._name = "asgi"
@@ -182,82 +202,47 @@ class SentryAsgiMiddleware:
                     sentry_scope.add_event_processor(processor)
 
                     ty = scope["type"]
-                    (
-                        transaction_name,
-                        transaction_source,
-                    ) = self._get_transaction_name_and_source(
-                        self.transaction_style,
-                        scope,
-                    )
 
                     method = scope.get("method", "").upper()
-                    transaction = None
-                    if ty in ("http", "websocket"):
-                        if ty == "websocket" or method in self.http_methods_to_capture:
-                            transaction = continue_trace(
-                                _get_headers(scope),
-                                op="{}.server".format(ty),
-                                name=transaction_name,
-                                source=transaction_source,
-                                origin=self.span_origin,
-                            )
-                            logger.debug(
-                                "[ASGI] Created transaction (continuing trace): %s",
-                                transaction,
-                            )
-                    else:
-                        transaction = Transaction(
-                            op=OP.HTTP_SERVER,
+                    should_trace = ty == "websocket" or (
+                        ty == "http" and method in self.http_methods_to_capture
+                    )
+                    if not should_trace:
+                        return await self._run_original_app(
+                            scope, receive, send, asgi_version
+                        )
+
+                    with sentry_sdk.continue_trace(_get_headers(scope)):
+                        with sentry_sdk.start_span(
+                            op=(
+                                OP.WEBSOCKET_SERVER
+                                if ty == "websocket"
+                                else OP.HTTP_SERVER
+                            ),
                             name=transaction_name,
                             source=transaction_source,
                             origin=self.span_origin,
-                        )
-                        logger.debug(
-                            "[ASGI] Created transaction (new): %s", transaction
-                        )
-
-                    if transaction:
-                        transaction.set_tag("asgi.type", ty)
-                        logger.debug(
-                            "[ASGI] Set transaction name and source on transaction: '%s' / '%s'",
-                            transaction.name,
-                            transaction.source,
-                        )
-
-                    with (
-                        sentry_sdk.start_transaction(
-                            transaction,
-                            custom_sampling_context={"asgi_scope": scope},
-                        )
-                        if transaction is not None
-                        else nullcontext()
-                    ):
-                        logger.debug("[ASGI] Started transaction: %s", transaction)
-                        try:
+                            attributes=_prepopulate_attributes(scope),
+                        ) as span:
+                            if span is not None:
+                                logger.debug("[ASGI] Started transaction: %s", span)
+                                span.set_tag("asgi.type", ty)
 
                             async def _sentry_wrapped_send(event):
                                 # type: (Dict[str, Any]) -> Any
-                                if transaction is not None:
-                                    is_http_response = (
-                                        event.get("type") == "http.response.start"
-                                        and "status" in event
-                                    )
-                                    if is_http_response:
-                                        transaction.set_http_status(event["status"])
+                                is_http_response = (
+                                    event.get("type") == "http.response.start"
+                                    and span is not None
+                                    and "status" in event
+                                )
+                                if is_http_response:
+                                    span.set_http_status(event["status"])
 
                                 return await send(event)
 
-                            if asgi_version == 2:
-                                return await self.app(scope)(
-                                    receive, _sentry_wrapped_send
-                                )
-                            else:
-                                return await self.app(
-                                    scope, receive, _sentry_wrapped_send
-                                )
-                        except Exception as exc:
-                            _capture_exception(exc, mechanism_type=self.mechanism_type)
-                            raise exc from None
+                            return await self._run_original_app(
+                                scope, receive, _sentry_wrapped_send, asgi_version
+                            )
         finally:
             _asgi_middleware_applied.set(False)
 
@@ -336,3 +321,37 @@ class SentryAsgiMiddleware:
             return name, source
 
         return name, source
+
+
+def _prepopulate_attributes(scope):
+    # type: (Any) -> dict[str, Any]
+    """Unpack ASGI scope into serializable OTel attributes."""
+    scope = scope or {}
+
+    attributes = {}
+    for attr, key in ASGI_SCOPE_PROPERTY_TO_ATTRIBUTE.items():
+        if scope.get(attr):
+            attributes[key] = scope[attr]
+
+    for attr in ("client", "server"):
+        if scope.get(attr):
+            try:
+                host, port = scope[attr]
+                attributes[f"{attr}.address"] = host
+                if port is not None:
+                    attributes[f"{attr}.port"] = port
+            except Exception:
+                pass
+
+    with capture_internal_exceptions():
+        full_url = _get_url(scope)
+        query = _get_query(scope)
+        if query:
+            attributes["url.query"] = query
+            full_url = f"{full_url}?{query}"
+
+        attributes["url.full"] = full_url
+
+    attributes.update(_request_headers_to_span_attributes(_get_headers(scope)))
+
+    return attributes

sentry_sdk/integrations/asyncio.py

@@ -48,6 +48,7 @@ def patch_asyncio():
                         op=OP.FUNCTION,
                         name=get_name(coro),
                         origin=AsyncioIntegration.origin,
+                        only_if_parent=True,
                     ):
                         try:
                             result = await coro

sentry_sdk/integrations/asyncpg.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 import contextlib
-from typing import Any, TypeVar, Callable, Awaitable, Iterator
+from typing import Any, TypeVar, Callable, Awaitable, Iterator, Optional
 
 import sentry_sdk
 from sentry_sdk.consts import OP, SPANDATA
@@ -8,6 +8,7 @@ from sentry_sdk.integrations import _check_minimum_version, Integration, DidNotE
 from sentry_sdk.tracing import Span
 from sentry_sdk.tracing_utils import add_query_source, record_sql_queries
 from sentry_sdk.utils import (
+    _serialize_span_attribute,
     ensure_integration_enabled,
     parse_version,
     capture_internal_exceptions,
@@ -38,7 +39,6 @@ class AsyncPGIntegration(Integration):
         asyncpg.Connection.execute = _wrap_execute(
             asyncpg.Connection.execute,
         )
-
         asyncpg.Connection._execute = _wrap_connection_method(
             asyncpg.Connection._execute
         )
@@ -78,8 +78,8 @@ def _wrap_execute(f: Callable[..., Awaitable[T]]) -> Callable[..., Awaitable[T]]
         ) as span:
             res = await f(*args, **kwargs)
 
-        with capture_internal_exceptions():
-            add_query_source(span)
+            with capture_internal_exceptions():
+                add_query_source(span)
 
         return res
 
@@ -121,10 +121,13 @@ def _wrap_connection_method(
     async def _inner(*args: Any, **kwargs: Any) -> T:
         if sentry_sdk.get_client().get_integration(AsyncPGIntegration) is None:
             return await f(*args, **kwargs)
+
         query = args[1]
         params_list = args[2] if len(args) > 2 else None
+
         with _record(None, query, params_list, executemany=executemany) as span:
-            _set_db_data(span, args[0])
+            data = _get_db_data(conn=args[0])
+            _set_on_span(span, data)
             res = await f(*args, **kwargs)
 
         return res
@@ -144,9 +147,10 @@ def _wrap_cursor_creation(f: Callable[..., T]) -> Callable[..., T]:
             params_list,
             executemany=False,
         ) as span:
-            _set_db_data(span, args[0])
+            data = _get_db_data(conn=args[0])
+            _set_on_span(span, data)
             res = f(*args, **kwargs)
-            span.set_data("db.cursor", res)
+            span.set_attribute("db.cursor", _serialize_span_attribute(res))
 
         return res
 
@@ -158,29 +162,24 @@ def _wrap_connect_addr(f: Callable[..., Awaitable[T]]) -> Callable[..., Awaitabl
         if sentry_sdk.get_client().get_integration(AsyncPGIntegration) is None:
             return await f(*args, **kwargs)
 
-        user = kwargs["params"].user
-        database = kwargs["params"].database
-
         with sentry_sdk.start_span(
             op=OP.DB,
             name="connect",
             origin=AsyncPGIntegration.origin,
+            only_if_parent=True,
         ) as span:
-            span.set_data(SPANDATA.DB_SYSTEM, "postgresql")
-            addr = kwargs.get("addr")
-            if addr:
-                try:
-                    span.set_data(SPANDATA.SERVER_ADDRESS, addr[0])
-                    span.set_data(SPANDATA.SERVER_PORT, addr[1])
-                except IndexError:
-                    pass
-            span.set_data(SPANDATA.DB_NAME, database)
-            span.set_data(SPANDATA.DB_USER, user)
+            data = _get_db_data(
+                addr=kwargs.get("addr"),
+                database=kwargs["params"].database,
+                user=kwargs["params"].user,
+            )
+            _set_on_span(span, data)
 
             with capture_internal_exceptions():
                 sentry_sdk.add_breadcrumb(
-                    message="connect", category="query", data=span._data
+                    message="connect", category="query", data=data
                 )
+
             res = await f(*args, **kwargs)
 
         return res
@@ -188,21 +187,37 @@ def _wrap_connect_addr(f: Callable[..., Awaitable[T]]) -> Callable[..., Awaitabl
     return _inner
 
 
-def _set_db_data(span: Span, conn: Any) -> None:
-    span.set_data(SPANDATA.DB_SYSTEM, "postgresql")
+def _get_db_data(
+    conn: Any = None,
+    addr: Optional[tuple[str, ...]] = None,
+    database: Optional[str] = None,
+    user: Optional[str] = None,
+) -> dict[str, str]:
+    if conn is not None:
+        addr = conn._addr
+        database = conn._params.database
+        user = conn._params.user
+
+    data = {
+        SPANDATA.DB_SYSTEM: "postgresql",
+    }
 
-    addr = conn._addr
     if addr:
         try:
-            span.set_data(SPANDATA.SERVER_ADDRESS, addr[0])
-            span.set_data(SPANDATA.SERVER_PORT, addr[1])
+            data[SPANDATA.SERVER_ADDRESS] = addr[0]
+            data[SPANDATA.SERVER_PORT] = addr[1]
         except IndexError:
             pass
 
-    database = conn._params.database
     if database:
-        span.set_data(SPANDATA.DB_NAME, database)
+        data[SPANDATA.DB_NAME] = database
 
-    user = conn._params.user
     if user:
-        span.set_data(SPANDATA.DB_USER, user)
+        data[SPANDATA.DB_USER] = user
+
+    return data
+
+
+def _set_on_span(span: Span, data: dict[str, Any]) -> None:
+    for key, value in data.items():
+        span.set_attribute(key, value)