sentry-sdk 2.27.0__py2.py3-none-any.whl → 3.0.0a1__py2.py3-none-any.whl

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)

sentry_sdk/integrations/strawberry.py

@@ -107,14 +107,6 @@ def _patch_schema_init():
                 "False" if should_use_async_extension else "True",
             )
 
-        # remove the built in strawberry sentry extension, if present
-        extensions = [
-            extension
-            for extension in extensions
-            if extension
-            not in (StrawberrySentryAsyncExtension, StrawberrySentrySyncExtension)
-        ]
-
         # add our extension
         extensions.append(
             SentryAsyncExtension if should_use_async_extension else SentrySyncExtension
@@ -184,58 +176,52 @@ class SentryAsyncExtension(SchemaExtension):
         event_processor = _make_request_event_processor(self.execution_context)
         scope.add_event_processor(event_processor)
 
-        span = sentry_sdk.get_current_span()
-        if span:
-            self.graphql_span = span.start_child(
-                op=op,
-                name=description,
-                origin=StrawberryIntegration.origin,
-            )
-        else:
-            self.graphql_span = sentry_sdk.start_span(
-                op=op,
-                name=description,
-                origin=StrawberryIntegration.origin,
-            )
+        with sentry_sdk.start_span(
+            op=op,
+            name=description,
+            origin=StrawberryIntegration.origin,
+            only_if_parent=True,
+        ) as graphql_span:
+            graphql_span.set_attribute("graphql.operation.type", operation_type)
+            graphql_span.set_attribute("graphql.document", self.execution_context.query)
+            graphql_span.set_attribute("graphql.resource_name", self._resource_name)
+
+            yield
 
-        self.graphql_span.set_data("graphql.operation.type", operation_type)
-        self.graphql_span.set_data("graphql.operation.name", self._operation_name)
-        self.graphql_span.set_data("graphql.document", self.execution_context.query)
-        self.graphql_span.set_data("graphql.resource_name", self._resource_name)
+            # we might have a more accurate operation_name after the parsing
+            self._operation_name = self.execution_context.operation_name
 
-        yield
+            if self._operation_name is not None:
+                graphql_span.set_attribute(
+                    "graphql.operation.name", self._operation_name
+                )
 
-        transaction = self.graphql_span.containing_transaction
-        if transaction and self.execution_context.operation_name:
-            transaction.name = self.execution_context.operation_name
-            transaction.source = TransactionSource.COMPONENT
-            transaction.op = op
+                sentry_sdk.get_current_scope().set_transaction_name(
+                    self._operation_name,
+                    source=TransactionSource.COMPONENT,
+                )
 
-        self.graphql_span.finish()
+            root_span = graphql_span.root_span
+            if root_span:
+                root_span.op = op
 
     def on_validate(self):
         # type: () -> Generator[None, None, None]
-        self.validation_span = self.graphql_span.start_child(
+        with sentry_sdk.start_span(
             op=OP.GRAPHQL_VALIDATE,
             name="validation",
             origin=StrawberryIntegration.origin,
-        )
-
-        yield
-
-        self.validation_span.finish()
+        ):
+            yield
 
     def on_parse(self):
         # type: () -> Generator[None, None, None]
-        self.parsing_span = self.graphql_span.start_child(
+        with sentry_sdk.start_span(
             op=OP.GRAPHQL_PARSE,
             name="parsing",
             origin=StrawberryIntegration.origin,
-        )
-
-        yield
-
-        self.parsing_span.finish()
+        ):
+            yield
 
     def should_skip_tracing(self, _next, info):
         # type: (Callable[[Any, GraphQLResolveInfo, Any, Any], Any], GraphQLResolveInfo) -> bool
@@ -257,15 +243,15 @@ class SentryAsyncExtension(SchemaExtension):
 
         field_path = "{}.{}".format(info.parent_type, info.field_name)
 
-        with self.graphql_span.start_child(
+        with sentry_sdk.start_span(
             op=OP.GRAPHQL_RESOLVE,
             name="resolving {}".format(field_path),
             origin=StrawberryIntegration.origin,
         ) as span:
-            span.set_data("graphql.field_name", info.field_name)
-            span.set_data("graphql.parent_type", info.parent_type.name)
-            span.set_data("graphql.field_path", field_path)
-            span.set_data("graphql.path", ".".join(map(str, info.path.as_list())))
+            span.set_attribute("graphql.field_name", info.field_name)
+            span.set_attribute("graphql.parent_type", info.parent_type.name)
+            span.set_attribute("graphql.field_path", field_path)
+            span.set_attribute("graphql.path", ".".join(map(str, info.path.as_list())))
 
             return await self._resolve(_next, root, info, *args, **kwargs)
 
@@ -278,15 +264,15 @@ class SentrySyncExtension(SentryAsyncExtension):
 
         field_path = "{}.{}".format(info.parent_type, info.field_name)
 
-        with self.graphql_span.start_child(
+        with sentry_sdk.start_span(
             op=OP.GRAPHQL_RESOLVE,
             name="resolving {}".format(field_path),
             origin=StrawberryIntegration.origin,
         ) as span:
-            span.set_data("graphql.field_name", info.field_name)
-            span.set_data("graphql.parent_type", info.parent_type.name)
-            span.set_data("graphql.field_path", field_path)
-            span.set_data("graphql.path", ".".join(map(str, info.path.as_list())))
+            span.set_attribute("graphql.field_name", info.field_name)
+            span.set_attribute("graphql.parent_type", info.parent_type.name)
+            span.set_attribute("graphql.field_path", field_path)
+            span.set_attribute("graphql.path", ".".join(map(str, info.path.as_list())))
 
             return _next(root, info, *args, **kwargs)
 
@@ -383,11 +369,6 @@ def _make_response_event_processor(response_data):
 
 def _guess_if_using_async(extensions):
     # type: (List[SchemaExtension]) -> bool
-    if StrawberrySentryAsyncExtension in extensions:
-        return True
-    elif StrawberrySentrySyncExtension in extensions:
-        return False
-
     return bool(
         {"starlette", "starlite", "litestar", "fastapi"} & set(_get_installed_modules())
     )

sentry_sdk/integrations/threading.py

@@ -4,12 +4,12 @@ from functools import wraps
 from threading import Thread, current_thread
 
 import sentry_sdk
+from sentry_sdk import Scope
+from sentry_sdk.scope import ScopeType
 from sentry_sdk.integrations import Integration
-from sentry_sdk.scope import use_isolation_scope, use_scope
 from sentry_sdk.utils import (
     event_from_exception,
     capture_internal_exceptions,
-    logger,
     reraise,
 )
 
@@ -19,7 +19,6 @@ if TYPE_CHECKING:
     from typing import Any
     from typing import TypeVar
     from typing import Callable
-    from typing import Optional
 
     from sentry_sdk._types import ExcInfo
 
@@ -29,22 +28,10 @@ if TYPE_CHECKING:
 class ThreadingIntegration(Integration):
     identifier = "threading"
 
-    def __init__(self, propagate_hub=None, propagate_scope=True):
-        # type: (Optional[bool], bool) -> None
-        if propagate_hub is not None:
-            logger.warning(
-                "Deprecated: propagate_hub is deprecated. This will be removed in the future."
-            )
-
-        # Note: propagate_hub did not have any effect on propagation of scope data
-        # scope data was always propagated no matter what the value of propagate_hub was
-        # This is why the default for propagate_scope is True
-
+    def __init__(self, propagate_scope=True):
+        # type: (bool) -> None
         self.propagate_scope = propagate_scope
 
-        if propagate_hub is not None:
-            self.propagate_scope = propagate_hub
-
     @staticmethod
     def setup_once():
         # type: () -> None
@@ -89,8 +76,8 @@ class ThreadingIntegration(Integration):
                     isolation_scope = sentry_sdk.get_isolation_scope().fork()
                     current_scope = sentry_sdk.get_current_scope().fork()
             else:
-                isolation_scope = None
-                current_scope = None
+                isolation_scope = Scope(ty=ScopeType.ISOLATION)
+                current_scope = Scope(ty=ScopeType.CURRENT)
 
             # Patching instance methods in `start()` creates a reference cycle if
             # done in a naive way. See
@@ -112,7 +99,7 @@ class ThreadingIntegration(Integration):
 
 
 def _wrap_run(isolation_scope_to_use, current_scope_to_use, old_run_func):
-    # type: (Optional[sentry_sdk.Scope], Optional[sentry_sdk.Scope], F) -> F
+    # type: (sentry_sdk.Scope, sentry_sdk.Scope, F) -> F
     @wraps(old_run_func)
     def run(*a, **kw):
         # type: (*Any, **Any) -> Any
@@ -124,12 +111,9 @@ def _wrap_run(isolation_scope_to_use, current_scope_to_use, old_run_func):
             except Exception:
                 reraise(*_capture_exception())
 
-        if isolation_scope_to_use is not None and current_scope_to_use is not None:
-            with use_isolation_scope(isolation_scope_to_use):
-                with use_scope(current_scope_to_use):
-                    return _run_old_run_func()
-        else:
-            return _run_old_run_func()
+        with sentry_sdk.use_isolation_scope(isolation_scope_to_use):
+            with sentry_sdk.use_scope(current_scope_to_use):
+                return _run_old_run_func()
 
     return run  # type: ignore
 

sentry_sdk/integrations/tornado.py

@@ -3,7 +3,6 @@ import contextlib
 from inspect import iscoroutinefunction
 
 import sentry_sdk
-from sentry_sdk.api import continue_trace
 from sentry_sdk.consts import OP
 from sentry_sdk.scope import should_send_default_pii
 from sentry_sdk.tracing import TransactionSource
@@ -20,13 +19,15 @@ from sentry_sdk.integrations._wsgi_common import (
     RequestExtractor,
     _filter_headers,
     _is_json_content_type,
+    _request_headers_to_span_attributes,
 )
 from sentry_sdk.integrations.logging import ignore_logger
 
 try:
     from tornado import version_info as TORNADO_VERSION
-    from tornado.web import RequestHandler, HTTPError
     from tornado.gen import coroutine
+    from tornado.httputil import HTTPServerRequest
+    from tornado.web import RequestHandler, HTTPError
 except ImportError:
     raise DidNotEnable("Tornado not installed")
 
@@ -42,6 +43,14 @@ if TYPE_CHECKING:
     from sentry_sdk._types import Event, EventProcessor
 
 
+REQUEST_PROPERTY_TO_ATTRIBUTE = {
+    "method": "http.request.method",
+    "path": "url.path",
+    "query": "url.query",
+    "protocol": "url.scheme",
+}
+
+
 class TornadoIntegration(Integration):
     identifier = "tornado"
     origin = f"auto.http.{identifier}"
@@ -111,22 +120,19 @@ def _handle_request_impl(self):
         processor = _make_event_processor(weak_handler)
         scope.add_event_processor(processor)
 
-        transaction = continue_trace(
-            headers,
-            op=OP.HTTP_SERVER,
-            # Like with all other integrations, this is our
-            # fallback transaction in case there is no route.
-            # sentry_urldispatcher_resolve is responsible for
-            # setting a transaction name later.
-            name="generic Tornado request",
-            source=TransactionSource.ROUTE,
-            origin=TornadoIntegration.origin,
-        )
-
-        with sentry_sdk.start_transaction(
-            transaction, custom_sampling_context={"tornado_request": self.request}
-        ):
-            yield
+        with sentry_sdk.continue_trace(headers):
+            with sentry_sdk.start_span(
+                op=OP.HTTP_SERVER,
+                # Like with all other integrations, this is our
+                # fallback transaction in case there is no route.
+                # sentry_urldispatcher_resolve is responsible for
+                # setting a transaction name later.
+                name="generic Tornado request",
+                source=TransactionSource.ROUTE,
+                origin=TornadoIntegration.origin,
+                attributes=_prepopulate_attributes(self.request),
+            ):
+                yield
 
 
 @ensure_integration_enabled(TornadoIntegration)
@@ -218,3 +224,36 @@ class TornadoRequestExtractor(RequestExtractor):
     def size_of_file(self, file):
         # type: (Any) -> int
         return len(file.body or ())
+
+
+def _prepopulate_attributes(request):
+    # type: (HTTPServerRequest) -> dict[str, Any]
+    # https://www.tornadoweb.org/en/stable/httputil.html#tornado.httputil.HTTPServerRequest
+    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, "version", None):
+        try:
+            proto, version = request.version.split("/")
+            attributes["network.protocol.name"] = proto
+            attributes["network.protocol.version"] = version
+        except ValueError:
+            attributes["network.protocol.name"] = request.version
+
+    if getattr(request, "host", None):
+        try:
+            address, port = request.host.split(":")
+            attributes["server.address"] = address
+            attributes["server.port"] = port
+        except ValueError:
+            attributes["server.address"] = request.host
+
+    with capture_internal_exceptions():
+        attributes["url.full"] = request.full_url()
+
+    attributes.update(_request_headers_to_span_attributes(request.headers))
+
+    return attributes

sentry_sdk/integrations/trytond.py

@@ -1,8 +1,9 @@
 import sentry_sdk
-from sentry_sdk.integrations import Integration
+from sentry_sdk.integrations import _check_minimum_version, Integration
 from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
 from sentry_sdk.utils import ensure_integration_enabled, event_from_exception
 
+from trytond import __version__ as trytond_version  # type: ignore
 from trytond.exceptions import TrytonException  # type: ignore
 from trytond.wsgi import app  # type: ignore
 
@@ -19,6 +20,8 @@ class TrytondWSGIIntegration(Integration):
 
     @staticmethod
     def setup_once():  # type: () -> None
+        _check_minimum_version(TrytondWSGIIntegration, trytond_version)
+
         app.wsgi_app = SentryWsgiMiddleware(
             app.wsgi_app,
             span_origin=TrytondWSGIIntegration.origin,