sentry-sdk 3.0.0a5__py2.py3-none-any.whl → 3.0.0a7__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/integrations/threading.py

@@ -38,7 +38,7 @@ class ThreadingIntegration(Integration):
 
         try:
             from django import VERSION as django_version  # noqa: N811
-            import channels  # type: ignore[import-not-found]
+            import channels  # type: ignore
 
             channels_version = channels.__version__
         except ImportError:

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/spotlight.py

@@ -1,24 +1,16 @@
 from __future__ import annotations
 import io
 import logging
-import os
-import urllib.parse
-import urllib.request
-import urllib.error
 import urllib3
 import sys
 
-from itertools import chain, product
-
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Dict, Optional
+    from typing import Any, Dict, Optional
 
 from sentry_sdk.utils import (
     logger as sentry_logger,
-    env_to_bool,
-    capture_internal_exceptions,
 )
 from sentry_sdk.envelope import Envelope
 
@@ -63,145 +55,6 @@ class SpotlightClient:
             # to avoid overflowing the variable if Spotlight never becomes reachable
 
 
-try:
-    from django.utils.deprecation import MiddlewareMixin
-    from django.http import HttpResponseServerError, HttpResponse, HttpRequest
-    from django.conf import settings
-
-    SPOTLIGHT_JS_ENTRY_PATH = "/assets/main.js"
-    SPOTLIGHT_JS_SNIPPET_PATTERN = (
-        "<script>window.__spotlight = {{ initOptions: {{ sidecarUrl: '{spotlight_url}', fullPage: false }} }};</script>\n"
-        '<script type="module" crossorigin src="{spotlight_js_url}"></script>\n'
-    )
-    SPOTLIGHT_ERROR_PAGE_SNIPPET = (
-        '<html><base href="{spotlight_url}">\n'
-        '<script>window.__spotlight = {{ initOptions: {{ fullPage: true, startFrom: "/errors/{event_id}" }}}};</script>\n'
-    )
-    CHARSET_PREFIX = "charset="
-    BODY_TAG_NAME = "body"
-    BODY_CLOSE_TAG_POSSIBILITIES = tuple(
-        "</{}>".format("".join(chars))
-        for chars in product(*zip(BODY_TAG_NAME.upper(), BODY_TAG_NAME.lower()))
-    )
-
-    class SpotlightMiddleware(MiddlewareMixin):  # type: ignore[misc]
-        _spotlight_script: Optional[str] = None
-        _spotlight_url: Optional[str] = None
-
-        def __init__(self, get_response: Callable[..., HttpResponse]) -> None:
-            super().__init__(get_response)
-
-            import sentry_sdk.api
-
-            self.sentry_sdk = sentry_sdk.api
-
-            spotlight_client = self.sentry_sdk.get_client().spotlight
-            if spotlight_client is None:
-                sentry_logger.warning(
-                    "Cannot find Spotlight client from SpotlightMiddleware, disabling the middleware."
-                )
-                return None
-            # Spotlight URL has a trailing `/stream` part at the end so split it off
-            self._spotlight_url = urllib.parse.urljoin(spotlight_client.url, "../")
-
-        @property
-        def spotlight_script(self) -> Optional[str]:
-            if self._spotlight_url is not None and self._spotlight_script is None:
-                try:
-                    spotlight_js_url = urllib.parse.urljoin(
-                        self._spotlight_url, SPOTLIGHT_JS_ENTRY_PATH
-                    )
-                    req = urllib.request.Request(
-                        spotlight_js_url,
-                        method="HEAD",
-                    )
-                    urllib.request.urlopen(req)
-                    self._spotlight_script = SPOTLIGHT_JS_SNIPPET_PATTERN.format(
-                        spotlight_url=self._spotlight_url,
-                        spotlight_js_url=spotlight_js_url,
-                    )
-                except urllib.error.URLError as err:
-                    sentry_logger.debug(
-                        "Cannot get Spotlight JS to inject at %s. SpotlightMiddleware will not be very useful.",
-                        spotlight_js_url,
-                        exc_info=err,
-                    )
-
-            return self._spotlight_script
-
-        def process_response(
-            self, _request: HttpRequest, response: HttpResponse
-        ) -> Optional[HttpResponse]:
-            content_type_header = tuple(
-                p.strip()
-                for p in response.headers.get("Content-Type", "").lower().split(";")
-            )
-            content_type = content_type_header[0]
-            if len(content_type_header) > 1 and content_type_header[1].startswith(
-                CHARSET_PREFIX
-            ):
-                encoding = content_type_header[1][len(CHARSET_PREFIX) :]
-            else:
-                encoding = "utf-8"
-
-            if (
-                self.spotlight_script is not None
-                and not response.streaming
-                and content_type == "text/html"
-            ):
-                content_length = len(response.content)
-                injection = self.spotlight_script.encode(encoding)
-                injection_site = next(
-                    (
-                        idx
-                        for idx in (
-                            response.content.rfind(body_variant.encode(encoding))
-                            for body_variant in BODY_CLOSE_TAG_POSSIBILITIES
-                        )
-                        if idx > -1
-                    ),
-                    content_length,
-                )
-
-                # This approach works even when we don't have a `</body>` tag
-                response.content = (
-                    response.content[:injection_site]
-                    + injection
-                    + response.content[injection_site:]
-                )
-
-                if response.has_header("Content-Length"):
-                    response.headers["Content-Length"] = content_length + len(injection)
-
-            return response
-
-        def process_exception(
-            self, _request: HttpRequest, exception: Exception
-        ) -> Optional[HttpResponseServerError]:
-            if not settings.DEBUG or not self._spotlight_url:
-                return None
-
-            try:
-                spotlight = (
-                    urllib.request.urlopen(self._spotlight_url).read().decode("utf-8")
-                )
-            except urllib.error.URLError:
-                return None
-            else:
-                event_id = self.sentry_sdk.capture_exception(exception)
-                return HttpResponseServerError(
-                    spotlight.replace(
-                        "<html>",
-                        SPOTLIGHT_ERROR_PAGE_SNIPPET.format(
-                            spotlight_url=self._spotlight_url, event_id=event_id
-                        ),
-                    )
-                )
-
-except ImportError:
-    settings = None
-
-
 def setup_spotlight(options: Dict[str, Any]) -> Optional[SpotlightClient]:
     _handler = logging.StreamHandler(sys.stderr)
     _handler.setFormatter(logging.Formatter(" [spotlight] %(levelname)s: %(message)s"))
@@ -216,20 +69,6 @@ def setup_spotlight(options: Dict[str, Any]) -> Optional[SpotlightClient]:
     if not isinstance(url, str):
         return None
 
-    with capture_internal_exceptions():
-        if (
-            settings is not None
-            and settings.DEBUG
-            and env_to_bool(os.environ.get("SENTRY_SPOTLIGHT_ON_ERROR", "1"))
-            and env_to_bool(os.environ.get("SENTRY_SPOTLIGHT_MIDDLEWARE", "1"))
-        ):
-            middleware = settings.MIDDLEWARE
-            if DJANGO_SPOTLIGHT_MIDDLEWARE_PATH not in middleware:
-                settings.MIDDLEWARE = type(middleware)(
-                    chain(middleware, (DJANGO_SPOTLIGHT_MIDDLEWARE_PATH,))
-                )
-                logger.info("Enabled Spotlight integration for Django")
-
     client = SpotlightClient(url)
     logger.info("Enabled Spotlight using sidecar at %s", url)
 

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