perf: check the bound event loop inline and call the guard only on a mismatch

Author: lesnik512

src/httpware/middleware/resilience/_event_loop_guard.py

@@ -11,24 +11,17 @@ def check_event_loop(
     loop_lock: threading.Lock,
     message_template: str,
 ) -> None:
-    """Bind the caller to the first event loop that calls it.
+    """Bind the caller to the running loop if it has none yet, else raise RuntimeError.
 
-    Raises RuntimeError on a later call from a different loop. `get_loop`/`set_loop`
-    read and write the caller's cached-loop attribute. The inner check re-reads via
-    `get_loop()` rather than reusing the outer snapshot, so a thread that loses the
-    race to acquire `loop_lock` still sees whichever loop the winner just bound
-    (double-checked locking) — the outer unlocked read handles the common
-    already-bound case without lock overhead.
+    The slow path of the caller's unlocked `self._loop is asyncio.get_running_loop()` check.
+    `get_loop`/`set_loop` read and write the caller's cached-loop attribute; the read under
+    `loop_lock` sees a loop that another thread bound after the caller's unlocked read.
     """
     current = asyncio.get_running_loop()
-    cached = get_loop()
-    if cached is current:
-        return
-    if cached is not None:
-        raise RuntimeError(message_template.format(first=cached, current=current))
     with loop_lock:
         cached = get_loop()
         if cached is None:
             set_loop(current)
-        elif cached is not current:
-            raise RuntimeError(message_template.format(first=cached, current=current))
+            return
+    if cached is not current:
+        raise RuntimeError(message_template.format(first=cached, current=current))

src/httpware/middleware/resilience/bulkhead.py

@@ -110,7 +110,8 @@ def _check_loop(self) -> None:
 
     async def __call__(self, request: httpx2.Request, next: AsyncNext) -> httpx2.Response:  # noqa: A002
         """Acquire a slot (bounded by acquire_timeout), invoke next, release."""
-        self._check_loop()
+        if self._loop is not asyncio.get_running_loop():
+            self._check_loop()
         try:
             if self._acquire_timeout is None or not self._sem.locked():
                 await self._sem.acquire()

src/httpware/middleware/resilience/circuit_breaker.py

@@ -564,7 +564,8 @@ def state(self) -> CircuitState:
 
     async def __call__(self, request: httpx2.Request, next: AsyncNext) -> httpx2.Response:  # noqa: A002
         """Admit, forward, then record the outcome. Fast-fail when the circuit is not closed."""
-        self._check_loop()
+        if self._loop is not asyncio.get_running_loop():
+            self._check_loop()
         return await _call_async(self._state, request, next)
 
 
@@ -659,7 +660,8 @@ def _check_loop(self) -> None:
 
     async def __call__(self, request: httpx2.Request, next: AsyncNext) -> httpx2.Response:  # noqa: A002
         """Pick the request's circuit, then admit, forward and record the outcome on it."""
-        self._check_loop()
+        if self._loop is not asyncio.get_running_loop():
+            self._check_loop()
         return await _call_async(self._states.get(request), request, next)
 
 

tests/test_event_loop_guard.py

@@ -8,12 +8,11 @@
 
 async def test_raises_when_another_loop_binds_between_unlocked_and_locked_read() -> None:
     other_loop = asyncio.new_event_loop()
-    reads = iter([None, other_loop])
     bound: list[asyncio.AbstractEventLoop] = []
     try:
         with pytest.raises(RuntimeError, match="bound to"):
             check_event_loop(
-                lambda: next(reads),
+                lambda: other_loop,
                 bound.append,
                 threading.Lock(),
                 "bound to {first}, called from {current}",