fresh_connection 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 84a4630927af9e729f2d600212561edbbdf48084
-  data.tar.gz: 1f5c9524e3f3f95c946b8bde1657df5760cdb3dc
+  metadata.gz: 5209747ee5ebffd0721b5c2dbcf20940721867c4
+  data.tar.gz: 022c9dce7d03c2ca0bc0732022ea70099df547df
 SHA512:
-  metadata.gz: d2c39cc2b23fd83562b9b2116efed94e5fa5e1dac6098a00903de328406d4b974c795307a91b302fbe9d3b9ba2340015d0765c8c13ae8c93659ee62f9940b0ca
-  data.tar.gz: 5f6ec976453e0f1222ded67b61241ec07f4bb3a65c90e83737d2e6e99465ee5b8680aaf98b120e6319ed496075284a63878a48cb5d54fbe995e848a775e71efc
+  metadata.gz: 700f794d9cb774036025d53b6cf471ffd83c8a9de8b1188c1d0bf153e292c98c69804473a1e20bf535e18fc4be771d264585db463affeeda1b7b2303942aa868
+  data.tar.gz: d4f6fbea8f6debe411aa22f603a3e463bc03986dbefd05ded39374fe645641811e862814f09c34de2d38881ceb6e946ab8b4b8cdaed638bbf226337c0bbb0505

data/.travis.yml

@@ -8,8 +8,8 @@ before_script:
   - bundle update
   - cp test/config/database_postgresql.yml.travis test/config/database_postgresql.yml
   - psql -c 'create database fresh_connection_test_master;' -U postgres
-  - psql -c 'create database fresh_connection_test_slave1;' -U postgres
-  - psql -c 'create database fresh_connection_test_slave2;' -U postgres
+  - psql -c 'create database fresh_connection_test_replica1;' -U postgres
+  - psql -c 'create database fresh_connection_test_replica2;' -U postgres
 cache: bundler
 rvm:
   - 2.1.10

data/README.md

@@ -1,68 +1,87 @@
 # FreshConnection
 [![Gem Version](https://badge.fury.io/rb/fresh_connection.svg)](http://badge.fury.io/rb/fresh_connection) [![Build Status](https://travis-ci.org/tsukasaoishi/fresh_connection.svg?branch=master)](https://travis-ci.org/tsukasaoishi/fresh_connection) [![Code Climate](https://codeclimate.com/github/tsukasaoishi/fresh_connection/badges/gpa.svg)](https://codeclimate.com/github/tsukasaoishi/fresh_connection)
 
-FreshConnection can access to slave servers via a load balancer.
+**FreshConnection** provides access to one or more configured database replicas.
 
-For example.
+For example:
 ```
-Rails ------------ Master DB
+Rails ------------ DB Master
              |
-             |                     +------ Slave1 DB
+             +---- DB Replica
+
+```
+
+or:
+
+```
+Rails -------+---- DB Master
+             |
+             |                     +------ DB Replica1
              |                     |
              +---- Loadbalancer ---+
                                    |
-                                   +------ Slave2 DB
+                                   +------ DB Replica2
 ```
 
-FreshConnction connects with one of slave servers behind the load balancer.  
-Read query goes to the slave server.  
-Write query goes to the master server.  
-Inside transaction, all queries go to the master server.  
+FreshConnction connects one or more configured DB replicas, or with multiple
+replicas behind a DB query load balancer.
+
+- Read queries go to the DB replica.
+- Write queries go to the DB master.
+- Within a transaction, all queries go to the DB master.
 
-If you can't use a load balancer, could use [EbisuConnection](https://github.com/tsukasaoishi/ebisu_connection).
+If you wish to use multiple DB replicas on any given connection but not have
+a load balancer (such as [`pgbouncer`](https://pgbouncer.github.io) for Posgres
+databases), you can use [EbisuConnection](https://github.com/tsukasaoishi/ebisu_connection).
 
 ## Usage
-### Access to Slave
-Read query goes to the slave server.
+### Access to the DB Replica
+Read queries are automatically connected to the DB replica.
 
 ```ruby
-Article.where(:id => 1)
+Article.where(id: 1)
+
+Account.count
 ```
 
-### Access to Master
-If read query want to access to the master server, use `read_master`.  
-In before version 0.4.3, can use `readonly(false)`.
+### Access to the DB Master
+If you wish to ensure that queries are directed to the DB master, call `read_master`.
+Before version 0.4.3, `readonly(false)` must be used.
 
 ```ruby
-Article.where(:id => 1).read_master
+Article.where(id: 1).read_master
+
+Account.count.read_master
 ```
 
-In transaction, All queries go to the master server.
+Within transactions, all queries are connected to the DB master.
 
 ```ruby
 Article.transaction do
-  Article.where(:id => 1)
+  Article.where(id: 1)
 end
 ```
 
-Create, Update and Delete queries go to the master server.
+Create, update and delete queries are connected to the DB master.
 
 ```ruby
-article = Article.create(...)
-article.title = "FreshConnection"
-article.save
-article.destory
+new_article = Article.create(...)
+new_article.title = "FreshConnection"
+new_article.save
+...
+old_article.destroy
 ```
 
-## Support ActiveRecord version
-FreshConnection supports ActiveRecord version 4.0 or later.  
-If you are using Rails 3.2, could use FreshConnection version 1.0.0 or before.
+## ActiveRecord Versions Supported
+FreshConnection supports ActiveRecord version 4.2 or later.
+If you are using Rails 4.1 or 4.0, you can use FreshConnection version 2.1.2 or before.
+If you are using Rails 3.2, you can use FreshConnection version 1.0.0 or before.
 
-## Support DB
-FreshConnection supports MySQL and PostgreSQL.
+## Databases Supported
+FreshConnection currently supports MySQL and PostgreSQL.
 
 ## Installation
-Add this line to your application's Gemfile:
+Add this line to your application's `Gemfile`:
 
 ```ruby
 gem "fresh_connection"
@@ -74,105 +93,158 @@ And then execute:
 $ bundle
 ```
 
-Or install it yourself as:
+Or install it manually with:
 
 ```
 $ gem install fresh_connection
 ```
 
+### Variant Installation For Use With Some Other ActiveRecord Gems
+If you are using NewRelic or other gems that insert themselves into the
+ActiveRecord call-chain using `method_alias`, then a slight variation on the
+installation and configuration is required.
 
-## Config
-### config/database.yml
+In the `Gemfile`, use:
 
-```yaml
-production:
-  adapter: mysql2
-  encoding: utf8
-  reconnect: true
-  database: kaeru
-  pool: 5
-  username: master
-  password: master
-  host: localhost
-  socket: /var/run/mysqld/mysqld.sock
+```ruby
+gem "fresh_connection", require: false
+```
+
+Then, in `config/application.rb`, add the following:
 
-  slave:
-    username: slave
-    password: slave
-    host: slave
+```ruby
+config.after_initialize do
+  require 'fresh_connection'
+end
 ```
 
-```slave``` is a config to connect to slave servers.
-Others will use the master server settings.
+## Configuration
+
+The FreshConnection database replica is configured within the standard Rails
+database configuration file, `config/database.yml`, using a `replica:` stanza.
+
+*Security Note*:
+
+> We strongly recommend against using secrets within the `config/database.yml`
+> file.  Instead, it is both convenient and advisable to use ERB substitutions with 
+> environment variables within the file.
 
-### use multiple slave servers group
-If you may want to use multiple slave groups, write the config to ```config/database.yml```.
+> Using the [`dotenv`](https://github.com/bkeepers/dotenv) gem to keep secrets in a `.env` file that is never committed 
+> to the source management repository will help make secrets manageable.
+
+Below is a sample such configuration file.
+
+### `config/database.yml`
 
 ```yaml
 production:
-  adapter: mysql2
-  encoding: utf8
+  adapter:   mysql2
+  encoding:  utf8
   reconnect: true
-  database: kaeru
-  pool: 5
-  username: master
-  password: master
-  host: localhost
-  socket: /var/run/mysqld/mysqld.sock
+  database:  <%= ENV['DB_MASTER_NAME'] %>
+  pool:      5
+  username:  <%= ENV['DB_MASTER_USER'] %>
+  password:  <%= ENV['DB_MASTER_PASS'] %>
+  host:      <%= ENV['DB_MASTER_HOST'] %>
+  socket:    /var/run/mysqld/mysqld.sock
+
+  replica:
+    username: <%= ENV['DB_REPLICA_USER'] %>
+    password: <%= ENV['DB_REPLICA_PASS'] %>
+    host:     <%= ENV['DB_REPLICA_HOST'] %>
+```
+
+`replica` is the configuration used for connecting read-only queries to the
+database replica.  All other connections will use the database master settings.
+
+### Multiple DB Replicas
+If you want to use multiple configured DB replicas, the configuration can
+contain multiple `replica` stanzas in the configuration file `config/database.yml`.
 
-  slave:
-    username: slave
-    password: slave
-    host: slave
+For example:
 
-  admin_slave:
-    username: slave
-    password: slave
-    host: admin_slaves
+```yaml
+production:
+  adapter:   mysql2
+  encoding:  utf8
+  reconnect: true
+  database:  <%= ENV['DB_MASTER_NAME'] %>
+  pool:      5
+  username:  <%= ENV['DB_MASTER_USER'] %>
+  password:  <%= ENV['DB_MASTER_PASS'] %>
+  host:      <%= ENV['DB_MASTER_HOST'] %>
+  socket:    /var/run/mysqld/mysqld.sock
+
+  replica:
+    username: <%= ENV['DB_REPLICA_USER'] %>
+    password: <%= ENV['DB_REPLICA_PASS'] %>
+    host:     <%= ENV['DB_REPLICA_HOST'] %>
+
+  admin_replica:
+    username: <%= ENV['DB_ADMIN_REPLICA_USER'] %>
+    password: <%= ENV['DB_ADMIN_REPLICA_PASS'] %>
+    host:     <%= ENV['DB_ADMIN_REPLICA_HOST'] %>
 ```
 
-And call the establish_fresh_connection method in a model that access to ```admin_slave``` slave group.
+The custom replica stanza can then be applied as an argument to the
+`establish_fresh_connection` method in the models that should use it.  For
+example:
 
 ```ruby
 class AdminUser < ActiveRecord::Base
-  establish_fresh_connection :admin_slave
+  establish_fresh_connection :admin_replica
 end
 ```
 
-The children class will access to same slave group as the parent.
+The child (sub) classes of the configured model will inherit the same access
+as the parent class.  Example:
 
 ```ruby
-class Parent < ActiveRecord::Base
-  establish_fresh_connection :admin_slave
+class AdminBase < ActiveRecord::Base
+  establish_fresh_connection :admin_replica
+end
+
+class AdminUser < AdminBase
 end
 
-class AdminUser < Parent
+class Benefit < AdminBase
 end
 
-class Benefit < Parent
+class Customer < ActiveRecord::Base
 end
 ```
 
-AdminUser and Benefit access to ```admin_slave``` slave group.
+The `AdminUser` and `Benefit` models will access the database configured for
+the `admin_replica` group.
 
+The `Customer` model will use the default connections: read-only queries will
+connect to the standard DB replica, and state-changing queries will connect to
+the DB master.
 
-### Declare model that doesn't use slave db
+
+### Master-only Models
+
+It is possible to declare that specific models always use the DB master for all connections, using
+the `master_db_only!` method:
 
 ```ruby
-class SomethingModel < ActiveRecord::Base
+class CustomerState < ActiveRecord::Base
   master_db_only!
 end
 ```
 
-If a model that always access to the master server is exist, You write ```master_db_only!```  in the model.
-The model that master_db_only model's child is always access to master db.
+All queries generated by methods on the `CustomerState` model will be directed to the DB master.
+
+### Using FreshConnection With Unicorn
 
-### for Unicorn
+When using FreshConnection with Unicorn (or any other multi-processing web
+server which restarts processes on the fly), connection management needs
+special attention during startup:
 
 ```ruby
 before_fork do |server, worker|
   ...
-  ActiveRecord::Base.clear_all_slave_connections!
+  ActiveRecord::Base.clear_all_replica_connections!
   ...
 end
 
@@ -183,37 +255,42 @@ after_fork do |server, worker|
 end
 ```
 
-### Slave Connection Manager
-Default slave connection manager is FreshConnection::ConnectionManager.
-If you would like to change slave connection manager, assign yourself slave connection manager.
+### Replica Connection Manager
+The default replica connection manager is `FreshConnection::ConnectionManager`.
+If an alternative (custom) replica connection manager is desired, this can be done
+with a simple assignment within a Rails initializer:
 
-#### config/initializers/fresh_connection.rb
+`config/initializers/fresh_connection.rb`:
 
 ```ruby
-FreshConnection.connection_manager = MySlaveConnection
+FreshConnection.connection_manager = MyOwnReplicaConnection
 ```
 
-
-Yourself Slave Connection Manager should be inherited FreshConnection::AbstractConnectionManager
+The `MyOwnReplicaConnection` class should inherit from
+`FreshConnection::AbstractConnectionManager`, which has this interface:
 
 ```ruby
-class MySlaveConnection < FreshConnection::AbstractConnectionManager
-  def slave_connection
-    # must return object of ActiveRecord::ConnectionAdapters::Mysql2Adapter
+class MyOwnReplicaConnection < FreshConnection::AbstractConnectionManager
+
+  def replica_connection
+    # must return an instance of a subclass of ActiveRecord::ConnectionAdapters
+    # eg: ActiveRecord::ConnectionAdapter::Mysql2Adapter
+    # or: ActiveRecord::ConnectionAdapter::PostgresqlAdapter
   end
 
   def clear_all_connections!
-    # called when all connections disconnect
+    # called to disconnect all connections
   end
-  
+
   def put_aside!
     # called when end of Rails controller action
   end
 
   def recovery?
-    # called when raise exception to access slave server
-    # retry to access when this method return true
+    # called when raising exceptions on access to the DB replica
+    # access will be retried when this method returns true
   end
+
 end
 ```
 
@@ -228,17 +305,22 @@ end
 
 ## Test
 
-I'm glad that you would do test!
-To run the test suite, you need mysql installed.
-How to setup your test environment.
+I'm glad that you would test!
+To run the test suite, `mysql` must be installed.
+
+### Test Configuration
 
-First of all, you setting the config of the test mysql server in ```spec/database.yml```
+First, configure the test `mysql` server in `spec/database.yml`.
+
+Then, run:
 
 ```bash
 ./bin/setup
 ```
 
-This command run the spec suite for all rails versions supported.
+### Running Tests
+
+To run the spec suite for all supported versions of rails:
 
 ```bash
 ./bin/test

data/benchmarks/benchmark.rb

@@ -13,7 +13,7 @@ class ActiveRecord::Base
     username: 'root',
     password: '',
     socket: '/tmp/mysql.sock',
-    slave: { encoding: 'utf8' }
+    replica: { encoding: 'utf8' }
   )
 end
 

data/bin/test

@@ -1,6 +1,17 @@
 #!/usr/bin/env bash
 set -euo pipefail
 IFS=$'\n\t'
-set -vx
 
+for dbname in fresh_connection_test_master fresh_connection_test_replica1 fresh_connection_test_replica2 ; do
+  if ! psql $dbname -c '\q' 2>/dev/null ; then
+    if [[ -n "`psql -l | grep \"$dbname\"`" ]]; then
+      echo "Dropping database $dbname .."
+      dropdb $dbname
+    fi
+    echo "Creating database $dbname .."
+    createdb $dbname
+  fi
+done
+
+set -vx
 bundle exec appraisal rake test

data/fresh_connection.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Tsukasa OISHI"]
   spec.email         = ["tsukasa.oishi@gmail.com"]
 
-  spec.summary       = %q{FreshConnection supports to connect with Mysql slave servers via Load Balancers.}
+  spec.summary       = %q{FreshConnection supports connections with configured replica servers.}
   spec.description   = %q{https://github.com/tsukasaoishi/fresh_connection}
   spec.homepage      = "https://github.com/tsukasaoishi/fresh_connection"
   spec.license       = "MIT"

data/lib/fresh_connection/abstract_connection_manager.rb

@@ -1,15 +1,36 @@
+require 'active_support/deprecation'
+
 module FreshConnection
   class AbstractConnectionManager
-    attr_reader :slave_group
+    class << self
+      def method_added(name)
+        return unless name == :slave_connection
+
+        ActiveSupport::Deprecation.warn(
+          "'slave_connection' has been deprecated. use 'replica_connection' insted."
+        )
+      end
+    end
+
+    attr_reader :replica_group
+
+    def initialize(replica_group = "replica")
+      replica_group = "replica" if replica_group.to_s == "slave"
+      @replica_group = replica_group.to_s
+      @replica_group = "replica" if @replica_group.empty?
+    end
+
+    def slave_group
+      ActiveSupport::Deprecation.warn(
+        "'slave_group' is deprecated and will removed from version 2.4.0. use 'replica_group' insted."
+      )
 
-    def initialize(slave_group = "slave")
-      @slave_group = slave_group.to_s
-      @slave_group = "slave" if @slave_group.empty?
+      replica_group
     end
 
-    def slave_connection
+    def replica_connection
     end
-    undef_method :slave_connection
+    undef_method :replica_connection
 
     def clear_all_connections!
     end

data/lib/fresh_connection/access_control.rb

@@ -5,17 +5,17 @@ module FreshConnection
         switch_to(:master, &block)
       end
 
-      def access(enable_slave_access, &block)
+      def access(enable_replica_access, &block)
         if access_db
           block.call
         else
-          db = enable_slave_access ? :slave : :master
+          db = enable_replica_access ? :replica : :master
           switch_to(db, &block)
         end
       end
 
-      def slave_access?
-        access_db == :slave
+      def replica_access?
+        access_db == :replica
       end
 
       def catch_exceptions

data/lib/fresh_connection/connection_factory.rb

@@ -1,3 +1,4 @@
+require 'active_support/deprecation'
 require 'active_support/core_ext/hash/keys'
 
 module FreshConnection
@@ -23,7 +24,18 @@ module FreshConnection
 
     def build_spec
       config = ar_spec.config.symbolize_keys
-      group_config = (config[@group] || {}).symbolize_keys
+      group_config = config[@group]
+
+      # provide backward compatibility for older :slave usage
+      if !group_config && @group == :replica && config.key?(:slave)
+        ActiveSupport::Deprecation.warn(
+          "'slave' in database.yml is deprecated and will ignored from version 2.4.0. use 'replica' insted."
+        )
+        group_config = config[:slave]
+      end
+
+      group_config = (group_config || {}).symbolize_keys
+
       config.merge(group_config).merge(@modify_spec)
     end
 

data/lib/fresh_connection/connection_manager.rb

@@ -9,7 +9,7 @@ module FreshConnection
       @connections = Concurrent::Map.new
     end
 
-    def slave_connection
+    def replica_connection
       @connections.fetch_or_store(current_thread_id) do |_|
         connection_factory.new_connection
       end
@@ -29,7 +29,7 @@ module FreshConnection
     end
 
     def recovery?
-      return false if slave_connection.active?
+      return false if replica_connection.active?
       put_aside!
       true
     end
@@ -37,7 +37,7 @@ module FreshConnection
     private
 
     def connection_factory
-      @connection_factory ||= ConnectionFactory.new(@slave_group)
+      @connection_factory ||= ConnectionFactory.new(@replica_group)
     end
 
     def current_thread_id

data/lib/fresh_connection/extend/ar_abstract_adapter.rb

@@ -2,11 +2,11 @@ module FreshConnection
   module Extend
     module ArAbstractAdapter
       def self.prepended(base)
-        base.send :attr_writer, :slave_group
+        base.send :attr_writer, :replica_group
       end
 
       def log(*args)
-        args[1] = "[#{@slave_group}] #{args[1]}" if defined?(@slave_group)
+        args[1] = "[#{@replica_group}] #{args[1]}" if defined?(@replica_group)
         super
       end
     end

data/lib/fresh_connection/extend/ar_base.rb

@@ -1,15 +1,16 @@
+require 'active_support/deprecation'
 require 'fresh_connection/access_control'
-require 'fresh_connection/slave_connection_handler'
+require 'fresh_connection/replica_connection_handler'
 
 module FreshConnection
   module Extend
     module ArBase
       def connection
-        if FreshConnection::AccessControl.slave_access?
+        if FreshConnection::AccessControl.replica_access?
           if logger && logger.debug?
-            slave_connection.tap{|c| c.slave_group = slave_group }
+            replica_connection.tap{|c| c.replica_group = replica_group }
           else
-            slave_connection
+            replica_connection
           end
         else
           super
@@ -24,16 +25,32 @@ module FreshConnection
         all.manage_access(false, &block)
       end
 
-      def establish_fresh_connection(slave_group = nil)
-        slave_connection_handler.establish_connection(name, slave_group)
+      def establish_fresh_connection(replica_group = nil)
+        replica_connection_handler.establish_connection(name, replica_group)
+      end
+
+      def replica_connection
+        replica_connection_handler.connection(self)
       end
 
       def slave_connection
-        slave_connection_handler.connection(self)
+        ActiveSupport::Deprecation.warn(
+          "'slave_connection' is deprecated and will removed from version 2.4.0. use 'replica_connection' insted."
+        )
+
+        replica_connection
+      end
+
+      def clear_all_replica_connections!
+        replica_connection_handler.clear_all_connections!
       end
 
       def clear_all_slave_connections!
-        slave_connection_handler.clear_all_connections!
+        ActiveSupport::Deprecation.warn(
+          "'clear_all_slave_connections!' is deprecated and will removed from version 2.4.0. use 'clear_all_replica_connections!' insted."
+        )
+
+        clear_all_replica_connections!
       end
 
       def master_db_only!
@@ -45,22 +62,46 @@ module FreshConnection
           (self != ActiveRecord::Base && superclass.master_db_only?)
       end
 
+      def replica_connection_put_aside!
+        replica_connection_handler.put_aside!
+      end
+
       def slave_connection_put_aside!
-        slave_connection_handler.put_aside!
+        ActiveSupport::Deprecation.warn(
+          "'slave_connection_put_aside!' is deprecated and will removed from version 2.4.0. use 'replica_connection_put_aside!' insted."
+        )
+
+        replica_connection_put_aside!
+      end
+
+      def replica_connection_recovery?
+        replica_connection_handler.recovery?(self)
       end
 
       def slave_connection_recovery?
-        slave_connection_handler.recovery?(self)
+        ActiveSupport::Deprecation.warn(
+          "'slave_connection_recovery?' is deprecated and will removed from version 2.4.0. use 'replica_connection_recovery?' insted."
+        )
+
+        replica_connection_recovery?
+      end
+
+      def replica_group
+        replica_connection_handler.replica_group(self)
       end
 
       def slave_group
-        slave_connection_handler.slave_group(self)
+        ActiveSupport::Deprecation.warn(
+          "'slave_connection_recovery?' is deprecated and will removed from version 2.4.0. use 'replica_connection_recovery?' insted."
+        )
+
+        replica_group
       end
 
       private
 
-      def slave_connection_handler
-        @@slave_connection_handler ||= FreshConnection::SlaveConnectionHandler.new
+      def replica_connection_handler
+        @@replica_connection_handler ||= FreshConnection::ReplicaConnectionHandler.new
       end
     end
   end

data/lib/fresh_connection/extend/ar_relation.rb

@@ -1,18 +1,20 @@
+require 'active_support/deprecation'
+
 module FreshConnection
   module Extend
     module ArRelation
       RETRY_LIMIT = 3
       private_constant :RETRY_LIMIT
 
-      def manage_access(slave_access = enable_slave_access, &block)
+      def manage_access(replica_access = enable_replica_access, &block)
         if @klass.master_db_only?
           FreshConnection::AccessControl.force_master_access(&block)
         else
           retry_count = 0
           begin
-            FreshConnection::AccessControl.access(slave_access, &block)
+            FreshConnection::AccessControl.access(replica_access, &block)
           rescue *FreshConnection::AccessControl.catch_exceptions
-            if @klass.slave_connection_recovery?
+            if @klass.replica_connection_recovery?
               retry_count += 1
               retry if retry_count < RETRY_LIMIT
             end
@@ -52,10 +54,18 @@ module FreshConnection
         @values[:read_master] = value
       end
 
-      def enable_slave_access
+      def enable_replica_access
         connection.open_transactions == 0 && !read_master_value
       end
 
+      def enable_slave_access
+        ActiveSupport::Deprecation.warn(
+          "'enable_slave_access' is deprecated and will removed from version 2.4.0. use 'enable_replica_access' insted."
+        )
+
+        enable_replica_access
+      end
+
       private
 
       def exec_queries

data/lib/fresh_connection/rack/connection_management.rb

@@ -10,12 +10,12 @@ module FreshConnection
 
         response = @app.call(env)
         response[2] = ::Rack::BodyProxy.new(response[2]) do
-          ActiveRecord::Base.slave_connection_put_aside! unless testing
+          ActiveRecord::Base.replica_connection_put_aside! unless testing
         end
 
         response
       rescue Exception
-        ActiveRecord::Base.slave_connection_put_aside! unless testing
+        ActiveRecord::Base.replica_connection_put_aside! unless testing
         raise
       end
     end

data/lib/fresh_connection/{slave_connection_handler.rb → replica_connection_handler.rb}

@@ -1,21 +1,21 @@
 require 'concurrent'
 
 module FreshConnection
-  class SlaveConnectionHandler
+  class ReplicaConnectionHandler
     def initialize
       @class_to_pool = Concurrent::Map.new
     end
 
-    def establish_connection(name, slave_group)
+    def establish_connection(name, replica_group)
       if cm = class_to_pool[name]
         cm.put_aside!
       end
 
-      class_to_pool[name] = FreshConnection.connection_manager.new(slave_group)
+      class_to_pool[name] = FreshConnection.connection_manager.new(replica_group)
     end
 
     def connection(klass)
-      detect_connection_manager(klass).slave_connection
+      detect_connection_manager(klass).replica_connection
     end
 
     def clear_all_connections!
@@ -34,8 +34,8 @@ module FreshConnection
       end
     end
 
-    def slave_group(klass)
-      detect_connection_manager(klass).slave_group
+    def replica_group(klass)
+      detect_connection_manager(klass).replica_group
     end
 
     private

data/lib/fresh_connection/version.rb

@@ -1,4 +1,4 @@
 module FreshConnection
-  VERSION = "2.2.0"
+  VERSION = "2.3.0"
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fresh_connection
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.3.0
 platform: ruby
 authors:
 - Tsukasa OISHI
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-12 00:00:00.000000000 Z
+date: 2017-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -223,7 +223,7 @@ files:
 - lib/fresh_connection/extend/ar_statement_cache.rb
 - lib/fresh_connection/rack/connection_management.rb
 - lib/fresh_connection/railtie.rb
-- lib/fresh_connection/slave_connection_handler.rb
+- lib/fresh_connection/replica_connection_handler.rb
 - lib/fresh_connection/version.rb
 - log/.gitkeep
 homepage: https://github.com/tsukasaoishi/fresh_connection
@@ -249,5 +249,5 @@ rubyforge_project:
 rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: FreshConnection supports to connect with Mysql slave servers via Load Balancers.
+summary: FreshConnection supports connections with configured replica servers.
 test_files: []