sentry-sdk 3.0.0a5__py2.py3-none-any.whl → 3.0.0a6__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: Exception) -> None:
@@ -113,7 +114,6 @@ def patch_app_init() -> None:
             *(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/openai_agents/patches/agent_run.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 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
@@ -11,7 +10,6 @@ from typing import TYPE_CHECKING
 if TYPE_CHECKING:
     from typing import Any, Optional
 
-
 try:
     import agents
 except ImportError:

sentry_sdk/integrations/openai_agents/patches/runner.py

@@ -23,20 +23,23 @@ def _create_run_wrapper(original_func: Callable[..., Any]) -> Callable[..., Any]
 
     @wraps(original_func)
     async def wrapper(*args: Any, **kwargs: 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
-                span = sentry_sdk.get_current_span()
-                if span is not None and span.timestamp is None:
-                    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/quart.py

@@ -94,8 +94,8 @@ def patch_asgi_app() -> None:
         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

@@ -24,7 +24,6 @@ from sentry_sdk.utils import (
     capture_internal_exceptions,
     ensure_integration_enabled,
     event_from_exception,
-    logger,
     parse_version,
     transaction_from_function,
 )
@@ -388,9 +387,9 @@ def patch_asgi_app() -> None:
                 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
@@ -698,9 +697,6 @@ def _set_transaction_name_and_source(
         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(

sentry_sdk/integrations/starlite.py

@@ -17,7 +17,7 @@ try:
     from starlite.plugins.base import get_plugin_for_value  # type: ignore
     from starlite.routes.http import HTTPRoute  # type: ignore
     from starlite.utils import ConnectionDataExtractor, is_async_callable, Ref  # type: ignore
-    from pydantic import BaseModel
+    from pydantic import BaseModel  # type: ignore
 except ImportError:
     raise DidNotEnable("Starlite is not installed")
 
@@ -65,6 +65,7 @@ class SentryStarliteASGIMiddleware(SentryAsgiMiddleware):
             transaction_style="endpoint",
             mechanism_type="asgi",
             span_origin=span_origin,
+            asgi_version=3,
         )
 
 
@@ -92,7 +93,6 @@ def patch_app_init() -> None:
             ]
         )
 
-        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

@@ -61,7 +61,7 @@ if TYPE_CHECKING:
         Self,
     )
 
-    from collections.abc import Mapping, MutableMapping
+    from collections.abc import Mapping
 
     import sentry_sdk
     from sentry_sdk._types import (
@@ -201,24 +201,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
 
@@ -627,12 +627,12 @@ class Scope:
         self._level: Optional[LogLevelStr] = None
         self._fingerprint: Optional[List[str]] = None
         self._transaction: Optional[str] = None
-        self._transaction_info: MutableMapping[str, str] = {}
+        self._transaction_info: Dict[str, str] = {}
         self._user: Optional[Dict[str, Any]] = None
 
         self._tags: Dict[str, Any] = {}
         self._contexts: Dict[str, Dict[str, Any]] = {}
-        self._extras: MutableMapping[str, Any] = {}
+        self._extras: Dict[str, Any] = {}
         self._attachments: List[Attachment] = []
 
         self.clear_breadcrumbs()

sentry_sdk/tracing.py

@@ -23,6 +23,7 @@ from sentry_sdk.consts import (
     SENTRY_TRACE_HEADER_NAME,
     SPANSTATUS,
     SPANDATA,
+    SPANTEMPLATE,
     TransactionSource,
 )
 from sentry_sdk.opentelemetry.consts import (
@@ -278,6 +279,14 @@ class Span:
         self.finish()
         self.deactivate()
 
+    async def __aenter__(self) -> Span:
+        return self.__enter__()
+
+    async def __aexit__(
+        self, ty: Optional[Any], value: Optional[Any], tb: Optional[Any]
+    ) -> None:
+        return self.__exit__(ty, value, tb)
+
     @property
     def description(self) -> Optional[str]:
         return self.get_attribute(SentrySpanAttribute.DESCRIPTION)
@@ -543,39 +552,107 @@ Transaction = Span
 if TYPE_CHECKING:
 
     @overload
-    def trace(func: None = None) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    def trace(
+        func: Optional[Callable[P, R]] = None,
+        *,
+        op: Optional[str] = None,
+        name: Optional[str] = None,
+        attributes: Optional[dict[str, Any]] = None,
+        template: SPANTEMPLATE = SPANTEMPLATE.DEFAULT,
+    ) -> Union[Callable[P, R], Callable[[Callable[P, R]], Callable[P, R]]]:
+        # Handles: @trace() and @trace(op="custom")
         pass
 
     @overload
     def trace(func: Callable[P, R]) -> Callable[P, R]:
+        # Handles: @trace
         pass
 
 
 def trace(
     func: Optional[Callable[P, R]] = None,
+    *,
+    op: Optional[str] = None,
+    name: Optional[str] = None,
+    attributes: Optional[dict[str, Any]] = None,
+    template: SPANTEMPLATE = SPANTEMPLATE.DEFAULT,
 ) -> 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():
-            ...
-
-        @sentry_sdk.trace
-        async def my_async_function():
-            ...
+        def process_data():
+            # Function implementation
+            pass
+
+        # 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