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

sentry_sdk/integrations/rust_tracing.py

@@ -32,16 +32,14 @@ Each native extension requires its own integration.
 
 import json
 from enum import Enum, auto
-from typing import Any, Callable, Dict, Tuple, Optional
+from typing import Any, Callable, Dict, Optional
 
 import sentry_sdk
 from sentry_sdk.integrations import Integration
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.tracing import Span as SentrySpan
+from sentry_sdk.tracing import Span
 from sentry_sdk.utils import SENSITIVE_DATA_SUBSTITUTE
 
-TraceState = Optional[Tuple[Optional[SentrySpan], SentrySpan]]
-
 
 class RustTracingLevel(Enum):
     Trace = "TRACE"
@@ -171,7 +169,7 @@ class RustTracingLayer:
             else self.include_tracing_fields
         )
 
-    def on_event(self, event: str, _span_state: TraceState) -> None:
+    def on_event(self, event: str, _span_state: Optional[Span]) -> None:
         deserialized_event = json.loads(event)
         metadata = deserialized_event.get("metadata", {})
 
@@ -185,7 +183,7 @@ class RustTracingLayer:
         elif event_type == EventTypeMapping.Event:
             process_event(deserialized_event)
 
-    def on_new_span(self, attrs: str, span_id: str) -> TraceState:
+    def on_new_span(self, attrs: str, span_id: str) -> Optional[Span]:
         attrs = json.loads(attrs)
         metadata = attrs.get("metadata", {})
 
@@ -205,48 +203,35 @@ class RustTracingLayer:
         else:
             sentry_span_name = "<unknown>"
 
-        kwargs = {
-            "op": "function",
-            "name": sentry_span_name,
-            "origin": self.origin,
-        }
-
-        scope = sentry_sdk.get_current_scope()
-        parent_sentry_span = scope.span
-        if parent_sentry_span:
-            sentry_span = parent_sentry_span.start_child(**kwargs)
-        else:
-            sentry_span = scope.start_span(**kwargs)
+        span = sentry_sdk.start_span(
+            op="function",
+            name=sentry_span_name,
+            origin=self.origin,
+            only_if_parent=True,
+        )
+        span.__enter__()
 
         fields = metadata.get("fields", [])
         for field in fields:
             if self._include_tracing_fields():
-                sentry_span.set_data(field, attrs.get(field))
-            else:
-                sentry_span.set_data(field, SENSITIVE_DATA_SUBSTITUTE)
-
-        scope.span = sentry_span
-        return (parent_sentry_span, sentry_span)
-
-    def on_close(self, span_id: str, span_state: TraceState) -> None:
-        if span_state is None:
-            return
-
-        parent_sentry_span, sentry_span = span_state
-        sentry_span.finish()
-        sentry_sdk.get_current_scope().span = parent_sentry_span
-
-    def on_record(self, span_id: str, values: str, span_state: TraceState) -> None:
-        if span_state is None:
-            return
-        _parent_sentry_span, sentry_span = span_state
-
-        deserialized_values = json.loads(values)
-        for key, value in deserialized_values.items():
-            if self._include_tracing_fields():
-                sentry_span.set_data(key, value)
+                span.set_attribute(field, attrs.get(field))
             else:
-                sentry_span.set_data(key, SENSITIVE_DATA_SUBSTITUTE)
+                span.set_attribute(field, SENSITIVE_DATA_SUBSTITUTE)
+
+        return span
+
+    def on_close(self, span_id: str, span: Optional[Span]) -> None:
+        if span is not None:
+            span.__exit__(None, None, None)
+
+    def on_record(self, span_id: str, values: str, span: Optional[Span]) -> None:
+        if span is not None:
+            deserialized_values = json.loads(values)
+            for key, value in deserialized_values.items():
+                if self._include_tracing_fields():
+                    span.set_attribute(key, value)
+                else:
+                    span.set_attribute(key, SENSITIVE_DATA_SUBSTITUTE)
 
 
 class RustTracingIntegration(Integration):

sentry_sdk/integrations/sanic.py

@@ -4,7 +4,6 @@ from inspect import isawaitable
 from urllib.parse import urlsplit
 
 import sentry_sdk
-from sentry_sdk import continue_trace
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations import _check_minimum_version, Integration, DidNotEnable
 from sentry_sdk.integrations._wsgi_common import RequestExtractor, _filter_headers
@@ -182,21 +181,25 @@ async def _context_enter(request):
         return
 
     weak_request = weakref.ref(request)
-    request.ctx._sentry_scope = sentry_sdk.isolation_scope()
-    scope = request.ctx._sentry_scope.__enter__()
+    request.ctx._sentry_scope_manager = sentry_sdk.isolation_scope()
+    scope = request.ctx._sentry_scope_manager.__enter__()
+    request.ctx._sentry_scope = scope
+
+    scope.set_transaction_name(request.path, TransactionSource.URL)
     scope.clear_breadcrumbs()
     scope.add_event_processor(_make_request_processor(weak_request))
 
-    transaction = continue_trace(
-        dict(request.headers),
+    # TODO-neel-potel test if this works
+    request.ctx._sentry_continue_trace = sentry_sdk.continue_trace(
+        dict(request.headers)
+    )
+    request.ctx._sentry_continue_trace.__enter__()
+    request.ctx._sentry_transaction = sentry_sdk.start_span(
         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__()
 
 
@@ -211,16 +214,23 @@ async def _context_exit(request, response=None):
         response_status = None if response is None else response.status
 
         # 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.
+        # happens while trying to end the transaction, we still attempt to exit the scope.
         with capture_internal_exceptions():
             request.ctx._sentry_transaction.set_http_status(response_status)
-            request.ctx._sentry_transaction.sampled &= (
+
+            if (
                 isinstance(integration, SanicIntegration)
-                and response_status not in integration._unsampled_statuses
-            )
+                and response_status in integration._unsampled_statuses
+            ):
+                # drop the event in an event processor
+                request.ctx._sentry_scope.add_event_processor(
+                    lambda _event, _hint: None
+                )
+
             request.ctx._sentry_transaction.__exit__(None, None, None)
+            request.ctx._sentry_continue_trace.__exit__(None, None, None)
 
-        request.ctx._sentry_scope.__exit__(None, None, None)
+        request.ctx._sentry_scope_manager.__exit__(None, None, None)
 
 
 async def _set_transaction(request, route, **_):

sentry_sdk/integrations/socket.py

@@ -61,10 +61,13 @@ def _patch_create_connection():
             op=OP.SOCKET_CONNECTION,
             name=_get_span_description(address[0], address[1]),
             origin=SocketIntegration.origin,
+            only_if_parent=True,
         ) as span:
-            span.set_data("address", address)
-            span.set_data("timeout", timeout)
-            span.set_data("source_address", source_address)
+            host, port = address
+            span.set_attribute("address.host", host)
+            span.set_attribute("address.port", port)
+            span.set_attribute("timeout", timeout)
+            span.set_attribute("source_address", source_address)
 
             return real_create_connection(
                 address=address, timeout=timeout, source_address=source_address
@@ -87,9 +90,10 @@ def _patch_getaddrinfo():
             op=OP.SOCKET_DNS,
             name=_get_span_description(host, port),
             origin=SocketIntegration.origin,
+            only_if_parent=True,
         ) as span:
-            span.set_data("host", host)
-            span.set_data("port", port)
+            span.set_attribute("host", host)
+            span.set_attribute("port", port)
 
             return real_getaddrinfo(host, port, family, type, proto, flags)
 

sentry_sdk/integrations/sqlalchemy.py

@@ -68,15 +68,15 @@ def _after_cursor_execute(conn, cursor, statement, parameters, context, *args):
         context, "_sentry_sql_span_manager", None
     )  # type: Optional[ContextManager[Any]]
 
-    if ctx_mgr is not None:
-        context._sentry_sql_span_manager = None
-        ctx_mgr.__exit__(None, None, None)
-
     span = getattr(context, "_sentry_sql_span", None)  # type: Optional[Span]
     if span is not None:
         with capture_internal_exceptions():
             add_query_source(span)
 
+    if ctx_mgr is not None:
+        context._sentry_sql_span_manager = None
+        ctx_mgr.__exit__(None, None, None)
+
 
 def _handle_error(context, *args):
     # type: (Any, *Any) -> None
@@ -128,19 +128,19 @@ def _set_db_data(span, conn):
     # type: (Span, Any) -> None
     db_system = _get_db_system(conn.engine.name)
     if db_system is not None:
-        span.set_data(SPANDATA.DB_SYSTEM, db_system)
+        span.set_attribute(SPANDATA.DB_SYSTEM, db_system)
 
     if conn.engine.url is None:
         return
 
     db_name = conn.engine.url.database
     if db_name is not None:
-        span.set_data(SPANDATA.DB_NAME, db_name)
+        span.set_attribute(SPANDATA.DB_NAME, db_name)
 
     server_address = conn.engine.url.host
     if server_address is not None:
-        span.set_data(SPANDATA.SERVER_ADDRESS, server_address)
+        span.set_attribute(SPANDATA.SERVER_ADDRESS, server_address)
 
     server_port = conn.engine.url.port
     if server_port is not None:
-        span.set_data(SPANDATA.SERVER_PORT, server_port)
+        span.set_attribute(SPANDATA.SERVER_PORT, server_port)

sentry_sdk/integrations/starlette.py

@@ -1,12 +1,11 @@
 import asyncio
 import functools
-import warnings
 from collections.abc import Set
 from copy import deepcopy
 from json import JSONDecodeError
 
 import sentry_sdk
-from sentry_sdk.consts import OP
+from sentry_sdk.consts import OP, SOURCE_FOR_STYLE, TransactionSource
 from sentry_sdk.integrations import (
     DidNotEnable,
     Integration,
@@ -14,16 +13,11 @@ from sentry_sdk.integrations import (
 )
 from sentry_sdk.integrations._wsgi_common import (
     DEFAULT_HTTP_METHODS_TO_CAPTURE,
-    HttpCodeRangeContainer,
     _is_json_content_type,
     request_body_within_bounds,
 )
 from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.tracing import (
-    SOURCE_FOR_STYLE,
-    TransactionSource,
-)
 from sentry_sdk.utils import (
     AnnotatedValue,
     capture_internal_exceptions,
@@ -37,9 +31,9 @@ from sentry_sdk.utils import (
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any, Awaitable, Callable, Container, Dict, Optional, Tuple, Union
+    from typing import Any, Awaitable, Callable, Dict, Optional, Tuple
 
-    from sentry_sdk._types import Event, HttpStatusCodeRange
+    from sentry_sdk._types import Event
 
 try:
     import starlette  # type: ignore
@@ -89,7 +83,7 @@ class StarletteIntegration(Integration):
     def __init__(
         self,
         transaction_style="url",  # type: str
-        failed_request_status_codes=_DEFAULT_FAILED_REQUEST_STATUS_CODES,  # type: Union[Set[int], list[HttpStatusCodeRange], None]
+        failed_request_status_codes=_DEFAULT_FAILED_REQUEST_STATUS_CODES,  # type: Set[int]
         middleware_spans=True,  # type: bool
         http_methods_to_capture=DEFAULT_HTTP_METHODS_TO_CAPTURE,  # type: tuple[str, ...]
     ):
@@ -103,24 +97,7 @@ class StarletteIntegration(Integration):
         self.middleware_spans = middleware_spans
         self.http_methods_to_capture = tuple(map(str.upper, http_methods_to_capture))
 
-        if isinstance(failed_request_status_codes, Set):
-            self.failed_request_status_codes = (
-                failed_request_status_codes
-            )  # type: Container[int]
-        else:
-            warnings.warn(
-                "Passing a list or None for failed_request_status_codes is deprecated. "
-                "Please pass a set of int instead.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-
-            if failed_request_status_codes is None:
-                self.failed_request_status_codes = _DEFAULT_FAILED_REQUEST_STATUS_CODES
-            else:
-                self.failed_request_status_codes = HttpCodeRangeContainer(
-                    failed_request_status_codes
-                )
+        self.failed_request_status_codes = failed_request_status_codes
 
     @staticmethod
     def setup_once():
@@ -164,6 +141,7 @@ def _enable_span_for_middleware(middleware_class):
             op=OP.MIDDLEWARE_STARLETTE,
             name=middleware_name,
             origin=StarletteIntegration.origin,
+            only_if_parent=True,
         ) as middleware_span:
             middleware_span.set_tag("starlette.middleware_name", middleware_name)
 
@@ -174,6 +152,7 @@ def _enable_span_for_middleware(middleware_class):
                     op=OP.MIDDLEWARE_STARLETTE_RECEIVE,
                     name=getattr(receive, "__qualname__", str(receive)),
                     origin=StarletteIntegration.origin,
+                    only_if_parent=True,
                 ) as span:
                     span.set_tag("starlette.middleware_name", middleware_name)
                     return await receive(*args, **kwargs)
@@ -189,6 +168,7 @@ def _enable_span_for_middleware(middleware_class):
                     op=OP.MIDDLEWARE_STARLETTE_SEND,
                     name=getattr(send, "__qualname__", str(send)),
                     origin=StarletteIntegration.origin,
+                    only_if_parent=True,
                 ) as span:
                     span.set_tag("starlette.middleware_name", middleware_name)
                     return await send(*args, **kwargs)
@@ -329,7 +309,7 @@ def _add_user_to_sentry_scope(scope):
         user_info.setdefault("email", starlette_user.email)
 
     sentry_scope = sentry_sdk.get_isolation_scope()
-    sentry_scope.user = user_info
+    sentry_scope.set_user(user_info)
 
 
 def patch_authentication_middleware(middleware_class):
@@ -493,8 +473,8 @@ def patch_request_response():
                     return old_func(*args, **kwargs)
 
                 current_scope = sentry_sdk.get_current_scope()
-                if current_scope.transaction is not None:
-                    current_scope.transaction.update_active_thread()
+                if current_scope.root_span is not None:
+                    current_scope.root_span.update_active_thread()
 
                 sentry_scope = sentry_sdk.get_isolation_scope()
                 if sentry_scope.profile is not None:

sentry_sdk/integrations/starlite.py

@@ -1,9 +1,8 @@
 import sentry_sdk
-from sentry_sdk.consts import OP
+from sentry_sdk.consts import OP, SOURCE_FOR_STYLE, TransactionSource
 from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.tracing import SOURCE_FOR_STYLE, TransactionSource
 from sentry_sdk.utils import (
     ensure_integration_enabled,
     event_from_exception,
@@ -140,6 +139,7 @@ def enable_span_for_middleware(middleware):
             op=OP.MIDDLEWARE_STARLITE,
             name=middleware_name,
             origin=StarliteIntegration.origin,
+            only_if_parent=True,
         ) as middleware_span:
             middleware_span.set_tag("starlite.middleware_name", middleware_name)
 
@@ -152,6 +152,7 @@ def enable_span_for_middleware(middleware):
                     op=OP.MIDDLEWARE_STARLITE_RECEIVE,
                     name=getattr(receive, "__qualname__", str(receive)),
                     origin=StarliteIntegration.origin,
+                    only_if_parent=True,
                 ) as span:
                     span.set_tag("starlite.middleware_name", middleware_name)
                     return await receive(*args, **kwargs)
@@ -169,6 +170,7 @@ def enable_span_for_middleware(middleware):
                     op=OP.MIDDLEWARE_STARLITE_SEND,
                     name=getattr(send, "__qualname__", str(send)),
                     origin=StarliteIntegration.origin,
+                    only_if_parent=True,
                 ) as span:
                     span.set_tag("starlite.middleware_name", middleware_name)
                     return await send(message)

sentry_sdk/integrations/stdlib.py

@@ -13,10 +13,13 @@ from sentry_sdk.utils import (
     SENSITIVE_DATA_SUBSTITUTE,
     capture_internal_exceptions,
     ensure_integration_enabled,
+    get_current_thread_meta,
+    http_client_status_to_breadcrumb_level,
     is_sentry_url,
     logger,
     safe_repr,
     parse_url,
+    set_thread_info_from_span,
 )
 
 from typing import TYPE_CHECKING
@@ -71,7 +74,7 @@ def _install_httplib():
 
         client = sentry_sdk.get_client()
         if client.get_integration(StdlibIntegration) is None or is_sentry_url(
-            client, host
+            client, f"{host}:{port}"  # noqa: E231
         ):
             return real_putrequest(self, method, url, *args, **kwargs)
 
@@ -93,12 +96,22 @@ def _install_httplib():
             name="%s %s"
             % (method, parsed_url.url if parsed_url else SENSITIVE_DATA_SUBSTITUTE),
             origin="auto.http.stdlib.httplib",
+            only_if_parent=True,
         )
-        span.set_data(SPANDATA.HTTP_METHOD, method)
+        span.__enter__()
+
+        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)
 
         rv = real_putrequest(self, method, url, *args, **kwargs)
 
@@ -117,6 +130,7 @@ def _install_httplib():
                 self.putheader(key, value)
 
         self._sentrysdk_span = span  # type: ignore[attr-defined]
+        self._sentrysdk_span_data = data  # type: ignore[attr-defined]
 
         return rv
 
@@ -130,10 +144,22 @@ def _install_httplib():
         try:
             rv = real_getresponse(self, *args, **kwargs)
 
-            span.set_http_status(int(rv.status))
-            span.set_data("reason", rv.reason)
+            span_data = getattr(self, "_sentrysdk_span_data", {})
+            span_data[SPANDATA.HTTP_STATUS_CODE] = int(rv.status)
+            span_data["reason"] = rv.reason
+
+            status_code = int(rv.status)
+            span.set_http_status(status_code)
+            span.set_attribute("reason", rv.reason)
+
+            sentry_sdk.add_breadcrumb(
+                type="http",
+                category="httplib",
+                data=span_data,
+                level=http_client_status_to_breadcrumb_level(status_code),
+            )
         finally:
-            span.finish()
+            span.__exit__(None, None, None)
 
         return rv
 
@@ -207,6 +233,7 @@ def _install_subprocess():
             op=OP.SUBPROCESS,
             name=description,
             origin="auto.subprocess.stdlib.subprocess",
+            only_if_parent=True,
         ) as span:
             for k, v in sentry_sdk.get_current_scope().iter_trace_propagation_headers(
                 span=span
@@ -222,11 +249,29 @@ def _install_subprocess():
                 env["SUBPROCESS_" + k.upper().replace("-", "_")] = v
 
             if cwd:
-                span.set_data("subprocess.cwd", cwd)
+                span.set_attribute("subprocess.cwd", cwd)
 
             rv = old_popen_init(self, *a, **kw)
 
             span.set_tag("subprocess.pid", self.pid)
+
+            with capture_internal_exceptions():
+                thread_id, thread_name = get_current_thread_meta()
+                breadcrumb_data = {
+                    "subprocess.pid": self.pid,
+                    SPANDATA.THREAD_ID: thread_id,
+                    SPANDATA.THREAD_NAME: thread_name,
+                }
+                if cwd:
+                    breadcrumb_data["subprocess.cwd"] = cwd
+
+                sentry_sdk.add_breadcrumb(
+                    type="subprocess",
+                    category="subprocess",
+                    message=description,
+                    data=breadcrumb_data,
+                )
+
             return rv
 
     subprocess.Popen.__init__ = sentry_patched_popen_init  # type: ignore
@@ -239,6 +284,7 @@ def _install_subprocess():
         with sentry_sdk.start_span(
             op=OP.SUBPROCESS_WAIT,
             origin="auto.subprocess.stdlib.subprocess",
+            only_if_parent=True,
         ) as span:
             span.set_tag("subprocess.pid", self.pid)
             return old_popen_wait(self, *a, **kw)
@@ -253,6 +299,7 @@ def _install_subprocess():
         with sentry_sdk.start_span(
             op=OP.SUBPROCESS_COMMUNICATE,
             origin="auto.subprocess.stdlib.subprocess",
+            only_if_parent=True,
         ) as span:
             span.set_tag("subprocess.pid", self.pid)
             return old_popen_communicate(self, *a, **kw)