feat(starlette): add Starlette integration (#1441)

Adds integrations for Starlette and FastAPI. The majority of functionaly is in the Starlette integration. The FastAPI integration is just setting transaction names because those are handled differently in Starlette and FastAPI.

Author: sl0thentr0py

mypy.ini

@@ -63,3 +63,7 @@ disallow_untyped_defs = False
 ignore_missing_imports = True
 [mypy-flask.signals]
 ignore_missing_imports = True
+[mypy-starlette.*]
+ignore_missing_imports = True
+[mypy-fastapi.*]
+ignore_missing_imports = True

pytest.ini

@@ -3,7 +3,8 @@ DJANGO_SETTINGS_MODULE = tests.integrations.django.myapp.settings
 addopts = --tb=short
 markers =
     tests_internal_exceptions: Handle internal exceptions just as the SDK does, to test it. (Otherwise internal exceptions are recorded and reraised.)
-    only: A temporary marker, to make pytest only run the tests with the mark, similar to jest's `it.only`. To use, run `pytest -v -m only`.
+    only: A temporary marker, to make pytest only run the tests with the mark, similar to jests `it.only`. To use, run `pytest -v -m only`.
+asyncio_mode = strict
 
 [pytest-watch]
 ; Enable this to drop into pdb on errors

sentry_sdk/integrations/asgi.py

@@ -16,14 +16,13 @@
 from sentry_sdk.tracing import (
     SOURCE_FOR_STYLE,
     TRANSACTION_SOURCE_ROUTE,
-    TRANSACTION_SOURCE_UNKNOWN,
 )
 from sentry_sdk.utils import (
     ContextVar,
     event_from_exception,
-    transaction_from_function,
     HAS_REAL_CONTEXTVARS,
     CONTEXTVARS_ERROR_MESSAGE,
+    transaction_from_function,
 )
 from sentry_sdk.tracing import Transaction
 
@@ -45,15 +44,15 @@
 TRANSACTION_STYLE_VALUES = ("endpoint", "url")
 
 
-def _capture_exception(hub, exc):
-    # type: (Hub, Any) -> None
+def _capture_exception(hub, exc, mechanism_type="asgi"):
+    # type: (Hub, Any, str) -> None
 
     # Check client here as it might have been unset while streaming response
     if hub.client is not None:
         event, hint = event_from_exception(
             exc,
             client_options=hub.client.options,
-            mechanism={"type": "asgi", "handled": False},
+            mechanism={"type": mechanism_type, "handled": False},
         )
         hub.capture_event(event, hint=hint)
 
@@ -75,10 +74,16 @@ def _looks_like_asgi3(app):
 
 
 class SentryAsgiMiddleware:
-    __slots__ = ("app", "__call__", "transaction_style")
-
-    def __init__(self, app, unsafe_context_data=False, transaction_style="endpoint"):
-        # type: (Any, bool, str) -> None
+    __slots__ = ("app", "__call__", "transaction_style", "mechanism_type")
+
+    def __init__(
+        self,
+        app,
+        unsafe_context_data=False,
+        transaction_style="endpoint",
+        mechanism_type="asgi",
+    ):
+        # type: (Any, bool, str, str) -> None
         """
         Instrument an ASGI application with Sentry. Provides HTTP/websocket
         data to sent events and basic handling for exceptions bubbling up
@@ -100,6 +105,7 @@ def __init__(self, app, unsafe_context_data=False, transaction_style="endpoint")
                 % (transaction_style, TRANSACTION_STYLE_VALUES)
             )
         self.transaction_style = transaction_style
+        self.mechanism_type = mechanism_type
         self.app = app
 
         if _looks_like_asgi3(app):
@@ -127,7 +133,7 @@ async def _run_app(self, scope, callback):
             try:
                 return await callback()
             except Exception as exc:
-                _capture_exception(Hub.current, exc)
+                _capture_exception(Hub.current, exc, mechanism_type=self.mechanism_type)
                 raise exc from None
 
         _asgi_middleware_applied.set(True)
@@ -164,7 +170,9 @@ async def _run_app(self, scope, callback):
                         try:
                             return await callback()
                         except Exception as exc:
-                            _capture_exception(hub, exc)
+                            _capture_exception(
+                                hub, exc, mechanism_type=self.mechanism_type
+                            )
                             raise exc from None
         finally:
             _asgi_middleware_applied.set(False)
@@ -203,7 +211,6 @@ def event_processor(self, event, hint, asgi_scope):
 
     def _set_transaction_name_and_source(self, event, transaction_style, asgi_scope):
         # type: (Event, str, Any) -> None
-
         transaction_name_already_set = (
             event.get("transaction", _DEFAULT_TRANSACTION_NAME)
             != _DEFAULT_TRANSACTION_NAME
@@ -231,9 +238,8 @@ def _set_transaction_name_and_source(self, event, transaction_style, asgi_scope)
                     name = path
 
         if not name:
-            # If no transaction name can be found set an unknown source.
-            # This can happen when ASGI frameworks that are not yet supported well are used.
-            event["transaction_info"] = {"source": TRANSACTION_SOURCE_UNKNOWN}
+            event["transaction"] = _DEFAULT_TRANSACTION_NAME
+            event["transaction_info"] = {"source": TRANSACTION_SOURCE_ROUTE}
             return
 
         event["transaction"] = name

sentry_sdk/integrations/fastapi.py

@@ -0,0 +1,122 @@
+from sentry_sdk._types import MYPY
+from sentry_sdk.hub import Hub
+from sentry_sdk.integrations import DidNotEnable
+from sentry_sdk.integrations.starlette import (
+    SentryStarletteMiddleware,
+    StarletteIntegration,
+)
+from sentry_sdk.tracing import SOURCE_FOR_STYLE, TRANSACTION_SOURCE_ROUTE
+from sentry_sdk.utils import transaction_from_function
+
+if MYPY:
+    from typing import Any, Callable, Dict
+
+    from sentry_sdk._types import Event
+
+try:
+    from fastapi.applications import FastAPI
+    from fastapi.requests import Request
+except ImportError:
+    raise DidNotEnable("FastAPI is not installed")
+
+try:
+    from starlette.types import ASGIApp, Receive, Scope, Send
+except ImportError:
+    raise DidNotEnable("Starlette is not installed")
+
+
+_DEFAULT_TRANSACTION_NAME = "generic FastApi request"
+
+
+class FastApiIntegration(StarletteIntegration):
+    identifier = "fastapi"
+
+    @staticmethod
+    def setup_once():
+        # type: () -> None
+        StarletteIntegration.setup_once()
+        patch_middlewares()
+
+
+def patch_middlewares():
+    # type: () -> None
+
+    old_build_middleware_stack = FastAPI.build_middleware_stack
+
+    def _sentry_build_middleware_stack(self):
+        # type: (FastAPI) -> Callable[..., Any]
+        """
+        Adds `SentryStarletteMiddleware` and `SentryFastApiMiddleware` to the
+        middleware stack of the FastAPI application.
+        """
+        app = old_build_middleware_stack(self)
+        app = SentryStarletteMiddleware(app=app)
+        app = SentryFastApiMiddleware(app=app)
+        return app
+
+    FastAPI.build_middleware_stack = _sentry_build_middleware_stack
+
+
+def _set_transaction_name_and_source(event, transaction_style, request):
+    # type: (Event, str, Any) -> None
+    name = ""
+
+    if transaction_style == "endpoint":
+        endpoint = request.scope.get("endpoint")
+        if endpoint:
+            name = transaction_from_function(endpoint) or ""
+
+    elif transaction_style == "url":
+        route = request.scope.get("route")
+        if route:
+            path = getattr(route, "path", None)
+            if path is not None:
+                name = path
+
+    if not name:
+        event["transaction"] = _DEFAULT_TRANSACTION_NAME
+        event["transaction_info"] = {"source": TRANSACTION_SOURCE_ROUTE}
+        return
+
+    event["transaction"] = name
+    event["transaction_info"] = {"source": SOURCE_FOR_STYLE[transaction_style]}
+
+
+class SentryFastApiMiddleware:
+    def __init__(self, app, dispatch=None):
+        # type: (ASGIApp, Any) -> None
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        # type: (Scope, Receive, Send) -> Any
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        hub = Hub.current
+        integration = hub.get_integration(FastApiIntegration)
+        if integration is None:
+            return
+
+        with hub.configure_scope() as sentry_scope:
+            request = Request(scope, receive=receive, send=send)
+
+            def _make_request_event_processor(req, integration):
+                # type: (Any, Any) -> Callable[[Dict[str, Any], Dict[str, Any]], Dict[str, Any]]
+                def event_processor(event, hint):
+                    # type: (Dict[str, Any], Dict[str, Any]) -> Dict[str, Any]
+
+                    _set_transaction_name_and_source(
+                        event, integration.transaction_style, req
+                    )
+
+                    return event
+
+                return event_processor
+
+            sentry_scope._name = FastApiIntegration.identifier
+            sentry_scope.add_event_processor(
+                _make_request_event_processor(request, integration)
+            )
+
+            await self.app(scope, receive, send)