sidekiq-transaction_guard 1.1.1 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de06ea42809df15bffadb4ee4c00387dbf0dfd8cabb14130b98a0400b4502cee
-  data.tar.gz: fe97b6610a93aacfb5917ea80bdee919b9587d39e92cfe78ef6eddd16e9648ca
+  metadata.gz: 5c0d2035a276a481304f3b833e10119704d05583e63eda918a34da4a83823ab1
+  data.tar.gz: beb93e6793e86312f448d536eb4ba51b4b0b5290c5b45ebfe2a5916e37a00b5e
 SHA512:
-  metadata.gz: 56d18cbdb4a57f1ef5b32f333c30f36ed1c68889b596abaeeb62185264f5cc3cd2ace8d1b01f049183f461649372b7f11d2c1b5c55e1b48fae42a6ba83012f44
-  data.tar.gz: 5125a0ea08ccd991f0386a11e5a32cd63ab70ebe20d2594363fced7c34a37d01debd16c637a3fa8e77eb6821b2009255bac18a58136317c0b24e599e603a75df
+  metadata.gz: 1de9763227c618c2ecd3e4c7af601f20db01b388eac1632678ac3521f4b1d7baa93669de29e00d8cfe718a4ef9502967c593e17e4b8fec47f46804b2b9453de2
+  data.tar.gz: 97732ce309894eafc91fa5e4e2f1ff89cee2d1aeb8ed33da0e6e9496e3c635fe724b28c449c7dff54e3d3d16c1568d8b8c64f961466782b5d2643139a98d8594

data/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 1.1.3
+
+### Fixed
+
+- Transactions opened by the connection pool pinning machinery used by transactional tests in Rails 7.2+ are no longer counted as application transactions. Rails 7.2 pins a single connection wrapped in a non-joinable transaction and shares it with every thread, but the transaction level baseline captured by the test integrations is stored per thread. Threads other than the test runner thread (e.g. Capybara server threads, ActionCable workers, or inline Sidekiq jobs in system tests) had no baseline, so every job they enqueued was falsely flagged as inside a transaction. The allowed transaction level is now derived from the pool's pinned connection state as well, which is visible from all threads. Transactions opened by application code, including non-joinable ones, are still counted. The pinned connection state is only consulted once a test integration has started a testing context, so pinning a connection outside of tests does not bypass the guard.
+
+## 1.1.2
+
+### Fixed
+
+- `Sidekiq::TransactionGuard.init` now registers the client middleware in the Sidekiq server process as well. Previously jobs enqueued from within other jobs bypassed the transaction guard entirely because `Sidekiq.configure_client` is a no-op in server processes.
+- Fixed the Minitest helper so the transaction tracking set up by `Sidekiq::TransactionGuard.testing` remains active for the duration of the test. Previously the testing context was torn down when `setup` returned, so the transaction level snapshot was discarded before the test body ran and tests using transactional fixtures would raise false positive errors on every enqueue. The helper now uses Minitest's `before_setup`/`after_teardown` lifecycle hooks and takes the snapshot after all other setup hooks (including transactional fixtures) have run.
+- The Minitest helper no longer permanently changes the global mode when it is included and no longer defines `setup`/`teardown` methods that could be silently overridden by test classes defining their own.
+- `Sidekiq::TransactionGuard.disable` and the RSpec/Minitest test integrations now use a thread local mode override instead of mutating the global mode. This fixes race conditions where disabling the guard in one thread would disable it for all threads, and where concurrent save/restore of the global mode could leave it in the wrong state.
+- The RSpec integration now registers its per-example hooks at the example group level so the transaction level snapshot is taken after rspec-rails opens the transactional fixture transaction instead of before it.
+- Worker-level `transaction_guard` sidekiq options are now honored when the value is a string as well as a symbol.
+- Connection errors from registered connection classes without an established connection no longer raise from `in_transaction?`.
+- Use `lease_connection` instead of the deprecated `connection` method on ActiveRecord 7.2+.
+
+### Added
+
+- `Sidekiq::TransactionGuard.thread_local_mode` and `thread_local_mode=` to override the mode for the current thread only.
+- `Sidekiq::TransactionGuard.default_mode` to read the globally configured mode, ignoring any thread local override.
+
 ## 1.1.1
 
 ### Changed

data/README.md

@@ -70,9 +70,11 @@ For non-Rails applications, you need to manually add the middleware in your appl
 ```ruby
 require 'sidekiq/transaction_guard'
 
-Sidekiq::TransactionGuard::Middleware.init
+Sidekiq::TransactionGuard.init
 ```
 
+This registers the client middleware for both client processes and the Sidekiq server process, so jobs enqueued from within other jobs are checked as well.
+
 ### Mode
 
 You can set the mode at any time. The mode can be one of `[:warn, :stderr, :error, :disabled]`.
@@ -94,7 +96,13 @@ Sidekiq::TransactionGuard.mode = :disabled
 You can set the mode when initializing the middleware:
 
 ```ruby
-Sidekiq::TransactionGuard::Middleware.init(mode: :error)
+Sidekiq::TransactionGuard.init(mode: :error)
+```
+
+You can also override the mode for the current thread only. This does not affect jobs being enqueued concurrently in other threads. Set it to `nil` to remove the override.
+
+```ruby
+Sidekiq::TransactionGuard.thread_local_mode = :disabled
 ```
 
 You can also set the mode on individual worker classes with `sidekiq_options transaction_guard: mode`. The worker-specific mode will override the global mode.
@@ -175,7 +183,9 @@ If you're using RSpec, you can use the built-in RSpec helper to automatically se
 require 'sidekiq/transaction_guard/rspec'
 ```
 
-This will also add support for adding a metadata tag to your specs to control the transaction guard mode on a per-spec basis. For example:
+Require this file after `rspec-rails` (or anything else that opens transactions in its setup hooks) so that the transaction level snapshot is taken after those transactions are opened.
+
+Examples run with the `:error` mode by default. You can control the mode on a per-spec basis with a metadata tag. The value can be a mode symbol, `false` to disable the guard, or `:default` to use the globally configured mode. For example:
 
 ```ruby
 RSpec.describe "Some feature", sidekiq_transaction_guard: :disabled do
@@ -203,7 +213,7 @@ If you're using Minitest with `ActiveSupport::TestCase` (Rails default), you can
 require 'sidekiq/transaction_guard/minitest'
 ```
 
-This will automatically wrap each test in the appropriate `testing` block and handle transactional fixtures.
+Tests run with the `:error` mode. The guard is disabled while `setup do` callbacks and teardown hooks run, and the transaction level snapshot is taken after all other setup hooks (including transactional fixtures) have completed.
 
 If you're using plain Minitest (without `ActiveSupport::TestCase`), you can manually include the helper module:
 
@@ -223,7 +233,7 @@ Alternatively, you can manually use the `testing` method with minitest-hooks:
 class MyTests < Minitest::Test
   # Using minitest-hooks gem
   def around(&block)
-    Sidekiq::TransactionGuard.testing(base_transaction_level: 1) do
+    Sidekiq::TransactionGuard.testing do
       block.call
     end
   end
@@ -240,6 +250,8 @@ Sidekiq::TransactionGuard.disable do
 end
 ```
 
+The guard is only disabled for the current thread, so jobs enqueued concurrently in other threads are still checked.
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/VERSION

@@ -1 +1 @@
-1.1.1
+1.1.3

data/lib/sidekiq/transaction_guard/middleware.rb

@@ -24,7 +24,9 @@ module Sidekiq
       private
 
       def worker_mode(job)
-        read_sidekiq_option(job, :transaction_guard) || Sidekiq::TransactionGuard.mode
+        mode = read_sidekiq_option(job, :transaction_guard)
+        mode = mode.to_sym if mode.is_a?(String)
+        mode || Sidekiq::TransactionGuard.mode
       end
 
       def in_transaction?
@@ -47,7 +49,6 @@ module Sidekiq
       end
 
       def read_sidekiq_option(job, option_name)
-        # options = worker_class.sidekiq_options_hash
         job[option_name.to_s]
       end
 

data/lib/sidekiq/transaction_guard/minitest.rb

@@ -2,12 +2,22 @@
 
 require "minitest"
 
+require "sidekiq/transaction_guard"
+
 module Sidekiq
   module TransactionGuard
     # Minitest helper module for testing with Sidekiq::TransactionGuard.
     #
-    # Include this module in your test class to automatically wrap tests in the
-    # Sidekiq::TransactionGuard.testing block and handle transactional fixtures.
+    # Include this module in your test class to automatically set up transaction
+    # tracking for each test. If `ActiveSupport::TestCase` is defined when this
+    # file is required, the module is included there automatically.
+    #
+    # The integration uses Minitest's `before_setup`/`after_teardown` lifecycle
+    # hooks. The transaction level snapshot is taken after all other setup hooks
+    # have run (including transactional fixtures), so transactions opened by test
+    # setup are ignored, and the snapshot stays in effect for the entire test.
+    # The guard runs in `:error` mode during the test and is disabled while
+    # setup and teardown hooks run.
     #
     # @example
     #   class MyTest < Minitest::Test
@@ -18,46 +28,41 @@ module Sidekiq
     #     end
     #   end
     module MinitestHelper
-      def self.included(base)
-        base.class_eval do
-          # Save the original mode before the test suite runs
-          @@sidekiq_transaction_guard_mode = Sidekiq::TransactionGuard.mode
-          Sidekiq::TransactionGuard.mode = :disabled
+      def before_setup
+        @sidekiq_transaction_guard_saved_mode = Sidekiq::TransactionGuard.thread_local_mode
+        @sidekiq_transaction_guard_saved_state = Sidekiq::TransactionGuard.begin_testing
+        # Keep the guard disabled while other before_setup hooks (like
+        # transactional fixtures) and setup callbacks run.
+        Sidekiq::TransactionGuard.thread_local_mode = :disabled
+        super
+        # Take the snapshot now that all other setup hooks have run so that
+        # transactions opened during setup are treated as the baseline.
+        Sidekiq::TransactionGuard.set_allowed_transaction_level(:all)
+        Sidekiq::TransactionGuard.thread_local_mode = :error
+      end
 
-          def setup
-            @sidekiq_transaction_guard_saved_mode = Sidekiq::TransactionGuard.mode
-            Sidekiq::TransactionGuard.mode = :error
-            Sidekiq::TransactionGuard.testing do
-              @sidekiq_transaction_guard_testing_block = true
-              super
-            end
-          end
+      def before_teardown
+        Sidekiq::TransactionGuard.thread_local_mode = :disabled
+        super
+      end
 
-          def teardown
-            super
-            Sidekiq::TransactionGuard.mode = @sidekiq_transaction_guard_saved_mode
-          end
+      def after_teardown
+        super
+      ensure
+        if defined?(@sidekiq_transaction_guard_saved_state)
+          Sidekiq::TransactionGuard.end_testing(@sidekiq_transaction_guard_saved_state)
+        end
+        if defined?(@sidekiq_transaction_guard_saved_mode)
+          Sidekiq::TransactionGuard.thread_local_mode = @sidekiq_transaction_guard_saved_mode
         end
       end
     end
   end
 end
 
-# If using ActiveSupport::TestCase, automatically include the helper
+# If using ActiveSupport::TestCase, automatically include the helper.
 if defined?(ActiveSupport::TestCase)
-  ActiveSupport::TestCase.class_eval do
-    def setup
-      @sidekiq_transaction_guard_saved_mode = Sidekiq::TransactionGuard.mode
-      Sidekiq::TransactionGuard.mode = :error
-
-      Sidekiq::TransactionGuard.testing do
-        super
-      end
-    end
-
-    def teardown
-      super
-      Sidekiq::TransactionGuard.mode = @sidekiq_transaction_guard_saved_mode
-    end
-  end
+  # Included with `send` so that YARD doesn't try to statically resolve the
+  # ActiveSupport::TestCase namespace when generating documentation.
+  ActiveSupport::TestCase.send(:include, Sidekiq::TransactionGuard::MinitestHelper)
 end

data/lib/sidekiq/transaction_guard/rspec.rb

@@ -1,46 +1,84 @@
 # frozen_string_literal: true
 
-RSpec.configure do |config|
-  global_sidekiq_transaction_guard_mode = nil
+require "sidekiq/transaction_guard"
+
+module Sidekiq
+  module TransactionGuard
+    # RSpec integration. Requiring this file wraps every example in a
+    # `Sidekiq::TransactionGuard.testing` block and manages the transaction guard
+    # mode with a thread local override so parallel test threads can't interfere
+    # with each other.
+    #
+    # The per example mode can be controlled with the `:sidekiq_transaction_guard`
+    # metadata tag. The value can be a mode symbol, `false` to disable the guard,
+    # or `:default` to use the globally configured mode. Untagged examples run
+    # with the `:error` mode.
+    #
+    # This file should be required after rspec-rails (or any other library that
+    # opens transactions in its setup hooks) so that the transaction level
+    # snapshot taken before each example runs after those transactions are opened.
+    #
+    # @api private
+    module RSpecIntegration
+      def self.included(example_group)
+        # Nested example groups inherit hooks from their parent group, so only
+        # register the hooks on the outermost group that includes this module.
+        return if example_group.is_a?(Class) && example_group.superclass.include?(RSpecIntegration)
+
+        # These are registered as group level hooks so they run after hooks added
+        # by modules included earlier — in particular after rspec-rails has opened
+        # the transactional fixture transaction — so the snapshot taken here
+        # treats transactions opened by test setup as the baseline.
+        example_group.before do |example|
+          Sidekiq::TransactionGuard::RSpecIntegration.apply_example_mode(example)
+          Sidekiq::TransactionGuard.set_allowed_transaction_level(:all)
+        end
+
+        example_group.after do
+          # Disable the guard before fixture rollback and other teardown hooks run.
+          Sidekiq::TransactionGuard.thread_local_mode = :disabled
+        end
+      end
+
+      def self.apply_example_mode(example)
+        metadata = example.metadata
+        if metadata.key?(:sidekiq_transaction_guard)
+          mode = metadata[:sidekiq_transaction_guard]
+          mode = :disabled if mode == false
+          mode = nil if mode == :default
+          mode = :error unless mode.nil? || mode.is_a?(Symbol)
+          Sidekiq::TransactionGuard.thread_local_mode = mode
+        elsif Sidekiq::TransactionGuard.thread_local_mode == :disabled
+          # Apply the default mode only if an earlier hook hasn't already set one.
+          Sidekiq::TransactionGuard.thread_local_mode = :error
+        end
+      end
+    end
+  end
+end
 
-  # Disable by default to avoid raising errors in test setup and teardown.
+RSpec.configure do |config|
+  # Disable the guard for code running outside of examples, such as suite level
+  # setup and teardown.
   config.before(:suite) do
-    global_sidekiq_transaction_guard_mode = Sidekiq::TransactionGuard.mode
-    Sidekiq::TransactionGuard.mode = :disabled
+    Sidekiq::TransactionGuard.thread_local_mode = :disabled
   end
 
   config.after(:suite) do
-    Sidekiq::TransactionGuard.mode = global_sidekiq_transaction_guard_mode
+    Sidekiq::TransactionGuard.thread_local_mode = nil
   end
 
-  # Wrap each example in a block that sets up the testing block.
+  # Wrap each example in a testing block and keep the guard disabled except
+  # while the example itself is running.
   config.around do |example|
-    save_val = Sidekiq::TransactionGuard.mode
+    saved_mode = Sidekiq::TransactionGuard.thread_local_mode
     begin
-      # Set mode to disabled to avoid errors in setup and teardown.
-      Sidekiq::TransactionGuard.mode = :disabled
-      Sidekiq::TransactionGuard.testing do
-        example.run
-      end
+      Sidekiq::TransactionGuard.thread_local_mode = :disabled
+      Sidekiq::TransactionGuard.testing { example.run }
     ensure
-      Sidekiq::TransactionGuard.mode = save_val
+      Sidekiq::TransactionGuard.thread_local_mode = saved_mode
     end
   end
 
-  # Re-snapshot the allowed transaction level after all setup (including
-  # transactional fixtures) has run so that setup transactions are ignored.
-  config.before(:each) do |example|
-    mode = example.metadata[:sidekiq_transaction_guard]
-    mode = :disabled if mode == false
-    mode = global_sidekiq_transaction_guard_mode if mode == :default
-    mode = :error unless mode.is_a?(Symbol)
-    Sidekiq::TransactionGuard.mode = mode if Sidekiq::TransactionGuard.mode == :disabled
-
-    Sidekiq::TransactionGuard.set_allowed_transaction_level(:all)
-  end
-
-  # Restore the disabled mode after example so test teardown doesn't raise errors about transaction levels.
-  config.after(:each) do
-    Sidekiq::TransactionGuard.mode = :disabled
-  end
+  config.include Sidekiq::TransactionGuard::RSpecIntegration
 end

data/lib/sidekiq/transaction_guard.rb

@@ -15,22 +15,27 @@ module Sidekiq
     @connection_classes = Set.new
     @notify = nil
     @mode = :warn
+    @testing_context = false
 
     class << self
       VALID_MODES = [:warn, :stderr, :error, :disabled].freeze
 
-      # Helper method to add the client middleware to Sidekiq.
+      # Initialize Sidekiq::TransactionGuard by adding its client middleware to
+      # Sidekiq. The middleware is added to both the client and server
+      # configurations since jobs can also be enqueued from within other jobs
+      # running in the Sidekiq server process.
       #
+      # @param mode [Symbol, nil] optionally set the global mode (see `mode=`)
       # @return [void]
       def init(mode: nil)
         self.mode = mode if mode
 
         Sidekiq.configure_client do |config|
-          config.client_middleware do |chain|
-            unless chain.exists?(Sidekiq::TransactionGuard::Middleware)
-              chain.add Sidekiq::TransactionGuard::Middleware
-            end
-          end
+          add_client_middleware(config)
+        end
+
+        Sidekiq.configure_server do |config|
+          add_client_middleware(config)
         end
       end
 
@@ -46,16 +51,48 @@ module Sidekiq
       # @return [Symbol] the mode that was set
       def mode=(symbol)
         if VALID_MODES.include?(symbol)
-          @mode = symbol
+          @lock.synchronize { @mode = symbol }
         else
           raise ArgumentError.new("mode must be one of #{VALID_MODES.inspect}")
         end
       end
 
-      # Return the current mode.
+      # Return the mode in effect for the current thread. This is the thread local
+      # mode if one has been set, otherwise the global mode.
       #
       # @return [Symbol]
-      attr_reader :mode
+      def mode
+        thread_local_mode || default_mode
+      end
+
+      # Return the globally configured mode, ignoring any thread local override.
+      #
+      # @return [Symbol]
+      def default_mode
+        @lock.synchronize { @mode }
+      end
+
+      # Set a mode override for the current thread only. This is used by `disable`
+      # and the test integrations so that changing the mode in one thread cannot
+      # affect jobs being enqueued concurrently in other threads. Set to `nil` to
+      # remove the override and fall back to the global mode.
+      #
+      # @param symbol [Symbol, nil] one of `:warn`, `:stderr`, `:error`, `:disabled`, or nil
+      # @return [Symbol, nil] the mode that was set
+      def thread_local_mode=(symbol)
+        if symbol.nil? || VALID_MODES.include?(symbol)
+          Thread.current[:sidekiq_transaction_guard_mode] = symbol
+        else
+          raise ArgumentError.new("mode must be one of #{VALID_MODES.inspect}")
+        end
+      end
+
+      # Return the mode override for the current thread, or nil if none is set.
+      #
+      # @return [Symbol, nil]
+      def thread_local_mode
+        Thread.current[:sidekiq_transaction_guard_mode]
+      end
 
       # Define the global notify block. This block will be called with a Sidekiq
       # job hash for all jobs enqueued inside transactions if the mode is `:warn`
@@ -64,14 +101,14 @@ module Sidekiq
       # @yield [Hash] the Sidekiq job hash
       # @return [void]
       def notify(&block)
-        @notify = block
+        @lock.synchronize { @notify = block }
       end
 
       # Return the block set as the notify handler with a call to `notify`.
       #
       # @return [Proc, nil] the notify block, or nil if none has been set
       def notify_block
-        @notify
+        @lock.synchronize { @notify }
       end
 
       # Add a class that maintains its own connection pool to the connections
@@ -97,28 +134,29 @@ module Sidekiq
       # @return [Boolean]
       def in_transaction?
         connection_classes.any? do |connection_class|
-          connection_pool = connection_class.connection_pool
-          connection = connection_class.connection if connection_pool.active_connection?
-          if connection
-            connection.open_transactions > allowed_transaction_level(connection_class)
-          else
-            false
-          end
+          connection = active_connection(connection_class)
+          next false unless connection
+
+          connection.open_transactions > allowed_transaction_level(connection_class) &&
+            application_transaction_open?(connection)
         end
       end
 
       # Disable the transaction guard within the provided block. This is useful in test environments when you want to
       # setup data for your tests without worrying about transaction levels.
       #
+      # The guard is only disabled for the current thread so that jobs enqueued
+      # concurrently in other threads are still checked.
+      #
       # @yield the block to execute with the transaction guard disabled
       # @return [Object] the return value of the block
       def disable
-        save_mode = mode
+        save_mode = thread_local_mode
         begin
-          self.mode = :disabled
+          self.thread_local_mode = :disabled
           yield
         ensure
-          self.mode = save_mode
+          self.thread_local_mode = save_mode
         end
       end
 
@@ -130,17 +168,45 @@ module Sidekiq
       # @yield the test block to execute
       # @return [Object] the return value of the block
       def testing
-        var = :sidekiq_rails_transaction_guard
-        save_val = Thread.current[var]
+        saved_state = begin_testing
         begin
-          Thread.current[var] = (save_val ? save_val.dup : {})
           set_allowed_transaction_level(:all)
           yield
         ensure
-          Thread.current[var] = save_val
+          end_testing(saved_state)
         end
       end
 
+      # Start a testing context on the current thread without a block. This is used
+      # by test framework integrations (like the Minitest helper) that cannot wrap
+      # the entire test in a single block. Use `testing` instead whenever a block
+      # can be used. The returned state must be passed to `end_testing` when the
+      # test finishes.
+      #
+      # This method only allocates the transaction tracking state; it does not
+      # capture a transaction level baseline. The caller is responsible for calling
+      # `set_allowed_transaction_level` once any setup that opens transactions
+      # (e.g. transactional fixtures) has run.
+      #
+      # @api private
+      # @return [Object] opaque saved state to pass to `end_testing`
+      def begin_testing
+        var = :sidekiq_rails_transaction_guard
+        saved_state = Thread.current[var]
+        Thread.current[var] = (saved_state ? saved_state.dup : {})
+        @testing_context = true
+        saved_state
+      end
+
+      # End a testing context started with `begin_testing`.
+      #
+      # @api private
+      # @param saved_state [Object] the state returned by `begin_testing`
+      # @return [void]
+      def end_testing(saved_state)
+        Thread.current[:sidekiq_rails_transaction_guard] = saved_state
+      end
+
       # This method needs to be called to set the allowed transaction level for a connection
       # class (see `add_connection_class` for more info). The current transaction level
       # for that class's connection will be set as the zero point. This method can only
@@ -161,7 +227,11 @@ module Sidekiq
 
         connection_classes = self.connection_classes if connection_classes == :all
         Array(connection_classes).each do |connection_class|
-          class_count = connection_class.connection.open_transactions + base_transaction_level
+          class_count = begin
+            lease_connection(connection_class).open_transactions + base_transaction_level
+          rescue ActiveRecord::ConnectionNotEstablished
+            base_transaction_level
+          end
           connection_counts[connection_class.name] = class_count
         end
       end
@@ -172,6 +242,71 @@ module Sidekiq
         connection_counts = Thread.current[:sidekiq_rails_transaction_guard]
         (connection_counts && connection_counts[connection_class.name]) || 0
       end
+
+      # Return true if the connection has any open transaction that was not opened by
+      # the connection pool pinning machinery (Rails 7.2+). Transactional tests pin a
+      # connection and wrap it in a non-joinable transaction that the pool then shares
+      # with every thread. Those wrapper transactions are test scaffolding, not
+      # application transactions, so they never count against the guard. The pin state
+      # is read from the pool rather than from a thread local so that threads without a
+      # baseline (e.g. web server threads in system tests) get the correct level.
+      def application_transaction_open?(connection)
+        return true unless @testing_context
+        return true unless connection.respond_to?(:pinned)
+
+        # The pool changes the pin state under the connection lock. Hold it so the
+        # transaction count and the pin state cannot be read from different states.
+        connection.lock.synchronize do
+          next true unless connection.pinned
+
+          open_transactions = connection.open_transactions
+          open_transactions > pinned_transaction_count(connection, open_transactions)
+        end
+      end
+
+      # Return the number of open transactions on a pinned connection that belong to
+      # the pinning machinery. The pool counts pins rather than transactions, so the
+      # count is only trusted as far as the connection state supports it: it can never
+      # exceed the open transactions, and if it accounts for all of them then the
+      # innermost one must be non-joinable, since the wrappers always are. Anything
+      # else means the wrappers were closed outside of the pinning machinery and
+      # nothing should be discounted.
+      def pinned_transaction_count(connection, open_transactions)
+        depth = connection.pool.instance_variable_get(:@pinned_connections_depth).to_i
+        depth = open_transactions if depth > open_transactions
+        return 0 if depth == open_transactions && connection.current_transaction.joinable?
+
+        depth
+      end
+
+      def add_client_middleware(config)
+        config.client_middleware do |chain|
+          unless chain.exists?(Sidekiq::TransactionGuard::Middleware)
+            chain.add Sidekiq::TransactionGuard::Middleware
+          end
+        end
+      end
+
+      # Return the connection for the class only if the current thread already has
+      # one checked out. Checking out a new connection here would be pointless (a
+      # freshly checked out connection can't be inside an application transaction)
+      # and would tie up connections from pools the code isn't even using.
+      def active_connection(connection_class)
+        connection = nil
+        pool = connection_class.connection_pool
+        connection = lease_connection(connection_class) if pool.active_connection?
+        connection
+      rescue ActiveRecord::ConnectionNotEstablished
+        nil
+      end
+
+      def lease_connection(connection_class)
+        if connection_class.respond_to?(:lease_connection)
+          connection_class.lease_connection
+        else
+          connection_class.connection
+        end
+      end
     end
   end
 end
@@ -181,6 +316,7 @@ if defined?(Rails::Railtie)
 end
 
 # Configure the default transaction guard mode for known testing environments.
+# In a Rails application the Railtie initializer will override this default.
 if ENV["RAILS_ENV"] == "test" || ENV["RACK_ENV"] == "test"
   Sidekiq::TransactionGuard.mode = :stderr
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-transaction_guard
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.3
 platform: ruby
 authors:
 - Brian Durand
@@ -94,7 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Protect from accidentally invoking Sidekiq jobs when there are open database
   transactions