active_record_proxy_adapters 0.7.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5942f8ab80752d3abe9ac1015a991cc8bb8cbe7faa3961824e617ec478fd1cf0
-  data.tar.gz: daaf2fb00ad05b38c0477bb14d5a8f02d405863fd592252c63a887964385cc2f
+  metadata.gz: f404b61f94eec82c838124e111eba202e7fdbea61c07596739219749e7c76ac2
+  data.tar.gz: 930327b485fb9b7637a1b810c0cb52def9d0164777103f918862a9dd4a0a89e7
 SHA512:
-  metadata.gz: 2f61e7d36e3d968c9cf4f873f3cc7d70c5a1054337aa0b773ad59d76ad52b33088dc2c4588cf996725a7fa2efda42de77888654db6b3e53a93026a06dced44e4
-  data.tar.gz: 022acae0581a7910927a18a7452750e9628b238cc590b05e3b3bf15c0b3d4f8b163fbcc7fcc30071f3673dc7d1c6cd33fa01c2bd1c88d0c1e5611de6f77c060f
+  metadata.gz: 4d0c6210521feb5db9ce40fc476607fb862d818e16feb23d795e95f20f20b8db0b1311049a5895f6e9795ba2740cdef140ecb6ec67f5f1c7c7aec759e0a4c2ca
+  data.tar.gz: 1134342f6be3093cb5a3ddaba514ef702adb611e5646a3abd3c68073fcb7060459a39a5845983733b4c5f0bc24d5928f57e8333b7741bbb8b3fa812d9472f066

data/README.md

@@ -25,6 +25,18 @@ Install the gem and add to the application's Gemfile by executing:
 
     $ bundle add 'active_record_proxy_adapters'
 
+That will install and load the proxies for all Rails-supported adapters (i.e. `postgresql_proxy`, `mysql2_proxy`, `sqlite3_proxy` and `trilogy_proxy`).
+
+If you wish to load only one specific adapter for a faster application boot, use:
+
+    $ bundle add 'active_record_proxy_adapters' --require 'active_record_proxy_adapters/railties/<postgresql|mysql2|sqlite3|trilogy>'
+
+Or, in your Gemfile, use:
+
+```ruby
+  gem "active_record_proxy_adapters", require: 'active_record_proxy_adapters/railties/<postgresql|mysql2|sqlite3|trilogy>'
+```
+
 If bundler is not being used to manage dependencies, install the gem by executing:
 
     $ gem install active_record_proxy_adapters
@@ -558,7 +570,7 @@ To create a proxy adapter for an existing database `FoobarAdapter`, follow these
      return
    end
 
-   # This is only required for Rails 7.0 or earlier.
+   # This is only required for Rails 7.1 or earlier.
    module ActiveRecordProxyAdapters
      module Foobar
        module ConnectionHandling

data/lib/active_record/connection_adapters/mysql2_proxy_adapter.rb

@@ -13,12 +13,6 @@ module ActiveRecord
     class Mysql2ProxyAdapter < Mysql2Adapter
       include ActiveRecordProxyAdapters::Hijackable
 
-      if ActiveRecordProxyAdapters::ActiveRecordContext.active_record_v7_0?
-        require "active_record_proxy_adapters/transactionable_proxy_a_r_70"
-
-        include ActiveRecordProxyAdapters::TransactionableProxyAR70
-      end
-
       ADAPTER_NAME = "Mysql2Proxy"
 
       delegate_to_proxy(*ActiveRecordProxyAdapters::ActiveRecordContext.hijackable_methods)

data/lib/active_record/connection_adapters/postgresql_proxy_adapter.rb

@@ -13,12 +13,6 @@ module ActiveRecord
     class PostgreSQLProxyAdapter < PostgreSQLAdapter
       include ActiveRecordProxyAdapters::Hijackable
 
-      if ActiveRecordProxyAdapters::ActiveRecordContext.active_record_v7_0?
-        require "active_record_proxy_adapters/transactionable_proxy_a_r_70"
-
-        include ActiveRecordProxyAdapters::TransactionableProxyAR70
-      end
-
       ADAPTER_NAME = "PostgreSQLProxy"
 
       delegate_to_proxy(*ActiveRecordProxyAdapters::ActiveRecordContext.hijackable_methods)

data/lib/active_record/connection_adapters/trilogy_proxy_adapter.rb

@@ -13,15 +13,9 @@ module ActiveRecord
     class TrilogyProxyAdapter < TrilogyAdapter
       include ActiveRecordProxyAdapters::Hijackable
 
-      if ActiveRecordProxyAdapters::ActiveRecordContext.active_record_v7_0?
-        require "active_record_proxy_adapters/transactionable_proxy_a_r_70"
-
-        include ActiveRecordProxyAdapters::TransactionableProxyAR70
-      end
-
       ADAPTER_NAME = "TrilogyProxy"
 
-      delegate_to_proxy(*ActiveRecordProxyAdapters::ActiveRecordContext.hijackable_methods)
+      delegate_to_proxy(*ActiveRecordProxyAdapters::ActiveRecordContext.hijackable_methods, :exec_insert)
 
       def initialize(...)
         @proxy = ActiveRecordProxyAdapters::TrilogyProxy.new(self)

data/lib/active_record_proxy_adapters/active_record_context.rb

@@ -5,38 +5,18 @@ module ActiveRecordProxyAdapters
   # versions of rails.
   class ActiveRecordContext
     delegate :reading_role, :reading_role=, :writing_role, :writing_role=, to: :ActiveRecord
-    delegate :legacy_connection_handling, :legacy_connection_handling=, to: :connection_handling_context
     delegate :version, to: :ActiveRecord, prefix: :active_record
 
     class << self
       delegate_missing_to :new
     end
 
-    # rubocop:disable Naming/PredicateMethod
-    NullConnectionHandlingContext = Class.new do
-      def legacy_connection_handling
-        false
-      end
-
-      def legacy_connection_handling=(_value)
-        nil
-      end
-    end
-    # rubocop:enable Naming/PredicateMethod
-
     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
 
-    def connection_handling_context
-      # This config option has been removed in Rails 7.1+
-      return NullConnectionHandlingContext.new if active_record_v7_1_or_greater?
-
-      ActiveRecord
-    end
-
     def hijackable_methods
       hijackable = %i[execute exec_query]
 
@@ -46,11 +26,7 @@ module ActiveRecordProxyAdapters
     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_0?
-      active_record_version >= Gem::Version.new("7.0") && active_record_version < Gem::Version.new("7.1")
+      active_record_version >= Gem::Version.new("7.1") && active_record_version < Gem::Version.new("8.0")
     end
 
     def active_record_v7_1_or_greater?

data/lib/active_record_proxy_adapters/configuration.rb

@@ -3,26 +3,64 @@
 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 # rubocop:disable Style/Documentation
+  module_function
+
+  def configure
+    yield(config)
+  end
+
+  def bust_query_cache
+    config.cache.bust
+  end
+
+  def config
+    @config ||= Configuration.new
+  end
 
-module ActiveRecordProxyAdapters
   # Provides a global configuration object to configure how the proxy should behave.
   class Configuration
     include SynchronizableConfiguration
 
     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 +95,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 +129,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/connection_handling/sqlite3_proxy.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+begin
+  require "active_record/connection_adapters/sqlite3_proxy_adapter"
+rescue LoadError
+  # sqlite3 not available
+  return
+end
+
+module ActiveRecordProxyAdapters
+  module SQLite3
+    # Module to extend ActiveRecord::Base with the connection handling methods.
+    # Required to make adapter work in ActiveRecord versions <= 7.2.x
+    module ConnectionHandling
+      def sqlite3_proxy_adapter_class
+        ActiveRecord::ConnectionAdapters::SQLite3ProxyAdapter
+      end
+
+      def sqlite3_proxy_connection(config)
+        sqlite3_proxy_adapter_class.new(config)
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Base.extend(ActiveRecordProxyAdapters::SQLite3::ConnectionHandling)
+end

data/lib/active_record_proxy_adapters/connection_handling.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "active_record_proxy_adapters/connection_handling/postgresql"
-require "active_record_proxy_adapters/connection_handling/mysql2"
-require "active_record_proxy_adapters/connection_handling/trilogy"
-require "active_record_proxy_adapters/connection_handling/sqlite3"
+require "active_record_proxy_adapters/connection_handling/postgresql_proxy"
+require "active_record_proxy_adapters/connection_handling/mysql2_proxy"
+require "active_record_proxy_adapters/connection_handling/trilogy_proxy"
+require "active_record_proxy_adapters/connection_handling/sqlite3_proxy"

data/lib/active_record_proxy_adapters/core.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "active_record"
+require "active_record_proxy_adapters/version"
+require "active_record_proxy_adapters/active_record_context"
+require "active_record_proxy_adapters/configuration"
+require "active_record_proxy_adapters/context"
+require "active_record_proxy_adapters/contextualizer"
+require "active_record_proxy_adapters/database_tasks"
+require "active_record_proxy_adapters/errors"
+require "active_record_proxy_adapters/hijackable"
+require "active_record_proxy_adapters/mixin/configuration"
+require "active_record_proxy_adapters/primary_replica_proxy"

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/log_subscriber.rb

@@ -22,22 +22,12 @@ module ActiveRecordProxyAdapters
 
     def database_instance_prefix_for(event)
       connection      = event.payload[:connection]
-      db_config       = connection.pool.try(:db_config) || NullConfig.new # AR 7.0.x does not support "NullConfig"
+      db_config       = connection.pool.try(:db_config)
       connection_name = db_config.name
 
       prefix = log_subscriber_prefix(connection_name)
 
       "[#{prefix.call(event)}]"
     end
-
-    class NullConfig # rubocop:disable Style/Documentation
-      def method_missing(...)
-        nil
-      end
-
-      def respond_to_missing?(*)
-        true
-      end
-    end
   end
 end

data/lib/active_record_proxy_adapters/mixin/configuration.rb

@@ -3,7 +3,6 @@
 require "active_support/core_ext/integer/time"
 require "active_record_proxy_adapters/synchronizable_configuration"
 require "active_record_proxy_adapters/cache_configuration"
-require "active_record_proxy_adapters/context"
 
 module ActiveRecordProxyAdapters
   module Mixin
@@ -40,6 +39,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/railtie.rb

@@ -1,24 +1,17 @@
 # frozen_string_literal: true
 
 require "active_support"
+require "active_record_proxy_adapters/core"
+require "active_record_proxy_adapters/railties/postgresql"
+require "active_record_proxy_adapters/railties/mysql2"
+require "active_record_proxy_adapters/railties/trilogy"
+require "active_record_proxy_adapters/railties/sqlite3"
 
 module ActiveRecordProxyAdapters
   # Hooks into rails boot process to extend ActiveRecord with the proxy adapter.
   class Railtie < Rails::Railtie
-    require "active_record_proxy_adapters/connection_handling"
     require "active_record_proxy_adapters/middleware"
 
-    config.to_prepare do
-      Rails.autoloaders.each do |autoloader|
-        autoloader.inflector.inflect(
-          "postgresql_proxy_adapter" => "PostgreSQLProxyAdapter"
-        )
-        autoloader.inflector.inflect(
-          "sqlite3_proxy_adapter" => "SQLite3ProxyAdapter"
-        )
-      end
-    end
-
     initializer "active_record_proxy_adapters.configure_rails_initialization" do |app|
       app.middleware.use ActiveRecordProxyAdapters::Middleware
     end

data/lib/active_record_proxy_adapters/railties/mysql2.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_record_proxy_adapters/core"
+
+module ActiveRecordProxyAdapters
+  module Railties
+    # Hooks into rails boot process to load the Mysql2 Proxy adapter.
+    class Mysql2Proxy < Rails::Railtie
+      require "active_record_proxy_adapters/connection_handling/mysql2_proxy"
+    end
+  end
+end

data/lib/active_record_proxy_adapters/railties/postgresql.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_record_proxy_adapters/core"
+
+module ActiveRecordProxyAdapters
+  module Railties
+    # Hooks into rails boot process to load the PostgreSQL Proxy adapter.
+    class PostgreSQLProxy < Rails::Railtie
+      require "active_record_proxy_adapters/connection_handling/postgresql_proxy"
+
+      config.to_prepare do
+        Rails.autoloaders.each do |autoloader|
+          autoloader.inflector.inflect(
+            "postgresql_proxy_adapter" => "PostgreSQLProxyAdapter"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/active_record_proxy_adapters/railties/sqlite3.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_record_proxy_adapters/core"
+
+module ActiveRecordProxyAdapters
+  module Railties
+    # Hooks into rails boot process to load the SQLite3 Proxy adapter.
+    class SQLite3Proxy < Rails::Railtie
+      require "active_record_proxy_adapters/connection_handling/sqlite3_proxy"
+
+      config.to_prepare do
+        Rails.autoloaders.each do |autoloader|
+          autoloader.inflector.inflect(
+            "sqlite3_proxy_adapter" => "SQLite3ProxyAdapter"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/active_record_proxy_adapters/railties/trilogy.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_record_proxy_adapters/core"
+
+module ActiveRecordProxyAdapters
+  module Railties
+    # Hooks into rails boot process to load the Trilogy Proxy adapter.
+    class TrilogyProxy < Rails::Railtie
+      require "active_record_proxy_adapters/connection_handling/trilogy_proxy"
+    end
+  end
+end

data/lib/active_record_proxy_adapters/trilogy_proxy.rb

@@ -5,5 +5,6 @@ require "active_record_proxy_adapters/mysql2_proxy"
 module ActiveRecordProxyAdapters
   # Proxy to the Mysql2Proxy, allowing the use of the ActiveRecordProxyAdapters::PrimaryReplicaProxy.
   class TrilogyProxy < Mysql2Proxy
+    hijack_method :exec_insert
   end
 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.9.0"
 end

data/lib/active_record_proxy_adapters.rb

@@ -1,26 +1,7 @@
 # frozen_string_literal: true
 
-require "active_record"
-require "active_record_proxy_adapters/version"
-require "active_record_proxy_adapters/configuration"
-
 # The gem namespace.
 module ActiveRecordProxyAdapters
-  class Error < StandardError; end
-
-  module_function
-
-  def configure
-    yield(config)
-  end
-
-  def bust_query_cache
-    config.cache.bust
-  end
-
-  def config
-    @config ||= Configuration.new
-  end
 end
 
 require_relative "active_record_proxy_adapters/railtie" if defined?(Rails::Railtie)

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.9.0
 platform: ruby
 authors:
 - Matt Cruz
@@ -15,7 +15,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '8.1'
@@ -25,7 +25,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '8.1'
@@ -35,7 +35,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '8.1'
@@ -45,7 +45,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 7.0.0
+        version: 7.1.0
     - - "<"
       - !ruby/object:Gem::Version
         version: '8.1'
@@ -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
@@ -104,14 +132,16 @@ files:
 - lib/active_record_proxy_adapters/cache_configuration.rb
 - lib/active_record_proxy_adapters/configuration.rb
 - lib/active_record_proxy_adapters/connection_handling.rb
-- lib/active_record_proxy_adapters/connection_handling/mysql2.rb
-- lib/active_record_proxy_adapters/connection_handling/postgresql.rb
-- lib/active_record_proxy_adapters/connection_handling/sqlite3.rb
-- lib/active_record_proxy_adapters/connection_handling/trilogy.rb
+- lib/active_record_proxy_adapters/connection_handling/mysql2_proxy.rb
+- lib/active_record_proxy_adapters/connection_handling/postgresql_proxy.rb
+- lib/active_record_proxy_adapters/connection_handling/sqlite3_proxy.rb
+- lib/active_record_proxy_adapters/connection_handling/trilogy_proxy.rb
 - lib/active_record_proxy_adapters/context.rb
 - lib/active_record_proxy_adapters/contextualizer.rb
+- lib/active_record_proxy_adapters/core.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
@@ -120,9 +150,12 @@ files:
 - lib/active_record_proxy_adapters/postgresql_proxy.rb
 - lib/active_record_proxy_adapters/primary_replica_proxy.rb
 - lib/active_record_proxy_adapters/railtie.rb
+- lib/active_record_proxy_adapters/railties/mysql2.rb
+- lib/active_record_proxy_adapters/railties/postgresql.rb
+- lib/active_record_proxy_adapters/railties/sqlite3.rb
+- lib/active_record_proxy_adapters/railties/trilogy.rb
 - lib/active_record_proxy_adapters/sqlite3_proxy.rb
 - lib/active_record_proxy_adapters/synchronizable_configuration.rb
-- lib/active_record_proxy_adapters/transactionable_proxy_a_r_70.rb
 - lib/active_record_proxy_adapters/trilogy_proxy.rb
 - lib/active_record_proxy_adapters/version.rb
 homepage: https://github.com/Nasdaq/active_record_proxy_adapters
@@ -141,7 +174,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/active_record_proxy_adapters/connection_handling/sqlite3.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require "active_record/connection_adapters/sqlite3_proxy_adapter"
-rescue LoadError
-  # sqlite3 not available
-  return
-end
-
-module ActiveRecordProxyAdapters
-  module SQLite3
-    # Module to extend ActiveRecord::Base with the connection handling methods.
-    # Required to make adapter work in ActiveRecord versions <= 7.2.x
-    module ConnectionHandling
-      def sqlite3_proxy_adapter_class
-        ActiveRecord::ConnectionAdapters::SQLite3ProxyAdapter
-      end
-
-      def sqlite3_proxy_connection(config)
-        connection_factory_mapping
-          .fetch("#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}")
-          .call(config)
-      end
-
-      def connection_factory_mapping
-        {
-          "7.0" => ->(config) { sqlite3_proxy_connection_ar_v70(config) },
-          "7.1" => ->(config) { sqlite3_proxy_connection_ar_v71(config) }
-        }
-      end
-
-      def sqlite3_proxy_connection_ar_v70(config) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
-        config = config.symbolize_keys
-
-        # Require database.
-        raise ArgumentError, "No database file specified. Missing argument: database" unless config[:database]
-
-        # Allow database path relative to Rails.root, but only if the database
-        # path is not the special path that tells sqlite to build a database only
-        # in memory.
-        if ":memory:" != config[:database] && !config[:database].to_s.start_with?("file:") # rubocop:disable Style/YodaCondition
-          config[:database] = File.expand_path(config[:database], Rails.root) if defined?(Rails.root)
-          dirname = File.dirname(config[:database])
-          Dir.mkdir(dirname) unless File.directory?(dirname)
-        end
-
-        db = ::SQLite3::Database.new(
-          config[:database].to_s,
-          config.merge(results_as_hash: true)
-        )
-
-        sqlite3_proxy_adapter_class.new(db, logger, nil, config)
-      rescue Errno::ENOENT => e
-        raise ActiveRecord::NoDatabaseError if e.message.include?("No such file or directory")
-
-        raise
-      end
-
-      def sqlite3_proxy_connection_ar_v71(config)
-        sqlite3_proxy_adapter_class.new(config)
-      end
-    end
-  end
-end
-
-ActiveSupport.on_load(:active_record) do
-  ActiveRecord::Base.extend(ActiveRecordProxyAdapters::SQLite3::ConnectionHandling)
-end

data/lib/active_record_proxy_adapters/transactionable_proxy_a_r_70.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecordProxyAdapters
-  module TransactionableProxyAR70 # rubocop:disable Style/Documentation
-    extend ActiveSupport::Concern
-
-    included do
-      def begin_db_transaction # :nodoc:
-        bypass_proxy_or_else("BEGIN", "TRANSACTION") { super }
-      end
-
-      def commit_db_transaction # :nodoc:
-        bypass_proxy_or_else("COMMIT", "TRANSACTION") { super }
-      end
-
-      def exec_rollback_db_transaction # :nodoc:
-        bypass_proxy_or_else("ROLLBACK", "TRANSACTION") { super }
-      end
-
-      private
-
-      def bypass_proxy_or_else(*args)
-        method_name = proxy_method_name_for(:execute)
-
-        return public_send(method_name, *args) if respond_to?(method_name)
-
-        yield
-      end
-    end
-  end
-end