mainsequence-metatable 0.1.15__tar.gz → 0.1.16.dev28__tar.gz

{mainsequence_metatable-0.1.15/src/mainsequence_metatable.egg-info → mainsequence_metatable-0.1.16.dev28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.15
+Version: 0.1.16.dev28
 Summary: Main Sequence MetaTables Python client and standalone API
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence-metatable"
-version = "0.1.15"
+version = "0.1.16.dev28"
 description = "Main Sequence MetaTables Python client and standalone API"
 readme = "README.md"
 requires-python = ">=3.13"

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28/src/mainsequence_metatable.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence-metatable
-Version: 0.1.15
+Version: 0.1.16.dev28
 Summary: Main Sequence MetaTables Python client and standalone API
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: MIT

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/mainsequence_metatable.egg-info/SOURCES.txt

@@ -172,6 +172,7 @@ src/metatables/api/app/configuration.py
 src/metatables/api/app/credential_admin.py
 src/metatables/api/app/development.py
 src/metatables/api/app/development_client.py
+src/metatables/api/app/error_logging.py
 src/metatables/api/app/main.py
 src/metatables/api/app/platform_cache.py
 src/metatables/api/app/runtime.py

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/bootstrap.py

@@ -177,6 +177,7 @@ class RuntimeBootstrap:
                 raise ValueError("Database heads do not match the migration files")
             result["migration_status"] = "pending" if pending else "up_to_date"
         except Exception:
+            logger.warning("Database revision is not compatible with the migration files", exc_info=True)
             result.update(migration_status="incompatible",
                           migration_error="The database revision is not compatible with these migration files. Review the migration history before applying changes.")
         return result
@@ -201,6 +202,7 @@ class RuntimeBootstrap:
                         self.error = "Multiple legacy local databases are saved. Choose the existing local runtime file in Settings; no database has been replaced."
                         return None
             except (OSError, ValueError):
+                logger.warning("Saved runtime selection cannot be read", exc_info=True)
                 self.error = "Saved runtime selection cannot be read. Configure the DataSource again."
                 return None
         if self.workspace:
@@ -214,9 +216,11 @@ class RuntimeBootstrap:
         try:
             self.declaration, candidate, self.credential_store = declared_database(self.config, self.credential_store)
         except RuntimeDatabaseError as exc:
+            logger.warning("Declared runtime database is unavailable", exc_info=True)
             self.status, self.error = exc.status, str(exc)
             return None
         except RuntimeError as exc:
+            logger.warning("Declared runtime database is incompatible", exc_info=True)
             self.status, self.error = "incompatible", str(exc)
             return None
         return candidate
@@ -307,6 +311,7 @@ class RuntimeBootstrap:
                         if script.get_revision(revision) is None:
                             raise ValueError("Unknown revision")
                 except Exception:
+                    logger.warning("Database has an unsupported MetaTables migration revision", exc_info=True)
                     self.status, self.error = "incompatible", "The database has an unsupported MetaTables migration revision. Earlier development databases require recreation."
                     return
                 if set(self.current) != set(self.expected):
@@ -345,8 +350,10 @@ class RuntimeBootstrap:
                     self.uid = row.uid
                     self.status = "ready"
         except (BootstrapError, CatalogConfigurationError) as exc:
+            logger.warning("Runtime database is incompatible", exc_info=True)
             self.status, self.error = "incompatible", str(exc)
         except CredentialStoreError as exc:
+            logger.warning("Runtime credential store is unavailable", exc_info=True)
             self.status, self.error = "unavailable", exc.message
         except Exception as exc:
             cause = log_failure("Cannot verify the selected database or its Alembic history", exc)
@@ -422,15 +429,15 @@ class RuntimeBootstrap:
             self.inspect()
             if isinstance(exc, CredentialStoreError):
                 self.error = exc.message
-                raise BootstrapError(exc.message) from None
+                raise BootstrapError(exc.message) from exc
             from metatables.api.backend.backends.contracts import SQLExecutionError
             if isinstance(exc, SQLExecutionError):
                 self.error = f"Database access setup failed ({exc.code}). Check the DataSource password Secret and database permissions, then retry setup."
-                raise BootstrapError(self.error) from None
+                raise BootstrapError(self.error) from exc
             if privilege_error := insufficient_privilege(exc):
                 self.error = (f"Database setup failed: {privilege_error}. The DataSource login must own the runtime "
                               "database and every object in it; see the DataSource database privileges.")
-                raise BootstrapError(self.error) from None
+                raise BootstrapError(self.error) from exc
             cause = log_failure("MetaTables migration or registration failed", exc)
             self.error = (f"MetaTables migration or registration failed ({cause}). The runtime was not activated; "
                           "inspect the database before retrying. The log has the full error.")
@@ -460,8 +467,8 @@ class RuntimeBootstrap:
                     stream = stack.enter_context(os.fdopen(descriptor, "a"))
                     try:
                         fcntl.flock(stream, fcntl.LOCK_EX | fcntl.LOCK_NB)
-                    except BlockingIOError:
-                        raise BootstrapError("Another local initialization is in progress. Retry when it finishes.") from None
+                    except BlockingIOError as error:
+                        raise BootstrapError("Another local initialization is in progress. Retry when it finishes.") from error
                 files = local_store_files(self.workspace)
                 saved = json.loads(self.saved_path.read_text()) if self.saved_path.exists() else {}
                 if "local" in saved:
@@ -484,7 +491,7 @@ class RuntimeBootstrap:
         except BootstrapError:
             raise
         except RuntimeError as exc:
-            raise BootstrapError(str(exc)) from None
+            raise BootstrapError(str(exc)) from exc
         except Exception as exc:
             cause = log_failure("Unable to finish local database destruction", exc)
             message = f"Unable to finish local database destruction ({cause}). Check file access and retry."
@@ -580,7 +587,7 @@ def mutation(request, caller):
         finally:
             control.cancel()
     except BootstrapError as exc:
-        raise HTTPException(409, str(exc)) from None
+        raise HTTPException(409, str(exc)) from exc
     finally:
         value.lock.release()
 
@@ -599,8 +606,8 @@ def configure(body: RuntimeSourceInput, request: Request, caller: AdmittedCaller
             value.configure(body, caller.user_uid)
         except BootstrapError:
             raise
-        except Exception:
-            raise BootstrapError("Invalid runtime DataSource configuration.") from None
+        except Exception as exc:
+            raise BootstrapError("Invalid runtime DataSource configuration.") from exc
         request.app.state.runtime = replace(request.app.state.runtime, data_sources=None, binding=RuntimeStorageBinding())
         return value.descriptor(caller.user_uid, is_admin=caller.is_admin)
 

mainsequence_metatable-0.1.16.dev28/src/metatables/api/app/error_logging.py

@@ -0,0 +1,41 @@
+"""Server-side error logs: every failure the API translates keeps its traceback."""
+
+import logging
+
+from metatables.log_contract import redact_text
+
+logger = logging.getLogger("metatables.api")
+
+
+class RedactingFormatter(logging.Formatter):
+    """Mask credential patterns in the message and the rendered traceback."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        return redact_text(super().format(record))
+
+
+def configure_logging() -> None:
+    """Emit ``metatables.*`` warnings and errors when the host configured no handler."""
+    package = logging.getLogger("metatables")
+    if package.hasHandlers():
+        return
+    handler = logging.StreamHandler()
+    handler.setFormatter(RedactingFormatter("%(asctime)s %(levelname)s %(name)s: %(message)s"))
+    package.addHandler(handler)
+
+
+def translated_cause(error: BaseException) -> BaseException | None:
+    if error.__cause__ is not None:
+        return error.__cause__
+    return None if error.__suppress_context__ else error.__context__
+
+
+def log_translated(request, error: BaseException, status_code: int) -> None:
+    """Log server failures and any exception translated into a client response."""
+    if status_code < 500 and translated_cause(error) is None:
+        return
+    logger.log(
+        logging.ERROR if status_code >= 500 else logging.WARNING,
+        "%s %s -> %s %s", request.method, request.url.path, status_code, type(error).__name__,
+        exc_info=error,
+    )

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/main.py

@@ -4,12 +4,15 @@ from contextlib import asynccontextmanager
 from uuid import UUID
 
 from fastapi import Depends, FastAPI, HTTPException, Request
+from fastapi.exception_handlers import http_exception_handler
 from fastapi.responses import JSONResponse
 from fastapi.routing import APIRoute
 from sqlalchemy.orm import Session
+from starlette.exceptions import HTTPException as StarletteHTTPException
 
 from metatables.api.app.auth.boundary import trusted_actor_facts
 from metatables.api.app.auth.local_actor import catalog_session
+from metatables.api.app.error_logging import configure_logging, log_translated
 from metatables.api.app.routes.column_search import router as column_search_router
 from metatables.api.app.routes.contract_validation import router as contract_validation_router
 from metatables.api.app.routes.data_sources import router as data_sources_router
@@ -99,6 +102,7 @@ from metatables.api.app.routes.update_crud import router as update_crud_router
 
 
 def create_app(config: RuntimeConfig | None = None) -> FastAPI:
+    configure_logging()
     selected = config or RuntimeConfig.from_environment()
 
     @asynccontextmanager
@@ -120,12 +124,18 @@ def create_app(config: RuntimeConfig | None = None) -> FastAPI:
     service = FastAPI(title="MetaTables API", version="0.1.0", lifespan=lifespan)
     from metatables.api.backend.backends.contracts import SQLExecutionError
 
+    @service.exception_handler(StarletteHTTPException)
+    async def http_error(request, error):
+        log_translated(request, error, error.status_code)
+        return await http_exception_handler(request, error)
+
     @service.exception_handler(SQLExecutionError)
     async def database_access_error(request, error):
         unavailable = error.code in {
             "sql_security_not_initialized", "sql_identity_secret_required",
             "sql_permission_reconciliation_pending", "sql_principal_permission_drift",
         } or error.code.endswith("outcome_unknown")
+        log_translated(request, error, 503 if unavailable else 400)
         return JSONResponse(status_code=503 if unavailable else 400,
                             content={"detail": {"code": error.code, "detail": error.detail}})
     from metatables.api.app.transfer import TransferMiddleware
@@ -135,8 +145,9 @@ def create_app(config: RuntimeConfig | None = None) -> FastAPI:
 
     @service.exception_handler(TransferError)
     async def transfer_error(request, error):
-        return JSONResponse(status_code=408 if isinstance(error, TransferDeadlineError) else 413,
-                            content={"detail": {"code": str(error)}})
+        status_code = 408 if isinstance(error, TransferDeadlineError) else 413
+        log_translated(request, error, status_code)
+        return JSONResponse(status_code=status_code, content={"detail": {"code": str(error)}})
 
     service.state.runtime = RuntimeState(config=selected)
     from metatables.api.app.runtime_control import RuntimeControl
@@ -154,6 +165,7 @@ def create_app(config: RuntimeConfig | None = None) -> FastAPI:
             if control is not None:
                 control.enter(request)
         except HTTPException as exc:
+            log_translated(request, exc, exc.status_code)
             return JSONResponse(status_code=exc.status_code, content={"detail": exc.detail})
         try:
             return await call_next(request)

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/routes/data_sources.py

@@ -56,9 +56,9 @@ class SourceRoute(APIRoute):
             try:
                 return await handler(request)
             except RuntimeBindingError as exc:
-                raise HTTPException(409, exc.code) from None
+                raise HTTPException(409, exc.code) from exc
             except CredentialStoreError as exc:
-                raise HTTPException(503, exc.message) from None
+                raise HTTPException(503, exc.message) from exc
             except RequestValidationError as exc:
                 # Keep field diagnostics without echoing submitted credentials.
                 detail = [{key: error[key] for key in ("loc", "msg", "type")}
@@ -206,13 +206,13 @@ def test_source_connection(body: SourceCreate, request: Request, actor: TrustedA
             source = replace(source, connection=replace(source.connection, **connection_tls))
         validate_connection(source)
     except CredentialStoreError as exc:
-        raise HTTPException(503, exc.message) from None
+        raise HTTPException(503, exc.message) from exc
     except DataSourceIntegrationError as exc:
         if exc.code in {"mysql_driver_unavailable", "mssql_driver_unavailable"}:
-            raise HTTPException(503, f"Install the {body.class_type} driver dependencies on the MetaTables API server.") from None
-        raise HTTPException(503, "Connection failed. Check the host, port, database name, credentials and TLS settings.") from None
-    except Exception:
-        raise HTTPException(503, "Connection failed. Check the host, port, database name, credentials and TLS settings.") from None
+            raise HTTPException(503, f"Install the {body.class_type} driver dependencies on the MetaTables API server.") from exc
+        raise HTTPException(503, "Connection failed. Check the host, port, database name, credentials and TLS settings.") from exc
+    except Exception as error:
+        raise HTTPException(503, "Connection failed. Check the host, port, database name, credentials and TLS settings.") from error
     return {"ok": True, "message": "Connection succeeded."}
 
 
@@ -347,17 +347,17 @@ def validate_source(uid: UUID, request: Request, actor: TrustedActorFacts = Depe
         source = resolve_source(row, request_credentials(request, session, actor), binding=binding)
         validate_connection(source)
     except CredentialStoreError as exc:
-        raise HTTPException(503, exc.message) from None
+        raise HTTPException(503, exc.message) from exc
     except DataSourceIntegrationError as exc:
         row.status = "FAILED"
         session.commit()
         if exc.code in {"mysql_driver_unavailable", "mssql_driver_unavailable"}:
-            raise HTTPException(503, f"Install the {row.class_type} driver dependencies on the MetaTables API server.") from None
-        raise HTTPException(503, "DataSource validation failed; check connection configuration and Secret access.") from None
-    except Exception:
+            raise HTTPException(503, f"Install the {row.class_type} driver dependencies on the MetaTables API server.") from exc
+        raise HTTPException(503, "DataSource validation failed; check connection configuration and Secret access.") from exc
+    except Exception as error:
         row.status = "FAILED"
         session.commit()
-        raise HTTPException(503, "DataSource validation failed; check connection configuration and Secret access.") from None
+        raise HTTPException(503, "DataSource validation failed; check connection configuration and Secret access.") from error
     row.status = "AVAILABLE"
     session.commit()
     return payload(row, actor, binding)

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/routes/managed_finalize.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 from collections.abc import Callable
 from typing import Any
 from uuid import UUID
@@ -47,6 +48,8 @@ from metatables.api.backend.persistence.projections import (
     resolved_foreign_key_targets,
 )
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/meta-tables", tags=["MetaTables"])
 
 
@@ -157,6 +160,7 @@ def finalize_managed(
                 physical_table_name=table.physical_table_name,
             )
         except PhysicalIntrospectionError as exc:
+            logger.warning("Physical table introspection failed during finalization", exc_info=True)
             if exc.code == "physical_table_not_found":
                 if uid == version_root:
                     rows.append(_row(table, uid, previous=previous, specialization=specialization,
@@ -220,6 +224,7 @@ def finalize_managed(
             rows.append(_row(table, uid, previous=previous, specialization=specialization,
                              exists=True, finalized=previous != "active"))
         except (CatalogInvariantError, ContractValidationError, IntegrityError) as exc:
+            logger.warning("Physical table contract could not be reconciled", exc_info=True)
             rows.append(_row(
                 table, uid, previous=previous, specialization=specialization, exists=True,
                 error={
@@ -229,6 +234,7 @@ def finalize_managed(
             ))
             continue
         except (TimescaleError, PhysicalConnectionUnavailable) as exc:
+            logger.warning("TimescaleDB hypertable could not be created", exc_info=True)
             rows.append(_row(
                 table, uid, previous=previous, specialization=specialization, exists=True,
                 error={

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/routes/run_logs.py

@@ -102,8 +102,8 @@ def update_logs(
     if request.query_params.get("run_uid"):
         try:
             statement = statement.where(UpdateRun.uid == UUID(request.query_params["run_uid"]))
-        except ValueError:
-            raise HTTPException(422, "Invalid run UID.") from None
+        except ValueError as exc:
+            raise HTTPException(422, "Invalid run UID.") from exc
     runs = list(
         session.scalars(statement.order_by(UpdateRun.started_at.desc(), UpdateRun.uid).limit(21))
     )

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/routes/runtime_context.py

@@ -1,5 +1,6 @@
 """Authenticated application initialization and effective storage settings."""
 
+import logging
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, Request, Response
@@ -13,6 +14,8 @@ from metatables.api.backend.integrations.local_workspace import source_descripto
 from metatables.api.backend.integrations.runtime_data_sources import DataSourceIntegrationError
 from metatables.runtime_contract import HostedEnvironment, RuntimeContext
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter(tags=["Runtime"])
 
 
@@ -31,10 +34,12 @@ def verified_environment(uid: UUID | None) -> HostedEnvironment:
             is_production=environment.is_production,
             required_repository_branch=environment.required_repository_branch)
     except ApiError as exc:
+        logger.warning("Hosted environment lookup failed", exc_info=True)
         return HostedEnvironment(uid=str(uid), status="not_found" if exc.status_code == 404 else "unavailable")
     except DoesNotExist:
         return HostedEnvironment(uid=str(uid), status="not_found")
     except Exception:
+        logger.exception("Hosted environment lookup failed")
         return HostedEnvironment(uid=str(uid), status="unavailable")
 
 
@@ -52,6 +57,7 @@ def developer_hosted_environment(cache: PlatformCache[UUID, HostedEnvironment])
         uid = get_code_repository_context().organization_environment_uid
         return cached_environment(cache, UUID(uid) if uid else None)
     except Exception:
+        logger.exception("Hosted environment resolution failed")
         return HostedEnvironment(uid=None, status="unavailable")
 
 
@@ -103,9 +109,12 @@ def runtime_context(
         uid = state.binding.source_uid or provider.default_uid()
         metadata = provider.metadata(uid)
     except DataSourceIntegrationError as exc:
+        if exc.code != "default_data_source_not_configured":
+            logger.warning("Runtime DataSource metadata is unavailable", exc_info=True)
         result["data_source_error"] = "data_source_not_configured" if exc.code == "default_data_source_not_configured" else "data_source_unavailable"
         return result
     except (KeyError, ValueError, RuntimeError, SQLAlchemyError):
+        logger.warning("Runtime DataSource metadata is unavailable", exc_info=True)
         result["data_source_error"] = "data_source_unavailable"
         return result
     if metadata is None:

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/routes/security.py

@@ -74,9 +74,9 @@ def reconcile_database_permissions(actor=Depends(require_admin_actor),
     try:
         backend.access.initialize(session)
         session.commit()
-    except Exception:
+    except Exception as exc:
         session.rollback()
-        raise HTTPException(503, "Database permission reconciliation failed; caller SQL remains disabled.") from None
+        raise HTTPException(503, "Database permission reconciliation failed; caller SQL remains disabled.") from exc
     return {"ok": True, "data_source_uid": str(backend.source.uid)}
 
 
@@ -162,7 +162,7 @@ def replace_grants(session, actor, kind, uid, body):
             try:
                 validate_principal(principal_kind, principal_uid)
             except PrincipalUnavailable as exc:
-                raise HTTPException(422, str(exc)) from None
+                raise HTTPException(422, str(exc)) from exc
     lock_catalog(session)
     session.expire_all()
     row = authorize(session, actor, kind, uid, edit=True)
@@ -256,7 +256,7 @@ def effective_access(uid: UUID, user_uid: UUID | None = None, without_grant_uid:
             identity = validate_principal("user", user_uid)
             teams, _ = platform_facts(identity)
         except PrincipalUnavailable as exc:
-            raise HTTPException(422, str(exc)) from None
+            raise HTTPException(422, str(exc)) from exc
         subject = TrustedActorFacts(user_uid=user_uid, user_active=True, active_team_uids=teams)
     contributions = GrantRepository(session).contributions(table=table, actor=subject)
     remaining = [g for g in contributions if g['grant_uid'] != str(without_grant_uid)]

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/routes/table_delete.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 from collections.abc import Callable
 from uuid import UUID
 
@@ -29,6 +30,8 @@ from metatables.api.backend.persistence.locking import lock_catalog
 from metatables.api.backend.persistence.models import MetaTable, MetaTableForeignKey, MetaTableGrant
 from metatables.api.backend.persistence.physical_operations import PhysicalOperationRepository
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter(prefix="/meta-tables", tags=["MetaTables"])
 
 
@@ -41,6 +44,7 @@ def _journal_reconciliation(session: Session, operation_uid: UUID) -> None:
         PhysicalOperationRepository(session).require_reconciliation(operation_uid=operation_uid)
         session.commit()
     except SQLAlchemyError:
+        logger.exception("Failed to record that the physical delete requires reconciliation")
         session.rollback()
 
 
@@ -133,6 +137,7 @@ def destroy_meta_table(
             repository.record_failed(operation_uid=operation_uid, safe_error_code=safe_code)
             session.commit()
         except SQLAlchemyError:
+            logger.exception("Failed to record the failed physical delete")
             session.rollback()
         status = exc.status_code if isinstance(exc, DataSourceAdmissionError) else 409
         if isinstance(exc, (DataSourceIntegrationError, PhysicalConnectionUnavailable)):

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/routes/table_import.py

@@ -40,22 +40,22 @@ def invoke(session, operation):
         return operation()
     except RelationError as exc:
         session.rollback()
-        raise HTTPException(exc.status, {"code": exc.code}) from None
+        raise HTTPException(exc.status, {"code": exc.code}) from exc
     except CredentialStoreError as exc:
         session.rollback()
-        raise HTTPException(503, {"code": exc.code, "detail": exc.message}) from None
+        raise HTTPException(503, {"code": exc.code, "detail": exc.message}) from exc
     except (DataSourceIntegrationError, DataSourceAdmissionError, SQLExecutionError) as exc:
         session.rollback()
-        raise HTTPException(getattr(exc, "status_code", 409), {"code": exc.code}) from None
-    except PhysicalConnectionUnavailable:
+        raise HTTPException(getattr(exc, "status_code", 409), {"code": exc.code}) from exc
+    except PhysicalConnectionUnavailable as error:
         session.rollback()
-        raise HTTPException(503, {"code": "relation_access_failed"}) from None
-    except SQLAlchemyError:
+        raise HTTPException(503, {"code": "relation_access_failed"}) from error
+    except SQLAlchemyError as error:
         session.rollback()
-        raise HTTPException(503, {"code": "relation_catalog_unavailable"}) from None
-    except ValueError:
+        raise HTTPException(503, {"code": "relation_catalog_unavailable"}) from error
+    except ValueError as error:
         session.rollback()
-        raise HTTPException(422, {"code": "invalid_relation_contract"}) from None
+        raise HTTPException(422, {"code": "invalid_relation_contract"}) from error
 
 
 @source_router.get("/{source_uid}/relations/", response_model=RelationDiscovery)

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/routes/table_introspection.py

@@ -80,7 +80,7 @@ def introspect_meta_table(
     except DataSourceIntegrationError as exc:
         raise HTTPException(status_code=503, detail="DataSource service is unavailable.") from exc
     except RelationError as exc:
-        raise HTTPException(status_code=exc.status, detail={"code": exc.code}) from None
+        raise HTTPException(status_code=exc.status, detail={"code": exc.code}) from exc
     except PhysicalIntrospectionError as exc:
         raise HTTPException(status_code=409, detail=exc.code) from exc
     session.commit()

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/routes/table_sql.py

@@ -124,7 +124,7 @@ def execute_operation(
     try:
         backend.sql.check_wire_contract(payload.dialect, payload.statement.paramstyle)
     except SQLExecutionError as exc:
-        raise HTTPException(422, exc.code) from None
+        raise HTTPException(422, exc.code) from exc
     result = _execute(
         executor,
         backend,

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/runtime.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import errno
 import ipaddress
 import json
+import logging
 import os
 import socket
 from dataclasses import dataclass, field, replace
@@ -39,6 +40,8 @@ from metatables.api.backend.integrations.runtime_binding import (
 )
 from metatables.runtime_contract import HostedEnvironment
 
+logger = logging.getLogger(__name__)
+
 LOCAL_TOKEN_HEADER = "X-MetaTables-Local-Token"
 UNSAFE_METHODS = frozenset({"POST", "PUT", "PATCH", "DELETE"})
 
@@ -245,6 +248,7 @@ def initialize_runtime(config: RuntimeConfig) -> RuntimeState:
         try:
             bootstrap.configure(candidate, None)
         except Exception:
+            logger.exception("Saved or declared runtime configuration is invalid")
             bootstrap.status = "unavailable"
             bootstrap.error = ("Saved runtime configuration is invalid. Configure the DataSource again in Settings."
                                if config.local_mode else "The declared runtime database configuration is invalid. "

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/runtime_control.py

@@ -153,7 +153,7 @@ def select_runtime(body: RuntimeSelection, request: Request, background: Backgro
     try:
         DeploymentConfiguration.load(control.configuration).require_development()
     except RuntimeError as exc:
-        raise HTTPException(403, str(exc)) from None
+        raise HTTPException(403, str(exc)) from exc
     current = request.app.state.runtime.config.profile
     if body.mode == current:
         return {"mode": current, "restarting": False}
@@ -168,13 +168,13 @@ def select_runtime(body: RuntimeSelection, request: Request, background: Backgro
     except HTTPException:
         control.cancel()
         raise
-    except Exception:
+    except Exception as error:
         control.cancel()
-        raise HTTPException(409, "Unable to switch runtime mode. Check its current operations.") from None
+        raise HTTPException(409, "Unable to switch runtime mode. Check its current operations.") from error
     try:
         write_state(control.directory / "request.json", {"mode": body.mode})
-    except OSError:
+    except OSError as error:
         control.cancel()
-        raise HTTPException(503, "Unable to record the runtime switch; the current mode remains active.") from None
+        raise HTTPException(503, "Unable to record the runtime switch; the current mode remains active.") from error
     background.add_task(control.shutdown)
     return {"mode": body.mode, "restarting": True}

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/runtime_database.py

@@ -46,9 +46,9 @@ def read_secret(name: str) -> tuple[UUID, str]:
         if not secret.uid or not value:
             raise ValueError("Empty Secret")
         return UUID(str(secret.uid)), value
-    except Exception:
+    except Exception as exc:
         raise RuntimeDatabaseError("unavailable", f"Cannot read the Environment Secret {name}. Create it in this "
-                                   "Environment, then deploy the API.") from None
+                                   "Environment, then deploy the API.") from exc
 
 
 def declaration(config):

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/app/source_passwords.py

@@ -1,5 +1,6 @@
 """Persist write-only credential fields through the runtime's CredentialStore."""
 
+import logging
 from contextlib import contextmanager
 from dataclasses import dataclass
 
@@ -11,6 +12,8 @@ from metatables.api.backend.integrations.credential_store import (
     CredentialStoreError,
 )
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass
 class PasswordConfiguration:
@@ -34,7 +37,7 @@ def password_configuration(configuration: dict, password: SecretStr | None, cred
                 prepared.values[field] = str(uid)
         yield prepared
     except CredentialStoreError as exc:
-        raise HTTPException(503, exc.message) from None
+        raise HTTPException(503, exc.message) from exc
     finally:
         if not prepared.saved:
             for uid in reversed(created):
@@ -43,4 +46,4 @@ def password_configuration(configuration: dict, password: SecretStr | None, cred
                 except Exception:
                     # Local rows roll back with the session. Hosted cleanup
                     # compensates only newly created Secrets, never old refs.
-                    pass
+                    logger.exception("Failed to delete a newly created credential during rollback")

{mainsequence_metatable-0.1.15 → mainsequence_metatable-0.1.16.dev28}/src/metatables/api/backend/backends/access.py

@@ -378,8 +378,8 @@ def _after_transaction_end(session, transaction):
     if committed and access is not None:
         try:
             access.finish_pending(session.get_bind())
-        except Exception:
-            raise SQLExecutionError(code="sql_permission_reconciliation_pending") from None
+        except Exception as exc:
+            raise SQLExecutionError(code="sql_permission_reconciliation_pending") from exc
 
 
 event.listen(Session, "after_commit", _after_commit)