active_record_slave 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6235db3e4c19fc1b58a00eaacde74d778e7cb8a8ef3672fe2ca63ca20f10702c
-  data.tar.gz: cad224213432afad1c87358923595f992ce61d63c1d467ce7dbc84b6af5d37cc
+  metadata.gz: 28bf8e5c0b1aa126621369c792755c5bf4c3da94d7aecbd1f60af335908b8078
+  data.tar.gz: 959fa6afaecb8c24934085e2e5b1a018891286b3e0234d293a6cb0a27ca75f9d
 SHA512:
-  metadata.gz: 7e26f4116785cc6ef8777d4850d44b2034e52448c20b13c6f1a920e47d41a6a9ceded5a47d8aaed5bb12fc9ee327013f0fa40214b720bc51e0fe88c666b153a2
-  data.tar.gz: cef0b388839d44b90e4c34c1c0a9fa9978e2155621042742ab58c6fb7b5ccd40b811d746e6b3509934accd0d5654006e1e96bf0637417d106baa70947b3825cf
+  metadata.gz: d327d0e133592d461d954340bb28111956259ce1333765cdaf756a8e146d73728da556faf38ad994510e86e29f85bbe333c6d468ae0343cb9c92050508fb4cc5
+  data.tar.gz: 1345aaa4edbf866b22372c47bbd1cad0cae08ec42f169b6c4a43fe38eac079500e3803031629ec1d0afcc55984b3df08e8f195f875f3cf4ccb699770249fbee3

data/README.md

@@ -26,7 +26,7 @@ Production Ready. Actively used in large production environments.
     * Detects when a query is inside of a transaction and sends those reads to the master by default.
     * Can be configured to send reads in a transaction to slave databases.
 * Lightweight footprint.
-* No overhead whatsoever when a slave is not configured.
+* No overhead whatsoever when a slave is _not_ configured.
 * Negligible overhead when redirecting reads to the slave.
 * Connection Pools to both databases are retained and maintained independently by ActiveRecord.
 * The master and slave databases do not have to be of the same type.
@@ -132,13 +132,81 @@ end
 
 ## Note
 
-ActiveRecord::Base.execute is sometimes used to perform custom SQL calls against
-the database to bypass ActiveRecord. It is necessary to replace these calls
-with the standard ActiveRecord::Base.select call for them to be picked up by
-active_record_slave and redirected to the slave.
+Active Record Slave is a very simple layer that inserts itself into the call chain whenever a slave 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`.
 
-This is because ActiveRecord::Base.execute can also be used for database updates
-which we do not want redirected to the slave
+Using this observation Active Record Slave 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 slave active record model `ActiveRecordSlave::Slave`. 
+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 slave 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 slave 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 master even though
+the transaction may never be used.
+
+Even though the transaction is unused it sends the following messages to the master database:
+~~~
+SET autocommit=0
+commit
+SET autocommit=1
+~~~ 
+
+This will impact the master 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 master, even when reads are going to slaves:
+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
+ActiveRecordSlave.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 
+`ActiveRecordSlave.block_transactions` to make it raise an exception anytime a transaction is attempted:
+
+~~~ruby
+ActiveRecordSlave.block_transactions do
+  parent = Parent.new
+  parent.child = Child.new
+end
+~~~
 
 ## Install
 
@@ -255,14 +323,8 @@ production:
 
 ## Dependencies
 
-* Tested on Rails 3 and Rails 4
-
 See [.travis.yml](https://github.com/reidmorrison/active_record_slave/blob/master/.travis.yml) for the list of tested Ruby platforms
 
-## Possible Future Enhancements
-
-* Support for multiple named slaves (ask for it by submitting an issue)
-
 ## Versioning
 
 This project uses [Semantic Versioning](http://semver.org/).

data/lib/active_record_slave.rb

@@ -1,6 +1,7 @@
 require 'active_record'
 require 'active_record/base'
 require 'active_record_slave/version'
+require 'active_record_slave/errors'
 require 'active_record_slave/slave'
 require 'active_record_slave/instance_methods'
 require 'active_record_slave/active_record_slave'

data/lib/active_record_slave/active_record_slave.rb

@@ -2,7 +2,6 @@
 # ActiveRecord read from a slave
 #
 module ActiveRecordSlave
-
   # Install ActiveRecord::Slave into ActiveRecord to redirect reads to the slave
   # Parameters:
   #   adapter_class:
@@ -36,12 +35,11 @@ module ActiveRecordSlave
   def self.read_from_master
     return yield if read_from_master?
     begin
-      # Set :master indicator in thread local storage so that it is visible
-      # during the select call
+      previous = Thread.current.thread_variable_get(:active_record_slave)
       read_from_master!
       yield
     ensure
-      read_from_slave!
+      Thread.current.thread_variable_set(:active_record_slave, previous)
     end
   end
 
@@ -54,33 +52,68 @@ module ActiveRecordSlave
   def self.read_from_slave
     return yield if read_from_slave?
     begin
-      # Set nil indicator in thread local storage so that it is visible
-      # during the select call
+      previous = Thread.current.thread_variable_get(:active_record_slave)
       read_from_slave!
       yield
     ensure
-      read_from_master!
+      Thread.current.thread_variable_set(:active_record_slave, previous)
+    end
+  end
+
+  # When only reading from a slave it is important to prevent entering any into
+  # a transaction since the transaction still sends traffic to the master
+  # that will cause the master database to slow down processing empty transactions.
+  def self.block_transactions
+    begin
+      previous = Thread.current.thread_variable_get(:active_record_slave_transaction)
+      Thread.current.thread_variable_set(:active_record_slave_transaction, :block)
+      yield
+    ensure
+      Thread.current.thread_variable_set(:active_record_slave_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_slave_transaction)
+      Thread.current.thread_variable_set(:active_record_slave_transaction, :skip)
+      yield
+    ensure
+      Thread.current.thread_variable_set(:active_record_slave_transaction, previous)
     end
   end
 
   # Whether this thread is currently forcing all reads to go against the master database
   def self.read_from_master?
-    thread_variable_get(:active_record_slave) == :master
+    Thread.current.thread_variable_get(:active_record_slave) == :master
   end
 
   # Whether this thread is currently forcing all reads to go against the slave database
   def self.read_from_slave?
-    thread_variable_get(:active_record_slave) == nil
+    Thread.current.thread_variable_get(:active_record_slave).nil?
   end
 
   # Force all subsequent reads on this thread and any fibers called by this thread to go the master
   def self.read_from_master!
-    thread_variable_set(:active_record_slave, :master)
+    Thread.current.thread_variable_set(:active_record_slave, :master)
   end
 
   # Subsequent reads on this thread and any fibers called by this thread can go to a slave
   def self.read_from_slave!
-    thread_variable_set(:active_record_slave, nil)
+    Thread.current.thread_variable_set(:active_record_slave, 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_slave_transaction) == :block
+  end
+
+  # Whether any attempt to start a transaction should be skipped.
+  def self.skip_transactions?
+    Thread.current.thread_variable_get(:active_record_slave_transaction) == :skip
   end
 
   # Returns whether slave reads are ignoring transactions
@@ -93,43 +126,7 @@ module ActiveRecordSlave
     @ignore_transactions = ignore_transactions
   end
 
-  ##############################################################################
   private
 
   @ignore_transactions = false
-
-  # Returns the value of the local thread variable
-  #
-  # Parameters
-  #   variable [Symbol]
-  #     Name of variable to get
-  if (RUBY_VERSION.to_i >= 2) && !defined?(Rubinius::VERSION)
-    # Fibers have their own thread local variables so use thread_variable_get
-    def self.thread_variable_get(variable)
-      Thread.current.thread_variable_get(variable)
-    end
-  else
-    def self.thread_variable_get(variable)
-      Thread.current[variable]
-    end
-  end
-
-  # Sets the value of the local thread variable
-  #
-  # Parameters
-  #   variable [Symbol]
-  #     Name of variable to set
-  #   value [Object]
-  #     Value to set the thread variable to
-  if (RUBY_VERSION.to_i >= 2) && !defined?(Rubinius::VERSION)
-    # Fibers have their own thread local variables so use thread_variable_set
-    def self.thread_variable_set(variable, value)
-      Thread.current.thread_variable_set(variable, value)
-    end
-  else
-    def self.thread_variable_set(variable, value)
-      Thread.current[variable] = value
-    end
-  end
-
 end

data/lib/active_record_slave/errors.rb

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

data/lib/active_record_slave/instance_methods.rb

@@ -21,6 +21,41 @@ module ActiveRecordSlave
       METHOD
     end
 
+    def begin_db_transaction
+      return if ActiveRecordSlave.skip_transactions?
+      return super unless ActiveRecordSlave.block_transactions?
+
+      raise(TransactionAttempted, 'Attempting to begin a transaction during a read-only database connection.')
+    end
+
+    def commit_db_transaction
+      return if ActiveRecordSlave.skip_transactions?
+      return super unless ActiveRecordSlave.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 ActiveRecordSlave.skip_transactions?
+      return super unless ActiveRecordSlave.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 ActiveRecordSlave.skip_transactions?
+      return super unless ActiveRecordSlave.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 ActiveRecordSlave.skip_transactions?
+      return super unless ActiveRecordSlave.block_transactions?
+
+      raise(TransactionAttempted, 'Attempting to release a savepoint during a read-only database connection.')
+    end
+
     # Returns whether to read from the master database
     def active_record_slave_read_from_master?
       # Read from master when forced by thread variable, or

data/lib/active_record_slave/railtie.rb

@@ -1,6 +1,5 @@
-module ActiveRecordSlave #:nodoc:
-  class Railtie < Rails::Railtie #:nodoc:
-
+module ActiveRecordSlave
+  class Railtie < Rails::Railtie
     # Make the ActiveRecordSlave configuration available in the Rails application config
     #
     # Example: For this application ignore the current transactions since the application

data/lib/active_record_slave/version.rb

@@ -1,3 +1,3 @@
-module ActiveRecordSlave #:nodoc
-  VERSION = '1.4.0'
+module ActiveRecordSlave
+  VERSION = '1.5.0'
 end

data/test/active_record_slave_test.rb

@@ -41,6 +41,10 @@ ActiveRecordSlave.install!(nil, 'test')
 #
 # Unit Test for active_record_slave
 #
+# 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 ActiveRecordSlaveTest < Minitest::Test
   describe 'the active_record_slave gem' do
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record_slave
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Reid Morrison
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-29 00:00:00.000000000 Z
+date: 2019-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -36,18 +36,17 @@ files:
 - Rakefile
 - lib/active_record_slave.rb
 - lib/active_record_slave/active_record_slave.rb
+- lib/active_record_slave/errors.rb
 - lib/active_record_slave/instance_methods.rb
 - lib/active_record_slave/railtie.rb
 - lib/active_record_slave/slave.rb
 - lib/active_record_slave/version.rb
 - test/active_record_slave_test.rb
 - test/database.yml
-- test/test.sqlite3
 - test/test_helper.rb
-- test/test_slave.sqlite3
 homepage: https://github.com/rocketjob/active_record_slave
 licenses:
-- Apache License V2.0
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -57,22 +56,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: Redirect ActiveRecord (Rails) reads to slave databases while ensuring all
   writes go to the master database.
 test_files:
-- test/test_slave.sqlite3
 - test/active_record_slave_test.rb
-- test/test.sqlite3
 - test/database.yml
 - test/test_helper.rb