velocity-python 0.1.79__tar.gz → 0.1.80__tar.gz

{velocity_python-0.1.79 → velocity_python-0.1.80}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.79
+Version: 0.1.80
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.79 → velocity_python-0.1.80}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.1.79"
+version = "0.1.80"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.1.79 → velocity_python-0.1.80}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.79"
+__version__ = version = "0.1.80"
 
 import importlib as _importlib
 

{velocity_python-0.1.79 → velocity_python-0.1.80}/src/velocity/aws/handlers/mixins/web_handler.py

@@ -522,8 +522,40 @@ Request Details:
         self.track_activity_start(tx, context)
 
     def _enhanced_after_action(self, tx, context):
-        """Enhanced afterAction that adds activity tracking"""
-        self.track_activity_success(tx, context)
+        """Enhanced afterAction that adds activity tracking.
+
+        Activity tracking is bookkeeping — it must never convert a completed
+        action into a 500. Two guards:
+
+        * If the transaction is already aborted, the action caught a DB error and
+          returned a "success" response WITHOUT rolling back to a savepoint. The
+          tracking UPDATE would then fail at ``SAVEPOINT`` with "current
+          transaction is aborted", masking the real error (prod incident
+          2026-07-01). Skip the write and log loudly — the swallow-without-
+          savepoint is the actual bug; wrap the fallible statement in
+          ``with tx.savepoint():``.
+        * Any other failure of the tracking write is caught and logged rather than
+          propagated, so bookkeeping can't fail an otherwise-successful request.
+        """
+        try:
+            if getattr(tx, "is_aborted", None) and tx.is_aborted():
+                logger.error(
+                    "Skipping success activity tracking: transaction is aborted "
+                    "after a 'successful' action (action=%s handler=%s). An earlier "
+                    "DB error was caught without rolling back to a savepoint — wrap "
+                    "the fallible statement in `with tx.savepoint():`.",
+                    context.action(),
+                    self.__class__.__name__,
+                )
+            else:
+                self.track_activity_success(tx, context)
+        except Exception:
+            logger.exception(
+                "Success activity tracking failed (action=%s handler=%s); "
+                "continuing without it.",
+                context.action(),
+                self.__class__.__name__,
+            )
         if self._perf_timing_enabled:
             elapsed_ms = context.perf.log("web_handler action total")
             if elapsed_ms is not None:

{velocity_python-0.1.79 → velocity_python-0.1.80}/src/velocity/db/core/transaction.py

@@ -577,6 +577,40 @@ class Transaction:
             # Transaction is clean again — no uncommitted work pending.
             self._in_progress = False
 
+    def is_aborted(self):
+        """Return True if the connection is in a failed/aborted transaction.
+
+        After a statement errors on PostgreSQL, the whole transaction is poisoned:
+        every subsequent statement — *including* ``SAVEPOINT`` — fails with
+        "current transaction is aborted, commands ignored until end of transaction
+        block" until a ``ROLLBACK`` (or rollback to a savepoint taken *before* the
+        error). Because even ``SAVEPOINT`` fails in this state, a ``tx.savepoint()``
+        wrapper cannot rescue an already-poisoned transaction — callers that want to
+        run bookkeeping after a fallible step should check this first and skip (and
+        fix the swallow-without-savepoint upstream).
+
+        Best-effort and driver-specific: returns False when it cannot be determined
+        (no open connection, or a driver without a transaction-status concept). For
+        psycopg (v2/v3) this maps to libpq ``PQTRANS_INERROR`` (numeric 3).
+        """
+        conn = self.connection
+        if conn is None:
+            return False
+        try:
+            status = conn.info.transaction_status
+        except Exception:
+            return False
+        if status is None:
+            return False
+        # psycopg3: pq.TransactionStatus.INERROR (IntEnum, name 'INERROR', value 3).
+        # Compare by name and by the stable libpq numeric to stay driver-robust.
+        try:
+            if getattr(status, "name", None) == "INERROR":
+                return True
+            return int(status) == 3
+        except Exception:
+            return False
+
     def create_savepoint(self, sp=None, cursor=None):
         """
         Creates a savepoint named `sp`. If none given, uses a random name.

{velocity_python-0.1.79 → velocity_python-0.1.80}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.79
+Version: 0.1.80
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.79 → velocity_python-0.1.80}/src/velocity_python.egg-info/SOURCES.txt

@@ -151,6 +151,7 @@ src/velocity_python.egg-info/dependency_links.txt
 src/velocity_python.egg-info/entry_points.txt
 src/velocity_python.egg-info/requires.txt
 src/velocity_python.egg-info/top_level.txt
+tests/test_activity_tracking_aborted_tx.py
 tests/test_amplify_build.py
 tests/test_asset_indexing.py
 tests/test_asset_references.py

velocity_python-0.1.80/tests/test_activity_tracking_aborted_tx.py

@@ -0,0 +1,116 @@
+"""Bookkeeping must never turn a completed action into a 500.
+
+If an action catches a DB error and returns a "success" response WITHOUT rolling
+back to a savepoint, the transaction stays aborted. velocity's afterAction
+activity-tracking UPDATE would then fail at SAVEPOINT with "current transaction is
+aborted", masking the real error and producing an unhandled 500 (prod incident
+2026-07-01, BackOfficeData BillingDashboard). These tests pin:
+
+  * Transaction.is_aborted() detects the poisoned state.
+  * _enhanced_after_action skips the tracking write when aborted (and never
+    raises), and still tracks on a healthy transaction.
+"""
+
+import unittest
+from unittest.mock import MagicMock
+
+from velocity.db.core.transaction import Transaction
+from velocity.aws.handlers.mixins.web_handler import WebHandler
+
+
+class IsAbortedTest(unittest.TestCase):
+    def _tx_with_status(self, status):
+        tx = Transaction.__new__(Transaction)
+        conn = MagicMock()
+        conn.info.transaction_status = status
+        tx.connection = conn
+        return tx
+
+    def test_no_connection_is_not_aborted(self):
+        tx = Transaction.__new__(Transaction)
+        tx.connection = None
+        self.assertFalse(tx.is_aborted())
+
+    def test_inerror_by_name_is_aborted(self):
+        status = MagicMock()
+        status.name = "INERROR"
+        self.assertTrue(self._tx_with_status(status).is_aborted())
+
+    def test_inerror_by_numeric_is_aborted(self):
+        # A driver enum member whose .name isn't 'INERROR' but int() == 3.
+        class _Status:
+            name = "PQTRANS_INERROR"
+
+            def __int__(self):
+                return 3
+
+        self.assertTrue(self._tx_with_status(_Status()).is_aborted())
+
+    def test_intrans_is_not_aborted(self):
+        status = MagicMock()
+        status.name = "INTRANS"
+        status.__int__ = lambda self: 2
+        self.assertFalse(self._tx_with_status(status).is_aborted())
+
+    def test_status_probe_failure_is_not_aborted(self):
+        tx = Transaction.__new__(Transaction)
+        conn = MagicMock()
+        type(conn).info = property(lambda self: (_ for _ in ()).throw(RuntimeError()))
+        tx.connection = conn
+        self.assertFalse(tx.is_aborted())
+
+
+class _Handler(WebHandler):
+    """Minimal harness exercising the real _enhanced_after_action."""
+
+    def __init__(self):
+        self._perf_timing_enabled = False
+        self.track_activity_success = MagicMock()
+
+
+def _context():
+    ctx = MagicMock()
+    ctx.action.return_value = "query"
+    return ctx
+
+
+class EnhancedAfterActionGuardTest(unittest.TestCase):
+    def test_skips_tracking_when_tx_aborted(self):
+        handler = _Handler()
+        tx = MagicMock()
+        tx.is_aborted.return_value = True
+
+        handler._enhanced_after_action(tx, _context())  # must not raise
+
+        handler.track_activity_success.assert_not_called()
+
+    def test_tracks_when_tx_healthy(self):
+        handler = _Handler()
+        tx = MagicMock()
+        tx.is_aborted.return_value = False
+
+        handler._enhanced_after_action(tx, _context())
+
+        handler.track_activity_success.assert_called_once()
+
+    def test_tracking_failure_is_swallowed(self):
+        handler = _Handler()
+        handler.track_activity_success.side_effect = RuntimeError("boom")
+        tx = MagicMock()
+        tx.is_aborted.return_value = False
+
+        # A failing bookkeeping write must not propagate out of afterAction.
+        handler._enhanced_after_action(tx, _context())
+
+    def test_missing_is_aborted_falls_back_to_tracking(self):
+        # Older Transaction without is_aborted() (getattr guard) still tracks.
+        handler = _Handler()
+        tx = MagicMock(spec=[])  # no is_aborted attribute
+
+        handler._enhanced_after_action(tx, _context())
+
+        handler.track_activity_success.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()