active_record_replica 2.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5cc978d66d3457173ce9e9c7f90a7fab59429853f52504d478f4f5abd2c9d885
+  data.tar.gz: 44c3ec2886dc9877b972869ba74b22b6dcdc72b00d5f50183b02246d5d3fc99a
+SHA512:
+  metadata.gz: a620d2745c2b29212a3e1ba45eef5594ec25604286def24f623cdf5a6b473471462ed33632f4b93ad7f1f65575e75b6f70ad1e2b7554d058bf976b1327bbd4b5
+  data.tar.gz: f4a086eb1ce2d4a737a2b46336b20cbcb5038a5123a0d68ed0f6545cc4a9c4de0988c3e55289b185b0e12a72296dfce38120a04fbbc77166f5278dfca4ee3a00

data/LICENSE.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2012, 2013, 2014 Reid Morrison
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,10 @@
+# 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) 
+
+Redirect ActiveRecord (Rails) reads to replica databases while ensuring all writes go to the primary database.
+
+## Status
+
+All of the capabilities of this gem are now included in Rails 6 :tada:
+
+_This gem is now archived and no longer maintained._

data/Rakefile

@@ -0,0 +1,31 @@
+# Setup bundler to avoid having to run bundle exec all the time.
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rake/testtask'
+require_relative 'lib/active_record_replica/version'
+
+task :gem do
+  system "gem build active_record_replica.gemspec"
+end
+
+task :publish => :gem do
+  system "git tag -a v#{ActiveRecordReplica::VERSION} -m 'Tagging #{ActiveRecordReplica::VERSION}'"
+  system "git push --tags"
+  system "gem push active_record_replica-#{ActiveRecordReplica::VERSION}.gem"
+  system "rm active_record_replica-#{ActiveRecordReplica::VERSION}.gem"
+end
+
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.warning = false
+end
+
+# By default run tests against all appraisals
+if !ENV["APPRAISAL_INITIALIZED"] && !ENV["TRAVIS"]
+  require 'appraisal'
+  task default: :appraisal
+else
+  task default: :test
+end

data/lib/active_record_replica.rb

@@ -0,0 +1,11 @@
+require 'active_record'
+require 'active_record/base'
+require 'active_record_replica/version'
+require 'active_record_replica/errors'
+require 'active_record_replica/replica'
+require 'active_record_replica/active_record_replica'
+require 'active_record_replica/extensions'
+
+if defined?(Rails)
+  require 'active_record_replica/railtie'
+end

data/lib/active_record_replica/active_record_replica.rb

@@ -0,0 +1,139 @@
+#
+# 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:
+  #     By default, only the default Database adapter (ActiveRecord::Base.connection.class)
+  #     is extended with replica read capabilities
+  #
+  #   environment:
+  #     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"
+    end
+  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
+  end
+
+  #
+  # The default behavior can also 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.
+  # 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
+  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
+  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
+  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
+  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?
+  end
+
+  # Force all subsequent reads on this thread and any fibers called by this thread to go the primary
+  def self.read_from_primary!
+    Thread.current.thread_variable_set(:active_record_replica, :primary)
+  end
+
+  # Subsequent reads on this thread and any fibers called by this thread can go to a replica
+  def self.read_from_replica!
+    Thread.current.thread_variable_set(:active_record_replica, nil)
+  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
+  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
+  end
+
+  # Returns whether replica reads are ignoring transactions
+  def self.ignore_transactions?
+    @ignore_transactions
+  end
+
+  # Set whether replica reads should ignore transactions
+  def self.ignore_transactions=(ignore_transactions)
+    @ignore_transactions = ignore_transactions
+  end
+
+  private
+
+  @ignore_transactions = false
+end

data/lib/active_record_replica/errors.rb

@@ -0,0 +1,5 @@
+module ActiveRecordReplica
+  # Attempting to start a transaction during a read-only database connection.
+  class TransactionAttempted < StandardError
+  end
+end

data/lib/active_record_replica/extensions.rb

@@ -0,0 +1,65 @@
+require 'active_support/concern'
+module ActiveRecordReplica
+  module Extensions
+    extend ActiveSupport::Concern
+
+    ActiveRecordReplica::SELECT_METHODS.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?
+  
+          ActiveRecordReplica.read_from_primary do
+            reader_connection.#{select_method}(sql, "Replica: \#{name || 'SQL'}", *args)
+          end
+        end
+      RUBY
+    end
+
+    def reader_connection
+      Replica.connection
+    end
+
+    def begin_db_transaction
+      return if ActiveRecordReplica.skip_transactions?
+      return super unless ActiveRecordReplica.block_transactions?
+
+      raise(TransactionAttempted, 'Attempting to begin a transaction during a read-only database connection.')
+    end
+
+    def commit_db_transaction
+      return if ActiveRecordReplica.skip_transactions?
+      return super unless ActiveRecordReplica.block_transactions?
+
+      raise(TransactionAttempted, 'Attempting to commit a transaction during a read-only database connection.')
+    end
+
+    def create_savepoint(name = current_savepoint_name(true))
+      return if ActiveRecordReplica.skip_transactions?
+      return super unless ActiveRecordReplica.block_transactions?
+
+      raise(TransactionAttempted, 'Attempting to create a savepoint during a read-only database connection.')
+    end
+
+    def rollback_to_savepoint(name = current_savepoint_name(true))
+      return if ActiveRecordReplica.skip_transactions?
+      return super unless ActiveRecordReplica.block_transactions?
+
+      raise(TransactionAttempted, 'Attempting to rollback a savepoint during a read-only database connection.')
+    end
+
+    def release_savepoint(name = current_savepoint_name(true))
+      return if ActiveRecordReplica.skip_transactions?
+      return super unless ActiveRecordReplica.block_transactions?
+
+      raise(TransactionAttempted, 'Attempting to release a savepoint during a read-only database connection.')
+    end
+
+    # Returns whether to read from the primary database
+    def active_record_replica_read_from_primary?
+      # Read from primary when forced by thread variable, or
+      # in a transaction and not ignoring transactions
+      ActiveRecordReplica.read_from_primary? ||
+        (open_transactions > 0) && !ActiveRecordReplica.ignore_transactions?
+    end
+  end
+end

data/lib/active_record_replica/railtie.rb

@@ -0,0 +1,24 @@
+module ActiveRecordReplica
+  class Railtie < Rails::Railtie
+    # Make the ActiveRecordReplica configuration available in the Rails application config
+    #
+    # Example: For this application ignore the current transactions since the application
+    #          has been coded to use ActiveRecordReplica.read_from_primary whenever
+    #          the current transaction must be visible to reads.
+    #            In file config/application.rb
+    #
+    #   Rails::Application.configure do
+    #     # Read from replica even when in an active transaction
+    #     # The application will use ActiveRecordReplica.read_from_primary to make
+    #     # changes in the current transaction visible to reads
+    #     config.active_record_replica.ignore_transactions = true
+    #   end
+    config.active_record_replica = ::ActiveRecordReplica
+
+    # Initialize ActiveRecordReplica
+    initializer "load active_record_replica", after: "active_record.initialize_database" do
+      ActiveRecordReplica.install!
+    end
+
+  end
+end

data/lib/active_record_replica/replica.rb

@@ -0,0 +1,12 @@
+module ActiveRecordReplica
+  # Class to hold replica connection pool
+  class Replica < ActiveRecord::Base
+    # Prevent Rails from trying to create an instance of this model
+    self.abstract_class = true
+
+    # Since this is an abstract class so it has no columns
+    def self.columns
+      []
+    end
+  end
+end

data/lib/active_record_replica/version.rb

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

data/test/active_record_replica_test.rb

@@ -0,0 +1,150 @@
+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)
+
+# 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')
+
+#
+# Unit Test for active_record_replica
+#
+# Since their 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.
+class ActiveRecordReplicaTest < Minitest::Test
+  describe 'the active_record_replica gem' do
+
+    before do
+      ActiveRecordReplica.ignore_transactions = false
+
+      User.delete_all
+
+      @name    = "Joe Bloggs"
+      @address = "Somewhere"
+      @user    = User.new(
+        :name    => @name,
+        :address => @address
+      )
+    end
+
+    after do
+      User.delete_all
+    end
+
+    it 'saves to primary' do
+      assert_equal true, @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
+      # Read from replica
+      assert_equal 0, User.where(:name => @name, :address => @address).count
+
+      # Write to primary
+      assert_equal true, @user.save!
+
+      # Read from replica
+      assert_equal 0, User.where(:name => @name, :address => @address).count
+    end
+
+    it 'save to primary, read from primary when in a transaction' do
+      assert_equal false, 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
+
+        # Write to primary
+        assert_equal true, @user.save!
+
+        # Read from Primary
+        assert_equal 1, User.where(:name => @name, :address => @address).count
+      end
+
+      # Read from Non-replicated replica
+      assert_equal 0, User.where(:name => @name, :address => @address).count
+    end
+
+    it 'save to primary, read from replica when ignoring transactions' do
+      ActiveRecordReplica.ignore_transactions = true
+      assert_equal true, 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
+
+        # Write to primary
+        assert_equal true, @user.save!
+
+        # Read from Non-replicated replica
+        assert_equal 0, User.where(:name => @name, :address => @address).count
+      end
+
+      # Read from Non-replicated replica
+      assert_equal 0, User.where(:name => @name, :address => @address).count
+    end
+
+    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
+
+      # Write to primary
+      assert_equal true, @user.save!
+
+      # Read from replica
+      assert_equal 0, User.where(:name => @name, :address => @address).count
+
+      # Read from Primary
+      ActiveRecordReplica.read_from_primary do
+        assert_equal 1, User.where(:name => @name, :address => @address).count
+      end
+    end
+
+  end
+end

data/test/database.yml

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

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+ENV['RAILS_ENV'] = 'test'
+
+require 'active_record'
+require 'minitest/autorun'
+require 'active_record_replica'
+require 'awesome_print'

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: active_record_replica
+version: !ruby/object:Gem::Version
+  version: 2.0.1
+platform: ruby
+authors:
+- Reid Morrison
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+description: 
+email:
+- reidmo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/active_record_replica.rb
+- lib/active_record_replica/active_record_replica.rb
+- lib/active_record_replica/errors.rb
+- lib/active_record_replica/extensions.rb
+- lib/active_record_replica/railtie.rb
+- lib/active_record_replica/replica.rb
+- 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
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.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