delayed 4.1.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70e3822f06e3d5b6a663f08998abf783ae91137a96cf154dded1487548ab9544
-  data.tar.gz: e166f6ba77ff5e268059dc32de8e72e619b56106e69a96b884c1c5e31e22542a
+  metadata.gz: 7af8a042ab9fe6f3e5bb5709860ab1c7544f5f13124b02cb5d181b9afa378b6d
+  data.tar.gz: c76388de277c68702a51aa8379b83902e9f339ec0444b41e67b663a7d6db76b7
 SHA512:
-  metadata.gz: 86379222dec057f27b106602cc91ce90800861f705e16fb53857590f6b730a6e523780be0eeec09c6a9dd8d9f9b1760b0c15793c73fcfac5173bf2ba17354f4b
-  data.tar.gz: 4ce59e9dbec2d10339cf3979ff5c49a97adc337fba6119d69662e65ff2407f8fc1ab32cac09ab3ad83044e795384f2c36ae478fa5763a3578b87178cdb624123
+  metadata.gz: bd7129db0460a29f3000c630a47b3801b4b57e42de65ac12b3c719e670f48a1d955b7fc714f56dc3b6d269db819393ca562256a1305a25b28bcfa81775db97d8
+  data.tar.gz: 7b81ffcbf2eca36479c7648c8c94a878d5c3c4a2f674a94ffe08f2f6fadf570a2f0c21f997688d24e342d0296a58a9a465fdc9cac6db9c572651dfde3b6b6479

data/README.md

@@ -632,6 +632,18 @@ upserting `RETURNING` clause and database-native timestamp arithmetic. You can c
 connection at runtime with `Delayed::Limit.supported?`. (Attempting to use the limiter on an
 unsupported database will raise `Delayed::Limit::UnsupportedDatabaseError`.)
 
+Additionally, the limiter **must not be called inside an open database
+transaction** (it raises `Delayed::Limit::TransactionOpenError`), because the
+reserved row would stay locked until the transaction commits. If it must run
+inside transactions, give `Delayed::Limit` a connection pool of its own (at the
+cost of up to one extra connection per thread) in a Rails initializer:
+
+```ruby
+Rails.application.config.to_prepare do
+  Delayed::Limit.establish_connection(ActiveRecord::Base.connection_db_config.configuration_hash)
+end
+```
+
 #### Traffic Shaping vs Traffic Enforcement
 
 By default, the limiter will `sleep` up to 5 seconds (or a specified `wait_timeout`) before

data/app/models/delayed/limit.rb

@@ -38,6 +38,10 @@ module Delayed
   #
   # It is **not** recommended to register limits dynamically at runtime, because
   # registered limits are cached indefinitely in memory and are not thread-safe.
+  #
+  # The limiter must not be called inside an open database transaction (it
+  # raises `TransactionOpenError`), because the reserved row would stay locked
+  # until that transaction commits.
   class Limit < ActiveRecord::Base
     self.table_name = 'delayed_limits'
 
@@ -52,6 +56,12 @@ module Delayed
     # (see `.supported?`).
     class UnsupportedDatabaseError < StandardError; end
 
+    # Raised when `.within_limit` is called inside an open database
+    # transaction. The reservation query takes a row lock that would otherwise
+    # be held until the transaction commits, causing lock contention to pile up
+    # behind the caller's (potentially long-running) work.
+    class TransactionOpenError < StandardError; end
+
     class << self
       # Used only for limits registered in advance (via `.register!`):
       def limits
@@ -115,6 +125,11 @@ module Delayed
         # e.g. for a target of 100 req/min, the drain_interval would be 0.6 sec/req.
         drain_interval = config.fetch(:per).seconds / config.fetch(:max).to_d
 
+        if transaction_open?
+          raise TransactionOpenError,
+            'Delayed::Limit.within_limit cannot be called inside a database transaction '
+        end
+
         # Attempt to reserve capacity via an uncached database query:
         limit = connection.uncached do
           find_by_sql(reserve_sql(purpose, drain_interval, wait_timeout.seconds)).first
@@ -144,6 +159,14 @@ module Delayed
 
       private
 
+      # Checks `joinable?` rather than the connection's `transaction_open?` so
+      # that the per-example transaction opened by Rails' transactional tests
+      # (which is non-joinable) does not trip the guard, while any transaction
+      # opened by application code (joinable by default) does.
+      def transaction_open?
+        connection.current_transaction.joinable?
+      end
+
       # We reserve capacity by pushing a 'drained_at' timestamp forward by the
       # drain_interval, returning how long the caller must wait to avoid filling
       # the bucket beyond its capacity. (The WHERE clause significantly reduces

data/lib/delayed/version.rb

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

data/spec/delayed/limit_spec.rb

@@ -3,6 +3,8 @@
 require 'helper'
 
 RSpec::Matchers.define_negated_matcher :not_change, :change
+RSpec::Matchers.define_negated_matcher :not_yield_control, :yield_control
+RSpec::Matchers.define_negated_matcher :not_emit_notification, :emit_notification
 
 RSpec.describe Delayed::Limit do
   before do
@@ -128,6 +130,105 @@ RSpec.describe Delayed::Limit do
       end
     end
 
+    context 'when called inside a database transaction' do
+      it 'raises TransactionOpenError without reserving capacity or yielding' do
+        expect { |b| described_class.transaction { described_class.within_limit(purpose, **limit, &b) } }
+          .to raise_error(described_class::TransactionOpenError, /inside a database transaction/)
+          .and not_change { described_class.count }
+          .and not_yield_control
+      end
+
+      it 'raises before the transaction is materialized (no SQL is sent)' do
+        expect { described_class.transaction { described_class.within_limit(purpose, **limit) { nil } } }
+          .to raise_error(described_class::TransactionOpenError)
+          .and not_emit_notification('sql.active_record')
+      end
+    end
+
+    context 'when the only open transaction is non-joinable' do
+      it 'does not raise, and reserves capacity as usual' do
+        expect { |b| described_class.transaction(joinable: false) { described_class.within_limit(purpose, **limit, &b) } }
+          .to yield_control.once
+
+        expect(described_class.count).to eq(1)
+      end
+
+      it 'still raises when application code opens a nested transaction' do
+        expect { |b| described_class.transaction(joinable: false) { described_class.transaction { described_class.within_limit(purpose, **limit, &b) } } }
+          .to raise_error(described_class::TransactionOpenError)
+          .and not_yield_control
+      end
+    end
+
+    context "under Rails' transactional test harness" do
+      # Opens the per-example transaction the same way ActiveRecord::TestFixtures does
+      # (via the connection pool on Rails 7.2+, and directly on the connection before that).
+      around do |example|
+        pool = described_class.connection_pool
+        if pool.respond_to?(:pin_connection!)
+          pool.pin_connection!(true)
+          begin
+            example.run
+          ensure
+            pool.unpin_connection!
+          end
+        else
+          connection = described_class.connection
+          connection.begin_transaction(joinable: false, _lazy: false)
+          begin
+            example.run
+          ensure
+            connection.rollback_transaction
+          end
+        end
+      end
+
+      it 'does not raise, and reserves capacity as usual' do
+        expect(described_class.connection.transaction_open?).to be(true)
+
+        expect { |b| described_class.within_limit(purpose, **limit, &b) }
+          .to yield_control.once
+
+        expect(described_class.count).to eq(1)
+      end
+
+      it 'still raises when the code under test opens a transaction' do
+        expect { |b| described_class.transaction { described_class.within_limit(purpose, **limit, &b) } }
+          .to raise_error(described_class::TransactionOpenError)
+          .and not_yield_control
+      end
+    end
+
+    context 'when Delayed::Limit has its own connection pool' do
+      around do |example|
+        config = if ActiveRecord::Base.respond_to?(:connection_db_config)
+          ActiveRecord::Base.connection_db_config.configuration_hash
+        else
+          ActiveRecord::Base.connection_config
+        end
+        described_class.establish_connection(config)
+        example.run
+      ensure
+        described_class.remove_connection
+      end
+
+      it 'uses a separate pool from the application' do
+        expect(described_class.connection_pool).not_to equal(ActiveRecord::Base.connection_pool)
+      end
+
+      it 'does not treat a transaction on the application pool as an open transaction' do
+        expect { |b| ActiveRecord::Base.transaction { described_class.within_limit(purpose, **limit, &b) } }
+          .to yield_control.once
+          .and change { described_class.count }.by(1)
+      end
+
+      it 'still raises for a transaction on its own pool' do
+        expect { |b| described_class.transaction { described_class.within_limit(purpose, **limit, &b) } }
+          .to raise_error(described_class::TransactionOpenError)
+          .and not_yield_control
+      end
+    end
+
     context 'with a limit registered in advance via .register!' do
       before { allow(described_class).to receive(:limits).and_return(purpose => limit) }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delayed
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 4.2.0
 platform: ruby
 authors:
 - Nathan Griffith