active_record_proxy_adapters 0.4.2 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1dbad1d7e12818f5671c53475572a48f6ad2645ac528410d96dd851760cce2f5
-  data.tar.gz: 51d8be8b3b36f5c7590d7d804427fdad95d4753c66cee3c3453fafb17d68c36c
+  metadata.gz: b3d41a4a59d8c5917bdbc07a02c626f6e0f028b1fac534a436ec114816902c4a
+  data.tar.gz: c0a14e90a707f6ffdaf2e0f67443a880de96c6bb3278795677dd47258c07bf26
 SHA512:
-  metadata.gz: ccb3f7e1347e7d21a79c36fbf39740f58188d215b7929b2e1926cbe7142bd5f97afebf2ddbc0cfbdf0a8dd4536d18f1586f3f63464b8f3fde096545eb0696431
-  data.tar.gz: 3e9646ced949036ef60f27e0dd2dbf973e75f81efc1be3be90cbb6713b7647b74b1ba2d993d8edd448a0709fae7c70ed7c6d9f68041f2ed34d7b53d54ccbb759
+  metadata.gz: a89e0589e582bc2ed1da956640bf3c1455e14ae4d712684adad898c7c2eb00c6b297cf5f0dd0184a1fc70c9642814d130749a3c2352480790fba4f0574c89ffe
+  data.tar.gz: 2f9dc79dad11c1469ff3fb04e1a201f6f746206714a49a03d9e15e501cade1878b0959ddeb80f02b6538d340a8af911f20588a93d251e87ee77ca120e9f97186

data/README.md

@@ -246,9 +246,6 @@ Since Rails already leases exactly one connection per thread from the pool and t
 
 As long as you're not writing thread unsafe code that handles connections from the pool directly, or you don't have any other gem depenencies that write thread unsafe pool operations, you're all set.
 
-There is, however, an open bug in `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter` for Rails versions 7.1 and greater that can cause random race conditions, but it's not caused by this gem (More info [here](https://github.com/rails/rails/issues/51780)).
-Rails 7.0 works as expected.
-
 Multi-threaded queries example:
 ```ruby
 # app/models/application_record.rb

data/lib/active_record/connection_adapters/mysql2_proxy_adapter.rb

@@ -15,7 +15,7 @@ module ActiveRecord
 
       ADAPTER_NAME = "Mysql2Proxy"
 
-      delegate_to_proxy :execute, :exec_query
+      delegate_to_proxy(*ActiveRecordProxyAdapters::ActiveRecordContext.hijackable_methods)
 
       def initialize(...)
         @proxy = ActiveRecordProxyAdapters::Mysql2Proxy.new(self)

data/lib/active_record/connection_adapters/postgresql_proxy_adapter.rb

@@ -15,7 +15,7 @@ module ActiveRecord
 
       ADAPTER_NAME = "PostgreSQLProxy"
 
-      delegate_to_proxy :execute, :exec_query
+      delegate_to_proxy(*ActiveRecordProxyAdapters::ActiveRecordContext.hijackable_methods)
 
       unless ActiveRecordProxyAdapters::ActiveRecordContext.active_record_v8_0_or_greater?
         delegate_to_proxy :exec_no_cache, :exec_cache

data/lib/active_record/connection_adapters/trilogy_proxy_adapter.rb

@@ -15,7 +15,7 @@ module ActiveRecord
 
       ADAPTER_NAME = "TrilogyProxy"
 
-      delegate_to_proxy :execute, :exec_query
+      delegate_to_proxy(*ActiveRecordProxyAdapters::ActiveRecordContext.hijackable_methods)
 
       def initialize(...)
         @proxy = ActiveRecordProxyAdapters::TrilogyProxy.new(self)

data/lib/active_record_proxy_adapters/active_record_context.rb

@@ -23,6 +23,8 @@ module ActiveRecordProxyAdapters
     end
 
     def connection_class_for(connection)
+      return connection.connection_descriptor.name.constantize if active_record_v8_0_2_or_greater?
+
       connection.connection_class || ActiveRecord::Base
     end
 
@@ -33,6 +35,18 @@ module ActiveRecordProxyAdapters
       ActiveRecord
     end
 
+    def hijackable_methods
+      hijackable = %i[execute exec_query]
+
+      hijackable << :internal_exec_query if active_record_v8_0_or_greater?
+
+      hijackable
+    end
+
+    def active_record_v7?
+      active_record_version >= Gem::Version.new("7.0") && active_record_version < Gem::Version.new("8.0")
+    end
+
     def active_record_v7_1_or_greater?
       active_record_version >= Gem::Version.new("7.1")
     end
@@ -44,5 +58,9 @@ module ActiveRecordProxyAdapters
     def active_record_v8_0_or_greater?
       active_record_version >= Gem::Version.new("8.0")
     end
+
+    def active_record_v8_0_2_or_greater?
+      active_record_version >= Gem::Version.new("8.0.2")
+    end
   end
 end

data/lib/active_record_proxy_adapters/configuration.rb

@@ -11,19 +11,21 @@ module ActiveRecordProxyAdapters
     LOG_SUBSCRIBER_REPLICA_PREFIX = proc { |event| "#{event.payload[:connection].class::ADAPTER_NAME} Replica" }.freeze
 
     # @return [ActiveSupport::Duration] How long the proxy should reroute all read requests to the primary database
-    #   since the latest write. Defaults to PROXY_DELAY.
-    attr_accessor :proxy_delay
+    #   since the latest write. Defaults to PROXY_DELAY. Thread safe.
+    attr_reader :proxy_delay
     # @return [ActiveSupport::Duration] How long the proxy should wait for a connection from the replica pool.
-    #   Defaults to CHECKOUT_TIMEOUT.
-    attr_accessor :checkout_timeout
+    #   Defaults to CHECKOUT_TIMEOUT. Thread safe.
+    attr_reader :checkout_timeout
 
-    # @return [Proc] Prefix for the log subscriber when the primary database is used.
+    # @return [Proc] Prefix for the log subscriber when the primary database is used. Thread safe.
     attr_reader :log_subscriber_primary_prefix
 
-    # @return [Proc] Prefix for the log subscriber when the replica database is used.
+    # @return [Proc] Prefix for the log subscriber when the replica database is used. Thread safe.
     attr_reader :log_subscriber_replica_prefix
 
     def initialize
+      @lock = Monitor.new
+
       self.proxy_delay                   = PROXY_DELAY
       self.checkout_timeout              = CHECKOUT_TIMEOUT
       self.log_subscriber_primary_prefix = LOG_SUBSCRIBER_PRIMARY_PREFIX
@@ -31,11 +33,45 @@ module ActiveRecordProxyAdapters
     end
 
     def log_subscriber_primary_prefix=(prefix)
-      @log_subscriber_primary_prefix = prefix.is_a?(Proc) ? prefix : proc { prefix.to_s }
+      prefix_proc = prefix.is_a?(Proc) ? prefix : proc { prefix.to_s }
+
+      synchronize_update(:log_subscriber_primary_prefix, from: @log_subscriber_primary_prefix, to: prefix_proc) do
+        @log_subscriber_primary_prefix = prefix_proc
+      end
     end
 
     def log_subscriber_replica_prefix=(prefix)
-      @log_subscriber_replica_prefix = prefix.is_a?(Proc) ? prefix : proc { prefix.to_s }
+      prefix_proc = prefix.is_a?(Proc) ? prefix : proc { prefix.to_s }
+
+      synchronize_update(:log_subscriber_replica_prefix, from: @log_subscriber_replica_prefix, to: prefix_proc) do
+        @log_subscriber_replica_prefix = prefix_proc
+      end
+    end
+
+    def proxy_delay=(proxy_delay)
+      synchronize_update(:proxy_delay, from: @proxy_delay, to: proxy_delay) do
+        @proxy_delay = proxy_delay
+      end
+    end
+
+    def checkout_timeout=(checkout_timeout)
+      synchronize_update(:checkout_timeout, from: @checkout_timeout, to: checkout_timeout) do
+        @checkout_timeout = checkout_timeout
+      end
+    end
+
+    private
+
+    def synchronize_update(attribute, from:, to:, &block)
+      ActiveSupport::Notifications.instrument(
+        "active_record_proxy_adapters.configuration_update",
+        attribute:,
+        who: Thread.current,
+        from:,
+        to:
+      ) do
+        @lock.synchronize(&block)
+      end
     end
   end
 end

data/lib/active_record_proxy_adapters/primary_replica_proxy.rb

@@ -30,7 +30,7 @@ module ActiveRecordProxyAdapters
                                 /DROP\s/i].map(&:freeze).freeze
 
     # Abstract adapter methods that should be proxied.
-    hijack_method :execute, :exec_query
+    hijack_method(*ActiveRecordContext.hijackable_methods)
 
     def self.hijacked_methods
       @hijacked_methods.to_a
@@ -50,6 +50,22 @@ module ActiveRecordProxyAdapters
     delegate :connection_handler, to: :connection_class
     delegate :reading_role, :writing_role, to: :active_record_context
 
+    # We need to call .verify! to ensure `configure_connection` is called on the instance before attempting to use it.
+    # This is necessary because the connection may have been lazily initialized and is an unintended side effect from a
+    # change in Rails to defer connection verification: https://github.com/rails/rails/pull/44576
+    # verify! cannot be called before the object is initialized and because of how the proxy hooks into the connection
+    # instance, it has to be done lazily (hence the memoization). Ideally, we shouldn't have to worry about this at all
+    # But there is tight coupling between methods in ActiveRecord::ConnectionAdapters::AbstractAdapter and
+    # its descendants which will require significant refactoring to be decoupled.
+    # See https://github.com/rails/rails/issues/51780
+    def verified_primary_connection
+      @verified_primary_connection ||= begin
+        connected_to(role: writing_role) { primary_connection.verify! }
+
+        primary_connection
+      end
+    end
+
     def replica_pool_unavailable?
       !replica_pool
     end
@@ -120,7 +136,8 @@ module ActiveRecordProxyAdapters
     end
 
     def connection_for(role, sql_string)
-      connection = primary_connection if role == writing_role || replica_pool_unavailable?
+      connection = verified_primary_connection if role == writing_role || replica_pool_unavailable?
+
       connection ||= checkout_replica_connection
 
       result = connected_to(role:) { yield connection }

data/lib/active_record_proxy_adapters/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordProxyAdapters
-  VERSION = "0.4.2"
+  VERSION = "0.4.4"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active_record_proxy_adapters
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.4
 platform: ruby
 authors:
 - Matt Cruz
 bindir: exe
 cert_chain: []
-date: 2025-02-25 00:00:00.000000000 Z
+date: 2025-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord