simple-module-background-tasks 0.0.32__tar.gz → 0.0.34__tar.gz

{simple_module_background_tasks-0.0.32 → simple_module_background_tasks-0.0.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_background_tasks
-Version: 0.0.32
+Version: 0.0.34
 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
@@ -23,10 +23,10 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.12
 Requires-Dist: celery[redis]>=5.4
 Requires-Dist: redis>=5
-Requires-Dist: simple-module-core==0.0.32
-Requires-Dist: simple-module-db==0.0.32
-Requires-Dist: simple-module-hosting==0.0.32
-Requires-Dist: simple-module-settings==0.0.32
+Requires-Dist: simple-module-core==0.0.34
+Requires-Dist: simple-module-db==0.0.34
+Requires-Dist: simple-module-hosting==0.0.34
+Requires-Dist: simple-module-settings==0.0.34
 Description-Content-Type: text/markdown
 
 # simple_module_background_tasks

{simple_module_background_tasks-0.0.32 → simple_module_background_tasks-0.0.34}/background_tasks/constants.py

@@ -25,8 +25,14 @@ _MODULE_SETTINGS = "Settings"
 # ── Env / settings ──────────────────────────────────────────────
 ENV_PREFIX = "SM_BG_TASKS_"
 
+# The single Redis URL an operator sets. Seeds both the broker and the result
+# backend: Celery namespaces result keys as ``celery-task-meta-*``, so sharing
+# one database is safe and is what upstream's quickstart does. The per-field
+# DB-backed overrides still allow splitting them.
+ENV_REDIS_URL = "SM_REDIS_URL"
+
 # ── Permissions ─────────────────────────────────────────────────
-PERM_GROUP = "Background Tasks"
+PERM_GROUP = "Background tasks"
 PERM_VIEW = "background_tasks.view"
 PERM_MANAGE = "background_tasks.manage"
 
@@ -36,7 +42,7 @@ VIEW_PREFIX = "/admin/background-tasks"
 ADMIN_ROUTER_PREFIX = "/admin"
 
 # ── Menu ────────────────────────────────────────────────────────
-MENU_LABEL = "Background Tasks"
+MENU_LABEL = "Background tasks"
 MENU_ICON = "activity"
 MENU_ORDER = 120
 
@@ -59,10 +65,19 @@ class TaskStatus(StrEnum):
 
 
 RETRYABLE_STATUSES: frozenset[TaskStatus] = frozenset({TaskStatus.FAILED, TaskStatus.STUCK})
+
 TERMINAL_STATUSES: frozenset[TaskStatus] = frozenset(
     {TaskStatus.SUCCESS, TaskStatus.FAILED, TaskStatus.STUCK, TaskStatus.REVOKED}
 )
 
+# How many executions one "Retry all failed" press may re-enqueue.
+#
+# The sweep publishes to the broker once per row and writes a row per publish,
+# so an unbounded backlog turns one button into a multi-minute request holding
+# a DB transaction open. Capping it makes the cost of a press knowable; the
+# response says how many are left so the operator can press again.
+RETRY_ALL_BATCH = 500
+
 # ── Defaults ────────────────────────────────────────────────────
 DEFAULT_QUEUE = "default"
 DEFAULT_BROKER_URL = "redis://localhost:6379/0"

{simple_module_background_tasks-0.0.32 → simple_module_background_tasks-0.0.34}/background_tasks/contracts/schemas.py

@@ -72,6 +72,23 @@ class TaskExecutionListResponse(SQLModel):
     per_page: int
     status: TaskStatus | None = None
     task_name: str | None = None
+    queue: str | None = None
+
+
+class RetryFailedResult(SQLModel):
+    """What a bulk retry actually did.
+
+    The caller cannot compute either number: the endpoint decides which rows
+    count as retryable and caps how many it will take in one pass, so both have
+    to come back from the action rather than be inferred from what the screen
+    was showing.
+    """
+
+    queued: int
+    # Eligible rows the batch cap left behind. Non-zero means "press it again";
+    # the UI says so rather than leaving the operator to wonder why the backlog
+    # only half moved.
+    remaining: int = 0
 
 
 class WorkerInfo(SQLModel):
@@ -84,6 +101,10 @@ class WorkerInfo(SQLModel):
     pool_size: int | None = None
     total_processed: int | None = None
     software: str | None = None
+    # Seconds since this worker process started, as it reports them. ``None``
+    # for a worker that never answered ``stats()`` — an offline worker has no
+    # uptime to claim, and zero would read as "just restarted".
+    uptime_seconds: float | None = None
 
 
 class WorkerSnapshot(SQLModel):

{simple_module_background_tasks-0.0.32 → simple_module_background_tasks-0.0.34}/background_tasks/deps.py

@@ -4,15 +4,15 @@ from __future__ import annotations
 
 from fastapi import Depends, Request
 from simple_module_core.events import EventBus
+from simple_module_db import RequestSession
 from simple_module_db.deps import get_db
-from sqlalchemy.ext.asyncio import AsyncSession
 
 from background_tasks.service import BackgroundTaskService
 
 
 async def get_background_task_service(
     request: Request,
-    db: AsyncSession = Depends(get_db),
+    db: RequestSession = Depends(get_db),
 ) -> BackgroundTaskService:
     services = request.app.state.background_tasks
     bus: EventBus = request.app.state.sm.event_bus

{simple_module_background_tasks-0.0.32 → simple_module_background_tasks-0.0.34}/background_tasks/endpoints/api_admin.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 import uuid
 
 from fastapi import APIRouter, Depends, HTTPException, Query, Request
@@ -16,13 +15,14 @@ from background_tasks.constants import (
     TaskStatus,
 )
 from background_tasks.contracts.schemas import (
+    RetryFailedResult,
     TaskExecutionDetail,
     TaskExecutionListResponse,
     WorkerSnapshot,
 )
 from background_tasks.deps import get_background_task_service
 from background_tasks.service import BackgroundTaskService
-from background_tasks.worker_inspector import WorkerInspector
+from background_tasks.workers_state import poll_workers
 
 router = APIRouter(
     prefix=ADMIN_ROUTER_PREFIX,
@@ -34,12 +34,24 @@ router = APIRouter(
 @router.get("/executions", response_model=TaskExecutionListResponse)
 async def list_executions(
     status: TaskStatus | None = Query(default=None),
-    task_name: str | None = Query(default=None),
+    q: str | None = Query(default=None),
+    task_name: str | None = Query(default=None, deprecated=True),
+    queue: str | None = Query(default=None),
     page: int = Query(default=1, ge=1),
     per_page: int = Query(default=20, ge=1, le=200),
     service: BackgroundTaskService = Depends(get_background_task_service),
 ) -> TaskExecutionListResponse:
-    return await service.list(status=status, task_name=task_name, page=page, per_page=per_page)
+    """List executions, filtered exactly as the page filters them.
+
+    The task-name search is ``q`` — the same name the page and the sweep use,
+    so an operator can move a URL between the three and keep their filter. This
+    endpoint originally spelled it ``task_name``, which meant a link copied off
+    the screen silently listed *everything*; that spelling is still accepted so
+    existing API callers keep working, and ``q`` wins when both are given.
+    """
+    return await service.list(
+        status=status, task_name=q or task_name, queue=queue, page=page, per_page=per_page
+    )
 
 
 @router.get("/executions/{execution_id}", response_model=TaskExecutionDetail)
@@ -53,6 +65,26 @@ async def get_execution(
     return detail
 
 
+@router.post(
+    "/executions/retry-failed",
+    response_model=RetryFailedResult,
+    dependencies=[Depends(RequiresPermission(PERM_MANAGE))],
+)
+async def retry_failed_executions(
+    status: TaskStatus | None = Query(default=None),
+    task_name: str | None = Query(default=None, alias="q"),
+    queue: str | None = Query(default=None),
+    service: BackgroundTaskService = Depends(get_background_task_service),
+) -> RetryFailedResult:
+    """Re-enqueue every failed or stuck execution the current filter can see.
+
+    Takes the same three filters as the listing — status, search, queue — so
+    the sweep covers exactly the rows the operator is looking at and nothing
+    else. Capped per call; the response says how many eligible rows are left.
+    """
+    return await service.retry_failed(status=status, task_name=task_name, queue=queue)
+
+
 @router.post(
     "/executions/{execution_id}/retry",
     response_model=TaskExecutionDetail,
@@ -67,7 +99,10 @@ async def retry_execution(
 
 @router.get("/workers", response_model=WorkerSnapshot)
 async def get_workers(request: Request) -> WorkerSnapshot:
-    """Live snapshot of every Celery worker reachable via the broker."""
-    celery = request.app.state.background_tasks.celery
-    inspector = WorkerInspector(celery)
-    return await asyncio.to_thread(inspector.snapshot)
+    """Live snapshot of every Celery worker reachable via the broker.
+
+    Goes through ``poll_workers`` so the Refresh button also refreshes the
+    snapshot other screens read, rather than leaving them on a stale one this
+    request has already superseded.
+    """
+    return await poll_workers(request)

{simple_module_background_tasks-0.0.32 → simple_module_background_tasks-0.0.34}/background_tasks/endpoints/views.py

@@ -16,12 +16,16 @@ from background_tasks.constants import (
 )
 from background_tasks.deps import get_background_task_service
 from background_tasks.service import BackgroundTaskService
-from background_tasks.worker_inspector import WorkerInspector
+from background_tasks.worker_inspector import redact_broker_url
+from background_tasks.workers_state import poll_workers
 
 router = APIRouter(dependencies=[Depends(RequiresPermission(PERM_VIEW))])
 
 PER_PAGE = 20
 
+# Window the "Succeeded 24h" tile counts over.
+SUCCESS_WINDOW_HOURS = 24
+
 
 async def _worker_presence(request: Request) -> dict[str, object]:
     """Whether anything is actually able to run a task right now.
@@ -35,8 +39,7 @@ async def _worker_presence(request: Request) -> dict[str, object]:
     unfiltered list is genuinely empty — the one moment the answer changes what
     the screen should say. The normal path never pays for it.
     """
-    celery = request.app.state.background_tasks.celery
-    snapshot = await asyncio.to_thread(WorkerInspector(celery).snapshot)
+    snapshot = await poll_workers(request)
     return {
         "broker_reachable": snapshot.broker_reachable,
         "worker_count": sum(1 for w in snapshot.workers if w.online),
@@ -49,35 +52,51 @@ async def index(
     request: Request,
     status: TaskStatus | None = Query(default=None),
     task_name: str = Query(default="", alias="q"),
+    queue: str = Query(default=""),
     page: int = Query(default=1),
     service: BackgroundTaskService = Depends(get_background_task_service),
 ) -> InertiaResponse:
     response = await service.list(
         status=status,
         task_name=task_name or None,
+        queue=queue or None,
         page=page,
         per_page=PER_PAGE,
     )
     # A filtered-empty list says nothing about the fleet, so don't pay to poll
     # it: the screen already knows to blame the filter.
-    unfiltered_and_empty = response.total == 0 and not task_name and status is None
-    # `_worker_presence` polls the broker over a thread, not the DB session
-    # `status_counts` uses — the two don't share state, so run them
-    # concurrently instead of paying the ~1s inspect timeout serially on top
-    # of the count query.
-    if unfiltered_and_empty:
-        counts, presence = await asyncio.gather(
-            service.status_counts(task_name=task_name or None),
-            _worker_presence(request),
+    unfiltered_and_empty = response.total == 0 and not task_name and not queue and status is None
+
+    async def strip_data() -> tuple[dict[str, int], list[str]]:
+        """Everything above the table. Serial: one session, one connection."""
+        counts = await service.status_counts(task_name=task_name or None, queue=queue or None)
+        # The strip's third tile is a windowed throughput reading rather than a
+        # status total, so it needs its own count — see `success_count_since`.
+        counts["success_24h"] = await service.success_count_since(
+            hours=SUCCESS_WINDOW_HOURS,
+            task_name=task_name or None,
+            queue=queue or None,
         )
+        # Deliberately unfiltered: the dropdown is how an operator leaves the
+        # queue they are in, so it keeps offering the ones they are not in.
+        return counts, await service.queues()
+
+    # `_worker_presence` polls the broker over a thread, not the DB session the
+    # counts use — the two don't share state, so run them concurrently instead
+    # of paying the ~1s inspect timeout serially on top of the queries.
+    if unfiltered_and_empty:
+        (counts, queues), presence = await asyncio.gather(strip_data(), _worker_presence(request))
     else:
-        counts = await service.status_counts(task_name=task_name or None)
-        presence = None
+        (counts, queues), presence = await strip_data(), None
     return await inertia.render(
         "BackgroundTasks/Index",
         {
             "executions": [i.model_dump(mode="json") for i in response.items],
-            "status_counts": {s.value: counts.get(s.value, 0) for s in TaskStatus},
+            "status_counts": {
+                **{s.value: counts.get(s.value, 0) for s in TaskStatus},
+                "success_24h": counts["success_24h"],
+            },
+            "queues": queues,
             "worker_presence": presence,
             "pagination": {
                 "page": response.page,
@@ -87,18 +106,35 @@ async def index(
             "filters": {
                 "status": status.value if status else "",
                 "task_name": task_name,
+                "queue": queue,
             },
         },
     )
 
 
 @router.get("/workers", response_model=None)
-async def workers(inertia: InertiaDep, request: Request) -> InertiaResponse:
-    celery = request.app.state.background_tasks.celery
-    snapshot = await asyncio.to_thread(WorkerInspector(celery).snapshot)
+async def workers(
+    inertia: InertiaDep,
+    request: Request,
+    service: BackgroundTaskService = Depends(get_background_task_service),
+) -> InertiaResponse:
+    settings = request.app.state.background_tasks.settings
+    snapshot = await poll_workers(request)
+    # The start command the empty state offers has to name the queues this
+    # install actually uses, or it starts a worker that consumes nothing. The
+    # default queue leads because it is the one that always exists, even before
+    # a single task has run.
+    used_queues = await service.queues()
+    queues = [settings.task_default_queue] + [
+        q for q in used_queues if q != settings.task_default_queue
+    ]
     return await inertia.render(
         "BackgroundTasks/Workers",
-        {"snapshot": snapshot.model_dump(mode="json")},
+        {
+            "snapshot": snapshot.model_dump(mode="json"),
+            "broker_url_redacted": redact_broker_url(settings.broker_url),
+            "queues": queues,
+        },
     )
 
 
@@ -106,6 +142,7 @@ async def workers(inertia: InertiaDep, request: Request) -> InertiaResponse:
 async def detail(
     execution_id: str,
     inertia: InertiaDep,
+    request: Request,
     service: BackgroundTaskService = Depends(get_background_task_service),
 ) -> InertiaResponse:
     try:
@@ -117,5 +154,10 @@ async def detail(
         raise HTTPException(status_code=404)
     return await inertia.render(
         "BackgroundTasks/Detail",
-        {"execution": row.model_dump(mode="json")},
+        {
+            "execution": row.model_dump(mode="json"),
+            # The subline reads "attempt {n} of {max}"; without the ceiling the
+            # attempt count cannot say whether another one is coming.
+            "max_retries": request.app.state.background_tasks.settings.max_retries,
+        },
     )

simple_module_background_tasks-0.0.34/background_tasks/filters.py

@@ -0,0 +1,69 @@
+"""How the executions screen's filters become SQL.
+
+Shared by the listing, the strip counts and the bulk retry. They live out here
+rather than on the service because a bulk action scoped differently from the
+table it sits above is how an operator ends up re-enqueueing rows they never
+saw — one definition means they cannot drift apart.
+"""
+
+from __future__ import annotations
+
+from simple_module_db import LIKE_ESCAPE_CHAR, like_contains_pattern
+from sqlalchemy import ColumnElement, select
+
+from background_tasks.constants import RETRYABLE_STATUSES, TaskStatus
+from background_tasks.models import TaskExecution
+
+Conditions = list[ColumnElement[bool]]
+
+
+def execution_filters(
+    *,
+    status: TaskStatus | None = None,
+    task_name: str | None = None,
+    queue: str | None = None,
+) -> Conditions:
+    """The three axes the executions screen filters on."""
+    conditions: Conditions = []
+    if status is not None:
+        conditions.append(TaskExecution.status == status)
+    if task_name:
+        conditions.append(
+            TaskExecution.task_name.ilike(like_contains_pattern(task_name), escape=LIKE_ESCAPE_CHAR)
+        )
+    if queue:
+        conditions.append(TaskExecution.queue == queue)
+    return conditions
+
+
+def bulk_retry_conditions(
+    *,
+    status: TaskStatus | None = None,
+    task_name: str | None = None,
+    queue: str | None = None,
+) -> Conditions | None:
+    """What the bulk sweep may touch, or ``None`` when it may touch nothing.
+
+    Two rules on top of the screen's own filters.
+
+    A status that is not retryable narrows the set to empty rather than
+    widening it: pressing the button while looking at ``running`` queues
+    nothing, because the button can never reach past what is on screen.
+
+    A row that already has a child has already been re-queued, and sweeping it
+    again would multiply the backlog on every press — two clicks on a wedged
+    queue of 40 would enqueue 80 tasks. Excluding it makes the button
+    idempotent in the way an operator expects. Retrying such a row
+    *deliberately* is still possible through its own dialog, which says how
+    many attempts it has had and makes the person decide.
+    """
+    wanted = RETRYABLE_STATUSES if status is None else RETRYABLE_STATUSES & {status}
+    if not wanted:
+        return None
+    child = TaskExecution.__table__.alias("retry_child")
+    already_retried = select(child.c.id).where(child.c.retried_from_id == TaskExecution.id).exists()
+    return [
+        TaskExecution.status.in_(sorted(wanted)),
+        *execution_filters(task_name=task_name, queue=queue),
+        ~already_retried,
+    ]

simple_module_background_tasks-0.0.34/background_tasks/health.py

@@ -0,0 +1,58 @@
+"""Health check for the Celery broker and result backend.
+
+Doubles as the "Test connection" action on the module-settings screen and as
+the connection step of the first-run setup wizard. Without it a wrong Redis
+URL stays invisible until the first task is enqueued and silently never runs —
+the queue accepts the message, no worker is listening on that database, and
+nothing surfaces an error.
+
+The detail string carries the underlying exception verbatim, because
+"connection refused", "authentication required" and "wrong database number"
+need three different fixes and a bare "unhealthy" tells an operator none of
+them.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from fastapi import FastAPI
+from simple_module_core.health import HealthCheckResult, HealthStatus
+
+CHECK_REDIS = "background_tasks.redis"
+
+# kombu's connection is blocking, so it runs in a worker thread. One retry
+# would double the probe's worst-case latency for no diagnostic gain — the
+# point is to report the failure, not to ride it out.
+_CONNECT_TIMEOUT_SECONDS = 3.0
+
+
+def _ping(celery) -> None:
+    """Open and close a broker connection. Raises on any failure."""
+    connection = celery.connection()
+    try:
+        connection.ensure_connection(max_retries=0, timeout=_CONNECT_TIMEOUT_SECONDS)
+    finally:
+        connection.release()
+
+
+def build_redis_check(app: FastAPI):
+    """Return an async check closing over *app* so it re-reads live settings."""
+
+    async def check() -> HealthCheckResult:
+        services = getattr(app.state, "background_tasks", None)
+        celery = getattr(services, "celery", None)
+        if celery is None:
+            return HealthCheckResult(
+                status=HealthStatus.UNHEALTHY, detail="Celery app not initialised"
+            )
+
+        try:
+            await asyncio.to_thread(_ping, celery)
+        except Exception as exc:
+            return HealthCheckResult(status=HealthStatus.UNHEALTHY, detail=str(exc))
+
+        broker = getattr(services.settings, "broker_url", "")
+        return HealthCheckResult(status=HealthStatus.HEALTHY, detail=f"Broker reachable ({broker})")
+
+    return check

simple_module_background_tasks-0.0.34/background_tasks/locales/en.json

@@ -0,0 +1,152 @@
+{
+  "index": {
+    "title": "Background tasks",
+    "description": "Monitor executions and retry failed or stuck jobs",
+    "search_placeholder": "Search by task name…",
+    "workers_button": "Workers",
+    "retry_all_button": "Retry all failed",
+    "previous": "Previous",
+    "next": "Next",
+    "showing": "Showing {from}–{to} of {total}"
+  },
+  "strip": {
+    "queued": "Queued",
+    "running": "Running",
+    "succeeded": "Succeeded",
+    "failed": "Failed",
+    "stuck": "Stuck",
+    "window_all": "All time",
+    "window_24h": "Last 24h"
+  },
+  "filters": {
+    "status_label": "Filter by status",
+    "all": "All",
+    "failed": "Failed",
+    "running": "Running",
+    "stuck": "Stuck",
+    "queue_label": "Queue:",
+    "queue_all": "all",
+    "queue_aria": "Filter by queue"
+  },
+  "status": {
+    "queued": "queued",
+    "running": "running",
+    "success": "success",
+    "failed": "failed",
+    "stuck": "stuck",
+    "revoked": "revoked",
+    "retrying": "retrying"
+  },
+  "table": {
+    "task": "Task",
+    "status": "Status",
+    "queue": "Queue",
+    "queued_at": "Queued",
+    "duration": "Duration",
+    "actions": "Actions",
+    "retry": "Retry"
+  },
+  "detail": {
+    "head_title": "Task detail",
+    "description": "execution {id} · attempt {attempt} of {max}",
+    "attempt": "attempt {attempt} of {max}",
+    "back_button": "Back to executions",
+    "retry_button": "Retry task",
+    "meta": "Details",
+    "queue": "Queue",
+    "worker": "Worker",
+    "celery_id": "Celery id",
+    "queued_at": "Queued at",
+    "started_at": "Started at",
+    "finished_at": "Finished at",
+    "duration": "Duration",
+    "heartbeat": "Heartbeat",
+    "retried_from": "Retried from",
+    "exception": "Exception",
+    "args": "Arguments",
+    "kwargs": "Keyword arguments",
+    "result": "Result",
+    "traceback": "Traceback",
+    "copy": "Copy",
+    "copied": "Copied",
+    "no_traceback": "No traceback recorded."
+  },
+  "retry_dialog": {
+    "title": "Retry {name}?",
+    "description": "A new execution is queued with the same arguments.",
+    "retried_before_one": "This one has already been retried once.",
+    "retried_before_other": "This one has already been retried {count} times.",
+    "args_label": "args",
+    "kwargs_label": "kwargs",
+    "no_args": "This task takes no arguments.",
+    "cancel": "Cancel",
+    "confirm": "Queue retry"
+  },
+  "retry_all_dialog": {
+    "title": "Retry all failed tasks?",
+    "description": "Every failed or stuck execution in the current view is queued again with its original arguments. Rows that already have a retry in flight are skipped.",
+    "scope_all_queues": "All queues",
+    "scope_queue": "Queue {queue}",
+    "scope_all_statuses": "Failed and stuck",
+    "cancel": "Cancel",
+    "confirm": "Queue retries",
+    "scope_search": "Search “{query}”",
+    "scope_no_search": "Any task name"
+  },
+  "toasts": {
+    "retried": "Task \"{name}\" re-enqueued",
+    "retry_failed": "Failed to retry task",
+    "bulk_retried_one": "Queued {count} retry",
+    "bulk_retried_other": "Queued {count} retries",
+    "bulk_retry_failed": "Failed to retry tasks",
+    "bulk_remaining_one": "{count} more remains — run it again.",
+    "bulk_remaining_other": "{count} more remain — run it again."
+  },
+  "worker_health": {
+    "broker_unreachable_title": "Broker unreachable",
+    "broker_unreachable_detail": "Nothing can be queued or run until the broker is back. The counts below are the last state written to the database.",
+    "no_workers_title_one": "{count} task waiting, no worker running",
+    "no_workers_title_other": "{count} tasks waiting, no worker running",
+    "no_workers_detail": "The broker is up but nothing is consuming the queue, so this backlog will not move on its own.",
+    "view_workers": "View workers"
+  },
+  "tasks_empty": {
+    "filtered_title": "No tasks match these filters",
+    "filtered_description": "Executions exist outside the current search, status and queue filters.",
+    "clear_filters": "Clear filters",
+    "broker_unreachable_title": "Can't reach the broker",
+    "broker_unreachable_description": "Nothing can be queued or executed until the broker is back. Tasks are not being lost — they are not being accepted.",
+    "no_workers_title": "No worker is running",
+    "no_workers_description": "The broker is up, but nothing is consuming the queue. Tasks enqueued now will wait rather than run.",
+    "healthy_title": "No task has run yet",
+    "healthy_description": "Registered tasks appear here the first time they execute."
+  },
+  "workers": {
+    "title": "Workers",
+    "description": "Celery workers connected to the broker",
+    "back_button": "Executions",
+    "last_updated": "Last updated {time}",
+    "refresh": "Refresh",
+    "online": "Online",
+    "offline": "Offline",
+    "uptime": "uptime {uptime}",
+    "offline_state": "offline",
+    "active": "Active",
+    "pool": "Pool",
+    "processed": "Processed",
+    "queues": "Queues",
+    "broker_unreachable_title": "Broker unreachable",
+    "broker_unreachable_description": "The connection to the broker failed, so nothing can be queued or run. Check this setting and confirm the broker is up.",
+    "no_error_reported": "No error message reported.",
+    "no_workers_title": "No workers connected",
+    "no_workers_description": "The broker is reachable but nothing is consuming the queue. Start a worker locally with:",
+    "refresh_failed_status": "Failed to refresh workers (HTTP {status})",
+    "refresh_failed": "Failed to refresh workers"
+  },
+  "nav": {
+    "background_tasks": "Background tasks"
+  },
+  "audit": {
+    "task_execution": "Task execution"
+  }
+}