tina4-python 3.13.6__tar.gz → 3.13.8__tar.gz

{tina4_python-3.13.6 → tina4_python-3.13.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.13.6
+Version: 3.13.8
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.13.6 → tina4_python-3.13.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.6"
+version = "3.13.8"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}

{tina4_python-3.13.6 → tina4_python-3.13.8}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.13.6"
+__version__ = "3.13.8"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401

{tina4_python-3.13.6 → tina4_python-3.13.8}/tina4_python/core/server.py

@@ -1307,9 +1307,38 @@ def _handle_route_error(
     error: Exception, request: Request, response: Response,
     request_id: str, is_dev: bool,
 ) -> Response:
-    """Format an error response for a failed route handler."""
+    """Format an error response for a failed route handler.
+
+    Two contracts (v3.13.7):
+
+    1. Fire ``tina4.request.error`` before rendering, so observers
+       (centralised logging, APM, Sentry) see the failure even though
+       the framework caught it. Payload is a single dict ``{exception,
+       request}`` — the canonical shape mirrored by PHP/Ruby/Node.
+       Listener exceptions are swallowed so a broken listener can't
+       break the 500 page.
+
+    2. In non-debug mode, never put the stack trace in the response
+       body (CWE-209). The trace is still available via ``Log.error``
+       above and the dev-admin ``BrokenTracker`` in dev mode. The
+       framework's own 500.twig now guards the trace block with
+       ``{% if error_message %}``.
+    """
     Log.error(f"Route error: {error}", path=request.path)
     _write_broken(request, error)
+
+    try:
+        from tina4_python.core.events import emit as _emit
+        _emit("tina4.request.error", {"exception": error, "request": request})
+    except Exception as listener_err:
+        try:
+            Log.warning(
+                f"Listener for tina4.request.error raised: "
+                f"{type(listener_err).__name__}: {listener_err}"
+            )
+        except Exception:
+            pass
+
     if is_dev:
         try:
             import traceback as _tb
@@ -1324,9 +1353,9 @@ def _handle_route_error(
         overlay_html = render_error_overlay(error, request)
         response.status(500).html(overlay_html)
     else:
-        import traceback
-        tb = traceback.format_exc()
-        html = _render_error_page(500, request.path, request_id, tb)
+        # Production: NO traceback in the body. The trace is logged via
+        # Log.error above; clients only see the generic page + request_id.
+        html = _render_error_page(500, request.path, request_id, "")
         if html:
             response.status(500).html(html)
         else:

{tina4_python-3.13.6 → tina4_python-3.13.8}/tina4_python/database/postgres.py

@@ -49,6 +49,60 @@ class PostgreSQLAdapter(DatabaseAdapter):
         else:
             cursor.execute(sql)
 
+    def _heal_aborted_txn(self):
+        """Issue #46 follow-on (v3.13.8): pre-flight rollback if the
+        connection arrived in an aborted-transaction state.
+
+        v3.13.6 added auto-rollback inside :meth:`_on_query_error` — that
+        clears the abort *on* a failure the wrapper catches. But the
+        connection can still arrive poisoned from elsewhere:
+
+        - A boot-time query that failed before request handling started
+          (migration probe, ORM ``information_schema`` lookup, etc.)
+        - A failure inside an explicit transaction where the user owned
+          the rollback but never issued one
+        - A direct ``cursor.execute`` call in another adapter method
+          (e.g. the ``SELECT lastval()`` SAVEPOINT probe) that managed to
+          leave the txn dirty
+
+        In all those cases the *next* query — even one routed through
+        our wrapper — hits ``InFailedSqlTransaction`` immediately, and
+        the cascade message buries whatever the original cause was.
+
+        Healing fix: before executing, ask psycopg2 whether the
+        connection is in ``TRANSACTION_STATUS_INERROR`` and rollback if
+        so. Only when NOT inside an explicit transaction — explicit txns
+        stay under the caller's control.
+
+        Reported by Schalk (24rent) against v3.13.7.
+        """
+        if self._in_transaction or self._conn is None:
+            return
+        try:
+            import psycopg2.extensions as _ext
+            status = self._conn.info.transaction_status
+        except Exception:
+            return
+        if status != _ext.TRANSACTION_STATUS_INERROR:
+            return
+        try:
+            self._conn.rollback()
+        except Exception:
+            # If even the heal-rollback fails, fall through — the next
+            # cursor.execute will raise with the real psycopg2 error and
+            # _on_query_error will pick it up. Better than masking.
+            return
+        try:
+            from tina4_python.debug import Log
+            Log.warning(
+                "PostgreSQL connection arrived in aborted-transaction "
+                "state — issued pre-flight ROLLBACK so the next query "
+                "starts clean. Look back in the log for the original "
+                "PostgreSQL query failed entry."
+            )
+        except Exception:
+            pass
+
     def _exec_with_handling(self, cursor, sql: str, params=None):
         """Run a query through :meth:`_safe_execute` and surface failures.
 
@@ -59,18 +113,23 @@ class PostgreSQLAdapter(DatabaseAdapter):
         block``, *far* from the actual cause. Without framework-side
         logging, the original SQL + error never reach the user.
 
-        On failure this method:
+        This method:
 
-        1. Logs the original error via ``Log.error`` with SQL+params context
-        2. Stores it on ``self.last_error``
-        3. Auto-rollbacks when NOT inside an explicit transaction (so the
-           next caller gets a clean connection)
+        0. (v3.13.8) Pre-flight heal — if the connection arrived in an
+           aborted-transaction state from anywhere outside this wrapper,
+           rollback first so this query starts on a clean txn.
+        1. Logs failures via ``Log.error`` with SQL+params context
+        2. Stores them on ``self.last_error``
+        3. Auto-rollbacks on failure when NOT inside an explicit
+           transaction (so the next caller gets a clean connection)
         4. Re-raises so callers still see the failure
 
-        Inside an explicit transaction we do NOT rollback — the user owns
-        that transaction (could be running a SAVEPOINT/retry pattern). We
-        still log + store ``last_error`` so they can diagnose.
+        Inside an explicit transaction we do NOT auto-rollback — the
+        user owns that transaction (could be running a SAVEPOINT/retry
+        pattern). We still log + store ``last_error`` so they can
+        diagnose, and the heal step also defers to explicit txns.
         """
+        self._heal_aborted_txn()
         try:
             self._safe_execute(cursor, sql, params)
         except Exception as e:
@@ -208,6 +267,12 @@ class PostgreSQLAdapter(DatabaseAdapter):
 
         sql = self._translate_sql(sql)
 
+        # v3.13.8: heal first so the COUNT probe below doesn't open on a
+        # poisoned connection — the probe uses raw _safe_execute (it's
+        # allowed to fail without polluting last_error) so it bypasses
+        # _exec_with_handling's heal step.
+        self._heal_aborted_txn()
+
         cursor = self._conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
 
         # Count total rows
@@ -217,6 +282,14 @@ class PostgreSQLAdapter(DatabaseAdapter):
             total = cursor.fetchone()["cnt"]
         except Exception:
             total = 0
+            # If the probe failed because the connection arrived (or
+            # became) aborted, roll back so the real pagination query
+            # below sees a clean txn. Without this we'd cascade.
+            if not self._in_transaction and self._conn is not None:
+                try:
+                    self._conn.rollback()
+                except Exception:
+                    pass
 
         # Apply pagination — the real query, so use the error-handling
         # wrapper. The count probe above is best-effort and stays on

{tina4_python-3.13.6 → tina4_python-3.13.8}/tina4_python/templates/errors/500.twig

@@ -27,7 +27,7 @@ body { font-family: system-ui, -apple-system, sans-serif; background: #0f172a; c
         <div class="error-title">Server Error</div>
     </div>
     <div class="error-msg">Something went wrong while processing your request.</div>
-    <pre class="error-trace">{{ error_message }}</pre>
+    {% if error_message %}<pre class="error-trace">{{ error_message }}</pre>{% endif %}
     <div class="error-footer">
         <span class="error-hint">Fix the error and save to auto-reload</span>
         <span class="error-id">{{ request_id }}</span>