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

sentry_sdk/integrations/clickhouse_driver.py

@@ -3,9 +3,13 @@ from sentry_sdk.consts import OP, SPANDATA
 from sentry_sdk.integrations import _check_minimum_version, Integration, DidNotEnable
 from sentry_sdk.tracing import Span
 from sentry_sdk.scope import should_send_default_pii
-from sentry_sdk.utils import capture_internal_exceptions, ensure_integration_enabled
+from sentry_sdk.utils import (
+    _serialize_span_attribute,
+    capture_internal_exceptions,
+    ensure_integration_enabled,
+)
 
-from typing import TYPE_CHECKING, TypeVar
+from typing import TYPE_CHECKING, cast, Any, Dict, TypeVar
 
 # Hack to get new Python features working in older versions
 # without introducing a hard dependency on `typing_extensions`
@@ -84,19 +88,23 @@ def _wrap_start(f: Callable[P, T]) -> Callable[P, T]:
             op=OP.DB,
             name=query,
             origin=ClickhouseDriverIntegration.origin,
+            only_if_parent=True,
         )
 
         connection._sentry_span = span  # type: ignore[attr-defined]
 
-        _set_db_data(span, connection)
-
-        span.set_data("query", query)
+        data = _get_db_data(connection)
+        data = cast("dict[str, Any]", data)
+        data["db.query.text"] = query
 
         if query_id:
-            span.set_data("db.query_id", query_id)
+            data["db.query_id"] = query_id
 
         if params and should_send_default_pii():
-            span.set_data("db.params", params)
+            data["db.params"] = params
+
+        connection._sentry_db_data = data  # type: ignore[attr-defined]
+        _set_on_span(span, data)
 
         # run the original code
         ret = f(*args, **kwargs)
@@ -109,20 +117,32 @@ def _wrap_start(f: Callable[P, T]) -> Callable[P, T]:
 def _wrap_end(f: Callable[P, T]) -> Callable[P, T]:
     def _inner_end(*args: P.args, **kwargs: P.kwargs) -> T:
         res = f(*args, **kwargs)
-        instance = args[0]
-        span = getattr(instance.connection, "_sentry_span", None)  # type: ignore[attr-defined]
+        client = cast("clickhouse_driver.client.Client", args[0])
+        connection = client.connection
 
+        span = getattr(connection, "_sentry_span", None)
         if span is not None:
+            data = getattr(connection, "_sentry_db_data", {})
+
             if res is not None and should_send_default_pii():
-                span.set_data("db.result", res)
+                data["db.result"] = res
+                span.set_attribute("db.result", _serialize_span_attribute(res))
 
             with capture_internal_exceptions():
-                span.scope.add_breadcrumb(
-                    message=span._data.pop("query"), category="query", data=span._data
-                )
+                query = data.pop("db.query.text", None)
+                if query:
+                    sentry_sdk.add_breadcrumb(
+                        message=query, category="query", data=data
+                    )
 
             span.finish()
 
+            try:
+                del connection._sentry_db_data
+                del connection._sentry_span
+            except AttributeError:
+                pass
+
         return res
 
     return _inner_end
@@ -130,28 +150,39 @@ def _wrap_end(f: Callable[P, T]) -> Callable[P, T]:
 
 def _wrap_send_data(f: Callable[P, T]) -> Callable[P, T]:
     def _inner_send_data(*args: P.args, **kwargs: P.kwargs) -> T:
-        instance = args[0]  # type: clickhouse_driver.client.Client
-        data = args[2]
-        span = getattr(instance.connection, "_sentry_span", None)
+        client = cast("clickhouse_driver.client.Client", args[0])
+        connection = client.connection
+        db_params_data = cast("list[Any]", args[2])
+        span = getattr(connection, "_sentry_span", None)
 
         if span is not None:
-            _set_db_data(span, instance.connection)
+            data = _get_db_data(connection)
+            _set_on_span(span, data)
 
             if should_send_default_pii():
-                db_params = span._data.get("db.params", [])
-                db_params.extend(data)
-                span.set_data("db.params", db_params)
+                saved_db_data = getattr(
+                    connection, "_sentry_db_data", {}
+                )  # type: dict[str, Any]
+                db_params = saved_db_data.get("db.params") or []  # type: list[Any]
+                db_params.extend(db_params_data)
+                saved_db_data["db.params"] = db_params
+                span.set_attribute("db.params", _serialize_span_attribute(db_params))
 
         return f(*args, **kwargs)
 
     return _inner_send_data
 
 
-def _set_db_data(
-    span: Span, connection: clickhouse_driver.connection.Connection
-) -> None:
-    span.set_data(SPANDATA.DB_SYSTEM, "clickhouse")
-    span.set_data(SPANDATA.SERVER_ADDRESS, connection.host)
-    span.set_data(SPANDATA.SERVER_PORT, connection.port)
-    span.set_data(SPANDATA.DB_NAME, connection.database)
-    span.set_data(SPANDATA.DB_USER, connection.user)
+def _get_db_data(connection: clickhouse_driver.connection.Connection) -> Dict[str, str]:
+    return {
+        SPANDATA.DB_SYSTEM: "clickhouse",
+        SPANDATA.SERVER_ADDRESS: connection.host,
+        SPANDATA.SERVER_PORT: connection.port,
+        SPANDATA.DB_NAME: connection.database,
+        SPANDATA.DB_USER: connection.user,
+    }
+
+
+def _set_on_span(span: Span, data: Dict[str, Any]) -> None:
+    for key, value in data.items():
+        span.set_attribute(key, _serialize_span_attribute(value))

sentry_sdk/integrations/cohere.py

@@ -147,6 +147,7 @@ def _wrap_chat(f, streaming):
             op=consts.OP.COHERE_CHAT_COMPLETIONS_CREATE,
             name="cohere.client.Chat",
             origin=CohereIntegration.origin,
+            only_if_parent=True,
         )
         span.__enter__()
         try:
@@ -233,6 +234,7 @@ def _wrap_embed(f):
             op=consts.OP.COHERE_EMBEDDINGS_CREATE,
             name="Cohere Embedding Creation",
             origin=CohereIntegration.origin,
+            only_if_parent=True,
         ) as span:
             if "texts" in kwargs and (
                 should_send_default_pii() and integration.include_prompts

sentry_sdk/integrations/django/__init__.py

@@ -1,3 +1,4 @@
+import functools
 import inspect
 import sys
 import threading
@@ -5,10 +6,9 @@ import weakref
 from importlib import import_module
 
 import sentry_sdk
-from sentry_sdk.consts import OP, SPANDATA
+from sentry_sdk.consts import OP, SPANDATA, SOURCE_FOR_STYLE, TransactionSource
 from sentry_sdk.scope import add_global_event_processor, should_send_default_pii
 from sentry_sdk.serializer import add_global_repr_processor
-from sentry_sdk.tracing import SOURCE_FOR_STYLE, TransactionSource
 from sentry_sdk.tracing_utils import add_query_source, record_sql_queries
 from sentry_sdk.utils import (
     AnnotatedValue,
@@ -55,6 +55,7 @@ try:
 except ImportError:
     raise DidNotEnable("Django not installed")
 
+from sentry_sdk.integrations.django.caching import patch_caching
 from sentry_sdk.integrations.django.transactions import LEGACY_RESOLVER
 from sentry_sdk.integrations.django.templates import (
     get_template_frame_from_exception,
@@ -64,11 +65,6 @@ from sentry_sdk.integrations.django.middleware import patch_django_middlewares
 from sentry_sdk.integrations.django.signals_handlers import patch_signals
 from sentry_sdk.integrations.django.views import patch_views
 
-if DJANGO_VERSION[:2] > (1, 8):
-    from sentry_sdk.integrations.django.caching import patch_caching
-else:
-    patch_caching = None  # type: ignore
-
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -89,19 +85,6 @@ if TYPE_CHECKING:
     from sentry_sdk._types import Event, Hint, EventProcessor, NotImplementedType
 
 
-if DJANGO_VERSION < (1, 10):
-
-    def is_authenticated(request_user):
-        # type: (Any) -> bool
-        return request_user.is_authenticated()
-
-else:
-
-    def is_authenticated(request_user):
-        # type: (Any) -> bool
-        return request_user.is_authenticated
-
-
 TRANSACTION_STYLE_VALUES = ("function_name", "url")
 
 
@@ -131,7 +114,7 @@ class DjangoIntegration(Integration):
         transaction_style="url",  # type: str
         middleware_spans=True,  # type: bool
         signals_spans=True,  # type: bool
-        cache_spans=False,  # type: bool
+        cache_spans=True,  # type: bool
         signals_denylist=None,  # type: Optional[list[signals.Signal]]
         http_methods_to_capture=DEFAULT_HTTP_METHODS_TO_CAPTURE,  # type: tuple[str, ...]
     ):
@@ -321,6 +304,7 @@ def _patch_drf():
             else:
                 old_drf_initial = APIView.initial
 
+                @functools.wraps(old_drf_initial)
                 def sentry_patched_drf_initial(self, request, *args, **kwargs):
                     # type: (APIView, Any, *Any, **Any) -> Any
                     with capture_internal_exceptions():
@@ -413,11 +397,13 @@ def _set_transaction_name_and_source(scope, transaction_style, request):
         if hasattr(urlconf, "handler404"):
             handler = urlconf.handler404
             if isinstance(handler, str):
-                scope.transaction = handler
+                scope.set_transaction_name(handler)
             else:
-                scope.transaction = transaction_from_function(
+                name = transaction_from_function(
                     getattr(handler, "view_class", handler)
                 )
+                if isinstance(name, str):
+                    scope.set_transaction_name(name)
     except Exception:
         pass
 
@@ -471,6 +457,7 @@ def _patch_get_response():
 
     old_get_response = BaseHandler.get_response
 
+    @functools.wraps(old_get_response)
     def sentry_patched_get_response(self, request):
         # type: (Any, WSGIRequest) -> Union[HttpResponse, BaseException]
         _before_get_response(request)
@@ -594,7 +581,7 @@ def _set_user_info(request, event):
 
     user = getattr(request, "user", None)
 
-    if user is None or not is_authenticated(user):
+    if user is None or not user.is_authenticated:
         return
 
     try:
@@ -621,20 +608,11 @@ def install_sql_hook():
     except ImportError:
         from django.db.backends.util import CursorWrapper
 
-    try:
-        # django 1.6 and 1.7 compatability
-        from django.db.backends import BaseDatabaseWrapper
-    except ImportError:
-        # django 1.8 or later
-        from django.db.backends.base.base import BaseDatabaseWrapper
+    from django.db.backends.base.base import BaseDatabaseWrapper
 
-    try:
-        real_execute = CursorWrapper.execute
-        real_executemany = CursorWrapper.executemany
-        real_connect = BaseDatabaseWrapper.connect
-    except AttributeError:
-        # This won't work on Django versions < 1.6
-        return
+    real_execute = CursorWrapper.execute
+    real_executemany = CursorWrapper.executemany
+    real_connect = BaseDatabaseWrapper.connect
 
     @ensure_integration_enabled(DjangoIntegration, real_execute)
     def execute(self, sql, params=None):
@@ -650,8 +628,8 @@ def install_sql_hook():
             _set_db_data(span, self)
             result = real_execute(self, sql, params)
 
-        with capture_internal_exceptions():
-            add_query_source(span)
+            with capture_internal_exceptions():
+                add_query_source(span)
 
         return result
 
@@ -670,8 +648,8 @@ def install_sql_hook():
 
             result = real_executemany(self, sql, param_list)
 
-        with capture_internal_exceptions():
-            add_query_source(span)
+            with capture_internal_exceptions():
+                add_query_source(span)
 
         return result
 
@@ -685,6 +663,7 @@ def install_sql_hook():
             op=OP.DB,
             name="connect",
             origin=DjangoIntegration.origin_db,
+            only_if_parent=True,
         ) as span:
             _set_db_data(span, self)
             return real_connect(self)
@@ -699,7 +678,7 @@ def _set_db_data(span, cursor_or_db):
     # type: (Span, Any) -> None
     db = cursor_or_db.db if hasattr(cursor_or_db, "db") else cursor_or_db
     vendor = db.vendor
-    span.set_data(SPANDATA.DB_SYSTEM, vendor)
+    span.set_attribute(SPANDATA.DB_SYSTEM, vendor)
 
     # Some custom backends override `__getattr__`, making it look like `cursor_or_db`
     # actually has a `connection` and the `connection` has a `get_dsn_parameters`
@@ -732,16 +711,16 @@ def _set_db_data(span, cursor_or_db):
 
     db_name = connection_params.get("dbname") or connection_params.get("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 = connection_params.get("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 = connection_params.get("port")
     if server_port is not None:
-        span.set_data(SPANDATA.SERVER_PORT, str(server_port))
+        span.set_attribute(SPANDATA.SERVER_PORT, str(server_port))
 
     server_socket_address = connection_params.get("unix_socket")
     if server_socket_address is not None:
-        span.set_data(SPANDATA.SERVER_SOCKET_ADDRESS, server_socket_address)
+        span.set_attribute(SPANDATA.SERVER_SOCKET_ADDRESS, server_socket_address)

sentry_sdk/integrations/django/asgi.py

@@ -88,6 +88,7 @@ def patch_django_asgi_handler_impl(cls):
 
     old_app = cls.__call__
 
+    @functools.wraps(old_app)
     async def sentry_patched_asgi_handler(self, scope, receive, send):
         # type: (Any, Any, Any, Any) -> Any
         integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
@@ -125,6 +126,7 @@ def patch_get_response_async(cls, _before_get_response):
     # type: (Any, Any) -> None
     old_get_response_async = cls.get_response_async
 
+    @functools.wraps(old_get_response_async)
     async def sentry_patched_get_response_async(self, request):
         # type: (Any, Any) -> Union[HttpResponse, BaseException]
         _before_get_response(request)
@@ -142,6 +144,7 @@ def patch_channels_asgi_handler_impl(cls):
     if channels.__version__ < "3.0.0":
         old_app = cls.__call__
 
+        @functools.wraps(old_app)
         async def sentry_patched_asgi_handler(self, receive, send):
             # type: (Any, Any, Any) -> Any
             integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
@@ -173,8 +176,8 @@ def wrap_async_view(callback):
     async def sentry_wrapped_callback(request, *args, **kwargs):
         # type: (Any, *Any, **Any) -> Any
         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:
@@ -184,6 +187,7 @@ def wrap_async_view(callback):
             op=OP.VIEW_RENDER,
             name=request.resolver_match.view_name,
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         ):
             return await callback(request, *args, **kwargs)
 

sentry_sdk/integrations/django/caching.py

@@ -54,27 +54,28 @@ def _patch_cache_method(cache, method_name, address, port):
             op=op,
             name=description,
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         ) as span:
             value = original_method(*args, **kwargs)
 
             with capture_internal_exceptions():
                 if address is not None:
-                    span.set_data(SPANDATA.NETWORK_PEER_ADDRESS, address)
+                    span.set_attribute(SPANDATA.NETWORK_PEER_ADDRESS, address)
 
                 if port is not None:
-                    span.set_data(SPANDATA.NETWORK_PEER_PORT, port)
+                    span.set_attribute(SPANDATA.NETWORK_PEER_PORT, port)
 
                 key = _get_safe_key(method_name, args, kwargs)
                 if key is not None:
-                    span.set_data(SPANDATA.CACHE_KEY, key)
+                    span.set_attribute(SPANDATA.CACHE_KEY, key)
 
                 item_size = None
                 if is_get_operation:
                     if value:
                         item_size = len(str(value))
-                        span.set_data(SPANDATA.CACHE_HIT, True)
+                        span.set_attribute(SPANDATA.CACHE_HIT, True)
                     else:
-                        span.set_data(SPANDATA.CACHE_HIT, False)
+                        span.set_attribute(SPANDATA.CACHE_HIT, False)
                 else:  # TODO: We don't handle `get_or_set` which we should
                     arg_count = len(args)
                     if arg_count >= 2:
@@ -85,7 +86,7 @@ def _patch_cache_method(cache, method_name, address, port):
                         item_size = len(str(args[0]))
 
                 if item_size is not None:
-                    span.set_data(SPANDATA.CACHE_ITEM_SIZE, item_size)
+                    span.set_attribute(SPANDATA.CACHE_ITEM_SIZE, item_size)
 
             return value
 
@@ -133,22 +134,10 @@ def _get_address_port(settings):
     return address, int(port) if port is not None else None
 
 
-def should_enable_cache_spans():
-    # type: () -> bool
-    from sentry_sdk.integrations.django import DjangoIntegration
-
-    client = sentry_sdk.get_client()
-    integration = client.get_integration(DjangoIntegration)
-    from django.conf import settings
-
-    return integration is not None and (
-        (client.spotlight is not None and settings.DEBUG is True)
-        or integration.cache_spans is True
-    )
-
-
 def patch_caching():
     # type: () -> None
+    from sentry_sdk.integrations.django import DjangoIntegration
+
     if not hasattr(CacheHandler, "_sentry_patched"):
         if DJANGO_VERSION < (3, 2):
             original_get_item = CacheHandler.__getitem__
@@ -158,7 +147,8 @@ def patch_caching():
                 # type: (CacheHandler, str) -> Any
                 cache = original_get_item(self, alias)
 
-                if should_enable_cache_spans():
+                integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
+                if integration is not None and integration.cache_spans:
                     from django.conf import settings
 
                     address, port = _get_address_port(
@@ -180,7 +170,8 @@ def patch_caching():
                 # type: (CacheHandler, str) -> Any
                 cache = original_create_connection(self, alias)
 
-                if should_enable_cache_spans():
+                integration = sentry_sdk.get_client().get_integration(DjangoIntegration)
+                if integration is not None and integration.cache_spans:
                     address, port = _get_address_port(self.settings[alias or "default"])
 
                     _patch_cache(cache, address, port)

sentry_sdk/integrations/django/middleware.py

@@ -89,6 +89,7 @@ def _wrap_middleware(middleware, middleware_name):
             op=OP.MIDDLEWARE_DJANGO,
             name=description,
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         )
         middleware_span.set_tag("django.function_name", function_name)
         middleware_span.set_tag("django.middleware_name", middleware_name)

sentry_sdk/integrations/django/signals_handlers.py

@@ -50,6 +50,7 @@ def patch_signals():
 
     old_live_receivers = Signal._live_receivers
 
+    @wraps(old_live_receivers)
     def _sentry_live_receivers(self, sender):
         # type: (Signal, Any) -> Union[tuple[list[Callable[..., Any]], list[Callable[..., Any]]], list[Callable[..., Any]]]
         if DJANGO_VERSION >= (5, 0):
@@ -68,8 +69,9 @@ def patch_signals():
                     op=OP.EVENT_DJANGO,
                     name=signal_name,
                     origin=DjangoIntegration.origin,
+                    only_if_parent=True,
                 ) as span:
-                    span.set_data("signal", signal_name)
+                    span.set_attribute("signal", signal_name)
                     return receiver(*args, **kwargs)
 
             return wrapper

sentry_sdk/integrations/django/templates.py

@@ -1,8 +1,8 @@
 import functools
 
 from django.template import TemplateSyntaxError
+from django.template.base import Origin
 from django.utils.safestring import mark_safe
-from django import VERSION as DJANGO_VERSION
 
 import sentry_sdk
 from sentry_sdk.consts import OP
@@ -17,13 +17,6 @@ if TYPE_CHECKING:
     from typing import Iterator
     from typing import Tuple
 
-try:
-    # support Django 1.9
-    from django.template.base import Origin
-except ImportError:
-    # backward compatibility
-    from django.template.loader import LoaderOrigin as Origin
-
 
 def get_template_frame_from_exception(exc_value):
     # type: (Optional[BaseException]) -> Optional[Dict[str, Any]]
@@ -72,14 +65,15 @@ def patch_templates():
             op=OP.TEMPLATE_RENDER,
             name=_get_template_name_description(self.template_name),
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         ) as span:
-            span.set_data("context", self.context_data)
+            if isinstance(self.context_data, dict):
+                for k, v in self.context_data.items():
+                    span.set_attribute(f"context.{k}", v)
             return real_rendered_content.fget(self)
 
     SimpleTemplateResponse.rendered_content = rendered_content
 
-    if DJANGO_VERSION < (1, 7):
-        return
     import django.shortcuts
 
     real_render = django.shortcuts.render
@@ -100,8 +94,10 @@ def patch_templates():
             op=OP.TEMPLATE_RENDER,
             name=_get_template_name_description(template_name),
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         ) as span:
-            span.set_data("context", context)
+            for k, v in context.items():
+                span.set_attribute(f"context.{k}", v)
             return real_render(request, template_name, context, *args, **kwargs)
 
     django.shortcuts.render = render

sentry_sdk/integrations/django/transactions.py

@@ -19,12 +19,7 @@ if TYPE_CHECKING:
     from typing import Union
     from re import Pattern
 
-from django import VERSION as DJANGO_VERSION
-
-if DJANGO_VERSION >= (2, 0):
-    from django.urls.resolvers import RoutePattern
-else:
-    RoutePattern = None
+from django.urls.resolvers import RoutePattern
 
 try:
     from django.urls import get_resolver

sentry_sdk/integrations/django/views.py

@@ -31,12 +31,14 @@ def patch_views():
     old_make_view_atomic = BaseHandler.make_view_atomic
     old_render = SimpleTemplateResponse.render
 
+    @functools.wraps(old_render)
     def sentry_patched_render(self):
         # type: (SimpleTemplateResponse) -> Any
         with sentry_sdk.start_span(
             op=OP.VIEW_RESPONSE_RENDER,
             name="serialize response",
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         ):
             return old_render(self)
 
@@ -77,8 +79,8 @@ def _wrap_sync_view(callback):
     def sentry_wrapped_callback(request, *args, **kwargs):
         # type: (Any, *Any, **Any) -> Any
         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()
         # set the active thread id to the handler thread for sync views
@@ -90,6 +92,7 @@ def _wrap_sync_view(callback):
             op=OP.VIEW_RENDER,
             name=request.resolver_match.view_name,
             origin=DjangoIntegration.origin,
+            only_if_parent=True,
         ):
             return callback(request, *args, **kwargs)
 

sentry_sdk/integrations/falcon.py

@@ -1,8 +1,8 @@
 import sentry_sdk
+from sentry_sdk.consts import SOURCE_FOR_STYLE
 from sentry_sdk.integrations import _check_minimum_version, Integration, DidNotEnable
 from sentry_sdk.integrations._wsgi_common import RequestExtractor
 from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
-from sentry_sdk.tracing import SOURCE_FOR_STYLE
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     ensure_integration_enabled,
@@ -19,8 +19,6 @@ if TYPE_CHECKING:
 
     from sentry_sdk._types import Event, EventProcessor
 
-# In Falcon 3.0 `falcon.api_helpers` is renamed to `falcon.app_helpers`
-# and `falcon.API` to `falcon.App`
 
 try:
     import falcon  # type: ignore
@@ -29,24 +27,15 @@ try:
 except ImportError:
     raise DidNotEnable("Falcon not installed")
 
-try:
-    import falcon.app_helpers  # type: ignore
-
-    falcon_helpers = falcon.app_helpers
-    falcon_app_class = falcon.App
-    FALCON3 = True
-except ImportError:
-    import falcon.api_helpers  # type: ignore
+import falcon.app_helpers  # type: ignore
 
-    falcon_helpers = falcon.api_helpers
-    falcon_app_class = falcon.API
-    FALCON3 = False
+falcon_helpers = falcon.app_helpers
+falcon_app_class = falcon.App
 
 
 _FALCON_UNSET = None  # type: Optional[object]
-if FALCON3:  # falcon.request._UNSET is only available in Falcon 3.0+
-    with capture_internal_exceptions():
-        from falcon.request import _UNSET as _FALCON_UNSET  # type: ignore[import-not-found, no-redef]
+with capture_internal_exceptions():
+    from falcon.request import _UNSET as _FALCON_UNSET  # type: ignore[import-not-found, no-redef]
 
 
 class FalconRequestExtractor(RequestExtractor):
@@ -232,14 +221,7 @@ def _exception_leads_to_http_5xx(ex, response):
         ex, (falcon.HTTPError, falcon.http_status.HTTPStatus)
     )
 
-    # We only check the HTTP status on Falcon 3 because in Falcon 2, the status on the response
-    # at the stage where we capture it is listed as 200, even though we would expect to see a 500
-    # status. Since at the time of this change, Falcon 2 is ca. 4 years old, we have decided to
-    # only perform this check on Falcon 3+, despite the risk that some handled errors might be
-    # reported to Sentry as unhandled on Falcon 2.
-    return (is_server_error or is_unhandled_error) and (
-        not FALCON3 or _has_http_5xx_status(response)
-    )
+    return (is_server_error or is_unhandled_error) and _has_http_5xx_status(response)
 
 
 def _has_http_5xx_status(response):