active_record_proxy_adapters 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5942f8ab80752d3abe9ac1015a991cc8bb8cbe7faa3961824e617ec478fd1cf0
-  data.tar.gz: daaf2fb00ad05b38c0477bb14d5a8f02d405863fd592252c63a887964385cc2f
+  metadata.gz: 8e87a47a033b2402f2fdd0dbae2aec360ff04afbe4639f83615030da82d80cfc
+  data.tar.gz: 7caec5f8d663d2b67482f28f30b669e36a00fedb8d9eea6b06404ad3df9ce594
 SHA512:
-  metadata.gz: 2f61e7d36e3d968c9cf4f873f3cc7d70c5a1054337aa0b773ad59d76ad52b33088dc2c4588cf996725a7fa2efda42de77888654db6b3e53a93026a06dced44e4
-  data.tar.gz: 022acae0581a7910927a18a7452750e9628b238cc590b05e3b3bf15c0b3d4f8b163fbcc7fcc30071f3673dc7d1c6cd33fa01c2bd1c88d0c1e5611de6f77c060f
+  metadata.gz: 65850028f544840668b1aa172a6442665cf9142c1a52934773f433c823fc56365b0251b6188636ccd252f9b33f74c9a40c9578d44953b57e33af842393e92e54
+  data.tar.gz: eb1c1b67ba524477b2b792d8a23f003f057cd764c4ee2930e9c5613efee9262ea7ba03c18084004b406b26e9c9e770a905733a2164ce6a84d107b172589860b0

data/lib/active_record_proxy_adapters/configuration.rb

@@ -3,8 +3,10 @@
 require "active_record_proxy_adapters/cache_configuration"
 require "active_record_proxy_adapters/context"
 require "active_record_proxy_adapters/database_configuration"
+require "active_record_proxy_adapters/errors"
 require "active_record_proxy_adapters/synchronizable_configuration"
 require "active_support/core_ext/integer/time"
+require "logger"
 
 module ActiveRecordProxyAdapters
   # Provides a global configuration object to configure how the proxy should behave.
@@ -13,16 +15,38 @@ module ActiveRecordProxyAdapters
 
     DEFAULT_DATABASE_NAME         = :primary
     DEFAULT_REPLICA_DATABASE_NAME = :primary_replica
+    TIMEOUT_MESSAGE_BUILDER = proc { |sql_string, regex = nil|
+      [regex, "timed out. Input too big (#{sql_string.size})."].compact_blank.join(" ")
+    }.freeze
+
+    private_constant :TIMEOUT_MESSAGE_BUILDER
+
+    REGEXP_TIMEOUT_STRATEGY_REGISTRY = {
+      log: proc { |sql_string, regex = nil|
+        ActiveRecordProxyAdapters.config.logger.error(TIMEOUT_MESSAGE_BUILDER.call(sql_string, regex))
+      },
+      raise: proc { |sql_string, regex = nil|
+        raise ActiveRecordProxyAdapters::RegexpTimeoutError, TIMEOUT_MESSAGE_BUILDER.call(sql_string, regex)
+      }
+    }.freeze
 
     # @return [Class] The context that is used to store the current request's state.
     attr_reader :context_store
 
+    # @return [Proc] The timeout strategy to use for regex matching.
+    attr_reader :regexp_timeout_strategy
+
+    # @return [Logger] The logger to use for logging messages.
+    attr_reader :logger
+
     def initialize
       @lock = Monitor.new
 
-      self.cache_configuration = CacheConfiguration.new(@lock)
-      self.context_store       = ActiveRecordProxyAdapters::Context
-      @database_configurations = {}
+      self.cache_configuration     = CacheConfiguration.new(@lock)
+      self.context_store           = ActiveRecordProxyAdapters::Context
+      self.regexp_timeout_strategy = :log
+      self.logger                  = ActiveRecord::Base.logger || Logger.new($stdout)
+      @database_configurations     = {}
     end
 
     def log_subscriber_primary_prefix=(prefix)
@@ -57,6 +81,25 @@ module ActiveRecordProxyAdapters
       default_database_config.checkout_timeout = checkout_timeout
     end
 
+    def logger=(logger)
+      synchronize_update(:logger, from: @logger, to: logger) do
+        @logger = logger
+      end
+    end
+
+    def regexp_timeout_strategy=(strategy)
+      synchronize_update(:regexp_timeout_strategy, from: @regexp_timeout_strategy, to: strategy) do
+        @regexp_timeout_strategy = if strategy.respond_to?(:call)
+                                     strategy
+                                   else
+                                     REGEXP_TIMEOUT_STRATEGY_REGISTRY.fetch(strategy)
+                                   end
+      rescue KeyError
+        raise ActiveRecordProxyAdapters::ConfigurationError,
+              "Invalid regex timeout strategy: #{strategy.inspect}. Must be one of: #{valid_regexp_timeout_strategies}"
+      end
+    end
+
     def database(database_name)
       key = database_name.to_s
       lock.synchronize { @database_configurations[key] ||= DatabaseConfiguration.new }
@@ -72,6 +115,10 @@ module ActiveRecordProxyAdapters
 
     attr_reader :cache_configuration, :database_configurations, :lock
 
+    def valid_regexp_timeout_strategies
+      REGEXP_TIMEOUT_STRATEGY_REGISTRY.keys
+    end
+
     def default_database_config
       database(DEFAULT_DATABASE_NAME)
     end

data/lib/active_record_proxy_adapters/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveRecordProxyAdapters
+  Error              = Class.new(StandardError)
+  RegexpTimeoutError = Class.new(Error)
+  ConfigurationError = Class.new(Error)
+end

data/lib/active_record_proxy_adapters/mixin/configuration.rb

@@ -40,6 +40,20 @@ module ActiveRecordProxyAdapters
         proxy_config.context_store
       end
 
+      # Helper to retrieve the logger from the configuration stored in
+      # {ActiveRecordProxyAdapters::Configuration#logger}.
+      # @return [Logger]
+      def logger
+        proxy_config.logger
+      end
+
+      # Helper to retrieve the timeout strategy from the configuration stored in
+      # {ActiveRecordProxyAdapters::Configuration#regexp_timeout_strategy}.
+      # @return [Proc]
+      def regexp_timeout_strategy
+        proxy_config.regexp_timeout_strategy
+      end
+
       # Helper to retrieve the cache store from the configuration stored in
       # {ActiveRecordProxyAdapters::CacheConfiguration#store}.
       # @return [ActiveSupport::Cache::Store]

data/lib/active_record_proxy_adapters/primary_replica_proxy.rb

@@ -7,6 +7,7 @@ require "active_record_proxy_adapters/hijackable"
 require "active_record_proxy_adapters/mixin/configuration"
 require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/object/blank"
+require "timeout"
 
 module ActiveRecordProxyAdapters
   # This is the base class for all proxies. It defines the methods that should be proxied
@@ -113,8 +114,9 @@ module ActiveRecordProxyAdapters
       end.last
     end
 
-    def roles_for(sql_string) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
-      return [top_of_connection_stack_role] if top_of_connection_stack_role.present?
+    def roles_for(sql_string) # rubocop:disable Metrics/MethodLength
+      top_of_stack_role = top_of_connection_stack_role
+      return [top_of_stack_role] if top_of_stack_role.present?
       return [writing_role] if recent_write_to_primary? || in_transaction?
 
       cache_key = cache_key_for(sql_string)
@@ -136,17 +138,23 @@ module ActiveRecordProxyAdapters
       return if connected_to_stack.empty?
 
       top = connected_to_stack.last
-      role = top[:role]
+      role, klasses = top.values_at(:role, :klasses)
       return unless role.present?
 
-      [reading_role, writing_role].include?(role) ? role : nil
+      # ActiveRecord::Base is the parent record for all models so,
+      # if the top of the stack includes it, we should respect it.
+      role_for_current_class = klasses.include?(connection_class) || klasses.include?(ActiveRecord::Base)
+
+      [reading_role, writing_role].include?(role) && role_for_current_class ? role : nil
     end
 
     def connected_to_stack
       return connection_class.connected_to_stack if connection_class.respond_to?(:connected_to_stack)
 
       # handle Rails 7.2+ pending migrations Connection
-      return [{ role: writing_role }] if pending_migration_connection?
+      if pending_migration_connection?
+        return [{ role: writing_role, shard: nil, prevent_writes: false, klasses: [connection_class] }]
+      end
 
       []
     end
@@ -181,7 +189,7 @@ module ActiveRecordProxyAdapters
     end
 
     def checkout_replica_connection
-      replica_pool.checkout(checkout_timeout(primary_connection_name))
+      replica_pool.checkout(proxy_checkout_timeout)
     # rescue NoDatabaseError to avoid crashing when running db:create rake task
     # rescue ConnectionNotEstablished to handle connectivity issues in the replica
     # (for example, replication delay)
@@ -215,7 +223,14 @@ module ActiveRecordProxyAdapters
     end
 
     def match_sql?(sql_string)
-      proc { |matcher| matcher.match?(sql_string) }
+      proc do |matcher|
+        # TODO: switch to regexp timeout once Ruby 3.1 support is dropped.
+        Timeout.timeout(proxy_checkout_timeout.to_f) { matcher.match?(sql_string) }
+      rescue Timeout::Error
+        regexp_timeout_strategy.call(sql_string, matcher)
+
+        false
+      end
     end
 
     # @return Boolean
@@ -235,6 +250,10 @@ module ActiveRecordProxyAdapters
       @primary_connection_name ||= primary_connection.pool.try(:db_config).try(:name).try(:to_s)
     end
 
+    def proxy_checkout_timeout
+      checkout_timeout(primary_connection_name)
+    end
+
     def proxy_context
       self.current_context ||= context_store.new({})
     end

data/lib/active_record_proxy_adapters/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_proxy_adapters
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
 platform: ruby
 authors:
 - Matt Cruz
@@ -77,6 +77,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timeout
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |-
   This gem allows automatic connection switching between a primary and one read replica database in ActiveRecord.
   It pattern matches the SQL statement being sent to decide whether it should go to the replica (SELECT) or the
@@ -112,6 +140,7 @@ files:
 - lib/active_record_proxy_adapters/contextualizer.rb
 - lib/active_record_proxy_adapters/database_configuration.rb
 - lib/active_record_proxy_adapters/database_tasks.rb
+- lib/active_record_proxy_adapters/errors.rb
 - lib/active_record_proxy_adapters/hijackable.rb
 - lib/active_record_proxy_adapters/log_subscriber.rb
 - lib/active_record_proxy_adapters/middleware.rb