redis-memo 0.0.0.beta → 0.0.0.beta.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1316982523363ce87b0ada30b82b8200559a07b2f1a6bea54168b40b2afd397e
-  data.tar.gz: 1278e1ff6b7cc2275416c7af9b8668a13128c105a4cde74640deccd0a4380373
+  metadata.gz: ee7d2004ee718072b93ece80d2e98b038b9f4a21cd73632c1df4a3609f11e9e4
+  data.tar.gz: c8a89bb39f5b3e9f5a8b571942045c7b6b147a1d3e925f71ae611944c6aa13c9
 SHA512:
-  metadata.gz: 121069c8de985a8977234776ad15fd209c1c0db523c361a5caf9181ed7120533350af16c354d7f76dfc03168230248e37c64b37eb8ce9f6af16cfdc9160448f3
-  data.tar.gz: 133d18912a95eb599554b9cacb5c5932471772930165249381baaa8aeb403a3a6b21c6e17711a11eda56a1fa6dbf347396c7fe513cec3b53ec6f0c592d5b7d9a
+  metadata.gz: 15527040749e75dd0f27c31ecf08867cc63066b7582cdc4d618e269b2e9cb63e35601596d8f03900e55c192a20afd717c8b105426d5511df2c5db1906b4777e5
+  data.tar.gz: 1ab368f33e5a17209e28efbe2086a067e9f016443b28d56ece0499f557e15fcb3d801930af535d3d1fe1e1eb125b8f2595e694a71a5476c862201e5886cb826c

data/lib/redis-memo.rb

@@ -1 +1,5 @@
+# frozen_string_literal: true
+
+# Automatically require the main file of the redis-memo gem when adding it to
+# the Gemfile
 require_relative 'redis_memo'

data/lib/redis_memo.rb

@@ -1,18 +1,53 @@
 # frozen_string_literal: true
+
 require 'active_support/all'
 require 'digest'
 require 'json'
+require 'securerandom'
 
 module RedisMemo
   require 'redis_memo/memoize_method'
-  require 'redis_memo/memoize_records'
+  require 'redis_memo/memoize_query'
 
+  # A process-level +RedisMemo::Options+ instance that stores the global
+  # options. This object can be modified by +RedisMemo.configure+.
+  #
+  # +memoize_method+ allows users to provide method-level configuration.
+  # When no callsite-level configuration specified we will use the values in
+  # +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.
+  #
+  # @yieldparam [RedisMemo::Options] default_options
+  # +RedisMemo::DefaultOptions+
+  # @return [void]
   def self.configure(&blk)
     blk.call(DefaultOptions)
   end
 
+  # Batch Redis calls triggered by +memoize_method+ to minimize the 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.size == 5 # true
+  #
+  # See +RedisMemo::Batch+ for more information.
   def self.batch(&blk)
     RedisMemo::Batch.open
     blk.call
@@ -21,10 +56,17 @@ 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|
@@ -33,12 +75,17 @@ module RedisMemo
     end
   end
 
-  THREAD_KEY_WITHOUT_MEMO = :__redis_memo_without_memo__
-
+  # 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
   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
@@ -47,6 +94,8 @@ module RedisMemo
     Thread.current[THREAD_KEY_WITHOUT_MEMO] = prev_value
   end
 
+  # @todo Move errors to a separate file errors.rb
   class ArgumentError < ::ArgumentError; end
   class RuntimeError < ::RuntimeError; end
+  class WithoutMemoization < Exception; end
 end

data/lib/redis_memo/after_commit.rb

@@ -66,7 +66,12 @@ class RedisMemo::AfterCommit
       @@pending_memo_versions.each do |key, version|
         invalidation_queue =
           RedisMemo::Memoizable::Invalidation.class_variable_get(:@@invalidation_queue)
-        invalidation_queue << [key, version, @@previous_memo_versions[key]]
+
+        invalidation_queue << RedisMemo::Memoizable::Invalidation::Task.new(
+          key,
+          version,
+          @@previous_memo_versions[key],
+        )
       end
 
       RedisMemo::Memoizable::Invalidation.drain_invalidation_queue

data/lib/redis_memo/cache.rb

@@ -1,12 +1,14 @@
  # frozen_string_literal: true
 require_relative 'options'
 require_relative 'redis'
+require_relative 'connection_pool'
 
 class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
   class Rescuable < Exception; end
 
-  THREAD_KEY_LOCAL_CACHE = :__redis_memo_cache_local_cache__
-  THREAD_KEY_RAISE_ERROR = :__redis_memo_cache_raise_error__
+  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__
 
   @@redis = nil
   @@redis_store = nil
@@ -23,7 +25,12 @@ class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
   end
 
   def self.redis
-    @@redis ||= RedisMemo::DefaultOptions.redis
+    @@redis ||=
+      if RedisMemo::DefaultOptions.connection_pool
+        RedisMemo::ConnectionPool.new(**RedisMemo::DefaultOptions.connection_pool)
+      else
+        RedisMemo::DefaultOptions.redis
+      end
   end
 
   def self.redis_store
@@ -44,16 +51,22 @@ class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
     Thread.current[THREAD_KEY_LOCAL_CACHE]
   end
 
+  def self.local_dependency_cache
+    Thread.current[THREAD_KEY_LOCAL_DEPENDENCY_CACHE]
+  end
+
   class << self
     def with_local_cache(&blk)
       Thread.current[THREAD_KEY_LOCAL_CACHE] = {}
+      Thread.current[THREAD_KEY_LOCAL_DEPENDENCY_CACHE] = {}
       blk.call
     ensure
       Thread.current[THREAD_KEY_LOCAL_CACHE] = nil
+      Thread.current[THREAD_KEY_LOCAL_DEPENDENCY_CACHE] = nil
     end
 
     # RedisCacheStore doesn't read from the local cache before reading from redis
-    def read_multi(*keys, raise_error: false)
+    def read_multi(*keys, raw: false, raise_error: false)
       return {} if keys.empty?
 
       Thread.current[THREAD_KEY_RAISE_ERROR] = raise_error
@@ -64,7 +77,7 @@ class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
       keys_to_fetch -= local_entries.keys unless local_entries.empty?
       return local_entries if keys_to_fetch.empty?
 
-      remote_entries = redis_store.read_multi(*keys_to_fetch)
+      remote_entries = redis_store.read_multi(*keys_to_fetch, raw: raw)
       local_cache&.merge!(remote_entries)
 
       if local_entries.empty?

data/lib/redis_memo/connection_pool.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+require 'connection_pool'
+require_relative 'redis'
+
+class RedisMemo::ConnectionPool
+  def initialize(**options)
+    @connection_pool = ::ConnectionPool.new(**options) do
+      # Construct a new client every time the block gets called
+      RedisMemo::Redis.new(RedisMemo::DefaultOptions.redis_config)
+    end
+  end
+
+  # Avoid method_missing when possible for better performance
+  %i(get mget mapped_mget set eval).each do |method_name|
+    define_method method_name do |*args, &blk|
+      @connection_pool.with do |redis|
+        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)
+    end
+  end
+end

data/lib/redis_memo/future.rb

@@ -9,14 +9,14 @@ class RedisMemo::Future
     ref,
     method_id,
     method_args,
-    depends_on,
+    dependent_memos,
     cache_options,
     method_name_without_memo
   )
     @ref = ref
     @method_id = method_id
     @method_args = method_args
-    @depends_on = depends_on
+    @dependent_memos = dependent_memos
     @cache_options = cache_options
     @method_name_without_memo = method_name_without_memo
     @method_cache_key = nil
@@ -28,7 +28,7 @@ class RedisMemo::Future
   end
 
   def context
-    [@ref, @method_id, @method_args, @depends_on]
+    [@method_id, @method_args, @dependent_memos]
   end
 
   def method_cache_key

data/lib/redis_memo/memoizable.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require 'securerandom'
 
 class RedisMemo::Memoizable
   require_relative 'memoizable/dependency'
@@ -52,7 +51,7 @@ class RedisMemo::Memoizable
       cache_key = instance.cache_key
       RedisMemo::Memoizable::Invalidation.bump_version_later(
         cache_key,
-        SecureRandom.uuid,
+        RedisMemo.uuid,
       )
     end
 
@@ -83,7 +82,11 @@ class RedisMemo::Memoizable
       if keys_to_fetch.empty?
         {}
       else
-        RedisMemo::Cache.read_multi(*keys_to_fetch, raise_error: true)
+        RedisMemo::Cache.read_multi(
+          *keys_to_fetch,
+          raw: true,
+          raise_error: true,
+        )
       end
     memo_versions.merge!(cached_versions) unless cached_versions.empty?
 
@@ -96,7 +99,7 @@ class RedisMemo::Memoizable
         # cached result.
         need_to_bump_versions = true
 
-        new_version = SecureRandom.uuid
+        new_version = RedisMemo.uuid
         RedisMemo::Memoizable::Invalidation.bump_version_later(
           key,
           new_version,

data/lib/redis_memo/memoizable/dependency.rb

@@ -12,25 +12,55 @@ class RedisMemo::Memoizable::Dependency
     @nodes.values
   end
 
-  def depends_on(memo_or_model, **conditions)
-    if !memo_or_model.is_a?(RedisMemo::Memoizable)
+  def depends_on(dependency, **conditions)
+    case dependency
+    when self.class
+      nodes.merge!(dependency.nodes)
+    when RedisMemo::Memoizable
+      memo = dependency
+      return if nodes.include?(memo.cache_key)
+      nodes[memo.cache_key] = memo
+
+      if memo.depends_on
+        # Extract dependencies from the current memoizable and recurse
+        instance_exec(&memo.depends_on)
+      end
+    when ActiveRecord::Relation
+      extracted = extract_dependencies_for_relation(dependency)
+      nodes.merge!(extracted.nodes)
+    when UsingActiveRecord
       [
-        memo_or_model.redis_memo_class_memoizable,
-        RedisMemo::MemoizeRecords.create_memo(memo_or_model, **conditions),
+        dependency.redis_memo_class_memoizable,
+        RedisMemo::MemoizeQuery.create_memo(dependency, **conditions),
       ].each do |memo|
         nodes[memo.cache_key] = memo
       end
-
-      return
+    else
+      raise(
+        RedisMemo::ArgumentError,
+        "Invalid dependency #{dependency}"
+      )
     end
+  end
 
-    memo = memo_or_model
-    return if nodes.include?(memo.cache_key)
-    nodes[memo.cache_key] = memo
+  def extract_dependencies_for_relation(relation)
+    # Extract the dependent memos of an Arel without calling exec_query to actually execute the query
+    RedisMemo::MemoizeQuery::CachedSelect.with_new_query_context do
+      connection = ActiveRecord::Base.connection
+      query, binds, _ = connection.send(:to_sql_and_binds, relation.arel)
+      RedisMemo::MemoizeQuery::CachedSelect.current_query = relation.arel
+      is_query_cached = RedisMemo::MemoizeQuery::CachedSelect.extract_bind_params(query)
+        raise(
+          RedisMemo::WithoutMemoization,
+          "Arel query is not cached using RedisMemo."
+        ) unless is_query_cached
+        extracted_dependency = connection.dependency_of(:exec_query, query, nil, binds)
+    end
+  end
 
-    if memo.depends_on
-      # Extract dependencies from the current memoizable and recurse
-      instance_exec(&memo.depends_on)
+  class UsingActiveRecord
+    def self.===(dependency)
+      RedisMemo::MemoizeQuery.using_active_record?(dependency)
     end
   end
 end

data/lib/redis_memo/memoizable/invalidation.rb

@@ -3,12 +3,29 @@ require_relative '../after_commit'
 require_relative '../cache'
 
 module RedisMemo::Memoizable::Invalidation
-  # This is a thread safe data structure
-  #
-  # Handle transient network errors during cache invalidation
-  # Each item in the queue is a tuple:
-  #
-  #   [key, version (a UUID), previous_version (a UUID)]
+  class Task
+    attr_reader :key
+    attr_reader :version
+    attr_reader :previous_version
+
+    def initialize(key, version, previous_version)
+      @key = key
+      @version = version
+      @previous_version = previous_version
+      @created_at = current_timestamp
+    end
+
+    def current_timestamp
+      Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+    end
+
+    def duration
+      current_timestamp - @created_at
+    end
+  end
+
+  # This is a thread safe data structure to handle transient network errors
+  # during cache invalidation
   #
   # When an invalidation call arrives at Redis, we only bump to the specified
   # version (so the cached results using that version will become visible) if
@@ -28,8 +45,6 @@ module RedisMemo::Memoizable::Invalidation
   @@invalidation_queue = Queue.new
 
   def self.bump_version_later(key, version, previous_version: nil)
-    RedisMemo::DefaultOptions.logger&.info("[received] Bump memo key #{key}")
-
     if RedisMemo::AfterCommit.in_transaction?
       previous_version ||= RedisMemo::AfterCommit.pending_memo_versions[key]
     end
@@ -41,7 +56,10 @@ module RedisMemo::Memoizable::Invalidation
       # Fill an expected previous version so the later calculation results
       # based on this version can still be rolled out if this version
       # does not change
-      previous_version ||= RedisMemo::Cache.read_multi(key)[key]
+      previous_version ||= RedisMemo::Cache.read_multi(
+        key,
+        raw: true,
+      )[key]
     end
 
     local_cache&.send(:[]=, key, version)
@@ -52,7 +70,7 @@ module RedisMemo::Memoizable::Invalidation
         previous_version: previous_version,
       )
     else
-      @@invalidation_queue << [key, version, previous_version]
+      @@invalidation_queue << Task.new(key, version, previous_version)
     end
   end
 
@@ -89,31 +107,32 @@ module RedisMemo::Memoizable::Invalidation
     return redis.call('set', key, new_version, unpack(px))
   LUA
 
-  def self.bump_version(cache_key, version, previous_version:)
-    RedisMemo::Tracer.trace('redis_memo.memoizable.bump_version', nil) do
+  def self.bump_version(task)
+    RedisMemo::Tracer.trace('redis_memo.memoizable.bump_version', task.key) do
       ttl = RedisMemo::DefaultOptions.expires_in
       ttl = (ttl * 1000.0).to_i if ttl
       RedisMemo::Cache.redis.eval(
         LUA_BUMP_VERSION,
-        keys: [cache_key],
-        argv: [previous_version, version, SecureRandom.uuid, ttl],
+        keys: [task.key],
+        argv: [task.previous_version, task.version, RedisMemo.uuid, ttl],
       )
+      RedisMemo::Tracer.set_tag(enqueue_to_finish: task.duration)
     end
-    RedisMemo::DefaultOptions.logger&.info("[performed] Bump memo key #{cache_key}")
   end
 
   def self.drain_invalidation_queue_now
     retry_queue = []
     until @@invalidation_queue.empty?
-      tuple = @@invalidation_queue.pop
+      task = @@invalidation_queue.pop
       begin
-        bump_version(tuple[0], tuple[1], previous_version: tuple[2])
-      rescue SignalException, Redis::BaseConnectionError
-        retry_queue << tuple
+        bump_version(task)
+      rescue SignalException, Redis::BaseConnectionError,
+             ::ConnectionPool::TimeoutError
+        retry_queue << task
       end
     end
   ensure
-    retry_queue.each { |t| @@invalidation_queue << t }
+    retry_queue.each { |task| @@invalidation_queue << task }
   end
 
   at_exit do