switchman 3.5.12 → 3.5.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a18e4da75efcd07fcf8d46d08397d2323c7795f3f971a66561e03944383bf4e
-  data.tar.gz: 65963d628b6a011a7e29d7b76735f6d6318afec42b3359e5cd4c6f4c21e591c6
+  metadata.gz: c0ab0712ea0711e482d32ddf5ce6ec740b399b6dc8074ea86eaaa092c13bbdd1
+  data.tar.gz: a3e43929c88727da33b2954966f7cf357bd2b8793eed33563f57908839e2d97d
 SHA512:
-  metadata.gz: 278b27e999056a7b9a8bf1fbed3f4de12b110fc269410b7ffaf4c7fdcd340ef37e2af8174dd2ce499e90ab07483ee057261067224c474053707ab2de67c3c41c
-  data.tar.gz: 5d9aa9b061b88fe2ea62d11005eaf4db9e05c9c65da11fd6d82bdaf5ddb707507bd024b95a2b9fca1ab3b194a158fbfc8ce66e5f6b5d5f9bf9327cd121d897ba
+  metadata.gz: 67a005a7e156773576077ade7723e1500d291e782cdfb4af9662cef6ba2a217b2e0743aaea8a5e8bffc1777295baf465f9d7678f6d8fa6c681215b1ad9c5817a
+  data.tar.gz: 7e72531b558a3fc0d447d63efeec37b5a0480ebe873ff2e76fb6334927aee10d5342a92b0be8336bd324da57c2df6ff154b5efb2d88b5cc0e9e7b16f60bc6c78

data/lib/switchman/active_record/abstract_adapter.rb

@@ -27,8 +27,10 @@ module Switchman
         quote_table_name(name)
       end
 
-      def schema_migration
-        ::ActiveRecord::SchemaMigration
+      if ::Rails.version < "7.1"
+        def schema_migration
+          ::ActiveRecord::SchemaMigration
+        end
       end
 
       protected

data/lib/switchman/active_record/associations.rb

@@ -298,11 +298,48 @@ module Switchman
           record.has_attribute?(reflection.foreign_key) && record.send(reflection.foreign_key) != key
         end
 
-        def save_belongs_to_association(reflection)
-          # this seems counter-intuitive, but the autosave code will assign to attribute bypassing switchman,
-          # after reading the id attribute _without_ bypassing switchman. So we need Shard.current for the
-          # category of the associated record to match Shard.current for the category of self
-          shard.activate(connection_class_for_self_for_reflection(reflection)) { super }
+        if ::Rails.version < "7.1"
+          def save_belongs_to_association(reflection)
+            # this seems counter-intuitive, but the autosave code will assign to attribute bypassing switchman,
+            # after reading the id attribute _without_ bypassing switchman. So we need Shard.current for the
+            # category of the associated record to match Shard.current for the category of self
+            shard.activate(connection_class_for_self_for_reflection(reflection)) { super }
+          end
+        else
+          def save_belongs_to_association(reflection)
+            association = association_instance_get(reflection.name)
+            return unless association&.loaded? && !association.stale_target?
+
+            record = association.load_target
+            return unless record && !record.destroyed?
+
+            autosave = reflection.options[:autosave]
+
+            if autosave && record.marked_for_destruction?
+              foreign_key = Array(reflection.foreign_key)
+              foreign_key.each { |key| self[key] = nil }
+              record.destroy
+            elsif autosave != false
+              if record.new_record? || (autosave && record.changed_for_autosave?)
+                saved = record.save(validate: !autosave)
+              end
+
+              if association.updated?
+                primary_key = Array(compute_primary_key(reflection, record)).map(&:to_s)
+                foreign_key = Array(reflection.foreign_key)
+
+                primary_key_foreign_key_pairs = primary_key.zip(foreign_key)
+                primary_key_foreign_key_pairs.each do |pk, fk|
+                  # Notable change: add relative_id_for here
+                  association_id = Shard.relative_id_for(record._read_attribute(pk), record.shard, shard)
+                  self[fk] = association_id unless self[fk] == association_id
+                end
+                association.loaded!
+              end
+
+              saved if autosave
+            end
+          end
         end
       end
     end

data/lib/switchman/active_record/base.rb

@@ -57,7 +57,7 @@ module Switchman
         end
 
         def clear_query_caches_for_current_thread
-          ::ActiveRecord::Base.connection_handler.connection_pool_list.each do |pool|
+          ::ActiveRecord::Base.connection_handler.connection_pool_list(:all).each do |pool|
             pool.connection(switch_shard: false).clear_query_cache if pool.active_connection?
           end
         end
@@ -265,9 +265,9 @@ module Switchman
         result
       end
 
-      def transaction(**kwargs, &block)
+      def transaction(...)
         shard.activate(self.class.connection_class_for_self) do
-          self.class.transaction(**kwargs, &block)
+          self.class.transaction(...)
         end
       end
 

data/lib/switchman/active_record/connection_handler.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Switchman
+  module ActiveRecord
+    module ConnectionHandler
+      def resolve_pool_config(config, connection_name, role, shard)
+        ret = super
+        # Make *all* pool configs use the same schema reflection
+        ret.schema_reflection = ConnectionHandler.global_schema_reflection
+        ret
+      end
+
+      def self.global_schema_reflection
+        @global_schema_reflection ||= ::ActiveRecord::ConnectionAdapters::SchemaReflection.new(nil)
+      end
+    end
+  end
+end

data/lib/switchman/active_record/connection_pool.rb

@@ -3,22 +3,24 @@
 module Switchman
   module ActiveRecord
     module ConnectionPool
-      def get_schema_cache(connection)
-        self.schema_cache ||= SharedSchemaCache.get_schema_cache(connection)
-        self.schema_cache.connection = connection
+      if ::Rails.version < "7.1"
+        def get_schema_cache(connection)
+          self.schema_cache ||= SharedSchemaCache.get_schema_cache(connection)
+          self.schema_cache.connection = connection
 
-        self.schema_cache
-      end
+          self.schema_cache
+        end
 
-      # rubocop:disable Naming/AccessorMethodName override method
-      def set_schema_cache(cache)
-        schema_cache = get_schema_cache(cache.connection)
+        # rubocop:disable Naming/AccessorMethodName override method
+        def set_schema_cache(cache)
+          schema_cache = get_schema_cache(cache.connection)
 
-        cache.instance_variables.each do |x|
-          schema_cache.instance_variable_set(x, cache.instance_variable_get(x))
+          cache.instance_variables.each do |x|
+            schema_cache.instance_variable_set(x, cache.instance_variable_get(x))
+          end
         end
+        # rubocop:enable Naming/AccessorMethodName override method
       end
-      # rubocop:enable Naming/AccessorMethodName override method
 
       def default_schema
         connection unless @schemas

data/lib/switchman/active_record/database_configurations.rb

@@ -7,14 +7,26 @@ module Switchman
       # since all should point to the same data, even if multiple are writable
       # (Picks 'primary' since it is guaranteed to exist and switchman handles activating
       # deploy through other means)
-      def configs_for(include_replicas: false, name: nil, **)
-        res = super
-        if name && !include_replicas
-          return nil unless name.end_with?("primary")
-        elsif !include_replicas
-          return res.select { |config| config.name.end_with?("primary") }
+      if ::Rails.version < "7.1"
+        def configs_for(include_replicas: false, name: nil, **)
+          res = super
+          if name && !include_replicas
+            return nil unless name.end_with?("primary")
+          elsif !include_replicas
+            return res.select { |config| config.name.end_with?("primary") }
+          end
+          res
+        end
+      else
+        def configs_for(include_hidden: false, name: nil, **)
+          res = super
+          if name && !include_hidden
+            return nil unless name.end_with?("primary")
+          elsif !include_hidden
+            return res.select { |config| config.name.end_with?("primary") }
+          end
+          res
         end
-        res
       end
 
       private

data/lib/switchman/active_record/finder_methods.rb

@@ -42,26 +42,56 @@ module Switchman
         primary_shard.activate { super }
       end
 
-      def exists?(conditions = :none)
-        conditions = conditions.id if ::ActiveRecord::Base === conditions
-        return false unless conditions
+      if ::Rails.version < "7.1"
+        def exists?(conditions = :none)
+          conditions = conditions.id if ::ActiveRecord::Base === conditions
+          return false unless conditions
 
-        relation = apply_join_dependency(eager_loading: false)
-        return false if ::ActiveRecord::NullRelation === relation
+          relation = apply_join_dependency(eager_loading: false)
+          return false if ::ActiveRecord::NullRelation === relation
 
-        relation = relation.except(:select, :order).select("1 AS one").limit(1)
+          relation = relation.except(:select, :order).select("1 AS one").limit(1)
 
-        case conditions
-        when Array, Hash
-          relation = relation.where(conditions)
-        else
-          relation = relation.where(table[primary_key].eq(conditions)) if conditions != :none
+          case conditions
+          when Array, Hash
+            relation = relation.where(conditions)
+          else
+            relation = relation.where(table[primary_key].eq(conditions)) if conditions != :none
+          end
+
+          relation.activate do |shard_rel|
+            return true if connection.select_value(shard_rel.arel, "#{name} Exists")
+          end
+          false
         end
+      else
+        def exists?(conditions = :none)
+          return false if @none
+
+          if Base === conditions
+            raise ArgumentError, <<-TEXT.squish
+              You are passing an instance of ActiveRecord::Base to `exists?`.
+              Please pass the id of the object by calling `.id`.
+            TEXT
+          end
 
-        relation.activate do |shard_rel|
-          return true if connection.select_value(shard_rel.arel, "#{name} Exists")
+          return false if !conditions || limit_value == 0 # rubocop:disable Style/NumericPredicate
+
+          if eager_loading?
+            relation = apply_join_dependency(eager_loading: false)
+            return relation.exists?(conditions)
+          end
+
+          relation = construct_relation_for_exists(conditions)
+          return false if relation.where_clause.contradiction?
+
+          relation.activate do |shard_rel|
+            return true if skip_query_cache_if_necessary do
+                             connection.select_rows(shard_rel.arel, "#{name} Exists?").size == 1
+                           end
+          end
+          false
         end
-        false
       end
     end
   end

data/lib/switchman/active_record/log_subscriber.rb

@@ -5,8 +5,10 @@ module Switchman
     module LogSubscriber
       # sadly, have to completely replace this
       def sql(event)
-        self.class.runtime += event.duration
-        return unless logger.debug?
+        if ::Rails.version < "7.1"
+          self.class.runtime += event.duration
+          return unless logger.debug?
+        end
 
         payload = event.payload
 
@@ -27,7 +29,11 @@ module Switchman
         end
 
         name = colorize_payload_name(name, payload[:name])
-        sql  = color(sql, sql_color(sql), true)
+        sql  = if ::Rails.version < "7.1"
+                 color(sql, sql_color(sql), true)
+               else
+                 color(sql, sql_color(sql), bold: true)
+               end
 
         debug "  #{name}  #{sql}#{binds}#{shard}"
       end

data/lib/switchman/active_record/migration.rb

@@ -29,7 +29,11 @@ module Switchman
         db_name_hash = Zlib.crc32(Shard.current.name)
         shard_name_hash = ::ActiveRecord::Migrator::MIGRATOR_SALT * db_name_hash
         # Store in internalmetadata to allow other tools to be able to lock out migrations
-        ::ActiveRecord::InternalMetadata[:migrator_advisory_lock_id] = shard_name_hash
+        if ::Rails.version < "7.1"
+          ::ActiveRecord::InternalMetadata[:migrator_advisory_lock_id] = shard_name_hash
+        else
+          ::ActiveRecord::InternalMetadata.new(connection)[:migrator_advisory_lock_id] = shard_name_hash
+        end
         shard_name_hash
       end
 
@@ -48,17 +52,30 @@ module Switchman
     module MigrationContext
       def migrate(...)
         connection = ::ActiveRecord::Base.connection
-        connection_pool = ::ActiveRecord::Base.connection_pool
-        previous_schema_cache = connection_pool.get_schema_cache(connection)
-        temporary_schema_cache = ::ActiveRecord::ConnectionAdapters::SchemaCache.new(connection)
+        schema_cache_holder = ::ActiveRecord::Base.connection_pool
+        schema_cache_holder = schema_cache_holder.schema_reflection if ::Rails.version >= "7.1"
+        previous_schema_cache = if ::Rails.version < "7.1"
+                                  schema_cache_holder.get_schema_cache(connection)
+                                else
+                                  schema_cache_holder.instance_variable_get(:@cache)
+                                end
+
+        if ::Rails.version < "7.1"
+          temporary_schema_cache = ::ActiveRecord::ConnectionAdapters::SchemaCache.new(connection)
+
+          reset_column_information
+          schema_cache_holder.set_schema_cache(temporary_schema_cache)
+        else
+          schema_cache_holder.instance_variable_get(:@cache)
 
-        reset_column_information
-        connection_pool.set_schema_cache(temporary_schema_cache)
+          reset_column_information
+          schema_cache_holder.clear!
+        end
 
         begin
           super(...)
         ensure
-          connection_pool.set_schema_cache(previous_schema_cache)
+          schema_cache_holder.set_schema_cache(previous_schema_cache)
           reset_column_information
         end
       end

data/lib/switchman/active_record/query_cache.rb

@@ -5,28 +5,57 @@ module Switchman
     module QueryCache
       private
 
-      def cache_sql(sql, name, binds)
-        # have to include the shard id in the cache key because of switching dbs on the same connection
-        sql = "#{shard.id}::#{sql}"
-        @lock.synchronize do
-          result =
-            if query_cache[sql].key?(binds)
-              args = {
-                sql: sql,
-                binds: binds,
-                name: name,
-                connection_id: object_id,
-                cached: true,
-                type_casted_binds: -> { type_casted_binds(binds) }
-              }
-              ::ActiveSupport::Notifications.instrument(
-                "sql.active_record",
-                args
-              )
-              query_cache[sql][binds]
+      if ::Rails.version < "7.1"
+        def cache_sql(sql, name, binds)
+          # have to include the shard id in the cache key because of switching dbs on the same connection
+          sql = "#{shard.id}::#{sql}"
+          @lock.synchronize do
+            result =
+              if query_cache[sql].key?(binds)
+                args = {
+                  sql: sql,
+                  binds: binds,
+                  name: name,
+                  connection_id: object_id,
+                  cached: true,
+                  type_casted_binds: -> { type_casted_binds(binds) }
+                }
+                ::ActiveSupport::Notifications.instrument(
+                  "sql.active_record",
+                  args
+                )
+                query_cache[sql][binds]
+              else
+                query_cache[sql][binds] = yield
+              end
+            result.dup
+          end
+        end
+      else
+        def cache_sql(sql, name, binds)
+          # have to include the shard id in the cache key because of switching dbs on the same connection
+          sql = "#{shard.id}::#{sql}"
+          key = binds.empty? ? sql : [sql, binds]
+          result = nil
+          hit = false
+
+          @lock.synchronize do
+            if (result = @query_cache.delete(key))
+              hit = true
+              @query_cache[key] = result
             else
-              query_cache[sql][binds] = yield
+              result = @query_cache[key] = yield
+              @query_cache.shift if @query_cache_max_size && @query_cache.size > @query_cache_max_size
             end
+          end
+
+          if hit
+            ::ActiveSupport::Notifications.instrument(
+              "sql.active_record",
+              cache_notification_info(sql, name, binds)
+            )
+          end
+
           result.dup
         end
       end

data/lib/switchman/active_record/query_methods.rb

@@ -175,7 +175,7 @@ module Switchman
       end
 
       def sharded_foreign_key?(relation, column)
-        models_for_table(relation.table_name).any? { |m| m.sharded_column?(column) }
+        models_for_table(relation.name).any? { |m| m.sharded_column?(column) }
       end
 
       def sharded_primary_key?(relation, column)
@@ -187,7 +187,7 @@ module Switchman
 
       def source_shard_for_foreign_key(relation, column)
         reflection = nil
-        models_for_table(relation.table_name).each do |model|
+        models_for_table(relation.name).each do |model|
           reflection = model.send(:reflection_for_integer_attribute, column)
           break if reflection
         end

data/lib/switchman/active_record/test_fixtures.rb

@@ -14,21 +14,28 @@ module Switchman
         # Code adapted from the code in rails proper
         @connection_subscriber =
           ::ActiveSupport::Notifications.subscribe("!connection.active_record") do |_, _, _, _, payload|
-            spec_name = payload[:spec_name] if payload.key?(:spec_name)
+            spec_name = if ::Rails.version < "7.1"
+                          payload[:spec_name] if payload.key?(:spec_name)
+                        elsif payload.key?(:connection_name)
+                          payload[:connection_name]
+                        end
             shard = payload[:shard] if payload.key?(:shard)
-            setup_shared_connection_pool
 
             if spec_name && !FORBIDDEN_DB_ENVS.include?(shard)
               begin
                 connection = ::ActiveRecord::Base.connection_handler.retrieve_connection(spec_name, shard: shard)
+                connection.connect! if ::Rails.version >= "7.1" # eagerly validate the connection
               rescue ::ActiveRecord::ConnectionNotEstablished, ::ActiveRecord::NoDatabaseError
                 connection = nil
               end
 
-              if connection && !@fixture_connections.include?(connection)
-                connection.begin_transaction joinable: false, _lazy: false
-                connection.pool.lock_thread = true if lock_threads
-                @fixture_connections << connection
+              if connection
+                setup_shared_connection_pool
+                unless @fixture_connections.include?(connection)
+                  connection.begin_transaction joinable: false, _lazy: false
+                  connection.pool.lock_thread = true if lock_threads
+                  @fixture_connections << connection
+                end
               end
             end
           end
@@ -37,7 +44,7 @@ module Switchman
       def enlist_fixture_connections
         setup_shared_connection_pool
 
-        ::ActiveRecord::Base.connection_handler.connection_pool_list.reject do |cp|
+        ::ActiveRecord::Base.connection_handler.connection_pool_list(:primary).reject do |cp|
           FORBIDDEN_DB_ENVS.include?(cp.db_config.env_name.to_sym)
         end.map(&:connection)
       end

data/lib/switchman/arel.rb

@@ -24,27 +24,29 @@ module Switchman
           collector << quote_local_table_name(join_name) << "." << quote_column_name(o.name)
         end
 
-        def visit_Arel_Nodes_HomogeneousIn(o, collector)
-          collector.preparable = false
+        if ::Rails.version < "7.1"
+          def visit_Arel_Nodes_HomogeneousIn(o, collector)
+            collector.preparable = false
 
-          collector << quote_local_table_name(o.table_name) << "." << quote_column_name(o.column_name)
+            collector << quote_local_table_name(o.table_name) << "." << quote_column_name(o.column_name)
 
-          collector << if o.type == :in
-                         " IN ("
-                       else
-                         " NOT IN ("
-                       end
+            collector << if o.type == :in
+                           " IN ("
+                         else
+                           " NOT IN ("
+                         end
 
-          values = o.casted_values
+            values = o.casted_values
 
-          if values.empty?
-            collector << @connection.quote(nil)
-          else
-            collector.add_binds(values, o.proc_for_binds, &bind_block)
-          end
+            if values.empty?
+              collector << @connection.quote(nil)
+            else
+              collector.add_binds(values, o.proc_for_binds, &bind_block)
+            end
 
-          collector << ")"
-          collector
+            collector << ")"
+            collector
+          end
         end
 
         # rubocop:enable Naming/MethodName

data/lib/switchman/database_server.rb

@@ -228,7 +228,11 @@ module Switchman
           unless schema == false
             shard.activate do
               ::ActiveRecord::Base.connection.transaction(requires_new: true) do
-                ::ActiveRecord::Base.connection.migration_context.migrate
+                if ::Rails.version < "7.1"
+                  ::ActiveRecord::Base.connection.migration_context.migrate
+                else
+                  ::ActiveRecord::MigrationContext.new(::ActiveRecord::Migrator.migrations_paths).migrate
+                end
               end
 
               ::ActiveRecord::Base.descendants.reject do |m|

data/lib/switchman/engine.rb

@@ -5,7 +5,7 @@ module Switchman
     isolate_namespace Switchman
 
     # enable Rails 6.1 style connection handling
-    config.active_record.legacy_connection_handling = false
+    config.active_record.legacy_connection_handling = false if ::Rails.version < "7.1"
     config.active_record.writing_role = :primary
 
     ::GuardRail.singleton_class.prepend(GuardRail::ClassMethods)
@@ -60,6 +60,9 @@ module Switchman
           )
         end
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::AbstractAdapter)
+        unless ::Rails.version < "7.1"
+          ::ActiveRecord::ConnectionAdapters::ConnectionHandler.prepend(ActiveRecord::ConnectionHandler)
+        end
         ::ActiveRecord::ConnectionAdapters::ConnectionPool.prepend(ActiveRecord::ConnectionPool)
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::QueryCache)
         ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(ActiveRecord::PostgreSQLAdapter)

data/lib/switchman/shard.rb

@@ -166,7 +166,11 @@ module Switchman
           # clear connections prior to forking (no more queries will be executed in the parent,
           # and we want them gone so that we don't accidentally use them post-fork doing something
           # silly like dealloc'ing prepared statements)
-          ::ActiveRecord::Base.clear_all_connections!
+          if ::Rails.version < "7.1"
+            ::ActiveRecord::Base.clear_all_connections!(nil)
+          else
+            ::ActiveRecord::Base.connection_handler.clear_all_connections!(:all)
+          end
 
           parent_process_name = sanitized_process_title
           ret = ::Parallel.map(scopes, in_processes: (scopes.length > 1) ? parallel : 0) do |server, subscope|
@@ -258,7 +262,7 @@ module Switchman
             else
               shard = partition_object.shard
             end
-          when Integer, /^\d+$/, /^(\d+)~(\d+)$/
+          when Integer, /\A\d+\Z/, /\A(\d+)~(\d+)\Z/
             local_id, shard = Shard.local_id_for(partition_object)
             local_id ||= partition_object
             object = local_id unless partition_proc
@@ -300,14 +304,14 @@ module Switchman
         case any_id
         when ::ActiveRecord::Base
           any_id.id
-        when /^(\d+)~(-?\d+)$/
+        when /\A(\d+)~(-?\d+)\Z/
           local_id = $2.to_i
           signed_id_operation(local_id) do |id|
             return nil if id > IDS_PER_SHARD
 
             ($1.to_i * IDS_PER_SHARD) + id
           end
-        when Integer, /^-?\d+$/
+        when Integer, /\A-?\d+\Z/
           any_id.to_i
         end
       end
@@ -410,7 +414,10 @@ module Switchman
             end
           end
 
+          # this resets the default shard on rails 7.1+, but we want to preserve it
+          shard_was = klass.default_shard
           klass.connects_to shards: connects_to_hash
+          klass.default_shard = shard_was
         end
       end
 
@@ -519,6 +526,10 @@ module Switchman
       id
     end
 
+    def original_id_value
+      id
+    end
+
     def activate(*classes, &block)
       shards = hashify_classes(classes)
       Shard.activate(shards, &block)

data/lib/switchman/test_helper.rb

@@ -19,7 +19,7 @@ module Switchman
         end
 
         server1 = Shard.default.database_server
-        server2 = DatabaseServer.create(Shard.default.database_server.config.merge(server2: true))
+        server2 = DatabaseServer.create(Shard.default.database_server.config.merge(server2: true, schema_dump: false))
 
         if server1 == Shard.default.database_server && server1.config[:shard1] && server1.config[:shard2]
           # look for the shards in the db already

data/lib/switchman/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Switchman
-  VERSION = "3.5.12"
+  VERSION = "3.5.13"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: switchman
 version: !ruby/object:Gem::Version
-  version: 3.5.12
+  version: 3.5.13
 platform: ruby
 authors:
 - Cody Cutrer
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-03 00:00:00.000000000 Z
+date: 2023-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -21,7 +21,7 @@ dependencies:
         version: 6.1.4
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -31,7 +31,7 @@ dependencies:
         version: 6.1.4
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: guardrail
   requirement: !ruby/object:Gem::Requirement
@@ -69,7 +69,7 @@ dependencies:
         version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -79,21 +79,21 @@ dependencies:
         version: '6.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '7.2'
 - !ruby/object:Gem::Dependency
-  name: byebug
+  name: debug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -108,20 +108,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -255,6 +241,7 @@ files:
 - lib/switchman/active_record/attribute_methods.rb
 - lib/switchman/active_record/base.rb
 - lib/switchman/active_record/calculations.rb
+- lib/switchman/active_record/connection_handler.rb
 - lib/switchman/active_record/connection_pool.rb
 - lib/switchman/active_record/database_configurations.rb
 - lib/switchman/active_record/database_configurations/database_config.rb