sidekiq-transaction_guard 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e78c153bc733cc296bd92ee4ef71be1999660724aed0a4421c68a86bea98233
-  data.tar.gz: '095f61285d5cb8d7aade4f5c343ea7a6d7e3b548a3ec8e6a128dae5e0d64e740'
+  metadata.gz: 5c0d2035a276a481304f3b833e10119704d05583e63eda918a34da4a83823ab1
+  data.tar.gz: beb93e6793e86312f448d536eb4ba51b4b0b5290c5b45ebfe2a5916e37a00b5e
 SHA512:
-  metadata.gz: 386abe0d3a8b40f22358dd7e30bd808a6e9837e5dc0d34731b5693ee8a02375edee77a425c56e97efc3deec356207aaa7b247618ceda42d25d9da9756d653e7f
-  data.tar.gz: c4c88c36fc2b38e6ddbbec3933873f8983ba9a389d9d1554c4913e1ccbf160ba5ab1768a73e3120cb9fca40a92e5dac159518b627452c3ca5eae8fe517ae1453
+  metadata.gz: 1de9763227c618c2ecd3e4c7af601f20db01b388eac1632678ac3521f4b1d7baa93669de29e00d8cfe718a4ef9502967c593e17e4b8fec47f46804b2b9453de2
+  data.tar.gz: 97732ce309894eafc91fa5e4e2f1ff89cee2d1aeb8ed33da0e6e9496e3c635fe724b28c449c7dff54e3d3d16c1568d8b8c64f961466782b5d2643139a98d8594

data/CHANGELOG.md

@@ -4,6 +4,12 @@ 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

data/VERSION

@@ -1 +1 @@
-1.1.2
+1.1.3

data/lib/sidekiq/transaction_guard.rb

@@ -15,6 +15,7 @@ module Sidekiq
     @connection_classes = Set.new
     @notify = nil
     @mode = :warn
+    @testing_context = false
 
     class << self
       VALID_MODES = [:warn, :stderr, :error, :disabled].freeze
@@ -134,11 +135,10 @@ module Sidekiq
       def in_transaction?
         connection_classes.any? do |connection_class|
           connection = active_connection(connection_class)
-          if connection
-            connection.open_transactions > allowed_transaction_level(connection_class)
-          else
-            false
-          end
+          next false unless connection
+
+          connection.open_transactions > allowed_transaction_level(connection_class) &&
+            application_transaction_open?(connection)
         end
       end
 
@@ -194,6 +194,7 @@ module Sidekiq
         var = :sidekiq_rails_transaction_guard
         saved_state = Thread.current[var]
         Thread.current[var] = (saved_state ? saved_state.dup : {})
+        @testing_context = true
         saved_state
       end
 
@@ -242,6 +243,42 @@ module Sidekiq
         (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)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-transaction_guard
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.1.3
 platform: ruby
 authors:
 - Brian Durand