Plumb raw_message through cursor classifier; match no-tx on raw text; addr-suffix continuation failures; correct truncation marker unit

Five cycle-21 raw_message-pipeline follow-ups:

- ``_call_client``'s six non-OperationalError classifier arms
  (DqliteConnectionError, ClusterPolicyError, ClusterError,
  ProtocolError, DataError, InterfaceError catch-all) all dropped
  ``raw_message`` when wrapping into the dbapi exception. The
  cycle-21 cursor commit only plumbed it through the
  client.OperationalError → dbapi exception arm. Plumb on every
  arm via ``getattr(e, "raw_message", None) or str(e)`` so callers
  reading the un-truncated diagnostic don't need to walk
  ``__cause__`` based on which exception class the server emitted.

- ``_is_no_tx_rollback_error`` (client) and
  ``_is_no_transaction_error`` (dbapi) matched against ``str(exc)``
  which is truncated to ~1 KiB. A long server message that has
  the no-tx clause beyond the cap missed the substring and
  surfaced the no-tx as a real error. Match against
  ``raw_message`` instead.

- ``DqliteProtocol._read_continuation``'s ServerFailure-mid-stream
  arm raised ``OperationalError`` without the addr suffix, alone
  among the eight ``raise OperationalError`` sites in the file.
  Append it for log-correlation parity.

- ``OperationalError.message``'s truncation marker said "bytes" but
  ``len(message)`` and the slice cap are codepoints. An operator
  reading the marker now sees "codepoints" — the actual unit.

- Connect-time wrap double-prefixed ``raw_message`` with
  ``"Failed to connect: "``. Cycle 21 introduced ``raw_message`` as
  the verbatim-server-text contract; the prefix belongs on the
  user-facing ``message`` only.

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

Author: antoineleclair

src/dqliteclient/connection.py

@@ -604,7 +604,14 @@ def _is_no_tx_rollback_error(exc: BaseException) -> bool:
     code = getattr(exc, "code", None)
     if code is None or _primary_sqlite_code(code) != 1:  # SQLITE_ERROR
         return False
-    msg = str(exc).lower()
+    # Match against the un-truncated server text (raw_message) rather
+    # than ``str(exc)`` (truncated to _MAX_DISPLAY_MESSAGE codepoints).
+    # A long server message that has the no-tx clause beyond the
+    # truncation cap would otherwise miss the substring and fail to
+    # silent-swallow. Mirrors the BUSY-checkpoint matcher fix that
+    # established the discipline.
+    raw = getattr(exc, "raw_message", None) or str(exc)
+    msg = raw.lower()
     return any(s in msg for s in NO_TRANSACTION_MESSAGE_SUBSTRINGS)
 
 

src/dqliteclient/exceptions.py

@@ -93,9 +93,13 @@ def __init__(self, code: int, message: str) -> None:
         self.code = code
         self.raw_message = message
         if len(message) > self._MAX_DISPLAY_MESSAGE:
+            # ``len(message)`` and the slice cap count Python codepoints,
+            # not UTF-8 bytes. Match the unit in the marker so an
+            # operator inspecting a truncated message can compute the
+            # original size without converting between units.
             overflow = len(message) - self._MAX_DISPLAY_MESSAGE
             self.message = (
-                f"{message[: self._MAX_DISPLAY_MESSAGE]}... [truncated, {overflow} bytes]"
+                f"{message[: self._MAX_DISPLAY_MESSAGE]}... [truncated, {overflow} codepoints]"
             )
         else:
             self.message = message

src/dqliteclient/protocol.py

@@ -768,7 +768,10 @@ async def _read_continuation(self, deadline: float | None = None) -> RowsRespons
             # Server-authored failure mid-stream: surface the SQLite code
             # so sqlalchemy's is_disconnect and dbapi's code-to-exception
             # map can classify correctly (leader flip, constraint, etc.).
-            raise OperationalError(e.code, e.message) from e
+            # Append the addr suffix so the operator log shows which
+            # peer emitted the failure — matching the eight sibling
+            # ``raise OperationalError`` sites in this module.
+            raise OperationalError(e.code, f"{e.message}{self._addr_suffix()}") from e
         except _WireProtocolError as e:
             raise ProtocolError(f"Wire decode failed{self._addr_suffix()}: {e}") from e