dj-queue 0.6.4__tar.gz → 0.7.1__tar.gz

{dj_queue-0.6.4 → dj_queue-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dj-queue
-Version: 0.6.4
+Version: 0.7.1
 Summary: Database-backed task queue backend for Django’s Tasks framework.
 License-Expression: MIT
 License-File: LICENSE
@@ -349,6 +349,8 @@ If you need to pass model instances, files, or custom objects, store them elsewh
 
 For MySQL or MariaDB, install and configure a Django-compatible driver following Django's database docs.
 
+Other Django database vendors are rejected explicitly.
+
 Polling is the portability path everywhere. Backend-specific features improve latency and throughput but are not correctness requirements.
 
 For production PostgreSQL operational guidance, see [Postgres Queue Health](#postgres-queue-health).
@@ -358,6 +360,10 @@ For production PostgreSQL operational guidance, see [Postgres Queue Health](#pos
 `dj_queue` supports both static recurring tasks from settings and dynamic
 recurring tasks managed at runtime.
 
+Recurring tasks persist their next due cursor after the first scheduler poll so
+large recurring sets do not need cron parsing on every tick for rows that are not
+due yet.
+
 ### Static recurring tasks
 
 Define recurring tasks in `TASKS[...]["OPTIONS"]["recurring"]`:
@@ -538,7 +544,9 @@ backend-side validation failures instead of silently dropping work.
 Common reasons include:
 
 - args or kwargs are not JSON round-trippable
+- the task targets a queue outside a non-empty `QUEUES` allow-list
 - `concurrency_key` is set without `concurrency_limit`
+- `concurrency_limit` or `concurrency_duration` is not a positive integer
 - `concurrency_key` cannot be resolved from the enqueue arguments
 - `concurrency_key` does not resolve to a non-empty string up to 255 chars
 - `on_conflict` is not `"block"` or `"discard"`
@@ -670,6 +678,12 @@ policy, and autovacuum tuning.
 
 - Use a dedicated queue database via `database_alias`. Keep reporting and
   long-running transactions off the queue database.
+- Consider a positive Django `CONN_MAX_AGE` for the queue database connection
+  path. It can materially improve worker throughput by reusing worker-thread
+  connections, but size PostgreSQL `max_connections` or your connection pool
+  for the total web, runner, and worker-thread footprint first. `dj_queue`
+  logs `connection_budget.warning` on startup when the local worker footprint
+  appears close to PostgreSQL connection capacity.
 - Keep retention short. Set `preserve_finished_jobs = False` if you do not need
   successful results. Otherwise use bounded `clear_finished_jobs_after`,
   `clear_failed_jobs_after`, and `clear_recurring_executions_after` values.
@@ -730,6 +744,9 @@ Common setup choices:
 - multiple backends, same database: good for logical and operational separation without another database
 - multiple backends, multiple databases: use when you need stronger isolation and accept more migration and deployment complexity
 
+`TASKS[backend_alias]["QUEUES"]` is an enqueue allow-list. Leave it as `[]` to
+allow any queue name, or set an exact list to reject work outside those lanes.
+
 ### Deployment topology
 
 Once migrations are in place, start processing jobs with `python manage.py dj_queue`
@@ -920,6 +937,8 @@ The `/dj_queue/metrics` endpoint requires the `prometheus` extra:
 pip install "dj-queue[prometheus]"
 ```
 
+If the extra is missing, the endpoint returns `503` with an installation hint.
+
 Exported metric families:
 
 - `dj_queue_queue_jobs{backend,queue,state}`
@@ -937,6 +956,11 @@ Both endpoints support bearer token authentication. Set
 `Authorization: Bearer <token>`. Leave it unset if you protect these URLs at
 the network or proxy layer.
 
+## Benchmarks
+
+The repository includes a standalone benchmark harness for enqueue, promotion, recurring, worker-drain, and concurrency-contention scenarios. 
+See [`docs/benchmarks/`](docs/benchmarks/) for the latest published reports.
+
 ## License
 
 MIT

{dj_queue-0.6.4 → dj_queue-0.7.1}/README.md

@@ -321,6 +321,8 @@ If you need to pass model instances, files, or custom objects, store them elsewh
 
 For MySQL or MariaDB, install and configure a Django-compatible driver following Django's database docs.
 
+Other Django database vendors are rejected explicitly.
+
 Polling is the portability path everywhere. Backend-specific features improve latency and throughput but are not correctness requirements.
 
 For production PostgreSQL operational guidance, see [Postgres Queue Health](#postgres-queue-health).
@@ -330,6 +332,10 @@ For production PostgreSQL operational guidance, see [Postgres Queue Health](#pos
 `dj_queue` supports both static recurring tasks from settings and dynamic
 recurring tasks managed at runtime.
 
+Recurring tasks persist their next due cursor after the first scheduler poll so
+large recurring sets do not need cron parsing on every tick for rows that are not
+due yet.
+
 ### Static recurring tasks
 
 Define recurring tasks in `TASKS[...]["OPTIONS"]["recurring"]`:
@@ -510,7 +516,9 @@ backend-side validation failures instead of silently dropping work.
 Common reasons include:
 
 - args or kwargs are not JSON round-trippable
+- the task targets a queue outside a non-empty `QUEUES` allow-list
 - `concurrency_key` is set without `concurrency_limit`
+- `concurrency_limit` or `concurrency_duration` is not a positive integer
 - `concurrency_key` cannot be resolved from the enqueue arguments
 - `concurrency_key` does not resolve to a non-empty string up to 255 chars
 - `on_conflict` is not `"block"` or `"discard"`
@@ -642,6 +650,12 @@ policy, and autovacuum tuning.
 
 - Use a dedicated queue database via `database_alias`. Keep reporting and
   long-running transactions off the queue database.
+- Consider a positive Django `CONN_MAX_AGE` for the queue database connection
+  path. It can materially improve worker throughput by reusing worker-thread
+  connections, but size PostgreSQL `max_connections` or your connection pool
+  for the total web, runner, and worker-thread footprint first. `dj_queue`
+  logs `connection_budget.warning` on startup when the local worker footprint
+  appears close to PostgreSQL connection capacity.
 - Keep retention short. Set `preserve_finished_jobs = False` if you do not need
   successful results. Otherwise use bounded `clear_finished_jobs_after`,
   `clear_failed_jobs_after`, and `clear_recurring_executions_after` values.
@@ -702,6 +716,9 @@ Common setup choices:
 - multiple backends, same database: good for logical and operational separation without another database
 - multiple backends, multiple databases: use when you need stronger isolation and accept more migration and deployment complexity
 
+`TASKS[backend_alias]["QUEUES"]` is an enqueue allow-list. Leave it as `[]` to
+allow any queue name, or set an exact list to reject work outside those lanes.
+
 ### Deployment topology
 
 Once migrations are in place, start processing jobs with `python manage.py dj_queue`
@@ -892,6 +909,8 @@ The `/dj_queue/metrics` endpoint requires the `prometheus` extra:
 pip install "dj-queue[prometheus]"
 ```
 
+If the extra is missing, the endpoint returns `503` with an installation hint.
+
 Exported metric families:
 
 - `dj_queue_queue_jobs{backend,queue,state}`
@@ -909,6 +928,11 @@ Both endpoints support bearer token authentication. Set
 `Authorization: Bearer <token>`. Leave it unset if you protect these URLs at
 the network or proxy layer.
 
+## Benchmarks
+
+The repository includes a standalone benchmark harness for enqueue, promotion, recurring, worker-drain, and concurrency-contention scenarios. 
+See [`docs/benchmarks/`](docs/benchmarks/) for the latest published reports.
+
 ## License
 
 MIT

{dj_queue-0.6.4 → dj_queue-0.7.1}/dj_queue/api.py

@@ -1,14 +1,12 @@
 from functools import partial
 
-from django.db.models import Case, DateTimeField, DurationField, ExpressionWrapper, F, Value, When
 from django.db.models.functions import Coalesce
 from django.db import transaction
 from django.utils import timezone
 from django.utils.module_loading import import_string
 
 from dj_queue.db import get_database_alias
-from dj_queue.log import log_event
-from dj_queue.models import Pause, ReadyExecution, RecurringTask
+from dj_queue.models import Pause, ReadyExecution
 
 
 class QueueInfo:
@@ -46,53 +44,12 @@ class QueueInfo:
     )
 
   def pause(self):
-    alias = get_database_alias(self.backend_alias)
-    Pause.objects.using(alias).get_or_create(
-      backend_alias=self.backend_alias,
-      queue_name=self.queue_name,
-    )
-    log_event("queue.paused", backend_alias=self.backend_alias, queue_name=self.queue_name)
+    pause_queue = import_string("dj_queue.operations.queues.pause_queue")
+    pause_queue(self.queue_name, backend_alias=self.backend_alias)
 
   def resume(self):
-    alias = get_database_alias(self.backend_alias)
-    with transaction.atomic(using=alias):
-      pause = (
-        Pause.objects.using(alias)
-        .select_for_update()
-        .filter(backend_alias=self.backend_alias, queue_name=self.queue_name)
-        .first()
-      )
-      if pause is None:
-        return
-
-      resumed_at = timezone.now()
-      paused_at = pause.created_at
-      pause_duration = Value(resumed_at - paused_at, output_field=DurationField())
-      ready_row_ids = list(self._ready_queryset().values_list("id", flat=True))
-      if ready_row_ids:
-        ReadyExecution.objects.using(alias).filter(pk__in=ready_row_ids).update(
-          latency_started_at=Case(
-            When(
-              latency_started_at__isnull=True,
-              created_at__lt=paused_at,
-              then=ExpressionWrapper(
-                F("created_at") + pause_duration, output_field=DateTimeField()
-              ),
-            ),
-            When(
-              latency_started_at__lt=paused_at,
-              then=ExpressionWrapper(
-                F("latency_started_at") + pause_duration,
-                output_field=DateTimeField(),
-              ),
-            ),
-            default=Value(resumed_at, output_field=DateTimeField()),
-            output_field=DateTimeField(),
-          ),
-        )
-      pause.delete()
-
-    log_event("queue.resumed", backend_alias=self.backend_alias, queue_name=self.queue_name)
+    resume_queue = import_string("dj_queue.operations.queues.resume_queue")
+    resume_queue(self.queue_name, backend_alias=self.backend_alias)
 
   def clear(self, *, batch_size=500):
     deleted = 0
@@ -111,7 +68,7 @@ class QueueInfo:
     alias = get_database_alias(backend_alias)
     queue_names = (
       ReadyExecution.objects.using(alias)
-      .filter(job__backend_alias=backend_alias)
+      .filter(backend_alias=backend_alias)
       .order_by("queue_name")
       .values_list(
         "queue_name",
@@ -124,8 +81,8 @@ class QueueInfo:
   def _ready_queryset(self):
     alias = get_database_alias(self.backend_alias)
     return ReadyExecution.objects.using(alias).filter(
+      backend_alias=self.backend_alias,
       queue_name=self.queue_name,
-      job__backend_alias=self.backend_alias,
     )
 
 
@@ -150,33 +107,20 @@ def schedule_recurring_task(
   description="",
   backend_alias="default",
 ):
-  alias = get_database_alias(backend_alias)
-  if kwargs is None:
-    kwargs = {}
-
-  recurring_task, _ = RecurringTask.objects.using(alias).update_or_create(
-    backend_alias=backend_alias,
+  operation = import_string("dj_queue.operations.recurring.schedule_recurring_task")
+  return operation(
     key=key,
-    defaults={
-      "task_path": task_path,
-      "payload": {"args": list(args), "kwargs": dict(kwargs)},
-      "schedule": schedule,
-      "queue_name": queue_name,
-      "priority": priority,
-      "description": description,
-      "static": False,
-    },
+    task_path=task_path,
+    schedule=schedule,
+    args=args,
+    kwargs=kwargs,
+    queue_name=queue_name,
+    priority=priority,
+    description=description,
+    backend_alias=backend_alias,
   )
-  return recurring_task
 
 
 def unschedule_recurring_task(key, *, backend_alias="default"):
-  alias = get_database_alias(backend_alias)
-  queryset = RecurringTask.objects.using(alias).filter(
-    backend_alias=backend_alias,
-    key=key,
-    static=False,
-  )
-  deleted = queryset.count()
-  queryset.delete()
-  return deleted
+  operation = import_string("dj_queue.operations.recurring.unschedule_recurring_task")
+  return operation(key, backend_alias=backend_alias)

{dj_queue-0.6.4 → dj_queue-0.7.1}/dj_queue/backend.py

@@ -8,7 +8,11 @@ from django.utils.module_loading import import_string
 
 from dj_queue.db import get_database_alias
 from dj_queue.models import Job
-from dj_queue.operations.jobs import enqueue_job_with_dispatch, enqueue_jobs_bulk
+from dj_queue.operations.jobs import (
+  enqueue_job_with_dispatch,
+  enqueue_jobs_bulk,
+  validate_queue_allowed,
+)
 
 
 class DjQueueBackend(BaseTaskBackend):
@@ -17,6 +21,10 @@ class DjQueueBackend(BaseTaskBackend):
   supports_get_result = True
   supports_priority = True
 
+  def validate_task(self, task):
+    validate_queue_allowed(task.queue_name, backend_alias=self.alias)
+    return super().validate_task(task)
+
   def enqueue(self, task, args, kwargs):
     self.validate_task(task)
     job, dispatched_as = enqueue_job_with_dispatch(task, args, kwargs, backend_alias=self.alias)

{dj_queue-0.6.4 → dj_queue-0.7.1}/dj_queue/config.py

@@ -174,12 +174,15 @@ def _load_backend_config_cached(
   if mode not in {"fork", "async"}:
     raise ImproperlyConfigured(f"dj_queue mode must be 'fork' or 'async', got {mode!r}")
 
-  only_work = bool(cli_overrides.get("only_work", False))
-  only_dispatch = bool(cli_overrides.get("only_dispatch", False))
+  only_work = _bool_option(cli_overrides.get("only_work", False), "--only-work")
+  only_dispatch = _bool_option(cli_overrides.get("only_dispatch", False), "--only-dispatch")
   if only_work and only_dispatch:
     raise ImproperlyConfigured("--only-work and --only-dispatch cannot be combined")
 
   skip_recurring = _resolve_skip_recurring(cli_overrides, env)
+  preserve_finished_jobs = _bool_option(
+    resolved_options["preserve_finished_jobs"], "preserve_finished_jobs"
+  )
   on_thread_error = _validated_callback_path(resolved_options.get("on_thread_error"))
   recurring = _build_recurring_config(resolved_options.get("recurring", {}))
   scheduler = _build_scheduler_config(resolved_options.get("scheduler", DEFAULT_SCHEDULER))
@@ -195,7 +198,7 @@ def _load_backend_config_cached(
   elif skip_recurring or not _scheduler_has_work(
     scheduler,
     recurring,
-    preserve_finished_jobs=bool(resolved_options["preserve_finished_jobs"]),
+    preserve_finished_jobs=preserve_finished_jobs,
     clear_finished_jobs_after=resolved_options["clear_finished_jobs_after"],
     clear_failed_jobs_after=resolved_options["clear_failed_jobs_after"],
     clear_recurring_executions_after=resolved_options["clear_recurring_executions_after"],
@@ -215,21 +218,28 @@ def _load_backend_config_cached(
     dispatchers=dispatchers,
     scheduler=scheduler,
     recurring=recurring,
-    process_heartbeat_interval=int(resolved_options["process_heartbeat_interval"]),
-    process_alive_threshold=int(resolved_options["process_alive_threshold"]),
-    shutdown_timeout=int(resolved_options["shutdown_timeout"]),
+    process_heartbeat_interval=_nonnegative_float(
+      resolved_options["process_heartbeat_interval"], "process_heartbeat_interval"
+    ),
+    process_alive_threshold=_positive_float(
+      resolved_options["process_alive_threshold"], "process_alive_threshold"
+    ),
+    shutdown_timeout=_nonnegative_float(resolved_options["shutdown_timeout"], "shutdown_timeout"),
     supervisor_pidfile=resolved_options["supervisor_pidfile"],
-    preserve_finished_jobs=bool(resolved_options["preserve_finished_jobs"]),
+    preserve_finished_jobs=preserve_finished_jobs,
     clear_finished_jobs_after=_optional_int(resolved_options["clear_finished_jobs_after"]),
     clear_failed_jobs_after=_optional_int(resolved_options["clear_failed_jobs_after"]),
     clear_recurring_executions_after=_optional_int(
       resolved_options["clear_recurring_executions_after"]
     ),
-    default_concurrency_duration=int(resolved_options["default_concurrency_duration"]),
+    default_concurrency_duration=_positive_int(
+      resolved_options["default_concurrency_duration"],
+      "default_concurrency_duration",
+    ),
     database_alias=str(resolved_options["database_alias"]),
-    use_skip_locked=bool(resolved_options["use_skip_locked"]),
-    listen_notify=bool(resolved_options["listen_notify"]),
-    silence_polling=bool(resolved_options["silence_polling"]),
+    use_skip_locked=_bool_option(resolved_options["use_skip_locked"], "use_skip_locked"),
+    listen_notify=_bool_option(resolved_options["listen_notify"], "listen_notify"),
+    silence_polling=_bool_option(resolved_options["silence_polling"], "silence_polling"),
     on_thread_error=on_thread_error,
     skip_recurring=skip_recurring,
     only_work=only_work,
@@ -356,7 +366,7 @@ def _resolve_skip_recurring(
   env: Mapping[str, str],
 ) -> bool:
   if "skip_recurring" in cli_overrides:
-    return bool(cli_overrides["skip_recurring"])
+    return _bool_option(cli_overrides["skip_recurring"], "skip_recurring")
 
   value = env.get("DJ_QUEUE_SKIP_RECURRING")
   if value is None:
@@ -375,6 +385,16 @@ def _parse_bool(value: str, setting_name: str) -> bool:
   )
 
 
+def _bool_option(value: Any, setting_name: str) -> bool:
+  if isinstance(value, bool):
+    return value
+  if isinstance(value, str):
+    return _parse_bool(value, setting_name)
+  if isinstance(value, int) and value in (0, 1):
+    return bool(value)
+  raise ImproperlyConfigured(f"dj_queue {setting_name} must be a boolean")
+
+
 def _validated_callback_path(callback_path: Any) -> str | None:
   if callback_path in (None, ""):
     return None
@@ -400,8 +420,13 @@ def _build_worker_configs(raw_workers: Any, mode: str) -> tuple[WorkerConfig, ..
 
     worker = WorkerConfig(
       queues=_as_queue_selectors(raw_worker.get("queues", DEFAULT_WORKER["queues"])),
-      threads=int(raw_worker.get("threads", DEFAULT_WORKER["threads"])),
-      processes=int(raw_worker.get("processes", DEFAULT_WORKER["processes"])),
+      threads=_positive_int(
+        raw_worker.get("threads", DEFAULT_WORKER["threads"]), f"workers[{index}].threads"
+      ),
+      processes=_positive_int(
+        raw_worker.get("processes", DEFAULT_WORKER["processes"]),
+        f"workers[{index}].processes",
+      ),
       polling_interval=_positive_float(
         raw_worker.get("polling_interval", DEFAULT_WORKER["polling_interval"]),
         f"workers[{index}].polling_interval",
@@ -431,22 +456,27 @@ def _build_dispatcher_configs(raw_dispatchers: Any) -> tuple[DispatcherConfig, .
 
     dispatchers.append(
       DispatcherConfig(
-        batch_size=int(raw_dispatcher.get("batch_size", DEFAULT_DISPATCHER["batch_size"])),
+        batch_size=_positive_int(
+          raw_dispatcher.get("batch_size", DEFAULT_DISPATCHER["batch_size"]),
+          f"dispatchers[{index}].batch_size",
+        ),
         polling_interval=_positive_float(
           raw_dispatcher.get("polling_interval", DEFAULT_DISPATCHER["polling_interval"]),
           f"dispatchers[{index}].polling_interval",
         ),
-        concurrency_maintenance=bool(
+        concurrency_maintenance=_bool_option(
           raw_dispatcher.get(
             "concurrency_maintenance",
             DEFAULT_DISPATCHER["concurrency_maintenance"],
-          )
+          ),
+          f"dispatchers[{index}].concurrency_maintenance",
         ),
-        concurrency_maintenance_interval=int(
+        concurrency_maintenance_interval=_nonnegative_float(
           raw_dispatcher.get(
             "concurrency_maintenance_interval",
             DEFAULT_DISPATCHER["concurrency_maintenance_interval"],
-          )
+          ),
+          f"dispatchers[{index}].concurrency_maintenance_interval",
         ),
       )
     )
@@ -460,11 +490,12 @@ def _build_scheduler_config(raw_scheduler: Any) -> SchedulerConfig:
     raise ImproperlyConfigured("scheduler config must be a mapping")
 
   return SchedulerConfig(
-    dynamic_tasks_enabled=bool(
+    dynamic_tasks_enabled=_bool_option(
       raw_scheduler.get(
         "dynamic_tasks_enabled",
         DEFAULT_SCHEDULER["dynamic_tasks_enabled"],
-      )
+      ),
+      "scheduler.dynamic_tasks_enabled",
     ),
     polling_interval=_positive_float(
       raw_scheduler.get("polling_interval", DEFAULT_SCHEDULER["polling_interval"]),
@@ -556,5 +587,35 @@ def _positive_float(value: Any, setting_name: str) -> float:
   return number
 
 
+def _nonnegative_float(value: Any, setting_name: str) -> float:
+  try:
+    number = float(value)
+  except (TypeError, ValueError) as exc:
+    raise ImproperlyConfigured(
+      f"dj_queue {setting_name} must be a non-negative number, got {value!r}"
+    ) from exc
+
+  if not math.isfinite(number) or number < 0:
+    raise ImproperlyConfigured(
+      f"dj_queue {setting_name} must be a non-negative number, got {value!r}"
+    )
+  return number
+
+
+def _positive_int(value: Any, setting_name: str) -> int:
+  try:
+    number = int(value)
+  except (TypeError, ValueError, OverflowError) as exc:
+    raise ImproperlyConfigured(
+      f"dj_queue {setting_name} must be a positive integer, got {value!r}"
+    ) from exc
+
+  if number <= 0:
+    raise ImproperlyConfigured(
+      f"dj_queue {setting_name} must be a positive integer, got {value!r}"
+    )
+  return number
+
+
 def _cache_key(value: Any) -> str:
   return json.dumps(value, sort_keys=True, separators=(",", ":"), default=str)

{dj_queue-0.6.4 → dj_queue-0.7.1}/dj_queue/contrib/prometheus.py

@@ -1,7 +1,11 @@
 try:
   from prometheus_client import CollectorRegistry, generate_latest
   from prometheus_client.core import GaugeMetricFamily
-
+except ImportError:
+  DjQueueCollector = None
+  registry = None
+  generate_latest = None
+else:
   from dj_queue import observability
 
   class DjQueueCollector:
@@ -122,8 +126,3 @@ try:
 
   registry = CollectorRegistry(auto_describe=False)
   registry.register(DjQueueCollector())
-
-except ImportError:
-  DjQueueCollector = None
-  registry = None
-  generate_latest = None

{dj_queue-0.6.4 → dj_queue-0.7.1}/dj_queue/db.py

@@ -3,6 +3,7 @@ from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import Literal
 
+from django.core.exceptions import ImproperlyConfigured
 from django.db import DEFAULT_DB_ALIAS, connections
 
 from dj_queue.config import load_backend_config
@@ -65,4 +66,9 @@ def _backend_family(connection) -> Literal["postgresql", "mysql", "mariadb", "sq
     return "sqlite"
   if connection.vendor == "mysql" and getattr(connection, "mysql_is_mariadb", False):
     return "mariadb"
-  return "mysql"
+  if connection.vendor == "mysql":
+    return "mysql"
+  raise ImproperlyConfigured(
+    f"dj_queue unsupported database vendor {connection.vendor!r}; "
+    "supported vendors are 'postgresql', 'mysql', and 'sqlite'"
+  )

dj_queue-0.7.1/dj_queue/migrations/0007_recurringtask_next_run_at.py

@@ -0,0 +1,23 @@
+# Generated by Django 6.0.4 on 2026-05-06 06:30
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+  dependencies = [
+    ("dj_queue", "0006_blockedexecution_dj_queue_bl_concurr_2d8393_idx_and_more"),
+  ]
+
+  operations = [
+    migrations.AddField(
+      model_name="recurringtask",
+      name="next_run_at",
+      field=models.DateTimeField(blank=True, null=True),
+    ),
+    migrations.AddIndex(
+      model_name="recurringtask",
+      index=models.Index(
+        fields=["backend_alias", "next_run_at", "key"], name="dj_queue_rt_next_run_idx"
+      ),
+    ),
+  ]