move failsafe hook tests to ASGI test suite

Author: outergod

instrumentation/opentelemetry-instrumentation-asgi/tests/test_asgi_middleware.py

@@ -277,6 +277,17 @@ async def error_asgi(scope, receive, send):
         await send({"type": "http.response.body", "body": b"*"})
 
 
+class UnhandledException(Exception):
+    pass
+
+
+def failing_hook(msg):
+    def hook(*_):
+        raise UnhandledException(msg)
+
+    return hook
+
+
 # pylint: disable=too-many-public-methods
 class TestAsgiApplication(AsyncAsgiTestBase):
     def setUp(self):
@@ -481,6 +492,12 @@ def validate_outputs(
                 span.instrumentation_scope.name,
                 "opentelemetry.instrumentation.asgi",
             )
+            if "events" in expected:
+                self.assertEqual(len(span.events), len(expected["events"]))
+                for event, expected in zip(span.events, expected["events"]):
+                    self.assertEqual(event.name, expected["name"])
+                    for k, v in expected["attributes"].items():
+                        self.assertEqual(event.attributes[k], v)
 
     async def test_basic_asgi_call(self):
         """Test that spans are emitted as expected."""
@@ -1206,6 +1223,40 @@ def update_expected_hook_results(expected):
             outputs, modifiers=[update_expected_hook_results]
         )
 
+    async def test_hook_exceptions(self):
+        def exception_event(msg):
+            return {
+                "name": "exception",
+                "attributes": {
+                    "exception.type": f"{__name__}.UnhandledException",
+                    "exception.message": msg,
+                },
+            }
+
+        def update_expected_hook_results(expected):
+            for entry in expected:
+                if entry["kind"] == trace_api.SpanKind.SERVER:
+                    entry["events"] = [exception_event("server request")]
+                elif entry["name"] == "GET / http receive":
+                    entry["events"] = [exception_event("client request")]
+                elif entry["name"] == "GET / http send":
+                    entry["events"] = [exception_event("client response")]
+
+            return expected
+
+        app = otel_asgi.OpenTelemetryMiddleware(
+            simple_asgi,
+            server_request_hook=failing_hook("server request"),
+            client_request_hook=failing_hook("client request"),
+            client_response_hook=failing_hook("client response"),
+        )
+        self.seed_app(app)
+        await self.send_default_request()
+        outputs = await self.get_all_output()
+        self.validate_outputs(
+            outputs, modifiers=[update_expected_hook_results]
+        )
+
     async def test_asgi_metrics(self):
         app = otel_asgi.OpenTelemetryMiddleware(simple_asgi)
         self.seed_app(app)

instrumentation/opentelemetry-instrumentation-fastapi/tests/test_fastapi_instrumentation.py

@@ -2014,59 +2014,3 @@ async def _(*_):
             event.attributes.get(EXCEPTION_TYPE),
             f"{__name__}.UnhandledException",
         )
-
-
-class TestFailsafeHooks(TestBase):
-    """Tests to ensure FastAPI instrumentation hooks don't tear through"""
-
-    def setUp(self):
-        super().setUp()
-
-        self.app = fastapi.FastAPI()
-
-        @self.app.get("/foobar")
-        async def _():
-            return {"message": "Hello World"}
-
-        def failing_hook(*_):
-            raise UnhandledException("Hook Exception")
-
-        otel_fastapi.FastAPIInstrumentor().instrument_app(
-            self.app,
-            server_request_hook=failing_hook,
-            client_request_hook=failing_hook,
-            client_response_hook=failing_hook,
-        )
-        self.client = TestClient(self.app)
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        with self.disable_logging():
-            otel_fastapi.FastAPIInstrumentor().uninstrument_app(self.app)
-
-    def test_failsafe_hooks(self):
-        """Crashing hooks must not tear through"""
-        resp = self.client.get(
-            "/foobar",
-        )
-
-        self.assertEqual(200, resp.status_code)
-
-    def test_failsafe_error_recording(self):
-        """Failing hooks must record the exception on the span"""
-        self.client.get(
-            "/foobar",
-        )
-
-        spans = self.memory_exporter.get_finished_spans()
-
-        self.assertEqual(len(spans), 3)
-        span = spans[0]
-        self.assertEqual(len(span.events), 1)
-        event = span.events[0]
-        self.assertEqual(event.name, "exception")
-        assert event.attributes is not None
-        self.assertEqual(
-            event.attributes.get(EXCEPTION_TYPE),
-            f"{__name__}.UnhandledException",
-        )