tentantive fix

Author: sentrivana

sentry_sdk/integrations/grpc/aio/server.py

@@ -25,7 +25,7 @@ def __init__(
         self: "ServerInterceptor",
         find_name: "Callable[[ServicerContext], str] | None" = None,
     ) -> None:
-        self._find_method_name = find_name or self._find_name
+        self._custom_find_name = find_name
 
         super().__init__()
 
@@ -34,17 +34,21 @@ async def intercept_service(
         continuation: "Callable[[HandlerCallDetails], Awaitable[RpcMethodHandler]]",
         handler_call_details: "HandlerCallDetails",
     ) -> "Optional[Awaitable[RpcMethodHandler]]":
-        self._handler_call_details = handler_call_details
         handler = await continuation(handler_call_details)
         if handler is None:
             return None
 
+        method_name = handler_call_details.method
+        custom_find_name = self._custom_find_name
+
         if not handler.request_streaming and not handler.response_streaming:
             handler_factory = grpc.unary_unary_rpc_method_handler
 
             async def wrapped(request: "Any", context: "ServicerContext") -> "Any":
                 with sentry_sdk.isolation_scope():
-                    name = self._find_method_name(context)
+                    name = (
+                        custom_find_name(context) if custom_find_name else method_name
+                    )
                     if not name:
                         return await handler(request, context)
 
@@ -96,6 +100,3 @@ async def wrapped(request: "Any", context: "ServicerContext") -> "Any":  # type:
             request_deserializer=handler.request_deserializer,
             response_serializer=handler.response_serializer,
         )
-
-    def _find_name(self, context: "ServicerContext") -> str:
-        return self._handler_call_details.method

tests/integrations/grpc/test_grpc_aio.py

@@ -268,6 +268,83 @@ async def test_stream_unary(grpc_server_and_channel):
     assert response.text == "test"
 
 
+@pytest.mark.asyncio
+async def test_concurrent_requests_do_not_leak_method_name(sentry_init, capture_events):
+    """
+    Regression test for SDK-1184: the async ServerInterceptor must not stash
+    request-specific state on the shared interceptor instance, otherwise
+    concurrent requests can overwrite each other's method names.
+    """
+    from sentry_sdk.integrations.grpc.aio.server import ServerInterceptor
+
+    sentry_init(traces_sample_rate=1.0, integrations=[GRPCIntegration()])
+    events = capture_events()
+
+    interceptor = ServerInterceptor()
+
+    request_a_can_finish = asyncio.Event()
+    request_a_started = asyncio.Event()
+
+    async def handler_a(request, context):
+        request_a_started.set()
+        await request_a_can_finish.wait()
+        return "a-response"
+
+    async def handler_b(request, context):
+        return "b-response"
+
+    def make_handler(behavior):
+        h = type(
+            "H",
+            (),
+            {
+                "request_streaming": False,
+                "response_streaming": False,
+                "unary_unary": behavior,
+                "request_deserializer": None,
+                "response_serializer": None,
+            },
+        )()
+        return h
+
+    class FakeHandlerCallDetails:
+        def __init__(self, method):
+            self.method = method
+
+    class FakeContext:
+        def invocation_metadata(self):
+            return ()
+
+    async def continuation_a(_):
+        return make_handler(handler_a)
+
+    async def continuation_b(_):
+        return make_handler(handler_b)
+
+    wrapped_a_handler = await interceptor.intercept_service(
+        continuation_a, FakeHandlerCallDetails("/svc/MethodA")
+    )
+    # Kick off request A; it parks inside the handler awaiting the event.
+    task_a = asyncio.create_task(
+        wrapped_a_handler.unary_unary(None, FakeContext())  # type: ignore[attr-defined]
+    )
+    await request_a_started.wait()
+
+    # While A is parked, intercept B. Pre-fix this overwrote shared state on
+    # the interceptor and A would later read B's method name.
+    wrapped_b_handler = await interceptor.intercept_service(
+        continuation_b, FakeHandlerCallDetails("/svc/MethodB")
+    )
+    await wrapped_b_handler.unary_unary(None, FakeContext())  # type: ignore[attr-defined]
+
+    request_a_can_finish.set()
+    await task_a
+
+    transactions = [e for e in events if e.get("type") == "transaction"]
+    names = sorted(t["transaction"] for t in transactions)
+    assert names == ["/svc/MethodA", "/svc/MethodB"]
+
+
 @pytest.mark.asyncio
 async def test_span_origin(grpc_server_and_channel, capture_events_forksafe):
     _, channel = grpc_server_and_channel