dj-queue 0.9.0__tar.gz → 0.9.2__tar.gz

{dj_queue-0.9.0 → dj_queue-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dj-queue
-Version: 0.9.0
+Version: 0.9.2
 Summary: Database-backed task queue backend for Django’s Tasks framework.
 License-Expression: MIT
 License-File: LICENSE
@@ -780,26 +780,70 @@ concurrency-maintenance throughput.
 
 The main configuration lives in `TASKS[backend_alias]["OPTIONS"]`.
 
-Start with these options:
-
-- `mode`: `"fork"` or `"async"`
-- `workers`: queue selectors, thread counts, and process counts
-- `dispatchers`: scheduled promotion and concurrency maintenance settings
-- `scheduler`: dynamic recurring polling settings
-- `database_alias`: database alias for queue tables and runtime activity
-- `preserve_finished_jobs` and `clear_finished_jobs_after`: successful result retention and cleanup
-- `clear_failed_jobs_after`: optional failed-job retention window
-- `clear_recurring_executions_after`: optional recurring reservation retention window
-
-Additional operational tuning is available when needed:
-
-- `use_skip_locked`: use `SKIP LOCKED` when the active backend supports it
-- `listen_notify`: PostgreSQL-only worker wakeup optimization layered on top of polling
-- `silence_polling`: suppress `dj_queue`'s own poll-cycle noise without mutating Django's global SQL logger
-- `process_heartbeat_interval` and `process_alive_threshold`: process liveness reporting and stale-runner detection
-- `shutdown_timeout`: graceful drain window before standalone shutdown gives up on waiting
-- `supervisor_pidfile`: optional pidfile guard for standalone supervisors
-- `on_thread_error`: dotted callback path for runtime infrastructure exceptions
+No top-level `OPTIONS` key is required. Omit a key to use its default. Static
+`recurring` entries are the exception: each named recurring task requires
+`task_path` and `schedule`.
+
+Global options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `mode` | `"fork"` | standalone runtime mode, either `"fork"` or `"async"` |
+| `workers` | `[{"queues": "*", "threads": 3, "processes": 1, "polling_interval": 0.1}]` | worker topology and queue selectors |
+| `dispatchers` | `[{"batch_size": 500, "polling_interval": 1, "concurrency_maintenance": true, "concurrency_maintenance_interval": 600}]` | scheduled promotion and concurrency maintenance |
+| `scheduler` | `{"dynamic_tasks_enabled": false, "polling_interval": 5}` | dynamic recurring polling; the scheduler only starts when recurring or cleanup work exists |
+| `recurring` | `{}` | static recurring task definitions keyed by name |
+| `database_alias` | `"default"` | database alias for queue tables and runtime activity |
+| `preserve_finished_jobs` | `true` | keep successful jobs for result lookup and retention cleanup |
+| `clear_finished_jobs_after` | `86400` | seconds before finished successful jobs are cleaned up |
+| `clear_failed_jobs_after` | `null` | optional failed-job retention window in seconds |
+| `clear_recurring_executions_after` | `null` | optional recurring reservation retention window in seconds |
+| `default_concurrency_duration` | `180` | default semaphore TTL in seconds |
+| `use_skip_locked` | `true` | use `SKIP LOCKED` when the active backend supports it |
+| `listen_notify` | `true` | PostgreSQL-only worker wakeup optimization layered on top of polling |
+| `silence_polling` | `true` | suppress `dj_queue`'s own poll-cycle noise without mutating Django's global SQL logger |
+| `process_heartbeat_interval` | `60` | seconds between process heartbeat writes |
+| `process_alive_threshold` | `300` | seconds before a process row is stale |
+| `shutdown_timeout` | `5` | graceful drain window before standalone shutdown gives up on waiting |
+| `supervisor_pidfile` | `null` | optional pidfile guard for standalone supervisors |
+| `on_thread_error` | `null` | dotted callback path for runtime infrastructure exceptions |
+
+Worker entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `queues` | `"*"` | queue selector or selectors; `"*"` means all queues |
+| `threads` | `3` | worker threads per worker process |
+| `processes` | `1` | worker processes in `fork` mode; normalized to `1` in `async` mode |
+| `polling_interval` | `0.1` | seconds between worker polls |
+
+Dispatcher entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `batch_size` | `500` | maximum scheduled or blocked rows to promote per batch |
+| `polling_interval` | `1` | seconds between dispatcher polls |
+| `concurrency_maintenance` | `true` | run expired semaphore and blocked-job maintenance |
+| `concurrency_maintenance_interval` | `600` | seconds between maintenance passes; `0` means every poll |
+
+Scheduler entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `dynamic_tasks_enabled` | `false` | load dynamic recurring tasks from the database |
+| `polling_interval` | `5` | seconds between scheduler polls |
+
+Recurring entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `task_path` | none | required dotted import path for the task to enqueue |
+| `schedule` | none | required cron or supported Fugit-style cronish schedule |
+| `args` | `[]` | positional arguments for the task |
+| `kwargs` | `{}` | keyword arguments for the task |
+| `queue_name` | `"default"` | queue used for jobs created from this recurring task |
+| `priority` | `0` | priority used for jobs created from this recurring task |
+| `description` | `""` | operator-facing description |
 
 On PostgreSQL, `listen_notify` uses the same Django PostgreSQL driver
 configuration as the main database connection. Install a compatible driver in

{dj_queue-0.9.0 → dj_queue-0.9.2}/README.md

@@ -754,26 +754,70 @@ concurrency-maintenance throughput.
 
 The main configuration lives in `TASKS[backend_alias]["OPTIONS"]`.
 
-Start with these options:
-
-- `mode`: `"fork"` or `"async"`
-- `workers`: queue selectors, thread counts, and process counts
-- `dispatchers`: scheduled promotion and concurrency maintenance settings
-- `scheduler`: dynamic recurring polling settings
-- `database_alias`: database alias for queue tables and runtime activity
-- `preserve_finished_jobs` and `clear_finished_jobs_after`: successful result retention and cleanup
-- `clear_failed_jobs_after`: optional failed-job retention window
-- `clear_recurring_executions_after`: optional recurring reservation retention window
-
-Additional operational tuning is available when needed:
-
-- `use_skip_locked`: use `SKIP LOCKED` when the active backend supports it
-- `listen_notify`: PostgreSQL-only worker wakeup optimization layered on top of polling
-- `silence_polling`: suppress `dj_queue`'s own poll-cycle noise without mutating Django's global SQL logger
-- `process_heartbeat_interval` and `process_alive_threshold`: process liveness reporting and stale-runner detection
-- `shutdown_timeout`: graceful drain window before standalone shutdown gives up on waiting
-- `supervisor_pidfile`: optional pidfile guard for standalone supervisors
-- `on_thread_error`: dotted callback path for runtime infrastructure exceptions
+No top-level `OPTIONS` key is required. Omit a key to use its default. Static
+`recurring` entries are the exception: each named recurring task requires
+`task_path` and `schedule`.
+
+Global options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `mode` | `"fork"` | standalone runtime mode, either `"fork"` or `"async"` |
+| `workers` | `[{"queues": "*", "threads": 3, "processes": 1, "polling_interval": 0.1}]` | worker topology and queue selectors |
+| `dispatchers` | `[{"batch_size": 500, "polling_interval": 1, "concurrency_maintenance": true, "concurrency_maintenance_interval": 600}]` | scheduled promotion and concurrency maintenance |
+| `scheduler` | `{"dynamic_tasks_enabled": false, "polling_interval": 5}` | dynamic recurring polling; the scheduler only starts when recurring or cleanup work exists |
+| `recurring` | `{}` | static recurring task definitions keyed by name |
+| `database_alias` | `"default"` | database alias for queue tables and runtime activity |
+| `preserve_finished_jobs` | `true` | keep successful jobs for result lookup and retention cleanup |
+| `clear_finished_jobs_after` | `86400` | seconds before finished successful jobs are cleaned up |
+| `clear_failed_jobs_after` | `null` | optional failed-job retention window in seconds |
+| `clear_recurring_executions_after` | `null` | optional recurring reservation retention window in seconds |
+| `default_concurrency_duration` | `180` | default semaphore TTL in seconds |
+| `use_skip_locked` | `true` | use `SKIP LOCKED` when the active backend supports it |
+| `listen_notify` | `true` | PostgreSQL-only worker wakeup optimization layered on top of polling |
+| `silence_polling` | `true` | suppress `dj_queue`'s own poll-cycle noise without mutating Django's global SQL logger |
+| `process_heartbeat_interval` | `60` | seconds between process heartbeat writes |
+| `process_alive_threshold` | `300` | seconds before a process row is stale |
+| `shutdown_timeout` | `5` | graceful drain window before standalone shutdown gives up on waiting |
+| `supervisor_pidfile` | `null` | optional pidfile guard for standalone supervisors |
+| `on_thread_error` | `null` | dotted callback path for runtime infrastructure exceptions |
+
+Worker entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `queues` | `"*"` | queue selector or selectors; `"*"` means all queues |
+| `threads` | `3` | worker threads per worker process |
+| `processes` | `1` | worker processes in `fork` mode; normalized to `1` in `async` mode |
+| `polling_interval` | `0.1` | seconds between worker polls |
+
+Dispatcher entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `batch_size` | `500` | maximum scheduled or blocked rows to promote per batch |
+| `polling_interval` | `1` | seconds between dispatcher polls |
+| `concurrency_maintenance` | `true` | run expired semaphore and blocked-job maintenance |
+| `concurrency_maintenance_interval` | `600` | seconds between maintenance passes; `0` means every poll |
+
+Scheduler entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `dynamic_tasks_enabled` | `false` | load dynamic recurring tasks from the database |
+| `polling_interval` | `5` | seconds between scheduler polls |
+
+Recurring entry options:
+
+| Option | Default | Meaning |
+|---|---|---|
+| `task_path` | none | required dotted import path for the task to enqueue |
+| `schedule` | none | required cron or supported Fugit-style cronish schedule |
+| `args` | `[]` | positional arguments for the task |
+| `kwargs` | `{}` | keyword arguments for the task |
+| `queue_name` | `"default"` | queue used for jobs created from this recurring task |
+| `priority` | `0` | priority used for jobs created from this recurring task |
+| `description` | `""` | operator-facing description |
 
 On PostgreSQL, `listen_notify` uses the same Django PostgreSQL driver
 configuration as the main database connection. Install a compatible driver in

{dj_queue-0.9.0 → dj_queue-0.9.2}/dj_queue/admin.py

@@ -29,12 +29,19 @@ from dj_queue.models import (
   Semaphore,
 )
 from dj_queue.operations.jobs import (
+  DispatchOutcome,
   discard_failed_job,
   dispatch_scheduled_job_now,
   enqueue_job_again,
   retry_failed_job,
   retry_failed_jobs,
 )
+from dj_queue.queue_state import (
+  QUEUE_STATES,
+  filter_queue_state,
+  is_queue_state,
+  status_rank_expression,
+)
 
 
 class DjQueueFirstAdminSite(admin.AdminSite):
@@ -327,29 +334,12 @@ class JobStatusListFilter(admin.SimpleListFilter):
   parameter_name = "status"
 
   def lookups(self, request, model_admin):
-    return (
-      ("ready", "ready"),
-      ("scheduled", "scheduled"),
-      ("claimed", "claimed"),
-      ("blocked", "blocked"),
-      ("failed", "failed"),
-      ("finished", "finished"),
-    )
+    return QUEUE_STATES
 
   def queryset(self, request, queryset):
     value = self.value()
-    if value == "ready":
-      return queryset.ready()
-    if value == "scheduled":
-      return queryset.scheduled()
-    if value == "claimed":
-      return queryset.claimed()
-    if value == "blocked":
-      return queryset.blocked()
-    if value == "failed":
-      return queryset.failed()
-    if value == "finished":
-      return queryset.finished()
+    if is_queue_state(value):
+      return filter_queue_state(queryset, value)
     return queryset
 
 
@@ -503,18 +493,7 @@ class JobAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
 
   def get_queryset(self, request):
     queryset = super().get_queryset(request)
-    return queryset.annotate(
-      status_rank=Case(
-        When(ready_execution__isnull=False, then=Value(0)),
-        When(scheduled_execution__isnull=False, then=Value(1)),
-        When(claimed_execution__isnull=False, then=Value(2)),
-        When(blocked_execution__isnull=False, then=Value(3)),
-        When(failed_execution__isnull=False, then=Value(4)),
-        When(finished_at__isnull=False, then=Value(5)),
-        default=Value(99),
-        output_field=IntegerField(),
-      )
-    )
+    return queryset.annotate(status_rank=status_rank_expression())
 
   @admin.display(description="status", ordering="status_rank")
   def display_status(self, obj):
@@ -600,15 +579,17 @@ class JobAdmin(HiddenSidebarAdminMixin, admin.ModelAdmin):
   def handle_change_action(self, request, obj, action):
     if action == "run_now":
       try:
-        _job, dispatched_as = dispatch_scheduled_job_now(obj.pk, backend_alias=obj.backend_alias)
+        _job, dispatch_outcome = dispatch_scheduled_job_now(
+          obj.pk, backend_alias=obj.backend_alias
+        )
       except (EnqueueError, ImportError, AttributeError) as exc:
         self.message_user(request, f"Could not dispatch job now: {exc}", level=messages.ERROR)
         return self._current_object_redirect(obj, backend_alias=obj.backend_alias)
 
       message = "Dispatched scheduled job for immediate execution"
-      if dispatched_as == "blocked":
+      if dispatch_outcome is DispatchOutcome.BLOCKED:
         message = "Dispatched scheduled job immediately and it is now blocked"
-      if dispatched_as == "discarded":
+      if dispatch_outcome is DispatchOutcome.DISCARDED:
         message = "Dispatched scheduled job immediately and it was discarded"
       self.message_user(request, message, level=messages.SUCCESS)
       return self._current_object_redirect(obj, backend_alias=obj.backend_alias)

dj_queue-0.9.2/dj_queue/backend.py

@@ -0,0 +1,91 @@
+from asgiref.sync import sync_to_async
+from django.db import close_old_connections, connections
+from django.tasks.backends.base import BaseTaskBackend
+from django.tasks.exceptions import TaskResultDoesNotExist
+
+from dj_queue.db import get_database_alias
+from dj_queue.models import Job
+from dj_queue.operations.jobs import (
+  DispatchOutcome,
+  enqueue_job_with_dispatch,
+  enqueue_jobs_bulk,
+  validate_queue_allowed,
+)
+from dj_queue.task_results import task_result_from_enqueued_job, task_result_from_job
+
+
+class DjQueueBackend(BaseTaskBackend):
+  supports_async_task = True
+  supports_defer = True
+  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, dispatch_outcome = enqueue_job_with_dispatch(task, args, kwargs, backend_alias=self.alias)
+    return task_result_from_enqueued_job(
+      job,
+      task,
+      successful=dispatch_outcome is DispatchOutcome.DISCARDED,
+    )
+
+  async def aenqueue(self, task, args, kwargs):
+    return await sync_to_async(_async_backend_call, thread_sensitive=True)(
+      self.enqueue,
+      task=task,
+      args=args,
+      kwargs=kwargs,
+    )
+
+  def enqueue_all(self, task_calls):
+    jobs = []
+    for task, args, kwargs in task_calls:
+      self.validate_task(task)
+      jobs.append((task, args, kwargs))
+
+    created_jobs = enqueue_jobs_bulk(jobs, backend_alias=self.alias)
+    return [
+      task_result_from_enqueued_job(
+        job,
+        task,
+        successful=dispatch_outcome is DispatchOutcome.DISCARDED,
+      )
+      for job, task, dispatch_outcome in created_jobs
+    ]
+
+  def get_result(self, result_id):
+    alias = get_database_alias(self.alias)
+    try:
+      job = (
+        Job.objects.using(alias)
+        .select_related(
+          "ready_execution",
+          "scheduled_execution",
+          "claimed_execution__process",
+          "blocked_execution",
+          "failed_execution",
+        )
+        .get(pk=result_id, backend_alias=self.alias)
+      )
+    except Job.DoesNotExist as exc:
+      raise TaskResultDoesNotExist(str(result_id)) from exc
+
+    return task_result_from_job(job)
+
+  async def aget_result(self, result_id):
+    return await sync_to_async(_async_backend_call, thread_sensitive=True)(
+      self.get_result,
+      result_id=result_id,
+    )
+
+
+def _async_backend_call(method, /, **kwargs):
+  close_old_connections()
+  try:
+    return method(**kwargs)
+  finally:
+    connections.close_all()

dj_queue-0.9.2/dj_queue/contrib/prometheus.py

@@ -0,0 +1,26 @@
+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.metrics import metric_families
+
+  class DjQueueCollector:
+    """Prometheus collector that exposes dj_queue metrics from the shared observability snapshot."""
+
+    def collect(self):
+      for family in metric_families():
+        gauge = GaugeMetricFamily(
+          family.name,
+          family.help_text,
+          labels=list(family.labels),
+        )
+        for sample in family.samples:
+          gauge.add_metric(list(sample.labels), sample.value)
+        yield gauge
+
+  registry = CollectorRegistry(auto_describe=False)
+  registry.register(DjQueueCollector())

{dj_queue-0.9.0 → dj_queue-0.9.2}/dj_queue/dashboard.py

@@ -22,51 +22,26 @@ from dj_queue.operations.jobs import (
   enqueue_job_again,
   retry_failed_jobs,
 )
+from dj_queue.queue_state import (
+  QUEUE_STATE_DEFINITIONS,
+  QUEUE_STATE_LABELS,
+  QUEUE_STATES,
+  queue_state_count_key,
+  queue_state_queryset,
+)
 
-QUEUE_STATE_CONFIG = {
-  "ready": {
-    "label": "ready",
-    "job_actions": ({"name": "discard", "label": "discard selected"},),
-    "query_filter": {"ready_execution__isnull": False},
-    "query_order": ("-priority", "ready_execution__id"),
-  },
-  "claimed": {
-    "label": "claimed",
-    "job_actions": (),
-    "query_filter": {"claimed_execution__isnull": False},
-    "query_order": ("claimed_execution__created_at", "id"),
-  },
-  "scheduled": {
-    "label": "scheduled",
-    "job_actions": ({"name": "discard", "label": "discard selected"},),
-    "query_filter": {"scheduled_execution__isnull": False},
-    "query_order": ("scheduled_execution__scheduled_at", "-priority", "scheduled_execution__id"),
-  },
-  "blocked": {
-    "label": "blocked",
-    "job_actions": ({"name": "discard", "label": "discard selected"},),
-    "query_filter": {"blocked_execution__isnull": False},
-    "query_order": ("blocked_execution__expires_at", "-priority", "blocked_execution__id"),
-  },
-  "failed": {
-    "label": "failed",
-    "job_actions": (
-      {"name": "retry", "label": "retry selected"},
-      {"name": "discard", "label": "discard selected"},
-    ),
-    "query_filter": {"failed_execution__isnull": False},
-    "query_order": ("-failed_execution__created_at", "id"),
-  },
-  "finished": {
-    "label": "finished",
-    "job_actions": ({"name": "enqueue", "label": "enqueue selected again"},),
-    "query_filter": {"finished_at__isnull": False},
-    "query_order": ("-finished_at", "id"),
-  },
-}
 
-QUEUE_STATES = tuple((state, config["label"]) for state, config in QUEUE_STATE_CONFIG.items())
-QUEUE_STATE_LABELS = {state: config["label"] for state, config in QUEUE_STATE_CONFIG.items()}
+QUEUE_JOB_ACTIONS = {
+  "ready": ({"name": "discard", "label": "discard selected"},),
+  "claimed": (),
+  "scheduled": ({"name": "discard", "label": "discard selected"},),
+  "blocked": ({"name": "discard", "label": "discard selected"},),
+  "failed": (
+    {"name": "retry", "label": "retry selected"},
+    {"name": "discard", "label": "discard selected"},
+  ),
+  "finished": ({"name": "enqueue", "label": "enqueue selected again"},),
+}
 PAGE_SIZE = 100
 OVERVIEW_PAGE_SIZES = {
   "queues": 18,
@@ -87,12 +62,14 @@ OVERVIEW_SORTS = {
     "default": "name",
     "fields": {
       "name": {"label": "name", "key": "name", "default_desc": False, "css_class": "djq-col-name"},
-      "ready": {"label": "ready", "key": "ready_count", "default_desc": True},
-      "claimed": {"label": "claimed", "key": "claimed_count", "default_desc": True},
-      "scheduled": {"label": "scheduled", "key": "scheduled_count", "default_desc": True},
-      "blocked": {"label": "blocked", "key": "blocked_count", "default_desc": True},
-      "failed": {"label": "failed", "key": "failed_count", "default_desc": True},
-      "finished": {"label": "finished", "key": "finished_count", "default_desc": True},
+      **{
+        definition.name: {
+          "label": definition.label,
+          "key": definition.count_key,
+          "default_desc": True,
+        }
+        for definition in QUEUE_STATE_DEFINITIONS
+      },
       "paused": {"label": "paused", "key": "paused", "default_desc": True},
       "latency": {"label": "latency", "key": "latency_seconds", "default_desc": True},
       "workers": {"label": "workers", "key": "live_worker_count", "default_desc": True},
@@ -399,7 +376,7 @@ def queue_page_context(*, backend_alias, queue_name, state, page_number, query_p
   )
   queue_info = QueueInfo(queue_name, backend_alias=backend_alias)
   state_counts = {
-    state_name: queue_row[f"{state_name}_count"] for state_name, _label in QUEUE_STATES
+    definition.name: queue_row[definition.count_key] for definition in QUEUE_STATE_DEFINITIONS
   }
   state_tabs = [
     {
@@ -555,15 +532,15 @@ def apply_job_action(*, backend_alias, queue_name, state, action, job_ids):
 
 
 def job_actions_for_state(state):
-  return QUEUE_STATE_CONFIG[state]["job_actions"]
+  return QUEUE_JOB_ACTIONS[state]
 
 
 def _summary_cards(*, backend_alias, queue_rows, process_rows, recurring_rows, semaphore_rows):
   paused_count = sum(1 for row in queue_rows if row["paused"])
-  ready_count = sum(row["ready_count"] for row in queue_rows)
-  scheduled_count = sum(row["scheduled_count"] for row in queue_rows)
-  failed_count = sum(row["failed_count"] for row in queue_rows)
-  blocked_count = sum(row["blocked_count"] for row in queue_rows)
+  ready_count = sum(row[queue_state_count_key("ready")] for row in queue_rows)
+  scheduled_count = sum(row[queue_state_count_key("scheduled")] for row in queue_rows)
+  failed_count = sum(row[queue_state_count_key("failed")] for row in queue_rows)
+  blocked_count = sum(row[queue_state_count_key("blocked")] for row in queue_rows)
   live_processes = sum(1 for row in process_rows if row["is_live"])
   stale_processes = len(process_rows) - live_processes
 
@@ -1181,20 +1158,7 @@ def _failed_execution_changelist_url(backend_alias, **filters):
 
 
 def _jobs_for_queue_state(*, backend_alias, queue_name, state):
-  alias = get_database_alias(backend_alias)
-  queryset = (
-    Job.objects.using(alias)
-    .filter(backend_alias=backend_alias, queue_name=queue_name)
-    .select_related(
-      "ready_execution",
-      "scheduled_execution",
-      "claimed_execution__process",
-      "blocked_execution",
-      "failed_execution",
-    )
-  )
-  state_config = QUEUE_STATE_CONFIG[state]
-  return queryset.filter(**state_config["query_filter"]).order_by(*state_config["query_order"])
+  return queue_state_queryset(backend_alias=backend_alias, queue_name=queue_name, state=state)
 
 
 def _next_run_at(schedule, now):

{dj_queue-0.9.0 → dj_queue-0.9.2}/dj_queue/log.py

@@ -6,6 +6,17 @@ from dj_queue.config import load_backend_config
 logger = logging.getLogger("dj_queue")
 
 
+def event_logging_enabled(
+  level: int = logging.INFO,
+  *,
+  backend_alias: str = "default",
+  polling: bool = False,
+):
+  if polling and load_backend_config(backend_alias).silence_polling:
+    return False
+  return logger.isEnabledFor(level)
+
+
 def log_event(
   event: str,
   *,
@@ -14,7 +25,7 @@ def log_event(
   polling: bool = False,
   **fields: Any,
 ):
-  if polling and load_backend_config(backend_alias).silence_polling:
+  if not event_logging_enabled(level, backend_alias=backend_alias, polling=polling):
     return
 
   logger.log(