active_record_replica 2.0.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 5cc978d66d3457173ce9e9c7f90a7fab59429853f52504d478f4f5abd2c9d885
-  data.tar.gz: 44c3ec2886dc9877b972869ba74b22b6dcdc72b00d5f50183b02246d5d3fc99a
+SHA1:
+  metadata.gz: ee1b932bf5ba07710e4ecdcc0257b8447a98a16f
+  data.tar.gz: 06742d6ba57b35da5b60c0772dce3ceaecd3b2fe
 SHA512:
-  metadata.gz: a620d2745c2b29212a3e1ba45eef5594ec25604286def24f623cdf5a6b473471462ed33632f4b93ad7f1f65575e75b6f70ad1e2b7554d058bf976b1327bbd4b5
-  data.tar.gz: f4a086eb1ce2d4a737a2b46336b20cbcb5038a5123a0d68ed0f6545cc4a9c4de0988c3e55289b185b0e12a72296dfce38120a04fbbc77166f5278dfca4ee3a00
+  metadata.gz: 3b87ec244163be9129dbcfa7cf1f8ae0c7447c644560ee8646d1666bee28cc2a45790b81477bdd59fbcdd33d20cf1d0740d4dcafb0cf36d61fb383c115d2abae
+  data.tar.gz: 10cdb1ef5e8d5b12a2277c346e336dc72b99ba4606e6e3d80dc08999b6bf180be24899210c10146ed51e5ef42f9e26f94389ed0aaa3f87d6d2e45ceeb77ad217

data/README.md

@@ -1,10 +1,388 @@
 # Active Record Replica
-![](https://img.shields.io/badge/status-DEPRECATED-red.svg) [![Gem Version](https://img.shields.io/gem/v/active_record_replica.svg)](https://rubygems.org/gems/active_record_replica) [![Build Status](https://travis-ci.org/rocketjob/active_record_replica.svg?branch=master)](https://travis-ci.org/rocketjob/active_record_replica) [![Downloads](https://img.shields.io/gem/dt/active_record_replica.svg)](https://rubygems.org/gems/active_record_replica) [![License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](http://opensource.org/licenses/Apache-2.0) 
+[![Gem Version](https://img.shields.io/gem/v/active_record_replica.svg)](https://rubygems.org/gems/active_record_replica)
+[![Build Status](https://travis-ci.org/teespring/active_record_replica.svg?branch=master)](https://travis-ci.org/teespring/active_record_replica)
+[![License](https://img.shields.io/badge/license-Apache%202.0-brightgreen.svg)](http://opensource.org/licenses/Apache-2.0)
+![](https://img.shields.io/badge/status-Production%20Ready-blue.svg)
 
 Redirect ActiveRecord (Rails) reads to replica databases while ensuring all writes go to the primary database.
 
 ## Status
+This is a slight modification of Rocket Job's original library, simply renaming it from `active_record_slave` to `active_record_replica`.
 
-All of the capabilities of this gem are now included in Rails 6 :tada:
+In order to more clearly distinguish the library from `active_record_slave`, we also incremented the major version – it is, however, functionally equivalent.
 
-_This gem is now archived and no longer maintained._
+## Introduction
+
+`active_record_replica` redirects all database reads to replica instances while ensuring
+that all writes go to the primary database. `active_record_replica` ensures that
+any reads that are performed within a database transaction are by default directed to the primary
+database to ensure data consistency.
+
+## Status
+
+Production Ready. Actively used in large production environments.
+
+## Features
+
+* Redirecting reads to a single replica database.
+* Works with any database driver that works with ActiveRecord.
+* Supports all Rails 3, 4, or 5 read apis.
+    * Including dynamic finders, AREL, and ActiveRecord::Base.select.
+    * **NOTE**: In Rails 3 and 4, QueryCache is only enabled for BaseConnection by default. In Rails 5, it's enabled for all connections. [(PR)](https://github.com/rails/rails/pull/28869)
+* Transaction aware
+    * Detects when a query is inside of a transaction and sends those reads to the primary by default.
+    * Can be configured to send reads in a transaction to replica databases.
+* Lightweight footprint.
+* No overhead whatsoever when a replica is _not_ configured.
+* Negligible overhead when redirecting reads to the replica.
+* Connection Pools to both databases are retained and maintained independently by ActiveRecord.
+* The primary and replica databases do not have to be of the same type.
+    * For example Oracle could be the primary with MySQL as the replica database.
+* Debug logs include a prefix of `Replica: ` to indicate which SQL statements are going
+  to the replica database.
+
+### Example showing Replica redirected read
+
+```ruby
+# Read from the replica database
+r = Role.where(name: 'manager').first
+r.description = 'Manager'
+
+# Save changes back to the primary database
+r.save!
+```
+
+Log file output:
+
+    03-13-12 05:56:05 pm,[2608],b[0],[0],  Replica: Role Load (3.0ms)  SELECT `roles`.* FROM `roles` WHERE `roles`.`name` = 'manager' LIMIT 1
+    03-13-12 05:56:22 pm,[2608],b[0],[0],  AREL (12.0ms)  UPDATE `roles` SET `description` = 'Manager' WHERE `roles`.`id` = 5
+
+### Example showing how reads within a transaction go to the primary
+
+```ruby
+Role.transaction do
+  r = Role.where(name: 'manager').first
+  r.description = 'Manager'
+  r.save!
+end
+```
+
+Log file output:
+
+    03-13-12 06:02:09 pm,[2608],b[0],[0],  Role Load (2.0ms)  SELECT `roles`.* FROM `roles` WHERE `roles`.`name` = 'manager' LIMIT 1
+    03-13-12 06:02:09 pm,[2608],b[0],[0],  AREL (2.0ms)  UPDATE `roles` SET `description` = 'Manager' WHERE `roles`.`id` = 4
+
+### Forcing a read against the primary
+
+Sometimes it is necessary to read from the primary:
+
+```ruby
+ActiveRecordReplica.read_from_primary do
+  r = Role.where(name: 'manager').first
+end
+```
+
+## Usage Notes
+
+### delete_all
+
+Delete all executes against the primary database since it is only a delete:
+
+```
+D, [2012-11-06T19:47:29.125932 #89772] DEBUG -- :   SQL (1.0ms)  DELETE FROM "users"
+```
+
+### destroy_all
+
+First performs a read against the replica database and then deletes the corresponding
+data from the primary
+
+```
+D, [2012-11-06T19:43:26.890674 #89002] DEBUG -- :   Replica: User Load (0.1ms)  SELECT "users".* FROM "users"
+D, [2012-11-06T19:43:26.890972 #89002] DEBUG -- :    (0.0ms)  begin transaction
+D, [2012-11-06T19:43:26.891667 #89002] DEBUG -- :   SQL (0.4ms)  DELETE FROM "users" WHERE "users"."id" = ?  [["id", 3]]
+D, [2012-11-06T19:43:26.892697 #89002] DEBUG -- :    (0.9ms)  commit transaction
+```
+
+## Transactions
+
+By default ActiveRecordReplica detects when a call is inside a transaction and will
+send all reads to the _primary_ when a transaction is active.
+
+It is now possible to send reads to database replicas and ignore whether currently
+inside a transaction:
+
+In file config/application.rb:
+
+```ruby
+# Read from replica even when in an active transaction
+config.active_record_replica.ignore_transactions = true
+```
+
+It is important to identify any code in the application that depends on being
+able to read any changes already part of the transaction, but not yet committed
+and wrap those reads with `ActiveRecordReplica.read_from_primary`
+
+```ruby
+Inquiry.transaction do
+  # Create a new inquiry
+  Inquiry.create
+
+  # The above inquiry is not visible yet if already in a Rails transaction.
+  # Use `read_from_primary` to ensure it is included in the count below:
+  ActiveRecordReplica.read_from_primary do
+    count = Inquiry.count
+  end
+
+end
+```
+
+## Note
+
+`active_record_replica` is a very simple layer that inserts itself into the call chain whenever a replica is configured.
+By observation we noticed that all reads are made to a select set of methods and
+all writes are made directly to one method: `execute`.
+
+Using this observation `active_record_replica` only needs to intercept calls to the known select apis:
+* select_all
+* select_one
+* select_rows
+* select_value
+* select_values
+
+Calls to the above methods are redirected to the replica active record model `ActiveRecordReplica::Replica`.
+This model is 100% managed by the regular Active Record mechanisms such as connection pools etc.
+
+This lightweight approach ensures that all calls to the above API's are redirected to the replica without impacting:
+* Transactions
+* Writes
+* Any SQL calls directly to `execute`
+
+One of the limitations with this approach is that any code that performs a query by calling `execute` direct will not
+be redirected to the replica instance. In this case replace the use of `execute` with one of the the above select methods.
+
+
+## Note when using `dependent: destroy`
+
+When performing in-memory only model assignments Active Record will create a transaction against the primary even though
+the transaction may never be used.
+
+Even though the transaction is unused it sends the following messages to the primary database:
+~~
+SET autocommit=0
+commit
+SET autocommit=1
+~~
+
+This will impact the primary database if sufficient calls are made, such as in batch workers.
+
+For Example:
+
+~~ruby
+class Parent < ActiveRecord::Base
+  has_one :child, dependent: :destroy
+end
+
+class Child < ActiveRecord::Base
+  belongs_to :parent
+end
+
+# The following code will create an unused transaction against the primary, even when reads are going to replicas:
+parent = Parent.new
+parent.child = Child.new
+~~
+
+If the `dependent: :destroy` is removed it no longer creates a transaction, but it also means dependents are not
+destroyed when a parent is destroyed.
+
+For this scenario when we are 100% confident no writes are being performed the following can be performed to
+ignore any attempt Active Record makes at creating the transaction:
+
+~~ruby
+ActiveRecordReplica.skip_transactions do
+  parent = Parent.new
+  parent.child = Child.new
+end
+~~
+
+To help identify any code within a block that is creating transactions, wrap the code with
+`ActiveRecordReplica.block_transactions` to make it raise an exception anytime a transaction is attempted:
+
+~~ruby
+ActiveRecordReplica.block_transactions do
+  parent = Parent.new
+  parent.child = Child.new
+end
+~~
+
+## Install
+
+Add to `Gemfile`
+
+```ruby
+gem 'active_record_replica'
+```
+
+Run bundler to install:
+
+```
+bundle
+```
+
+Or, without Bundler:
+
+```
+gem install active_record_replica
+```
+
+## Configuration
+
+To enable replica reads for any environment just add a _replica:_ entry to database.yml
+along with all the usual ActiveRecord database configuration options.
+
+For Example:
+
+```yaml
+production:
+  database: production
+  username: username
+  password: password
+  encoding: utf8
+  adapter:  mysql
+  host:     primary1
+  pool:     50
+  replica:
+    database: production
+    username: username
+    password: password
+    encoding: utf8
+    adapter:  mysql
+    host:     replica1
+    pool:     50
+```
+
+Sometimes it is useful to turn on replica reads per host, for example to activate
+replica reads only on the linux host 'batch':
+
+```yaml
+production:
+  database: production
+  username: username
+  password: password
+  encoding: utf8
+  adapter:  mysql
+  host:     primary1
+  pool:     50
+<% if `hostname`.strip == 'batch' %>
+  replica:
+    database: production
+    username: username
+    password: password
+    encoding: utf8
+    adapter:  mysql
+    host:     replica1
+    pool:     50
+<% end %>
+```
+
+If there are multiple replicas, it is possible to randomly select a replica on startup
+to balance the load across the replicas:
+
+```yaml
+production:
+  database: production
+  username: username
+  password: password
+  encoding: utf8
+  adapter:  mysql
+  host:     primary1
+  pool:     50
+  replica:
+    database: production
+    username: username
+    password: password
+    encoding: utf8
+    adapter:  mysql
+    host:     <%= %w(replica1 replica2 replica3).sample %>
+    pool:     50
+```
+
+Replicas can also be assigned to specific hosts by using the hostname:
+
+```yaml
+production:
+  database: production
+  username: username
+  password: password
+  encoding: utf8
+  adapter:  mysql
+  host:     primary1
+  pool:     50
+  replica:
+    database: production
+    username: username
+    password: password
+    encoding: utf8
+    adapter:  mysql
+    host:     <%= `hostname`.strip == 'app1' ? 'replica1' : 'replica2' %>
+    pool:     50
+```
+
+## Set primary as default for Read
+
+The default behavior can also set to read/write operations against primary database.
+
+Create an initializer file config/initializer/active_record_replica.rb to force read from primary:
+
+```yaml
+    ActiveRecordReplica.read_from_primary!
+```
+
+Then use this method and supply block to read from the replica database:
+
+```yaml
+ActiveRecordReplica.read_from_replica do
+   User.count
+end
+```
+
+## Dependencies
+
+See [.travis.yml](https://github.com/reidmorrison/active_record_replica/blob/master/.travis.yml) for the list of tested Ruby platforms
+
+## Versioning
+
+This project uses [Semantic Versioning](http://semver.org/).
+
+## Contributing
+
+1. Fork repository in Github.
+
+2. Checkout your forked repository:
+
+    ```bash
+    git clone https://github.com/your_github_username/active_record_replica.git
+    cd active_record_replica
+    ```
+
+3. Create branch for your contribution:
+
+    ```bash
+    git co -b your_new_branch_name
+    ```
+
+4. Make code changes.
+
+5. Ensure tests pass.
+
+6. Push to your fork origin.
+
+    ```bash
+    git push origin
+    ```
+
+7. Submit PR from the branch on your fork in Github.
+
+## Author
+
+[Reid Morrison](https://github.com/reidmorrison) :: @reidmorrison

data/lib/active_record_replica/active_record_replica.rb

@@ -2,13 +2,6 @@
 # ActiveRecord read from a replica
 #
 module ActiveRecordReplica
-  # Select Methods
-  SELECT_METHODS = [:select, :select_all, :select_one, :select_rows, :select_value, :select_values]
-
-  # In case in the future we are forced to intercept connection#execute if the
-  # above select methods are not sufficient
-  #   SQL_READS = /\A\s*(SELECT|WITH|SHOW|CALL|EXPLAIN|DESCRIBE)/i
-
   # Install ActiveRecord::Replica into ActiveRecord to redirect reads to the replica
   # Parameters:
   #   adapter_class:
@@ -19,35 +12,32 @@ module ActiveRecordReplica
   #     In a non-Rails environment, supply the environment such as
   #     'development', 'production'
   def self.install!(adapter_class = nil, environment = nil)
-    replica_config =
-      if ActiveRecord::Base.connection.respond_to?(:config)
-        ActiveRecord::Base.connection.config[:replica]
-      else
-        ActiveRecord::Base.configurations[environment || Rails.env]['replica']
-      end
-    if replica_config
-      ActiveRecord::Base.logger.info "ActiveRecordReplica.install! v#{ActiveRecordReplica::VERSION} Establishing connection to replica database"
-      Replica.establish_connection(replica_config)
-
-      # Inject a new #select method into the ActiveRecord Database adapter
-      base = adapter_class || ActiveRecord::Base.connection.class
-      base.include(Extensions)
-    else
-      ActiveRecord::Base.logger.info "ActiveRecordReplica not installed since no replica database defined"
+    replica_config = ActiveRecord::Base.configurations[environment || Rails.env]["replica"]
+    unless replica_config
+      ActiveRecord::Base.logger.info("ActiveRecordReplica not installed since no replica database defined")
+      return
+    end
+
+    # When the DBMS is not available, an exception (e.g. PG::ConnectionBad) is raised
+    active_db_connection = ActiveRecord::Base.connection.active? rescue false
+    unless active_db_connection
+      ActiveRecord::Base.logger.info("ActiveRecord not connected so not installing ActiveRecordReplica")
+      return
     end
+
+    version = ActiveRecordReplica::VERSION
+    ActiveRecord::Base.logger.info("ActiveRecordReplica.install! v#{version} Establishing connection to replica database")
+    Replica.establish_connection(replica_config)
+
+    # Inject a new #select method into the ActiveRecord Database adapter
+    base = adapter_class || ActiveRecord::Base.connection.class
+    base.include(Extensions)
   end
 
   # Force reads for the supplied block to read from the primary database
   # Only applies to calls made within the current thread
-  def self.read_from_primary
-    return yield if read_from_primary?
-    begin
-      previous = Thread.current.thread_variable_get(:active_record_replica)
-      read_from_primary!
-      yield
-    ensure
-      Thread.current.thread_variable_set(:active_record_replica, previous)
-    end
+  def self.read_from_primary(&block)
+    thread_variable_yield(:active_record_replica, :primary, &block)
   end
 
   #
@@ -56,71 +46,63 @@ module ActiveRecordReplica
   # and set ActiveRecordReplica.read_from_primary! to force read from primary.
   # Then use this method and supply block to read from the replica database
   # Only applies to calls made within the current thread
-  def self.read_from_replica
-    return yield if read_from_replica?
-    begin
-      previous = Thread.current.thread_variable_get(:active_record_replica)
-      read_from_replica!
-      yield
-    ensure
-      Thread.current.thread_variable_set(:active_record_replica, previous)
-    end
+  def self.read_from_replica(&block)
+    thread_variable_yield(:active_record_replica, :replica, &block)
   end
 
   # When only reading from a replica it is important to prevent entering any into
   # a transaction since the transaction still sends traffic to the primary
   # that will cause the primary database to slow down processing empty transactions.
   def self.block_transactions
-    begin
-      previous = Thread.current.thread_variable_get(:active_record_replica_transaction)
-      Thread.current.thread_variable_set(:active_record_replica_transaction, :block)
-      yield
-    ensure
-      Thread.current.thread_variable_set(:active_record_replica_transaction, previous)
-    end
+    thread_variable_yield(:active_record_replica_transaction, :block, &block)
   end
 
   # During this block any attempts to start or end transactions will be ignored.
   # This extreme action should only be taken when 100% certain no writes are going to be
   # performed.
   def self.skip_transactions
-    begin
-      previous = Thread.current.thread_variable_get(:active_record_replica_transaction)
-      Thread.current.thread_variable_set(:active_record_replica_transaction, :skip)
-      yield
-    ensure
-      Thread.current.thread_variable_set(:active_record_replica_transaction, previous)
-    end
+    thread_variable_yield(:active_record_replica_transaction, :skip, &block)
   end
 
   # Whether this thread is currently forcing all reads to go against the primary database
   def self.read_from_primary?
-    Thread.current.thread_variable_get(:active_record_replica) == :primary
+    !read_from_replica?
   end
 
   # Whether this thread is currently forcing all reads to go against the replica database
   def self.read_from_replica?
-    Thread.current.thread_variable_get(:active_record_replica).nil?
+    case Thread.current.thread_variable_get(:active_record_replica)
+    when :primary
+      false
+    when :replica
+      true
+    else
+      @read_from_replica
+    end
   end
 
-  # Force all subsequent reads on this thread and any fibers called by this thread to go the primary
+  # Force all subsequent reads in this process to read from the primary database.
+  #
+  # The default behavior can be set to read/write operations against primary.
+  # Create an initializer file config/initializer/active_record_replica.rb
+  # and set ActiveRecordReplica.read_from_primary! to force read from primary.
   def self.read_from_primary!
-    Thread.current.thread_variable_set(:active_record_replica, :primary)
+    @read_from_replica = false
   end
 
-  # Subsequent reads on this thread and any fibers called by this thread can go to a replica
+  # Force all subsequent reads in this process to read from the replica database.
   def self.read_from_replica!
-    Thread.current.thread_variable_set(:active_record_replica, nil)
+    @read_from_replica = true
   end
 
   # Whether any attempt to start a transaction should result in an exception
   def self.block_transactions?
-    Thread.current.thread_variable_get(:active_record_replica_transaction) == :block
+    thread_variable_equals(:active_record_replica_transaction, :block)
   end
 
   # Whether any attempt to start a transaction should be skipped.
   def self.skip_transactions?
-    Thread.current.thread_variable_get(:active_record_replica_transaction) == :skip
+    thread_variable_equals(:active_record_replica_transaction, :skip)
   end
 
   # Returns whether replica reads are ignoring transactions
@@ -135,5 +117,24 @@ module ActiveRecordReplica
 
   private
 
+  def self.thread_variable_equals(key, value)
+    Thread.current.thread_variable_get(key) == value
+  end
+
+  # Sets the thread variable for the duration of the supplied block.
+  # Restores the previous value on completion of the block.
+  def self.thread_variable_yield(key, new_value)
+    previous = Thread.current.thread_variable_get(key)
+    return yield if previous == new_value
+
+    begin
+      Thread.current.thread_variable_set(key, new_value)
+      yield
+    ensure
+      Thread.current.thread_variable_set(key, previous)
+    end
+  end
+
   @ignore_transactions = false
+  @read_from_replica   = true
 end

data/lib/active_record_replica/extensions.rb

@@ -3,7 +3,7 @@ module ActiveRecordReplica
   module Extensions
     extend ActiveSupport::Concern
 
-    ActiveRecordReplica::SELECT_METHODS.each do |select_method|
+    [:select, :select_all, :select_one, :select_rows, :select_value, :select_values].each do |select_method|
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{select_method}(sql, name = nil, *args)
           return super if active_record_replica_read_from_primary?

data/lib/active_record_replica/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordReplica
-  VERSION = '2.0.1'
+  VERSION = '3.0.0'
 end

data/test/active_record_replica_test.rb

@@ -1,93 +1,44 @@
-require File.join(File.dirname(__FILE__), 'test_helper')
-require 'logger'
-require 'erb'
-
-l                                 = Logger.new('test.log')
-l.level                           = ::Logger::DEBUG
-ActiveRecord::Base.logger         = l
-ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read('test/database.yml')).result)
-
-# Define Schema in second database (replica)
-# Note: This is not be required when the primary database is being replicated to the replica db
-ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test']['replica'])
-
-# Create table users in database active_record_replica_test
-ActiveRecord::Schema.define :version => 0 do
-  create_table :users, :force => true do |t|
-    t.string :name
-    t.string :address
-  end
-end
-
-# Define Schema in primary database
-ActiveRecord::Base.establish_connection(:test)
+# frozen_string_literal: true
 
-# Create table users in database active_record_replica_test
-ActiveRecord::Schema.define :version => 0 do
-  create_table :users, :force => true do |t|
-    t.string :name
-    t.string :address
-  end
-end
-
-# AR Model
-class User < ActiveRecord::Base
-end
-
-# Install ActiveRecord replica. Done automatically by railtie in a Rails environment
-# Also tell it to use the test environment since Rails.env is not available
-ActiveRecordReplica.install!(nil, 'test')
+require_relative "test_helper"
 
 #
 # Unit Test for active_record_replica
 #
-# Since their is no database replication in this test environment, it will
+# Since there is no database replication in this test environment, it will
 # use 2 separate databases. Writes go to the first database and reads to the second.
 # As a result any writes to the first database will not be visible when trying to read from
 # the second test database.
+#
+# The tests verify that reads going to the replica database do not find data written to the primary.
 class ActiveRecordReplicaTest < Minitest::Test
-  describe 'the active_record_replica gem' do
+  describe ActiveRecordReplica do
+    let(:user_name) { "Joe Bloggs" }
+    let(:address) { "Somewhere" }
+    let(:user) { User.new(name: user_name, address: address) }
 
     before do
       ActiveRecordReplica.ignore_transactions = false
-
-      User.delete_all
-
-      @name    = "Joe Bloggs"
-      @address = "Somewhere"
-      @user    = User.new(
-        :name    => @name,
-        :address => @address
-      )
-    end
-
-    after do
+      ActiveRecordReplica.read_from_replica!
       User.delete_all
     end
 
-    it 'saves to primary' do
-      assert_equal true, @user.save!
+    it "saves to primary" do
+      user.save!
     end
 
-    #
-    # NOTE:
-    #
-    #   There is no automated replication between the SQL lite databases
-    #   so the tests will be verifying that reads going to the "replica" (second)
-    #   database do not find data written to the primary.
-    #
-    it 'saves to primary, read from replica' do
+    it "saves to primary, read from replica" do
       # Read from replica
-      assert_equal 0, User.where(:name => @name, :address => @address).count
+      assert_equal 0, User.where(name: user_name, address: address).count
 
       # Write to primary
-      assert_equal true, @user.save!
+      user.save!
 
       # Read from replica
-      assert_equal 0, User.where(:name => @name, :address => @address).count
+      assert_equal 0, User.where(name: user_name, address: address).count
     end
 
-    it 'save to primary, read from primary when in a transaction' do
+    it "save to primary, read from primary when in a transaction" do
       assert_equal false, ActiveRecordReplica.ignore_transactions?
 
       User.transaction do
@@ -95,56 +46,115 @@ class ActiveRecordReplicaTest < Minitest::Test
         assert_equal 0, User.count
 
         # Read from Primary
-        assert_equal 0, User.where(:name => @name, :address => @address).count
+        assert_equal 0, User.where(name: user_name, address: address).count
 
         # Write to primary
-        assert_equal true, @user.save!
+        user.save!
 
         # Read from Primary
-        assert_equal 1, User.where(:name => @name, :address => @address).count
+        assert_equal 1, User.where(name: user_name, address: address).count
       end
 
       # Read from Non-replicated replica
-      assert_equal 0, User.where(:name => @name, :address => @address).count
+      assert_equal 0, User.where(name: user_name, address: address).count
     end
 
-    it 'save to primary, read from replica when ignoring transactions' do
+    it "save to primary, read from replica when ignoring transactions" do
       ActiveRecordReplica.ignore_transactions = true
-      assert_equal true, ActiveRecordReplica.ignore_transactions?
+      assert ActiveRecordReplica.ignore_transactions?
 
       User.transaction do
         # The delete_all in setup should have cleared the table
         assert_equal 0, User.count
 
         # Read from Primary
-        assert_equal 0, User.where(:name => @name, :address => @address).count
+        assert_equal 0, User.where(name: user_name, address: address).count
 
         # Write to primary
-        assert_equal true, @user.save!
+        user.save!
 
         # Read from Non-replicated replica
-        assert_equal 0, User.where(:name => @name, :address => @address).count
+        assert_equal 0, User.where(name: user_name, address: address).count
       end
 
       # Read from Non-replicated replica
-      assert_equal 0, User.where(:name => @name, :address => @address).count
+      assert_equal 0, User.where(name: user_name, address: address).count
     end
 
-    it 'saves to primary, force a read from primary even when _not_ in a transaction' do
+    it "saves to primary, force a read from primary even when _not_ in a transaction" do
       # Read from replica
-      assert_equal 0, User.where(:name => @name, :address => @address).count
+      assert_equal 0, User.where(name: user_name, address: address).count
 
       # Write to primary
-      assert_equal true, @user.save!
+      user.save!
 
       # Read from replica
-      assert_equal 0, User.where(:name => @name, :address => @address).count
+      assert_equal 0, User.where(name: user_name, address: address).count
 
       # Read from Primary
       ActiveRecordReplica.read_from_primary do
-        assert_equal 1, User.where(:name => @name, :address => @address).count
+        assert_equal 1, User.where(name: user_name, address: address).count
       end
     end
 
+    describe ".read_from_replica?" do
+      it "is true when global replica flag is set" do
+        ActiveRecordReplica.read_from_replica!
+        assert ActiveRecordReplica.read_from_replica?
+      end
+
+      it "is false when reading from replica" do
+        ActiveRecordReplica.read_from_primary!
+        refute ActiveRecordReplica.read_from_replica?
+      end
+    end
+
+    describe ".read_from_primary?" do
+      it "is true when global primary flag is set" do
+        ActiveRecordReplica.read_from_primary!
+        assert ActiveRecordReplica.read_from_primary?
+      end
+
+      it "is false when reading from replica" do
+        ActiveRecordReplica.read_from_replica!
+        refute ActiveRecordReplica.read_from_primary?
+      end
+    end
+
+    describe ".read_from_replica" do
+      it "works with global replica flag" do
+        ActiveRecordReplica.read_from_replica!
+        ActiveRecordReplica.read_from_replica do
+          assert ActiveRecordReplica.read_from_replica?
+          refute ActiveRecordReplica.read_from_primary?
+        end
+      end
+
+      it "overwrites global replica flag" do
+        ActiveRecordReplica.read_from_primary!
+        ActiveRecordReplica.read_from_replica do
+          assert ActiveRecordReplica.read_from_replica?
+          refute ActiveRecordReplica.read_from_primary?
+        end
+      end
+    end
+
+    describe ".read_from_primary" do
+      it "works with global replica flag" do
+        ActiveRecordReplica.read_from_primary!
+        ActiveRecordReplica.read_from_primary do
+          assert ActiveRecordReplica.read_from_primary?
+          refute ActiveRecordReplica.read_from_replica?
+        end
+      end
+
+      it "overwrites global replica flag" do
+        ActiveRecordReplica.read_from_replica!
+        ActiveRecordReplica.read_from_primary do
+          assert ActiveRecordReplica.read_from_primary?
+          refute ActiveRecordReplica.read_from_replica?
+        end
+      end
+    end
   end
 end

data/test/database.yml

@@ -3,7 +3,7 @@ test:
   database: test/test.sqlite3
   pool:     5
   timeout:  5000
-  # Make the replica a separate database that is not replicad to ensure reads
+  # Make the replica a separate database that is not replicated to ensure reads
   # and writes go to the appropriate databases
   replica:
     adapter:  sqlite3

data/test/test_helper.rb

@@ -4,3 +4,41 @@ require 'active_record'
 require 'minitest/autorun'
 require 'active_record_replica'
 require 'awesome_print'
+require 'logger'
+require 'erb'
+
+l                                 = Logger.new('test.log')
+l.level                           = ::Logger::DEBUG
+ActiveRecord::Base.logger         = l
+ActiveRecord::Base.configurations = YAML::load(ERB.new(IO.read('test/database.yml')).result)
+
+# Define Schema in second database (replica)
+# Note: This is not be required when the primary database is being replicated to the replica db
+ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test']['replica'])
+
+# Create table users in database active_record_replica_test
+ActiveRecord::Schema.define :version => 0 do
+  create_table :users, :force => true do |t|
+    t.string :name
+    t.string :address
+  end
+end
+
+# Define Schema in primary database
+ActiveRecord::Base.establish_connection(:test)
+
+# Create table users in database active_record_replica_test
+ActiveRecord::Schema.define :version => 0 do
+  create_table :users, :force => true do |t|
+    t.string :name
+    t.string :address
+  end
+end
+
+# AR Model
+class User < ActiveRecord::Base
+end
+
+# Install ActiveRecord replica. Done automatically by railtie in a Rails environment
+# Also tell it to use the test environment since Rails.env is not available
+ActiveRecordReplica.install!(nil, 'test')

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: active_record_replica
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Reid Morrison
-autorequire: 
+- James Brady
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-14 00:00:00.000000000 Z
+date: 2021-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -30,9 +31,10 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: 6.0.0
-description: 
+description:
 email:
 - reidmo@gmail.com
+- james@spri.ng
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -49,14 +51,12 @@ files:
 - lib/active_record_replica/version.rb
 - test/active_record_replica_test.rb
 - test/database.yml
-- test/test.sqlite3
 - test/test_helper.rb
-- test/test_replica.sqlite3
-homepage: https://github.com/rocketjob/active_record_replica
+homepage: https://github.com/teespring/active_record_replica
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -71,14 +71,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubyforge_project:
+rubygems_version: 2.6.14.3
+signing_key:
 specification_version: 4
 summary: Redirect ActiveRecord (Rails) reads to replica databases while ensuring all
   writes go to the primary database.
 test_files:
 - test/database.yml
 - test/test_helper.rb
-- test/test.sqlite3
 - test/active_record_replica_test.rb
-- test/test_replica.sqlite3