delayed 0.5.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae36c9e652d4fb6ce28f8897b0e7b03b7777ce9907a74973924111b735bca3ae
-  data.tar.gz: 0d4c27d0bf1f7e256fa85914086a0711c6406b4be5e88f211eccbd921c001718
+  metadata.gz: 9e2ec868563930c9d66a6db2eb638559b20497de5a819d543694c8fa4814519e
+  data.tar.gz: b48f6b5951f5c7309ea8db1b693451d4501c6f87852b843e5b1c49a5113cd4ed
 SHA512:
-  metadata.gz: cbae79e450983c1dd968b5f9959b4497758c32cc2c21a45ecea5b41dc1d7829fac2699d0a8cea635369d276eaec5b07ce8d7fa292674578ff62690823bc163fc
-  data.tar.gz: df37746eee87f40792499e02421f82a2fc4afa4317e168bdb440f3bed1ba737c761469092098f99e2aa3fb163f50981e6b19a83a4859e91871ac8f046363f630
+  metadata.gz: 17289bfb6ea1de0202570e44351e023a9024395bd2df12121b848e9813fc6eebd57c71abf709c61f7625697fddb097dc22d8bc1c2e0b714996b9e0cbdac7ceee
+  data.tar.gz: 76b59feb415bf66841659c05aeb421a69d59579161004da33b11de4937fe7e30c232da6bab17008c12489cf65186d8c316b371f5c41deb710e5534796b95ba20

data/README.md

@@ -432,6 +432,10 @@ Delayed::Worker.read_ahead = 5
 
 # If a worker finds no jobs, it will sleep this number of seconds in between attempts:
 Delayed::Worker.sleep_delay = 5
+
+# Until version 1.0, the worker will not sleep at all between attemps if it finds jobs.
+# This can be configured by setting the minimum reserve interval:
+Delayed::Worker.min_reserve_interval = 0.5 # seconds
 ```
 
 If a job fails, it will be rerun up to 25 times (with an exponential back-off). Jobs will also

data/lib/delayed/active_job_adapter.rb

@@ -17,7 +17,7 @@ module Delayed
     private
 
     def _enqueue(job, opts = {})
-      if job.class.respond_to?(:enqueue_after_transaction_commit) && job.class.enqueue_after_transaction_commit == :always
+      if enqueue_after_transaction_commit_enabled?(job)
         raise UnsafeEnqueueError, "The ':delayed' ActiveJob adapter is not compatible with enqueue_after_transaction_commit"
       end
 
@@ -29,6 +29,11 @@ module Delayed
       end
     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)
+    end
+
     module EnqueuingPatch
       def self.included(klass)
         klass.prepend PrependedMethods

data/lib/delayed/job_wrapper.rb

@@ -20,6 +20,24 @@ module Delayed
       job_data['job_class']
     end
 
+    # If job failed to deserialize, we can't respond to delegated methods.
+    # Returning false here prevents instance method checks from blocking job cleanup.
+    # There is a (currently) unreleased Rails PR that changes the exception class in this case:
+    # https://github.com/rails/rails/pull/53770
+    if defined?(ActiveJob::UnknownJobClassError)
+      def respond_to?(*, **)
+        super
+      rescue ActiveJob::UnknownJobClassError
+        false
+      end
+    else
+      def respond_to?(*, **)
+        super
+      rescue NameError
+        false
+      end
+    end
+
     def perform
       ActiveJob::Callbacks.run_callbacks(:execute) do
         job.perform_now

data/lib/delayed/lifecycle.rb

@@ -8,7 +8,7 @@ module Delayed
       perform: %i(worker job),
       error: %i(worker job),
       failure: %i(worker job),
-      thread: %i(worker job),
+      thread: [:worker],
       invoke_job: [:job],
     }.freeze
 

data/lib/delayed/message_sending.rb

@@ -1,7 +1,8 @@
-require 'active_support/proxy_object'
-
 module Delayed
-  class DelayProxy < ActiveSupport::ProxyObject
+  class DelayProxy < BasicObject
+    undef_method :==
+    undef_method :equal?
+
     def initialize(payload_class, target, options)
       @payload_class = payload_class
       @target = target

data/lib/delayed/plugins/connection.rb

@@ -2,9 +2,9 @@ module Delayed
   module Plugins
     class Connection < Plugin
       callbacks do |lifecycle|
-        lifecycle.around(:thread) do |worker, job, &block|
+        lifecycle.around(:thread) do |worker, &block|
           Job.connection_pool.with_connection do
-            block.call(worker, job)
+            block.call(worker)
           end
         end
       end

data/lib/delayed/priority.rb

@@ -140,6 +140,7 @@ module Delayed
     attr_reader :value
 
     delegate :to_i, to: :value
+    delegate :to_f, to: :value
     delegate :to_s, to: :name
 
     def initialize(value)

data/lib/delayed/runnable.rb

@@ -21,7 +21,7 @@ module Delayed
     def on_exit!; end
 
     def interruptable_sleep(seconds)
-      pipe[0].wait_readable(seconds)
+      pipe[0].wait_readable(seconds) if seconds.positive?
     end
 
     def stop

data/lib/delayed/version.rb

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

data/lib/delayed/worker.rb

@@ -12,6 +12,7 @@ module Delayed
     include Runnable
 
     cattr_accessor :sleep_delay, instance_writer: false, default: 5
+    cattr_accessor :min_reserve_interval, instance_writer: false, default: 0
     cattr_accessor :max_attempts, instance_writer: false, default: 25
     cattr_accessor :max_claims, instance_writer: false, default: 5
     cattr_accessor :max_run_time, instance_writer: false, default: 20.minutes
@@ -92,6 +93,7 @@ module Delayed
       total = 0
 
       while total < num
+        start = clock_time
         jobs = reserve_jobs
         break if jobs.empty?
 
@@ -99,7 +101,15 @@ module Delayed
         pool = Concurrent::FixedThreadPool.new(jobs.length)
         jobs.each do |job|
           pool.post do
-            success.increment if run_job(job)
+            self.class.lifecycle.run_callbacks(:thread, self) do
+              success.increment if perform(job)
+            rescue DeserializationError => e
+              handle_unrecoverable_error(job, e)
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              handle_erroring_job(job, e)
+            end
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            say "Job thread crashed with #{e.class.name}: #{e.message}", 'error'
           end
         end
 
@@ -107,17 +117,16 @@ module Delayed
         pool.wait_for_termination
 
         break if stop? # leave if we're exiting
+
+        elapsed = clock_time - start
+        interruptable_sleep(self.class.min_reserve_interval - elapsed)
       end
 
       [success.value, total - success.value]
     end
 
-    def run_thread_callbacks(job, &block)
-      self.class.lifecycle.run_callbacks(:thread, self, job, &block)
-    end
-
-    def run(job)
-      run_thread_callbacks(job) do
+    def perform(job)
+      self.class.lifecycle.run_callbacks(:perform, self, job) do
         metadata = {
           status: 'RUNNING',
           name: job.name,
@@ -139,13 +148,10 @@ module Delayed
       end
       true # did work
     rescue DeserializationError => e
-      job_say job, "FAILED permanently with #{e.class.name}: #{e.message}", 'error'
-
-      job.error = e
-      failed(job)
+      handle_unrecoverable_error(job, e)
       false # work failed
     rescue Exception => e # rubocop:disable Lint/RescueException
-      self.class.lifecycle.run_callbacks(:error, self, job) { handle_failed_job(job, e) }
+      handle_erroring_job(job, e)
       false # work failed
     end
 
@@ -166,12 +172,12 @@ module Delayed
     def failed(job)
       self.class.lifecycle.run_callbacks(:failure, self, job) do
         job.hook(:failure)
-      rescue StandardError => e
-        say "Error when running failure callback: #{e}", 'error'
-        say e.backtrace.join("\n"), 'error'
-      ensure
-        job.destroy_failed_jobs? ? job.destroy : job.fail!
       end
+    rescue StandardError => e
+      say "Error when running failure callback: #{e}", 'error'
+      say e.backtrace.join("\n"), 'error'
+    ensure
+      job.destroy_failed_jobs? ? job.destroy : job.fail!
     end
 
     def job_say(job, text, level = Delayed.default_log_level)
@@ -198,14 +204,21 @@ module Delayed
       " (queue=#{queue})" if queue
     end
 
-    def handle_failed_job(job, error)
-      job.error = error
-      job_say job, "FAILED (#{job.attempts} prior attempts) with #{error.class.name}: #{error.message}", 'error'
-      reschedule(job)
+    def handle_erroring_job(job, error)
+      self.class.lifecycle.run_callbacks(:error, self, job) do
+        job.error = error
+        job_say job, "FAILED (#{job.attempts} prior attempts) with #{error.class.name}: #{error.message}", 'error'
+        reschedule(job)
+      end
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      handle_unrecoverable_error(job, e)
     end
 
-    def run_job(job)
-      self.class.lifecycle.run_callbacks(:perform, self, job) { run(job) }
+    def handle_unrecoverable_error(job, error)
+      job_say job, "FAILED permanently with #{error.class.name}: #{error.message}", 'error'
+
+      job.error = error
+      failed(job)
     end
 
     # The backend adapter may return either a list or a single job
@@ -227,5 +240,9 @@ module Delayed
     def reload!
       Rails.application.reloader.reload! if defined?(Rails.application.reloader) && Rails.application.reloader.check!
     end
+
+    def clock_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
   end
 end

data/lib/delayed.rb

@@ -42,8 +42,8 @@ module Delayed
   mattr_accessor(:default_log_level) { 'info'.freeze }
   mattr_accessor(:plugins) do
     [
-      Delayed::Plugins::Instrumentation,
       Delayed::Plugins::Connection,
+      Delayed::Plugins::Instrumentation,
     ]
   end
 

data/spec/delayed/active_job_adapter_spec.rb

@@ -49,11 +49,11 @@ RSpec.describe Delayed::ActiveJobAdapter do
         /  priority: ?\n/,
         "  arguments: []\n",
         "  executions: 0\n",
-        ("  exception_executions: {}\n" if ActiveJob::VERSION::MAJOR >= 6),
+        ("  exception_executions: {}\n" if ActiveJob.gem_version >= Gem::Version.new('6.0')),
         "  locale: en\n",
-        (/  timezone: ?\n/ if ActiveJob::VERSION::MAJOR >= 6),
-        (/  enqueued_at: '2023-01-20T18:52:29(\.\d+)?Z'\n/ if ActiveJob::VERSION::MAJOR >= 6),
-        (/  scheduled_at: ?\n/ if ActiveJob::VERSION::MAJOR >= 7 && ActiveJob::VERSION::MINOR >= 1),
+        (/  timezone: ?\n/ if ActiveJob.gem_version >= Gem::Version.new('6.0')),
+        (/  enqueued_at: '2023-01-20T18:52:29(\.\d+)?Z'\n/ if ActiveJob.gem_version >= Gem::Version.new('6.0')),
+        (/  scheduled_at: ?\n/ if ActiveJob.gem_version >= Gem::Version.new('7.1')),
       ].compact
     end
   end
@@ -62,10 +62,23 @@ RSpec.describe Delayed::ActiveJobAdapter do
     JobClass.perform_later
 
     Delayed::Job.last.tap do |dj|
-      dj.handler = dj.handler.gsub('JobClass', 'MissingJobClass')
+      dj.update!(handler: dj.handler.gsub('JobClass', 'MissingJobClass'))
       expect { dj.payload_object }.not_to raise_error
       expect { dj.payload_object.job_id }.to raise_error(NameError, 'uninitialized constant MissingJobClass')
     end
+    expect(Delayed::Worker.new.work_off).to eq([0, 1])
+    expect(Delayed::Job.last.last_error).to match(/uninitialized constant MissingJobClass/)
+  end
+
+  it 'deserializes even if an underlying argument gid is not defined' do
+    ActiveJobJob.perform_later(story: Story.create!)
+    Delayed::Job.last.tap do |dj|
+      dj.update!(handler: dj.handler.gsub('Story', 'MissingArgumentClass'))
+      expect { dj.payload_object }.not_to raise_error
+      expect { dj.payload_object.perform_now }.to raise_error(ActiveJob::DeserializationError)
+    end
+    expect(Delayed::Worker.new.work_off).to eq([0, 1])
+    expect(Delayed::Job.last.last_error).to match(/Error while trying to deserialize arguments/)
   end
 
   describe '.set' do
@@ -295,7 +308,9 @@ RSpec.describe Delayed::ActiveJobAdapter do
         end
 
         it 'raises an exception on enqueue' do
-          expect { JobClass.perform_later }.to raise_error(Delayed::ActiveJobAdapter::UnsafeEnqueueError)
+          ActiveJob.deprecator.silence do
+            expect { JobClass.perform_later }.to raise_error(Delayed::ActiveJobAdapter::UnsafeEnqueueError)
+          end
         end
       end
 
@@ -306,7 +321,33 @@ RSpec.describe Delayed::ActiveJobAdapter do
         end
 
         it 'does not raises an exception on enqueue' do
-          expect { JobClass.perform_later }.not_to raise_error(Delayed::ActiveJobAdapter::UnsafeEnqueueError)
+          ActiveJob.deprecator.silence do
+            expect { JobClass.perform_later }.not_to raise_error
+          end
+        end
+      end
+    end
+
+    if ActiveJob.gem_version.release >= Gem::Version.new('8.0')
+      context 'when the given job sets enqueue_after_transaction_commit to true' do
+        before do
+          JobClass.include ActiveJob::EnqueueAfterTransactionCommit # normally run in an ActiveJob railtie
+          JobClass.enqueue_after_transaction_commit = true
+        end
+
+        it 'raises an exception on enqueue' do
+          expect { JobClass.perform_later }.to raise_error(Delayed::ActiveJobAdapter::UnsafeEnqueueError)
+        end
+      end
+
+      context 'when the given job sets enqueue_after_transaction_commit to false' do
+        before do
+          JobClass.include ActiveJob::EnqueueAfterTransactionCommit # normally run in an ActiveJob railtie
+          JobClass.enqueue_after_transaction_commit = false
+        end
+
+        it 'does not raises an exception on enqueue' do
+          expect { JobClass.perform_later }.not_to raise_error
         end
       end
     end

data/spec/delayed/job_spec.rb

@@ -533,7 +533,7 @@ describe Delayed::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
-        worker.run(job)
+        worker.perform(job)
         expect(job.error).not_to be_nil
         expect(job.reload.last_error).to match(/expired/)
         expect(job.reload.last_error).to match(/Delayed::Worker\.max_run_time is only 1 second/)
@@ -558,7 +558,7 @@ describe Delayed::Job do
 
       it 'records last_error when destroy_failed_jobs = false, max_attempts = 1' do
         Delayed::Worker.max_attempts = 1
-        worker.run(@job)
+        worker.perform(@job)
         @job.reload
         expect(@job.error).not_to be_nil
         expect(@job.last_error).to match(/did not work/)
@@ -580,7 +580,7 @@ describe Delayed::Job do
 
       it 're-schedules jobs with handler provided time if present' do
         job = described_class.enqueue(CustomRescheduleJob.new(99.minutes))
-        worker.run(job)
+        worker.perform(job)
         job.reload
 
         expect((described_class.db_time_now + 99.minutes - job.run_at).abs).to be < 1
@@ -590,7 +590,7 @@ describe Delayed::Job do
         error_with_nil_message = StandardError.new
         expect(error_with_nil_message).to receive(:message).twice.and_return(nil)
         expect(@job).to receive(:invoke_job).and_raise error_with_nil_message
-        expect { worker.run(@job) }.not_to raise_error
+        expect { worker.perform(@job) }.not_to raise_error
       end
     end
 

data/spec/delayed/priority_spec.rb

@@ -207,6 +207,13 @@ RSpec.describe Delayed::Priority do
     expect(described_class.new(101)).to eq described_class.new(101) # rubocop:disable RSpec/IdenticalEqualityAssertion
   end
 
+  it 'supports explicit casting' do
+    expect(described_class.new(0).to_i).to eq 0
+    expect(described_class.new(3).to_f).to eq 3.0
+    expect(described_class.new(10).to_s).to eq 'user_visible'
+    expect(described_class.new(:eventual).to_d).to eq '20'.to_d
+  end
+
   it 'suports coercion' do
     expect(described_class.new(0)).to eq 0
     expect(described_class.new(8)).to be > 5

data/spec/delayed/tasks_spec.rb

@@ -64,7 +64,7 @@ describe 'rake' do
           .to change { Delayed::Worker.min_priority }.from(nil).to(6)
           .and change { Delayed::Worker.max_priority }.from(nil).to(8)
           .and change { Delayed::Worker.queues }.from([]).to(%w(foo bar))
-          .and change { Delayed::Worker.sleep_delay }.from(5).to(1)
+          .and change { Delayed::Worker.sleep_delay }.from(TEST_SLEEP_DELAY).to(1)
           .and change { Delayed::Worker.read_ahead }.from(5).to(3)
           .and change { Delayed::Worker.max_claims }.from(5).to(3)
       end
@@ -96,7 +96,7 @@ describe 'rake' do
           .to change { Delayed::Worker.min_priority }.from(nil).to(6)
           .and change { Delayed::Worker.max_priority }.from(nil).to(8)
           .and change { Delayed::Worker.queues }.from([]).to(%w(foo))
-          .and change { Delayed::Worker.sleep_delay }.from(5).to(1)
+          .and change { Delayed::Worker.sleep_delay }.from(TEST_SLEEP_DELAY).to(1)
           .and change { Delayed::Worker.read_ahead }.from(5).to(3)
           .and change { Delayed::Worker.max_claims }.from(5).to(3)
       end

data/spec/helper.rb

@@ -10,6 +10,19 @@ require 'sample_jobs'
 
 require 'rake'
 
+ActiveSupport.on_load(:active_record) do
+  require 'global_id/identification'
+  include GlobalID::Identification
+  GlobalID.app = 'test'
+end
+
+if ActiveSupport.gem_version >= Gem::Version.new('7.1')
+  frameworks = [ActiveModel, ActiveRecord, ActionMailer, ActiveJob, ActiveSupport]
+  frameworks.each { |framework| framework.deprecator.behavior = :raise }
+else
+  ActiveSupport::Deprecation.behavior = :raise
+end
+
 if ENV['DEBUG_LOGS']
   Delayed.logger = Logger.new($stdout)
 else
@@ -29,6 +42,7 @@ db_adapter ||= "sqlite3"
 config = YAML.load(ERB.new(File.read("spec/database.yml")).result)
 ActiveRecord::Base.establish_connection config[db_adapter]
 ActiveRecord::Base.logger = Delayed.logger
+ActiveJob::Base.logger = Delayed.logger
 ActiveRecord::Migration.verbose = false
 
 # MySQL 5.7 no longer supports null default values for the primary key
@@ -97,6 +111,11 @@ class SingletonClass
   include Singleton
 end
 
+# Negative values are treated as sleep(0),
+# so we can use different values to test the sleep behavior:
+TEST_MIN_RESERVE_INTERVAL = -10
+TEST_SLEEP_DELAY = -100
+
 RSpec.configure do |config|
   config.around(:each) do |example|
     aj_priority_was = ActiveJob::Base.priority
@@ -113,6 +132,11 @@ RSpec.configure do |config|
     queues_was = Delayed::Worker.queues
     read_ahead_was = Delayed::Worker.read_ahead
     sleep_delay_was = Delayed::Worker.sleep_delay
+    min_reserve_interval_was = Delayed::Worker.min_reserve_interval
+    plugins_was = Delayed.plugins.dup
+
+    Delayed::Worker.sleep_delay = TEST_SLEEP_DELAY
+    Delayed::Worker.min_reserve_interval = TEST_MIN_RESERVE_INTERVAL
 
     example.run
   ensure
@@ -130,6 +154,8 @@ RSpec.configure do |config|
     Delayed::Worker.queues = queues_was
     Delayed::Worker.read_ahead = read_ahead_was
     Delayed::Worker.sleep_delay = sleep_delay_was
+    Delayed::Worker.min_reserve_interval = min_reserve_interval_was
+    Delayed.plugins = plugins_was
 
     Delayed::Job.delete_all
   end

data/spec/sample_jobs.rb

@@ -113,5 +113,5 @@ class EnqueueJobMod < SimpleJob
 end
 
 class ActiveJobJob < ActiveJob::Base # rubocop:disable Rails/ApplicationJob
-  def perform; end
+  def perform(*args, **kwargs); end
 end

data/spec/worker_spec.rb

@@ -1,10 +1,6 @@
 require 'helper'
 
 describe Delayed::Worker do
-  before do
-    described_class.sleep_delay = 0
-  end
-
   describe 'start' do
     it 'runs the :execute lifecycle hook' do
       performances = []
@@ -32,62 +28,74 @@ describe Delayed::Worker do
       allow(subject).to receive(:interruptable_sleep).and_call_original
     end
 
-    context 'when there are no jobs' do
-      before do
-        allow(Delayed::Job).to receive(:reserve).and_return([])
-      end
+    around do |example|
+      max_claims_was = described_class.max_claims
+      described_class.max_claims = max_claims
+      example.run
+    ensure
+      described_class.max_claims = max_claims_was
+    end
 
-      it 'does not log and then sleeps' do
-        subject.run!
-        expect(Delayed.logger).not_to have_received(:info)
-        expect(subject).to have_received(:interruptable_sleep)
-      end
+    before do
+      allow(Delayed::Job).to receive(:reserve).and_return((0...jobs_returned).map { job }, [])
     end
 
-    context 'when there is a job worked off' do
-      around do |example|
-        max_claims_was = described_class.max_claims
-        described_class.max_claims = max_claims
-        example.run
-      ensure
-        described_class.max_claims = max_claims_was
-      end
+    let(:max_claims) { 1 }
+    let(:jobs_returned) { 1 }
+    let(:job) do
+      instance_double(
+        Delayed::Job,
+        id: 123,
+        max_run_time: 10,
+        name: 'MyJob',
+        run_at: Delayed::Job.db_time_now,
+        created_at: Delayed::Job.db_time_now,
+        priority: Delayed::Priority.interactive,
+        queue: 'testqueue',
+        attempts: 0,
+        invoke_job: true,
+        destroy: true,
+      )
+    end
 
-      before do
-        allow(Delayed::Job).to receive(:reserve).and_return([job], [])
-      end
+    it 'logs the count and sleeps only within the loop' do
+      subject.run!
+      expect(Delayed.logger).to have_received(:info).with(/1 jobs processed/)
+      expect(subject).to have_received(:interruptable_sleep).once.with(a_value_within(1).of(TEST_MIN_RESERVE_INTERVAL))
+      expect(subject).not_to have_received(:interruptable_sleep).with(TEST_SLEEP_DELAY)
+    end
 
-      let(:max_claims) { 1 }
-      let(:job) do
-        instance_double(
-          Delayed::Job,
-          id: 123,
-          max_run_time: 10,
-          name: 'MyJob',
-          run_at: Delayed::Job.db_time_now,
-          created_at: Delayed::Job.db_time_now,
-          priority: Delayed::Priority.interactive,
-          queue: 'testqueue',
-          attempts: 0,
-          invoke_job: true,
-          destroy: true,
-        )
+    context 'when no jobs are returned' do
+      let(:jobs_returned) { 0 }
+
+      it 'does not log and then sleeps only outside of the loop' do
+        subject.run!
+        expect(Delayed.logger).not_to have_received(:info)
+        expect(subject).to have_received(:interruptable_sleep).with(TEST_SLEEP_DELAY)
       end
+    end
+
+    context 'when max_claims is 3 and 3 jobs are returned' do
+      let(:max_claims) { 3 }
+      let(:jobs_returned) { 3 }
 
-      it 'logs the count and does not sleep' do
+      it 'logs the count and sleeps only in the loop' do
         subject.run!
-        expect(Delayed.logger).to have_received(:info).with(/1 jobs processed/)
-        expect(subject).not_to have_received(:interruptable_sleep)
+        expect(Delayed.logger).to have_received(:info).with(/3 jobs processed/)
+        expect(subject).to have_received(:interruptable_sleep).once.with(a_value_within(1).of(TEST_MIN_RESERVE_INTERVAL))
+        expect(subject).not_to have_received(:interruptable_sleep).with(TEST_SLEEP_DELAY)
       end
+    end
 
-      context 'when max_claims is 2' do
-        let(:max_claims) { 2 }
+    context 'when max_claims is 3 and 2 jobs are returned' do
+      let(:max_claims) { 3 }
+      let(:jobs_returned) { 2 }
 
-        it 'logs the count and sleeps' do
-          subject.run!
-          expect(Delayed.logger).to have_received(:info).with(/1 jobs processed/)
-          expect(subject).to have_received(:interruptable_sleep)
-        end
+      it 'logs the count and sleeps both in the loop and outside of the loop' do
+        subject.run!
+        expect(Delayed.logger).to have_received(:info).with(/2 jobs processed/)
+        expect(subject).to have_received(:interruptable_sleep).once.with(a_value_within(1).of(TEST_MIN_RESERVE_INTERVAL))
+        expect(subject).to have_received(:interruptable_sleep).once.with(TEST_SLEEP_DELAY)
       end
     end
   end
@@ -213,23 +221,134 @@ describe Delayed::Worker do
     end
   end
 
-  describe 'thread callback' do
-    it 'wraps code after thread is checked out' do
-      performances = Concurrent::AtomicFixnum.new(0)
-      plugin = Class.new(Delayed::Plugin) do
+  describe 'lifecycle callbacks' do
+    let(:plugin) do
+      Class.new(Delayed::Plugin) do
+        class << self
+          attr_accessor :last_error, :raise_on
+
+          def events
+            @events ||= []
+          end
+        end
+
         callbacks do |lifecycle|
-          lifecycle.before(:thread) { performances.increment }
+          lifecycle.around(:thread) do |_, &blk|
+            events << :thread_start
+            blk.call
+            raise "oh no" if raise_on == :thread
+
+            events << :thread_end
+          end
+
+          %i(perform error failure).each do |event|
+            lifecycle.around(event) do |_, job, &blk|
+              events << :"#{event}_start"
+              raise "oh no" if raise_on == event
+
+              blk.call.tap do
+                self.last_error = job.last_error if event == :error
+                events << :"#{event}_end"
+              end
+            end
+          end
         end
       end
+    end
+
+    before do
       Delayed.plugins << plugin
+    end
 
-      Delayed::Job.delete_all
+    it 'runs thread and perform callbacks' do
       Delayed::Job.enqueue SimpleJob.new
-      worker = described_class.new
+      described_class.new.work_off
+
+      expect(plugin.events).to eq %i(thread_start perform_start perform_end thread_end)
+      expect(plugin.last_error).to eq(nil)
+      expect(Delayed::Job.count).to eq 0
+    end
+
+    context 'when thread callback raises an error' do
+      before do
+        plugin.raise_on = :thread
+      end
+
+      it 'logs that the thread crashed' do
+        Delayed::Job.enqueue SimpleJob.new
+        described_class.new.work_off
+
+        expect(plugin.events).to eq %i(thread_start perform_start perform_end)
+        expect(plugin.last_error).to eq(nil)
+        expect(Delayed::Job.count).to eq 0
+      end
+    end
+
+    context 'when the perform callback raises an error' do
+      before do
+        plugin.raise_on = :perform
+      end
+
+      it 'runs expected perform and error callbacks' do
+        Delayed::Job.enqueue SimpleJob.new
+        described_class.new.work_off
+
+        expect(plugin.events).to eq %i(thread_start perform_start error_start error_end thread_end)
+        expect(plugin.last_error).to match(/oh no/) # assert that cleanup happened before `:perform_end`
+        expect(Delayed::Job.count).to eq 1
+      end
+    end
 
-      worker.work_off
+    context 'when the perform method raises an error' do
+      it 'runs error callbacks' do
+        Delayed::Job.enqueue ErrorJob.new
+        described_class.new.work_off
 
-      expect(performances.value).to eq(1)
+        expect(plugin.events).to eq %i(thread_start perform_start error_start error_end thread_end)
+        expect(plugin.last_error).to match(/did not work/) # assert that cleanup happened before `:perform_end`
+        expect(Delayed::Job.count).to eq 1
+      end
+
+      context 'when error callback raises an error' do
+        before do
+          plugin.raise_on = :error
+        end
+
+        it 'runs thread and perform callbacks' do
+          Delayed::Job.enqueue SimpleJob.new
+          described_class.new.work_off
+
+          expect(plugin.events).to eq %i(thread_start perform_start perform_end thread_end)
+          expect(plugin.last_error).to eq(nil)
+          expect(Delayed::Job.count).to eq 0
+        end
+      end
+    end
+
+    context 'when max attempts is exceeded' do
+      it 'runs failure callbacks' do
+        Delayed::Job.enqueue FailureJob.new
+        described_class.new.work_off
+
+        expect(plugin.events).to eq %i(thread_start perform_start error_start failure_start failure_end error_end thread_end)
+        expect(plugin.last_error).to match(/did not work/) # assert that cleanup happened before `:perform_end`
+        expect(Delayed::Job.count).to eq 1
+      end
+
+      context 'when failure callback raises an error' do
+        before do
+          plugin.raise_on = :failure
+        end
+
+        it 'runs thread and perform callbacks' do
+          Delayed::Job.enqueue SimpleJob.new
+          described_class.new.work_off
+
+          expect(plugin.events).to eq %i(thread_start perform_start perform_end thread_end)
+          expect(plugin.last_error).to eq(nil)
+          expect(Delayed::Job.count).to eq 0
+        end
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delayed
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 1.0.0
 platform: ruby
 authors:
 - Nathan Griffith
@@ -16,10 +16,9 @@ authors:
 - Matt Griffin
 - Steve Richert
 - Tobias Lütke
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -87,6 +86,7 @@ files:
 - lib/delayed/serialization/active_record.rb
 - lib/delayed/syck_ext.rb
 - lib/delayed/tasks.rb
+- lib/delayed/version.rb
 - lib/delayed/worker.rb
 - lib/delayed/yaml_ext.rb
 - lib/delayed_job.rb
@@ -124,7 +124,6 @@ metadata:
   bug_tracker_uri: https://github.com/betterment/delayed/issues
   source_code_uri: https://github.com/betterment/delayed
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -139,8 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 3.6.8
 specification_version: 4
 summary: a multi-threaded, SQL-driven ActiveJob backend used at Betterment to process
   millions of background jobs per day