delayed 2.2.0 → 3.0.0

data/spec/delayed/job_spec.rb

@@ -20,12 +20,12 @@ describe Delayed::Job do
   end
 
   it 'sets run_at automatically if not set' do
-    expect(described_class.create(payload_object: ErrorJob.new).run_at).not_to be_nil
+    expect(described_class.enqueue(payload_object: ErrorJob.new).run_at).not_to be_nil
   end
 
   it 'does not set run_at automatically if already set' do
     later = described_class.db_time_now + 5.minutes
-    job = described_class.create(payload_object: ErrorJob.new, run_at: later)
+    job = described_class.enqueue(payload_object: ErrorJob.new, run_at: later)
     expect(job.run_at).to be_within(1).of(later)
   end
 
@@ -37,12 +37,6 @@ describe Delayed::Job do
   end
 
   describe 'enqueue' do
-    it "allows enqueue hook to modify job at DB level" do
-      later = described_class.db_time_now + 20.minutes
-      job = described_class.enqueue payload_object: EnqueueJobMod.new
-      expect(described_class.find(job.id).run_at).to be_within(1).of(later)
-    end
-
     context 'with a hash' do
       it "raises ArgumentError when handler doesn't respond_to :perform" do
         expect { described_class.enqueue(payload_object: Object.new) }.to raise_error(ArgumentError)
@@ -170,6 +164,151 @@ describe Delayed::Job do
         expect(job).to be_persisted
       end
     end
+
+    context 'when payload defines an :enqueue hook' do
+      before do
+        stub_const('JobWithEnqueueHook', Class.new do
+          def enqueue(_job); end
+
+          def perform; end
+        end)
+      end
+
+      it 'raises an error naming the payload class' do
+        expect { described_class.enqueue(JobWithEnqueueHook.new) }
+          .to raise_error(RuntimeError, ':enqueue hook on JobWithEnqueueHook is no longer supported')
+      end
+
+      it 'does not invoke the payload enqueue method' do
+        payload = JobWithEnqueueHook.new
+        expect(payload).not_to receive(:enqueue)
+        expect { described_class.enqueue(payload) }.to raise_error(RuntimeError, /:enqueue hook/)
+      end
+    end
+
+    context 'when payload does not define :enqueue' do
+      it 'does not raise' do
+        expect { described_class.enqueue(SimpleJob.new) }.not_to raise_error
+      end
+    end
+
+    context 'when payload is an ActiveJob wrapper that responds to :enqueue' do
+      it 'does not raise' do
+        wrapper = ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(ActiveJobJob.new.serialize)
+        expect { described_class.enqueue(payload_object: wrapper) }.not_to raise_error
+      end
+    end
+
+    context 'when payload is a bare ActiveJob::Base instance' do
+      it 'raises' do
+        expect { described_class.enqueue(payload_object: ActiveJobJob.new) }.to raise_error(RuntimeError, /Delayed::Job enqueue methods do not accept ActiveJobs/)
+      end
+    end
+
+    context 'when passed a bare ActiveJob::Base instance' do
+      it 'raises' do
+        expect { described_class.enqueue(ActiveJobJob.new) }.to raise_error(RuntimeError, /Delayed::Job enqueue methods do not accept ActiveJobs/)
+      end
+    end
+  end
+
+  describe '.enqueue_all' do
+    def build_job(payload = SimpleJob.new, opts = {})
+      described_class.new(Delayed::Backend::JobPreparer.new(payload, opts).prepare)
+    end
+
+    it 'returns 0 when given no jobs' do
+      expect(described_class.enqueue_all([])).to eq(0)
+    end
+
+    it 'inserts all jobs in a single INSERT' do
+      jobs = Array.new(3) { build_job }
+      expect { described_class.enqueue_all(jobs) }
+        .to emit_notification('sql.active_record').with_payload(hash_including(sql: a_string_matching(/\AINSERT INTO/i)))
+      expect(described_class.count).to eq(3)
+    end
+
+    it 'returns the count of enqueued jobs' do
+      jobs = Array.new(3) { build_job }
+      expect(described_class.enqueue_all(jobs)).to eq(3)
+    end
+
+    it 'sets id on each job from INSERT RETURNING when supported' do
+      skip 'requires INSERT ... RETURNING support' unless described_class.connection.supports_insert_returning?
+
+      jobs = Array.new(2) { build_job }
+      described_class.enqueue_all(jobs)
+      expect(jobs.map(&:id)).to match_array(described_class.pluck(:id))
+    end
+
+    it 'fires :enqueue lifecycle once with the jobs array' do
+      observed = []
+      lifecycle_was = Delayed.lifecycle
+      Delayed.instance_variable_set(:@lifecycle, Delayed::Lifecycle.new)
+      Delayed.lifecycle.before(:enqueue) { |jobs| observed << jobs }
+
+      jobs = [build_job]
+      described_class.enqueue_all(jobs)
+
+      expect(observed.size).to eq(1)
+      expect(observed.first).to eq(jobs)
+    ensure
+      Delayed.instance_variable_set(:@lifecycle, lifecycle_was)
+    end
+
+    context 'when delay_jobs is false' do
+      before { Delayed::Worker.delay_jobs = false }
+
+      it 'inline-invokes each job and inserts nothing' do
+        payload = SimpleJob.new
+        expect(payload).to receive(:perform)
+        described_class.enqueue_all([build_job(payload)])
+        expect(described_class.count).to eq(0)
+      end
+    end
+
+    context 'when a job payload defines an :enqueue hook' do
+      before do
+        stub_const('JobWithEnqueueHook', Class.new do
+          def enqueue(_job); end
+
+          def perform; end
+        end)
+      end
+
+      it 'raises before inserting anything' do
+        jobs = [build_job(JobWithEnqueueHook.new)]
+        expect { described_class.enqueue_all(jobs) }
+          .to raise_error(RuntimeError, ':enqueue hook on JobWithEnqueueHook is no longer supported')
+        expect(described_class.count).to eq(0)
+      end
+    end
+
+    context 'when a job payload is a bare ActiveJob::Base instance' do
+      it 'raises' do
+        jobs = [build_job(ActiveJobJob.new)]
+        expect { described_class.enqueue_all(jobs) }.to raise_error(RuntimeError, /Delayed::Job enqueue methods do not accept ActiveJobs/)
+      end
+    end
+  end
+
+  describe '#hook' do
+    context 'with :enqueue' do
+      before do
+        stub_const('JobWithEnqueueHook', Class.new do
+          def enqueue(_job); end
+
+          def perform; end
+        end)
+      end
+
+      it 'raises rather than invoking the payload hook' do
+        job = described_class.new(payload_object: JobWithEnqueueHook.new)
+        expect(job.payload_object).not_to receive(:enqueue)
+        expect { job.hook(:enqueue) }
+          .to raise_error(RuntimeError, ':enqueue hook is no longer supported')
+      end
+    end
   end
 
   describe 'callbacks' do
@@ -187,9 +326,9 @@ describe Delayed::Job do
 
     it 'calls before and after callbacks' do
       job = described_class.enqueue(CallbackJob.new)
-      expect(CallbackJob.messages).to eq(['enqueue'])
+      expect(CallbackJob.messages).to eq([])
       job.invoke_job
-      expect(CallbackJob.messages).to eq(%w(enqueue before perform success after))
+      expect(CallbackJob.messages).to eq(%w(before perform success after))
     end
 
     it 'calls the after callback with an error' do
@@ -197,14 +336,14 @@ describe Delayed::Job do
       expect(job.payload_object).to receive(:perform).and_raise(RuntimeError.new('fail'))
 
       expect { job.invoke_job }.to raise_error(RuntimeError, 'fail')
-      expect(CallbackJob.messages).to eq(['enqueue', 'before', 'error: RuntimeError', 'after'])
+      expect(CallbackJob.messages).to eq(['before', 'error: RuntimeError', 'after'])
     end
 
     it 'calls error when before raises an error' do
       job = described_class.enqueue(CallbackJob.new)
       expect(job.payload_object).to receive(:before).and_raise(RuntimeError.new('fail'))
       expect { job.invoke_job }.to raise_error(RuntimeError, 'fail')
-      expect(CallbackJob.messages).to eq(['enqueue', 'error: RuntimeError', 'after'])
+      expect(CallbackJob.messages).to eq(['error: RuntimeError', 'after'])
     end
   end
 
@@ -462,26 +601,23 @@ describe Delayed::Job do
   describe '#name' do
     context 'when name column is populated' do
       it 'is the class name of the job that was enqueued' do
-        job = described_class.new(payload_object: ErrorJob.new)
+        job = described_class.enqueue(payload_object: ErrorJob.new)
         expect(job.name).to eq('ErrorJob')
-        job.save!
         expect(job.reload.name).to eq('ErrorJob')
         expect(described_class.group(:name).count).to eq('ErrorJob' => 1)
       end
 
       it 'is the class name of the performable job if it is an ActiveJob' do
         job_wrapper = ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(ActiveJobJob.new.serialize)
-        job = described_class.new(payload_object: job_wrapper)
+        job = described_class.enqueue(payload_object: job_wrapper)
         expect(job.name).to eq('ActiveJobJob')
-        job.save!
         expect(job.reload.name).to eq('ActiveJobJob')
         expect(described_class.group(:name).count).to eq('ActiveJobJob' => 1)
       end
 
       it 'is the returned display_name if display_name is defined on the job object' do
-        job = described_class.new(payload_object: NamedJob.new)
+        job = described_class.enqueue(payload_object: NamedJob.new)
         expect(job.name).to eq('named_job')
-        job.save!
         expect(job.reload.name).to eq('named_job')
         expect(described_class.group(:name).count).to eq('named_job' => 1)
       end
@@ -493,25 +629,38 @@ describe Delayed::Job do
       end
 
       it 'is the custom name value when set explicitly' do
-        job = described_class.new(payload_object: ErrorJob.new)
-        job.name = 'Custom Name'
-        job.save!
+        job = described_class.enqueue(payload_object: ErrorJob.new, name: 'Custom Name')
         expect(job.reload.name).to eq('Custom Name')
         expect(described_class.group(:name).count).to eq('Custom Name' => 1)
       end
     end
 
     context 'when name column is NULL' do
+      before do
+        ActiveRecord::Schema.define do
+          ValidateRunAtAndNameNotNull.migrate(:down)
+          AddRunAtAndNameNotNullCheck.migrate(:down)
+        end
+        described_class.reset_column_information
+      end
+
+      after do
+        described_class.delete_all
+        ActiveRecord::Schema.define do
+          AddRunAtAndNameNotNullCheck.migrate(:up)
+          ValidateRunAtAndNameNotNull.migrate(:up)
+        end
+        described_class.reset_column_information
+      end
+
       it 'is the class name of the job that was enqueued' do
-        job = described_class.create(payload_object: ErrorJob.new)
-        job.update_column(:name, nil) # rubocop:disable Rails/SkipsModelValidations
+        job = described_class.enqueue(payload_object: ErrorJob.new)
         expect(job.reload.name).to eq('ErrorJob')
       end
 
       it 'is the class name of the performable job if it is an ActiveJob' do
         job_wrapper = ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(ActiveJobJob.new.serialize)
-        job = described_class.create(payload_object: job_wrapper)
-        job.update_column(:name, nil) # rubocop:disable Rails/SkipsModelValidations
+        job = described_class.enqueue(payload_object: job_wrapper)
         expect(job.reload.name).to eq('ActiveJobJob')
       end
 
@@ -542,7 +691,7 @@ describe Delayed::Job do
       end
 
       it 'is the class name of the job that was enqueued' do
-        job = described_class.new(payload_object: ErrorJob.new)
+        job = described_class.new(payload_object: ErrorJob.new, run_at: Time.current)
         expect(job.name).to eq('ErrorJob')
         job.save!
         expect(job.reload.name).to eq('ErrorJob')
@@ -550,14 +699,14 @@ describe Delayed::Job do
 
       it 'is the class name of the performable job if it is an ActiveJob' do
         job_wrapper = ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper.new(ActiveJobJob.new.serialize)
-        job = described_class.new(payload_object: job_wrapper)
+        job = described_class.new(payload_object: job_wrapper, run_at: Time.current)
         expect(job.name).to eq('ActiveJobJob')
         job.save!
         expect(job.reload.name).to eq('ActiveJobJob')
       end
 
       it 'is the returned display_name if display_name is defined on the job object' do
-        job = described_class.new(payload_object: NamedJob.new)
+        job = described_class.new(payload_object: NamedJob.new, run_at: Time.current)
         expect(job.name).to eq('named_job')
         job.save!
         expect(job.reload.name).to eq('named_job')
@@ -835,7 +984,7 @@ describe Delayed::Job do
     describe 'running a job' do
       it 'fails after Worker.max_run_time' do
         Delayed::Worker.max_run_time = 1.second
-        job = described_class.create payload_object: LongRunningJob.new
+        job = described_class.enqueue payload_object: LongRunningJob.new
         worker.perform(job)
         expect(job.error).not_to be_nil
         expect(job.reload.last_error).to match(/expired/)
@@ -845,7 +994,7 @@ describe Delayed::Job do
 
       context 'when the job raises a deserialization error' do
         it 'marks the job as failed' do
-          job = described_class.create! payload_object: LongRunningJob.new
+          job = described_class.enqueue payload_object: LongRunningJob.new
           job.update_columns(handler: '--- !ruby/object:JobThatDoesNotExist {}') # rubocop:disable Rails/SkipsModelValidations
           expect_any_instance_of(described_class).to receive(:destroy_failed_jobs?).and_return(false)
           worker.work_off
@@ -900,13 +1049,13 @@ describe Delayed::Job do
 
     context 'reschedule' do
       before do
-        @job = described_class.create payload_object: SimpleJob.new
+        @job = described_class.enqueue payload_object: SimpleJob.new
       end
 
       shared_examples_for 'any failure more than Worker.max_attempts times' do
         context "when the job's payload has a #failure hook" do
           before do
-            @job = described_class.create payload_object: OnPermanentFailureJob.new
+            @job = described_class.enqueue payload_object: OnPermanentFailureJob.new
             expect(@job.payload_object).to respond_to(:failure)
           end
 

data/spec/delayed/monitor_spec.rb

@@ -123,6 +123,7 @@ RSpec.describe Delayed::Monitor do
           run_at: now,
           queue: 'default',
           handler: "--- !ruby/object:SimpleJob\n",
+          name: 'SimpleJob',
           attempts: 0,
         }
       end

data/spec/delayed/plugins/instrumentation_spec.rb

@@ -3,6 +3,47 @@ require 'helper'
 RSpec.describe Delayed::Plugins::Instrumentation do
   let!(:job) { Delayed::Job.enqueue SimpleJob.new, priority: 13, queue: 'test' }
 
+  it 'emits delayed.job.enqueue when a job is enqueued' do
+    expect { Delayed::Job.enqueue SimpleJob.new }.to emit_notification('delayed.job.enqueue').with_payload(
+      jobs: [
+        hash_including(
+          job_name: 'SimpleJob',
+          table: 'delayed_jobs',
+          database: current_database,
+          database_adapter: current_adapter,
+          job: an_instance_of(Delayed::Job),
+        ),
+      ],
+    )
+  end
+
+  it 'emits a single delayed.job.enqueue when a batch is enqueued via the ActiveJob adapter' do
+    job_class = Class.new(ActiveJob::Base) do
+      def perform; end
+    end
+    stub_const('BatchedJob', job_class)
+
+    adapter_was = ActiveJob::Base.queue_adapter
+    ActiveJob::Base.queue_adapter = :delayed
+    begin
+      jobs = Array.new(3) { BatchedJob.new }
+      expect { ActiveJob::Base.queue_adapter.enqueue_all(jobs) }
+        .to emit_notification('delayed.job.enqueue').with_payload(
+          jobs: Array.new(3) {
+            hash_including(
+              job_name: 'BatchedJob',
+              table: 'delayed_jobs',
+              database: current_database,
+              database_adapter: current_adapter,
+              job: an_instance_of(Delayed::Job),
+            )
+          },
+        )
+    ensure
+      ActiveJob::Base.queue_adapter = adapter_was
+    end
+  end
+
   it 'emits delayed.job.run' do
     expect { Delayed::Worker.new.work_off }.to emit_notification('delayed.job.run').with_payload(
       job_name: 'SimpleJob',

data/spec/helper.rb

@@ -92,6 +92,8 @@ ActiveRecord::Schema.define do
     run_migration(IndexFailedJobs)
     run_migration(SetPostgresFillfactor)
     run_migration(RemoveLegacyIndex)
+    run_migration(AddRunAtAndNameNotNullCheck)
+    run_migration(ValidateRunAtAndNameNotNull)
 
     # Test that these index migrations can be re-applied idempotently.
     # (In case identical indexes had been manually applied previously.)
@@ -266,6 +268,10 @@ def current_database
   end
 end
 
+def current_database_name
+  current_adapter == 'sqlite3' ? 'tmp/database.sqlite' : 'delayed_job_test'
+end
+
 QueryUnderTest = Struct.new(:sql, :connection) do
   def self.for(query, connection: ActiveRecord::Base.connection)
     new(query.respond_to?(:to_sql) ? query.to_sql : query.to_s, connection)
@@ -305,10 +311,12 @@ QueryUnderTest = Struct.new(:sql, :connection) do
   def postgresql_explain
     connection.execute("SET seq_page_cost = 100")
     connection.execute("SET enable_hashagg = off")
+    connection.execute("SET enable_incremental_sort = off")
     connection.execute("SET plan_cache_mode TO force_generic_plan")
     connection.execute("EXPLAIN (VERBOSE) #{sql}").values.flatten.join("\n")
   ensure
     connection.execute("RESET plan_cache_mode")
+    connection.execute("RESET enable_incremental_sort")
     connection.execute("RESET enable_hashagg")
     connection.execute("RESET seq_page_cost")
   end
@@ -334,6 +342,7 @@ QueryUnderTest = Struct.new(:sql, :connection) do
           run_at: now + (future ? i.minutes : -i.minutes),
           queue: "queue_#{i}",
           handler: "--- !ruby/object:SimpleJob\n",
+          name: 'SimpleJob',
           attempts: erroring ? i : 0,
           failed_at: failed ? now - i.minutes : nil,
           locked_at: locked ? now - i.seconds : nil,

data/spec/lifecycle_spec.rb

@@ -3,7 +3,7 @@ require 'helper'
 describe Delayed::Lifecycle do
   let(:lifecycle) { described_class.new }
   let(:callback) { lambda { |*_args| } }
-  let(:arguments) { [1] }
+  let(:arguments) { [%i(job_a job_b)] }
   let(:behavior) { double(Object, before!: nil, after!: nil, inside!: nil) }
   let(:wrapped_block) { proc { behavior.inside! } }
 

data/spec/message_sending_spec.rb

@@ -136,23 +136,13 @@ describe Delayed::MessageSending do
       }.to change { Delayed::Job.count }.by(1)
     end
 
-    it 'does delay when delay_jobs is a proc returning true' do
-      Delayed::Worker.delay_jobs = ->(_job) { true }
+    it 'raises when delay_jobs is a Proc' do
+      Delayed::Worker.delay_jobs = -> { true }
       fairy_tail = FairyTail.new
       expect {
         expect {
           fairy_tail.delay.tell('a', kwarg: 'b')
-        }.not_to change { fairy_tail.happy_ending }
-      }.to change { Delayed::Job.count }.by(1)
-    end
-
-    it 'does not delay the job when delay_jobs is a proc returning false' do
-      Delayed::Worker.delay_jobs = ->(_job) { false }
-      fairy_tail = FairyTail.new
-      expect {
-        expect {
-          fairy_tail.delay.tell('a', kwarg: 'b')
-        }.to change { fairy_tail.happy_ending }.from(nil).to %w(a b)
+        }.to raise_error('Delayed::Worker.delay_jobs may not be a Proc')
       }.not_to(change { Delayed::Job.count })
     end
   end

data/spec/performable_method_spec.rb

@@ -95,12 +95,6 @@ describe Delayed::PerformableMethod do
       end
     end
 
-    it 'delegates enqueue hook to object' do
-      story = Story.create
-      expect(story).to receive(:enqueue).with(an_instance_of(Delayed::Job))
-      story.delay.tell
-    end
-
     it 'delegates error hook to object' do
       story = Story.create
       expect(story).to receive(:error).with(an_instance_of(Delayed::Job), an_instance_of(RuntimeError))

data/spec/sample_jobs.rb

@@ -77,10 +77,6 @@ end
 class CallbackJob
   cattr_accessor :messages
 
-  def enqueue(_job)
-    self.class.messages << 'enqueue'
-  end
-
   def before(_job)
     self.class.messages << 'before'
   end
@@ -106,12 +102,6 @@ class CallbackJob
   end
 end
 
-class EnqueueJobMod < SimpleJob
-  def enqueue(job)
-    job.run_at = 20.minutes.from_now
-  end
-end
-
 class ActiveJobJob < ActiveJob::Base # rubocop:disable Rails/ApplicationJob
   def perform(*args, **kwargs); end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delayed
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Nathan Griffith
@@ -19,7 +19,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-12 00:00:00.000000000 Z
+date: 2026-06-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -66,13 +66,15 @@ files:
 - README.md
 - Rakefile
 - app/models/delayed/job.rb
-- db/migrate/1_create_delayed_jobs.rb
-- db/migrate/2_add_name_to_delayed_jobs.rb
-- db/migrate/3_add_index_to_delayed_jobs_name.rb
-- db/migrate/4_index_live_jobs.rb
-- db/migrate/5_index_failed_jobs.rb
-- db/migrate/6_set_postgres_fillfactor.rb
-- db/migrate/7_remove_legacy_index.rb
+- db/migrate/01_create_delayed_jobs.rb
+- db/migrate/02_add_name_to_delayed_jobs.rb
+- db/migrate/03_add_index_to_delayed_jobs_name.rb
+- db/migrate/04_index_live_jobs.rb
+- db/migrate/05_index_failed_jobs.rb
+- db/migrate/06_set_postgres_fillfactor.rb
+- db/migrate/07_remove_legacy_index.rb
+- db/migrate/08_add_run_at_and_name_not_null_check.rb
+- db/migrate/09_validate_run_at_and_name_not_null.rb
 - lib/delayed.rb
 - lib/delayed/active_job_adapter.rb
 - lib/delayed/backend/base.rb
@@ -128,7 +130,7 @@ homepage: http://github.com/betterment/delayed
 licenses:
 - MIT
 metadata:
-  changelog_uri: https://github.com/betterment/delayed/blob/main/CHANGELOG.md
+  changelog_uri: https://github.com/betterment/delayed/releases
   bug_tracker_uri: https://github.com/betterment/delayed/issues
   source_code_uri: https://github.com/betterment/delayed
   rubygems_mfa_required: 'true'