ref(bottle): Use new scopes API (#2872)

Author: sentrivana

sentry_sdk/integrations/bottle.py

@@ -1,15 +1,16 @@
-from sentry_sdk.hub import Hub
+import sentry_sdk
 from sentry_sdk.tracing import SOURCE_FOR_STYLE
 from sentry_sdk.utils import (
     capture_internal_exceptions,
+    ensure_integration_enabled,
     event_from_exception,
     parse_version,
     transaction_from_function,
 )
 from sentry_sdk.integrations import Integration, DidNotEnable
 from sentry_sdk.integrations.wsgi import SentryWsgiMiddleware
 from sentry_sdk.integrations._wsgi_common import RequestExtractor
-
+from sentry_sdk.scope import Scope
 from sentry_sdk._types import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -55,7 +56,6 @@ def __init__(self, transaction_style="endpoint"):
     @staticmethod
     def setup_once():
         # type: () -> None
-
         version = parse_version(BOTTLE_VERSION)
 
         if version is None:
@@ -64,64 +64,46 @@ def setup_once():
         if version < (0, 12):
             raise DidNotEnable("Bottle 0.12 or newer required.")
 
-        # monkey patch method Bottle.__call__
         old_app = Bottle.__call__
 
+        @ensure_integration_enabled(BottleIntegration, old_app)
         def sentry_patched_wsgi_app(self, environ, start_response):
             # type: (Any, Dict[str, str], Callable[..., Any]) -> _ScopedResponse
-
-            hub = Hub.current
-            integration = hub.get_integration(BottleIntegration)
-            if integration is None:
-                return old_app(self, environ, start_response)
-
             return SentryWsgiMiddleware(lambda *a, **kw: old_app(self, *a, **kw))(
                 environ, start_response
             )
 
         Bottle.__call__ = sentry_patched_wsgi_app
 
-        # monkey patch method Bottle._handle
         old_handle = Bottle._handle
 
         def _patched_handle(self, environ):
             # type: (Bottle, Dict[str, Any]) -> Any
-            hub = Hub.current
-            integration = hub.get_integration(BottleIntegration)
+            integration = sentry_sdk.get_client().get_integration(BottleIntegration)
             if integration is None:
                 return old_handle(self, environ)
 
-            # create new scope
-            scope_manager = hub.push_scope()
-
-            with scope_manager:
-                app = self
-                with hub.configure_scope() as scope:
-                    scope._name = "bottle"
-                    scope.add_event_processor(
-                        _make_request_event_processor(app, bottle_request, integration)
-                    )
-                res = old_handle(self, environ)
+            scope = Scope.get_isolation_scope()
+            scope._name = "bottle"
+            scope.add_event_processor(
+                _make_request_event_processor(self, bottle_request, integration)
+            )
+            res = old_handle(self, environ)
 
-            # scope cleanup
             return res
 
         Bottle._handle = _patched_handle
 
-        # monkey patch method Route._make_callback
         old_make_callback = Route._make_callback
 
         def patched_make_callback(self, *args, **kwargs):
             # type: (Route, *object, **object) -> Any
-            hub = Hub.current
-            integration = hub.get_integration(BottleIntegration)
+            client = sentry_sdk.get_client()
+            integration = client.get_integration(BottleIntegration)
             prepared_callback = old_make_callback(self, *args, **kwargs)
             if integration is None:
                 return prepared_callback
 
-            # If an integration is there, a client has to be there.
-            client = hub.client  # type: Any
-
             def wrapped_callback(*args, **kwargs):
                 # type: (*object, **object) -> Any
 
@@ -135,7 +117,7 @@ def wrapped_callback(*args, **kwargs):
                         client_options=client.options,
                         mechanism={"type": "bottle", "handled": False},
                     )
-                    hub.capture_event(event, hint=hint)
+                    sentry_sdk.capture_event(event, hint=hint)
                     raise exception
 
                 return res