switchman 3.1.0 → 3.5.0

data/lib/switchman/database_server.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'securerandom'
+require "securerandom"
 
 module Switchman
   class DatabaseServer
@@ -16,13 +16,13 @@ module Switchman
 
       def find(id_or_all)
         return all if id_or_all == :all
-        return id_or_all.map { |id| database_servers[id || ::Rails.env] }.compact.uniq if id_or_all.is_a?(Array)
+        return id_or_all.filter_map { |id| database_servers[id || ::Rails.env] }.uniq if id_or_all.is_a?(Array)
 
         database_servers[id_or_all || ::Rails.env]
       end
 
       def create(settings = {})
-        raise 'database servers should be set up in database.yml' unless ::Rails.env.test?
+        raise "database servers should be set up in database.yml" unless ::Rails.env.test?
 
         id = settings[:id]
         unless id
@@ -64,8 +64,8 @@ module Switchman
           @database_servers = {}.with_indifferent_access
           roles = []
           ::ActiveRecord::Base.configurations.configurations.each do |config|
-            if config.name.include?('/')
-              name, role = config.name.split('/')
+            if config.name.include?("/")
+              name, role = config.name.split("/")
             else
               name, role = config.env_name, config.name
             end
@@ -110,8 +110,9 @@ module Switchman
       self.class.send(:database_servers).delete(id) if id
       Shard.sharded_models.each do |klass|
         self.class.all_roles.each do |role|
-          klass.connection_handler.remove_connection_pool(klass.connection_specification_name, role: role,
-                                                                                               shard: id.to_sym)
+          klass.connection_handler.remove_connection_pool(klass.connection_specification_name,
+                                                          role: role,
+                                                          shard: id.to_sym)
         end
       end
     end
@@ -142,11 +143,13 @@ module Switchman
     # value of GuardRail.environment)
     def guard!(environment = :secondary)
       DatabaseServer.send(:reference_role, environment)
-      ::ActiveRecord::Base.connected_to_stack << { shard_roles: { id.to_sym => environment }, klasses: [::ActiveRecord::Base] }
+      ::ActiveRecord::Base.connected_to_stack << { shard_roles: { id.to_sym => environment },
+                                                   klasses: [::ActiveRecord::Base] }
     end
 
     def unguard!
-      ::ActiveRecord::Base.connected_to_stack << { shard_roles: { id.to_sym => :_switchman_inherit }, klasses: [::ActiveRecord::Base] }
+      ::ActiveRecord::Base.connected_to_stack << { shard_roles: { id.to_sym => :_switchman_inherit },
+                                                   klasses: [::ActiveRecord::Base] }
     end
 
     def unguard
@@ -162,7 +165,7 @@ module Switchman
 
     def shards
       if id == ::Rails.env
-        Shard.where('database_server_id IS NULL OR database_server_id=?', id)
+        Shard.where("database_server_id IS NULL OR database_server_id=?", id)
       else
         Shard.where(database_server_id: id)
       end
@@ -187,7 +190,7 @@ module Switchman
       end
 
       id ||= begin
-        id_seq = Shard.connection.quote(Shard.connection.quote_table_name('switchman_shards_id_seq'))
+        id_seq = Shard.connection.quote(Shard.connection.quote_table_name("switchman_shards_id_seq"))
         next_id = Shard.connection.select_value("SELECT nextval(#{id_seq})")
         next_id.to_i
       end
@@ -204,29 +207,28 @@ module Switchman
                                 name: name,
                                 database_server_id: self.id)
           if create_statement
-            if ::ActiveRecord::Base.connection.select_value("SELECT 1 FROM pg_namespace WHERE nspname=#{::ActiveRecord::Base.connection.quote(name)}")
+            if ::ActiveRecord::Base.connection.select_value(
+              "SELECT 1 FROM pg_namespace WHERE nspname=#{::ActiveRecord::Base.connection.quote(name)}"
+            )
               schema_already_existed = true
-              raise 'This schema already exists; cannot overwrite'
+              raise "This schema already exists; cannot overwrite"
             end
             Array(create_statement.call).each do |stmt|
               ::ActiveRecord::Base.connection.execute(stmt)
             end
           end
-          if config[:adapter] == 'postgresql'
-            old_proc = ::ActiveRecord::Base.connection.raw_connection.set_notice_processor do
-            end
+          if config[:adapter] == "postgresql"
+            old_proc = ::ActiveRecord::Base.connection.raw_connection.set_notice_processor {}
           end
           old_verbose = ::ActiveRecord::Migration.verbose
           ::ActiveRecord::Migration.verbose = false
 
           unless schema == false
             shard.activate do
-              reset_column_information
-
               ::ActiveRecord::Base.connection.transaction(requires_new: true) do
                 ::ActiveRecord::Base.connection.migration_context.migrate
               end
-              reset_column_information
+
               ::ActiveRecord::Base.descendants.reject do |m|
                 m <= UnshardedRecord || !m.table_exists?
               end.each(&:define_attribute_methods)
@@ -240,7 +242,6 @@ module Switchman
       rescue
         shard&.destroy
         shard&.drop_database rescue nil unless schema_already_existed
-        reset_column_information unless schema == false rescue nil
         raise
       ensure
         self.class.creating_new_shard = false
@@ -272,11 +273,5 @@ module Switchman
       end
       @primary_shard
     end
-
-    private
-
-    def reset_column_information
-      ::ActiveRecord::Base.descendants.reject { |m| m <= UnshardedRecord }.each(&:reset_column_information)
-    end
   end
 end

data/lib/switchman/default_shard.rb

@@ -3,9 +3,9 @@
 module Switchman
   class DefaultShard
     def id
-      'default'
+      "default"
     end
-    alias cache_key id
+    alias_method :cache_key, :id
     def activate(*_classes)
       yield
     end
@@ -58,7 +58,7 @@ module Switchman
     end
 
     def _dump(_depth)
-      ''
+      ""
     end
 
     def self._load(_str)

data/lib/switchman/engine.rb

@@ -10,19 +10,23 @@ module Switchman
 
     ::GuardRail.singleton_class.prepend(GuardRail::ClassMethods)
 
-    # after :initialize_dependency_mechanism to ensure autoloading is configured for any downstream initializers that care
-    # In rails 7.0 we should be able to just use an explicit after on configuring the once autoloaders and not need to go monkey around with initializer order
-    if ::Rails.version < '7.0'
-      initialize_dependency_mechanism = ::Rails::Application::Bootstrap.initializers.find { |i| i.name == :initialize_dependency_mechanism }
+    # after :initialize_dependency_mechanism to ensure autoloading is
+    # configured for any downstream initializers that care. In rails 7.0 we
+    # should be able to just use an explicit after on configuring the once
+    # autoloaders and not need to go monkey around with initializer order
+    if ::Rails.version < "7.0"
+      initialize_dependency_mechanism = ::Rails::Application::Bootstrap.initializers.find do |i|
+        i.name == :initialize_dependency_mechanism
+      end
       initialize_dependency_mechanism.instance_variable_get(:@options)[:after] = :set_autoload_paths
     end
 
-    initializer 'switchman.active_record_patch',
-                before: 'active_record.initialize_database',
-                after: (::Rails.version < '7.0' ? :initialize_dependency_mechanism : :setup_once_autoloader) do
+    initializer "switchman.active_record_patch",
+                before: "active_record.initialize_database",
+                after: ((::Rails.version < "7.0") ? :initialize_dependency_mechanism : :setup_once_autoloader) do
       ::ActiveSupport.on_load(:active_record) do
         # Switchman requires postgres, so just always load the pg adapter
-        require 'active_record/connection_adapters/postgresql_adapter'
+        require "active_record/connection_adapters/postgresql_adapter"
 
         self.default_shard = ::Rails.env.to_sym
         self.default_role = :primary
@@ -50,14 +54,20 @@ module Switchman
         ::ActiveRecord::Associations::CollectionProxy.include(ActiveRecord::Associations::CollectionProxy)
 
         ::ActiveRecord::Associations::Preloader::Association.prepend(ActiveRecord::Associations::Preloader::Association)
-        ::ActiveRecord::Associations::Preloader::Association::LoaderQuery.prepend(ActiveRecord::Associations::Preloader::Association::LoaderQuery) unless ::Rails.version < '7.0'
+        unless ::Rails.version < "7.0"
+          ::ActiveRecord::Associations::Preloader::Association::LoaderRecords.prepend(
+            ActiveRecord::Associations::Preloader::Association::LoaderRecords
+          )
+        end
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::AbstractAdapter)
         ::ActiveRecord::ConnectionAdapters::ConnectionPool.prepend(ActiveRecord::ConnectionPool)
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::QueryCache)
         ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(ActiveRecord::PostgreSQLAdapter)
 
         ::ActiveRecord::DatabaseConfigurations.prepend(ActiveRecord::DatabaseConfigurations)
-        ::ActiveRecord::DatabaseConfigurations::DatabaseConfig.prepend(ActiveRecord::DatabaseConfigurations::DatabaseConfig)
+        ::ActiveRecord::DatabaseConfigurations::DatabaseConfig.prepend(
+          ActiveRecord::DatabaseConfigurations::DatabaseConfig
+        )
 
         ::ActiveRecord::LogSubscriber.prepend(ActiveRecord::LogSubscriber)
         ::ActiveRecord::Migration.prepend(ActiveRecord::Migration)
@@ -77,8 +87,12 @@ module Switchman
         ::ActiveRecord::Relation.include(ActiveRecord::SpawnMethods)
         ::ActiveRecord::Relation.include(CallSuper)
 
-        ::ActiveRecord::PredicateBuilder::AssociationQueryValue.prepend(ActiveRecord::PredicateBuilder::AssociationQueryValue)
-        ::ActiveRecord::PredicateBuilder::PolymorphicArrayValue.prepend(ActiveRecord::PredicateBuilder::AssociationQueryValue)
+        ::ActiveRecord::PredicateBuilder::AssociationQueryValue.prepend(
+          ActiveRecord::PredicateBuilder::AssociationQueryValue
+        )
+        ::ActiveRecord::PredicateBuilder::PolymorphicArrayValue.prepend(
+          ActiveRecord::PredicateBuilder::AssociationQueryValue
+        )
 
         ::ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(ActiveRecord::Tasks::DatabaseTasks)
 
@@ -96,17 +110,18 @@ module Switchman
 
         ::ActiveRecord::ConnectionAdapters::TableDefinition.prepend(ActiveRecord::TableDefinition)
       end
-      # Ensure that ActiveRecord::Base is always loaded before any app-level initializers can go try to load Switchman::Shard or we get a loop
+      # Ensure that ActiveRecord::Base is always loaded before any app-level
+      # initializers can go try to load Switchman::Shard or we get a loop
       ::ActiveRecord::Base
     end
 
-    initializer 'switchman.error_patch', after: 'active_record.initialize_database' do
+    initializer "switchman.error_patch", after: "active_record.initialize_database" do
       ::ActiveSupport.on_load(:active_record) do
         ::StandardError.include(StandardError)
       end
     end
 
-    initializer 'switchman.initialize_cache', before: :initialize_cache, after: 'active_record.initialize_database' do
+    initializer "switchman.initialize_cache", before: :initialize_cache, after: "active_record.initialize_database" do
       ::ActiveSupport::Cache.singleton_class.prepend(ActiveSupport::Cache::ClassMethods)
 
       # if we haven't already setup our cache map out-of-band, set it up from
@@ -130,11 +145,11 @@ module Switchman
         Switchman.config[:cache_map][::Rails.env] = value
       end
 
-      middlewares = Switchman.config[:cache_map].values.map do |store|
+      middlewares = Switchman.config[:cache_map].values.filter_map do |store|
         store.middleware if store.respond_to?(:middleware)
-      end.compact.uniq
+      end.uniq
       middlewares.each do |middleware|
-        config.middleware.insert_before('Rack::Runtime', middleware)
+        config.middleware.insert_before("Rack::Runtime", middleware)
       end
 
       # prevent :initialize_cache from trying to (or needing to) set

data/lib/switchman/environment.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'etc'
+require "etc"
 
 module Switchman
   class Environment
-    def self.cpu_count(nproc_bin = 'nproc')
+    def self.cpu_count(nproc_bin = "nproc")
       return Etc.nprocessors if Etc.respond_to?(:nprocessors)
 
       `#{nproc_bin}`.to_i

data/lib/switchman/errors.rb

@@ -2,8 +2,21 @@
 
 module Switchman
   module Errors
+    class ManuallyCreatedShadowRecordError < RuntimeError
+      DEFAULT_MSG = "It looks like you're trying to manually create a shadow record. " \
+                    "Please use Switchman::ActiveRecord::Base#save_shadow_record instead."
+
+      def initialize(msg = DEFAULT_MSG)
+        super
+      end
+    end
+
     class NonExistentShardError < RuntimeError; end
 
     class ParallelShardExecError < RuntimeError; end
+
+    class ShadowRecordError < RuntimeError; end
+
+    class UnshardedTableError < RuntimeError; end
   end
 end

data/lib/switchman/guard_rail/relation.rb

@@ -13,8 +13,9 @@ module Switchman
       end
 
       %w[update_all delete_all].each do |method|
+        arg_params = (RUBY_VERSION <= "2.8") ? "*args" : "*args, **kwargs"
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{method}(*args)
+          def #{method}(#{arg_params})
             db = Shard.current(connection_class_for_self).database_server
             db.unguard { super }
           end

data/lib/switchman/parallel.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'parallel'
+require "parallel"
 
 module Switchman
   module Parallel
@@ -65,4 +65,4 @@ module Switchman
   end
 end
 
-::Parallel::UndumpableException.prepend(::Switchman::Parallel::UndumpableException)
+Parallel::UndumpableException.prepend(Switchman::Parallel::UndumpableException)

data/lib/switchman/r_spec_helper.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'switchman/test_helper'
+require "switchman/test_helper"
 
 module Switchman
   # including this module in your specs will give you several shards to
@@ -34,9 +34,9 @@ module Switchman
         groups = group.class.descendant_filtered_examples.map(&:example_group).uniq
         next unless groups.any? { |descendant_group| RSpecHelper.included_in?(descendant_group) }
 
-        puts 'Setting up sharding for all specs...'
+        puts "Setting up sharding for all specs..."
         Shard.delete_all
-        Switchman.cache.delete('default_shard')
+        Switchman.cache.delete("default_shard")
 
         @@shard1, @@shard2 = TestHelper.recreate_persistent_test_shards
         @@default_shard = Shard.default
@@ -48,7 +48,7 @@ module Switchman
             @@shard1 = @@shard1.create_new_shard
             @@shard2 = @@shard2.create_new_shard
           rescue => e
-            warn 'Sharding setup FAILED!:'
+            warn "Sharding setup FAILED!:"
             while e
               warn "\n#{e}\n"
               warn e.backtrace
@@ -66,9 +66,9 @@ module Switchman
         # we'll re-persist in the group's `before :all`; we don't want them to exist
         # in the db before then
         Shard.delete_all
-        Switchman.cache.delete('default_shard')
+        Switchman.cache.delete("default_shard")
         Shard.default(reload: true)
-        puts 'Done!'
+        puts "Done!"
 
         main_pid = Process.pid
         at_exit do
@@ -76,7 +76,7 @@ module Switchman
 
           # preserve rspec's exit status
           status = $!.is_a?(::SystemExit) ? $!.status : nil
-          puts 'Tearing down sharding for all specs'
+          puts "Tearing down sharding for all specs"
           @@shard1.database_server.destroy unless @@shard1.database_server == Shard.default.database_server
           unless @@keep_the_shards
             @@shard1.drop_database
@@ -95,7 +95,7 @@ module Switchman
         dup = @@default_shard.dup
         dup.id = @@default_shard.id
         dup.save!
-        Switchman.cache.delete('default_shard')
+        Switchman.cache.delete("default_shard")
         Shard.default(reload: true)
         dup = @@shard1.dup
         dup.id = @@shard1.id
@@ -107,7 +107,7 @@ module Switchman
       end
 
       klass.before do
-        raise 'Sharding did not set up correctly' if @@sharding_failed
+        raise "Sharding did not set up correctly" if @@sharding_failed
 
         Shard.clear_cache
         if use_transactional_tests
@@ -132,7 +132,7 @@ module Switchman
       klass.after(:all) do
         # Don't truncate because that can create some fun cross-connection lock contention
         Shard.delete_all
-        Switchman.cache.delete('default_shard')
+        Switchman.cache.delete("default_shard")
         Shard.default(reload: true)
       end
     end

data/lib/switchman/shard.rb

@@ -36,13 +36,15 @@ module Switchman
 
           # Now find the actual record, if it exists
           @default = begin
-            find_cached('default_shard') { Shard.where(default: true).take } || default
+            find_cached("default_shard") { Shard.where(default: true).take } || default
           rescue
             default
           end
 
           # make sure this is not erroneously cached
-          @default.database_server.remove_instance_variable(:@primary_shard) if @default.database_server.instance_variable_defined?(:@primary_shard)
+          if @default.database_server.instance_variable_defined?(:@primary_shard)
+            @default.database_server.remove_instance_variable(:@primary_shard)
+          end
 
           # and finally, check for cached references to the default shard on the existing connection
           sharded_models.each do |klass|
@@ -75,28 +77,30 @@ module Switchman
                       klass.current_switchman_shard != shard
 
           (activated_classes ||= []) << klass
-          klass.connected_to_stack << { shard: shard.database_server.id.to_sym, klasses: [klass], switchman_shard: shard }
+          klass.connected_to_stack << { shard: shard.database_server.id.to_sym,
+                                        klasses: [klass],
+                                        switchman_shard: shard }
         end
         activated_classes
       end
 
       def active_shards
-        sharded_models.map do |klass|
+        sharded_models.filter_map do |klass|
           [klass, current(klass)]
-        end.compact.to_h
+        end.to_h
       end
 
       def lookup(id)
         id_i = id.to_i
-        return current if id_i == current.id || id == 'self'
-        return default if id_i == default.id || id.nil? || id == 'default'
+        return current if id_i == current.id || id == "self"
+        return default if id_i == default.id || id.nil? || id == "default"
 
         id = id_i
         raise ArgumentError if id.zero?
 
         unless cached_shards.key?(id)
           cached_shards[id] = Shard.default.activate do
-            find_cached(['shard', id]) { find_by(id: id) }
+            find_cached(["shard", id]) { find_by(id: id) }
           end
         end
         cached_shards[id]
@@ -120,7 +124,8 @@ module Switchman
       #                forking.
       #    exception: - :ignore, :raise, :defer (wait until the end and raise the first
       #                error), or a proc
-      def with_each_shard(*args, parallel: false, exception: :raise, &block)
+      #    output: - :simple, :decorated (with database_server_id:shard_name)
+      def with_each_shard(*args, parallel: false, exception: :raise, output: :simple)
         raise ArgumentError, "wrong number of arguments (#{args.length} for 0...2)" if args.length > 2
 
         return Array.wrap(yield) unless default.is_a?(Shard)
@@ -139,13 +144,15 @@ module Switchman
         parallel = 0 if parallel == false || parallel.nil?
 
         scope ||= Shard.all
-        scope = scope.order(::Arel.sql('database_server_id IS NOT NULL, database_server_id, id')) if ::ActiveRecord::Relation === scope && scope.order_values.empty?
+        if ::ActiveRecord::Relation === scope && scope.order_values.empty?
+          scope = scope.order(::Arel.sql("database_server_id IS NOT NULL, database_server_id, id"))
+        end
 
         if parallel > 1
           if ::ActiveRecord::Relation === scope
             # still need a post-uniq, cause the default database server could be NULL or Rails.env in the db
-            database_servers = scope.reorder('database_server_id').select(:database_server_id).distinct.
-                               map(&:database_server).compact.uniq
+            database_servers = scope.reorder("database_server_id").select(:database_server_id).distinct
+                                    .filter_map(&:database_server).uniq
             # nothing to do
             return if database_servers.count.zero?
 
@@ -162,22 +169,23 @@ module Switchman
           ::ActiveRecord::Base.clear_all_connections!
 
           parent_process_name = `ps -ocommand= -p#{Process.pid}`.slice(/#{$0}.*/)
-          ret = ::Parallel.map(scopes, in_processes: scopes.length > 1 ? parallel : 0) do |server, subscope|
+          ret = ::Parallel.map(scopes, in_processes: (scopes.length > 1) ? parallel : 0) do |server, subscope|
             name = server.id
-            # rubocop:disable Style/GlobalStdStream
-            $stdout = Parallel::PrefixingIO.new(name, STDOUT)
-            $stderr = Parallel::PrefixingIO.new(name, STDERR)
-            # rubocop:enable Style/GlobalStdStream
+            last_description = name
+
             begin
               max_length = 128 - name.length - 3
               short_parent_name = parent_process_name[0..max_length] if max_length >= 0
-              new_title = [short_parent_name, name].join(' ')
+              new_title = [short_parent_name, name].join(" ")
               Process.setproctitle(new_title)
               Switchman.config[:on_fork_proc]&.call
-              with_each_shard(subscope, classes, exception: exception, &block).map { |result| Parallel::ResultWrapper.new(result) }
+              with_each_shard(subscope, classes, exception: exception, output: :decorated) do
+                last_description = Shard.current.description
+                Parallel::ResultWrapper.new(yield)
+              end
             rescue => e
               logger.error e.full_message
-              Parallel::QuietExceptionWrapper.new(name, ::Parallel::ExceptionWrapper.new(e))
+              Parallel::QuietExceptionWrapper.new(last_description, ::Parallel::ExceptionWrapper.new(e))
             end
           end.flatten
 
@@ -185,8 +193,9 @@ module Switchman
           unless errors.empty?
             raise errors.first.exception if errors.length == 1
 
+            errors_desc = errors.map(&:name).sort.join(", ")
             raise Errors::ParallelShardExecError,
-                  "The following database server(s) did not finish processing cleanly: #{errors.map(&:name).sort.join(', ')}",
+                  "The following database server(s) did not finish processing cleanly: #{errors_desc}",
                   cause: errors.first.exception
           end
 
@@ -195,14 +204,20 @@ module Switchman
 
         classes ||= []
 
-        previous_shard = nil
         result = []
         ex = nil
+        old_stdout = $stdout
+        old_stderr = $stderr
         scope.each do |shard|
           # shard references a database server that isn't configured in this environment
           next unless shard.database_server
 
           shard.activate(*classes) do
+            if output == :decorated
+              $stdout = Parallel::PrefixingIO.new(shard.description, $stdout)
+              $stderr = Parallel::PrefixingIO.new(shard.description, $stderr)
+            end
+
             result.concat Array.wrap(yield)
           rescue
             case exception
@@ -216,8 +231,10 @@ module Switchman
             else
               raise
             end
+          ensure
+            $stdout = old_stdout
+            $stderr = old_stderr
           end
-          previous_shard = shard
         end
         raise ex if ex
 
@@ -457,7 +474,7 @@ module Switchman
     end
 
     def description
-      [database_server.id, name].compact.join(':')
+      [database_server.id, name].compact.join(":")
     end
 
     # Shards are always on the default shard
@@ -491,7 +508,7 @@ module Switchman
     end
 
     def drop_database
-      raise('Cannot drop the database of the default shard') if default?
+      raise("Cannot drop the database of the default shard") if default?
       return unless read_attribute(:name)
 
       begin
@@ -500,12 +517,12 @@ module Switchman
         drop_statement = sharding_config[adapter]&.[](:drop_statement)
         drop_statement ||= sharding_config[:drop_statement]
         if drop_statement
-          drop_statement = Array(drop_statement).dup.
-                           map { |statement| statement.gsub('%{name}', name) }
+          drop_statement = Array(drop_statement).dup
+                                                .map { |statement| statement.gsub("%{name}", name) }
         end
 
         case adapter
-        when 'mysql', 'mysql2'
+        when "mysql", "mysql2"
           activate do
             ::GuardRail.activate(:deploy) do
               drop_statement ||= "DROP DATABASE #{name}"
@@ -514,7 +531,7 @@ module Switchman
               end
             end
           end
-        when 'postgresql'
+        when "postgresql"
           activate do
             ::GuardRail.activate(:deploy) do
               # Shut up, Postgres!
@@ -551,7 +568,7 @@ module Switchman
     end
 
     def destroy
-      raise('Cannot destroy the default shard') if default?
+      raise("Cannot destroy the default shard") if default?
 
       super
     end
@@ -560,8 +577,8 @@ module Switchman
 
     def clear_cache
       Shard.default.activate do
-        Switchman.cache.delete(['shard', id].join('/'))
-        Switchman.cache.delete('default_shard') if default?
+        Switchman.cache.delete(["shard", id].join("/"))
+        Switchman.cache.delete("default_shard") if default?
       end
       self.class.clear_cache
     end

data/lib/switchman/sharded_instrumenter.rb

@@ -16,7 +16,11 @@ module Switchman
         payload[:shard] = {
           database_server_id: shard.database_server.id,
           id: shard.id,
-          env: ::Rails.version < '7.0' ? @shard_host.pool.connection_klass&.current_role : @shard_host.pool.connection_class&.current_role
+          env: if ::Rails.version < "7.0"
+                 @shard_host.pool.connection_klass&.current_role
+               else
+                 @shard_host.pool.connection_class&.current_role
+               end
         }
       end
       super name, payload

data/lib/switchman/shared_schema_cache.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Switchman
+  class SharedSchemaCache
+    def self.get_schema_cache(connection)
+      @schema_cache ||= ::ActiveRecord::ConnectionAdapters::SchemaCache.new(connection)
+      @schema_cache.connection = connection
+      @schema_cache
+    end
+  end
+end

data/lib/switchman/test_helper.rb

@@ -65,7 +65,7 @@ module Switchman
         if server == Shard.default.database_server
           server.shards.where(name: name).first
         else
-          shard = Shard.where('database_server_id IS NOT NULL AND name=?', name).first
+          shard = Shard.where("database_server_id IS NOT NULL AND name=?", name).first
           # if somehow databases got created in a different order, change the shard to match
           shard.database_server = server if shard
           shard

data/lib/switchman/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Switchman
-  VERSION = '3.1.0'
+  VERSION = "3.5.0"
 end