redis-memo 0.1.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1f9810ab293851487a23911835eb644ce4401df360404a04236898b99e1ab64
-  data.tar.gz: edbd814f8e8c027207123340445f121e771e30260e7126fb91665a23139fd710
+  metadata.gz: 4e4b5e95c92879677df377b10736e7467efa86237d90ad41254bdd7a732a8260
+  data.tar.gz: 9dfb62913a6cfd96e114d6526f5876696e86d1fafb6256d2454d2723449e61c1
 SHA512:
-  metadata.gz: 2a07892d98f25a3690ee254015be04f0164053be755fcce73478598ba65e28a39a4e99b47d18b12f1ec6e89facfba06e9d1b8390dab61ac3713e291f4451b782
-  data.tar.gz: 47f5e0d42b7957d6422277f01446b6659f8526371e556957626a68c44635d1ba456380152d48f3682959cbd84f4d2adf333a50697be386f554b000b4edf67d1f
+  metadata.gz: 62eaf4aedb48325cc90c10cd27a3877de85a436960c78d7e1205c5dbbbe77bdb6c50ac82ea1af11d7dbd7219e7fa96cdc270b37038f1674c1fa491dffb8acec3
+  data.tar.gz: 2315c83ce0848d5b2f36d60e37fe60bcece24d80505ff2d7c38b1a9c0d33b8785888325410bae695abc0746a8b4663e037daec07ea83f32b6aaeafd4bf955693

data/lib/redis_memo.rb

@@ -3,11 +3,20 @@
 require 'active_support/all'
 require 'digest'
 require 'json'
+require 'ruby2_keywords'
 require 'securerandom'
 
 module RedisMemo
+  require 'redis_memo/thread_local_var'
+
+  ThreadLocalVar.define :without_memoization
+  ThreadLocalVar.define :connection_attempts_count
+  ThreadLocalVar.define :max_connection_attempts
+
+  require 'redis_memo/errors'
   require 'redis_memo/memoize_method'
-  require 'redis_memo/memoize_query'
+  require 'redis_memo/memoize_query' if defined?(ActiveRecord)
+  require 'redis_memo/railtie' if defined?(Rails) && defined?(Rails::Railtie)
 
   # A process-level +RedisMemo::Options+ instance that stores the global
   # options. This object can be modified by +RedisMemo.configure+.
@@ -17,9 +26,6 @@ module RedisMemo
   # +DefaultOptions+ as the default value.
   DefaultOptions = RedisMemo::Options.new
 
-  # @todo Move thread keys to +RedisMemo::ThreadKey+
-  THREAD_KEY_WITHOUT_MEMO = :__redis_memo_without_memo__
-
   # Configure global-level default options. Those options will be used unless
   # some options specified at +memoize_method+ callsite level. See
   # +RedisMemo::Options+ for all the possible options.
@@ -35,10 +41,10 @@ module RedisMemo
   # to Redis.
   # - Batches cannot be nested
   # - When a batch is still open (while still in the +RedisMemo.batch+ block)
-  # the return value of any memoized method is a +RedisMemo::Future+ instead of
-  # the actual method value
+  #   the return value of any memoized method is a +RedisMemo::Future+ instead of
+  #   the actual method value
   # - The actual method values are returned as a list, in the same order as
-  # invoking, after exiting the block
+  #   invoking, after exiting the block
   #
   # @example
   #   results = RedisMemo.batch do
@@ -56,46 +62,52 @@ module RedisMemo
     RedisMemo::Batch.close
   end
 
-  # @todo Move this method out of the top namespace
-  def self.checksum(serialized)
-    Digest::SHA1.base64digest(serialized)
-  end
-
-  # @todo Move this method out of the top namespace
-  def self.uuid
-    SecureRandom.uuid
-  end
-
-  # @todo Move this method out of the top namespace
-  def self.deep_sort_hash(orig_hash)
-    {}.tap do |new_hash|
-      orig_hash.sort.each do |k, v|
-        new_hash[k] = v.is_a?(Hash) ? deep_sort_hash(v) : v
-      end
-    end
-  end
-
   # Whether the current execution context has been configured to skip
   # memoization and use the uncached code path.
   #
   # @return [Boolean]
-  def self.without_memo?
-    Thread.current[THREAD_KEY_WITHOUT_MEMO] == true
+  def self.without_memoization?
+    RedisMemo::DefaultOptions.disable_all || ThreadLocalVar.without_memoization == true
   end
 
   # Configure the wrapped code in the block to skip memoization.
   #
   # @yield [] no_args The block of code to skip memoization.
-  def self.without_memo
-    prev_value = Thread.current[THREAD_KEY_WITHOUT_MEMO]
-    Thread.current[THREAD_KEY_WITHOUT_MEMO] = true
+  def self.without_memoization
+    prev_value = ThreadLocalVar.without_memoization
+    ThreadLocalVar.without_memoization = true
     yield
   ensure
-    Thread.current[THREAD_KEY_WITHOUT_MEMO] = prev_value
+    ThreadLocalVar.without_memoization = prev_value
   end
 
-  # @todo Move errors to a separate file errors.rb
-  class ArgumentError < ::ArgumentError; end
-  class RuntimeError < ::RuntimeError; end
-  class WithoutMemoization < Exception; end
+  # Set the max connection attempts to Redis per code block. If we fail to
+  # connect to Redis more than `max_attempts` times, the rest of the code block
+  # will fall back to the uncached flow, `RedisMemo.without_memoization`.
+  #
+  # @param [Integer] The max number of connection attempts.
+  # @yield [] no_args the block of code to set the max attempts for.
+  def self.with_max_connection_attempts(max_attempts)
+    prev_value = ThreadLocalVar.without_memoization
+    ThreadLocalVar.connection_attempts_count = 0
+    ThreadLocalVar.max_connection_attempts = max_attempts
+
+    yield
+  ensure
+    ThreadLocalVar.without_memoization = prev_value
+    ThreadLocalVar.connection_attempts_count = nil
+    ThreadLocalVar.max_connection_attempts = nil
+  end
+
+  private_class_method def self.incr_connection_attempts # :nodoc:
+    return unless ThreadLocalVar.max_connection_attempts && ThreadLocalVar.connection_attempts_count
+
+    # The connection attempts count and max connection attempts are reset in
+    # RedisMemo.with_max_connection_attempts
+    ThreadLocalVar.connection_attempts_count += 1
+    return if ThreadLocalVar.connection_attempts_count <
+              ThreadLocalVar.max_connection_attempts
+
+    ThreadLocalVar.without_memoization = true
+  end
 end

data/lib/redis_memo/after_commit.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 # TODO: -> RedisMemo::Memoizable::AfterCommit
 
 class RedisMemo::AfterCommit
@@ -34,8 +35,6 @@ class RedisMemo::AfterCommit
     connection.transaction_open? && connection.current_transaction.joinable?
   end
 
-  private
-
   def self.after_commit(&blk)
     connection.add_transaction_record(
       RedisMemo::AfterCommit::Callback.new(connection, committed: blk),
@@ -50,6 +49,7 @@ class RedisMemo::AfterCommit
 
   def self.reset_after_transaction
     return if @@callback_added
+
     @@callback_added = true
 
     after_commit do

data/lib/redis_memo/batch.rb

@@ -1,30 +1,54 @@
- # frozen_string_literal: true
+# frozen_string_literal: true
+
 require_relative 'cache'
 require_relative 'tracer'
 
+##
+# This class facilitates the batching of Redis calls triggered by +memoize_method+
+# to minimize the number of round trips to Redis.
+#
+# - Batches cannot be nested
+# - When a batch is still open (while still in the +RedisMemo.batch+ block)
+#   the return value of any memoized method is a +RedisMemo::Future+ instead of
+#   the actual method value
+# - The actual method values are returned as a list, in the same order as
+#   invoking, after exiting the block
+#
+# @example
+#   results = RedisMemo.batch do
+#     5.times { |i| memoized_calculation(i) }
+#     nil # Not the return value of the block
+#   end
+#   results # [1,2,3,4,5] (results from the memoized_calculation calls)
 class RedisMemo::Batch
-  THREAD_KEY = :__redis_memo_current_batch__
+  RedisMemo::ThreadLocalVar.define :batch
 
+  # Opens a new batch. If a batch is already open, raises an error
+  # to prevent nested batches.
   def self.open
     if current
-      raise RedisMemo::RuntimeError, 'Batch can not be nested'
+      raise RedisMemo::RuntimeError.new('Batch can not be nested')
     end
 
-    Thread.current[THREAD_KEY] = []
+    RedisMemo::ThreadLocalVar.batch = []
   end
 
+  # Closes the current batch, returning the futures in that batch.
   def self.close
-    if current
-      futures = current
-      Thread.current[THREAD_KEY] = nil
-      futures
-    end
+    return unless current
+
+    futures = current
+    RedisMemo::ThreadLocalVar.batch = nil
+    futures
   end
 
+  # Retrieves the current open batch.
   def self.current
-    Thread.current[THREAD_KEY]
+    RedisMemo::ThreadLocalVar.batch
   end
 
+  # Executes all the futures in the current batch using batched calls to
+  # Redis and closes it.
   def self.execute
     futures = close
     return unless futures
@@ -33,7 +57,8 @@ class RedisMemo::Batch
     method_cache_keys = nil
 
     RedisMemo::Tracer.trace('redis_memo.cache.batch.read', nil) do
-      method_cache_keys = RedisMemo::MemoizeMethod.method_cache_keys(
+      method_cache_keys = RedisMemo::MemoizeMethod.__send__(
+        :method_cache_keys,
         futures.map(&:context),
       )
 

data/lib/redis_memo/cache.rb

@@ -1,14 +1,17 @@
- # frozen_string_literal: true
+# frozen_string_literal: true
+
 require_relative 'options'
 require_relative 'redis'
 require_relative 'connection_pool'
 
 class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
-  class Rescuable < Exception; end
+  # This needs to be an Exception since RedisCacheStore rescues all
+  # RuntimeErrors
+  class Rescuable < Exception; end # rubocop:disable Lint/InheritException
 
-  THREAD_KEY_LOCAL_CACHE            = :__redis_memo_cache_local_cache__
-  THREAD_KEY_LOCAL_DEPENDENCY_CACHE = :__redis_memo_local_cache_dependency_cache__
-  THREAD_KEY_RAISE_ERROR            = :__redis_memo_cache_raise_error__
+  RedisMemo::ThreadLocalVar.define :local_cache
+  RedisMemo::ThreadLocalVar.define :local_dependency_cache
+  RedisMemo::ThreadLocalVar.define :raise_error
 
   @@redis = nil
   @@redis_store = nil
@@ -17,11 +20,15 @@ class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
     RedisMemo::DefaultOptions.redis_error_handler&.call(exception, method)
     RedisMemo::DefaultOptions.logger&.warn(exception.full_message)
 
-    if Thread.current[THREAD_KEY_RAISE_ERROR]
+    if exception.is_a?(Redis::BaseConnectionError)
+      RedisMemo.__send__(:incr_connection_attempts)
+    end
+
+    if RedisMemo::ThreadLocalVar.raise_error
       raise RedisMemo::Cache::Rescuable
-    else
-      returning
     end
+
+    returning
   end
 
   def self.redis
@@ -48,28 +55,38 @@ class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
   # ActiveSupport::Cache::Entry object -- which is slower comparing to a simple
   # hash storing object references
   def self.local_cache
-    Thread.current[THREAD_KEY_LOCAL_CACHE]
+    RedisMemo::ThreadLocalVar.local_cache
   end
 
   def self.local_dependency_cache
-    Thread.current[THREAD_KEY_LOCAL_DEPENDENCY_CACHE]
+    RedisMemo::ThreadLocalVar.local_dependency_cache
+  end
+
+  # See https://github.com/rails/rails/blob/fe76a95b0d252a2d7c25e69498b720c96b243ea2/activesupport/lib/active_support/cache/redis_cache_store.rb#L477
+  # We overwrite this private method so we can also rescue ConnectionPool::TimeoutErrors
+  def failsafe(method, returning: nil)
+    yield
+  rescue ::Redis::BaseError, ::ConnectionPool::TimeoutError => error
+    handle_exception exception: error, method: method, returning: returning
+    returning
   end
+  private :failsafe
 
   class << self
-    def with_local_cache(&blk)
-      Thread.current[THREAD_KEY_LOCAL_CACHE] = {}
-      Thread.current[THREAD_KEY_LOCAL_DEPENDENCY_CACHE] = {}
-      blk.call
+    def with_local_cache
+      RedisMemo::ThreadLocalVar.local_cache = {}
+      RedisMemo::ThreadLocalVar.local_dependency_cache = {}
+      yield
     ensure
-      Thread.current[THREAD_KEY_LOCAL_CACHE] = nil
-      Thread.current[THREAD_KEY_LOCAL_DEPENDENCY_CACHE] = nil
+      RedisMemo::ThreadLocalVar.local_cache = nil
+      RedisMemo::ThreadLocalVar.local_dependency_cache = nil
     end
 
     # RedisCacheStore doesn't read from the local cache before reading from redis
     def read_multi(*keys, raw: false, raise_error: false)
       return {} if keys.empty?
 
-      Thread.current[THREAD_KEY_RAISE_ERROR] = raise_error
+      RedisMemo::ThreadLocalVar.raise_error = raise_error
 
       local_entries = local_cache&.slice(*keys) || {}
 
@@ -88,7 +105,7 @@ class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
     end
 
     def write(key, value, disable_async: false, raise_error: false, **options)
-      Thread.current[THREAD_KEY_RAISE_ERROR] = raise_error
+      RedisMemo::ThreadLocalVar.raise_error = raise_error
 
       if local_cache
         local_cache[key] = value
@@ -99,7 +116,7 @@ class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
         redis_store.write(key, value, **options)
       else
         async.call do
-          Thread.current[THREAD_KEY_RAISE_ERROR] = raise_error
+          RedisMemo::ThreadLocalVar.raise_error = raise_error
           redis_store.write(key, value, **options)
         end
       end

data/lib/redis_memo/connection_pool.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'connection_pool'
 require_relative 'redis'
 
@@ -11,17 +12,17 @@ class RedisMemo::ConnectionPool
   end
 
   # Avoid method_missing when possible for better performance
-  %i(get mget mapped_mget set eval).each do |method_name|
+  %i[get mget mapped_mget set eval evalsha run_script].each do |method_name|
     define_method method_name do |*args, &blk|
       @connection_pool.with do |redis|
-        redis.send(method_name, *args, &blk)
+        redis.__send__(method_name, *args, &blk)
       end
     end
   end
 
   def method_missing(method_name, *args, &blk)
     @connection_pool.with do |redis|
-      redis.send(method_name, *args, &blk)
+      redis.__send__(method_name, *args, &blk)
     end
   end
 end

data/lib/redis_memo/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RedisMemo
+  class ArgumentError < ::ArgumentError; end
+
+  class RuntimeError < ::RuntimeError; end
+
+  class WithoutMemoization < RuntimeError; end
+end

data/lib/redis_memo/future.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'cache'
 require_relative 'tracer'
 
@@ -11,14 +12,14 @@ class RedisMemo::Future
     method_args,
     dependent_memos,
     cache_options,
-    method_name_without_memo
+    method_name_without_memoization
   )
     @ref = ref
     @method_id = method_id
     @method_args = method_args
     @dependent_memos = dependent_memos
     @cache_options = cache_options
-    @method_name_without_memo = method_name_without_memo
+    @method_name_without_memoization = method_name_without_memoization
     @method_cache_key = nil
     @cache_hit = false
     @cached_result = nil
@@ -33,18 +34,26 @@ class RedisMemo::Future
 
   def method_cache_key
     @method_cache_key ||=
-      RedisMemo::MemoizeMethod.method_cache_keys([context])&.first || ''
+      RedisMemo::MemoizeMethod.__send__(:method_cache_keys, [context])&.first || ''
   end
 
-  def execute(cached_results=nil)
+  def validate_cache_result
+    cache_validation_sample_percentage =
+      @cache_options[:cache_validation_sample_percentage] || RedisMemo::DefaultOptions.cache_validation_sample_percentage
+
+    if cache_validation_sample_percentage.nil?
+      false
+    else
+      cache_validation_sample_percentage > Random.rand(0...100)
+    end
+  end
+
+  def execute(cached_results = nil)
     if RedisMemo::Batch.current
-      raise RedisMemo::RuntimeError, 'Cannot execute future when a batch is still open'
+      raise RedisMemo::RuntimeError.new('Cannot execute future when a batch is still open')
     end
 
     if cache_hit?(cached_results)
-      validate_cache_result =
-        RedisMemo::DefaultOptions.cache_validation_sampler&.call(@method_id)
-
       if validate_cache_result && cached_result != fresh_result
         RedisMemo::DefaultOptions.cache_out_of_date_handler&.call(
           @ref,
@@ -64,7 +73,7 @@ class RedisMemo::Future
 
   def result
     unless @computed_cached_result
-      raise RedisMemo::RuntimeError, 'Future has not been executed'
+      raise RedisMemo::RuntimeError.new('Future has not been executed')
     end
 
     @fresh_result || @cached_result
@@ -72,13 +81,13 @@ class RedisMemo::Future
 
   private
 
-  def cache_hit?(cached_results=nil)
+  def cache_hit?(cached_results = nil)
     cached_result(cached_results)
 
     @cache_hit
   end
 
-  def cached_result(cached_results=nil)
+  def cached_result(cached_results = nil)
     return @cached_result if @computed_cached_result
 
     @cache_hit = false
@@ -102,7 +111,7 @@ class RedisMemo::Future
 
     RedisMemo::Tracer.trace('redis_memo.cache.write', @method_id) do
       # cache miss
-      @fresh_result = @ref.send(@method_name_without_memo, *@method_args)
+      @fresh_result = @ref.__send__(@method_name_without_memoization, *@method_args)
       if @cache_options.include?(:expires_in) && @cache_options[:expires_in].respond_to?(:call)
         @cache_options[:expires_in] = @cache_options[:expires_in].call(@fresh_result)
       end
@@ -114,7 +123,7 @@ class RedisMemo::Future
             # result)
             @cache_hit && @cached_result != @fresh_result
           )
-      )
+        )
         RedisMemo::Cache.write(method_cache_key, @fresh_result, **@cache_options)
       end
     end