sentry-sdk 2.34.1__py2.py3-none-any.whl → 2.35.1__py2.py3-none-any.whl

sentry_sdk/integrations/litestar.py

@@ -85,6 +85,7 @@ class SentryLitestarASGIMiddleware(SentryAsgiMiddleware):
             transaction_style="endpoint",
             mechanism_type="asgi",
             span_origin=span_origin,
+            asgi_version=3,
         )
 
     def _capture_request_exception(self, exc):
@@ -116,7 +117,6 @@ def patch_app_init():
             *(kwargs.get("after_exception") or []),
         ]
 
-        SentryLitestarASGIMiddleware.__call__ = SentryLitestarASGIMiddleware._run_asgi3  # type: ignore
         middleware = kwargs.get("middleware") or []
         kwargs["middleware"] = [SentryLitestarASGIMiddleware, *middleware]
         old__init__(self, *args, **kwargs)

sentry_sdk/integrations/logging.py

@@ -12,6 +12,7 @@ from sentry_sdk.utils import (
     event_from_exception,
     current_stacktrace,
     capture_internal_exceptions,
+    has_logs_enabled,
 )
 from sentry_sdk.integrations import Integration
 
@@ -344,7 +345,7 @@ class SentryLogsHandler(_BaseHandler):
             if not client.is_active():
                 return
 
-            if not client.options["_experiments"].get("enable_logs", False):
+            if not has_logs_enabled(client.options):
                 return
 
             self._capture_log_from_record(client, record)

sentry_sdk/integrations/loguru.py

@@ -8,6 +8,7 @@ from sentry_sdk.integrations.logging import (
     _BaseHandler,
 )
 from sentry_sdk.logger import _log_level_to_otel
+from sentry_sdk.utils import has_logs_enabled
 
 from typing import TYPE_CHECKING
 
@@ -151,7 +152,7 @@ def loguru_sentry_logs_handler(message):
     if not client.is_active():
         return
 
-    if not client.options["_experiments"].get("enable_logs", False):
+    if not has_logs_enabled(client.options):
         return
 
     record = message.record

sentry_sdk/integrations/openai.py

@@ -20,6 +20,11 @@ if TYPE_CHECKING:
     from sentry_sdk.tracing import Span
 
 try:
+    try:
+        from openai import NOT_GIVEN
+    except ImportError:
+        NOT_GIVEN = None
+
     from openai.resources.chat.completions import Completions, AsyncCompletions
     from openai.resources import Embeddings, AsyncEmbeddings
 
@@ -192,12 +197,13 @@ def _set_input_data(span, kwargs, operation, integration):
     }
     for key, attribute in kwargs_keys_to_attributes.items():
         value = kwargs.get(key)
-        if value is not None:
+
+        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 None and len(tools) > 0:
+    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)
         )

sentry_sdk/integrations/openai_agents/patches/agent_run.py

@@ -1,7 +1,6 @@
 from functools import wraps
 
 from sentry_sdk.integrations import DidNotEnable
-
 from ..spans import invoke_agent_span, update_invoke_agent_span, handoff_span
 
 from typing import TYPE_CHECKING
@@ -9,7 +8,6 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from typing import Any, Optional
 
-
 try:
     import agents
 except ImportError:
@@ -62,7 +60,6 @@ def _patch_agent_run():
     async def patched_run_single_turn(cls, *args, **kwargs):
         # type: (agents.Runner, *Any, **Any) -> Any
         """Patched _run_single_turn that creates agent invocation spans"""
-
         agent = kwargs.get("agent")
         context_wrapper = kwargs.get("context_wrapper")
         should_run_agent_start_hooks = kwargs.get("should_run_agent_start_hooks")

sentry_sdk/integrations/openai_agents/patches/runner.py

@@ -23,20 +23,23 @@ def _create_run_wrapper(original_func):
     @wraps(original_func)
     async def wrapper(*args, **kwargs):
         # type: (*Any, **Any) -> Any
-        agent = args[0]
-        with agent_workflow_span(agent):
-            result = None
-            try:
-                result = await original_func(*args, **kwargs)
-                return result
-            except Exception as exc:
-                _capture_exception(exc)
-
-                # It could be that there is a "invoke agent" span still open
-                current_span = sentry_sdk.get_current_span()
-                if current_span is not None and current_span.timestamp is None:
-                    current_span.__exit__(None, None, None)
-
-                raise exc from None
+        # Isolate each workflow so that when agents are run in asyncio tasks they
+        # don't touch each other's scopes
+        with sentry_sdk.isolation_scope():
+            agent = args[0]
+            with agent_workflow_span(agent):
+                result = None
+                try:
+                    result = await original_func(*args, **kwargs)
+                    return result
+                except Exception as exc:
+                    _capture_exception(exc)
+
+                    # It could be that there is a "invoke agent" span still open
+                    current_span = sentry_sdk.get_current_span()
+                    if current_span is not None and current_span.timestamp is None:
+                        current_span.__exit__(None, None, None)
+
+                    raise exc from None
 
     return wrapper

sentry_sdk/integrations/openfeature.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from sentry_sdk.feature_flags import add_feature_flag
 from sentry_sdk.integrations import DidNotEnable, Integration
@@ -8,7 +8,6 @@ try:
     from openfeature.hook import Hook
 
     if TYPE_CHECKING:
-        from openfeature.flag_evaluation import FlagEvaluationDetails
         from openfeature.hook import HookContext, HookHints
 except ImportError:
     raise DidNotEnable("OpenFeature is not installed")
@@ -25,9 +24,8 @@ class OpenFeatureIntegration(Integration):
 
 
 class OpenFeatureHook(Hook):
-
     def after(self, hook_context, details, hints):
-        # type: (HookContext, FlagEvaluationDetails[bool], HookHints) -> None
+        # type: (Any, Any, Any) -> None
         if isinstance(details.value, bool):
             add_feature_flag(details.flag_key, details.value)
 

sentry_sdk/integrations/quart.py

@@ -95,8 +95,8 @@ def patch_asgi_app():
         middleware = SentryAsgiMiddleware(
             lambda *a, **kw: old_app(self, *a, **kw),
             span_origin=QuartIntegration.origin,
+            asgi_version=3,
         )
-        middleware.__call__ = middleware._run_asgi3
         return await middleware(scope, receive, send)
 
     Quart.__call__ = sentry_patched_asgi_app

sentry_sdk/integrations/starlette.py

@@ -29,7 +29,6 @@ from sentry_sdk.utils import (
     capture_internal_exceptions,
     ensure_integration_enabled,
     event_from_exception,
-    logger,
     parse_version,
     transaction_from_function,
 )
@@ -403,9 +402,9 @@ def patch_asgi_app():
                 if integration
                 else DEFAULT_HTTP_METHODS_TO_CAPTURE
             ),
+            asgi_version=3,
         )
 
-        middleware.__call__ = middleware._run_asgi3
         return await middleware(scope, receive, send)
 
     Starlette.__call__ = _sentry_patched_asgi_app
@@ -723,9 +722,6 @@ def _set_transaction_name_and_source(scope, transaction_style, request):
         source = TransactionSource.ROUTE
 
     scope.set_transaction_name(name, source=source)
-    logger.debug(
-        "[Starlette] Set transaction name and source on scope: %s / %s", name, source
-    )
 
 
 def _get_transaction_from_middleware(app, asgi_scope, integration):

sentry_sdk/integrations/starlite.py

@@ -65,6 +65,7 @@ class SentryStarliteASGIMiddleware(SentryAsgiMiddleware):
             transaction_style="endpoint",
             mechanism_type="asgi",
             span_origin=span_origin,
+            asgi_version=3,
         )
 
 
@@ -94,7 +95,6 @@ def patch_app_init():
             ]
         )
 
-        SentryStarliteASGIMiddleware.__call__ = SentryStarliteASGIMiddleware._run_asgi3  # type: ignore
         middleware = kwargs.get("middleware") or []
         kwargs["middleware"] = [SentryStarliteASGIMiddleware, *middleware]
         old__init__(self, *args, **kwargs)

sentry_sdk/scope.py

@@ -48,7 +48,7 @@ import typing
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping, MutableMapping
+    from collections.abc import Mapping
 
     from typing import Any
     from typing import Callable
@@ -238,24 +238,24 @@ class Scope:
         rv._name = self._name
         rv._fingerprint = self._fingerprint
         rv._transaction = self._transaction
-        rv._transaction_info = dict(self._transaction_info)
+        rv._transaction_info = self._transaction_info.copy()
         rv._user = self._user
 
-        rv._tags = dict(self._tags)
-        rv._contexts = dict(self._contexts)
-        rv._extras = dict(self._extras)
+        rv._tags = self._tags.copy()
+        rv._contexts = self._contexts.copy()
+        rv._extras = self._extras.copy()
 
         rv._breadcrumbs = copy(self._breadcrumbs)
-        rv._n_breadcrumbs_truncated = copy(self._n_breadcrumbs_truncated)
-        rv._event_processors = list(self._event_processors)
-        rv._error_processors = list(self._error_processors)
+        rv._n_breadcrumbs_truncated = self._n_breadcrumbs_truncated
+        rv._event_processors = self._event_processors.copy()
+        rv._error_processors = self._error_processors.copy()
         rv._propagation_context = self._propagation_context
 
         rv._should_capture = self._should_capture
         rv._span = self._span
         rv._session = self._session
         rv._force_auto_session_tracking = self._force_auto_session_tracking
-        rv._attachments = list(self._attachments)
+        rv._attachments = self._attachments.copy()
 
         rv._profile = self._profile
 
@@ -683,12 +683,12 @@ class Scope:
         self._level = None  # type: Optional[LogLevelStr]
         self._fingerprint = None  # type: Optional[List[str]]
         self._transaction = None  # type: Optional[str]
-        self._transaction_info = {}  # type: MutableMapping[str, str]
+        self._transaction_info = {}  # type: dict[str, str]
         self._user = None  # type: Optional[Dict[str, Any]]
 
         self._tags = {}  # type: Dict[str, Any]
         self._contexts = {}  # type: Dict[str, Dict[str, Any]]
-        self._extras = {}  # type: MutableMapping[str, Any]
+        self._extras = {}  # type: dict[str, Any]
         self._attachments = []  # type: List[Attachment]
 
         self.clear_breadcrumbs()

sentry_sdk/tracing.py

@@ -5,7 +5,7 @@ from datetime import datetime, timedelta, timezone
 from enum import Enum
 
 import sentry_sdk
-from sentry_sdk.consts import INSTRUMENTER, SPANSTATUS, SPANDATA
+from sentry_sdk.consts import INSTRUMENTER, SPANSTATUS, SPANDATA, SPANTEMPLATE
 from sentry_sdk.profiler.continuous_profiler import get_profiler_id
 from sentry_sdk.utils import (
     get_current_thread_meta,
@@ -257,8 +257,8 @@ class Span:
     """
 
     __slots__ = (
-        "trace_id",
-        "span_id",
+        "_trace_id",
+        "_span_id",
         "parent_span_id",
         "same_process_as_parent",
         "sampled",
@@ -301,8 +301,8 @@ class Span:
         name=None,  # type: Optional[str]
     ):
         # type: (...) -> None
-        self.trace_id = trace_id or uuid.uuid4().hex
-        self.span_id = span_id or uuid.uuid4().hex[16:]
+        self._trace_id = trace_id
+        self._span_id = span_id
         self.parent_span_id = parent_span_id
         self.same_process_as_parent = same_process_as_parent
         self.sampled = sampled
@@ -356,6 +356,32 @@ class Span:
         if self._span_recorder is None:
             self._span_recorder = _SpanRecorder(maxlen)
 
+    @property
+    def trace_id(self):
+        # type: () -> str
+        if not self._trace_id:
+            self._trace_id = uuid.uuid4().hex
+
+        return self._trace_id
+
+    @trace_id.setter
+    def trace_id(self, value):
+        # type: (str) -> None
+        self._trace_id = value
+
+    @property
+    def span_id(self):
+        # type: () -> str
+        if not self._span_id:
+            self._span_id = uuid.uuid4().hex[16:]
+
+        return self._span_id
+
+    @span_id.setter
+    def span_id(self, value):
+        # type: (str) -> None
+        self._span_id = value
+
     def _get_local_aggregator(self):
         # type: (...) -> LocalAggregator
         rv = self._local_aggregator
@@ -602,6 +628,10 @@ class Span:
         # type: (str, Any) -> None
         self._data[key] = value
 
+    def update_data(self, data):
+        # type: (Dict[str, Any]) -> None
+        self._data.update(data)
+
     def set_flag(self, flag, result):
         # type: (str, bool) -> None
         if len(self._flags) < self._flags_capacity:
@@ -818,7 +848,6 @@ class Transaction(Span):
         **kwargs,  # type: Unpack[SpanKwargs]
     ):
         # type: (...) -> None
-
         super().__init__(**kwargs)
 
         self.name = name
@@ -1275,6 +1304,10 @@ class NoOpSpan(Span):
         # type: (str, Any) -> None
         pass
 
+    def update_data(self, data):
+        # type: (Dict[str, Any]) -> None
+        pass
+
     def set_status(self, value):
         # type: (str) -> None
         pass
@@ -1332,43 +1365,103 @@ class NoOpSpan(Span):
 if TYPE_CHECKING:
 
     @overload
-    def trace(func=None):
-        # type: (None) -> Callable[[Callable[P, R]], Callable[P, R]]
+    def trace(
+        func=None, *, op=None, name=None, attributes=None, template=SPANTEMPLATE.DEFAULT
+    ):
+        # type: (None, Optional[str], Optional[str], Optional[dict[str, Any]], SPANTEMPLATE) -> Callable[[Callable[P, R]], Callable[P, R]]
+        # Handles: @trace() and @trace(op="custom")
         pass
 
     @overload
     def trace(func):
         # type: (Callable[P, R]) -> Callable[P, R]
+        # Handles: @trace
         pass
 
 
-def trace(func=None):
-    # type: (Optional[Callable[P, R]]) -> Union[Callable[P, R], Callable[[Callable[P, R]], Callable[P, R]]]
+def trace(
+    func=None, *, op=None, name=None, attributes=None, template=SPANTEMPLATE.DEFAULT
+):
+    # type: (Optional[Callable[P, R]], Optional[str], Optional[str], Optional[dict[str, Any]], SPANTEMPLATE) -> Union[Callable[P, R], Callable[[Callable[P, R]], Callable[P, R]]]
     """
-    Decorator to start a child span under the existing current transaction.
-    If there is no current transaction, then nothing will be traced.
-
-    .. code-block::
-        :caption: Usage
+    Decorator to start a child span around a function call.
+
+    This decorator automatically creates a new span when the decorated function
+    is called, and finishes the span when the function returns or raises an exception.
+
+    :param func: The function to trace. When used as a decorator without parentheses,
+        this is the function being decorated. When used with parameters (e.g.,
+        ``@trace(op="custom")``, this should be None.
+    :type func: Callable or None
+
+    :param op: The operation name for the span. This is a high-level description
+        of what the span represents (e.g., "http.client", "db.query").
+        You can use predefined constants from :py:class:`sentry_sdk.consts.OP`
+        or provide your own string. If not provided, a default operation will
+        be assigned based on the template.
+    :type op: str or None
+
+    :param name: The human-readable name/description for the span. If not provided,
+        defaults to the function name. This provides more specific details about
+        what the span represents (e.g., "GET /api/users", "process_user_data").
+    :type name: str or None
+
+    :param attributes: A dictionary of key-value pairs to add as attributes to the span.
+        Attribute values must be strings, integers, floats, or booleans. These
+        attributes provide additional context about the span's execution.
+    :type attributes: dict[str, Any] or None
+
+    :param template: The type of span to create. This determines what kind of
+        span instrumentation and data collection will be applied. Use predefined
+        constants from :py:class:`sentry_sdk.consts.SPANTEMPLATE`.
+        The default is `SPANTEMPLATE.DEFAULT` which is the right choice for most
+        use cases.
+    :type template: :py:class:`sentry_sdk.consts.SPANTEMPLATE`
+
+    :returns: When used as ``@trace``, returns the decorated function. When used as
+        ``@trace(...)`` with parameters, returns a decorator function.
+    :rtype: Callable or decorator function
+
+    Example::
 
         import sentry_sdk
+        from sentry_sdk.consts import OP, SPANTEMPLATE
 
+        # Simple usage with default values
         @sentry_sdk.trace
-        def my_function():
-            ...
+        def process_data():
+            # Function implementation
+            pass
 
-        @sentry_sdk.trace
-        async def my_async_function():
-            ...
+        # With custom parameters
+        @sentry_sdk.trace(
+            op=OP.DB_QUERY,
+            name="Get user data",
+            attributes={"postgres": True}
+        )
+        def make_db_query(sql):
+            # Function implementation
+            pass
+
+        # With a custom template
+        @sentry_sdk.trace(template=SPANTEMPLATE.AI_TOOL)
+        def calculate_interest_rate(amount, rate, years):
+            # Function implementation
+            pass
     """
-    from sentry_sdk.tracing_utils import start_child_span_decorator
+    from sentry_sdk.tracing_utils import create_span_decorator
+
+    decorator = create_span_decorator(
+        op=op,
+        name=name,
+        attributes=attributes,
+        template=template,
+    )
 
-    # This patterns allows usage of both @sentry_traced and @sentry_traced(...)
-    # See https://stackoverflow.com/questions/52126071/decorator-with-arguments-avoid-parenthesis-when-no-arguments/52126278
     if func:
-        return start_child_span_decorator(func)
+        return decorator(func)
     else:
-        return start_child_span_decorator
+        return decorator
 
 
 # Circular imports