svc-infra 0.1.602__tar.gz → 0.1.604__tar.gz

{svc_infra-0.1.602 → svc_infra-0.1.604}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: svc-infra
-Version: 0.1.602
+Version: 0.1.604
 Summary: Infrastructure for building and deploying prod-ready services
 License: MIT
 Keywords: fastapi,sqlalchemy,alembic,auth,infra,async,pydantic
@@ -91,8 +91,10 @@ svc-infra packages the shared building blocks we use to ship production FastAPI
 | Jobs | JobQueue, scheduler, CLI worker | [Jobs quickstart](docs/jobs.md) |
 | Cache | cashews decorators, namespace management, TTL helpers | [Cache guide](docs/cache.md) |
 | Observability | Prometheus middleware, Grafana automation, OTEL hooks | [Observability guide](docs/observability.md) |
+| Ops | Probes, breaker, SLOs & dashboards | [SLOs & Ops](docs/ops.md) |
 | Webhooks | Subscription store, signing, retry worker | [Webhooks framework](docs/webhooks.md) |
 | Security | Password policy, lockout, signed cookies, headers | [Security hardening](docs/security.md) |
+| Data Lifecycle | Fixtures, retention, erasure, backups | [Data lifecycle](docs/data-lifecycle.md) |
 
 ## Minimal FastAPI bootstrap
 

{svc_infra-0.1.602 → svc_infra-0.1.604}/README.md

@@ -15,8 +15,10 @@ svc-infra packages the shared building blocks we use to ship production FastAPI
 | Jobs | JobQueue, scheduler, CLI worker | [Jobs quickstart](docs/jobs.md) |
 | Cache | cashews decorators, namespace management, TTL helpers | [Cache guide](docs/cache.md) |
 | Observability | Prometheus middleware, Grafana automation, OTEL hooks | [Observability guide](docs/observability.md) |
+| Ops | Probes, breaker, SLOs & dashboards | [SLOs & Ops](docs/ops.md) |
 | Webhooks | Subscription store, signing, retry worker | [Webhooks framework](docs/webhooks.md) |
 | Security | Password policy, lockout, signed cookies, headers | [Security hardening](docs/security.md) |
+| Data Lifecycle | Fixtures, retention, erasure, backups | [Data lifecycle](docs/data-lifecycle.md) |
 
 ## Minimal FastAPI bootstrap
 

{svc_infra-0.1.602 → svc_infra-0.1.604}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "svc-infra"
-version = "0.1.602"
+version = "0.1.604"
 description = "Infrastructure for building and deploying prod-ready services"
 authors = ["Ali Khatami <aliikhatami94@gmail.com>"]
 license = "MIT"
@@ -127,6 +127,8 @@ markers = [
     "jobs: Background jobs and scheduling tests",
     "webhooks: Webhooks framework tests",
     "tenancy: Tenancy isolation and enforcement tests",
+    "data_lifecycle: Data lifecycle (fixtures, retention, erasure, backups)",
+    "ops: SLOs & Ops tests (probes, breaker, instrumentation)",
 ]
 filterwarnings = [
     "ignore:The `route` decorator is deprecated:DeprecationWarning:starlette.*",

{svc_infra-0.1.602 → svc_infra-0.1.604}/src/svc_infra/api/fastapi/db/sql/crud_router.py

@@ -46,6 +46,18 @@ def make_crud_router_plus_sql(
         redirect_slashes=False,
     )
 
+    def _coerce_id(v: Any) -> Any:
+        """Best-effort coercion of path ids: cast digit-only strings to int.
+
+        Keeps original type otherwise to avoid breaking non-integer IDs.
+        """
+        if isinstance(v, str) and v.isdigit():
+            try:
+                return int(v)
+            except Exception:
+                return v
+        return v
+
     def _parse_ordering_to_fields(order_spec: Optional[str]) -> list[str]:
         if not order_spec:
             return []
@@ -87,9 +99,7 @@ def make_crud_router_plus_sql(
         else:
             items = await service.list(session, limit=lp.limit, offset=lp.offset, order_by=order_by)
             total = await service.count(session)
-        return Page[read_schema].from_items(
-            total=total, items=items, limit=lp.limit, offset=lp.offset
-        )
+        return Page[Any].from_items(total=total, items=items, limit=lp.limit, offset=lp.offset)
 
     # -------- GET by id --------
     @router.get(
@@ -98,7 +108,7 @@ def make_crud_router_plus_sql(
         description=f"Get item of type {model.__name__}",
     )
     async def get_item(item_id: Any, session: SqlSessionDep):  # type: ignore[name-defined]
-        row = await service.get(session, item_id)
+        row = await service.get(session, _coerce_id(item_id))
         if not row:
             raise HTTPException(404, "Not found")
         return row
@@ -139,7 +149,7 @@ def make_crud_router_plus_sql(
             data = payload
         else:
             raise HTTPException(422, "invalid_payload")
-        row = await service.update(session, item_id, data)
+        row = await service.update(session, _coerce_id(item_id), data)
         if not row:
             raise HTTPException(404, "Not found")
         return row
@@ -149,7 +159,7 @@ def make_crud_router_plus_sql(
         "/{item_id}", status_code=204, description=f"Delete item of type {model.__name__}"
     )
     async def delete_item(item_id: Any, session: SqlSessionDep):  # type: ignore[name-defined]
-        ok = await service.delete(session, item_id)
+        ok = await service.delete(session, _coerce_id(item_id))
         if not ok:
             raise HTTPException(404, "Not found")
         return
@@ -180,6 +190,25 @@ def make_tenant_crud_router_plus_sql(
         redirect_slashes=False,
     )
 
+    # Evaluate the base service once to preserve in-memory state across requests in tests/local.
+    # Consumers may pass either an instance or a zero-arg factory function.
+    try:
+        _base_instance = service_factory() if callable(service_factory) else service_factory  # type: ignore[misc]
+    except TypeError:
+        # If the callable requires args, assume it's already an instance
+        _base_instance = service_factory  # type: ignore[assignment]
+
+    def _coerce_id(v: Any) -> Any:
+        """Best-effort coercion of path ids: cast digit-only strings to int.
+        Keeps original type otherwise.
+        """
+        if isinstance(v, str) and v.isdigit():
+            try:
+                return int(v)
+            except Exception:
+                return v
+        return v
+
     def _parse_ordering_to_fields(order_spec: Optional[str]) -> list[str]:
         if not order_spec:
             return []
@@ -194,17 +223,8 @@ def make_tenant_crud_router_plus_sql(
 
     # create per-request service with tenant scoping
     async def _svc(session: SqlSessionDep, tenant_id: TenantId):  # type: ignore[name-defined]
-        base = service_factory  # consumer-provided factory or instance
-        svc = base  # assume already a SqlService by default
-        if callable(base):
-            svc = base  # the consumer likely closed over repo
-            # if callable returns a service, call it now
-            try:
-                svc = base()  # type: ignore[misc]
-            except TypeError:
-                svc = base  # already instance
-        if not isinstance(svc, TenantSqlService):
-            svc = TenantSqlService(getattr(svc, "repo", svc), tenant_id=tenant_id, tenant_field=tenant_field)  # type: ignore[arg-type]
+        repo_or_service = getattr(_base_instance, "repo", _base_instance)
+        svc: Any = TenantSqlService(repo_or_service, tenant_id=tenant_id, tenant_field=tenant_field)  # type: ignore[arg-type]
         return svc  # type: ignore[return-value]
 
     @router.get("", response_model=cast(Any, Page[Any]))
@@ -232,14 +252,12 @@ def make_tenant_crud_router_plus_sql(
         else:
             items = await svc.list(session, limit=lp.limit, offset=lp.offset, order_by=order_by)
             total = await svc.count(session)
-        return Page[read_schema].from_items(
-            total=total, items=items, limit=lp.limit, offset=lp.offset
-        )
+        return Page[Any].from_items(total=total, items=items, limit=lp.limit, offset=lp.offset)
 
     @router.get("/{item_id}", response_model=cast(Any, Any))
     async def get_item(item_id: Any, session: SqlSessionDep, tenant_id: TenantId):  # type: ignore[name-defined]
         svc = await _svc(session, tenant_id)
-        row = await svc.get(session, item_id)
+        row = await svc.get(session, _coerce_id(item_id))
         if not row:
             raise HTTPException(404, "Not found")
         return row
@@ -273,7 +291,7 @@ def make_tenant_crud_router_plus_sql(
             data = payload
         else:
             raise HTTPException(422, "invalid_payload")
-        row = await svc.update(session, item_id, data)
+        row = await svc.update(session, _coerce_id(item_id), data)
         if not row:
             raise HTTPException(404, "Not found")
         return row
@@ -281,7 +299,7 @@ def make_tenant_crud_router_plus_sql(
     @router.delete("/{item_id}", status_code=204)
     async def delete_item(item_id: Any, session: SqlSessionDep, tenant_id: TenantId):  # type: ignore[name-defined]
         svc = await _svc(session, tenant_id)
-        ok = await svc.delete(session, item_id)
+        ok = await svc.delete(session, _coerce_id(item_id))
         if not ok:
             raise HTTPException(404, "Not found")
         return

{svc_infra-0.1.602 → svc_infra-0.1.604}/src/svc_infra/api/fastapi/docs/add.py

@@ -5,6 +5,8 @@ from pathlib import Path
 from typing import Optional
 
 from fastapi import FastAPI
+from fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html
+from fastapi.responses import HTMLResponse, JSONResponse
 
 
 def add_docs(
@@ -15,21 +17,41 @@ def add_docs(
     openapi_url: str = "/openapi.json",
     export_openapi_to: Optional[str] = None,
 ) -> None:
-    """Enable docs endpoints and optionally export OpenAPI schema to disk on startup."""
-    # Configure FastAPI docs URLs
-    app.docs_url = swagger_url
-    app.redoc_url = redoc_url
-    app.openapi_url = openapi_url
+    """Enable docs endpoints and optionally export OpenAPI schema to disk on startup.
 
+    We mount docs and OpenAPI routes explicitly so this works even when configured post-init.
+    """
+
+    # OpenAPI JSON route
+    async def openapi_handler() -> JSONResponse:  # noqa: ANN201
+        return JSONResponse(app.openapi())
+
+    app.add_api_route(openapi_url, openapi_handler, methods=["GET"], include_in_schema=False)
+
+    # Swagger UI route
+    async def swagger_ui() -> HTMLResponse:  # noqa: ANN201
+        return get_swagger_ui_html(openapi_url=openapi_url, title="API Docs")
+
+    app.add_api_route(swagger_url, swagger_ui, methods=["GET"], include_in_schema=False)
+
+    # Redoc route
+    async def redoc_ui() -> HTMLResponse:  # noqa: ANN201
+        return get_redoc_html(openapi_url=openapi_url, title="API ReDoc")
+
+    app.add_api_route(redoc_url, redoc_ui, methods=["GET"], include_in_schema=False)
+
+    # Optional export to disk on startup
     if export_openapi_to:
         export_path = Path(export_openapi_to)
 
-        @app.on_event("startup")
-        async def _export_spec() -> None:  # noqa: ANN202
+        async def _export_docs() -> None:
+            # Startup export
             spec = app.openapi()
             export_path.parent.mkdir(parents=True, exist_ok=True)
             export_path.write_text(json.dumps(spec, indent=2))
 
+        app.add_event_handler("startup", _export_docs)
+
 
 def add_sdk_generation_stub(
     app: FastAPI,

{svc_infra-0.1.602 → svc_infra-0.1.604}/src/svc_infra/cli/cmds/db/sql/alembic_cmds.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+from importlib import import_module
 from typing import List, Optional
 
 import typer
@@ -209,3 +210,28 @@ def register(app: typer.Typer) -> None:
     app.command("sql-stamp")(cmd_stamp)
     app.command("sql-merge-heads")(cmd_merge_heads)
     app.command("sql-setup-and-migrate")(cmd_setup_and_migrate)
+    app.command("sql-seed")(cmd_seed)
+
+
+def _import_callable(path: str):
+    mod_name, _, fn_name = path.partition(":")
+    if not mod_name or not fn_name:
+        raise typer.BadParameter("Expected format 'module.path:callable'")
+    mod = import_module(mod_name)
+    fn = getattr(mod, fn_name, None)
+    if not callable(fn):
+        raise typer.BadParameter(f"Callable '{fn_name}' not found in module '{mod_name}'")
+    return fn
+
+
+def cmd_seed(
+    target: str = typer.Argument(..., help="Seed callable path 'module:func'"),
+    database_url: Optional[str] = typer.Option(
+        None,
+        help="Database URL; overrides env for this command.",
+    ),
+):
+    """Run a user-provided seed function to load fixtures/reference data."""
+    apply_database_url(database_url)
+    fn = _import_callable(target)
+    fn()

{svc_infra-0.1.602 → svc_infra-0.1.604}/src/svc_infra/data/add.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import inspect
 from typing import Callable, Iterable, Optional
 
 from fastapi import FastAPI
@@ -30,10 +31,9 @@ def add_data_lifecycle(
     and offers extension points. Jobs should be scheduled using svc_infra.jobs helpers.
     """
 
-    @app.on_event("startup")
-    async def _data_lifecycle_startup() -> None:  # noqa: D401, ANN202
+    async def _run_lifecycle() -> None:
+        # Startup
         if auto_migrate:
-            # Use existing CLI function to perform end-to-end setup and migrate.
             cmd_setup_and_migrate(
                 database_url=database_url,
                 overwrite_scaffold=False,
@@ -44,10 +44,12 @@ def add_data_lifecycle(
                 discover_packages=discover_packages,
                 with_payments=with_payments,
             )
-
         if on_load_fixtures:
-            # Run user-provided fixture loader (idempotent expected).
-            on_load_fixtures()
+            res = on_load_fixtures()
+            if inspect.isawaitable(res):
+                await res  # type: ignore[misc]
+
+    app.add_event_handler("startup", _run_lifecycle)
 
     # Store optional jobs on app.state for external schedulers to discover/register.
     if retention_jobs is not None:

svc_infra-0.1.604/src/svc_infra/data/backup.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Callable, Optional
+
+
+@dataclass(frozen=True)
+class BackupHealthReport:
+    ok: bool
+    last_success: Optional[datetime]
+    retention_days: Optional[int]
+    message: str = ""
+
+
+def verify_backups(
+    *, last_success: Optional[datetime] = None, retention_days: Optional[int] = None
+) -> BackupHealthReport:
+    """Return a basic backup health report.
+
+    In production, callers should plug a provider-specific checker and translate into this report.
+    """
+    if last_success is None:
+        return BackupHealthReport(
+            ok=False, last_success=None, retention_days=retention_days, message="no_backup_seen"
+        )
+    now = datetime.now(timezone.utc)
+    age_days = (now - last_success).total_seconds() / 86400.0
+    ok = retention_days is None or age_days <= max(1, retention_days)
+    return BackupHealthReport(ok=ok, last_success=last_success, retention_days=retention_days)
+
+
+__all__ = ["BackupHealthReport", "verify_backups"]
+
+
+def make_backup_verification_job(
+    checker: Callable[[], BackupHealthReport],
+    *,
+    on_report: Optional[Callable[[BackupHealthReport], None]] = None,
+):
+    """Return a callable suitable for scheduling in a job runner.
+
+    The checker should perform provider-specific checks and return a BackupHealthReport.
+    If on_report is provided, it will be invoked with the report.
+    """
+
+    def _job() -> BackupHealthReport:
+        rep = checker()
+        if on_report:
+            on_report(rep)
+        return rep
+
+    return _job

svc_infra-0.1.604/src/svc_infra/data/erasure.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Iterable, Optional, Protocol
+
+
+class SqlSession(Protocol):  # minimal protocol for tests/integration
+    async def execute(self, stmt: Any) -> Any:
+        pass
+
+
+@dataclass(frozen=True)
+class ErasureStep:
+    name: str
+    run: Callable[[SqlSession, str], Awaitable[int] | int]
+
+
+@dataclass(frozen=True)
+class ErasurePlan:
+    steps: Iterable[ErasureStep]
+
+
+async def run_erasure(
+    session: SqlSession,
+    principal_id: str,
+    plan: ErasurePlan,
+    *,
+    on_audit: Optional[Callable[[str, dict[str, Any]], None]] = None,
+) -> int:
+    """Run an erasure plan and optionally emit an audit event.
+
+    Returns total affected rows across steps.
+    """
+    total = 0
+    for s in plan.steps:
+        res = s.run(session, principal_id)
+        if hasattr(res, "__await__"):
+            res = await res  # type: ignore[misc]
+        total += int(res or 0)
+    if on_audit:
+        on_audit("erasure.completed", {"principal_id": principal_id, "affected": total})
+    return total
+
+
+__all__ = ["ErasureStep", "ErasurePlan", "run_erasure"]

svc_infra-0.1.604/src/svc_infra/data/fixtures.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import inspect
+from pathlib import Path
+from typing import Awaitable, Callable, Iterable, Optional
+
+
+async def run_fixtures(
+    loaders: Iterable[Callable[[], None | Awaitable[None]]], *, run_once_file: Optional[str] = None
+) -> None:
+    """Run a sequence of fixture loaders (sync or async).
+
+    - If run_once_file is provided and exists, does nothing.
+    - On success, creates the run_once_file sentinel (parent dirs included).
+    """
+    if run_once_file:
+        sentinel = Path(run_once_file)
+        if sentinel.exists():
+            return
+    for fn in loaders:
+        res = fn()
+        if inspect.isawaitable(res):  # type: ignore[arg-type]
+            await res  # type: ignore[misc]
+    if run_once_file:
+        sentinel.parent.mkdir(parents=True, exist_ok=True)
+        Path(run_once_file).write_text("ok")
+
+
+def make_on_load_fixtures(
+    *loaders: Callable[[], None | Awaitable[None]], run_once_file: Optional[str] = None
+) -> Callable[[], Awaitable[None]]:
+    """Return an async callable suitable for add_data_lifecycle(on_load_fixtures=...)."""
+
+    async def _runner() -> None:
+        await run_fixtures(loaders, run_once_file=run_once_file)
+
+    return _runner
+
+
+__all__ = ["run_fixtures", "make_on_load_fixtures"]

svc_infra-0.1.604/src/svc_infra/data/retention.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from typing import Any, Iterable, Optional, Protocol, Sequence
+
+
+class SqlSession(Protocol):  # minimal protocol for tests/integration
+    async def execute(self, stmt: Any) -> Any:
+        pass
+
+
+@dataclass(frozen=True)
+class RetentionPolicy:
+    name: str
+    model: Any  # SQLAlchemy model or test double exposing columns
+    older_than_days: int
+    soft_delete_field: Optional[str] = "deleted_at"
+    extra_where: Optional[Sequence[Any]] = None
+    hard_delete: bool = False
+
+
+async def purge_policy(session: SqlSession, policy: RetentionPolicy) -> int:
+    """Execute a single retention purge according to policy.
+
+    If hard_delete is False and soft_delete_field exists on model, set timestamp; else DELETE.
+    Returns number of affected rows (best-effort; test doubles may return an int directly).
+    """
+    cutoff = datetime.now(timezone.utc) - timedelta(days=policy.older_than_days)
+    m = policy.model
+    where = list(policy.extra_where or [])
+    created_col = getattr(m, "created_at", None)
+    if created_col is not None and hasattr(created_col, "__le__"):
+        where.append(created_col <= cutoff)  # type: ignore[operator]
+
+    # Soft-delete path when available and requested
+    if not policy.hard_delete and policy.soft_delete_field and hasattr(m, policy.soft_delete_field):
+        stmt = m.update().where(*where).values({policy.soft_delete_field: cutoff})  # type: ignore[attr-defined]
+        res = await session.execute(stmt)
+        return getattr(res, "rowcount", 0)
+
+    # Hard delete fallback
+    stmt = m.delete().where(*where)  # type: ignore[attr-defined]
+    res = await session.execute(stmt)
+    return getattr(res, "rowcount", 0)
+
+
+async def run_retention_purge(session: SqlSession, policies: Iterable[RetentionPolicy]) -> int:
+    total = 0
+    for p in policies:
+        total += await purge_policy(session, p)
+    return total
+
+
+__all__ = ["RetentionPolicy", "purge_policy", "run_retention_purge"]

{svc_infra-0.1.602 → svc_infra-0.1.604}/src/svc_infra/db/sql/repository.py

@@ -124,9 +124,10 @@ class SqlRepository:
             return False
         if self.soft_delete:
             # Prefer timestamp, also optionally set flag to False
-            if hasattr(self.model, self.soft_delete_field):
+            # Check attributes on the instance to support test doubles without class-level fields
+            if hasattr(obj, self.soft_delete_field):
                 setattr(obj, self.soft_delete_field, func.now())
-            if self.soft_delete_flag_field and hasattr(self.model, self.soft_delete_flag_field):
+            if self.soft_delete_flag_field and hasattr(obj, self.soft_delete_flag_field):
                 setattr(obj, self.soft_delete_flag_field, False)
             await session.flush()
             return True

svc_infra-0.1.604/src/svc_infra/obs/add.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Iterable, Optional, Protocol
+
+from svc_infra.obs.settings import ObservabilitySettings
+
+
+def _want_metrics(cfg: ObservabilitySettings) -> bool:
+    return bool(cfg.METRICS_ENABLED)
+
+
+class RouteClassifier(Protocol):
+    def __call__(
+        self, route_path: str, method: str
+    ) -> str:  # e.g., returns "public|internal|admin"
+        ...
+
+
+def add_observability(
+    app: Any | None = None,
+    *,
+    db_engines: Optional[Iterable[Any]] = None,
+    metrics_path: str | None = None,
+    skip_metric_paths: Optional[Iterable[str]] = None,
+    route_classifier: RouteClassifier | None = None,
+) -> Callable[[], None]:
+    """
+    Enable Prometheus metrics for the ASGI app and optional SQLAlchemy pool metrics.
+    Returns a no-op shutdown callable for API compatibility.
+    """
+    cfg = ObservabilitySettings()
+
+    # --- Metrics (Prometheus) — import lazily so CLIs/tests don’t require prometheus_client
+    if app is not None and _want_metrics(cfg):
+        try:
+            from svc_infra.obs.metrics.asgi import (  # lazy
+                PrometheusMiddleware,
+                add_prometheus,
+                metrics_endpoint,
+            )
+
+            path = metrics_path or cfg.METRICS_PATH
+            skip_paths = tuple(skip_metric_paths or (path, "/health", "/healthz"))
+            # If a route_classifier is provided, use a custom route_resolver to append class label
+            if route_classifier is None:
+                add_prometheus(
+                    app,
+                    path=path,
+                    skip_paths=skip_paths,
+                )
+            else:
+                # Install middleware manually to pass route_resolver
+                def _resolver(req):
+                    # Base template
+                    from svc_infra.obs.metrics.asgi import _route_template  # type: ignore
+
+                    base = _route_template(req)
+                    method = getattr(req, "method", "GET")
+                    cls = route_classifier(base, method)
+                    # Encode as base|class for downstream label splitting in dashboards
+                    return f"{base}|{cls}"
+
+                app.add_middleware(
+                    PrometheusMiddleware,
+                    skip_paths=skip_paths,
+                    route_resolver=_resolver,
+                )
+                # Mount /metrics endpoint without re-adding middleware
+                try:
+                    from svc_infra.api.fastapi.dual.public import public_router
+                    from svc_infra.app.env import CURRENT_ENVIRONMENT, DEV_ENV, LOCAL_ENV
+
+                    router = public_router()
+                    router.add_api_route(
+                        path,
+                        endpoint=metrics_endpoint(),
+                        include_in_schema=CURRENT_ENVIRONMENT in (LOCAL_ENV, DEV_ENV),
+                        tags=["observability"],
+                    )
+                    app.include_router(router)
+                except Exception:
+                    app.add_route(path, metrics_endpoint())
+        except Exception:
+            pass
+
+    # --- DB pool metrics (best effort) — also lazy
+    if db_engines:
+        try:
+            from svc_infra.obs.metrics.sqlalchemy import bind_sqlalchemy_pool_metrics  # lazy
+
+            for eng in db_engines:
+                try:
+                    bind_sqlalchemy_pool_metrics(eng)
+                except Exception:
+                    pass
+        except Exception:
+            pass
+
+    # --- HTTP client metrics (best effort) — import lazily
+    try:
+        from svc_infra.obs.metrics.http import instrument_httpx, instrument_requests  # lazy
+
+        try:
+            instrument_requests()
+        except Exception:
+            pass
+        try:
+            instrument_httpx()
+        except Exception:
+            pass
+    except Exception:
+        pass
+
+    # Tracing removed; return no-op for backward compatibility
+    return lambda: None