simple-module-background-tasks 0.0.37__tar.gz → 0.0.39__tar.gz

{simple_module_background_tasks-0.0.37 → simple_module_background_tasks-0.0.39}/.gitignore

@@ -7,8 +7,6 @@ build/
 .venv/
 *.egg
 
-# UV
-uv.lock
 
 # Node
 node_modules/
@@ -65,3 +63,4 @@ host/client_app/.playwright-cli/*
 .qa/
 .verify/
 /openapi.json
+qa-shots/

{simple_module_background_tasks-0.0.37 → simple_module_background_tasks-0.0.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_background_tasks
-Version: 0.0.37
+Version: 0.0.39
 Summary: Celery + Redis task queue with admin UI for monitoring and retrying failed/stuck tasks
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -21,12 +21,12 @@ Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
-Requires-Dist: celery[redis]>=5.4
-Requires-Dist: redis>=5
-Requires-Dist: simple-module-core==0.0.37
-Requires-Dist: simple-module-db==0.0.37
-Requires-Dist: simple-module-hosting==0.0.37
-Requires-Dist: simple-module-settings==0.0.37
+Requires-Dist: celery[redis]<6,>=5.4
+Requires-Dist: redis<7,>=5
+Requires-Dist: simple-module-core==0.0.39
+Requires-Dist: simple-module-db==0.0.39
+Requires-Dist: simple-module-hosting==0.0.39
+Requires-Dist: simple-module-settings==0.0.39
 Description-Content-Type: text/markdown
 
 # simple_module_background_tasks

simple_module_background_tasks-0.0.39/background_tasks/__init__.py

@@ -0,0 +1,39 @@
+"""BackgroundTasks module — Celery + Redis task queue with admin UI."""
+
+from typing import TYPE_CHECKING, Any
+
+from background_tasks.after_commit import enqueue_after_commit
+from background_tasks.log_context import (
+    bind_task_context,
+    get_log_context,
+    install_log_filter,
+)
+
+if TYPE_CHECKING:
+    from background_tasks.task_heartbeat import heartbeat
+    from background_tasks.worker_settings import settings_for
+
+_LAZY_HEARTBEAT = "heartbeat"
+_LAZY_SETTINGS = "settings_for"
+
+
+def __getattr__(name: str) -> Any:
+    if name == _LAZY_HEARTBEAT:
+        from background_tasks.task_heartbeat import heartbeat
+
+        return heartbeat
+    if name == _LAZY_SETTINGS:
+        from background_tasks.worker_settings import settings_for
+
+        return settings_for
+    raise AttributeError(name)
+
+
+__all__ = [
+    "bind_task_context",
+    "enqueue_after_commit",
+    "get_log_context",
+    "heartbeat",
+    "install_log_filter",
+    "settings_for",
+]

simple_module_background_tasks-0.0.39/background_tasks/_lifecycle.py

@@ -0,0 +1,174 @@
+"""Startup/shutdown wiring for the BackgroundTasks module.
+
+``BackgroundTasksModule`` keeps the ``on_startup`` / ``on_shutdown`` hooks and
+delegates here, so the module file stays a declaration of what the module
+contributes and this file owns the order things are installed and torn down.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
+logger = logging.getLogger(__name__)
+
+
+async def startup(app: FastAPI, module_name: str) -> None:
+    """Build the Celery app, install signal handlers, hand-off to worker."""
+    import asyncio
+
+    from simple_module_hosting.log_sinks import redact
+
+    from background_tasks.celery_app import build_celery
+    from background_tasks.db_settings import worker_database_options
+    from background_tasks.log_sink import install_log_sink
+    from background_tasks.signals import bind_event_bus
+    from background_tasks.sync_db import configure_database, set_database_url
+    from background_tasks.tenant_context import set_default_tenant
+
+    services = app.state.background_tasks
+    # Pin the sync engine to the same URL the host's async settings
+    # resolved — pydantic-settings reads ``.env`` but never propagates
+    # to ``os.environ``, so signals would otherwise fall back to the
+    # SQLite default and silently drop ``TaskExecution`` rows.
+    host = app.state.sm.settings
+    multi = bool(getattr(host, "multi_tenant", False))
+    default_tenant = None if multi else getattr(host, "default_tenant", "") or None
+    set_database_url(host.database_url, tenant_strict=multi, default_tenant=default_tenant)
+    configure_database(worker_database_options(host, services.settings))
+    set_default_tenant(default_tenant)
+    # build_celery imports `signals` for side effects and runs
+    # `autodiscover_tasks` across every installed module.
+    services.celery = build_celery(services.settings)
+    # Let signal handlers hop onto the API loop to publish events.
+    # In a standalone worker process this bind never runs, so signals
+    # stay a silent no-op — that's the documented cross-process limit.
+    bind_event_bus(app.state.sm.event_bus, asyncio.get_running_loop())
+    install_durable_transport(app)
+    install_log_sink(services.settings)
+    logger.info(
+        "BackgroundTasks: Celery app ready (broker=%s, queue=%s)",
+        redact(services.settings.broker_url),
+        services.settings.task_default_queue,
+    )
+
+    await start_invalidation_transport(app)
+
+    # Registered here, not in register_health_checks: the Celery app does
+    # not exist until this hook builds it, and the check must follow later
+    # settings changes rather than pinning the boot-time instance.
+    from simple_module_core.health import HealthCheck
+
+    from background_tasks.health import CHECK_REDIS, build_redis_check
+
+    app.state.sm.health_registry.add(
+        HealthCheck(
+            name=CHECK_REDIS,
+            check=build_redis_check(app),
+            module=module_name,
+            # On demand only, like the mailer and storage checks. An
+            # earlier version had this on the readiness probe, reasoning
+            # that Redis is infrastructure this app owns rather than a
+            # third party. That conflates two different questions: whether
+            # this process can serve requests, and whether the system is
+            # fully functional. Failing readiness pulls the web tier out of
+            # the load balancer, turning "background jobs are backed up"
+            # into "the site is down" — and it made /health/ready report
+            # unhealthy on every deployment without Redis, which CI caught.
+            # The wizard's connection step and the settings screen's "Test
+            # connection" both run it explicitly, which is what it is for.
+            probe=False,
+        )
+    )
+
+
+def install_durable_transport(app: FastAPI) -> None:
+    """Make ``bus.publish_durable`` write to this module's outbox (GH #459)."""
+    from background_tasks.constants import OutboxMode
+    from background_tasks.outbox_sweep import start_sweep
+    from background_tasks.outbox_transport import OutboxTransport
+    from background_tasks.outbox_worker import use_bus
+
+    bus = app.state.sm.event_bus
+    services = app.state.background_tasks
+    mode = (
+        OutboxMode.INPROCESS
+        if services.celery.conf.task_always_eager
+        else OutboxMode(services.settings.outbox_mode)
+    )
+    transport = OutboxTransport(services=services, bus=bus, db_state=app.state.sm.db, mode=mode)
+    bus.durable_transport = transport
+    if mode == OutboxMode.INPROCESS:
+        start_sweep(services, app.state.sm.db.session_factory, bus, transport.policy)
+    # An eager in-process dispatch delivers with the app's bus, which already
+    # carries every module's durable subscriptions.
+    use_bus(bus)
+
+
+async def start_invalidation_transport(app: FastAPI) -> None:
+    """Hand the framework bus the Redis connection this module configures.
+
+    The transport is installed here rather than in a registration hook
+    because it needs a running event loop for its listener task, and it is
+    installed by *this* module because it owns the Redis URL — a cache-owning
+    module opening its own connection is the duplication GH #318 exists to
+    avoid.
+
+    A worker process that runs Celery without the FastAPI app never reaches
+    this, so it publishes nothing and hears nothing. That is the same
+    documented cross-process limit as ``bind_event_bus`` above: a task that
+    invalidates a cache should do it through an API call or accept the TTL.
+    """
+    from background_tasks.invalidation import RedisInvalidationTransport
+
+    services = app.state.background_tasks
+    s = services.settings
+    if not s.broadcast_invalidations:
+        logger.info(
+            "BackgroundTasks: cross-worker cache invalidation disabled "
+            "(broadcast_invalidations=false) — per-process caches expire on their own TTL"
+        )
+        return
+
+    bus = app.state.sm.invalidation
+    transport = RedisInvalidationTransport(bus, s.broker_url, s.invalidation_channel)
+    await transport.start()
+    bus.set_transport(transport)
+    services.invalidation_transport = transport
+    logger.info(
+        "BackgroundTasks: invalidation transport on %r for channel(s) %s",
+        s.invalidation_channel,
+        ", ".join(bus.channels) or "(none subscribed)",
+    )
+
+
+async def shutdown(app: FastAPI) -> None:
+    from background_tasks.log_sink import uninstall_log_sink
+    from background_tasks.outbox_sweep import stop_sweep
+    from background_tasks.outbox_worker import reset_worker_state
+    from background_tasks.signals import unbind_event_bus
+    from background_tasks.sync_db import dispose_sync_engine
+
+    await stop_sweep(app.state.background_tasks)
+    bus = getattr(app.state.sm, "event_bus", None)
+    if bus is not None:
+        drain = getattr(bus.durable_transport, "drain", None)
+        if drain is not None:
+            # Eager deliveries still running on this loop.
+            await drain()
+        bus.durable_transport = None
+    reset_worker_state()
+    services = app.state.background_tasks
+    if services.invalidation_transport is not None:
+        app.state.sm.invalidation.clear_transport()
+        await services.invalidation_transport.stop()
+        services.invalidation_transport = None
+    if services.celery is not None:
+        services.celery.close()
+    unbind_event_bus()
+    # Before the engine goes: the final flush still needs it.
+    uninstall_log_sink()
+    dispose_sync_engine()

{simple_module_background_tasks-0.0.37 → simple_module_background_tasks-0.0.39}/background_tasks/_signal_bus.py

@@ -7,6 +7,7 @@ re-exports :func:`bind_event_bus` / :func:`unbind_event_bus`.
 from __future__ import annotations
 
 import asyncio
+import concurrent.futures
 import logging
 from typing import Any
 
@@ -53,7 +54,7 @@ def publish_from_signal(event: Any) -> None:
     future.add_done_callback(_log_publish_failure)
 
 
-def _log_publish_failure(future: asyncio.Future[Any]) -> None:
+def _log_publish_failure(future: concurrent.futures.Future[Any]) -> None:
     if future.cancelled():
         return
     exc = future.exception()

{simple_module_background_tasks-0.0.37 → simple_module_background_tasks-0.0.39}/background_tasks/_signal_support.py

@@ -7,14 +7,21 @@ These helpers are intentionally side-effect-free except for the DB write in
 
 from __future__ import annotations
 
+import logging
 import traceback as tb_mod
+from collections.abc import Callable
 from datetime import UTC, datetime
 from typing import Any
 
 from sqlalchemy import select
 from sqlalchemy.orm import Session
+from sqlmodel import col
 
+from background_tasks.constants import INTERNAL_TASK_SWEEP_OUTBOX, TaskStatus
 from background_tasks.models import TaskExecution
+from background_tasks.sync_db import sync_session
+
+logger = logging.getLogger(__name__)
 
 
 def now_utc() -> datetime:
@@ -47,7 +54,7 @@ def upsert_by_celery_id(
     """
     row: TaskExecution | None = None
     if celery_task_id:
-        stmt = select(TaskExecution).where(TaskExecution.celery_task_id == celery_task_id)
+        stmt = select(TaskExecution).where(col(TaskExecution.celery_task_id) == celery_task_id)
         row = session.execute(stmt).scalar_one_or_none()
     if row is None:
         row = TaskExecution(celery_task_id=celery_task_id, **defaults)
@@ -103,3 +110,48 @@ def render_traceback(einfo: Any, exception: BaseException | None) -> str | None:
     if exception is not None:
         return "".join(tb_mod.format_exception(type(exception), exception, exception.__traceback__))
     return None
+
+
+# Beat ticks that fire every few seconds and are a no-op almost every time;
+# recording each run buried real work (QA, GH #459). Only a run that went wrong
+# is worth a row.
+_UNRECORDED_WHEN_QUIET = frozenset({INTERNAL_TASK_SWEEP_OUTBOX})
+_QUIET_STATUSES = frozenset({None, TaskStatus.PENDING, TaskStatus.RUNNING, TaskStatus.SUCCESS})
+
+
+def apply_signal(
+    handler: str,
+    *,
+    celery_task_id: str | None,
+    defaults: dict[str, Any],
+    after: Callable[[TaskExecution], None] | None = None,
+    tenant_id: str | None = None,
+    owner_user_id: str | None = None,
+) -> TaskExecution | None:
+    """Open a sync session, upsert by celery_task_id, log on failure.
+
+    Returns the upserted row (or ``None`` if the session raised) so callers
+    can read DB-assigned fields like ``id`` without a second round trip.
+
+    ``tenant_id`` and ``owner_user_id`` (the message's) are written only when
+    known, so a signal whose message carries neither never blanks a row already
+    stamped.
+    """
+    if (
+        defaults.get("task_name") in _UNRECORDED_WHEN_QUIET
+        and defaults.get("status") in _QUIET_STATUSES
+    ):
+        return None
+    if tenant_id:
+        defaults = {**defaults, "tenant_id": tenant_id}
+    if owner_user_id:
+        defaults = {**defaults, "owner_user_id": owner_user_id}
+    try:
+        with sync_session() as session:
+            row = upsert_by_celery_id(session, celery_task_id=celery_task_id, defaults=defaults)
+            if after is not None:
+                after(row)
+            return row
+    except Exception:
+        logger.exception("%s failed for task_id=%s", handler, celery_task_id)
+        return None

{simple_module_background_tasks-0.0.37 → simple_module_background_tasks-0.0.39}/background_tasks/after_commit.py

@@ -30,13 +30,24 @@ import uuid
 from collections.abc import Callable, Sequence
 from typing import Any
 
-from celery import current_app
 from simple_module_db import RequestSession, bind_current_tenant, mark_written
 from simple_module_db.transaction import SESSION_START_KEY
 from sqlalchemy import event
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session, SessionTransaction
 
+
+class _LazyCurrentApp:
+    """``celery.current_app``, imported on first use so importing this module stays light."""
+
+    def __getattr__(self, name: str) -> Any:
+        from celery import current_app as _current_app
+
+        return getattr(_current_app, name)
+
+
+current_app: Any = _LazyCurrentApp()
+
 logger = logging.getLogger(__name__)
 
 type Publish = Callable[[], object]
@@ -48,6 +59,11 @@ _HOOKED_KEY = "background_tasks_after_commit_hooked"
 def enqueue_after_commit(db: AsyncSession | Session, task: Any, *args: Any, **kwargs: Any) -> str:
     """Send *task* once *db*'s transaction commits; never if it rolls back.
 
+    Delivery is at-most-once: publish intent exists only in memory. Broker
+    failure after commit is logged without retry; a process exit between commit
+    and publish also loses the job. For must-run work use the event bus's
+    ``publish_durable(event, db)`` transactional outbox with a durable handler.
+
     *task* is a Celery task (``send_receipt``), a signature
     (``send_receipt.s().set(queue="mail")``, for routing options), or a
     registered task name. ``*args`` / ``**kwargs`` are the task's own
@@ -78,7 +94,7 @@ def after_commit(
     request. Left off for a single publish so Celery's eager mode — which runs
     the task body inside the publish — stays on the loop's thread. One failed
     publish is logged and does not stop the rest: the rows are already
-    committed, and an unsent ``pending`` row is visible and retryable.
+    committed. Only callers with persisted pending work can reconcile failures.
     """
     batch = list(publishes)
     if isinstance(db, RequestSession) and SESSION_START_KEY in db.info:

{simple_module_background_tasks-0.0.37 → simple_module_background_tasks-0.0.39}/background_tasks/constants.py

@@ -18,9 +18,8 @@ TABLE_TASK_EXECUTION = f"{TABLE_PREFIX}task_execution"
 TABLE_OUTBOX = f"{TABLE_PREFIX}outbox"
 
 # ── Module dependencies ─────────────────────────────────────────
-_MODULE_USERS = "Users"
-# register_settings() calls settings.registration.register_module_settings,
-# which reads app.state.settings — so Settings must register first.
+# Sorted after Settings for its admin editor and reload path; registering
+# settings itself no longer needs it (the framework owns the registry, #500).
 _MODULE_SETTINGS = "Settings"
 
 # ── Env / settings ──────────────────────────────────────────────
@@ -42,10 +41,14 @@ API_PREFIX = "/api/background_tasks"
 VIEW_PREFIX = "/admin/background-tasks"
 ADMIN_ROUTER_PREFIX = "/admin"
 
+STATUS_ROUTER_PREFIX = "/tasks"
+
 # ── Menu ────────────────────────────────────────────────────────
 MENU_LABEL = "Background tasks"
 MENU_ICON = "activity"
 MENU_ORDER = 120
+LOGS_MENU_LABEL = "Logs"
+LOGS_MENU_ICON = "scroll-text"
 
 # ── Page identifiers ────────────────────────────────────────────
 # Kept as literals at the call site (see endpoints/views.py) so
@@ -141,7 +144,7 @@ class OutboxScope(StrEnum):
 
 
 DEFAULT_OUTBOX_MAX_ATTEMPTS = 8
-DEFAULT_OUTBOX_SWEEP_INTERVAL_SECONDS = 30
+DEFAULT_OUTBOX_SWEEP_INTERVAL_SECONDS = 5
 # How long a claimed row stays ``running`` before another worker may reclaim it.
 # Durable handlers are cut off ``outbox_lease_margin`` before it, so no run can
 # outlive its claim and overlap the rerun a reclaim would start.
@@ -173,3 +176,26 @@ OUTBOX_KEY_MAX_LENGTH = 255
 TENANT_ID_MAX_LENGTH = 50
 # Filter value meaning "executions with no tenant" (beat / platform publishes).
 PLATFORM_TENANT_FILTER = "__platform__"
+
+OWNER_ID_MAX_LENGTH = 64
+PROGRESS_MESSAGE_MAX_LENGTH = 255
+PROGRESS_PHASE_MAX_LENGTH = 64
+
+
+class OutboxMode(StrEnum):
+    CELERY = "celery"
+    INPROCESS = "inprocess"
+
+
+# ── Retained logs (GH #537) ─────────────────────────────────────
+TABLE_LOG_RECORD = f"{TABLE_PREFIX}log_record"
+LOG_MESSAGE_MAX_LENGTH = 4096
+LOG_NAME_MAX_LENGTH = 255
+LOG_ID_MAX_LENGTH = 64
+LOG_EXTRA_MAX_KEYS = 20
+LOG_EXTRA_VALUE_MAX_LENGTH = 1000
+DEFAULT_LOG_SINK_LEVEL = "INFO"
+DEFAULT_LOG_RETENTION_DAYS = 7
+LOG_PER_PAGE = 50
+# Level names the admin filter offers, lowest first.
+LOG_LEVEL_NAMES = ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")

simple_module_background_tasks-0.0.39/background_tasks/contracts/logs.py

@@ -0,0 +1,31 @@
+"""DTOs for the retained-log screens (GH #537)."""
+
+from __future__ import annotations
+
+import uuid
+from datetime import datetime
+from typing import Any
+
+from simple_module_db.types import AwareDateTime
+from sqlmodel import Field, SQLModel
+
+
+class LogItem(SQLModel):
+    id: uuid.UUID
+    ts: datetime = Field(sa_type=AwareDateTime())
+    level: int
+    level_name: str
+    logger: str
+    message: str
+    task_id: str | None = None
+    job_id: str | None = None
+    tenant_id: str | None = None
+    correlation_id: str | None = None
+    extra: dict[str, Any] = Field(default_factory=dict)
+
+
+class LogListResponse(SQLModel):
+    items: list[LogItem]
+    total: int
+    page: int
+    per_page: int

{simple_module_background_tasks-0.0.37 → simple_module_background_tasks-0.0.39}/background_tasks/contracts/outbox.py

@@ -15,7 +15,7 @@ from background_tasks.constants import OutboxStatus
 class OutboxItem(SQLModel):
     """One (event, durable handler) delivery as the admin screen shows it."""
 
-    model_config = ConfigDict(from_attributes=True)
+    model_config = ConfigDict(from_attributes=True)  # ty: ignore[invalid-assignment]
 
     id: uuid.UUID
     event_key: str

{simple_module_background_tasks-0.0.37 → simple_module_background_tasks-0.0.39}/background_tasks/contracts/schemas.py

@@ -6,7 +6,7 @@ import uuid
 from datetime import datetime
 from typing import Any
 
-from pydantic import ConfigDict
+from pydantic import ConfigDict, field_validator
 from sqlmodel import SQLModel
 
 from background_tasks.constants import TaskStatus
@@ -21,7 +21,7 @@ class TaskExecutionListItem(SQLModel):
     the operator needs to read it *before* confirming, not on a second page.
     """
 
-    model_config = ConfigDict(from_attributes=True)
+    model_config = ConfigDict(from_attributes=True)  # ty: ignore[invalid-assignment]
 
     id: uuid.UUID
     celery_task_id: str | None = None
@@ -39,11 +39,21 @@ class TaskExecutionListItem(SQLModel):
     exception_type: str | None = None
     retried_from_id: uuid.UUID | None = None
 
+    @field_validator("args", mode="before")
+    @classmethod
+    def _args_none(cls, v: Any) -> Any:
+        return [] if v is None else v
+
+    @field_validator("kwargs", mode="before")
+    @classmethod
+    def _kwargs_none(cls, v: Any) -> Any:
+        return {} if v is None else v
+
 
 class TaskExecutionDetail(SQLModel):
     """Full row for the detail page (adds args/kwargs/result/traceback)."""
 
-    model_config = ConfigDict(from_attributes=True)
+    model_config = ConfigDict(from_attributes=True)  # ty: ignore[invalid-assignment]
 
     id: uuid.UUID
     celery_task_id: str | None = None
@@ -59,6 +69,45 @@ class TaskExecutionDetail(SQLModel):
     worker: str | None = None
     retries: int = 0
     retried_from_id: uuid.UUID | None = None
+    owner_user_id: str | None = None
+    progress_current: int | None = None
+    progress_total: int | None = None
+    progress_message: str | None = None
+    progress_phase: str | None = None
+    queued_at: datetime | None = None
+    started_at: datetime | None = None
+    finished_at: datetime | None = None
+    heartbeat_at: datetime | None = None
+
+    @field_validator("args", mode="before")
+    @classmethod
+    def _args_none(cls, v: Any) -> Any:
+        return [] if v is None else v
+
+    @field_validator("kwargs", mode="before")
+    @classmethod
+    def _kwargs_none(cls, v: Any) -> Any:
+        return {} if v is None else v
+
+
+class TaskStatusDTO(SQLModel):
+    """What the owner of a task may see of it (#536).
+
+    Deliberately narrower than :class:`TaskExecutionDetail`: no args, kwargs,
+    result or traceback, and the error is the exception's *type name* only —
+    a message or traceback can carry other users' data or server internals.
+    """
+
+    model_config = ConfigDict(from_attributes=True)  # ty: ignore[invalid-assignment]
+
+    celery_task_id: str
+    task_name: str
+    status: TaskStatus
+    progress_current: int | None = None
+    progress_total: int | None = None
+    progress_message: str | None = None
+    progress_phase: str | None = None
+    exception_type: str | None = None
     queued_at: datetime | None = None
     started_at: datetime | None = None
     finished_at: datetime | None = None

simple_module_background_tasks-0.0.39/background_tasks/db_settings.py

@@ -0,0 +1,34 @@
+"""Restart-required worker engine settings."""
+
+from typing import Any
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+_RESTART = {"requires_restart": True, "group": "Database"}
+
+
+class WorkerDatabaseSettings(BaseSettings):
+    """Inherited by BackgroundTasksSettings with its SM_BG_TASKS_ env prefix."""
+
+    db_pool_size: int = Field(default=2, ge=1, json_schema_extra=_RESTART)
+    db_max_overflow: int = Field(default=3, ge=0, json_schema_extra=_RESTART)
+    db_recycle: int = Field(default=1800, ge=0, json_schema_extra=_RESTART)
+    db_statement_timeout_ms: int | None = Field(default=None, ge=0, json_schema_extra=_RESTART)
+
+
+def worker_database_options(host: Any, worker: WorkerDatabaseSettings) -> dict[str, int]:
+    """Use host timeouts unless the worker has an explicit statement limit."""
+    return {
+        "pool_size": worker.db_pool_size,
+        "max_overflow": worker.db_max_overflow,
+        "pool_recycle": worker.db_recycle,
+        "pool_timeout": host.db_pool_timeout,
+        "connect_timeout": host.db_connect_timeout,
+        "statement_timeout_ms": (
+            host.db_statement_timeout_ms
+            if worker.db_statement_timeout_ms is None
+            else worker.db_statement_timeout_ms
+        ),
+        "idle_in_tx_timeout_ms": host.db_idle_in_tx_timeout_ms,
+    }

{simple_module_background_tasks-0.0.37 → simple_module_background_tasks-0.0.39}/background_tasks/deps.py

@@ -8,6 +8,7 @@ from simple_module_core.permissions import is_admin
 from simple_module_db import RequestSession, current_tenant_id
 from simple_module_db.deps import get_db
 
+from background_tasks.log_service import LogScope, LogService
 from background_tasks.outbox_service import OutboxScope, OutboxService
 from background_tasks.outbox_transport import OutboxTransport
 from background_tasks.service import BackgroundTaskService
@@ -49,3 +50,11 @@ def outbox_scope(request: Request) -> OutboxScope:
         return OutboxScope(tenant_id=tenant_id)
     multi_tenant = bool(getattr(request.app.state.sm.settings, "multi_tenant", False))
     return OutboxScope(everything=not multi_tenant)
+
+
+async def get_log_service(
+    request: Request,
+    db: RequestSession = Depends(get_db),
+) -> LogService:
+    scope = outbox_scope(request)
+    return LogService(db=db, scope=LogScope(everything=scope.everything, tenant_id=scope.tenant_id))

{simple_module_background_tasks-0.0.37 → simple_module_background_tasks-0.0.39}/background_tasks/endpoints/api_admin.py

@@ -5,6 +5,8 @@ from __future__ import annotations
 import uuid
 
 from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from simple_module_db.pagination import PageParams
+from simple_module_hosting.pagination import page_params
 from simple_module_hosting.permissions import RequiresPermission
 
 from background_tasks.constants import (
@@ -38,8 +40,7 @@ async def list_executions(
     task_name: str | None = Query(default=None, deprecated=True),
     queue: str | None = Query(default=None),
     tenant_id: str | None = Query(default=None),
-    page: int = Query(default=1, ge=1),
-    per_page: int = Query(default=20, ge=1, le=200),
+    params: PageParams = Depends(page_params(20)),
     service: BackgroundTaskService = Depends(get_background_task_service),
 ) -> TaskExecutionListResponse:
     """List executions, filtered exactly as the page filters them.
@@ -55,8 +56,8 @@ async def list_executions(
         task_name=q or task_name,
         queue=queue,
         tenant_id=tenant_id,
-        page=page,
-        per_page=per_page,
+        page=params.page,
+        per_page=params.per_page,
     )