delayed 1.2.1 → 2.0.0

data/spec/delayed/job_spec.rb

@@ -4,7 +4,7 @@ describe Delayed::Job do
   let(:worker) { Delayed::Worker.new }
 
   def create_job(opts = {})
-    described_class.create(opts.merge(payload_object: SimpleJob.new))
+    described_class.enqueue(SimpleJob.new, **opts)
   end
 
   before do
@@ -197,6 +197,103 @@ describe Delayed::Job do
     end
   end
 
+  describe '.claimable_by' do
+    let(:now) { '2025-11-10 17:20:13 UTC' }
+    let(:worker) do
+      instance_double(Delayed::Worker, name: "worker1", read_ahead: 1, max_claims: 1, min_priority: nil, max_priority: nil, queues: queues)
+    end
+    let(:queues) { [] }
+    let(:query) { QueryUnderTest.for(described_class.claimable_by(worker)) }
+
+    around { |example| Timecop.freeze(now) { example.run } }
+
+    it "generates the expected #{current_adapter} query" do
+      expect(query.formatted).to match_snapshot
+    end
+
+    it "generates the expected #{current_adapter} query plan" do
+      expect(query.explain).to match_snapshot
+    end
+
+    context 'when a single queue is specified' do
+      let(:queues) { %w(default) }
+
+      it "generates the expected #{current_adapter} query for one queue" do
+        expect(query.formatted).to match_snapshot
+      end
+
+      it "generates a #{current_adapter} query plan for one queue" do
+        expect(query.explain).to match_snapshot
+      end
+    end
+
+    context 'multiple queues are specified' do
+      let(:queues) { %w(default mailers tracking) }
+
+      it "generates the expected #{current_adapter} query for multiple queue" do
+        expect(query.formatted).to match_snapshot
+      end
+
+      it "generates a #{current_adapter} query plan for multiple queues" do
+        expect(query.explain).to match_snapshot
+      end
+    end
+
+    context 'when using the legacy index', :with_legacy_table_index do
+      it "[legacy index] generates the expected #{current_adapter} query plan" do
+        expect(query.explain).to match_snapshot
+      end
+
+      context 'when a single queue is specified' do
+        let(:queues) { %w(default) }
+
+        it "[legacy index] generates a #{current_adapter} query plan for one queue" do
+          expect(query.explain).to match_snapshot
+        end
+      end
+
+      context 'multiple queues are specified' do
+        let(:queues) { %w(default mailers tracking) }
+
+        it "[legacy index] generates a #{current_adapter} query plan for multiple queues" do
+          expect(query.explain).to match_snapshot
+        end
+      end
+    end
+  end
+
+  describe '.claimed_by' do
+    let(:now) { '2025-11-10 17:20:13 UTC' }
+    let(:worker) { instance_double(Delayed::Worker, name: "worker1") }
+    let(:query) { QueryUnderTest.for(described_class.claimed_by(worker).select(:locked_at, :locked_by)) }
+
+    around { |example| Timecop.freeze(now) { example.run } }
+
+    it "generates a well-scoped #{current_adapter} query" do
+      expect(query.formatted).to match_snapshot
+    end
+
+    it "generates an efficient #{current_adapter} query plan" do
+      expect(query.explain).to match_snapshot
+    end
+
+    context 'when using legacy index', :with_legacy_table_index do
+      it "[legacy index] generates an efficient #{current_adapter} query plan" do
+        expect(query.explain).to match_snapshot
+      end
+    end
+  end
+
+  describe '.lock_timeout' do
+    it 'changes relative to Worker.max_run_time' do
+      Delayed::Worker.max_run_time = 5.minutes
+      expect(described_class.lock_timeout).to eq(5.minutes + described_class::REENQUEUE_BUFFER)
+
+      Delayed::Worker.max_run_time = 10.minutes
+      expect(described_class.lock_timeout).to eq(10.minutes + described_class::REENQUEUE_BUFFER)
+    end
+  end
+
   describe 'reserve' do
     before do
       Delayed::Worker.max_run_time = 2.minutes
@@ -204,6 +301,7 @@ describe Delayed::Job do
 
     after do
       Time.zone = nil
+      self.default_timezone = :utc
     end
 
     it 'does not reserve failed jobs' do
@@ -221,10 +319,82 @@ describe Delayed::Job do
       expect(described_class.reserve(worker)).to eq([job])
     end
 
-    it 'reserves jobs scheduled for the past when time zones are involved' do
-      Time.zone = 'US/Eastern'
-      job = create_job run_at: described_class.db_time_now - 1.minute
-      expect(described_class.reserve(worker)).to eq([job])
+    context 'during DST change' do
+      before do
+        Time.zone = 'US/Eastern'
+      end
+
+      let(:dst_start) { Time.zone.parse('2024-11-03 01:00:00 EDT') }
+
+      it 'does not reserve future-scheduled jobs scheduled for during the "fall back" hour' do
+        allow(Delayed.logger).to receive(:warn)
+        job = create_job run_at: dst_start + 1.hour + 1.minute
+        expect(described_class.reserve(worker, dst_start + 59.minutes)).to eq []
+        expect(job.run_at).to eq(Time.zone.parse('2024-11-03 01:01:00 EST'))
+        expect(Delayed.logger).not_to have_received(:warn)
+      end
+
+      it 'does not reserve future-scheduled jobs scheduled for after the "fall back" hour' do
+        job = create_job run_at: dst_start + 2.hours + 1.minute
+        expect(described_class.reserve(worker, dst_start + 59.minutes)).to eq []
+        expect(job.run_at).to eq(Time.zone.parse('2024-11-03 02:01:00 EST'))
+      end
+
+      it 'reserves jobs scheduled for the past' do
+        job = create_job run_at: dst_start + 1.minute
+        expect(described_class.reserve(worker, dst_start + 59.minutes)).to eq([job])
+      end
+
+      it 'does not break when run_at is explicitly nil' do
+        job = create_job run_at: nil
+        expect(job.run_at).not_to be_nil
+      end
+    end
+
+    context 'when using :local non-UTC time for DB timestamps' do
+      before do
+        self.default_timezone = :local
+      end
+
+      it 'does not reserve jobs scheduled for the future' do
+        create_job run_at: 1.minute.from_now
+        expect(described_class.reserve(worker)).to eq []
+      end
+
+      it 'reserves jobs scheduled for the past' do
+        job = create_job run_at: 1.minute.ago
+        expect(described_class.reserve(worker)).to eq([job])
+      end
+
+      context 'during DST change' do
+        before do
+          Time.zone = 'US/Eastern'
+        end
+
+        let(:dst_start) { Time.zone.parse('2024-11-03 01:00:00 EDT') }
+
+        it 'does not reserve future-scheduled jobs scheduled for during the "fall back" hour' do
+          allow(Delayed.logger).to receive(:warn)
+          job = create_job run_at: dst_start + 1.hour + 1.minute
+          expect(described_class.reserve(worker, dst_start + 59.minutes)).to eq []
+          # see Delayed::Backend::JobPreparer#handle_dst for default_timezone = `:local` handling:
+          expect(job.run_at).to eq(Time.zone.parse('2024-11-03 02:00:00 EST'))
+          expect(Delayed.logger).to have_received(:warn).with(
+            "Adjusted run_at from 2024-11-03 01:01:00 -0500 to 2024-11-03 02:00:00 -0500 to account for fall back DST transition",
+          )
+        end
+
+        it 'does not reserve future-scheduled jobs scheduled for after the "fall back" hour' do
+          job = create_job run_at: dst_start + 2.hours + 1.minute
+          expect(described_class.reserve(worker, dst_start + 59.minutes)).to eq []
+          expect(job.run_at).to eq(Time.zone.parse('2024-11-03 02:01:00 EST'))
+        end
+
+        it 'reserves jobs scheduled for the past' do
+          job = create_job run_at: dst_start + 1.minute
+          expect(described_class.reserve(worker, dst_start + 59.minutes)).to eq([job])
+        end
+      end
     end
 
     it 'does not reserve jobs locked by other workers' do
@@ -412,18 +582,24 @@ describe Delayed::Job do
   end
 
   context 'clear_locks!' do
-    before do
-      @job = create_job(locked_by: 'worker1', locked_at: described_class.db_time_now)
+    let(:worker) do
+      instance_double(Delayed::Worker, name: "worker1", read_ahead: 1, max_claims: 1, min_priority: nil, max_priority: nil, queues: [])
+    end
+    let(:different_worker) do
+      instance_double(Delayed::Worker, name: "worker2", read_ahead: 1, max_claims: 1, min_priority: nil, max_priority: nil, queues: [])
     end
 
     it 'clears locks for the given worker' do
-      described_class.clear_locks!('worker1')
-      expect(described_class.reserve(worker)).to eq([@job])
+      job = create_job(locked_by: 'worker1', locked_at: described_class.db_time_now)
+      described_class.clear_locks!(worker)
+      expect(described_class.reserve(different_worker)).to eq([job])
     end
 
     it 'does not clear locks for other workers' do
-      described_class.clear_locks!('different_worker')
-      expect(described_class.reserve(worker)).not_to include(@job)
+      job = create_job(locked_by: 'worker1', locked_at: described_class.db_time_now)
+      described_class.clear_locks!(different_worker)
+      expect(described_class.reserve(different_worker)).not_to include(job)
+      expect(described_class.reserve(worker)).to eq([job])
     end
   end
 
@@ -674,7 +850,7 @@ describe Delayed::Job do
         worker.perform(job)
         job.reload
 
-        expect((described_class.db_time_now + 99.minutes - job.run_at).abs).to be < 1
+        expect((described_class.db_time_now + 99.minutes - job.run_at).abs).to be_within(1).of(0.5)
       end
 
       it "does not fail when the triggered error doesn't have a message" do
@@ -839,7 +1015,7 @@ describe Delayed::Job do
   context "db_time_now" do
     after do
       Time.zone = nil
-      self.default_timezone = :local
+      self.default_timezone = :utc
     end
 
     it "returns time in current time zone if set" do

data/spec/delayed/monitor_spec.rb

@@ -94,7 +94,7 @@ RSpec.describe Delayed::Monitor do
   end
 
   context 'when there are jobs in the queue' do
-    let(:now) { Time.now.change(nsec: 0) } # rubocop:disable Rails/TimeZone
+    let(:now) { Delayed::Job.db_time_now.change(nsec: 0) }
     let(:job_attributes) do
       {
         run_at: now,
@@ -103,11 +103,11 @@ RSpec.describe Delayed::Monitor do
         attempts: 0,
       }
     end
-    let(:failed_attributes) { { run_at: now - 1.week, last_error: '123', failed_at: now - 1.day, attempts: 4, locked_at: now - 1.day } }
-    let(:p0_attributes) { job_attributes.merge(priority: 1) }
-    let(:p10_attributes) { job_attributes.merge(priority: 13) }
-    let(:p20_attributes) { job_attributes.merge(priority: 23) }
-    let(:p30_attributes) { job_attributes.merge(priority: 999) }
+    let(:failed_attributes) { { run_at: now - 1.week, attempts: 1, failed_at: now - 1.day, locked_at: now - 1.day } }
+    let(:p0_attributes) { job_attributes.merge(priority: 1, attempts: 1) }
+    let(:p10_attributes) { job_attributes.merge(priority: 13, locked_at: now - 1.day) }
+    let(:p20_attributes) { job_attributes.merge(priority: 23, attempts: 1) }
+    let(:p30_attributes) { job_attributes.merge(priority: 999, locked_at: now - 1.day) }
     let(:p0_payload) { default_payload.merge(priority: 'interactive') }
     let(:p10_payload) { default_payload.merge(priority: 'user_visible') }
     let(:p20_payload) { default_payload.merge(priority: 'eventual') }
@@ -139,8 +139,8 @@ RSpec.describe Delayed::Monitor do
         .to emit_notification("delayed.monitor.run").with_payload(default_payload.except(:queue))
         .and emit_notification("delayed.job.count").with_payload(p0_payload).with_value(4)
         .and emit_notification("delayed.job.future_count").with_payload(p0_payload).with_value(1)
-        .and emit_notification("delayed.job.locked_count").with_payload(p0_payload).with_value(2)
-        .and emit_notification("delayed.job.erroring_count").with_payload(p0_payload).with_value(1)
+        .and emit_notification("delayed.job.locked_count").with_payload(p0_payload).with_value(1)
+        .and emit_notification("delayed.job.erroring_count").with_payload(p0_payload).with_value(3)
         .and emit_notification("delayed.job.failed_count").with_payload(p0_payload).with_value(1)
         .and emit_notification("delayed.job.working_count").with_payload(p0_payload).with_value(1)
         .and emit_notification("delayed.job.workable_count").with_payload(p0_payload).with_value(1)
@@ -149,8 +149,8 @@ RSpec.describe Delayed::Monitor do
         .and emit_notification("delayed.job.alert_age_percent").with_payload(p0_payload).with_value(30.0.seconds / 1.minute * 100)
         .and emit_notification("delayed.job.count").with_payload(p10_payload).with_value(4)
         .and emit_notification("delayed.job.future_count").with_payload(p10_payload).with_value(1)
-        .and emit_notification("delayed.job.locked_count").with_payload(p10_payload).with_value(2)
-        .and emit_notification("delayed.job.erroring_count").with_payload(p10_payload).with_value(1)
+        .and emit_notification("delayed.job.locked_count").with_payload(p10_payload).with_value(1)
+        .and emit_notification("delayed.job.erroring_count").with_payload(p10_payload).with_value(0)
         .and emit_notification("delayed.job.failed_count").with_payload(p10_payload).with_value(1)
         .and emit_notification("delayed.job.working_count").with_payload(p10_payload).with_value(1)
         .and emit_notification("delayed.job.workable_count").with_payload(p10_payload).with_value(1)
@@ -159,8 +159,8 @@ RSpec.describe Delayed::Monitor do
         .and emit_notification("delayed.job.alert_age_percent").with_payload(p10_payload).with_value(2.0.minutes / 3.minutes * 100)
         .and emit_notification("delayed.job.count").with_payload(p20_payload).with_value(4)
         .and emit_notification("delayed.job.future_count").with_payload(p20_payload).with_value(1)
-        .and emit_notification("delayed.job.locked_count").with_payload(p20_payload).with_value(2)
-        .and emit_notification("delayed.job.erroring_count").with_payload(p20_payload).with_value(1)
+        .and emit_notification("delayed.job.locked_count").with_payload(p20_payload).with_value(1)
+        .and emit_notification("delayed.job.erroring_count").with_payload(p20_payload).with_value(3)
         .and emit_notification("delayed.job.failed_count").with_payload(p20_payload).with_value(1)
         .and emit_notification("delayed.job.working_count").with_payload(p20_payload).with_value(1)
         .and emit_notification("delayed.job.workable_count").with_payload(p20_payload).with_value(1)
@@ -169,8 +169,8 @@ RSpec.describe Delayed::Monitor do
         .and emit_notification("delayed.job.alert_age_percent").with_payload(p20_payload).with_value(1.hour / 1.5.hours * 100)
         .and emit_notification("delayed.job.count").with_payload(p30_payload).with_value(4)
         .and emit_notification("delayed.job.future_count").with_payload(p30_payload).with_value(1)
-        .and emit_notification("delayed.job.locked_count").with_payload(p30_payload).with_value(2)
-        .and emit_notification("delayed.job.erroring_count").with_payload(p30_payload).with_value(1)
+        .and emit_notification("delayed.job.locked_count").with_payload(p30_payload).with_value(1)
+        .and emit_notification("delayed.job.erroring_count").with_payload(p30_payload).with_value(0)
         .and emit_notification("delayed.job.failed_count").with_payload(p30_payload).with_value(1)
         .and emit_notification("delayed.job.working_count").with_payload(p30_payload).with_value(1)
         .and emit_notification("delayed.job.workable_count").with_payload(p30_payload).with_value(1)
@@ -196,8 +196,8 @@ RSpec.describe Delayed::Monitor do
           .to emit_notification("delayed.monitor.run").with_payload(default_payload.except(:queue))
           .and emit_notification("delayed.job.count").with_payload(p0_payload).with_value(8)
           .and emit_notification("delayed.job.future_count").with_payload(p0_payload).with_value(2)
-          .and emit_notification("delayed.job.locked_count").with_payload(p0_payload).with_value(4)
-          .and emit_notification("delayed.job.erroring_count").with_payload(p0_payload).with_value(2)
+          .and emit_notification("delayed.job.locked_count").with_payload(p0_payload).with_value(2)
+          .and emit_notification("delayed.job.erroring_count").with_payload(p0_payload).with_value(3)
           .and emit_notification("delayed.job.failed_count").with_payload(p0_payload).with_value(2)
           .and emit_notification("delayed.job.working_count").with_payload(p0_payload).with_value(2)
           .and emit_notification("delayed.job.workable_count").with_payload(p0_payload).with_value(2)
@@ -206,8 +206,8 @@ RSpec.describe Delayed::Monitor do
           .and emit_notification("delayed.job.alert_age_percent").with_payload(p0_payload).with_value(0)
           .and emit_notification("delayed.job.count").with_payload(p20_payload).with_value(8)
           .and emit_notification("delayed.job.future_count").with_payload(p20_payload).with_value(2)
-          .and emit_notification("delayed.job.locked_count").with_payload(p20_payload).with_value(4)
-          .and emit_notification("delayed.job.erroring_count").with_payload(p20_payload).with_value(2)
+          .and emit_notification("delayed.job.locked_count").with_payload(p20_payload).with_value(2)
+          .and emit_notification("delayed.job.erroring_count").with_payload(p20_payload).with_value(3)
           .and emit_notification("delayed.job.failed_count").with_payload(p20_payload).with_value(2)
           .and emit_notification("delayed.job.working_count").with_payload(p20_payload).with_value(2)
           .and emit_notification("delayed.job.workable_count").with_payload(p20_payload).with_value(2)
@@ -273,4 +273,47 @@ RSpec.describe Delayed::Monitor do
       end
     end
   end
+
+  describe '#query_for' do
+    let(:monitor) { described_class.new }
+    let(:queries) { [] }
+    let(:now) { '2025-11-10 17:20:13 UTC' }
+
+    around { |example| Timecop.freeze(now) { example.run } }
+
+    before do
+      Delayed::Worker.queues = []
+      ActiveSupport::Notifications.subscribe('sql.active_record') do |_, _, _, _, details|
+        sql = details[:sql]
+        details[:binds]&.each do |value|
+          value = value.value if value.is_a?(ActiveModel::Attribute)
+          sql = sql.sub(/(\?|\$\d)/, ActiveRecord::Base.connection.quote(value))
+        end
+        queries << sql
+      end
+    end
+
+    def queries_for(metric)
+      monitor.query_for(metric)
+      queries.map { |q| QueryUnderTest.for(q) }
+    end
+
+    described_class::METRICS.each do |metric|
+      context "('#{metric}')" do
+        it "runs the expected #{current_adapter} query for #{metric}" do
+          expect(queries_for(metric).map(&:formatted).join("\n")).to match_snapshot
+        end
+
+        it "produces the expected #{current_adapter} query plan for #{metric}" do
+          expect(queries_for(metric).map(&:explain).join("\n")).to match_snapshot
+        end
+
+        context 'when using the legacy index', :with_legacy_table_index do
+          it "[legacy index] produces the expected #{current_adapter} query plan for #{metric}" do
+            expect(queries_for(metric).map(&:explain).join("\n")).to match_snapshot
+          end
+        end
+      end
+    end
+  end
 end

data/spec/helper.rb

@@ -10,6 +10,8 @@ require 'sample_jobs'
 
 require 'rake'
 
+require 'snapshot_testing/rspec'
+
 ActiveSupport.on_load(:active_record) do
   require 'global_id/identification'
   include GlobalID::Identification
@@ -23,15 +25,17 @@ else
   ActiveSupport::Deprecation.behavior = :raise
 end
 
-if ENV['DEBUG_LOGS']
-  Delayed.logger = Logger.new($stdout)
-else
-  require 'tempfile'
+Delayed.logger = Logger.new($stdout)
+Delayed.logger.level = ENV['DEBUG_LOGS'] ? Logger::DEBUG : Logger::FATAL
 
-  tf = Tempfile.new('dj.log')
-  Delayed.logger = Logger.new(tf.path)
-  tf.unlink
+def with_log_level(level)
+  logger_level_was = Delayed.logger.level
+  Delayed.logger.level = level
+  yield
+ensure
+  Delayed.logger.level = logger_level_was
 end
+
 ENV['RAILS_ENV'] = 'test'
 
 db_adapter = ENV["ADAPTER"]
@@ -45,6 +49,12 @@ ActiveRecord::Base.logger = Delayed.logger
 ActiveJob::Base.logger = Delayed.logger
 ActiveRecord::Migration.verbose = false
 
+if ActiveRecord.respond_to?(:default_timezone=)
+  ActiveRecord.default_timezone = :utc
+else
+  ActiveRecord::Base.default_timezone = :utc
+end
+
 # MySQL 5.7 no longer supports null default values for the primary key
 # Override the default primary key type in Rails <= 4.0
 # https://stackoverflow.com/a/34555109
@@ -62,11 +72,35 @@ end
 Dir['db/migrate/*.rb'].each { |f| require_relative("../#{f}") }
 
 ActiveRecord::Schema.define do
-  drop_table :delayed_jobs, if_exists: true
+  if ActiveRecord::VERSION::MAJOR >= 7
+    drop_table :delayed_jobs, if_exists: true
+  elsif ActiveRecord::Base.connection.table_exists?(:delayed_jobs)
+    drop_table :delayed_jobs
+  end
 
-  CreateDelayedJobs.migrate(:up)
-  AddNameToDelayedJobs.migrate(:up)
-  AddIndexToDelayedJobsName.migrate(:up)
+  # Let's prove reversibility when we set up our test DB:
+  def run_migration(klass)
+    klass.migrate(:up)
+    klass.migrate(:down)
+    klass.migrate(:up)
+  end
+
+  with_log_level(Logger::WARN) do
+    run_migration(CreateDelayedJobs)
+    run_migration(AddNameToDelayedJobs)
+    run_migration(AddIndexToDelayedJobsName)
+    run_migration(IndexLiveJobs)
+    run_migration(IndexFailedJobs)
+    run_migration(SetPostgresFillfactor)
+    run_migration(RemoveLegacyIndex)
+
+    # Test that these index migrations can be re-applied idempotently.
+    # (In case identical indexes had been manually applied previously.)
+    AddIndexToDelayedJobsName.migrate(:up)
+    IndexLiveJobs.migrate(:up)
+    IndexFailedJobs.migrate(:up)
+    RemoveLegacyIndex.migrate(:up)
+  end
 
   create_table :stories, primary_key: :story_id, force: true do |table|
     table.string :text
@@ -101,6 +135,8 @@ TEST_MIN_RESERVE_INTERVAL = -10
 TEST_SLEEP_DELAY = -100
 
 RSpec.configure do |config|
+  config.include SnapshotTesting::RSpec
+
   config.around(:each) do |example|
     aj_priority_was = ActiveJob::Base.priority
     aj_queue_name_was = ActiveJob::Base.queue_name
@@ -144,6 +180,19 @@ RSpec.configure do |config|
     Delayed::Job.delete_all
   end
 
+  config.around(:each, :with_legacy_table_index) do |example|
+    IndexFailedJobs.migrate(:down)
+    IndexLiveJobs.migrate(:down)
+    AddIndexToDelayedJobsName.migrate(:down)
+    RemoveLegacyIndex.migrate(:down)
+    example.run
+  ensure
+    RemoveLegacyIndex.migrate(:up)
+    AddIndexToDelayedJobsName.migrate(:up)
+    IndexLiveJobs.migrate(:up)
+    IndexFailedJobs.migrate(:up)
+  end
+
   config.expect_with :rspec do |c|
     c.syntax = :expect
   end
@@ -211,3 +260,72 @@ def current_database
     'delayed_job_test'
   end
 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)
+  end
+
+  def formatted
+    fmt = sql.squish
+
+    if ActiveRecord::VERSION::MAJOR < 7
+      # Rails 6.0->6.1 optimizes for fewer "OR" parenthesis
+      fmt.gsub!(/\(\((.+ OR .+)\)( OR .+)\)/) { "(#{Regexp.last_match(1)}#{Regexp.last_match(2)})" }
+    end
+
+    # basic formatting for easier git diffing
+    fmt.gsub(/ (SELECT|FROM|WHERE|GROUP BY|ORDER BY) /) { "\n  #{Regexp.last_match(1).strip} " }
+      .gsub(/ (AND|OR) /) { "\n    #{Regexp.last_match(1).strip} " }
+      # normalize and truncate 'AS' names/aliases (changes across Rails versions)
+      .gsub(/AS ("|`)?(\w+)("|`)?/) { "AS #{Regexp.last_match(2)[0...63]}" }
+  end
+
+  def explain
+    send(:"#{current_adapter}_explain").strip
+      # normalize plan estimates
+      .gsub(/\(cost=.+\)/, '(cost=...)')
+  end
+
+  private
+
+  def postgresql_explain
+    connection.execute("SET seq_page_cost = 100")
+    connection.execute("SET enable_hashagg = 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_hashagg")
+    connection.execute("RESET seq_page_cost")
+  end
+
+  def mysql2_explain
+    seed_rows! # MySQL needs a bit of data to reach for indexes
+    connection.execute("ANALYZE TABLE #{Delayed::Job.table_name}")
+    connection.execute("SET SESSION max_seeks_for_key = 1")
+    connection.execute("EXPLAIN FORMAT=TREE #{sql}").to_a.map(&:first).join("\n")
+  ensure
+    connection.execute("SET SESSION max_seeks_for_key = DEFAULT")
+  end
+
+  def sqlite3_explain
+    connection.execute("EXPLAIN QUERY PLAN #{sql}").flat_map { |r| r["detail"] }.join("\n")
+  end
+
+  def seed_rows!
+    now = Delayed::Job.db_time_now
+    10.times do
+      [true, false].repeated_combination(5).each_with_index do |(erroring, failed, locked, future), i|
+        Delayed::Job.create!(
+          run_at: now + (future ? i.minutes : -i.minutes),
+          queue: "queue_#{i}",
+          handler: "--- !ruby/object:SimpleJob\n",
+          attempts: erroring ? i : 0,
+          failed_at: failed ? now - i.minutes : nil,
+          locked_at: locked ? now - i.seconds : nil,
+        )
+      end
+    end
+  end
+end

data/spec/sample_jobs.rb

@@ -115,3 +115,13 @@ end
 class ActiveJobJob < ActiveJob::Base # rubocop:disable Rails/ApplicationJob
   def perform(*args, **kwargs); end
 end
+
+class RescuesStandardErrorJob
+  cattr_accessor(:runs) { 0 }
+  def perform
+    self.class.runs += 1
+    sleep 10
+  rescue StandardError => e
+    raise "Rescued: #{e.class}"
+  end
+end

data/spec/worker_spec.rb

@@ -221,6 +221,24 @@ describe Delayed::Worker do
     end
   end
 
+  describe '.max_run_time' do
+    before { described_class.max_run_time = 1 }
+    after { RescuesStandardErrorJob.runs = 0 }
+
+    it 'times out and raises a WorkerTimeout that bypasses any StandardError rescuing' do
+      Delayed::Job.enqueue RescuesStandardErrorJob.new
+      described_class.new.work_off
+
+      expect(Delayed::Job.count).to eq 1
+      expect(RescuesStandardErrorJob.runs).to eq 1
+      Delayed::Job.first.tap do |job|
+        expect(job.attempts).to eq 1
+        expect(job.last_error).to match(/execution expired/)
+        expect(job.last_error).to match(/Delayed::Worker.max_run_time is only 1 second/)
+      end
+    end
+  end
+
   describe 'lifecycle callbacks' do
     let(:plugin) do
       Class.new(Delayed::Plugin) do