Absorb RuntimeError from shielded close so user's exception propagates

acquire()'s broken-conn cleanup wraps the underlying close in
asyncio.shield. The inner except only catches OSError /
DqliteConnectionError. A RuntimeError from inside the close — most
commonly "Event loop is closed" during a racing engine.dispose() —
would propagate out and SUPPLANT the user's original exception
(preserved only on __context__).

Add a narrow except RuntimeError that logs-and-absorbs. The bare
``raise`` further out then re-raises the user's original exception
unchanged. Narrow to RuntimeError specifically so programming bugs
(AttributeError, TypeError, etc.) still surface per done/ISSUE-198.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: antoineleclair

src/dqliteclient/pool.py

@@ -786,6 +786,23 @@ async def acquire(self) -> AsyncIterator[DqliteConnection]:
                                 getattr(conn, "_address", "?"),
                                 exc_info=True,
                             )
+                        except RuntimeError:
+                            # ``RuntimeError`` from inside the shielded
+                            # close — typically ``"Event loop is closed"``
+                            # during a racing ``engine.dispose()`` — would
+                            # otherwise propagate out and SUPPLANT the
+                            # user's original exception (preserved only
+                            # via ``__context__``). Log it and absorb so
+                            # the bare ``raise`` further out re-raises
+                            # the user's original error. Narrow to
+                            # ``RuntimeError`` so programming bugs
+                            # (``AttributeError``, ``TypeError``, etc.)
+                            # still surface — see done/ISSUE-198.
+                            logger.debug(
+                                "pool.acquire cleanup: conn.close(%r) raised RuntimeError",
+                                getattr(conn, "_address", "?"),
+                                exc_info=True,
+                            )
                     finally:
                         # Always set ``_pool_released`` so a subsequent
                         # close() short-circuits and the slot accounting

tests/test_pool_acquire_close_shielded_on_cancel.py

@@ -108,21 +108,26 @@ async def fake_drain_idle() -> None:
 async def test_acquire_cleanup_close_failure_still_sets_pool_released() -> None:
     """If ``conn.close()`` raises an unhandled exception (not
     OSError/DqliteConnectionError), the inner ``finally`` must still
-    set ``_pool_released=True`` so subsequent close() short-circuits."""
+    set ``_pool_released=True`` so subsequent close() short-circuits.
+
+    Also pin: the user's ORIGINAL ValueError must propagate — the
+    close-time RuntimeError must NOT supplant it. The widened
+    ``except Exception`` log-and-absorb pattern preserves the user's
+    exception for the bare ``raise`` further out."""
     pool, conn = await _build_pool_with_breakable_conn()
 
     async def fake_close() -> None:
         # Simulate an unrecognised close failure (not OSError /
-        # DqliteConnectionError). Must propagate, but the finally
-        # still flips _pool_released.
-        raise RuntimeError("unexpected close failure")
+        # DqliteConnectionError). Must NOT supplant the user's
+        # original exception.
+        raise RuntimeError("simulated close-time RuntimeError")
 
     async def fake_drain_idle() -> None:
         return
 
     pool._drain_idle = fake_drain_idle
 
-    with patch.object(conn, "close", new=fake_close), pytest.raises((ValueError, RuntimeError)):
+    with patch.object(conn, "close", new=fake_close), pytest.raises(ValueError, match="user"):
         async with pool.acquire():
             _break_conn(conn)
             raise ValueError("user code error")