delayed 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 984a910472fc4f1dedafcf4060cf076bcda408196bfa80f08039ed2527533a41
-  data.tar.gz: 98f7de42e2964ee1576ba6ae3fc2b39cbe76a841263054a5b9634f7e55ce1114
+  metadata.gz: 6d365ce7fa45762c6122da4a21a7c96e30893c15534f76bb26cbb4e3f721f7c6
+  data.tar.gz: ca6deb755821f865e354a4ff62375d7c918c81e0b9b4be5f665aa9a347ee90e9
 SHA512:
-  metadata.gz: dcb018c429ff591409796e410c570f49408eb0b8363759f6c8970ac4ee1773abccc117b5398c3596ecf8491c0e70db548bd4a2ea54ef39a77fa78da43b6cbfe4
-  data.tar.gz: 020a785c7bfc81456b8cc7b8ddace55fad1f9468edb3b9cef0ef066eb6aed64b580d30974b48ce97bc7b1602294c9901c7c26fa294d3e4b4ecebd177aef677c8
+  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

@@ -38,7 +38,7 @@ module Delayed
     def self.sql_now_in_utc
       case ActiveRecord::Base.connection.adapter_name
       when 'PostgreSQL'
-        "TIMEZONE('UTC', NOW())"
+        "TIMEZONE('UTC', STATEMENT_TIMESTAMP())"
       when 'MySQL', 'Mysql2'
         "UTC_TIMESTAMP()"
       else
@@ -95,103 +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)
-        .select(<<~SQL.squish)
-          (#{priority_case_statement}) AS priority,
-          queue,
-          MIN(#{column}) AS #{column},
-          #{self.class.sql_now_in_utc} AS db_now_utc
-        SQL
-        .group_by { |j| [j.priority.to_i, j.queue] }
-        .transform_values(&:first)
+    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_at_query.transform_values { |j| db_now(j) - j.locked_at }
+      pending_counts.transform_values { |j| time_ago(db_now(j), j.locked_at) }
     end
 
     def max_age_grouped
-      oldest_run_at_query.transform_values { |j| db_now(j) - j.run_at }
+      live_counts.transform_values { |j| time_ago(db_now(j), j.run_at) }
     end
 
     def alert_age_percent_grouped
-      oldest_run_at_query.each_with_object({}) do |((priority, queue), j), metrics|
-        max_age = db_now(j) - j.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
-      oldest_locked_at_query.transform_values(&:locked_at)
+      pending_counts.transform_values(&:locked_at).compact
     end
 
     def oldest_workable_job_grouped
-      oldest_run_at_query.transform_values(&: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 oldest_locked_at_query
-      @memo[:oldest_locked_at_query] ||= grouped_min(jobs.claimed, :locked_at)
+    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 oldest_run_at_query
-      @memo[:oldest_run_at_query] ||= grouped_min(jobs.claimable, :run_at)
+    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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayed
-  VERSION = '2.1.0'
+  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