delayed 2.0.3 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4227961278ab7f1ed435e8357cbf83998ee6d1d597f981fc4d1ab92a0d1069fa
-  data.tar.gz: fd108cb072de3ec495d2713326821b231cfe8ffa153782a80f84da06d272ecfa
+  metadata.gz: 6d365ce7fa45762c6122da4a21a7c96e30893c15534f76bb26cbb4e3f721f7c6
+  data.tar.gz: ca6deb755821f865e354a4ff62375d7c918c81e0b9b4be5f665aa9a347ee90e9
 SHA512:
-  metadata.gz: 36fd83967d57e3ae7d58a2edfceb790d35bcf3f9a49a9bf3de9e34c15528ba2c3ae36468c7847e8e49d7d90ca8b03ef1e39a62620257fb06cb8f321a5af0909e
-  data.tar.gz: df0443f6ca1f859e5b4155a0b38aa72310e0607f57c30ba31dcd0fda39825e0ae81903d0b019886c7405e607d1817f3733c47fbfed81b25cb897440cb2be8da8
+  metadata.gz: 936fabfd27c2ae4ee68c5f999f8b10e778a171b7f438e191a6bdadfc4c3b16da455e5f1620ff0044fc7efa257308fe0679fc74ec879342d0c5c5a248a6d657d0
+  data.tar.gz: 5cb3cdb9e392ed6ae999d768fe910d0587fa1c5cb652cd5a2cd2f5ce2fc88a8598c105a199e831e0c3185af47cc310e82ada88bc862862fe4c9ebd291166a958

data/app/models/delayed/job.rb

@@ -10,26 +10,22 @@ module Delayed
 
     # high-level queue states (live => erroring => failed)
     scope :live, -> { where(failed_at: nil) }
-    scope :erroring, -> { where(arel_table[:attempts].gt(0)).merge(unscoped.live) }
+    scope :erroring, -> { where(erroring_clause).merge(unscoped.live) }
     scope :failed, -> { where.not(failed_at: nil) }
 
     # live queue states (future vs pending)
-    scope :future, ->(as_of = db_time_now) { merge(unscoped.live).where(arel_table[:run_at].gt(as_of)) }
-    scope :pending, ->(as_of = db_time_now) { merge(unscoped.live).where(arel_table[:run_at].lteq(as_of)) }
+    scope :future, ->(as_of = db_time_now) { merge(unscoped.live).where(future_clause(as_of)) }
+    scope :pending, ->(as_of = db_time_now) { merge(unscoped.live).where(pending_clause(as_of)) }
 
     # pending queue states (claimed vs claimable)
     scope :claimed, ->(as_of = db_time_now) {
-      where(arel_table[:locked_at].gteq(db_time_now - lock_timeout))
-        .merge(unscoped.pending(as_of))
+      where(claimed_clause(as_of)).merge(unscoped.pending(as_of))
     }
     scope :claimed_by, ->(worker, as_of = db_time_now) {
-      where(locked_by: worker.name)
-        .claimed(as_of)
+      where(locked_by: worker.name).claimed(as_of)
     }
     scope :claimable, ->(as_of = db_time_now) {
-      where(locked_at: nil)
-        .or(where(arel_table[:locked_at].lt(db_time_now - lock_timeout)))
-        .merge(unscoped.pending(as_of))
+      where(claimable_clause(as_of)).merge(unscoped.pending(as_of))
     }
     scope :claimable_by, ->(worker, as_of = db_time_now) {
       claimable(as_of)
@@ -40,6 +36,26 @@ module Delayed
         .by_priority
     }
 
+    def self.erroring_clause
+      arel_table[:attempts].gt(0)
+    end
+
+    def self.future_clause(as_of = db_time_now)
+      arel_table[:run_at].gt(as_of)
+    end
+
+    def self.pending_clause(as_of = db_time_now)
+      arel_table[:run_at].lteq(as_of)
+    end
+
+    def self.claimed_clause(as_of = db_time_now)
+      arel_table[:locked_at].gteq(as_of - lock_timeout)
+    end
+
+    def self.claimable_clause(as_of = db_time_now)
+      arel_table[:locked_at].eq(nil).or arel_table[:locked_at].lt(as_of - lock_timeout)
+    end
+
     before_save :set_default_run_at, :set_name
 
     REENQUEUE_BUFFER = 30.seconds

data/lib/delayed/backend/job_preparer.rb

@@ -13,6 +13,7 @@ module Delayed
         set_queue_name
         set_priority
         handle_dst
+        reject_stale_run_at
         handle_deprecation
         options
       end
@@ -51,6 +52,18 @@ module Delayed
         end
       end
 
+      def reject_stale_run_at
+        return unless Delayed::Worker.deny_stale_enqueues
+        return unless options[:run_at]
+
+        threshold = Job.db_time_now - Job.lock_timeout
+        return unless options[:run_at] < threshold
+
+        raise StaleEnqueueError,
+              "Cannot enqueue a job in the distant past (run_at: #{options[:run_at].iso8601}," \
+              " threshold: #{threshold.iso8601}). This is usually a bug."
+      end
+
       def handle_deprecation
         unless options[:payload_object].respond_to?(:perform)
           raise ArgumentError,

data/lib/delayed/exceptions.rb

@@ -14,4 +14,6 @@ module Delayed
   class FatalBackendError < RuntimeError; end
 
   class DeserializationError < StandardError; end
+
+  class StaleEnqueueError < StandardError; end
 end

data/lib/delayed/monitor.rb

@@ -35,6 +35,33 @@ module Delayed
       send(:"#{metric}_grouped")
     end
 
+    def self.sql_now_in_utc
+      case ActiveRecord::Base.connection.adapter_name
+      when 'PostgreSQL'
+        "TIMEZONE('UTC', STATEMENT_TIMESTAMP())"
+      when 'MySQL', 'Mysql2'
+        "UTC_TIMESTAMP()"
+      else
+        "CURRENT_TIMESTAMP"
+      end
+    end
+
+    def self.parse_utc_time(string)
+      # Depending on Rails version & DB adapter, this will be either a String or a DateTime.
+      # If it's a DateTime, and if connection is running with the `:local` time zone config,
+      # then by default Rails incorrectly assumes it's in local time instead of UTC.
+      # We use `strftime` to strip the encoded TZ info and re-parse it as UTC.
+      #
+      # Example:
+      # - "2026-02-05 10:01:23"        -> DB-returned string
+      # - "2026-02-05 10:01:23 -0600"  -> Rails-parsed DateTime with incorrect TZ
+      # - "2026-02-05 10:01:23"        -> `strftime` output
+      # - "2026-02-05 04:01:23 -0600"  -> Re-parsed as UTC and converted to local time
+      string = string.strftime('%Y-%m-%d %H:%M:%S') if string.respond_to?(:strftime)
+
+      ActiveSupport::TimeZone.new("UTC").parse(string)
+    end
+
     private
 
     attr_reader :jobs
@@ -68,83 +95,129 @@ module Delayed
       }
     end
 
-    def grouped_count(scope)
-      Delayed::Job.from(scope.select('priority, queue, COUNT(*) AS count'))
-        .group(priority_case_statement, :queue).sum(:count)
+    # This method generates a query that scans the specified scope, groups by
+    # priority and queue, and calculates the specified aggregates. An outer
+    # query is executed for priority bucketing and appending db_now_utc (to
+    # avoid running these computations for each tuple in the inner query).
+    def grouped_query(scope, include_db_time: false, **kwargs)
+      inner_selects = kwargs.map { |key, (agg, expr)| as_expression(agg, expr, key) }
+      outer_selects = kwargs.map { |key, (agg, _)| as_expression(agg == :count ? :sum : agg, key, key) }
+      outer_selects << "#{self.class.sql_now_in_utc} AS db_now_utc" if include_db_time
+
+      Delayed::Job
+        .from(scope.select(:priority, :queue, *inner_selects).group(:priority, :queue))
+        .group(priority_case_statement, :queue).select(
+          *outer_selects,
+          "#{priority_case_statement} AS priority",
+          'queue AS queue',
+        ).group_by { |j| [j.priority.to_i, j.queue] }
+        .transform_values(&:first)
     end
 
-    def grouped_min(scope, column)
-      Delayed::Job.from(scope.select("priority, queue, MIN(#{column}) AS #{column}"))
-        .group(priority_case_statement, :queue).minimum(column)
+    def as_expression(aggregate_function, aggregate_expression, column_name)
+      "#{aggregate_function.to_s.upcase}(#{aggregate_expression}) AS #{column_name}"
     end
 
     def count_grouped
-      if Job.connection.supports_partial_index?
-        failed_count_grouped.merge(live_count_grouped) { |_, l, f| l + f }
-      else
-        grouped_count(jobs)
-      end
+      failed_count_grouped.merge(live_count_grouped) { |_, l, f| l + f }
     end
 
     def live_count_grouped
-      grouped_count(jobs.live)
+      live_counts.transform_values(&:count)
     end
 
     def future_count_grouped
-      grouped_count(jobs.future)
+      live_counts.transform_values(&:future_count)
     end
 
-    def locked_count_grouped
-      @memo[:locked_count_grouped] ||= grouped_count(jobs.claimed)
+    def erroring_count_grouped
+      live_counts.transform_values(&:erroring_count)
     end
 
-    def erroring_count_grouped
-      grouped_count(jobs.erroring)
+    def locked_count_grouped
+      pending_counts.transform_values(&:claimed_count)
     end
 
     def failed_count_grouped
-      @memo[:failed_count_grouped] ||= grouped_count(jobs.failed)
+      failed_counts.transform_values(&:count)
     end
 
     def max_lock_age_grouped
-      oldest_locked_job_grouped.transform_values { |locked_at| Job.db_time_now - locked_at }
+      pending_counts.transform_values { |j| time_ago(db_now(j), j.locked_at) }
     end
 
     def max_age_grouped
-      oldest_workable_job_grouped.transform_values { |run_at| Job.db_time_now - run_at }
+      live_counts.transform_values { |j| time_ago(db_now(j), j.run_at) }
     end
 
     def alert_age_percent_grouped
-      oldest_workable_job_grouped.each_with_object({}) do |((priority, queue), run_at), metrics|
-        max_age = Job.db_time_now - run_at
+      live_counts.each_with_object({}) do |((priority, queue), j), metrics|
+        max_age = time_ago(db_now(j), j.run_at)
         alert_age = Priority.new(priority).alert_age
         metrics[[priority, queue]] = [max_age / alert_age * 100, 100].min if alert_age
       end
     end
 
     def workable_count_grouped
-      grouped_count(jobs.claimable)
+      pending_counts.transform_values(&:claimable_count)
     end
 
     alias working_count_grouped locked_count_grouped
 
     def oldest_locked_job_grouped
-      grouped_min(jobs.claimed, :locked_at)
+      pending_counts.transform_values(&:locked_at).compact
     end
 
     def oldest_workable_job_grouped
-      @memo[:oldest_workable_job_grouped] ||= grouped_min(jobs.claimable, :run_at)
+      live_counts.transform_values(&:run_at).compact
+    end
+
+    def live_counts
+      @memo[:live_counts] ||= grouped_query(
+        jobs.live,
+        include_db_time: true,
+        count: [:count, '*'],
+        future_count: [:sum, case_when(Job.future_clause.to_sql)],
+        erroring_count: [:sum, case_when(Job.erroring_clause.to_sql)],
+        run_at: [:min, case_when(Job.pending_clause.to_sql, 'run_at')],
+      )
+    end
+
+    def pending_counts
+      @memo[:pending_counts] ||= grouped_query(
+        jobs.pending,
+        include_db_time: true,
+        claimed_count: [:sum, case_when(Job.claimed_clause.to_sql)],
+        claimable_count: [:sum, case_when(Job.claimable_clause.to_sql)],
+        locked_at: [:min, case_when(Job.claimed_clause.to_sql, 'locked_at')],
+      )
+    end
+
+    def failed_counts
+      @memo[:failed_counts] ||= grouped_query(jobs.failed, count: [:count, '*'])
+    end
+
+    def db_now(record)
+      self.class.parse_utc_time(record.db_now_utc)
+    end
+
+    def time_ago(now, value)
+      [now - (value || now), 0].max
+    end
+
+    def case_when(condition, true_val = 1)
+      "CASE WHEN #{condition} THEN #{true_val} ELSE #{true_val == 1 ? 0 : 'NULL'} END"
     end
 
     def priority_case_statement
       [
         'CASE',
         Priority.ranges.values.map do |range|
-          [
-            "WHEN priority >= #{range.first.to_i}",
-            ("AND priority < #{range.last.to_i}" unless range.last.infinite?),
-            "THEN #{range.first.to_i}",
-          ].compact
+          if range.last.infinite?
+            "WHEN priority >= #{range.first.to_i} THEN #{range.first.to_i}"
+          else
+            "WHEN priority < #{range.last.to_i} THEN #{range.first.to_i}"
+          end
         end,
         'END',
       ].flatten.join(' ')

data/lib/delayed/tasks.rb

@@ -10,17 +10,37 @@ namespace :delayed do
 
     next unless defined?(Rails.application.config)
 
-    # By default, Rails < 6.1 overrides eager_load to 'false' inside of rake tasks, which is not ideal in production environments.
-    # Additionally, the classic Rails autoloader is not threadsafe, so we do not want any autoloading after we start the worker.
-    # While the zeitwork autoloader technically does not need this workaround, we will still eager load for consistency's sake.
-    # We will use the cache_classes config as a proxy for determining if we should eager load before booting workers.
-    if !Rails.application.config.respond_to?(:rake_eager_load) && Rails.application.config.cache_classes
-      Rails.application.config.eager_load = true
-      Rails::Application::Finisher.initializers
-        .find { |i| i.name == :eager_load! }
-        .bind(Rails.application)
-        .run
-    end
+    # By default, Rails wants to disable eager loading inside of `rake`
+    # commands, even if `eager_load` is set to true. This is done to speed up
+    # the boot time of rake tasks that don't need the entire application loaded.
+    #
+    # The problem is that long-lived processes like `delayed` **do** want to
+    # eager load the application before spawning any threads or forks.
+    # (Especially if in a production environment where we want full load-order
+    # parity with the `rails server` processes!)
+    #
+    # When a Rails app boots, it chooses whether to eager load based on its
+    # `eager_load` config and whether or not it was initiated by a `rake`
+    # command. If it did eager load, we don't want to eager load again, but if
+    # it was initiated by a `rake` command, it sets `eager_load` to false before
+    # the point at which `delayed` starts setting up _its_ rake environment.
+    #
+    # So we cannot rely on that config to know whether or not to eager load --
+    # instead we must make an inference:
+    # - Newer rails versions (~7.0+) have a `config.rake_eager_load` option,
+    # which tells us whether the app has already eager loaded in a `rake`
+    # context.
+    # - If `rake_eager_loading` is not defined or `false`, we will then check
+    # `cache_classes` & explicitly eager load if true.
+
+    eager_loaded = Rails.application.config.respond_to?(:rake_eager_load) && Rails.application.config.rake_eager_load
+    next if eager_loaded || !Rails.application.config.cache_classes
+
+    Rails.application.config.eager_load = true
+    Rails::Application::Finisher.initializers
+      .find { |i| i.name == :eager_load! }
+      .bind(Rails.application)
+      .run
   end
 
   desc 'start a delayed worker'

data/lib/delayed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayed
-  VERSION = '2.0.3'
+  VERSION = '2.2.0'
 end

data/lib/delayed/worker.rb

@@ -22,6 +22,8 @@ module Delayed
     cattr_accessor :read_ahead, instance_writer: false, default: 5
     cattr_accessor :destroy_failed_jobs, instance_writer: false, default: false
 
+    cattr_accessor :deny_stale_enqueues, instance_writer: false, default: false
+
     cattr_accessor :min_priority, :max_priority, instance_writer: false
 
     # TODO: Remove this and rely on ActiveJob.queue_name when no queue is specified