redis-memo 0.0.0.beta.3 → 0.0.0.beta.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd8d075c12b20782f27bdfe2488cba1c0f31f5fb537241a9cedcc72f484588b9
-  data.tar.gz: 0eef678b83746557ba84aca013e660ecc31a028042cf052606673179e185d61e
+  metadata.gz: 72bcf0679b811825222a6b38de0fcdadf4546640d2f61b18ebc827e37137dc41
+  data.tar.gz: 7a55c7bbd084a24afe085e85bc5cd5c486cf240094b64ca09d48e9e0ce126384
 SHA512:
-  metadata.gz: a8f573eb77832f3dfb0600ab607c8d60090969082c86a9403a98b784899931da60d66f1b761bf863fd4007492ff47dee2d7880ec2f10cf5143fce33bc791684b
-  data.tar.gz: 4f9e44c13d2b4918f69f143f78eb4d80ad306b43abb650c03c481d727a88938f70c3ef89854e5c67afe92cc656df82ff44df84bb07878904bcdfbb2b86c15275
+  metadata.gz: 5a3af887512e4b6571829fcfda719e43abb917eb4773407bd27788b0b671a42263ec31c2f6286f0a1279a354851c8c8cb48eb9701cba59863e500ca47419080e
+  data.tar.gz: feeb72b177ec07953b839e6e0759cbdf42dfd4eddd19f89599e721589462e849e7685a659b03128504d670764223f1805402cb3ee8a96411b834f229ba837d99

data/lib/redis_memo.rb

@@ -97,4 +97,5 @@ module RedisMemo
   # @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/cache.rb

@@ -1,6 +1,7 @@
  # frozen_string_literal: true
 require_relative 'options'
 require_relative 'redis'
+require_relative 'connection_pool'
 
 class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
   class Rescuable < Exception; end
@@ -24,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
@@ -60,7 +66,7 @@ class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
     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
@@ -71,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

@@ -82,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?
 

data/lib/redis_memo/memoizable/dependency.rb

@@ -51,8 +51,8 @@ class RedisMemo::Memoizable::Dependency
       RedisMemo::MemoizeQuery::CachedSelect.current_query = relation.arel
       is_query_cached = RedisMemo::MemoizeQuery::CachedSelect.extract_bind_params(query)
         raise(
-          RedisMemo::ArgumentError,
-          "Invalid Arel dependency. Query is not enabled for RedisMemo caching."
+          RedisMemo::WithoutMemoization,
+          "Arel query is not cached using RedisMemo."
         ) unless is_query_cached
         extracted_dependency = connection.dependency_of(:exec_query, query, nil, binds)
     end

data/lib/redis_memo/memoizable/invalidation.rb

@@ -56,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)
@@ -123,7 +126,8 @@ module RedisMemo::Memoizable::Invalidation
       task = @@invalidation_queue.pop
       begin
         bump_version(task)
-      rescue SignalException, Redis::BaseConnectionError
+      rescue SignalException, Redis::BaseConnectionError,
+             ::ConnectionPool::TimeoutError
         retry_queue << task
       end
     end

data/lib/redis_memo/memoize_method.rb

@@ -15,6 +15,12 @@ module RedisMemo::MemoizeMethod
     define_method method_name_with_memo do |*args|
       return send(method_name_without_memo, *args) if RedisMemo.without_memo?
 
+      dependent_memos = nil
+      if depends_on
+        dependency = RedisMemo::MemoizeMethod.get_or_extract_dependencies(self, *args, &depends_on)
+        dependent_memos = dependency.memos
+      end
+
       future = RedisMemo::Future.new(
         self,
         case method_id
@@ -26,7 +32,7 @@ module RedisMemo::MemoizeMethod
           method_id.call(self, *args)
         end,
         args,
-        depends_on,
+        dependent_memos,
         options,
         method_name_without_memo,
       )
@@ -37,6 +43,8 @@ module RedisMemo::MemoizeMethod
       end
 
       future.execute
+    rescue RedisMemo::WithoutMemoization
+      send(method_name_without_memo, *args)
     end
 
     alias_method method_name, method_name_with_memo
@@ -83,17 +91,14 @@ module RedisMemo::MemoizeMethod
 
   def self.method_cache_keys(future_contexts)
     memos = Array.new(future_contexts.size)
-    future_contexts.each_with_index do |(ref, _, method_args, depends_on), i|
-      if depends_on
-        dependency = get_or_extract_dependencies(ref, *method_args, &depends_on)
-        memos[i] = dependency.memos
-      end
+    future_contexts.each_with_index do |(_, _, dependent_memos), i|
+      memos[i] = dependent_memos
     end
 
     j = 0
     memo_checksums = RedisMemo::Memoizable.checksums(memos.compact)
     method_cache_key_versions = Array.new(future_contexts.size)
-    future_contexts.each_with_index do |(_, method_id, method_args, _), i|
+    future_contexts.each_with_index do |(method_id, method_args, _), i|
       if memos[i]
         method_cache_key_versions[i] = [method_id, memo_checksums[j]]
         j += 1

data/lib/redis_memo/memoize_query.rb

@@ -13,6 +13,8 @@ if defined?(ActiveRecord)
     # after each record save
     def memoize_table_column(*raw_columns, editable: true)
       RedisMemo::MemoizeQuery.using_active_record!(self)
+      return if ENV["REDIS_MEMO_DISABLE_#{self.table_name.upcase}"] == 'true'
+
       columns = raw_columns.map(&:to_sym).sort
 
       RedisMemo::MemoizeQuery.memoized_columns(self, editable_only: true) << columns if editable
@@ -102,8 +104,10 @@ if defined?(ActiveRecord)
       end
     end
 
-    def self.invalidate(record)
-      RedisMemo::Memoizable.invalidate(to_memos(record))
+    def self.invalidate(*records)
+      RedisMemo::Memoizable.invalidate(
+        records.map { |record| to_memos(record) }.flatten,
+      )
     end
 
     def self.to_memos(record)

data/lib/redis_memo/memoize_query/cached_select.rb

@@ -123,7 +123,14 @@ class RedisMemo::MemoizeQuery::CachedSelect
 
         depends_on RedisMemo::Memoizable.new(
           __redis_memo_memoize_query_memoize_query_sql__: sql,
-          __redis_memo_memoize_query_memoize_query_binds__: binds.map(&:value_for_database),
+          __redis_memo_memoize_query_memoize_query_binds__: binds.map do |bind|
+            if bind.respond_to?(:value_for_database)
+              bind.value_for_database
+            else
+              # In activerecord >= 6, a bind could be an actual database value
+              bind
+            end
+          end
         )
       end
     end
@@ -210,7 +217,7 @@ class RedisMemo::MemoizeQuery::CachedSelect
     bind_params = BindParams.new
 
     case node
-    when Arel::Nodes::Equality, Arel::Nodes::In
+    when NodeHasFilterCondition
       attr_node = node.left
       return unless attr_node.is_a?(Arel::Attributes::Attribute)
 
@@ -247,7 +254,13 @@ class RedisMemo::MemoizeQuery::CachedSelect
           }
         when Arel::Nodes::Casted
           bind_params.params[binding_relation] << {
-            right.attribute.name.to_sym => right.val,
+            right.attribute.name.to_sym =>
+              if right.respond_to?(:val)
+                right.val
+              else
+                # activerecord >= 6
+                right.value
+              end,
           }
         else
           bind_params = bind_params.union(extract_bind_params_recurse(right))
@@ -343,6 +356,23 @@ class RedisMemo::MemoizeQuery::CachedSelect
     enabled_models[table_node.try(:name)]
   end
 
+  class NodeHasFilterCondition
+    def self.===(node)
+      case node
+      when Arel::Nodes::Equality, Arel::Nodes::In
+        true
+      else
+        # In activerecord >= 6, a new arel node HomogeneousIn is introduced
+        if defined?(Arel::Nodes::HomogeneousIn) &&
+           node.is_a?(Arel::Nodes::HomogeneousIn)
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+
   # Thread locals to exchange information between RedisMemo and ActiveRecord
   THREAD_KEY_AREL = :__redis_memo_memoize_query_cached_select_arel__
   THREAD_KEY_SUBSTITUTES = :__redis_memo_memoize_query_cached_select_substitues__

data/lib/redis_memo/memoize_query/invalidation.rb

@@ -110,9 +110,9 @@ class RedisMemo::MemoizeQuery::Invalidation
       define_method method_name do |*args, &blk|
         options = args.last.is_a?(Hash) ? args.last : {}
         records = args[args.last.is_a?(Hash) ? -2 : -1]
-        unique_by = options[:on_duplicate_key_update]
-        if unique_by.is_a?(Hash)
-          unique_by = unique_by[:columns]
+        columns_to_update = options[:on_duplicate_key_update]
+        if columns_to_update.is_a?(Hash)
+          columns_to_update = columns_to_update[:columns]
         end
 
         if records.last.is_a?(Hash)
@@ -123,11 +123,11 @@ class RedisMemo::MemoizeQuery::Invalidation
         # - default values filled by the database
         # - updates on conflict conditions
         records_to_invalidate =
-          if unique_by
+          if columns_to_update
             RedisMemo::MemoizeQuery::Invalidation.send(
-              :select_by_uniq_index,
+              :select_by_columns,
               records,
-              unique_by,
+              columns_to_update,
             )
           else
             []
@@ -135,38 +135,77 @@ class RedisMemo::MemoizeQuery::Invalidation
 
         result = send(:"#{method_name}_without_redis_memo_invalidation", *args, &blk)
 
-        records_to_invalidate += RedisMemo.without_memo do
-          # Not all databases support "RETURNING", which is useful when
-          # invaldating records after bulk creation
-          model_class.where(model_class.primary_key => result.ids).to_a
+        # Offload the records to invalidate while selecting the next set of
+        # records to invalidate
+        case records_to_invalidate
+        when Array
+          RedisMemo::MemoizeQuery.invalidate(*records_to_invalidate) unless records_to_invalidate.empty?
+
+          RedisMemo::MemoizeQuery.invalidate(*RedisMemo::MemoizeQuery::Invalidation.send(
+            :select_by_id,
+            model_class,
+            # Not all databases support "RETURNING", which is useful when
+            # invaldating records after bulk creation
+            result.ids,
+          ))
+        else
+          RedisMemo::MemoizeQuery.invalidate_all(model_class)
         end
 
-        memos_to_invalidate = records_to_invalidate.map do |record|
-          RedisMemo::MemoizeQuery.to_memos(record)
-        end
-        RedisMemo::Memoizable.invalidate(memos_to_invalidate.flatten)
-
         result
       end
     end
   end
 
-  def self.select_by_uniq_index(records, unique_by)
+  def self.select_by_columns(records, columns_to_update)
     model_class = records.first.class
     or_chain = nil
-
-    records.each do |record|
-      conditions = {}
-      unique_by.each do |column|
-        conditions[column] = record.send(column)
+    columns_to_select = columns_to_update & RedisMemo::MemoizeQuery
+      .memoized_columns(model_class)
+      .to_a.flatten.uniq
+
+    # Nothing to invalidate here
+    return [] if columns_to_select.empty?
+
+    RedisMemo::Tracer.trace(
+      'redis_memo.memoize_query.invalidation',
+      "#{__method__}##{model_class.name}",
+    ) do
+      records.each do |record|
+        conditions = {}
+        columns_to_select.each do |column|
+          conditions[column] = record.send(column)
+        end
+        if or_chain
+          or_chain = or_chain.or(model_class.where(conditions))
+        else
+          or_chain = model_class.where(conditions)
+        end
       end
-      if or_chain
-        or_chain = or_chain.or(model_class.where(conditions))
+
+      record_count = RedisMemo.without_memo { or_chain.count }
+      if record_count > bulk_operations_invalidation_limit
+        nil
       else
-        or_chain = model_class.where(conditions)
+        RedisMemo.without_memo { or_chain.to_a }
       end
     end
+  end
+
+  def self.select_by_id(model_class, ids)
+    RedisMemo::Tracer.trace(
+      'redis_memo.memoize_query.invalidation',
+      "#{__method__}##{model_class.name}",
+    ) do
+      RedisMemo.without_memo do
+        model_class.where(model_class.primary_key => ids).to_a
+      end
+    end
+  end
 
-    RedisMemo.without_memo { or_chain.to_a }
+  def self.bulk_operations_invalidation_limit
+    ENV['REDIS_MEMO_BULK_OPERATIONS_INVALIDATION_LIMIT']&.to_i ||
+      RedisMemo::DefaultOptions.bulk_operations_invalidation_limit ||
+      10000
   end
 end

data/lib/redis_memo/options.rb

@@ -13,7 +13,7 @@ class RedisMemo::Options
   )
     @compress = compress.nil? ? true : compress
     @compress_threshold = compress_threshold || 1.kilobyte
-    @redis = redis
+    @redis_config = redis
     @redis_client = nil
     @redis_error_handler = redis_error_handler
     @tracer = tracer
@@ -22,20 +22,18 @@ class RedisMemo::Options
     @expires_in = expires_in
   end
 
-  def redis(&blk)
-    if blk.nil?
-      return @redis_client if @redis_client.is_a?(RedisMemo::Redis)
+  def redis
+    @redis_client ||= RedisMemo::Redis.new(redis_config)
+  end
 
-      if @redis.respond_to?(:call)
-        @redis_client = RedisMemo::Redis.new(@redis.call)
-      elsif @redis
-        @redis_client = RedisMemo::Redis.new(@redis)
-      else
-        @redis_client = RedisMemo::Redis.new
-      end
-    else
-      @redis = blk
-    end
+  def redis_config
+    @redis_config || {}
+  end
+
+  def redis=(config)
+    @redis_config = config
+    @redis_client = nil
+    redis
   end
 
   def tracer(&blk)
@@ -74,15 +72,16 @@ class RedisMemo::Options
   end
 
   attr_accessor :async
+  attr_accessor :bulk_operations_invalidation_limit
+  attr_accessor :cache_out_of_date_handler
+  attr_accessor :cache_validation_sampler
   attr_accessor :compress
   attr_accessor :compress_threshold
-  attr_accessor :redis_error_handler
+  attr_accessor :connection_pool
   attr_accessor :expires_in
-  attr_accessor :cache_validation_sampler
-  attr_accessor :cache_out_of_date_handler
+  attr_accessor :redis_error_handler
 
   attr_writer :global_cache_key_version
-  attr_writer :redis
   attr_writer :tracer
   attr_writer :logger
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-memo
 version: !ruby/object:Gem::Version
-  version: 0.0.0.beta.3
+  version: 0.0.0.beta.4
 platform: ruby
 authors:
 - Chan Zuckerberg Initiative
@@ -14,42 +14,56 @@ dependencies:
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: 4.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: 4.0.1
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.3
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
 - !ruby/object:Gem::Dependency
@@ -161,6 +175,7 @@ files:
 - lib/redis_memo/after_commit.rb
 - lib/redis_memo/batch.rb
 - lib/redis_memo/cache.rb
+- lib/redis_memo/connection_pool.rb
 - lib/redis_memo/future.rb
 - lib/redis_memo/memoizable.rb
 - lib/redis_memo/memoizable/dependency.rb