switchman 3.3.6 → 4.2.5

data/lib/switchman/active_record/test_fixtures.rb

@@ -4,39 +4,85 @@ module Switchman
   module ActiveRecord
     module TestFixtures
       FORBIDDEN_DB_ENVS = %i[development production].freeze
-      def setup_fixtures(config = ::ActiveRecord::Base)
-        super
 
-        return unless run_in_transaction?
+      if ::Rails.version < "7.2"
+        def setup_fixtures(config = ::ActiveRecord::Base)
+          super
+          return unless run_in_transaction?
 
-        # Replace the one that activerecord natively uses with a switchman-optimized one
-        ::ActiveSupport::Notifications.unsubscribe(@connection_subscriber)
-        # 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)
-          shard = payload[:shard] if payload.key?(:shard)
-          setup_shared_connection_pool
+          # Replace the one that activerecord natively uses with a switchman-optimized one
+          ::ActiveSupport::Notifications.unsubscribe(@connection_subscriber)
+          # Code adapted from the code in rails proper
+          @connection_subscriber =
+            ::ActiveSupport::Notifications.subscribe("!connection.active_record") do |_, _, _, _, payload|
+              spec_name = (payload[:connection_name] if payload.key?(:connection_name))
+              shard = payload[:shard] if payload.key?(:shard)
 
-          if spec_name && !FORBIDDEN_DB_ENVS.include?(shard)
-            begin
-              connection = ::ActiveRecord::Base.connection_handler.retrieve_connection(spec_name, shard: shard)
-            rescue ::ActiveRecord::ConnectionNotEstablished, ::ActiveRecord::NoDatabaseError
-              connection = nil
-            end
+              if spec_name && !FORBIDDEN_DB_ENVS.include?(shard)
+                begin
+                  connection = ::ActiveRecord::Base.connection_handler.retrieve_connection(spec_name, shard:)
+                  connection.connect! # eagerly validate the connection
+                rescue ::ActiveRecord::ConnectionNotEstablished
+                  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
-          end
         end
-      end
 
-      def enlist_fixture_connections
-        setup_shared_connection_pool
+        def enlist_fixture_connections
+          setup_shared_connection_pool
 
-        ::ActiveRecord::Base.connection_handler.connection_pool_list.reject { |cp| FORBIDDEN_DB_ENVS.include?(cp.db_config.env_name.to_sym) }.map(&:connection)
+          ::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
+      else
+        def setup_transactional_fixtures
+          setup_shared_connection_pool
+
+          # Begin transactions for connections already established
+          # INST: :writing -> :primary
+          @fixture_connection_pools = ::ActiveRecord::Base.connection_handler.connection_pool_list(:primary)
+          # INST: filter by FORBIDDEN_DB_ENVS
+          @fixture_connection_pools = @fixture_connection_pools.reject do |cp|
+            FORBIDDEN_DB_ENVS.include?(cp.db_config.env_name.to_sym)
+          end
+
+          @fixture_connection_pools.each do |pool|
+            pool.pin_connection!(lock_threads)
+            pool.lease_connection
+          end
+
+          # When connections are established in the future, begin a transaction too
+          @connection_subscriber = ::ActiveSupport::Notifications
+                                   .subscribe("!connection.active_record") do |_, _, _, _, payload|
+            connection_name = payload[:connection_name] if payload.key?(:connection_name)
+            shard = payload[:shard] if payload.key?(:shard)
+
+            # INST: filter by FORBIDDEN_DB_ENVS
+            if connection_name && !FORBIDDEN_DB_ENVS.include?(shard)
+              pool = ::ActiveRecord::Base.connection_handler.retrieve_connection_pool(connection_name, shard:)
+              if pool
+                setup_shared_connection_pool
+
+                unless @fixture_connection_pools.include?(pool)
+                  pool.pin_connection!(lock_threads)
+                  pool.lease_connection
+                  @fixture_connection_pools << pool
+                end
+              end
+            end
+          end
+        end
       end
     end
   end

data/lib/switchman/active_support/cache.rb

@@ -22,9 +22,14 @@ module Switchman
 
         def lookup_store(*store_options)
           store = super
-          # can't use defined?, because it's a _ruby_ autoloaded constant,
-          # so just checking that will cause it to get required
-          ::ActiveSupport::Cache::RedisCacheStore.prepend(RedisCacheStore) if store.instance_of?(ActiveSupport::Cache::RedisCacheStore) && !::ActiveSupport::Cache::RedisCacheStore.ancestors.include?(RedisCacheStore)
+          # must use the string name, otherwise it will try to auto-load the constant
+          # and we don't want to require redis in this file (since it's not a hard dependency)
+          # rubocop:disable Style/ClassEqualityComparison
+          if store.class.name == "ActiveSupport::Cache::RedisCacheStore" &&
+             !(::ActiveSupport::Cache::RedisCacheStore <= RedisCacheStore)
+            ::ActiveSupport::Cache::RedisCacheStore.prepend(RedisCacheStore)
+          end
+          # rubocop:enable Style/ClassEqualityComparison
           store.options[:namespace] ||= -> { Shard.current.default? ? nil : "shard_#{Shard.current.id}" }
           store
         end
@@ -33,7 +38,7 @@ module Switchman
       module RedisCacheStore
         def clear(namespace: nil, **)
           # RedisCacheStore tries to be smart and only clear the cache under your namespace, if you have one set
-          # unfortunately, it uses the keys command, which is extraordinarily inefficient in a large redis instance
+          # unfortunately, it doesn't work using redis clustering because of the way redis keys are distributed
           # fortunately, we can assume we control the entire instance, because we set up the namespacing, so just
           # always unset it temporarily for clear calls
           namespace = nil # rubocop:disable Lint/ShadowedArgument

data/lib/switchman/arel.rb

@@ -13,38 +13,29 @@ module Switchman
         # rubocop:disable Naming/MethodName
         # rubocop:disable Naming/MethodParameterName
 
+        def visit_Arel_Nodes_Cte(o, collector)
+          collector << quote_local_table_name(o.name)
+          collector << " AS "
+
+          case o.materialized
+          when true
+            collector << "MATERIALIZED "
+          when false
+            collector << "NOT MATERIALIZED "
+          end
+
+          visit o.relation, collector
+        end
+
         def visit_Arel_Nodes_TableAlias(o, collector)
           collector = visit o.relation, collector
-          collector << ' '
+          collector << " "
           collector << quote_local_table_name(o.name)
         end
 
         def visit_Arel_Attributes_Attribute(o, collector)
           join_name = o.relation.table_alias || o.relation.name
-          collector << quote_local_table_name(join_name) << '.' << quote_column_name(o.name)
-        end
-
-        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 << if o.type == :in
-                         ' IN ('
-                       else
-                         ' NOT IN ('
-                       end
-
-          values = o.casted_values
-
-          if values.empty?
-            collector << @connection.quote(nil)
-          else
-            collector.add_binds(values, o.proc_for_binds, &bind_block)
-          end
-
-          collector << ')'
-          collector
+          collector << quote_local_table_name(join_name) << "." << quote_column_name(o.name)
         end
 
         # rubocop:enable Naming/MethodName

data/lib/switchman/call_super.rb

@@ -12,14 +12,8 @@ module Switchman
       method.super_method
     end
 
-    if RUBY_VERSION <= '2.8'
-      def call_super(method, above_module, *args, &block)
-        super_method_above(method, above_module).call(*args, &block)
-      end
-    else
-      def call_super(method, above_module, *args, **kwargs, &block)
-        super_method_above(method, above_module).call(*args, **kwargs, &block)
-      end
+    def call_super(method, above_module, ...)
+      super_method_above(method, above_module).call(...)
     end
   end
 end

data/lib/switchman/database_server.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'securerandom'
+require "securerandom"
 
 module Switchman
   class DatabaseServer
@@ -10,19 +10,23 @@ module Switchman
       attr_accessor :creating_new_shard
       attr_reader :all_roles
 
+      include Enumerable
+
+      delegate :each, to: :all
+
       def all
         database_servers.values
       end
 
       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
@@ -50,6 +54,10 @@ module Switchman
         all.each { |db| db.guard! if db.config[:prefer_secondary] }
       end
 
+      def regions
+        @regions ||= all.filter_map(&:region).uniq.sort
+      end
+
       private
 
       def reference_role(role)
@@ -64,8 +72,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
@@ -81,6 +89,8 @@ module Switchman
           # Do this after so that all database servers for all roles are established and we won't prematurely
           # configure a connection for the wrong role
           @all_roles = roles.uniq
+          return @database_servers if @database_servers.empty?
+
           Shard.send(:configure_connects_to)
         end
         @database_servers
@@ -110,8 +120,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:,
+                                                          shard: id.to_sym)
         end
       end
     end
@@ -137,16 +148,41 @@ module Switchman
         end
     end
 
+    def region
+      config[:region]
+    end
+
+    # @param region [String, Array<String>] the region(s) to check against
+    # @return true if the database server doesn't have a region, or it
+    #   matches the specified region
+    def in_region?(region)
+      !self.region || (region.is_a?(Array) ? region.include?(self.region) : self.region == region)
+    end
+
+    # @return true if the database server doesn't have a region, Switchman is
+    #   not configured with a region, or the database server's region matches
+    #   Switchman's current region
+    def in_current_region?
+      unless instance_variable_defined?(:@in_current_region)
+        @in_current_region = !region ||
+                             !Switchman.region ||
+                             region == Switchman.region
+      end
+      @in_current_region
+    end
+
     # locks this db to a specific environment, except for
     # when doing writes (then it falls back to the current
     # 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 +198,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
@@ -182,12 +218,12 @@ module Switchman
       if config_create_statement
         create_commands = Array(config_create_statement).dup
         create_statement = lambda {
-          create_commands.map { |statement| format(statement, name: name, password: password) }
+          create_commands.map { |statement| format(statement, name:, password:) }
         }
       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
@@ -200,31 +236,30 @@ module Switchman
         self.class.creating_new_shard = true
         DatabaseServer.send(:reference_role, :deploy)
         ::ActiveRecord::Base.connected_to(shard: self.id.to_sym, role: :deploy) do
-          shard = Shard.create!(id: id,
-                                name: name,
+          shard = Shard.create!(id:,
+                                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
-              with_empty_caches do
-                ::ActiveRecord::Base.connection.transaction(requires_new: true) do
-                  ::ActiveRecord::Base.connection.migration_context.migrate
-                end
+              ::ActiveRecord::Base.connection.transaction(requires_new: true) do
+                ::ActiveRecord::MigrationContext.new(::ActiveRecord::Migrator.migrations_paths).migrate
               end
 
               ::ActiveRecord::Base.descendants.reject do |m|
@@ -240,7 +275,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
@@ -265,33 +299,18 @@ module Switchman
     end
 
     def primary_shard
-      unless instance_variable_defined?(:@primary_shard)
-        # if sharding isn't fully set up yet, we may not be able to query the shards table
-        @primary_shard = Shard.default if Shard.default.database_server == self
-        @primary_shard ||= shards.where(name: nil).first
-      end
-      @primary_shard
-    end
-
-    private
+      return nil unless primary_shard_id
 
-    def reset_column_information
-      ::ActiveRecord::Base.descendants.reject { |m| m <= UnshardedRecord }.each(&:reset_column_information)
+      Shard.lookup(primary_shard_id)
     end
 
-    def with_empty_caches
-      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)
-
-      reset_column_information
-      connection_pool.set_schema_cache(temporary_schema_cache)
-
-      yield
-
-      connection_pool.set_schema_cache(previous_schema_cache)
-      reset_column_information
+    def primary_shard_id
+      unless instance_variable_defined?(:@primary_shard_id)
+        # if sharding isn't fully set up yet, we may not be able to query the shards table
+        @primary_shard_id = Shard.default.id if Shard.default.database_server == self
+        @primary_shard_id ||= shards.where(name: nil).first&.id
+      end
+      @primary_shard_id
     end
   end
 end

data/lib/switchman/default_shard.rb

@@ -3,9 +3,10 @@
 module Switchman
   class DefaultShard
     def id
-      'default'
+      "default"
     end
-    alias cache_key id
+    alias_method :cache_key, :id
+
     def activate(*_classes)
       yield
     end
@@ -57,8 +58,18 @@ module Switchman
       self
     end
 
+    def region; end
+
+    def in_region?(_region)
+      true
+    end
+
+    def in_current_region?
+      true
+    end
+
     def _dump(_depth)
-      ''
+      ""
     end
 
     def self._load(_str)

data/lib/switchman/engine.rb

@@ -4,25 +4,16 @@ module Switchman
   class Engine < ::Rails::Engine
     isolate_namespace Switchman
 
-    # enable Rails 6.1 style connection handling
-    config.active_record.legacy_connection_handling = false
     config.active_record.writing_role = :primary
 
     ::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 }
-      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: :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 +41,27 @@ module Switchman
         ::ActiveRecord::Associations::CollectionProxy.include(ActiveRecord::Associations::CollectionProxy)
 
         ::ActiveRecord::Associations::Preloader::Association.prepend(ActiveRecord::Associations::Preloader::Association)
-        ::ActiveRecord::Associations::Preloader::Association::LoaderRecords.prepend(ActiveRecord::Associations::Preloader::Association::LoaderRecords) unless ::Rails.version < '7.0'
+        ::ActiveRecord::Associations::Preloader::Association::LoaderRecords.prepend(
+          ActiveRecord::Associations::Preloader::Association::LoaderRecords
+        )
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::AbstractAdapter)
+        ::ActiveRecord::ConnectionAdapters::ConnectionHandler.prepend(ActiveRecord::ConnectionHandler)
         ::ActiveRecord::ConnectionAdapters::ConnectionPool.prepend(ActiveRecord::ConnectionPool)
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::QueryCache)
         ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(ActiveRecord::PostgreSQLAdapter)
+        # https://github.com/rails/rails/commit/0016280f4fde55d96738887093dc333aae0d107b
+        if ::Rails.version < "7.2"
+          ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(ActiveRecord::PostgreSQLAdapter::ClassMethods)
+        else
+          ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.singleton_class.prepend(
+            ActiveRecord::PostgreSQLAdapter::ClassMethods
+          )
+        end
 
         ::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)
@@ -65,6 +69,11 @@ module Switchman
         ::ActiveRecord::MigrationContext.prepend(ActiveRecord::MigrationContext)
         ::ActiveRecord::Migrator.prepend(ActiveRecord::Migrator)
 
+        if ::Rails.version > "7.1.3"
+          ::ActiveRecord::PendingMigrationConnection.singleton_class
+                                                    .include(ActiveRecord::PendingMigrationConnection::ClassMethods)
+        end
+
         ::ActiveRecord::Reflection::AbstractReflection.include(ActiveRecord::Reflection::AbstractReflection)
         ::ActiveRecord::Reflection::AssociationReflection.prepend(ActiveRecord::Reflection::AssociationScopeCache)
         ::ActiveRecord::Reflection::ThroughReflection.prepend(ActiveRecord::Reflection::AssociationScopeCache)
@@ -74,11 +83,13 @@ module Switchman
         ::ActiveRecord::Relation.include(ActiveRecord::QueryMethods)
         ::ActiveRecord::Relation.prepend(GuardRail::Relation)
         ::ActiveRecord::Relation.prepend(ActiveRecord::Relation)
+        ::ActiveRecord::Relation.prepend(ActiveRecord::Relation::InsertUpsertAll) if ::Rails.version >= "7.2"
         ::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::PolymorphicArrayValue.prepend(
+          ActiveRecord::PredicateBuilder::PolymorphicArrayValue
+        )
 
         ::ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(ActiveRecord::Tasks::DatabaseTasks)
 
@@ -96,17 +107,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 +142,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,9 +13,8 @@ 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}(#{arg_params})
+          def #{method}(*args, **kwargs)
             db = Shard.current(connection_class_for_self).database_server
             db.unguard { super }
           end