active_record_proxy_adapters 0.4.3 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 299fa220d8633ce3fe600183dd0dfa78232a48500b8d45fb39f74d15a48189ad
-  data.tar.gz: 9436980b06fadd82948a0d4110c00490fd32d61512ecb9fee07eb94c7c2dd22a
+  metadata.gz: 5c60e5b3ab2242f3c816eeefd49bbb4db18d039b9dd958cc6f356820434f9625
+  data.tar.gz: 995f0698c350be766b1b6ae83061187a4e2a76a5cd1f6a6bb3b76f4df06a0fd5
 SHA512:
-  metadata.gz: 0fb16ad43cbbfc1053e3b5d82ac856f5f490712a2415b5b85c348a27e87a831ebf72ea212ac5e4b453bcb762e7affb999758c2af4e4334fe6395cb8dc7959a5c
-  data.tar.gz: 32204c72f50b05e5a5a1babb7c478b9c871591b9294744e00c1459657f8aedcf1f1ebde239314515a65769986825d7682bc3e3975c1a44e7e1f54a52f1c96c1a
+  metadata.gz: 438d205bc160dfa52773b8048c9057dbf7b564d26927cb25a25ef470ed9a3cd5fe579acb067aa64cc12eeb7a02fa003ce0b75f2e7dd8093349d4925dac970cd0
+  data.tar.gz: dc0fb03f548118d1475f9fa5a94187b1d31dbaec66ebafef5d906d59597d116cceb4ec31ee25be61f2499cbefb2b6ba46a67c81d0a59f0e0a399f5cb26550932

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

@@ -18,19 +18,30 @@ module ActiveRecordProxyAdapters
       /\A\s*select.+for update\Z/i, /select.+lock in share mode\Z/i,
       /\A\s*select.+(nextval|currval|lastval|get_lock|release_lock|pg_advisory_lock|pg_advisory_unlock)\(/i
     ].map(&:freeze).freeze
+
+    CTE_MATCHER = /\A\s*WITH\s+(?<CTE>\S+\s+AS\s+\(\s?[\s\S]*\))/i
     # All queries that match these patterns should be sent to the replica database
-    SQL_REPLICA_MATCHERS     = [/\A\s*(select|with\s[\s\S]*\)\s*select)\s/i].map(&:freeze).freeze
+    SQL_REPLICA_MATCHERS = [
+      /\A\s*(select)\s/i,
+      /#{CTE_MATCHER.source}\s*select/i
+    ].map(&:freeze).freeze
     # All queries that match these patterns should be sent to all databases
     SQL_ALL_MATCHERS         = [/\A\s*set\s/i].map(&:freeze).freeze
     # Local sets queries should not be sent to all datbases
     SQL_SKIP_ALL_MATCHERS    = [/\A\s*set\s+local\s/i].map(&:freeze).freeze
     # These patterns define which database statments are considered write statments, so we can shortly re-route all
     # requests to the primary database so the replica has time to replicate
-    WRITE_STATEMENT_MATCHERS = [/\ABEGIN/i, /\ACOMMIT/i, /INSERT\sINTO\s/i, /UPDATE\s/i, /DELETE\sFROM\s/i,
-                                /DROP\s/i].map(&:freeze).freeze
+    WRITE_STATEMENT_MATCHERS = [
+      /\ABEGIN/i,
+      /\ACOMMIT/i,
+      /INSERT\s[\s\S]*INTO\s[\s\S]*/i,
+      /UPDATE\s[\s\S]*/i,
+      /DELETE\s[\s\S]*FROM\s[\s\S]*/i,
+      /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
@@ -171,16 +182,21 @@ module ActiveRecordProxyAdapters
     # @return [TrueClass] if there has been a write within the last {#proxy_delay} seconds
     # @return [TrueClass] if sql_string matches a write statement (i.e. INSERT, UPDATE, DELETE, SELECT FOR UPDATE)
     # @return [FalseClass] if sql_string matches a read statement (i.e. SELECT)
-    def need_primary?(sql_string)
-      return true if recent_write_to_primary?
-
+    def need_primary?(sql_string) # rubocop:disable Metrics/CyclomaticComplexity
+      return true  if recent_write_to_primary?
       return true  if in_transaction?
+      return true  if cte_for_write?(sql_string)
       return true  if SQL_PRIMARY_MATCHERS.any?(&match_sql?(sql_string))
       return false if SQL_REPLICA_MATCHERS.any?(&match_sql?(sql_string))
 
       true
     end
 
+    def cte_for_write?(sql_string)
+      CTE_MATCHER.match?(sql_string) &&
+        WRITE_STATEMENT_MATCHERS.any?(&match_sql?(sql_string))
+    end
+
     def need_all?(sql_string)
       return false if SQL_SKIP_ALL_MATCHERS.any?(&match_sql?(sql_string))
 

data/lib/active_record_proxy_adapters/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: active_record_proxy_adapters
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.5
 platform: ruby
 authors:
 - Matt Cruz
 bindir: exe
 cert_chain: []
-date: 2025-03-04 00:00:00.000000000 Z
+date: 2025-03-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord