distribute_reads 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 731daba05fd408780f3548cac44ddeda0d4c0c7c
-  data.tar.gz: 403b13ce349e56794b0bdc3457222724f1da4f8b
+  metadata.gz: 0d5f81a8379060ca196ed7550fa1dcafc706afc7
+  data.tar.gz: 78f4f6af58f6c6b184d1e56532e9c7d910846719
 SHA512:
-  metadata.gz: 76250c6a063c2797328938254bdc0b9c18508929c11a969f9f03d05ada6fe419038d1d25b0772ba536a486f3daf2cfa58673c5ec637324d49ebcddfb04e625d5
-  data.tar.gz: 4e7289ee561734260874b0a4098f1f991d2ee4965132b59a2257530a3ad54d13510bf6ad3de9fb2c0498b1b9a058cd5f25b29995bc577891178dff05d32504c6
+  metadata.gz: 78b965141d1bd574726480b2c795131539fb1fcfa2f8456307f4f10ffc34b893826d2c822d170602588a19ab1b09f3d360ab016555f2b5d8e2e9fb92c4c09f40
+  data.tar.gz: ef38d4ed23658799456f197bff9d0a25ab044e81994aaa453a37495990d108e761e02de0ac97dd017115ba3b9ace8cefbacd157755de3ff80fc43e00ca77ce6c

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+## 0.2.0
+
+Breaking
+
+- Jobs default to replica when `default_to_primary` is false
+
+Other
+
+- Replaced `default_to_primary` with `by_default`
+- Fixed `max_lag` option
+- Added `lag_failover` option
+- Added `failover` option
+- Added `lag_on` option
+- Added `primary` option
+- Added default options
+- Improved lag query
+
 ## 0.1.2
 
 - Raise `ArgumentError` when missing block

data/README.md

@@ -70,8 +70,12 @@ class TestJob < ApplicationJob
 end
 ```
 
+You can pass any options as well.
+
 ## Options
 
+### Replica Lag
+
 Raise an error when replica lag is too high - *PostgreSQL only*
 
 ```ruby
@@ -80,12 +84,71 @@ distribute_reads(max_lag: 3) do
 end
 ```
 
-Don’t default to primary (default Makara behavior)
+Instead of raising an error, you can also use primary
+
+```ruby
+distribute_reads(max_lag: 3, lag_failover: true) do
+  # ...
+end
+```
+
+If you have multiple databases, this only checks lag on `ActiveRecord::Base` connection. Specify connections to check with
+
+```ruby
+distribute_reads(max_lag: 3, lag_on: [ApplicationRecord, LogRecord]) do
+  # ...
+end
+```
+
+**Note:** If lag on any connection exceeds the max lag and lag failover is used, *all connections* will use their primary.
+
+### Availability
+
+If no replicas are available, primary is used. To prevent this situation from overloading the primary, you can raise an error instead.
+
+```ruby
+distribute_reads(failover: false) do
+  # raises DistributeReads::NoReplicasAvailable
+end
+```
+
+### Default Options
+
+Change the defaults
+
+```ruby
+DistributeReads.default_options = {
+  lag_failover: true,
+  failover: false
+}
+```
+
+## Distribute Reads by Default
+
+At some point, you may wish to distribute reads by default.
+
+```ruby
+DistributeReads.by_default = true
+```
+
+Once you do this, Makara will use the Rails cache to track its state. To reduce load on the Rails cache, use a write-through cache in front of it.
 
 ```ruby
-DistributeReads.default_to_primary = false
+Makara::Cache.store = DistributeReads::CacheStore.new
 ```
 
+To make queries go to primary, use:
+
+```ruby
+distribute_reads(primary: true) do
+  # ...
+end
+```
+
+## Thanks
+
+Thanks to [TaskRabbit](https://github.com/taskrabbit) for Makara and [Nick Elser](https://github.com/nickelser) for the write-through cache.
+
 ## History
 
 View the [changelog](https://github.com/ankane/distribute_reads/blob/master/CHANGELOG.md)

data/lib/distribute_reads.rb

@@ -1,29 +1,54 @@
 require "makara"
 require "distribute_reads/appropriate_pool"
+require "distribute_reads/cache_store"
 require "distribute_reads/global_methods"
 require "distribute_reads/version"
 
 module DistributeReads
-  class TooMuchLag < StandardError; end
+  class Error < StandardError; end
+  class TooMuchLag < Error; end
+  class NoReplicasAvailable < Error; end
 
   class << self
-    attr_accessor :default_to_primary
+    attr_accessor :by_default
+    attr_accessor :default_options
   end
-  self.default_to_primary = true
+  self.by_default = false
+  self.default_options = {
+    failover: true,
+    lag_failover: false
+  }
 
-  def self.lag
-    conn = ActiveRecord::Base.connection
-    if %w(PostgreSQL PostGIS).include?(conn.adapter_name)
-      conn.execute(
+  def self.lag(connection: nil)
+    raise DistributeReads::Error, "Don't use outside distribute_reads" unless Thread.current[:distribute_reads]
+
+    connection ||= ActiveRecord::Base.connection
+    if %w(PostgreSQL PostGIS).include?(connection.adapter_name)
+      replica_pool = connection.instance_variable_get(:@slave_pool)
+      if replica_pool && replica_pool.connections.size > 1
+        warn "[distribute_reads] Multiple replicas available, lag only reported for one"
+      end
+
+      connection.execute(
         "SELECT CASE
-          WHEN pg_last_xlog_receive_location() = pg_last_xlog_replay_location() THEN 0
+          WHEN NOT pg_is_in_recovery() OR pg_last_xlog_receive_location() = pg_last_xlog_replay_location() THEN 0
           ELSE EXTRACT (EPOCH FROM NOW() - pg_last_xact_replay_timestamp())
         END AS lag"
       ).first["lag"].to_f
     else
-      raise "Option not supported with this adapter"
+      raise DistributeReads::Error, "Option not supported with this adapter"
     end
   end
+
+  # legacy
+  def self.default_to_primary
+    !by_default
+  end
+
+  # legacy
+  def self.default_to_primary=(value)
+    self.by_default = !value
+  end
 end
 
 Makara::Proxy.send :prepend, DistributeReads::AppropriatePool
@@ -31,5 +56,5 @@ Object.send :include, DistributeReads::GlobalMethods
 
 ActiveSupport.on_load(:active_job) do
   require "distribute_reads/job_methods"
-  extend DistributeReads::JobMethods
+  include DistributeReads::JobMethods
 end

data/lib/distribute_reads/appropriate_pool.rb

@@ -2,15 +2,16 @@ module DistributeReads
   module AppropriatePool
     def _appropriate_pool(*args)
       if Thread.current[:distribute_reads]
-        if needs_master?(*args) || @slave_pool.completely_blacklisted?
-          stick_to_master(*args) unless DistributeReads.default_to_primary
+        if Thread.current[:distribute_reads][:primary] || needs_master?(*args) || (blacklisted = @slave_pool.completely_blacklisted?)
+          raise DistributeReads::NoReplicasAvailable, "No replicas available" if blacklisted && Thread.current[:distribute_reads][:failover] == false
+          stick_to_master(*args) if DistributeReads.by_default
           @master_pool
         elsif in_transaction?
           @master_pool
         else
           @slave_pool
         end
-      elsif DistributeReads.default_to_primary
+      elsif !DistributeReads.by_default
         @master_pool
       else
         super

data/lib/distribute_reads/cache_store.rb

@@ -0,0 +1,29 @@
+module DistributeReads
+  class CacheStore
+    def read(key)
+      memory_cached = memory_store.read(key)
+      return nil if memory_cached == :nil
+      return memory_cached if memory_cached
+
+      store_cached = store.try(:read, key)
+      memory_store.write(key, store_cached || :nil)
+      store_cached
+    end
+
+    def write(*args)
+      memory_store.write(*args)
+      store.try(:write, *args)
+    end
+
+    private
+
+    # use ActiveSupport::Cache::MemoryStore instead?
+    def memory_store
+      @memory_store ||= Makara::Cache::MemoryStore.new
+    end
+
+    def store
+      @store ||= Rails.cache
+    end
+  end
+end

data/lib/distribute_reads/global_methods.rb

@@ -1,15 +1,32 @@
 module DistributeReads
   module GlobalMethods
-    def distribute_reads(max_lag: nil)
+    def distribute_reads(**options)
       raise ArgumentError, "Missing block" unless block_given?
 
-      if max_lag && DistributeReads.lag > max_lag
-        raise DistributeReads::TooMuchLag, "Replica lag over #{max_lag} seconds"
-      end
+      unknown_keywords = options.keys - [:failover, :lag_failover, :lag_on, :max_lag, :primary]
+      raise ArgumentError, "Unknown keywords: #{unknown_keywords.join(", ")}" if unknown_keywords.any?
+
+      options = DistributeReads.default_options.merge(options)
 
       previous_value = Thread.current[:distribute_reads]
       begin
-        Thread.current[:distribute_reads] = true
+        Thread.current[:distribute_reads] = {failover: options[:failover], primary: options[:primary]}
+
+        # TODO ensure same connection is used to test lag and execute queries
+        max_lag = options[:max_lag]
+        if max_lag && !options[:primary]
+          Array(options[:lag_on] || [ActiveRecord::Base]).each do |base_model|
+            if DistributeReads.lag(connection: base_model.connection) > max_lag
+              if options[:lag_failover]
+                # TODO possibly per connection
+                Thread.current[:distribute_reads][:primary] = true
+              else
+                raise DistributeReads::TooMuchLag, "Replica lag over #{max_lag} seconds#{options[:lag_on] ? " on #{base_model.name} connection" : ""}"
+              end
+            end
+          end
+        end
+
         value = yield
         warn "[distribute_reads] Call `to_a` inside block to execute query on replica" if value.is_a?(ActiveRecord::Relation) && !previous_value
         value

data/lib/distribute_reads/job_methods.rb

@@ -1,8 +1,20 @@
+require "active_support/concern"
+
 module DistributeReads
   module JobMethods
-    def distribute_reads(max_lag: nil)
-      around_perform do |job, block|
-        distribute_reads(max_lag: max_lag) { block.call }
+    extend ActiveSupport::Concern
+
+    included do
+      before_perform do
+        Makara::Context.set_current(Makara::Context.generate) if DistributeReads.by_default
+      end
+    end
+
+    class_methods do
+      def distribute_reads(*args)
+        around_perform do |job, block|
+          distribute_reads(*args) { block.call }
+        end
       end
     end
   end

data/lib/distribute_reads/version.rb

@@ -1,3 +1,3 @@
 module DistributeReads
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: distribute_reads
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-09-21 00:00:00.000000000 Z
+date: 2017-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: makara
@@ -110,6 +110,7 @@ files:
 - distribute_reads.gemspec
 - lib/distribute_reads.rb
 - lib/distribute_reads/appropriate_pool.rb
+- lib/distribute_reads/cache_store.rb
 - lib/distribute_reads/global_methods.rb
 - lib/distribute_reads/job_methods.rb
 - lib/distribute_reads/version.rb