Log exceptions instead of storing in database

Author: fmell

backend/alembic/versions/7c2e1f4b8a90_drop_pickle_exception.py

@@ -0,0 +1,40 @@
+"""drop results.python_exception (PickleType)
+
+Revision ID: 7c2e1f4b8a90
+Revises: 9b4e2c1a7d50
+Create Date: 2026-05-19 00:00:00.000000
+
+Removes the ``python_exception`` column on ``results``, which used
+SQLAlchemy ``PickleType``. Loading that column unpickled arbitrary bytes
+from the database on every result read, which is an insecure-
+deserialization sink (RCE primitive given any DB write capability).
+
+The column was not used by application logic, so the existing pickled blobs are discarded.
+Full exception details are logged to Application Insights via ``logger.exception`` instead
+of being persisted in the database.
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+
+revision: str = "7c2e1f4b8a90"
+down_revision: Union[str, Sequence[str], None] = "9b4e2c1a7d50"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.drop_column("results", "python_exception")
+
+
+def downgrade() -> None:
+    # Restore the column shape for compatibility, but not the data:
+    # re-creating PickleType data would require reintroducing the
+    # deserialization sink that this migration exists to remove.
+    op.add_column(
+        "results",
+        sa.Column("python_exception", sa.PickleType(), nullable=True),
+    )

backend/src/acidwatch_api/database.py

@@ -10,7 +10,6 @@
     Engine,
     ForeignKey,
     DateTime,
-    PickleType,
     Uuid,
     JSON,
     create_engine,
@@ -71,7 +70,6 @@ class ModelResult(Base):
     model_input_id: Mapped[UUID] = mapped_column(ForeignKey("model_inputs.id"))
     concentrations: Mapped[dict[str, float]] = mapped_column(JSON)
     panels: Mapped[list[Any]] = mapped_column(JSON)
-    python_exception: Mapped[BaseException | None] = mapped_column(PickleType)
     error: Mapped[str | None] = mapped_column()
 
     model_input: Mapped[ModelInput] = relationship("ModelInput")

backend/src/acidwatch_api/routes/models.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-import sys
+import logging
 from collections import defaultdict
 from typing import Annotated
 from uuid import UUID, uuid4
@@ -42,6 +42,8 @@
 
 router = APIRouter()
 
+logger = logging.getLogger(__name__)
+
 
 type AdapterSet = dict[str, type[BaseAdapter]]
 
@@ -126,18 +128,23 @@ async def _run_adapter(
             model_input_id=model_input_id,
             concentrations=concs,
             panels=[p.model_dump(mode="json", by_alias=True) for p in panels],
-            python_exception=None,
             error=None,
         )
 
         return concs
     except BaseException as exc:
+        # Full traceback goes to logs (App Insights); only a short message
+        # is persisted for surfacing to the API caller.
+        logger.exception(
+            "Adapter %s failed for model_input %s",
+            adapter.model_id,
+            model_input_id,
+        )
         result_obj = db.ModelResult(
             model_input_id=model_input_id,
             concentrations={},
             panels=[],
-            python_exception=exc,
-            error=str(exc),
+            error=f"{type(exc).__name__}: {exc}",
         )
         return {}
 
@@ -187,7 +194,7 @@ def get_result_for_simulation(
             continue
 
         if result.error is not None:
-            print(result.error, file=sys.stderr)
+            logger.error("Simulation %s failed: %s", simulation_id, result.error)
             raise HTTPException(
                 status_code=500,
                 detail=f"Simulation encountered an error: {result.error}",

backend/tests/test_models_endpoints.py

@@ -474,7 +474,6 @@ def test_results_order(client, sql_session, swap):
                 result=db.ModelResult(
                     concentrations={"A": 1},
                     panels=[],
-                    python_exception=None,
                     error=None,
                 ),
             ),
@@ -484,7 +483,6 @@ def test_results_order(client, sql_session, swap):
                 result=db.ModelResult(
                     concentrations={"B": 2},
                     panels=[],
-                    python_exception=None,
                     error=None,
                 ),
             ),

backend/tests/test_schema_guardrails.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from sqlalchemy import PickleType
+from acidwatch_api.database import Base
+
+
+def test_no_pickle_type_columns() -> None:
+    """``PickleType`` columns deserialize arbitrary Python objects on read.
+
+    Forbidding them at the schema level prevents the insecure-
+    deserialization sink that ``results.python_exception`` previously
+    introduced from being reintroduced by accident.
+    """
+    offenders = [
+        f"{table.name}.{column.name}"
+        for table in Base.metadata.tables.values()
+        for column in table.columns
+        if isinstance(column.type, PickleType)
+    ]
+    assert not offenders, (
+        f"PickleType columns are forbidden; found: {offenders}. "
+        "Log via logging.exception() or store text/JSON instead."
+    )