active_record_shards 3.17.0 → 3.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb66e1dcadbbd2c1c6f619cb1504ad0b55cfba8c4e36c76015d74781f7e29b5b
-  data.tar.gz: 0f63d2ffbdae6ded142d886af712a10c6b2f0fc59cdc8ab6de9c59d078663d7c
+  metadata.gz: 1f573041b49f55115d94db028525da537bbbadffc4526d8a4f220f3d4ab1d4fd
+  data.tar.gz: f29528996589d7cef3f14671df47d10a8d4cf4a3b0ad81b022aaddf7b229178d
 SHA512:
-  metadata.gz: 8cc61cd8b0c9b18a41c3b7ab1cd21d16a32d03b51e372855792bec89fe40bd45a4900b2ccfb9fdbafcdc841a98301e9ced9c91d1ba44100d12660723ee655682
-  data.tar.gz: 48e7fdb5d1501834e9008efd22ec617af5a429aab37bece0f435547f49b5bec539950bbf08c5412b336a201f4d756c62f45be580d063b250ce8e10ee89aaf423
+  metadata.gz: 782a638a2d4ce88a06ac0f6d93d277de20831d918ee1014fec1b2a01f95631b5857fb2df1d83b15ced1e52b1749283ec497c43ccfc0d85ffd6e3bd271d4d9f28
+  data.tar.gz: f28464784b171c3dd8a888574f1bb362e645f3949dcf3b07a70a9c195e73ae00a1c5a7319c107666f4060e37c04c3daacd8415187124dbda891aae5cb19a7ecf

data/README.md

@@ -2,7 +2,7 @@
 
 # ActiveRecord Shards
 
-ActiveRecord Shards is an extension for ActiveRecord that provides support for sharded database and slaves. Basically it is just a nice way to
+ActiveRecord Shards is an extension for ActiveRecord that provides support for sharded database and replicas. Basically it is just a nice way to
 switch between database connections. We've made the implementation very small, and have tried not to reinvent any wheels already present in ActiveRecord.
 
 ActiveRecord Shards has been used and tested on Rails 4.2, 5.x and 6.0, and has in some form or another been used in production on large Rails apps for several years.
@@ -24,7 +24,7 @@ and make sure to require 'active\_record\_shards' in some way.
 
 ## Configuration
 
-Add the slave and shard configuration to config/database.yml:
+Add the replica and shard configuration to config/database.yml:
 
 ```yaml
 production:
@@ -35,19 +35,19 @@ production:
   host: db1
   username: root
   password:
-  slave:
-    host: db1_slave
+  replica:
+    host: db1_replica
   shards:
     1:
       host: db_shard1
       database: my_app_shard
-      slave:
-        host: db_shard1_slave
+      replica:
+        host: db_shard1_replica
     2:
       host: db_shard2
       database: my_app_shard
-      slave:
-        host: db_shard2_slave
+      replica:
+        host: db_shard2_replica
 ```
 
 basically connections inherit configuration from the parent configuration file.
@@ -140,23 +140,23 @@ class AccountMiddleware
 end
 ```
 
-You can switch to the slave databases at any point by wrapping your code in an on\_slave block:
+You can switch to the replica databases at any point by wrapping your code in an on\_replica block:
 
 ```ruby
-ActiveRecord::Base.on_slave do
+ActiveRecord::Base.on_replica do
   Account.find_by_big_expensive_query
 end
 ```
 
-This will perform the query on the slave, and mark the returned instances as read only. There is also a shortcut for this:
+This will perform the query on the replica, and mark the returned instances as read only. There is also a shortcut for this:
 
 ```ruby
-Account.on_slave.find_by_big_expensive_query
+Account.on_replica.find_by_big_expensive_query
 ```
 
 ## Debugging
 
-Show if a query went to master or slave in the logs:
+Show if a query went to primary or replica in the logs:
 
 ```Ruby
 require 'active_record_shards/sql_comments'

data/lib/active_record_shards.rb

@@ -8,7 +8,7 @@ require 'active_record_shards/shard_selection'
 require 'active_record_shards/connection_switcher'
 require 'active_record_shards/association_collection_connection_selection'
 require 'active_record_shards/migration'
-require 'active_record_shards/default_slave_patches'
+require 'active_record_shards/default_replica_patches'
 require 'active_record_shards/schema_dumper_extension'
 
 module ActiveRecordShards
@@ -23,10 +23,10 @@ end
 ActiveRecord::Base.extend(ActiveRecordShards::ConfigurationParser)
 ActiveRecord::Base.extend(ActiveRecordShards::Model)
 ActiveRecord::Base.extend(ActiveRecordShards::ConnectionSwitcher)
-ActiveRecord::Base.extend(ActiveRecordShards::DefaultSlavePatches)
-ActiveRecord::Relation.include(ActiveRecordShards::DefaultSlavePatches::ActiveRelationPatches)
+ActiveRecord::Base.extend(ActiveRecordShards::DefaultReplicaPatches)
+ActiveRecord::Relation.include(ActiveRecordShards::DefaultReplicaPatches::ActiveRelationPatches)
 ActiveRecord::Associations::CollectionProxy.include(ActiveRecordShards::AssociationCollectionConnectionSelection)
-ActiveRecord::Associations::Builder::HasAndBelongsToMany.include(ActiveRecordShards::DefaultSlavePatches::Rails41HasAndBelongsToManyBuilderExtension)
+ActiveRecord::Associations::Builder::HasAndBelongsToMany.include(ActiveRecordShards::DefaultReplicaPatches::Rails41HasAndBelongsToManyBuilderExtension)
 ActiveRecord::SchemaDumper.prepend(ActiveRecordShards::SchemaDumperExtension)
 
 case "#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}"
@@ -37,3 +37,47 @@ when '5.0', '5.1', '5.2', '6.0'
 else
   raise "ActiveRecordShards is not compatible with #{ActiveRecord::VERSION::STRING}"
 end
+
+require 'active_record_shards/deprecation'
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::AssociationCollectionConnectionSelection,
+  on_slave_if: :on_replica_if,
+  on_slave_unless: :on_replica_unless,
+  on_slave: :on_replica,
+  on_master: :on_primary,
+  on_master_if: :on_primary_if,
+  on_master_unless: :on_primary_unless
+)
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::ConnectionSwitcher,
+  on_slave_if: :on_replica_if,
+  on_slave_unless: :on_replica_unless,
+  on_master_or_slave: :on_primary_or_replica,
+  on_slave: :on_replica,
+  on_master: :on_primary,
+  on_master_if: :on_primary_if,
+  on_master_unless: :on_primary_unless,
+  on_slave?: :on_replica?
+)
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::DefaultReplicaPatches,
+  columns_with_force_slave: :columns_with_force_replica,
+  table_exists_with_force_slave?: :table_exists_with_force_replica?,
+  transaction_with_slave_off: :transaction_with_replica_off,
+  on_slave_unless_tx: :on_replica_unless_tx
+)
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::Model,
+  on_slave_by_default?: :on_replica_by_default?,
+  :on_slave_by_default= => :on_replica_by_default=
+)
+
+ActiveRecordShards::Deprecation.deprecate_methods(
+  ActiveRecordShards::ShardSelection,
+  on_slave?: :on_replica?,
+  :on_slave= => :on_replica=
+)

data/lib/active_record_shards/association_collection_connection_selection.rb

@@ -2,31 +2,37 @@
 
 module ActiveRecordShards
   module AssociationCollectionConnectionSelection
-    def on_slave_if(condition)
-      condition ? on_slave : self
+    def on_replica_if(condition)
+      condition ? on_replica : self
     end
+    alias_method :on_slave_if, :on_replica_if
 
-    def on_slave_unless(condition)
-      on_slave_if(!condition)
+    def on_replica_unless(condition)
+      on_replica_if(!condition)
     end
+    alias_method :on_slave_unless, :on_replica_unless
 
-    def on_master_if(condition)
-      condition ? on_master : self
+    def on_primary_if(condition)
+      condition ? on_primary : self
     end
+    alias_method :on_master_if, :on_primary_if
 
-    def on_master_unless(condition)
-      on_master_if(!condition)
+    def on_primary_unless(condition)
+      on_primary_if(!condition)
     end
+    alias_method :on_master_unless, :on_primary_unless
 
-    def on_slave
-      MasterSlaveProxy.new(self, :slave)
+    def on_replica
+      PrimaryReplicaProxy.new(self, :replica)
     end
+    alias_method :on_slave, :on_replica
 
-    def on_master
-      MasterSlaveProxy.new(self, :master)
+    def on_primary
+      PrimaryReplicaProxy.new(self, :primary)
     end
+    alias_method :on_master, :on_primary
 
-    class MasterSlaveProxy
+    class PrimaryReplicaProxy
       def initialize(association_collection, which)
         @association_collection = association_collection
         @which = which
@@ -37,5 +43,7 @@ module ActiveRecordShards
         reflection.klass.on_cx_switch_block(@which) { @association_collection.send(method, *args, &block) }
       end
     end
+
+    MasterSlaveProxy = PrimaryReplicaProxy
   end
 end

data/lib/active_record_shards/configuration_parser.rb

@@ -24,10 +24,18 @@ module ActiveRecordShards
       end
 
       conf.to_a.each do |env_name, env_config|
-        if slave_conf = env_config.delete('slave')
-          expand_child!(env_config, slave_conf)
-          conf["#{env_name}_slave"] = slave_conf
+        if replica_conf = env_config.delete('replica')
+          expand_child!(env_config, replica_conf)
+          conf["#{env_name}_replica"] = replica_conf
         end
+
+        # rubocop:disable Style/Next
+        if legacy_replica_conf = env_config.delete('slave')
+          ActiveRecordShards::Deprecation.warn('`slave` configuration keys should be replaced with `replica` keys!')
+          expand_child!(env_config, legacy_replica_conf)
+          conf["#{env_name}_replica"] = legacy_replica_conf
+        end
+        # rubocop:enable Style/Next
       end
 
       conf
@@ -35,7 +43,7 @@ module ActiveRecordShards
 
     def expand_child!(parent, child)
       parent.each do |key, value|
-        unless ['slave', 'shards'].include?(key) || value.is_a?(Hash)
+        unless ['slave', 'replica', 'shards'].include?(key) || value.is_a?(Hash)
           child[key] ||= value
         end
       end

data/lib/active_record_shards/connection_switcher-4-2.rb

@@ -4,8 +4,8 @@ module ActiveRecordShards
     def connection_pool_name # :nodoc:
       name = current_shard_selection.shard_name(self)
 
-      # e.g. if "production_slave" is not defined in `Configuration`, fall back to "production"
-      if configurations[name].nil? && on_slave?
+      # e.g. if "production_replica" is not defined in `Configuration`, fall back to "production"
+      if configurations[name].nil? && on_replica?
         current_shard_selection.shard_name(self, false)
       else
         name

data/lib/active_record_shards/connection_switcher.rb

@@ -59,70 +59,79 @@ module ActiveRecordShards
       switch_connection(old_options)
     end
 
-    def on_slave_if(condition, &block)
-      condition ? on_slave(&block) : yield
+    def on_replica_if(condition, &block)
+      condition ? on_replica(&block) : yield
     end
+    alias_method :on_slave_if, :on_replica_if
 
-    def on_slave_unless(condition, &block)
-      on_slave_if(!condition, &block)
+    def on_replica_unless(condition, &block)
+      on_replica_if(!condition, &block)
     end
+    alias_method :on_slave_unless, :on_replica_unless
 
-    def on_master_if(condition, &block)
-      condition ? on_master(&block) : yield
+    def on_primary_if(condition, &block)
+      condition ? on_primary(&block) : yield
     end
+    alias_method :on_master_if, :on_primary_if
 
-    def on_master_unless(condition, &block)
-      on_master_if(!condition, &block)
+    def on_primary_unless(condition, &block)
+      on_primary_if(!condition, &block)
     end
+    alias_method :on_master_unless, :on_primary_unless
 
-    def on_master_or_slave(which, &block)
+    def on_primary_or_replica(which, &block)
       if block_given?
         on_cx_switch_block(which, &block)
       else
-        MasterSlaveProxy.new(self, which)
+        PrimaryReplicaProxy.new(self, which)
       end
     end
+    alias_method :on_master_or_slave, :on_primary_or_replica
 
-    # Executes queries using the slave database. Fails over to master if no slave is found.
-    # if you want to execute a block of code on the slave you can go:
-    #   Account.on_slave do
+    # Executes queries using the replica database. Fails over to primary if no replica is found.
+    # if you want to execute a block of code on the replica you can go:
+    #   Account.on_replica do
     #     Account.first
     #   end
-    # the first account will be found on the slave DB
+    # the first account will be found on the replica DB
     #
     # For one-liners you can simply do
-    #   Account.on_slave.first
-    def on_slave(&block)
-      on_master_or_slave(:slave, &block)
+    #   Account.on_replica.first
+    def on_replica(&block)
+      on_primary_or_replica(:replica, &block)
     end
+    alias_method :on_slave, :on_replica
 
-    def on_master(&block)
-      on_master_or_slave(:master, &block)
+    def on_primary(&block)
+      on_primary_or_replica(:primary, &block)
     end
+    alias_method :on_master, :on_primary
 
     # just to ease the transition from replica to active_record_shards
-    alias_method :with_slave, :on_slave
-    alias_method :with_slave_if, :on_slave_if
-    alias_method :with_slave_unless, :on_slave_unless
+    alias_method :with_slave, :on_replica
+    alias_method :with_slave_if, :on_replica_if
+    alias_method :with_slave_unless, :on_replica_unless
 
     def on_cx_switch_block(which, force: false, construct_ro_scope: nil, &block)
-      @disallow_slave ||= 0
-      @disallow_slave += 1 if which == :master
+      @disallow_replica ||= 0
+      @disallow_replica += 1 if [:primary, :master].include?(which)
 
-      switch_to_slave = force || @disallow_slave.zero?
+      ActiveRecordShards::Deprecation.warn('the `:master` option should be replaced with `:primary`!') if which == :master
+
+      switch_to_replica = force || @disallow_replica.zero?
       old_options = current_shard_selection.options
 
-      switch_connection(slave: switch_to_slave)
+      switch_connection(replica: switch_to_replica)
 
       # we avoid_readonly_scope to prevent some stack overflow problems, like when
       # .columns calls .with_scope which calls .columns and onward, endlessly.
-      if self == ActiveRecord::Base || !switch_to_slave || construct_ro_scope == false
+      if self == ActiveRecord::Base || !switch_to_replica || construct_ro_scope == false
         yield
       else
         readonly.scoping(&block)
       end
     ensure
-      @disallow_slave -= 1 if which == :master
+      @disallow_replica -= 1 if [:primary, :master].include?(which)
       switch_connection(old_options) if old_options
     end
 
@@ -130,9 +139,10 @@ module ActiveRecordShards
       shard_names.any?
     end
 
-    def on_slave?
-      current_shard_selection.on_slave?
+    def on_replica?
+      current_shard_selection.on_replica?
     end
+    alias_method :on_slave?, :on_replica?
 
     def current_shard_selection
       Thread.current[:shard_selection] ||= ShardSelection.new
@@ -157,8 +167,8 @@ module ActiveRecordShards
 
     def switch_connection(options)
       if options.any?
-        if options.key?(:slave)
-          current_shard_selection.on_slave = options[:slave]
+        if options.key?(:replica)
+          current_shard_selection.on_replica = options[:replica]
         end
 
         if options.key?(:shard)
@@ -199,16 +209,18 @@ module ActiveRecordShards
       with_default_shard { table_exists_without_default_shard? }
     end
 
-    class MasterSlaveProxy
+    class PrimaryReplicaProxy
       def initialize(target, which)
         @target = target
         @which = which
       end
 
       def method_missing(method, *args, &block) # rubocop:disable Style/MethodMissingSuper, Style/MissingRespondToMissing
-        @target.on_master_or_slave(@which) { @target.send(method, *args, &block) }
+        @target.on_primary_or_replica(@which) { @target.send(method, *args, &block) }
       end
     end
+
+    MasterSlaveProxy = PrimaryReplicaProxy
   end
 end
 

data/lib/active_record_shards/default_replica_patches.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module ActiveRecordShards
+  module DefaultReplicaPatches
+    def self.wrap_method_in_on_replica(class_method, base, method, force_on_replica: false)
+      base_methods =
+        if class_method
+          base.methods + base.private_methods
+        else
+          base.instance_methods + base.private_instance_methods
+        end
+
+      return unless base_methods.include?(method)
+
+      _, method, punctuation = method.to_s.match(/^(.*?)([\?\!]?)$/).to_a
+      # _ALWAYS_ on replica, or only for on `on_replica_by_default = true` models?
+      wrapper = force_on_replica ? 'force_on_replica' : 'on_replica_unless_tx'
+      base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        #{class_method ? 'class << self' : ''}
+          def #{method}_with_default_replica#{punctuation}(*args, &block)
+            #{wrapper} do
+              #{method}_without_default_replica#{punctuation}(*args, &block)
+            end
+          end
+
+          alias_method :#{method}_without_default_replica#{punctuation}, :#{method}#{punctuation}
+          alias_method :#{method}#{punctuation}, :#{method}_with_default_replica#{punctuation}
+        #{class_method ? 'end' : ''}
+      RUBY
+    end
+
+    def self.wrap_method_in_on_slave(*args)
+      ActiveRecordShards::Deprecation.deprecation_warning(
+        :'self.wrap_method_in_on_slave',
+        :'self.wrap_method_in_on_replica'
+      )
+      wrap_method_in_on_replica(*args)
+    end
+
+    def columns_with_force_replica(*args, &block)
+      on_cx_switch_block(:replica, construct_ro_scope: false, force: true) do
+        columns_without_force_replica(*args, &block)
+      end
+    end
+    alias_method :columns_with_force_slave, :columns_with_force_replica
+
+    def table_exists_with_force_replica?(*args, &block)
+      on_cx_switch_block(:replica, construct_ro_scope: false, force: true) do
+        table_exists_without_force_replica?(*args, &block)
+      end
+    end
+    alias_method :table_exists_with_force_slave?, :table_exists_with_force_replica?
+
+    def transaction_with_replica_off(*args, &block)
+      if on_replica_by_default?
+        begin
+          old_val = Thread.current[:_active_record_shards_replica_off]
+          Thread.current[:_active_record_shards_replica_off] = true
+          transaction_without_replica_off(*args, &block)
+        ensure
+          Thread.current[:_active_record_shards_replica_off] = old_val
+        end
+      else
+        transaction_without_replica_off(*args, &block)
+      end
+    end
+    alias_method :transaction_with_slave_off, :transaction_with_replica_off
+
+    module InstanceMethods
+      # fix ActiveRecord to do the right thing, and use our aliased quote_value
+      def quote_value(*args, &block)
+        self.class.quote_value(*args, &block)
+      end
+    end
+
+    CLASS_REPLICA_METHODS = [
+      :calculate,
+      :count_by_sql,
+      :exists?,
+      :find_by_sql,
+      :find_every,
+      :find_one,
+      :find_some
+    ].freeze
+
+    CLASS_FORCE_REPLICA_METHODS = [
+      :columns,
+      :replace_bind_variable,
+      :replace_bind_variables,
+      :sanitize_sql_array,
+      :sanitize_sql_hash_for_assignment,
+      :table_exists?
+    ].freeze
+
+    CLASS_SLAVE_METHODS = CLASS_REPLICA_METHODS
+    CLASS_FORCE_SLAVE_METHODS = CLASS_FORCE_REPLICA_METHODS
+
+    def self.extended(base)
+      CLASS_REPLICA_METHODS.each { |m| ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(true, base, m) }
+      CLASS_FORCE_SLAVE_METHODS.each { |m| ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(true, base, m, force_on_replica: true) }
+
+      base.class_eval do
+        include InstanceMethods
+
+        class << self
+          alias_method :transaction_without_replica_off, :transaction
+          alias_method :transaction, :transaction_with_replica_off
+        end
+      end
+      if ActiveRecord::Associations.const_defined?(:HasAndBelongsToManyAssociation)
+        ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(false, ActiveRecord::Associations::HasAndBelongsToManyAssociation, :construct_sql)
+        ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(false, ActiveRecord::Associations::HasAndBelongsToManyAssociation, :construct_find_options!)
+      end
+    end
+
+    def on_replica_unless_tx
+      if on_replica_by_default? && !Thread.current[:_active_record_shards_replica_off]
+        on_replica { yield }
+      else
+        yield
+      end
+    end
+    alias_method :on_slave_unless_tx, :on_replica_unless_tx
+
+    def force_on_replica(&block)
+      on_cx_switch_block(:replica, construct_ro_scope: false, force: true, &block)
+    end
+
+    module ActiveRelationPatches
+      def self.included(base)
+        [:calculate, :exists?, :pluck, :load].each do |m|
+          ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(false, base, m)
+        end
+
+        if ActiveRecord::VERSION::MAJOR == 4
+          # `where` and `having` clauses call `create_binds`, which will use the primary connection
+          ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(false, base, :create_binds, force_on_replica: true)
+        end
+
+        ActiveRecordShards::DefaultReplicaPatches.wrap_method_in_on_replica(false, base, :to_sql, force_on_replica: true)
+      end
+
+      def on_replica_unless_tx
+        @klass.on_replica_unless_tx { yield }
+      end
+    end
+
+    # in rails 4.1+, they create a join class that's used to pull in records for HABTM.
+    # this simplifies the hell out of our existence, because all we have to do is inerit on-replica-by-default
+    # down from the parent now.
+    module Rails41HasAndBelongsToManyBuilderExtension
+      def self.included(base)
+        base.class_eval do
+          alias_method :through_model_without_inherit_default_replica_from_lhs, :through_model
+          alias_method :through_model, :through_model_with_inherit_default_replica_from_lhs
+        end
+      end
+
+      def through_model_with_inherit_default_replica_from_lhs
+        model = through_model_without_inherit_default_replica_from_lhs
+        def model.on_replica_by_default?
+          left_reflection.klass.on_replica_by_default?
+        end
+
+        # also transfer the sharded-ness of the left table to the join model
+        model.not_sharded unless model.left_reflection.klass.is_sharded?
+        model
+      end
+    end
+  end
+end

data/lib/active_record_shards/default_slave_patches.rb

@@ -1,144 +1,5 @@
-# frozen_string_literal: true
+ActiveRecordShards::Deprecation.warn('`DefaultSlavePatches` is deprecated, please use `DefaultReplicaPatches`.')
 
 module ActiveRecordShards
-  module DefaultSlavePatches
-    def self.wrap_method_in_on_slave(class_method, base, method, force_on_slave: false)
-      base_methods =
-        if class_method
-          base.methods + base.private_methods
-        else
-          base.instance_methods + base.private_instance_methods
-        end
-
-      return unless base_methods.include?(method)
-
-      _, method, punctuation = method.to_s.match(/^(.*?)([\?\!]?)$/).to_a
-      # _ALWAYS_ on slave, or only for on `on_slave_by_default = true` models?
-      wrapper = force_on_slave ? 'force_on_slave' : 'on_slave_unless_tx'
-      base.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        #{class_method ? 'class << self' : ''}
-          def #{method}_with_default_slave#{punctuation}(*args, &block)
-            #{wrapper} do
-              #{method}_without_default_slave#{punctuation}(*args, &block)
-            end
-          end
-
-          alias_method :#{method}_without_default_slave#{punctuation}, :#{method}#{punctuation}
-          alias_method :#{method}#{punctuation}, :#{method}_with_default_slave#{punctuation}
-        #{class_method ? 'end' : ''}
-      RUBY
-    end
-
-    def transaction_with_slave_off(*args, &block)
-      if on_slave_by_default?
-        begin
-          old_val = Thread.current[:_active_record_shards_slave_off]
-          Thread.current[:_active_record_shards_slave_off] = true
-          transaction_without_slave_off(*args, &block)
-        ensure
-          Thread.current[:_active_record_shards_slave_off] = old_val
-        end
-      else
-        transaction_without_slave_off(*args, &block)
-      end
-    end
-
-    module InstanceMethods
-      # fix ActiveRecord to do the right thing, and use our aliased quote_value
-      def quote_value(*args, &block)
-        self.class.quote_value(*args, &block)
-      end
-    end
-
-    CLASS_SLAVE_METHODS = [
-      :calculate,
-      :count_by_sql,
-      :exists?,
-      :find_by_sql,
-      :find_every,
-      :find_one,
-      :find_some
-    ].freeze
-
-    CLASS_FORCE_SLAVE_METHODS = [
-      :columns,
-      :replace_bind_variable,
-      :replace_bind_variables,
-      :sanitize_sql_array,
-      :sanitize_sql_hash_for_assignment,
-      :table_exists?
-    ].freeze
-
-    def self.extended(base)
-      CLASS_SLAVE_METHODS.each { |m| ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(true, base, m) }
-      CLASS_FORCE_SLAVE_METHODS.each { |m| ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(true, base, m, force_on_slave: true) }
-
-      base.class_eval do
-        include InstanceMethods
-
-        class << self
-          alias_method :transaction_without_slave_off, :transaction
-          alias_method :transaction, :transaction_with_slave_off
-        end
-      end
-      if ActiveRecord::Associations.const_defined?(:HasAndBelongsToManyAssociation)
-        ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(false, ActiveRecord::Associations::HasAndBelongsToManyAssociation, :construct_sql)
-        ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(false, ActiveRecord::Associations::HasAndBelongsToManyAssociation, :construct_find_options!)
-      end
-    end
-
-    def on_slave_unless_tx(&block)
-      if on_slave_by_default? && !Thread.current[:_active_record_shards_slave_off]
-        on_slave(&block)
-      else
-        yield
-      end
-    end
-
-    def force_on_slave(&block)
-      on_cx_switch_block(:slave, construct_ro_scope: false, force: true, &block)
-    end
-
-    module ActiveRelationPatches
-      def self.included(base)
-        [:calculate, :exists?, :pluck, :load].each do |m|
-          ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(false, base, m)
-        end
-
-        if ActiveRecord::VERSION::MAJOR == 4
-          # `where` and `having` clauses call `create_binds`, which will use the master connection
-          ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(false, base, :create_binds, force_on_slave: true)
-        end
-
-        ActiveRecordShards::DefaultSlavePatches.wrap_method_in_on_slave(false, base, :to_sql, force_on_slave: true)
-      end
-
-      def on_slave_unless_tx(&block)
-        @klass.on_slave_unless_tx(&block)
-      end
-    end
-
-    # in rails 4.1+, they create a join class that's used to pull in records for HABTM.
-    # this simplifies the hell out of our existence, because all we have to do is inerit on-slave-by-default
-    # down from the parent now.
-    module Rails41HasAndBelongsToManyBuilderExtension
-      def self.included(base)
-        base.class_eval do
-          alias_method :through_model_without_inherit_default_slave_from_lhs, :through_model
-          alias_method :through_model, :through_model_with_inherit_default_slave_from_lhs
-        end
-      end
-
-      def through_model_with_inherit_default_slave_from_lhs
-        model = through_model_without_inherit_default_slave_from_lhs
-        def model.on_slave_by_default?
-          left_reflection.klass.on_slave_by_default?
-        end
-
-        # also transfer the sharded-ness of the left table to the join model
-        model.not_sharded unless model.left_reflection.klass.is_sharded?
-        model
-      end
-    end
-  end
+  DefaultSlavePatches = DefaultReplicaPatches
 end

data/lib/active_record_shards/deprecation.rb

@@ -0,0 +1,12 @@
+module ActiveRecordShards
+  class Deprecation < ActiveSupport::Deprecation
+    # This allows us to define separate deprecation behavior for ActiveRecordShards, but defaults to
+    # the same behavior globally configured with ActiveSupport.
+    #
+    # For example, this allows us to silence our own deprecation warnings in test while still being
+    # able to fail tests for upstream deprecation warnings.
+    def behavior
+      @behavior ||= ActiveSupport::Deprecation.behavior
+    end
+  end
+end

data/lib/active_record_shards/model.rb

@@ -24,34 +24,38 @@ module ActiveRecordShards
       end
     end
 
-    def on_slave_by_default?
+    def on_replica_by_default?
       if self == ActiveRecord::Base
         false
       else
         base = base_class
-        if base.instance_variable_defined?(:@on_slave_by_default)
-          base.instance_variable_get(:@on_slave_by_default)
+        if base.instance_variable_defined?(:@on_replica_by_default)
+          base.instance_variable_get(:@on_replica_by_default)
         end
       end
     end
+    alias_method :on_slave_by_default?, :on_replica_by_default?
 
-    def on_slave_by_default=(value)
+    def on_replica_by_default=(value)
       if self == ActiveRecord::Base
-        raise ArgumentError, "Cannot set on_slave_by_default on ActiveRecord::Base"
+        raise ArgumentError, "Cannot set on_replica_by_default on ActiveRecord::Base"
       else
-        base_class.instance_variable_set(:@on_slave_by_default, value)
+        base_class.instance_variable_set(:@on_replica_by_default, value)
       end
     end
+    alias_method :on_slave_by_default=, :on_replica_by_default=
 
     module InstanceMethods
-      def initialize_shard_and_slave
-        @from_slave = !!self.class.current_shard_selection.options[:slave]
+      def initialize_shard_and_replica
+        @from_replica = !!self.class.current_shard_selection.options[:replica]
         @from_shard = self.class.current_shard_selection.options[:shard]
       end
+      alias_method :initialize_shard_and_slave, :initialize_shard_and_replica
 
-      def from_slave?
-        @from_slave
+      def from_replica?
+        @from_replica
       end
+      alias_method :from_slave?, :from_replica?
 
       def from_shard
         @from_shard
@@ -60,7 +64,7 @@ module ActiveRecordShards
 
     def self.extended(base)
       base.send(:include, InstanceMethods)
-      base.after_initialize :initialize_shard_and_slave
+      base.after_initialize :initialize_shard_and_replica
     end
 
     private

data/lib/active_record_shards/shard_selection.rb

@@ -6,7 +6,7 @@ module ActiveRecordShards
     cattr_accessor :default_shard
 
     def initialize
-      @on_slave = false
+      @on_replica = false
       @shard = nil
     end
 
@@ -22,17 +22,17 @@ module ActiveRecordShards
         end
       end
 
-      def shard_name(klass = nil, try_slave = true)
+      def shard_name(klass = nil, try_replica = true)
         the_shard = shard(klass)
 
         @shard_names ||= {}
         @shard_names[ActiveRecordShards.rails_env] ||= {}
         @shard_names[ActiveRecordShards.rails_env][the_shard] ||= {}
-        @shard_names[ActiveRecordShards.rails_env][the_shard][try_slave] ||= {}
-        @shard_names[ActiveRecordShards.rails_env][the_shard][try_slave][@on_slave] ||= begin
+        @shard_names[ActiveRecordShards.rails_env][the_shard][try_replica] ||= {}
+        @shard_names[ActiveRecordShards.rails_env][the_shard][try_replica][@on_replica] ||= begin
           s = ActiveRecordShards.rails_env.dup
           s << "_shard_#{the_shard}" if the_shard
-          s << "_slave"              if @on_slave && try_slave
+          s << "_replica"            if @on_replica && try_replica
           s
         end
       end
@@ -55,11 +55,11 @@ module ActiveRecordShards
         @connection_names ||= {}
         @connection_names[env] ||= {}
         @connection_names[env][resolved_shard] ||= {}
-        @connection_names[env][resolved_shard][@on_slave] ||= begin
+        @connection_names[env][resolved_shard][@on_replica] ||= begin
           name = env.dup
           name << "_shard_#{resolved_shard}" if resolved_shard
-          if @on_slave && configurations["#{name}_slave"]
-            "#{name}_slave"
+          if @on_replica && configurations["#{name}_replica"]
+            "#{name}_replica"
           else
             # ActiveRecord always names its default connection pool 'primary'
             # while everything else is named by the configuration name
@@ -74,16 +74,18 @@ module ActiveRecordShards
       @shard = (new_shard || NO_SHARD)
     end
 
-    def on_slave?
-      @on_slave
+    def on_replica?
+      @on_replica
     end
+    alias_method :on_slave?, :on_replica?
 
-    def on_slave=(new_slave)
-      @on_slave = (new_slave == true)
+    def on_replica=(new_replica)
+      @on_replica = (new_replica == true)
     end
+    alias_method :on_slave=, :on_replica=
 
     def options
-      { shard: @shard, slave: @on_slave }
+      { shard: @shard, replica: @on_replica }
     end
   end
 end

data/lib/active_record_shards/sql_comments.rb

@@ -1,16 +1,16 @@
-# show which connection was picked to debug master/slave slowness when both servers are the same
+# show which connection was picked to debug primary/replica slowness when both servers are the same
 module ActiveRecordShards
   module SqlComments
     module Methods
       def execute(query, name = nil)
-        slave = ActiveRecord::Base.current_shard_selection.on_slave?
-        query += " /* #{slave ? 'slave' : 'master'} */"
+        replica = ActiveRecord::Base.current_shard_selection.on_replica?
+        query += " /* #{replica ? 'replica' : 'primary'} */"
         super(query, name)
       end
     end
 
     def self.enable
-      ActiveRecord::Base.on_slave do
+      ActiveRecord::Base.on_replica do
         ActiveRecord::Base.on_shard(nil) do
           ActiveRecord::Base.connection.class.prepend(Methods)
         end

data/lib/active_record_shards/tasks.rb

@@ -10,7 +10,7 @@ namespace :db do
   desc 'Drops the database for the current RAILS_ENV including shards'
   task drop: :load_config do
     ActiveRecord::Base.configurations.to_h.each do |key, conf|
-      next if !key.starts_with?(ActiveRecordShards.rails_env) || key.ends_with?("_slave")
+      next if !key.start_with?(ActiveRecordShards.rails_env) || key.end_with?("_replica", "_slave")
 
       begin
         ActiveRecordShards::Tasks.root_connection(conf).drop_database(conf['database'])
@@ -31,7 +31,7 @@ namespace :db do
   desc "Create the database defined in config/database.yml for the current RAILS_ENV including shards"
   task create: :load_config do
     ActiveRecord::Base.configurations.to_h.each do |key, conf|
-      next if !key.starts_with?(ActiveRecordShards.rails_env) || key.ends_with?("_slave")
+      next if !key.start_with?(ActiveRecordShards.rails_env) || key.end_with?("_replica", "_slave")
 
       begin
         # MysqlAdapter takes charset instead of encoding in Rails 4.2 or greater

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_shards
 version: !ruby/object:Gem::Version
-  version: 3.17.0
+  version: 3.18.0
 platform: ruby
 authors:
 - Benjamin Quorning
@@ -10,10 +10,10 @@ authors:
 - Mick Staugaard
 - Eric Chapweske
 - Ben Osheroff
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-02 00:00:00.000000000 Z
+date: 2021-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -195,7 +195,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.5.1
-description: Easily run queries on shard and slave databases.
+description: Easily run queries on shard and replica databases.
 email:
 - bquorning@zendesk.com
 - gabe@zendesk.com
@@ -216,7 +216,9 @@ files:
 - lib/active_record_shards/connection_switcher-5-0.rb
 - lib/active_record_shards/connection_switcher-5-1.rb
 - lib/active_record_shards/connection_switcher.rb
+- lib/active_record_shards/default_replica_patches.rb
 - lib/active_record_shards/default_slave_patches.rb
+- lib/active_record_shards/deprecation.rb
 - lib/active_record_shards/migration.rb
 - lib/active_record_shards/model.rb
 - lib/active_record_shards/patches-4-2.rb
@@ -229,7 +231,7 @@ homepage: https://github.com/zendesk/active_record_shards
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -244,8 +246,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.1
-signing_key: 
+rubygems_version: 3.2.16
+signing_key:
 specification_version: 4
 summary: Simple database switching for ActiveRecord.
 test_files: []