MISP-665: made sdk compatible with Python 3.4

hlugtenburg · hlugtenburg · commit d3d4b6df3771 · 2020-02-11T17:10:43.000+01:00
diff --git a/sentry_sdk/integrations/aiohttp.py b/sentry_sdk/integrations/aiohttp.py
@@ -55,13 +55,16 @@ def setup_once():
 
         old_handle = Application._handle
 
-        async def sentry_app_handle(self, request, *args, **kwargs):
+        @asyncio.coroutine
+        def sentry_app_handle(self, request, *args, **kwargs):
             # type: (Any, Request, *Any, **Any) -> Any
-            async def inner():
+            @asyncio.coroutine
+            def inner():
                 # type: () -> Any
                 hub = Hub.current
                 if hub.get_integration(AioHttpIntegration) is None:
-                    return await old_handle(self, request, *args, **kwargs)
+                    old_handle_response =  yield from old_handle(self, request, *args, **kwargs)
+                    return old_handle_response
 
                 weak_request = weakref.ref(request)
 
@@ -78,7 +81,7 @@ async def inner():
 
                     with hub.start_span(span):
                         try:
-                            response = await old_handle(self, request)
+                            response = yield from old_handle(self, request)
                         except HTTPException as e:
                             span.set_http_status(e.status_code)
                             raise
@@ -96,15 +99,17 @@ async def inner():
             # Explicitly wrap in task such that current contextvar context is
             # copied. Just doing `return await inner()` will leak scope data
             # between requests.
-            return await asyncio.get_event_loop().create_task(inner())
+            event_loop_response =  yield from asyncio.get_event_loop().create_task(inner())
+            return event_loop_response
 
         Application._handle = sentry_app_handle
 
         old_urldispatcher_resolve = UrlDispatcher.resolve
 
-        async def sentry_urldispatcher_resolve(self, request):
+        @asyncio.coroutine
+        def sentry_urldispatcher_resolve(self, request):
             # type: (UrlDispatcher, Request) -> AbstractMatchInfo
-            rv = await old_urldispatcher_resolve(self, request)
+            rv = yield from old_urldispatcher_resolve(self, request)
 
             name = None
 
diff --git a/sentry_sdk/integrations/asgi.py b/sentry_sdk/integrations/asgi.py
@@ -70,20 +70,26 @@ def __init__(self, app):
 
     def _run_asgi2(self, scope):
         # type: (Any) -> Any
-        async def inner(receive, send):
+        @asyncio.coroutine
+        def inner(receive, send):
             # type: (Any, Any) -> Any
-            return await self._run_app(scope, lambda: self.app(scope)(receive, send))
+            response = yield from self._run_app(scope, lambda: self.app(scope)(receive, send))
+            return response
 
         return inner
 
-    async def _run_asgi3(self, scope, receive, send):
+    @asyncio.coroutine
+    def _run_asgi3(self, scope, receive, send):
         # type: (Any, Any, Any) -> Any
-        return await self._run_app(scope, lambda: self.app(scope, receive, send))
+        response = yield from self._run_app(scope, lambda: self.app(scope, receive, send))
+        return response
 
-    async def _run_app(self, scope, callback):
+    @asyncio.coroutine
+    def _run_app(self, scope, callback):
         # type: (Any, Any) -> Any
         if _asgi_middleware_applied.get(False):
-            return await callback()
+            response = yield from callback()
+            return response
 
         _asgi_middleware_applied.set(True)
         try:
@@ -112,7 +118,8 @@ async def _run_app(self, scope, callback):
                     # would have to wrap send(). That is a bit hard to do with
                     # the current abstraction over ASGI 2/3.
                     try:
-                        return await callback()
+                        response = yield from callback()
+                        return response
                     except Exception as exc:
                         _capture_exception(hub, exc)
                         raise exc from None
diff --git a/sentry_sdk/integrations/django/asgi.py b/sentry_sdk/integrations/django/asgi.py
@@ -12,6 +12,8 @@
 from sentry_sdk.integrations.django import DjangoIntegration
 from sentry_sdk.integrations.asgi import SentryAsgiMiddleware
 
+import asyncio
+
 if MYPY:
     from typing import Any
 
@@ -20,13 +22,14 @@ def patch_django_asgi_handler_impl(cls):
     # type: (Any) -> None
     old_app = cls.__call__
 
-    async def sentry_patched_asgi_handler(self, scope, receive, send):
+    @asyncio.coroutine
+    def sentry_patched_asgi_handler(self, scope, receive, send):
         # type: (Any, Any, Any, Any) -> Any
         if Hub.current.get_integration(DjangoIntegration) is None:
-            return await old_app(self, scope, receive, send)
+            yield from old_app(self, scope, receive, send)
 
         middleware = SentryAsgiMiddleware(old_app.__get__(self, cls))._run_asgi3
-        return await middleware(scope, receive, send)
+        yield from middleware(scope, receive, send)
 
     cls.__call__ = sentry_patched_asgi_handler
 
@@ -35,13 +38,14 @@ def patch_channels_asgi_handler_impl(cls):
     # type: (Any) -> None
     old_app = cls.__call__
 
-    async def sentry_patched_asgi_handler(self, receive, send):
+    @asyncio.coroutine
+    def sentry_patched_asgi_handler(self, receive, send):
         # type: (Any, Any, Any) -> Any
         if Hub.current.get_integration(DjangoIntegration) is None:
-            return await old_app(self, receive, send)
+            yield from old_app(self, receive, send)
 
         middleware = SentryAsgiMiddleware(lambda _scope: old_app.__get__(self, cls))
 
-        return await middleware(self.scope)(receive, send)
+        yield from middleware(self.scope)(receive, send)
 
     cls.__call__ = sentry_patched_asgi_handler
diff --git a/sentry_sdk/integrations/sanic.py b/sentry_sdk/integrations/sanic.py
@@ -20,6 +20,8 @@
 
 from sentry_sdk._types import MYPY
 
+import asyncio
+
 if MYPY:
     from typing import Any
     from typing import Callable
@@ -61,7 +63,8 @@ def setup_once():
 
         old_handle_request = Sanic.handle_request
 
-        async def sentry_handle_request(self, request, *args, **kwargs):
+        @asyncio.coroutine
+        def sentry_handle_request(self, request, *args, **kwargs):
             # type: (Any, Request, *Any, **Any) -> Any
             hub = Hub.current
             if hub.get_integration(SanicIntegration) is None:
@@ -76,7 +79,7 @@ async def sentry_handle_request(self, request, *args, **kwargs):
 
                 response = old_handle_request(self, request, *args, **kwargs)
                 if isawaitable(response):
-                    response = await response
+                    response = yield from response
 
                 return response
 
@@ -109,12 +112,13 @@ def sentry_error_handler_lookup(self, exception):
             if Hub.current.get_integration(SanicIntegration) is None:
                 return old_error_handler
 
-            async def sentry_wrapped_error_handler(request, exception):
+            @asyncio.coroutine
+            def sentry_wrapped_error_handler(request, exception):
                 # type: (Request, Exception) -> Any
                 try:
                     response = old_error_handler(request, exception)
                     if isawaitable(response):
-                        response = await response
+                        response = yield from response
                     return response
                 except Exception:
                     # Report errors that occur in Sanic error handler. These
diff --git a/sentry_sdk/integrations/tornado.py b/sentry_sdk/integrations/tornado.py
@@ -22,6 +22,8 @@
 
 from sentry_sdk._types import MYPY
 
+import asyncio
+
 if MYPY:
     from typing import Any
     from typing import Optional
@@ -59,20 +61,23 @@ def setup_once():
         if awaitable:
             # Starting Tornado 6 RequestHandler._execute method is a standard Python coroutine (async/await)
             # In that case our method should be a coroutine function too
-            async def sentry_execute_request_handler(self, *args, **kwargs):
+            @asyncio.coroutine
+            def sentry_execute_request_handler(self, *args, **kwargs):
                 # type: (Any, *Any, **Any) -> Any
                 hub = Hub.current
                 integration = hub.get_integration(TornadoIntegration)
                 if integration is None:
-                    return await old_execute(self, *args, **kwargs)
+                    result = yield from old_execute(self, *args, **kwargs)
+                    return result
 
                 weak_handler = weakref.ref(self)
 
                 with Hub(hub) as hub:
                     with hub.configure_scope() as scope:
                         scope.clear_breadcrumbs()
                         scope.add_event_processor(_make_event_processor(weak_handler))
-                    return await old_execute(self, *args, **kwargs)
+                    result = yield from old_execute(self, *args, **kwargs)
+                    return result
 
         else:
 
