fix: handling no sentry-sdk installed corner case

Author: stas

fastapi_jsonrpc/__init__.py

@@ -14,7 +14,6 @@
 from fastapi.dependencies.utils import _should_embed_body_fields  # noqa
 from fastapi.openapi.constants import REF_PREFIX
 
-
 from fastapi._compat import ModelField, Undefined  # noqa
 from fastapi.dependencies.models import Dependant
 from fastapi.encoders import jsonable_encoder
@@ -36,41 +35,55 @@
 
 logger = logging.getLogger(__name__)
 
-
-try:
-    import sentry_sdk
-    import sentry_sdk.tracing
-    from sentry_sdk.utils import transaction_from_function as sentry_transaction_from_function
-except ImportError:
-    sentry_sdk = None
-    sentry_transaction_from_function = None
-
 try:
     from fastapi._compat import _normalize_errors  # noqa
 except ImportError:
     def _normalize_errors(errors: Sequence[Any]) -> List[Dict[str, Any]]:
         return errors
+try:
+    import sentry_sdk
+    import sentry_sdk.tracing
+    from sentry_sdk.utils import transaction_from_function as sentry_transaction_from_function
 
-if hasattr(sentry_sdk, 'new_scope'):
-    # sentry_sdk 2.x
-    sentry_new_scope = sentry_sdk.new_scope
-
-    def get_sentry_integration():
-        return sentry_sdk.get_client().get_integration(
-            "FastApiJsonRPCIntegration"
-        )
-else:
-    # sentry_sdk 1.x
-    @contextmanager
-    def sentry_new_scope():
-        hub = sentry_sdk.Hub.current
-        with sentry_sdk.Hub(hub) as hub:
-            with hub.configure_scope() as scope:
+    if hasattr(sentry_sdk, 'new_scope'):
+        # sentry_sdk 2.x
+        @contextmanager
+        def _handle_disabled_sentry_integration(self: "JsonRpcContext"):
+            with sentry_sdk.new_scope() as scope:
+                scope.clear_breadcrumbs()
+                scope.add_event_processor(self._make_sentry_event_processor())
                 yield scope
 
-    get_sentry_integration = lambda : None
+
+        def get_sentry_integration():
+            return sentry_sdk.get_client().get_integration(
+                "FastApiJsonRPCIntegration"
+            )
+    else:
+        # sentry_sdk 1.x
+        @contextmanager
+        def _handle_disabled_sentry_integration(self: "JsonRpcContext"):
+            hub = sentry_sdk.Hub.current
+            with sentry_sdk.Hub(hub) as hub:
+                with hub.configure_scope() as scope:
+                    scope.clear_breadcrumbs()
+                    scope.add_event_processor(self._make_sentry_event_processor())
+                    yield scope
+
+
+        get_sentry_integration = lambda: None
+
+except ImportError:
+    # no sentry installed
+    sentry_sdk = None
+    sentry_transaction_from_function = None
+    get_sentry_integration = lambda: None
 
 
+    @asynccontextmanager
+    def _handle_disabled_sentry_integration(self: "JsonRpcContext"):
+        yield None
+
 class Params(fastapi.params.Body):
     def __init__(
         self,
@@ -650,25 +663,19 @@ async def _handle_exception(self, reraise=True):
 
     @contextmanager
     def _enter_sentry_scope(self):
-        if get_sentry_integration() is not None:
+        integration_is_active = get_sentry_integration() is not None
+        # we do not need to use sentry fallback if `sentry-sdk`is not installed or integration is enabled explicitly
+        if integration_is_active or sentry_sdk is None:
             yield
             return
 
+
         warnings.warn(
             "Implicit Sentry integration is deprecated and may be removed in a future major release. "
             "To ensure compatibility, use sentry-sdk 2.* and explicit integration:"
             "`from fastapi_jsonrpc.contrib.sentry import FastApiJsonRPCIntegration`. "
         )
-        with sentry_new_scope() as scope:
-            # Actually we can use set_transaction_name
-            #             scope.set_transaction_name(
-            #                 sentry_transaction_from_function(method_route.func),
-            #                 source=sentry_sdk.tracing.TRANSACTION_SOURCE_CUSTOM,
-            #             )
-            # and we need `method_route` instance for that,
-            # but method_route is optional and is harder to track it than adding event processor
-            scope.clear_breadcrumbs()
-            scope.add_event_processor(self._make_sentry_event_processor())
+        with _handle_disabled_sentry_integration(self) as scope:
             yield scope
 
     def _make_sentry_event_processor(self):

tests/sentry/conftest.py

@@ -80,11 +80,6 @@ def capture_event_scope(self, event, hint=None, scope=None):
 @pytest.fixture
 def sentry_init(request):
     def inner(*a, **kw):
-        kw.setdefault("transport", TestTransport())
-        kw.setdefault("integrations", [FastApiJsonRPCIntegration()])
-        kw.setdefault("traces_sample_rate", 1.0)
-        kw.setdefault("disabled_integrations", [StarletteIntegration, FastApiIntegration])
-
         client = sentry_sdk.Client(*a, **kw)
         sentry_sdk.get_global_scope().set_client(client)
 
@@ -102,6 +97,22 @@ def inner(*a, **kw):
             sentry_sdk.get_global_scope().set_client(old_client)
 
 
+@pytest.fixture
+def sentry_with_integration(sentry_init):
+    kw = {
+        "transport": TestTransport(),
+        "integrations": [FastApiJsonRPCIntegration()],
+        "traces_sample_rate": 1.0,
+        "disabled_integrations": [StarletteIntegration, FastApiIntegration],
+    }
+    sentry_init(**kw)
+
+
+@pytest.fixture
+def sentry_no_integration(sentry_init):
+    sentry_init()
+
+
 class TestTransport(Transport):
     def capture_envelope(self, _: Envelope) -> None:
         """

tests/sentry/test_sentry_sdk_1x.py

@@ -41,23 +41,24 @@ def test_transaction_is_jsonrpc_method(
     exceptions = capture_exceptions()
     events = capture_events()
 
-    # Test in batch to ensure we correctly handle multiple requests
-    json_request(
-        [
-            {
-                "id": 1,
-                "jsonrpc": "2.0",
-                "method": "probe",
-                "params": {},
-            },
-            {
-                "id": 2,
-                "jsonrpc": "2.0",
-                "method": "probe2",
-                "params": {},
-            },
-        ]
-    )
+    with pytest.warns(UserWarning, match="Implicit Sentry integration is deprecated"):
+        # Test in batch to ensure we correctly handle multiple requests
+        json_request(
+            [
+                {
+                    "id": 1,
+                    "jsonrpc": "2.0",
+                    "method": "probe",
+                    "params": {},
+                },
+                {
+                    "id": 2,
+                    "jsonrpc": "2.0",
+                    "method": "probe2",
+                    "params": {},
+                },
+            ]
+        )
 
     assert {type(e) for e in exceptions} == {RuntimeError, ZeroDivisionError}
 

tests/sentry/test_sentry_sdk_2x.py

@@ -45,10 +45,9 @@ async def successful_method():
 
 
 def test_exception_logger_event_creation(
-    json_request, capture_exceptions, capture_events, capture_envelopes, failing_router, sentry_init,
-    assert_log_errors,
+        json_request, capture_exceptions, capture_events, capture_envelopes, failing_router, sentry_with_integration,
+        assert_log_errors,
 ):
-    sentry_init()
     exceptions = capture_exceptions()
     envelops = capture_envelopes()
     json_request(
@@ -67,10 +66,9 @@ def test_exception_logger_event_creation(
 
 
 def test_unhandled_exception_capturing(
-    json_request, capture_exceptions, capture_events, capture_envelopes, failing_router, assert_log_errors,
-    sentry_init
+        json_request, capture_exceptions, capture_events, capture_envelopes, failing_router, assert_log_errors,
+        sentry_with_integration
 ):
-    sentry_init()
     exceptions = capture_exceptions()
     envelops = capture_envelopes()
     json_request({"jsonrpc": "2.0", "method": "unhandled_error_method", "params": {}, "id": 1})
@@ -109,10 +107,9 @@ def test_unhandled_exception_capturing(
     ],
 )
 def test_trace_id_propagation(
-    request_payload, json_request, capture_exceptions, capture_events, capture_envelopes, failing_router,
-    assert_log_errors, sentry_init
+        request_payload, json_request, capture_exceptions, capture_events, capture_envelopes, failing_router,
+        assert_log_errors, sentry_with_integration
 ):
-    sentry_init()
     envelops = capture_envelopes()
     expected_trace_id = uuid.uuid4().hex
     incoming_transaction = Transaction(trace_id=expected_trace_id)
@@ -129,3 +126,10 @@ def test_trace_id_propagation(
         'First route exc', pytest.raises(ValueError),
         'Third route exc', pytest.raises(RuntimeError),
     )
+
+
+def test_no_integration_warning_message(json_request, sentry_no_integration):
+    with pytest.warns(UserWarning, match="Implicit Sentry integration is deprecated"):
+        json_request(
+            {"jsonrpc": "2.0", "method": "successful_method", "params": {}, "id": 1}
+        )