delayed 2.1.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 984a910472fc4f1dedafcf4060cf076bcda408196bfa80f08039ed2527533a41
-  data.tar.gz: 98f7de42e2964ee1576ba6ae3fc2b39cbe76a841263054a5b9634f7e55ce1114
+  metadata.gz: 5fac8946441b682c8df0e1365cd446cb7d507e3831f8155d692abe6ef1d52003
+  data.tar.gz: 602f57430c6ac8b7c94bd248f270ffe768d65de07d50bc2e482bfed67fc1ca7c
 SHA512:
-  metadata.gz: dcb018c429ff591409796e410c570f49408eb0b8363759f6c8970ac4ee1773abccc117b5398c3596ecf8491c0e70db548bd4a2ea54ef39a77fa78da43b6cbfe4
-  data.tar.gz: 020a785c7bfc81456b8cc7b8ddace55fad1f9468edb3b9cef0ef066eb6aed64b580d30974b48ce97bc7b1602294c9901c7c26fa294d3e4b4ecebd177aef677c8
+  metadata.gz: 3d5a2383bd876172d81e9d0926d818afe6f989af71e4143c970daf0ea5149f63cad5ccf0029be97e59765b4ceae77dc555578a76fb955ed67f1caaaf92c71352
+  data.tar.gz: 0f33ed115647bbacfdfe27e9db20e075c2b7374d7ee23e57bbe1a983dacfc7d1cbea6e295fb7d672203664f98d151035675e4fccb35eeb2b627dadab921f2a4d

data/README.md

@@ -284,11 +284,11 @@ The following events will be emitted automatically by workers as jobs are reserv
 - **delayed.job.run** - an event measuring the duration of a job's execution
 - **delayed.job.error** - an event indicating that a job has errored and may be retried (no duration attached)
 - **delayed.job.failure** - an event indicating that a job has permanently failed (no duration attached)
-- **delayed.job.enqueue** - an event measuring the time it takes to enqueue a job
+- **delayed.job.enqueue** - an event measuring the time it takes to enqueue one or more jobs (fires once per `Delayed::Job.enqueue` call and once per `perform_all_later` / `enqueue_all` batch)
 - **delayed.worker.reserve_jobs** - an event measuring the duration of the job "pickup query"
 
-The "run", "error", "failure" and "enqueue" events will include a `:job` argument in the event's payload,
-providing access to the job instance.
+The "run", "error", and "failure" events will include a `:job` argument in the event's payload,
+providing access to the job instance. The "enqueue" event will include a `:jobs` array.
 
 ```ruby
 ActiveSupport::Notifications.subscribe('delayed.job.run') do |*args|

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,7 +36,25 @@ module Delayed
         .by_priority
     }
 
-    before_save :set_default_run_at, :set_name
+    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
 
     REENQUEUE_BUFFER = 30.seconds
 
@@ -265,12 +279,5 @@ module Delayed
     def attempts_alert?
       alert_attempts&.<= attempts
     end
-
-    private
-
-    def set_name
-      # [feat:NameColumn] remove 'if' statement and use `||=` once the 'name' column is required.
-      self.name = display_name if respond_to?(:name=) && attributes.fetch('name').nil?
-    end
   end
 end

data/db/migrate/08_add_run_at_and_name_not_null_check.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class AddRunAtAndNameNotNullCheck < ActiveRecord::Migration[6.0]
+  CONSTRAINTS = {
+    run_at: 'chk_delayed_jobs_run_at_not_null',
+    name: 'chk_delayed_jobs_name_not_null',
+  }.freeze
+
+  def up
+    return unless postgres?
+
+    CONSTRAINTS.each do |column, name|
+      execute <<~SQL.squish
+        ALTER TABLE delayed_jobs
+          ADD CONSTRAINT #{name}
+          CHECK (#{column} IS NOT NULL) NOT VALID
+      SQL
+    end
+  end
+
+  def down
+    return unless postgres?
+
+    CONSTRAINTS.each_value do |name|
+      execute "ALTER TABLE delayed_jobs DROP CONSTRAINT IF EXISTS #{name}"
+    end
+  end
+
+  private
+
+  def postgres?
+    connection.adapter_name == 'PostgreSQL'
+  end
+end

data/db/migrate/09_validate_run_at_and_name_not_null.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class ValidateRunAtAndNameNotNull < ActiveRecord::Migration[6.0]
+  CONSTRAINTS = {
+    run_at: 'chk_delayed_jobs_run_at_not_null',
+    name: 'chk_delayed_jobs_name_not_null',
+  }.freeze
+
+  def up
+    CONSTRAINTS.each do |column, name|
+      if postgres?
+        execute "ALTER TABLE delayed_jobs VALIDATE CONSTRAINT #{name}"
+        change_column_null :delayed_jobs, column, false
+        execute "ALTER TABLE delayed_jobs DROP CONSTRAINT #{name}"
+      else
+        change_column_null :delayed_jobs, column, false
+      end
+    end
+  end
+
+  def down
+    CONSTRAINTS.each do |column, name|
+      if postgres?
+        change_column_null :delayed_jobs, column, true
+        execute <<~SQL.squish
+          ALTER TABLE delayed_jobs
+            ADD CONSTRAINT #{name}
+            CHECK (#{column} IS NOT NULL) NOT VALID
+        SQL
+      else
+        change_column_null :delayed_jobs, column, true
+      end
+    end
+  end
+
+  private
+
+  def postgres?
+    connection.adapter_name == 'PostgreSQL'
+  end
+end

data/lib/delayed/active_job_adapter.rb

@@ -11,24 +11,57 @@ module Delayed
     end
 
     def enqueue_at(job, timestamp)
-      _enqueue(job, run_at: Time.at(timestamp)) # rubocop:disable Rails/TimeZone
+      job.scheduled_at = Time.at(timestamp) # rubocop:disable Rails/TimeZone
+      _enqueue(job)
+    end
+
+    def enqueue_all(jobs)
+      return 0 if jobs.empty?
+
+      assert_jobs_safe_to_enqueue!(jobs)
+
+      delayed_jobs = jobs.map { |job| build_delayed_job(job) }
+      Delayed::Job.enqueue_all(delayed_jobs)
+
+      perform_post_enqueue_assignments(jobs, delayed_jobs)
+
+      jobs.size
     end
 
     private
 
-    def _enqueue(job, opts = {})
-      if enqueue_after_transaction_commit_enabled?(job)
-        raise UnsafeEnqueueError, "The ':delayed' ActiveJob adapter is not compatible with enqueue_after_transaction_commit"
+    def _enqueue(job)
+      job.tap { |j| enqueue_all([j]) }
+    end
+
+    def assert_jobs_safe_to_enqueue!(jobs)
+      jobs.each do |job|
+        if enqueue_after_transaction_commit_enabled?(job)
+          raise UnsafeEnqueueError, "The ':delayed' ActiveJob adapter is not compatible with enqueue_after_transaction_commit"
+        end
       end
+    end
 
-      opts.merge!({ queue: job.queue_name, priority: job.priority }.compact)
-        .merge!(job.provider_attributes || {})
+    def build_delayed_job(job)
+      opts = { queue: job.queue_name, priority: job.priority }.compact
+      opts.merge!(job.provider_attributes || {})
+      opts[:run_at] = coerce_scheduled_at(job.scheduled_at) if job.scheduled_at
 
-      Delayed::Job.enqueue(JobWrapper.new(job), opts).tap do |dj|
-        job.provider_job_id = dj.id
+      prepared = Delayed::Backend::JobPreparer.new(JobWrapper.new(job), opts).prepare
+      Delayed::Job.new(prepared)
+    end
+
+    def perform_post_enqueue_assignments(active_jobs, delayed_jobs)
+      active_jobs.zip(delayed_jobs) do |active_job, delayed_job|
+        active_job.successfully_enqueued = true if active_job.respond_to?(:successfully_enqueued=)
+        active_job.provider_job_id = delayed_job.id
       end
     end
 
+    def coerce_scheduled_at(value)
+      value.is_a?(Numeric) ? Time.at(value) : value # rubocop:disable Rails/TimeZone
+    end
+
     def enqueue_after_transaction_commit_enabled?(job)
       job.class.respond_to?(:enqueue_after_transaction_commit) &&
         [true, :always].include?(job.class.enqueue_after_transaction_commit)

data/lib/delayed/backend/base.rb

@@ -14,11 +14,37 @@ module Delayed
 
         def enqueue_job(options)
           new(options).tap do |job|
-            Delayed.lifecycle.run_callbacks(:enqueue, job) do
-              job.hook(:enqueue)
-              Delayed::Worker.delay_job?(job) ? job.save : job.invoke_job
+            assert_payload_not_active_job!(job.payload_object)
+            assert_no_enqueue_hook!(job.payload_object)
+            assert_delay_jobs_not_proc!
+
+            Delayed.lifecycle.run_callbacks(:enqueue, [job]) do
+              Delayed::Worker.delay_jobs ? job.save : job.invoke_job
+            end
+          end
+        end
+
+        # Bulk-enqueue an array of pre-built Delayed::Job instances. Callers are
+        # responsible for running JobPreparer and instantiating each job via
+        # `Delayed::Job.new(...)` before calling this method.
+        def enqueue_all(jobs)
+          return 0 if jobs.empty?
+
+          jobs.each do |job|
+            assert_payload_not_active_job!(job.payload_object)
+            assert_no_enqueue_hook!(job.payload_object)
+          end
+          assert_delay_jobs_not_proc!
+
+          Delayed.lifecycle.run_callbacks(:enqueue, jobs) do
+            if Delayed::Worker.delay_jobs
+              bulk_insert_all(jobs)
+            else
+              jobs.each(&:invoke_job)
             end
           end
+
+          jobs.size
         end
 
         def reserve(worker, max_run_time = Worker.max_run_time)
@@ -41,6 +67,38 @@ module Delayed
           warn '[DEPRECATION] `Delayed::Job.work_off` is deprecated. Use `Delayed::Worker.new.work_off instead.'
           Delayed::Worker.new.work_off(num)
         end
+
+        def name_assignable?
+          column_names.include?('name')
+        end
+
+        private
+
+        def bulk_insert_all(jobs)
+          now = db_time_now
+          jobs.each { |job| job.created_at = job.updated_at = now }
+          rows = jobs.map { |job| job.attributes.compact }
+          result = insert_all(rows) # rubocop:disable Rails/SkipsModelValidations
+          return unless connection.supports_insert_returning?
+
+          ids = result.rows.map(&:first)
+          jobs.zip(ids) { |job, id| job.id = id }
+        end
+
+        def assert_payload_not_active_job!(payload)
+          raise "Delayed::Job enqueue methods do not accept ActiveJobs, use perform_later instead" if payload.is_a?(ActiveJob::Base)
+        end
+
+        def assert_no_enqueue_hook!(payload)
+          return if payload.is_a?(Delayed::JobWrapper)
+          return unless payload.respond_to?(:enqueue)
+
+          raise ":enqueue hook on #{payload.class} is no longer supported"
+        end
+
+        def assert_delay_jobs_not_proc!
+          raise 'Delayed::Worker.delay_jobs may not be a Proc' if Delayed::Worker.delay_jobs.is_a?(Proc)
+        end
       end
 
       attr_reader :error
@@ -58,7 +116,7 @@ module Delayed
       ParseObjectFromYaml = %r{!ruby/\w+:([^\s]+)} # rubocop:disable Naming/ConstantName
 
       def name
-        if self.class.column_names.include?('name')
+        if self.class.name_assignable?
           super || display_name
         else
           display_name # [feat:NameColumn] remove fallback once the "name" column is required.
@@ -105,9 +163,11 @@ module Delayed
 
       def hook(name, *args)
         if payload_object.respond_to?(name)
-          if payload_object.is_a?(Delayed::JobWrapper)
-            return if name == :enqueue # this callback is not supported due to method naming conflicts.
+          if name == :enqueue
+            raise ':enqueue hook is no longer supported'
+          end
 
+          if payload_object.is_a?(Delayed::JobWrapper)
             warn '[DEPRECATION] Job hook methods (`before`, `after`, `success`, etc) are deprecated. Use ActiveJob callbacks instead.'
           end
 
@@ -158,17 +218,13 @@ module Delayed
         @display_name ||= payload_object.display_name if payload_object.respond_to?(:display_name)
         @display_name ||= payload_object.class.name
       rescue DeserializationError # [feat:NameColumn] remove this `rescue` once the "name" column is required.
-        raise if !persisted? && self.class.column_names.include?('name')
+        raise if !persisted? && self.class.name_assignable?
 
         ParseObjectFromYaml.match(handler)[1]
       end
 
       protected
 
-      def set_default_run_at
-        self.run_at ||= self.class.db_time_now
-      end
-
       # Call during reload operation to clear out internal state
       def reset
         @payload_object = nil

data/lib/delayed/backend/job_preparer.rb

@@ -12,7 +12,10 @@ module Delayed
         set_payload
         set_queue_name
         set_priority
+        set_run_at
+        set_name
         handle_dst
+        reject_stale_run_at
         handle_deprecation
         options
       end
@@ -33,6 +36,24 @@ module Delayed
         options[:priority] ||= Delayed::Worker.default_priority
       end
 
+      def set_run_at
+        options[:run_at] ||= Job.db_time_now
+      end
+
+      def set_name
+        return if options[:name] || !Job.name_assignable?
+
+        payload = options[:payload_object]
+        options[:name] =
+          if payload.respond_to?(:job_data)
+            payload.job_data['job_class']
+          elsif payload.respond_to?(:display_name)
+            payload.display_name
+          else
+            payload.class.name
+          end
+      end
+
       def scheduled_into_fall_back_hour?
         options[:run_at] &&
           !options[:run_at].in_time_zone.dst? &&
@@ -51,6 +72,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/lifecycle.rb

@@ -4,7 +4,7 @@ module Delayed
   class Lifecycle
     EVENTS = {
       execute: [nil],
-      enqueue: [:job],
+      enqueue: [:jobs],
       perform: %i(worker job),
       error: %i(worker job),
       failure: %i(worker job),

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/plugins/instrumentation.rb

@@ -2,9 +2,9 @@ module Delayed
   module Plugins
     class Instrumentation < Plugin
       callbacks do |lifecycle|
-        lifecycle.around(:enqueue) do |job, *args, &block|
-          ActiveSupport::Notifications.instrument('delayed.job.enqueue', active_support_notifications_tags(job)) do
-            block.call(job, *args)
+        lifecycle.around(:enqueue) do |jobs, &block|
+          ActiveSupport::Notifications.instrument('delayed.job.enqueue', bulk_enqueue_tags(jobs)) do
+            block.call(jobs)
           end
         end
 
@@ -34,6 +34,12 @@ module Delayed
           job: job,
         }
       end
+
+      def self.bulk_enqueue_tags(jobs)
+        {
+          jobs: jobs.map { |job| active_support_notifications_tags(job) },
+        }
+      end
     end
   end
 end

data/lib/delayed/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delayed
-  VERSION = '2.1.0'
+  VERSION = '3.0.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
@@ -35,14 +37,6 @@ module Delayed
                :default_log_level, :default_log_level=, to: Delayed
     end
 
-    def self.delay_job?(job)
-      if delay_jobs.is_a?(Proc)
-        delay_jobs.arity == 1 ? delay_jobs.call(job) : delay_jobs.call
-      else
-        delay_jobs
-      end
-    end
-
     def initialize
       @failed_reserve_count = 0