threadmill 0.6.3__tar.gz → 0.7.1__tar.gz

{threadmill-0.6.3 → threadmill-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: threadmill
-Version: 0.6.3
+Version: 0.7.1
 Summary: The most reliable backend for Django's task framework.
 Keywords: Django,tasks,worker
 Author-email: Johannes Maron <johannes@maron.family>
@@ -151,12 +151,14 @@ uv run manage.py threadmill inspector
 The `RedisTaskBackend` accepts the following options under `OPTIONS` in your
 `TASKS` configuration:
 
-| Option            | Default                | Description                                                  |
-| ----------------- | ---------------------- | ------------------------------------------------------------ |
-| `lease_ttl`       | `timedelta(hours=1)`   | Max processing time before a started task is marked FAILED.  |
-| `result_ttl`      | `timedelta(days=1)`    | How long task results are retained before automatic removal. |
-| `broker_interval` | `timedelta(seconds=1)` | Interval between background broker maintenance passes.       |
-| `batch_size`      | `100`                  | Max tasks to move or requeue per broker pass.                |
+| Option              | Default                   | Description                                                             |
+| ------------------- | ------------------------- | ----------------------------------------------------------------------- |
+| `lease_ttl`         | `timedelta(hours=1)`      | Max processing time before a started task is marked FAILED.             |
+| `result_ttl`        | `timedelta(days=1)`       | How long task results are retained before automatic removal.            |
+| `broker_interval`   | `timedelta(seconds=1)`    | Interval between background broker maintenance passes.                  |
+| `batch_size`        | `100`                     | Max tasks to move or requeue per broker pass.                           |
+| `poll_interval`     | `timedelta(seconds=0.01)` | Base wait between idle acquire attempts, doubled after each empty poll. |
+| `poll_max_interval` | `timedelta(seconds=1)`    | Max wait between idle acquire attempts.                                 |
 
 A task that is started but never acknowledged (lease expired) is marked FAILED
 with an `AcknowledgementTimeout` error. Set `lease_ttl` comfortably above your

{threadmill-0.6.3 → threadmill-0.7.1}/README.md

@@ -114,12 +114,14 @@ uv run manage.py threadmill inspector
 The `RedisTaskBackend` accepts the following options under `OPTIONS` in your
 `TASKS` configuration:
 
-| Option            | Default                | Description                                                  |
-| ----------------- | ---------------------- | ------------------------------------------------------------ |
-| `lease_ttl`       | `timedelta(hours=1)`   | Max processing time before a started task is marked FAILED.  |
-| `result_ttl`      | `timedelta(days=1)`    | How long task results are retained before automatic removal. |
-| `broker_interval` | `timedelta(seconds=1)` | Interval between background broker maintenance passes.       |
-| `batch_size`      | `100`                  | Max tasks to move or requeue per broker pass.                |
+| Option              | Default                   | Description                                                             |
+| ------------------- | ------------------------- | ----------------------------------------------------------------------- |
+| `lease_ttl`         | `timedelta(hours=1)`      | Max processing time before a started task is marked FAILED.             |
+| `result_ttl`        | `timedelta(days=1)`       | How long task results are retained before automatic removal.            |
+| `broker_interval`   | `timedelta(seconds=1)`    | Interval between background broker maintenance passes.                  |
+| `batch_size`        | `100`                     | Max tasks to move or requeue per broker pass.                           |
+| `poll_interval`     | `timedelta(seconds=0.01)` | Base wait between idle acquire attempts, doubled after each empty poll. |
+| `poll_max_interval` | `timedelta(seconds=1)`    | Max wait between idle acquire attempts.                                 |
 
 A task that is started but never acknowledged (lease expired) is marked FAILED
 with an `AcknowledgementTimeout` error. Set `lease_ttl` comfortably above your

{threadmill-0.6.3 → threadmill-0.7.1}/threadmill/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.6.3'
-__version_tuple__ = version_tuple = (0, 6, 3)
+__version__ = version = '0.7.1'
+__version_tuple__ = version_tuple = (0, 7, 1)
 
-__commit_id__ = commit_id = 'g814435eae'
+__commit_id__ = commit_id = 'gc60eae976'

{threadmill-0.6.3 → threadmill-0.7.1}/threadmill/backends/redis.py

@@ -155,6 +155,13 @@ class RedisTaskBackend(ThreadmillTaskBackend):
         self.lease_ttl = self.options.get("lease_ttl", datetime.timedelta(hours=1))
         self.result_ttl = self.options.get("result_ttl", datetime.timedelta(days=1))
         self.batch_size = self.options.get("batch_size", 100)
+        self.poll_interval = self.options.get(
+            "poll_interval", datetime.timedelta(seconds=0.01)
+        )
+        self.poll_max_interval = self.options.get(
+            "poll_max_interval", datetime.timedelta(seconds=1)
+        )
+        self._miss_count = 0
         self._acquire_script = self.client.register_script(self.ACQUIRE_SCRIPT)
         self._acknowledge_script = self.client.register_script(self.ACKNOWLEDGE_SCRIPT)
 
@@ -270,17 +277,25 @@ class RedisTaskBackend(ThreadmillTaskBackend):
                     str(int(self.lease_ttl.total_seconds() * 1000)),
                 ],
             ):
+                self._miss_count = 0
                 return self.deserialize_task_result(data)
 
             try:
-                if deadline - time.monotonic() <= 0:
-                    raise TimeoutError(
-                        "No task available within the specified timeout."
-                    )
+                remaining = deadline - time.monotonic()
             except TypeError:
                 raise queue.Empty("No task available.")
-            else:
-                time.sleep(0.01)
+            if remaining <= 0:
+                raise TimeoutError("No task available within the specified timeout.")
+            # Stop doubling once the interval reaches poll_max_interval; larger
+            # exponents would only overflow the float math.
+            cap = int(self.poll_max_interval / self.poll_interval).bit_length()
+            interval_secs = min(
+                self.poll_interval.total_seconds() * 2 ** min(self._miss_count, cap),
+                self.poll_max_interval.total_seconds(),
+                remaining,
+            )
+            self._miss_count += 1
+            time.sleep(interval_secs)
 
     def acknowledge(self, task_result: TaskResult) -> None:
         serialized = self.serialize_task_result(task_result)

{threadmill-0.6.3 → threadmill-0.7.1}/threadmill/executor.py

@@ -3,6 +3,7 @@
 import asyncio
 import dataclasses
 import datetime
+import json
 import logging
 import multiprocessing
 import random
@@ -16,6 +17,7 @@ from queue import Empty
 from traceback import format_exception
 
 import django
+from django.core.serializers.json import DjangoJSONEncoder
 from django.tasks import TaskResult, task_backends
 from django.tasks.base import TaskContext, TaskError, TaskResultStatus
 from django.tasks.signals import task_finished, task_started
@@ -25,12 +27,62 @@ from django.utils.json import normalize_json
 if typing.TYPE_CHECKING:
     from .backends.base import Broker, ThreadmillTaskBackend
 
+
+class JsonFormatter(logging.Formatter):
+    """Format log records as single-line JSON objects."""
+
+    standard_attributes = frozenset(
+        {
+            "args",
+            "asctime",
+            "created",
+            "exc_info",
+            "exc_text",
+            "filename",
+            "funcName",
+            "levelname",
+            "levelno",
+            "lineno",
+            "message",
+            "module",
+            "msecs",
+            "msg",
+            "name",
+            "pathname",
+            "process",
+            "processName",
+            "relativeCreated",
+            "stack_info",
+            "taskName",
+            "thread",
+            "threadName",
+        }
+    )
+
+    def format(self, record: logging.LogRecord) -> str:
+        payload = {
+            "created_at": datetime.datetime.fromtimestamp(
+                record.created, tz=timezone.get_current_timezone()
+            ),
+            "level": record.levelname,
+            "logger": record.name,
+            "message": record.getMessage(),
+            "process": record.process,
+            "process_name": record.processName,
+            "thread": record.threadName,
+        } | {
+            key: value
+            for key, value in record.__dict__.items()
+            if key not in self.standard_attributes
+        }
+        if record.exc_info:
+            payload["exception"] = "".join(format_exception(*record.exc_info))
+        return json.dumps(payload, cls=DjangoJSONEncoder)
+
+
 logger = multiprocessing.get_logger()
-formatter = logging.Formatter(
-    "%(levelname)s: %(asctime)s - pid=%(process)s - %(message)s"
-)
 handler = logging.StreamHandler()
-handler.setFormatter(formatter)
+handler.setFormatter(JsonFormatter())
 logger.addHandler(handler)
 logger.setLevel(logging.INFO)
 
@@ -44,6 +96,8 @@ class TaskExecutor:
     threads: int = 1
     max_tasks: int = 0
     max_tasks_jitter: int = 0
+    poll_interval: datetime.timedelta = datetime.timedelta(seconds=0.01)
+    poll_max_interval: datetime.timedelta = datetime.timedelta(seconds=1)
     is_publishing: bool = dataclasses.field(default=True, init=False)
     worker_processes: list[WorkerProcess] = dataclasses.field(
         default_factory=list, init=False
@@ -53,6 +107,7 @@ class TaskExecutor:
     queues: tuple[str]
     broker: Broker | None = dataclasses.field(default=None, init=False)
     exit_empty: bool = False
+    log_formatter: logging.Formatter = dataclasses.field(default_factory=JsonFormatter)
 
     def __post_init__(self) -> None:
         """Initialize derived orchestration fields and queues."""
@@ -69,17 +124,21 @@ class TaskExecutor:
     def create_worker_process(self) -> WorkerProcess:
         """Create and start a new worker process."""
         worker = WorkerProcess(
-            self.thread_count,
-            self.get_maximum_tasks_per_child(),
-            self.backend.alias,
-            self.queues,
-            self.exit_empty,
+            thread_count=self.thread_count,
+            max_tasks=self.get_maximum_tasks_per_child(),
+            backend_alias=self.backend.alias,
+            queues=self.queues,
+            exit_empty=self.exit_empty,
+            poll_interval=self.poll_interval,
+            poll_max_interval=self.poll_max_interval,
+            log_formatter=self.log_formatter,
         )
         worker.start()
         return worker
 
     def run(self) -> None:
         """Start consuming tasks until shutdown is requested."""
+        handler.setFormatter(self.log_formatter)
         self.worker_processes = [
             self.create_worker_process() for _ in range(self.process_count)
         ]
@@ -127,11 +186,15 @@ class WorkerProcess(multiprocessing.Process):
 
     def __init__(
         self,
+        *,
         thread_count: int,
         max_tasks: int | None = None,
         backend_alias: str = "",
         queues: tuple[str, ...] = (),
         exit_empty: bool = False,
+        poll_interval: datetime.timedelta = datetime.timedelta(seconds=0.01),
+        poll_max_interval: datetime.timedelta = datetime.timedelta(seconds=1),
+        log_formatter: logging.Formatter,
     ) -> None:
         """Create process with dedicated thread pool for task execution."""
         self.shutdown_requested = multiprocessing.Event()
@@ -141,17 +204,23 @@ class WorkerProcess(multiprocessing.Process):
         self.backend_alias = backend_alias
         self.queues = queues
         self.exit_empty = exit_empty
+        self.poll_interval = poll_interval
+        self.poll_max_interval = poll_max_interval
+        self.log_formatter = log_formatter
         self.task_count = 0
         self.lock: threading.Lock | None = None
         self.expired: threading.Event | None = None
 
     def run(self) -> None:
         """Start consumer execution inside this process."""
+        handler.setFormatter(self.log_formatter)
         django.setup()
         logger.info("Starting worker process %s", self.name)
         self.lock = threading.Lock()
         self.expired = threading.Event()
         backend = task_backends[self.backend_alias]
+        backend.poll_interval = self.poll_interval
+        backend.poll_max_interval = self.poll_max_interval
         consumer_threads = [
             WorkerThread(worker=self, index=index, backend=backend)
             for index in range(self.thread_count)

{threadmill-0.6.3 → threadmill-0.7.1}/threadmill/management/commands/threadmill.py

@@ -1,3 +1,5 @@
+import datetime
+import logging
 import signal
 import sys
 
@@ -10,7 +12,7 @@ from django.tasks import (
     task_backends,
 )
 
-from ...executor import TaskExecutor
+from ...executor import JsonFormatter, TaskExecutor
 
 
 def kill_softly(signum, frame):
@@ -66,11 +68,30 @@ class WorkerCommand(DjangoBaseCommand):
             default=0,
             help="Maximum random jitter to add to the max-tasks value by randint(0, max_tasks_jitter).",
         )
+        parser.add_argument(
+            "--poll-interval",
+            type=float,
+            default=0.01,
+            help="Base wait between idle acquire attempts in seconds.",
+        )
+        parser.add_argument(
+            "--poll-max-interval",
+            type=float,
+            default=1,
+            help="Maximum wait between idle acquire attempts in seconds.",
+        )
         parser.add_argument(
             "--exit-empty",
             action="store_true",
             help="Drain the task queue and exit with 0.",
         )
+        parser.add_argument(
+            "--log-format",
+            help=(
+                "Logging format string for worker log records, e.g."
+                " '%%(levelname)s %%(message)s'. Defaults to JSON."
+            ),
+        )
 
     def handle(
         self,
@@ -82,7 +103,10 @@ class WorkerCommand(DjangoBaseCommand):
         threads,
         max_tasks,
         max_tasks_jitter,
+        poll_interval,
+        poll_max_interval,
         exit_empty,
+        log_format,
         **options,
     ):
         match sys.platform:
@@ -101,14 +125,28 @@ class WorkerCommand(DjangoBaseCommand):
             raise CommandError(
                 f"Backend does not support all specified queues: {_non_queues!r}"
             )
+        try:
+            log_formatter = (
+                JsonFormatter() if log_format is None else logging.Formatter(log_format)
+            )
+            log_formatter.format(
+                logging.LogRecord(
+                    "threadmill", logging.INFO, __file__, 1, "Ready", (), None
+                )
+            )
+        except (TypeError, ValueError) as e:
+            raise CommandError(f"Invalid log format: {log_format!r}") from e
         exe = TaskExecutor(
             backend=backend,
             workers=workers,
             threads=threads,
             max_tasks=max_tasks,
             max_tasks_jitter=max_tasks_jitter,
+            poll_interval=datetime.timedelta(seconds=poll_interval),
+            poll_max_interval=datetime.timedelta(seconds=poll_max_interval),
             exit_empty=exit_empty,
             queues=queues,
+            log_formatter=log_formatter,
         )
         try:
             exe.run()