Log rollback failure in AsyncAdaptedConnection.close

The narrow ``contextlib.suppress`` used to swallow the categories a
best-effort rollback can legitimately raise (OperationalError,
InterfaceError, DqliteConnectionError, OSError, TimeoutError,
ConnectionError). That kept programming bugs surfacing, but also
hid the suppressed rollback failures from operators — a
SQLAlchemy-pooled connection returning during a leader flip left
no log breadcrumb for the dangling server-side transaction.

Replace with a try/except/DEBUG-log-before-continuing, matching the
ISSUE-255/257 precedent. The narrow exception tuple is preserved.

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

Author: antoineleclair

src/sqlalchemydqlite/aio.py

@@ -1,6 +1,7 @@
 """Async dqlite dialect for SQLAlchemy."""
 
 import contextlib
+import logging
 import types
 from collections import deque
 from collections.abc import Iterable, Iterator, Sequence
@@ -15,6 +16,8 @@
 from dqlitedbapi.exceptions import InterfaceError, NotSupportedError, OperationalError
 from sqlalchemydqlite.base import DqliteDialect
 
+logger = logging.getLogger(__name__)
+
 if TYPE_CHECKING:
     from dqlitedbapi.aio import AsyncConnection
 
@@ -228,15 +231,24 @@ def close(self) -> None:
         # so programming bugs (AttributeError, TypeError, bare RuntimeError,
         # etc.) still propagate. The tuple mirrors the client layer's own
         # is_disconnect classification in base.py.
-        with contextlib.suppress(
+        try:
+            await_only(self._connection.rollback())
+        except (
             OperationalError,
             InterfaceError,
             DqliteConnectionError,
             OSError,
             TimeoutError,
             ConnectionError,
-        ):
-            await_only(self._connection.rollback())
+        ) as exc:
+            # Silent suppression used to hide e.g. "leader flip
+            # mid-rollback" from operators — a DEBUG line preserves the
+            # diagnostic without masking or propagating.
+            logger.debug(
+                "AsyncAdaptedConnection.close: rollback failed (%s); proceeding to close",
+                type(exc).__name__,
+                exc_info=True,
+            )
         await_only(self._connection.close())
 
 

tests/test_aio_close_rollback_log.py

@@ -0,0 +1,121 @@
+"""Pin the DEBUG-log breadcrumb on AsyncAdaptedConnection.close.
+
+The narrow ``contextlib.suppress`` used to hide failed rollbacks
+(leader flip, transport timeout, etc.) silently. Replace with a
+try/except that DEBUG-logs before continuing to the close. Programming
+bugs (AttributeError, RuntimeError, etc.) still propagate.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import pytest
+
+from dqliteclient.exceptions import DqliteConnectionError
+from dqlitedbapi.exceptions import OperationalError
+from sqlalchemydqlite.aio import AsyncAdaptedConnection
+
+
+class _FakeAsyncConn:
+    """A synchronous stand-in: sqlalchemy.util.await_only accepts a plain
+    callable's return when the adapter is driven by greenlet glue. For
+    testing we short-circuit to a sync method and let ``await_only``
+    see the already-complete coroutine-ish value.
+    """
+
+    def __init__(self, rollback_exc: BaseException | None) -> None:
+        self._rollback_exc = rollback_exc
+        self.close_calls = 0
+
+    async def rollback(self) -> None:
+        if self._rollback_exc is not None:
+            raise self._rollback_exc
+
+    async def close(self) -> None:
+        self.close_calls += 1
+
+
+def test_close_logs_rollback_failure(caplog: pytest.LogCaptureFixture) -> None:
+    fake = _FakeAsyncConn(OperationalError("server gone"))
+    adapter = AsyncAdaptedConnection(fake)  # type: ignore[arg-type]
+
+    # sqlalchemy.util.await_only drives the coroutine; using a live
+    # engine is overkill for an observability test. Stub await_only.
+    from sqlalchemydqlite import aio as aio_module
+
+    def _fake_await_only(coro: object) -> object:
+        # ``coro`` is a coroutine object; run it synchronously via send.
+        import asyncio
+
+        return asyncio.new_event_loop().run_until_complete(coro)  # type: ignore[arg-type]
+
+    orig = aio_module.await_only
+    aio_module.await_only = _fake_await_only  # type: ignore[assignment]
+    try:
+        with caplog.at_level(logging.DEBUG, logger="sqlalchemydqlite.aio"):
+            adapter.close()
+    finally:
+        aio_module.await_only = orig  # type: ignore[assignment]
+
+    matching = [
+        r
+        for r in caplog.records
+        if r.levelno == logging.DEBUG and "rollback failed" in r.getMessage()
+    ]
+    assert matching, f"expected DEBUG 'rollback failed' record; got {caplog.records!r}"
+    assert matching[0].exc_info is not None
+    assert isinstance(matching[0].exc_info[1], OperationalError)
+    assert fake.close_calls == 1  # close still ran
+
+
+def test_close_propagates_programming_bug() -> None:
+    """RuntimeError / AttributeError / etc. are NOT suppressed."""
+    fake = _FakeAsyncConn(RuntimeError("programming bug"))
+    adapter = AsyncAdaptedConnection(fake)  # type: ignore[arg-type]
+
+    from sqlalchemydqlite import aio as aio_module
+
+    def _fake_await_only(coro: object) -> object:
+        import asyncio
+
+        return asyncio.new_event_loop().run_until_complete(coro)  # type: ignore[arg-type]
+
+    orig = aio_module.await_only
+    aio_module.await_only = _fake_await_only  # type: ignore[assignment]
+    try:
+        with pytest.raises(RuntimeError, match="programming bug"):
+            adapter.close()
+    finally:
+        aio_module.await_only = orig  # type: ignore[assignment]
+
+
+def test_close_with_also_failing_transport_errors(caplog: pytest.LogCaptureFixture) -> None:
+    """The full category tuple (OSError, TimeoutError, ConnectionError, etc.)
+    is all caught and DEBUG-logged.
+    """
+    fake = _FakeAsyncConn(DqliteConnectionError("peer reset"))
+    adapter = AsyncAdaptedConnection(fake)  # type: ignore[arg-type]
+
+    from sqlalchemydqlite import aio as aio_module
+
+    def _fake_await_only(coro: object) -> object:
+        import asyncio
+
+        return asyncio.new_event_loop().run_until_complete(coro)  # type: ignore[arg-type]
+
+    orig = aio_module.await_only
+    aio_module.await_only = _fake_await_only  # type: ignore[assignment]
+    try:
+        with caplog.at_level(logging.DEBUG, logger="sqlalchemydqlite.aio"):
+            adapter.close()
+    finally:
+        aio_module.await_only = orig  # type: ignore[assignment]
+
+    matching = [
+        r
+        for r in caplog.records
+        if r.levelno == logging.DEBUG and "rollback failed" in r.getMessage()
+    ]
+    assert matching
+    assert fake.close_calls == 1