simple-module-background-tasks 0.0.23__tar.gz → 0.0.25__tar.gz

{simple_module_background_tasks-0.0.23 → simple_module_background_tasks-0.0.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple_module_background_tasks
-Version: 0.0.23
+Version: 0.0.25
 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.23
-Requires-Dist: simple-module-db==0.0.23
-Requires-Dist: simple-module-hosting==0.0.23
-Requires-Dist: simple-module-settings==0.0.23
+Requires-Dist: simple-module-core==0.0.25
+Requires-Dist: simple-module-db==0.0.25
+Requires-Dist: simple-module-hosting==0.0.25
+Requires-Dist: simple-module-settings==0.0.25
 Description-Content-Type: text/markdown
 
 # simple_module_background_tasks
@@ -57,8 +57,7 @@ from celery import shared_task
 
 
 @shared_task(name="reports.generate")
-def generate_report(report_id: int) -> None:
-    ...
+def generate_report(report_id: int) -> None: ...
 ```
 
 Declaring `background_tasks` as a `depends_on` ensures the Celery app is built before your tasks run:
@@ -100,10 +99,11 @@ domain `job_id` that named a Celery task is the canonical example):
 from background_tasks import bind_task_context
 from celery import shared_task
 
+
 @shared_task
 def process_dataset(job_id: int) -> None:
     with bind_task_context(job_id=job_id):
-        logger.info("starting ingest")   # now carries job_id too
+        logger.info("starting ingest")  # now carries job_id too
 ```
 
 Bindings nest cleanly and restore on exit. structlog users can mount the

{simple_module_background_tasks-0.0.23 → simple_module_background_tasks-0.0.25}/README.md

@@ -26,8 +26,7 @@ from celery import shared_task
 
 
 @shared_task(name="reports.generate")
-def generate_report(report_id: int) -> None:
-    ...
+def generate_report(report_id: int) -> None: ...
 ```
 
 Declaring `background_tasks` as a `depends_on` ensures the Celery app is built before your tasks run:
@@ -69,10 +68,11 @@ domain `job_id` that named a Celery task is the canonical example):
 from background_tasks import bind_task_context
 from celery import shared_task
 
+
 @shared_task
 def process_dataset(job_id: int) -> None:
     with bind_task_context(job_id=job_id):
-        logger.info("starting ingest")   # now carries job_id too
+        logger.info("starting ingest")  # now carries job_id too
 ```
 
 Bindings nest cleanly and restore on exit. structlog users can mount the

{simple_module_background_tasks-0.0.23 → simple_module_background_tasks-0.0.25}/background_tasks/module.py

@@ -71,7 +71,7 @@ class BackgroundTasksModule(ModuleBase):
         registry.add(
             MenuItem(
                 label=MENU_LABEL,
-                url=VIEW_PREFIX,
+                url=f"{VIEW_PREFIX}/",
                 icon=MENU_ICON,
                 order=MENU_ORDER,
                 section=MenuSection.SIDEBAR,

{simple_module_background_tasks-0.0.23 → simple_module_background_tasks-0.0.25}/background_tasks/worker_inspector.py

@@ -9,6 +9,7 @@ instead of the endpoint returning a 5xx.
 from __future__ import annotations
 
 import logging
+from concurrent.futures import ThreadPoolExecutor
 from datetime import UTC, datetime
 from typing import TYPE_CHECKING, Any
 
@@ -23,6 +24,10 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+# The four independent inspect broadcasts, issued concurrently.
+_PROBES = ("ping", "stats", "active_queues", "active")
+
+
 class WorkerInspector:
     """Synchronous adapter; call from async code via ``asyncio.to_thread``."""
 
@@ -30,6 +35,11 @@ class WorkerInspector:
         self.celery = celery
         self.timeout = timeout
 
+    def _probe(self, name: str) -> dict:
+        """Run one inspect broadcast on its own handle. ``None`` means nobody replied."""
+        inspect = self.celery.control.inspect(timeout=self.timeout)
+        return getattr(inspect, name)() or {}
+
     def snapshot(self) -> WorkerSnapshot:
         polled_at = datetime.now(UTC)
 
@@ -48,12 +58,24 @@ class WorkerInspector:
                 error=str(exc),
             )
 
-        inspect = self.celery.control.inspect(timeout=self.timeout)
+        # Each inspect call broadcasts and then waits the *full* timeout for
+        # replies — it cannot know whether a slow worker is still coming. Run
+        # sequentially that is 4 x timeout, so with the broker up and no
+        # workers this page took ~4s: precisely the state an admin opens it to
+        # diagnose. The four probes are independent, so issue them together
+        # and the page costs one timeout instead of four.
+        #
+        # Each gets its own inspect handle rather than sharing one across
+        # threads. Results are still merged by hostname afterwards, so a
+        # worker that answers some probes but not others (a degraded worker)
+        # is still reported.
         try:
-            ping = inspect.ping() or {}
-            stats = inspect.stats() or {}
-            queues = inspect.active_queues() or {}
-            active = inspect.active() or {}
+            with ThreadPoolExecutor(max_workers=len(_PROBES)) as pool:
+                futures = {name: pool.submit(self._probe, name) for name in _PROBES}
+                ping = futures["ping"].result()
+                stats = futures["stats"].result()
+                queues = futures["active_queues"].result()
+                active = futures["active"].result()
         except (OperationalError, RedisError, ConnectionError, OSError) as exc:
             logger.info("inspect() failed mid-call: %s", exc)
             return WorkerSnapshot(

{simple_module_background_tasks-0.0.23 → simple_module_background_tasks-0.0.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_background_tasks"
-version = "0.0.23"
+version = "0.0.25"
 description = "Celery + Redis task queue with admin UI for monitoring and retrying failed/stuck tasks"
 readme = "README.md"
 license = "MIT"
@@ -21,10 +21,10 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "simple_module_core==0.0.23",
-    "simple_module_db==0.0.23",
-    "simple_module_hosting==0.0.23",
-    "simple_module_settings==0.0.23",
+    "simple_module_core==0.0.25",
+    "simple_module_db==0.0.25",
+    "simple_module_hosting==0.0.25",
+    "simple_module_settings==0.0.25",
     "celery[redis]>=5.4",
     "redis>=5",
 ]

{simple_module_background_tasks-0.0.23 → simple_module_background_tasks-0.0.25}/tests/test_worker_inspector.py

@@ -2,10 +2,15 @@
 
 from __future__ import annotations
 
+import time
 from unittest.mock import MagicMock
 
 from celery import Celery
 
+PROBE_DELAY = 0.25
+# Sequential would be 4x PROBE_DELAY; allow well under that but above one probe.
+SEQUENTIAL_SLACK = 2.5
+
 
 def _make_celery_with_dead_broker() -> Celery:
     """Build a Celery app pointed at an unreachable broker.
@@ -104,3 +109,81 @@ def test_redis_error_during_probe_returns_unreachable_snapshot():
     assert snapshot.workers == []
     assert snapshot.error is not None
     assert "invalid password" in snapshot.error
+
+
+def _celery_with_live_broker_no_workers() -> tuple[Celery, MagicMock]:
+    """Broker reachable, but no worker ever answers — the common outage case."""
+    celery = MagicMock(spec=Celery)
+    celery.connection.return_value.ensure_connection.return_value = None
+    inspect = celery.control.inspect.return_value
+    # Celery returns None when nobody replies before the timeout.
+    inspect.ping.return_value = None
+    inspect.stats.return_value = None
+    inspect.active_queues.return_value = None
+    inspect.active.return_value = None
+    return celery, inspect
+
+
+def test_probes_run_concurrently_not_sequentially():
+    """Four sequential probes cost 4 x timeout; concurrent ones cost about one.
+
+    With the broker up and no workers running, every inspect call waits its
+    full timeout for replies that never come. Sequentially that made
+    /admin/background-tasks/workers take ~4s — exactly the state an admin
+    opens that page to diagnose.
+
+    Each mocked probe sleeps for PROBE_DELAY. Sequential would be 4x that;
+    the assertion allows generous slack so this cannot flake on a loaded box
+    while still failing outright if the calls go back to being serial.
+    """
+    from background_tasks.worker_inspector import WorkerInspector
+
+    celery, _ = _celery_with_live_broker_no_workers()
+    inspect = celery.control.inspect.return_value
+    for name in ("ping", "stats", "active_queues", "active"):
+        getattr(inspect, name).side_effect = lambda *_, **__: (time.sleep(PROBE_DELAY), None)[1]
+
+    start = time.perf_counter()
+    snapshot = WorkerInspector(celery, timeout=PROBE_DELAY).snapshot()
+    elapsed = time.perf_counter() - start
+
+    assert elapsed < PROBE_DELAY * SEQUENTIAL_SLACK, (
+        f"probes took {elapsed:.2f}s; {PROBE_DELAY * 4:.2f}s means they are still sequential"
+    )
+    assert snapshot.broker_reachable is True
+    assert snapshot.workers == []
+
+
+def test_all_four_probes_are_still_issued_when_nobody_replies():
+    """Concurrency must not drop probes — a worker that answers only stats
+    (degraded, not answering ping) must still be reported. See
+    test_worker_in_stats_but_not_ping_is_offline."""
+    from background_tasks.worker_inspector import WorkerInspector
+
+    celery, inspect = _celery_with_live_broker_no_workers()
+    WorkerInspector(celery, timeout=0.05).snapshot()
+
+    inspect.ping.assert_called_once()
+    inspect.stats.assert_called_once()
+    inspect.active_queues.assert_called_once()
+    inspect.active.assert_called_once()
+
+
+def test_workers_present_still_collects_every_detail():
+    """The short-circuit must not skip the calls when workers do reply."""
+    from background_tasks.worker_inspector import WorkerInspector
+
+    celery = MagicMock(spec=Celery)
+    celery.connection.return_value.ensure_connection.return_value = None
+    inspect = celery.control.inspect.return_value
+    inspect.ping.return_value = {"celery@host-a": {"ok": "pong"}}
+    inspect.stats.return_value = {"celery@host-a": {"pool": {"max-concurrency": 2}}}
+    inspect.active_queues.return_value = {"celery@host-a": [{"name": "default"}]}
+    inspect.active.return_value = {"celery@host-a": []}
+
+    snapshot = WorkerInspector(celery, timeout=1.0).snapshot()
+
+    inspect.stats.assert_called_once()
+    inspect.active_queues.assert_called_once()
+    inspect.active.assert_called_once()
+    assert [w.hostname for w in snapshot.workers] == ["celery@host-a"]