delayed 3.1.0 → 4.0.0

data/spec/delayed/limitable_spec.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require 'helper'
+
+RSpec.describe Delayed::Limitable do
+  let(:purpose) { :limitable_spec }
+
+  around do |example|
+    original_limits = Delayed::Limit.limits
+    example.run
+  ensure
+    Delayed::Limit.instance_variable_set(:@limits, original_limits)
+  end
+
+  before do
+    allow(Delayed::Limit).to receive(:within_limit).and_yield
+  end
+
+  it 'is automatically included in ActiveJob classes' do
+    expect(ActiveJob::Base).to respond_to(:with_limit)
+  end
+
+  describe '.with_limit' do
+    context 'when on: is not specified' do
+      let(:job_class) do
+        p = purpose
+        Class.new(ActiveJob::Base) do
+          with_limit p, max: 4, per: 1.second
+
+          define_method(:perform) { :result }
+        end
+      end
+
+      it 'wraps perform with within_limit' do
+        job_class.new.perform
+        expect(Delayed::Limit).to have_received(:within_limit)
+          .with(purpose, wait_timeout: 5.seconds).once
+      end
+
+      it 'registers the limit policy with Delayed::Limit' do
+        job_class
+        expect(Delayed::Limit.limits.fetch(purpose)).to eq(max: 4, per: 1.second)
+      end
+    end
+
+    context 'when purpose is not specified' do
+      let(:job_class) do
+        Class.new(ActiveJob::Base) do
+          define_method(:perform) { :result }
+        end
+      end
+
+      before do
+        stub_const('LimitableDefaultPurposeJob', job_class)
+        job_class.with_limit(max: 4, per: 1.second)
+      end
+
+      it 'defaults the purpose to the underscored class name' do
+        job_class.new.perform
+        expect(Delayed::Limit).to have_received(:within_limit)
+          .with(:limitable_default_purpose_job, wait_timeout: 5.seconds).once
+      end
+    end
+
+    context 'when wait_timeout: is specified' do
+      let(:job_class) do
+        p = purpose
+        Class.new(ActiveJob::Base) do
+          with_limit p, max: 4, per: 1.second, wait_timeout: 30.seconds
+
+          define_method(:perform) { :result }
+        end
+      end
+
+      it 'passes the wait_timeout through to within_limit' do
+        job_class.new.perform
+        expect(Delayed::Limit).to have_received(:within_limit)
+          .with(purpose, wait_timeout: 30.seconds).once
+      end
+    end
+
+    context 'when on: is a single method name' do
+      let(:job_class) do
+        p = purpose
+        Class.new(ActiveJob::Base) do
+          with_limit p, max: 4, per: 1.second, on: :do_work
+
+          define_method(:perform) { do_work && dont_do_work }
+          define_method(:do_work) { :result_b }
+          define_method(:dont_do_work) { :result_a }
+        end
+      end
+
+      it 'wraps the specified method with within_limit' do
+        job_class.new.do_work
+        expect(Delayed::Limit).to have_received(:within_limit)
+          .with(purpose, wait_timeout: 5.seconds).once
+      end
+
+      it 'does not add an extra within_limit call when perform delegates to the wrapped method' do
+        job_class.new.perform
+        expect(Delayed::Limit).to have_received(:within_limit).once
+      end
+    end
+
+    context 'when on: is an array of method names' do
+      let(:job_class) do
+        p = purpose
+        Class.new(ActiveJob::Base) do
+          with_limit p, max: 4, per: 1.second, on: %i(do_work_a do_work_b)
+
+          def perform; end
+          define_method(:do_work_a) { :result_a }
+          define_method(:do_work_b) { :result_b }
+        end
+      end
+
+      it 'wraps each named method with within_limit' do
+        job_class.new.tap do |job|
+          job.perform
+          job.do_work_a
+          job.do_work_b
+        end
+        expect(Delayed::Limit).to have_received(:within_limit)
+          .with(purpose, wait_timeout: 5.seconds).twice
+      end
+    end
+
+    context 'when the purpose was registered in advance and no config is given' do
+      before { Delayed::Limit.register!(purpose, max: 4, per: 1.second) }
+
+      let(:job_class) do
+        p = purpose
+        Class.new(ActiveJob::Base) do
+          with_limit p
+
+          define_method(:perform) { :result }
+        end
+      end
+
+      it 'references the registered limit by purpose' do
+        job_class.new.perform
+        expect(Delayed::Limit).to have_received(:within_limit)
+          .with(purpose, wait_timeout: 5.seconds).once
+      end
+    end
+
+    context 'when the config contains an unknown key' do
+      it 'raises ArgumentError' do
+        p = purpose
+        expect {
+          Class.new(ActiveJob::Base) { with_limit p, max: 4, per: 1.second, wait_timout: 1.second }
+        }.to raise_error(ArgumentError, /wait_timout/)
+      end
+    end
+
+    context 'when with_limit is declared multiple times' do
+      let(:other_purpose) { :"#{purpose}_b" }
+
+      let(:job_class) do
+        p = purpose
+        other = other_purpose
+        Class.new(ActiveJob::Base) do
+          with_limit p, max: 4, per: 1.second, wait_timeout: 100.seconds, on: :do_work_a, retry_jitter: 0
+          with_limit other, max: 2, per: 1.minute, wait_timeout: 30.seconds, on: :do_work_b, retry_jitter: 0
+
+          define_method(:perform) { raise Delayed::Limit::LimitExceededError }
+          define_method(:do_work_a) { :result_a }
+          define_method(:do_work_b) { :result_b }
+        end
+      end
+
+      before { stub_const('LimitableMultipleLimitsJob', job_class) }
+
+      it 'registers each limit policy' do
+        job_class
+        expect(Delayed::Limit.limits.fetch(purpose)).to eq(max: 4, per: 1.second)
+        expect(Delayed::Limit.limits.fetch(other_purpose)).to eq(max: 2, per: 1.minute)
+      end
+
+      it 'wraps each method with its own limit' do
+        job_class.new.tap do |job|
+          job.do_work_a
+          job.do_work_b
+        end
+        expect(Delayed::Limit).to have_received(:within_limit)
+          .with(purpose, wait_timeout: 100.seconds).once
+        expect(Delayed::Limit).to have_received(:within_limit)
+          .with(other_purpose, wait_timeout: 30.seconds).once
+      end
+
+      it 'defines only a single retry handler' do
+        handlers = job_class.rescue_handlers.select do |class_name, _|
+          class_name == Delayed::Limit::LimitExceededError.name
+        end
+        expect(handlers.size).to eq(1)
+      end
+
+      it 'retries according to the first declaration (its wait_timeout floors the retry wait)' do
+        job = job_class.new
+        allow(job).to receive(:retry_job)
+        job.perform_now
+        expect(job).to have_received(:retry_job)
+          .with(a_hash_including(wait: 100.seconds))
+      end
+    end
+
+    context 'when included in a plain (non-ActiveJob) class' do
+      let(:klass) do
+        p = purpose
+        Class.new do
+          include Delayed::Limitable
+
+          with_limit p, max: 4, per: 1.second, on: :do_work
+
+          define_method(:do_work) { :result }
+        end
+      end
+
+      it 'wraps the specified method with within_limit' do
+        expect(klass.new.do_work).to eq(:result)
+        expect(Delayed::Limit).to have_received(:within_limit)
+          .with(purpose, wait_timeout: 5.seconds).once
+      end
+
+      it 'registers the limit policy with Delayed::Limit' do
+        klass
+        expect(Delayed::Limit.limits.fetch(purpose)).to eq(max: 4, per: 1.second)
+      end
+
+      it 'leaves LimitExceededError handling to the caller' do
+        allow(Delayed::Limit).to receive(:within_limit).and_raise(Delayed::Limit::LimitExceededError)
+        expect { klass.new.do_work }.to raise_error(Delayed::Limit::LimitExceededError)
+      end
+    end
+  end
+
+  describe 'retry behavior' do
+    let(:job_class) do
+      p = purpose
+      Class.new(ActiveJob::Base) do
+        with_limit p, max: 4, per: 1.second, retry_jitter: 0
+
+        define_method(:perform) { raise Delayed::Limit::LimitExceededError }
+      end
+    end
+
+    before { stub_const('LimitableRetryJob', job_class) }
+
+    it 'retries the job when the limit is exceeded' do
+      job = job_class.new
+      allow(job).to receive(:retry_job)
+      job.perform_now
+      expect(job).to have_received(:retry_job)
+        .with(a_hash_including(wait: a_value > 0, error: an_instance_of(Delayed::Limit::LimitExceededError)))
+    end
+
+    it 'floors the retry wait at the wait_timeout' do
+      job = job_class.new
+      allow(job).to receive(:retry_job)
+      job.perform_now
+      expect(job).to have_received(:retry_job)
+        .with(a_hash_including(wait: 5.seconds))
+    end
+
+    context 'when a custom wait: is specified' do
+      let(:job_class) do
+        p = purpose
+        Class.new(ActiveJob::Base) do
+          with_limit p, max: 4, per: 1.second, retry_wait: ->(_attempts) { 123 }
+
+          define_method(:perform) { raise Delayed::Limit::LimitExceededError }
+        end
+      end
+
+      it 'uses the custom wait' do
+        job = job_class.new
+        allow(job).to receive(:retry_job)
+        job.perform_now
+        expect(job).to have_received(:retry_job)
+          .with(a_hash_including(wait: 123))
+      end
+    end
+
+    context 'when retry_attempts: is specified' do
+      let(:job_class) do
+        p = purpose
+        Class.new(ActiveJob::Base) do
+          with_limit p, max: 4, per: 1.second, retry_attempts: 1
+
+          define_method(:perform) { raise Delayed::Limit::LimitExceededError }
+        end
+      end
+
+      it 'stops retrying once the attempts are exhausted' do
+        job = job_class.new
+        allow(job).to receive(:retry_job)
+        expect { job.perform_now }.to raise_error(Delayed::Limit::LimitExceededError)
+        expect(job).not_to have_received(:retry_job)
+      end
+    end
+  end
+end

data/spec/helper.rb

@@ -73,8 +73,10 @@ Dir['db/migrate/*.rb'].each { |f| require_relative("../#{f}") }
 ActiveRecord::Schema.define do
   if ActiveRecord::VERSION::MAJOR >= 7
     drop_table :delayed_jobs, if_exists: true
-  elsif ActiveRecord::Base.connection.table_exists?(:delayed_jobs)
-    drop_table :delayed_jobs
+    drop_table :delayed_limits, if_exists: true
+  else
+    drop_table :delayed_jobs if ActiveRecord::Base.connection.table_exists?(:delayed_jobs)
+    drop_table :delayed_limits if ActiveRecord::Base.connection.table_exists?(:delayed_limits)
   end
 
   # Let's prove reversibility when we set up our test DB:
@@ -94,6 +96,7 @@ ActiveRecord::Schema.define do
     run_migration(RemoveLegacyIndex)
     run_migration(AddRunAtAndNameNotNullCheck)
     run_migration(ValidateRunAtAndNameNotNull)
+    run_migration(CreateDelayedLimits)
 
     # Test that these index migrations can be re-applied idempotently.
     # (In case identical indexes had been manually applied previously.)
@@ -296,6 +299,8 @@ QueryUnderTest = Struct.new(:sql, :connection) do
       .gsub(/AS ("|`)?(\w+)("|`)?/) { "AS #{Regexp.last_match(2)[0...63]}" }
       # newline and indent when aliased columns are listed
       .gsub(/AS (\w+),/) { "AS #{Regexp.last_match(1)},\n      " }
+      # normalize 'FROM (...) AS' subqueries (changes across Rails versions)
+      .gsub(") AS subquery") { ") subquery" }
       # remove quotes around column names in aggregate functions
       .gsub(/(MIN|MAX|COUNT|SUM)\(("|`)(\w+)("|`)\)/) { "#{Regexp.last_match(1)}(#{Regexp.last_match(3)})" }
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delayed
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 4.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: 2026-07-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -35,6 +34,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +79,7 @@ files:
 - README.md
 - Rakefile
 - app/models/delayed/job.rb
+- app/models/delayed/limit.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
@@ -75,6 +89,7 @@ files:
 - 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
+- db/migrate/10_create_delayed_limits.rb
 - lib/delayed.rb
 - lib/delayed/active_job_adapter.rb
 - lib/delayed/backend/base.rb
@@ -84,6 +99,7 @@ files:
 - lib/delayed/helpers/migration.rb
 - lib/delayed/job_wrapper.rb
 - lib/delayed/lifecycle.rb
+- lib/delayed/limitable.rb
 - lib/delayed/message_sending.rb
 - lib/delayed/monitor.rb
 - lib/delayed/performable_mailer.rb
@@ -112,6 +128,8 @@ files:
 - spec/delayed/active_job_adapter_spec.rb
 - spec/delayed/helpers/migration_spec.rb
 - spec/delayed/job_spec.rb
+- spec/delayed/limit_spec.rb
+- spec/delayed/limitable_spec.rb
 - spec/delayed/monitor_spec.rb
 - spec/delayed/plugins/instrumentation_spec.rb
 - spec/delayed/priority_spec.rb
@@ -134,7 +152,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
@@ -149,8 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key:
+rubygems_version: 4.0.16
 specification_version: 4
 summary: a multi-threaded, SQL-driven ActiveJob backend used at Betterment to process
   millions of background jobs per day
@@ -165,6 +181,8 @@ test_files:
 - spec/delayed/active_job_adapter_spec.rb
 - spec/delayed/helpers/migration_spec.rb
 - spec/delayed/job_spec.rb
+- spec/delayed/limit_spec.rb
+- spec/delayed/limitable_spec.rb
 - spec/delayed/monitor_spec.rb
 - spec/delayed/plugins/instrumentation_spec.rb
 - spec/delayed/priority_spec.rb