sentry-sdk 2.30.0__py2.py3-none-any.whl → 3.0.0a2__py2.py3-none-any.whl

sentry_sdk/integrations/aiohttp.py

@@ -3,8 +3,14 @@ import weakref
 from functools import wraps
 
 import sentry_sdk
-from sentry_sdk.api import continue_trace
-from sentry_sdk.consts import OP, SPANSTATUS, SPANDATA
+from sentry_sdk.consts import (
+    OP,
+    SPANSTATUS,
+    SPANDATA,
+    BAGGAGE_HEADER_NAME,
+    SOURCE_FOR_STYLE,
+    TransactionSource,
+)
 from sentry_sdk.integrations import (
     _DEFAULT_FAILED_REQUEST_STATUS_CODES,
     _check_minimum_version,
@@ -15,22 +21,20 @@ from sentry_sdk.integrations.logging import ignore_logger
 from sentry_sdk.sessions import track_session
 from sentry_sdk.integrations._wsgi_common import (
     _filter_headers,
+    _request_headers_to_span_attributes,
     request_body_within_bounds,
 )
-from sentry_sdk.tracing import (
-    BAGGAGE_HEADER_NAME,
-    SOURCE_FOR_STYLE,
-    TransactionSource,
-)
 from sentry_sdk.tracing_utils import should_propagate_trace
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     ensure_integration_enabled,
     event_from_exception,
+    http_client_status_to_breadcrumb_level,
     logger,
     parse_url,
     parse_version,
     reraise,
+    set_thread_info_from_span,
     transaction_from_function,
     HAS_REAL_CONTEXTVARS,
     CONTEXTVARS_ERROR_MESSAGE,
@@ -67,6 +71,13 @@ if TYPE_CHECKING:
 
 TRANSACTION_STYLE_VALUES = ("handler_name", "method_and_path_pattern")
 
+REQUEST_PROPERTY_TO_ATTRIBUTE = {
+    "query_string": "url.query",
+    "method": "http.request.method",
+    "scheme": "url.scheme",
+    "path": "url.path",
+}
+
 
 class AioHttpIntegration(Integration):
     identifier = "aiohttp"
@@ -123,51 +134,38 @@ class AioHttpIntegration(Integration):
                     scope.add_event_processor(_make_request_processor(weak_request))
 
                     headers = dict(request.headers)
-                    transaction = continue_trace(
-                        headers,
-                        op=OP.HTTP_SERVER,
-                        # If this transaction name makes it to the UI, AIOHTTP's
-                        # URL resolver did not find a route or died trying.
-                        name="generic AIOHTTP request",
-                        source=TransactionSource.ROUTE,
-                        origin=AioHttpIntegration.origin,
-                    )
-                    with sentry_sdk.start_transaction(
-                        transaction,
-                        custom_sampling_context={"aiohttp_request": request},
-                    ):
-                        try:
-                            response = await old_handle(self, request)
-                        except HTTPException as e:
-                            transaction.set_http_status(e.status_code)
-
-                            if (
-                                e.status_code
-                                in integration._failed_request_status_codes
-                            ):
-                                _capture_exception()
-
-                            raise
-                        except (asyncio.CancelledError, ConnectionResetError):
-                            transaction.set_status(SPANSTATUS.CANCELLED)
-                            raise
-                        except Exception:
-                            # This will probably map to a 500 but seems like we
-                            # have no way to tell. Do not set span status.
-                            reraise(*_capture_exception())
-
-                        try:
-                            # A valid response handler will return a valid response with a status. But, if the handler
-                            # returns an invalid response (e.g. None), the line below will raise an AttributeError.
-                            # Even though this is likely invalid, we need to handle this case to ensure we don't break
-                            # the application.
-                            response_status = response.status
-                        except AttributeError:
-                            pass
-                        else:
-                            transaction.set_http_status(response_status)
-
-                        return response
+                    with sentry_sdk.continue_trace(headers):
+                        with sentry_sdk.start_span(
+                            op=OP.HTTP_SERVER,
+                            # If this transaction name makes it to the UI, AIOHTTP's
+                            # URL resolver did not find a route or died trying.
+                            name="generic AIOHTTP request",
+                            source=TransactionSource.ROUTE,
+                            origin=AioHttpIntegration.origin,
+                            attributes=_prepopulate_attributes(request),
+                        ) as span:
+                            try:
+                                response = await old_handle(self, request)
+                            except HTTPException as e:
+                                span.set_http_status(e.status_code)
+
+                                if (
+                                    e.status_code
+                                    in integration._failed_request_status_codes
+                                ):
+                                    _capture_exception()
+
+                                raise
+                            except (asyncio.CancelledError, ConnectionResetError):
+                                span.set_status(SPANSTATUS.CANCELLED)
+                                raise
+                            except Exception:
+                                # This will probably map to a 500 but seems like we
+                                # have no way to tell. Do not set span status.
+                                reraise(*_capture_exception())
+
+                            span.set_http_status(response.status)
+                            return response
 
         Application._handle = sentry_app_handle
 
@@ -238,12 +236,21 @@ def create_trace_config():
             name="%s %s"
             % (method, parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE),
             origin=AioHttpIntegration.origin,
+            only_if_parent=True,
         )
-        span.set_data(SPANDATA.HTTP_METHOD, method)
+
+        data = {
+            SPANDATA.HTTP_METHOD: method,
+        }
+        set_thread_info_from_span(data, span)
+
         if parsed_url is not None:
-            span.set_data("url", parsed_url.url)
-            span.set_data(SPANDATA.HTTP_QUERY, parsed_url.query)
-            span.set_data(SPANDATA.HTTP_FRAGMENT, parsed_url.fragment)
+            data["url"] = parsed_url.url
+            data[SPANDATA.HTTP_QUERY] = parsed_url.query
+            data[SPANDATA.HTTP_FRAGMENT] = parsed_url.fragment
+
+        for key, value in data.items():
+            span.set_attribute(key, value)
 
         client = sentry_sdk.get_client()
 
@@ -268,15 +275,28 @@ def create_trace_config():
                     params.headers[key] = value
 
         trace_config_ctx.span = span
+        trace_config_ctx.span_data = data
 
     async def on_request_end(session, trace_config_ctx, params):
         # type: (ClientSession, SimpleNamespace, TraceRequestEndParams) -> None
         if trace_config_ctx.span is None:
             return
 
+        span_data = trace_config_ctx.span_data or {}
+        status_code = int(params.response.status)
+        span_data[SPANDATA.HTTP_STATUS_CODE] = status_code
+        span_data["reason"] = params.response.reason
+
+        sentry_sdk.add_breadcrumb(
+            type="http",
+            category="httplib",
+            data=span_data,
+            level=http_client_status_to_breadcrumb_level(status_code),
+        )
+
         span = trace_config_ctx.span
         span.set_http_status(int(params.response.status))
-        span.set_data("reason", params.response.reason)
+        span.set_attribute("reason", params.response.reason)
         span.finish()
 
     trace_config = TraceConfig()
@@ -355,3 +375,30 @@ def get_aiohttp_request_data(request):
 
     # request has no body
     return None
+
+
+def _prepopulate_attributes(request):
+    # type: (Request) -> dict[str, Any]
+    """Construct initial span attributes that can be used in traces sampler."""
+    attributes = {}
+
+    for prop, attr in REQUEST_PROPERTY_TO_ATTRIBUTE.items():
+        if getattr(request, prop, None) is not None:
+            attributes[attr] = getattr(request, prop)
+
+    if getattr(request, "host", None) is not None:
+        try:
+            host, port = request.host.split(":")
+            attributes["server.address"] = host
+            attributes["server.port"] = port
+        except ValueError:
+            attributes["server.address"] = request.host
+
+    with capture_internal_exceptions():
+        url = f"{request.scheme}://{request.host}{request.path}"  # noqa: E231
+        if request.query_string:
+            attributes["url.full"] = f"{url}?{request.query_string}"
+
+    attributes.update(_request_headers_to_span_attributes(dict(request.headers)))
+
+    return attributes

sentry_sdk/integrations/anthropic.py

@@ -121,13 +121,13 @@ def _add_ai_data_to_span(
     with capture_internal_exceptions():
         if should_send_default_pii() and integration.include_prompts:
             complete_message = "".join(content_blocks)
-            span.set_data(
+            span.set_attribute(
                 SPANDATA.AI_RESPONSES,
                 [{"type": "text", "text": complete_message}],
             )
         total_tokens = input_tokens + output_tokens
         record_token_usage(span, input_tokens, output_tokens, total_tokens)
-        span.set_data(SPANDATA.AI_STREAMING, True)
+        span.set_attribute(SPANDATA.AI_STREAMING, True)
 
 
 def _sentry_patched_create_common(f, *args, **kwargs):
@@ -148,6 +148,7 @@ def _sentry_patched_create_common(f, *args, **kwargs):
         op=OP.ANTHROPIC_MESSAGES_CREATE,
         description="Anthropic messages create",
         origin=AnthropicIntegration.origin,
+        only_if_parent=True,
     )
     span.__enter__()
 
@@ -158,15 +159,17 @@ def _sentry_patched_create_common(f, *args, **kwargs):
     model = kwargs.get("model")
 
     with capture_internal_exceptions():
-        span.set_data(SPANDATA.AI_MODEL_ID, model)
-        span.set_data(SPANDATA.AI_STREAMING, False)
+        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_data(SPANDATA.AI_INPUT_MESSAGES, messages)
+            span.set_attribute(SPANDATA.AI_INPUT_MESSAGES, messages)
 
         if hasattr(result, "content"):
             if should_send_default_pii() and integration.include_prompts:
-                span.set_data(SPANDATA.AI_RESPONSES, _get_responses(result.content))
+                span.set_attribute(
+                    SPANDATA.AI_RESPONSES, _get_responses(result.content)
+                )
             _calculate_token_usage(result, span)
             span.__exit__(None, None, None)
 
@@ -214,7 +217,7 @@ def _sentry_patched_create_common(f, *args, **kwargs):
                 result._iterator = new_iterator()
 
         else:
-            span.set_data("unknown_response", True)
+            span.set_attribute("unknown_response", True)
             span.__exit__(None, None, None)
 
     return result

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