redis-memo 0.0.0.beta.6 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10f721bc9b55f26c51674ce16f120bc643c306748dd9ff5aa5f54a7d9b944b51
-  data.tar.gz: 3cf3fefe9a5119d231bf973da22aa7787fcac1cf71f46ab0cadc5421cc82da52
+  metadata.gz: a03c34771a13ad121b14359ba0e7b3596ef37da5cbf1f6c46e59bf28238e5e5d
+  data.tar.gz: 55d84f1b82f40c261b0ff8a7a5faa868b50caf248e89e755b31a0011f1caab3f
 SHA512:
-  metadata.gz: a576fa80cef7462769055bdf657e0ee0f70fc9fb63a08f5b4ceabb931faaa8c6c8d310f01424c2124c7842b00d3c069d7c31499fc4dff166544e85b52989d0bd
-  data.tar.gz: 45cc8638df93f0c22fd050ad39b25fd1d8671ac309fbee8e41979d51e0a6136e7c98d9fc9a31acd9e1e1828c592f5b2068349f6a0e1bb294664fcacea8911f48
+  metadata.gz: 83638771de1cb0041c4864b71d53bb89c99508f2827db23b504f1751e1ad22cff7010451d5f47cdcb14ffb619162f16fe4cf177e403b0522e654b7e697b0b872
+  data.tar.gz: fc5df8d6c8a336985927a2f35b177373a8f2e4dcd2b87bccac705440eaeaabe1a09f3d90138543c528b4763b70edc38931e6c9bc642e362b2c5ffef61e088d16

data/lib/redis_memo.rb

@@ -19,6 +19,8 @@ module RedisMemo
 
   # @todo Move thread keys to +RedisMemo::ThreadKey+
   THREAD_KEY_WITHOUT_MEMO = :__redis_memo_without_memo__
+  THREAD_KEY_CONNECTION_ATTEMPTS_COUNT = :__redis_memo_connection_attempts_count__
+  THREAD_KEY_MAX_CONNECTION_ATTEMPTS = :__redis_memo_max_connection_attempts__
 
   # Configure global-level default options. Those options will be used unless
   # some options specified at +memoize_method+ callsite level. See
@@ -80,7 +82,7 @@ module RedisMemo
   #
   # @return [Boolean]
   def self.without_memo?
-    Thread.current[THREAD_KEY_WITHOUT_MEMO] == true
+    ENV["REDIS_MEMO_DISABLE_ALL"] == 'true' || Thread.current[THREAD_KEY_WITHOUT_MEMO] == true
   end
 
   # Configure the wrapped code in the block to skip memoization.
@@ -94,6 +96,35 @@ module RedisMemo
     Thread.current[THREAD_KEY_WITHOUT_MEMO] = prev_value
   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_memo`.
+  #
+  # @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 = Thread.current[THREAD_KEY_WITHOUT_MEMO]
+    if max_attempts
+      Thread.current[THREAD_KEY_CONNECTION_ATTEMPTS_COUNT] = 0
+      Thread.current[THREAD_KEY_MAX_CONNECTION_ATTEMPTS] = max_attempts
+    end
+    yield
+  ensure
+    Thread.current[THREAD_KEY_WITHOUT_MEMO] = prev_value
+    Thread.current[THREAD_KEY_CONNECTION_ATTEMPTS_COUNT] = nil
+    Thread.current[THREAD_KEY_MAX_CONNECTION_ATTEMPTS] = nil
+  end
+
+  private
+  def self.incr_connection_attempts # :nodoc:
+    return if Thread.current[THREAD_KEY_MAX_CONNECTION_ATTEMPTS].nil? || Thread.current[THREAD_KEY_CONNECTION_ATTEMPTS_COUNT].nil?
+
+    # The connection attempts count and max connection attempts are reset in RedisMemo.with_max_connection_attempts
+    Thread.current[THREAD_KEY_CONNECTION_ATTEMPTS_COUNT] += 1
+    if Thread.current[THREAD_KEY_CONNECTION_ATTEMPTS_COUNT] >= Thread.current[THREAD_KEY_MAX_CONNECTION_ATTEMPTS]
+      Thread.current[THREAD_KEY_WITHOUT_MEMO] = true
+    end
+  end
+
   # @todo Move errors to a separate file errors.rb
   class ArgumentError < ::ArgumentError; end
   class RuntimeError < ::RuntimeError; end

data/lib/redis_memo/cache.rb

@@ -17,6 +17,8 @@ class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
     RedisMemo::DefaultOptions.redis_error_handler&.call(exception, method)
     RedisMemo::DefaultOptions.logger&.warn(exception.full_message)
 
+    RedisMemo.incr_connection_attempts if exception.is_a?(Redis::BaseConnectionError)
+
     if Thread.current[THREAD_KEY_RAISE_ERROR]
       raise RedisMemo::Cache::Rescuable
     else
@@ -55,6 +57,16 @@ class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
     Thread.current[THREAD_KEY_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 => e
+    handle_exception exception: e, method: method, returning: returning
+    returning
+  end
+  private :failsafe
+
   class << self
     def with_local_cache(&blk)
       Thread.current[THREAD_KEY_LOCAL_CACHE] = {}

data/lib/redis_memo/memoizable/dependency.rb

@@ -26,14 +26,18 @@ class RedisMemo::Memoizable::Dependency
         instance_exec(&memo.depends_on)
       end
     when ActiveRecord::Relation
-      extracted = extract_dependencies_for_relation(dependency)
+      extracted = self.class.extract_from_relation(dependency)
       nodes.merge!(extracted.nodes)
-    when UsingActiveRecord
-      [
-        dependency.redis_memo_class_memoizable,
-        RedisMemo::MemoizeQuery.create_memo(dependency, **conditions),
-      ].each do |memo|
+    when RedisMemo::MemoizeQuery::CachedSelect::BindParams
+      # A private API
+      dependency.params.each do |model, attrs_set|
+        memo = model.redis_memo_class_memoizable
         nodes[memo.cache_key] = memo
+
+        attrs_set.each do |attrs|
+          memo = RedisMemo::MemoizeQuery.create_memo(model, **attrs)
+          nodes[memo.cache_key] = memo
+        end
       end
     else
       raise(
@@ -43,24 +47,24 @@ class RedisMemo::Memoizable::Dependency
     end
   end
 
-  def extract_dependencies_for_relation(relation)
+  private
+
+  def self.extract_from_relation(relation)
+    connection = ActiveRecord::Base.connection
+    unless connection.respond_to?(:dependency_of)
+      raise RedisMemo::WithoutMemoization, 'Caching active record queries is currently disabled on RedisMemo'
+    end
     # 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
 
-  class UsingActiveRecord
-    def self.===(dependency)
-      RedisMemo::MemoizeQuery.using_active_record?(dependency)
+      unless is_query_cached
+        raise RedisMemo::WithoutMemoization, 'Arel query is not cached using RedisMemo'
+      end
+
+      connection.dependency_of(:exec_query, query, nil, binds)
     end
   end
 end

data/lib/redis_memo/memoizable/invalidation.rb

@@ -127,7 +127,10 @@ module RedisMemo::Memoizable::Invalidation
       begin
         bump_version(task)
       rescue SignalException, Redis::BaseConnectionError,
-             ::ConnectionPool::TimeoutError
+        ::ConnectionPool::TimeoutError => e
+
+        RedisMemo::DefaultOptions.redis_error_handler&.call(e, __method__)
+        RedisMemo::DefaultOptions.logger&.warn(e.full_message)
         retry_queue << task
       end
     end

data/lib/redis_memo/memoize_method.rb

@@ -81,14 +81,88 @@ module RedisMemo::MemoizeMethod
 
   def self.get_or_extract_dependencies(ref, *method_args, &depends_on)
     if RedisMemo::Cache.local_dependency_cache
-      RedisMemo::Cache.local_dependency_cache[ref] ||= {}
-      RedisMemo::Cache.local_dependency_cache[ref][depends_on] ||= {}
-      RedisMemo::Cache.local_dependency_cache[ref][depends_on][method_args] ||= extract_dependencies(ref, *method_args, &depends_on)
+      RedisMemo::Cache.local_dependency_cache[ref.class] ||= {}
+      RedisMemo::Cache.local_dependency_cache[ref.class][depends_on] ||= {}
+      named_args = exclude_anonymous_args(depends_on, ref, method_args)
+      RedisMemo::Cache.local_dependency_cache[ref.class][depends_on][named_args] ||= extract_dependencies(ref, *method_args, &depends_on)
     else
       extract_dependencies(ref, *method_args, &depends_on)
     end
   end
 
+  # We only look at named method parameters in the dependency block in order to define its dependent
+  # memos and ignore anonymous parameters, following the convention that nil or :_ is an anonymous parameter.
+  # Example:
+  # ```
+  #    def method(param1, param2)
+  #    end
+  #
+  #    memoize_method :method do |_, _, param2|`
+  #      depends_on RedisMemo::Memoizable.new(param2: param2)
+  #    end
+  # ```
+  #  `exclude_anonymous_args(depends_on, ref, [1, 2])` returns [2]
+  def self.exclude_anonymous_args(depends_on, ref, args)
+    return [] if depends_on.parameters.empty? or args.empty?
+
+    positional_args = []
+    kwargs = {}
+    depends_on_args = [ref] + args
+    options = depends_on_args.extract_options!
+
+    # Keep track of the splat start index, and the number of positional args before and after the splat,
+    # so we can map which args belong to positional args and which args belong to the splat.
+    named_splat = false
+    splat_index = nil
+    num_positional_args_after_splat = 0
+    num_positional_args_before_splat = 0
+
+    depends_on.parameters.each_with_index do |param, i|
+      # Defined by https://github.com/ruby/ruby/blob/22b8ddfd1049c3fd1e368684c4fd03bceb041b3a/proc.c#L3048-L3059
+      case param.first
+      when :opt, :req
+        if splat_index
+          num_positional_args_after_splat += 1
+        else
+          num_positional_args_before_splat += 1
+        end
+      when :rest
+        named_splat = is_named?(param)
+        splat_index = i
+      when :key, :keyreq
+        kwargs[param.last] = options[param.last] if is_named?(param)
+      when :keyrest
+        kwargs.merge!(options) if is_named?(param)
+      else
+        raise(RedisMemo::ArgumentError, "#{param.first} argument isn't supported in the dependency block")
+      end
+    end
+
+    # Determine the named positional and splat arguments after we know the # of pos. arguments before and after splat
+    after_splat_index = depends_on_args.size - num_positional_args_after_splat
+    depends_on_args.each_with_index do |arg, i|
+      # if the index is within the splat
+      if i >= num_positional_args_before_splat && i < after_splat_index
+        positional_args << arg if named_splat
+      else
+        j = i < num_positional_args_before_splat ? i : i - (after_splat_index - splat_index) - 1
+        positional_args << arg if is_named?(depends_on.parameters[j])
+      end
+    end
+
+    if !kwargs.empty?
+      positional_args + [kwargs]
+    elsif named_splat && !options.empty?
+      positional_args + [options]
+    else
+      positional_args
+    end
+  end
+private
+  def self.is_named?(param)
+    param.size == 2 && param.last != :_
+  end
+
   def self.method_cache_keys(future_contexts)
     memos = Array.new(future_contexts.size)
     future_contexts.each_with_index do |(_, _, dependent_memos), i|

data/lib/redis_memo/memoize_query.rb

@@ -13,6 +13,7 @@ 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_ALL"] == 'true'
       return if ENV["REDIS_MEMO_DISABLE_#{self.table_name.upcase}"] == 'true'
 
       columns = raw_columns.map(&:to_sym).sort

data/lib/redis_memo/memoize_query/cached_select.rb

@@ -111,15 +111,8 @@ class RedisMemo::MemoizeQuery::CachedSelect
           sql.gsub(/(\$\d+)/, '?')      # $1 -> ?
              .gsub(/((, *)*\?)+/, '?')  # (?, ?, ? ...) -> (?)
         end,
-      ) do |_, sql, name, binds, **kwargs|
-        RedisMemo::MemoizeQuery::CachedSelect
-          .current_query_bind_params
-          .params
-          .each do |model, attrs_set|
-            attrs_set.each do |attrs|
-              depends_on model, **attrs
-            end
-          end
+      ) do |_, sql, _, binds, **|
+        depends_on RedisMemo::MemoizeQuery::CachedSelect.current_query_bind_params
 
         depends_on RedisMemo::Memoizable.new(
           __redis_memo_memoize_query_memoize_query_sql__: sql,
@@ -274,9 +267,6 @@ class RedisMemo::MemoizeQuery::CachedSelect
 
       bind_params
     when Arel::Nodes::SelectStatement
-      # No OREDER BY
-      return unless node.orders.empty?
-
       node.cores.each do |core|
         # We don't support JOINs
         return unless core.source.right.empty?
@@ -346,6 +336,11 @@ class RedisMemo::MemoizeQuery::CachedSelect
       end
 
       bind_params
+
+    when Arel::Nodes::NotEqual
+      # We don't cache based on NOT queries (where.not) because it is unbound
+      # but we memoize queries with NOT and other bound queries, so we return the original bind_params
+      return bind_params
     else
       # Not yet supported
       return

data/lib/redis_memo/memoize_query/invalidation.rb

@@ -36,10 +36,8 @@ class RedisMemo::MemoizeQuery::Invalidation
       decrement_counter
       delete_all delete_by
       increment_counter
-      insert insert! insert_all insert_all!
       touch_all
       update_column update_columns update_all update_counters
-      upsert upsert_all
     ).each do |method_name|
       # Example: Model.update_all
       rewrite_default_method(
@@ -58,6 +56,24 @@ class RedisMemo::MemoizeQuery::Invalidation
       )
     end
 
+    %i(
+      insert insert! insert_all insert_all!
+    ).each do |method_name|
+      rewrite_insert_method(
+        model_class,
+        method_name,
+      )
+    end
+
+    %i(
+      upsert upsert_all
+    ).each do |method_name|
+      rewrite_upsert_method(
+        model_class,
+        method_name,
+      )
+    end
+
     %i(
       import import!
     ).each do |method_name|
@@ -70,6 +86,36 @@ class RedisMemo::MemoizeQuery::Invalidation
     model_class.class_variable_set(var_name, true)
   end
 
+  def self.invalidate_new_records(model_class, &blk)
+    current_id = model_class.maximum(model_class.primary_key)
+    result = blk.call
+    records = select_by_new_ids(model_class, current_id)
+    RedisMemo::MemoizeQuery.invalidate(*records) unless records.empty?
+    result
+  end
+
+  def self.invalidate_records_by_conflict_target(model_class, records:, conflict_target: nil, &blk)
+    if conflict_target.nil?
+      # When the conflict_target is not set, we are basically inserting new
+      # records since duplicate rows are simply skipped
+      return invalidate_new_records(model_class, &blk)
+    end
+
+    relation = build_relation_by_conflict_target(model_class, records, conflict_target)
+    # Invalidate records before updating
+    records = select_by_conflict_target_relation(model_class, relation)
+    RedisMemo::MemoizeQuery.invalidate(*records) unless records.empty?
+
+    # Perform updating
+    result = blk.call
+
+    # Invalidate records after updating
+    records = select_by_conflict_target_relation(model_class, relation)
+    RedisMemo::MemoizeQuery.invalidate(*records) unless records.empty?
+
+    result
+  end
+
   private
 
   #
@@ -95,12 +141,48 @@ class RedisMemo::MemoizeQuery::Invalidation
     end
   end
 
-  def self.rewrite_import_method(model_class, method_name)
-    # This optimization to avoid over-invalidation only works on postgres
-    unless ActiveRecord::Base.connection.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
-      rewrite_default_method(model_class, model_class, method_name, class_method: true)
-      return
+  def self.rewrite_insert_method(model_class, method_name)
+    return unless model_class.respond_to?(method_name)
+
+    model_class.singleton_class.class_eval do
+      alias_method :"#{method_name}_without_redis_memo_invalidation", method_name
+
+      define_method method_name do |*args, &blk|
+        RedisMemo::MemoizeQuery::Invalidation.invalidate_new_records(model_class) do
+          send(:"#{method_name}_without_redis_memo_invalidation", *args, &blk)
+        end
+      end
     end
+  end
+
+  def self.rewrite_upsert_method(model_class, method_name)
+    return unless model_class.respond_to?(method_name)
+
+    model_class.singleton_class.class_eval do
+      alias_method :"#{method_name}_without_redis_memo_invalidation", method_name
+
+      define_method method_name do |attributes, unique_by: nil, **kwargs, &blk|
+        RedisMemo::MemoizeQuery::Invalidation.invalidate_records_by_conflict_target(
+          model_class,
+          records: nil, # not used
+          # upsert does not support on_duplicate_key_update yet at activerecord
+          # HEAD (6.1.3)
+          conflict_target: nil,
+        ) do
+          send(
+            :"#{method_name}_without_redis_memo_invalidation",
+            attributes,
+            unique_by: unique_by,
+            **kwargs,
+            &blk
+          )
+        end
+      end
+    end
+  end
+
+  def self.rewrite_import_method(model_class, method_name)
+    return unless model_class.respond_to?(method_name)
 
     model_class.singleton_class.class_eval do
       alias_method :"#{method_name}_without_redis_memo_invalidation", method_name
@@ -110,104 +192,75 @@ 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]
-        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)
-          records.map! { |hash| model_class.new(hash) }
-        end
-
-        # Invalidate the records before and after the import to resolve
-        # - default values filled by the database
-        # - updates on conflict conditions
-        records_to_invalidate =
-          if columns_to_update
-            RedisMemo::MemoizeQuery::Invalidation.send(
-              :select_by_columns,
-              model_class,
-              records,
-              columns_to_update,
-            )
+        on_duplicate_key_update = options[:on_duplicate_key_update]
+        conflict_target =
+          case on_duplicate_key_update
+          when Hash
+            # The conflict_target option is only supported in PostgreSQL. In
+            # MySQL, the primary_key is used as the conflict_target
+            on_duplicate_key_update[:conflict_target] || [model_class.primary_key.to_sym]
+          when Array
+            # The default conflict_target is just the primary_key
+            [model_class.primary_key.to_sym]
           else
-            []
+            # Ignore duplicate rows
+            nil
           end
 
-        result = send(:"#{method_name}_without_redis_memo_invalidation", *args, &blk)
-
-        # 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)
+        if conflict_target && records.last.is_a?(Hash)
+          records.map! { |hash| model_class.new(hash) }
         end
 
-        result
+        RedisMemo::MemoizeQuery::Invalidation.invalidate_records_by_conflict_target(
+          model_class,
+          records: records,
+          conflict_target: conflict_target,
+        ) do
+          send(:"#{method_name}_without_redis_memo_invalidation", *args, &blk)
+        end
       end
     end
   end
 
-  def self.select_by_columns(model_class, records, columns_to_update)
-    return [] if records.empty?
-
+  def self.build_relation_by_conflict_target(model_class, records, conflict_target)
     or_chain = nil
-    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
+    records.each do |record|
+      conditions = {}
+      conflict_target.each do |column|
+        conditions[column] = record.send(column)
       end
-
-      record_count = RedisMemo.without_memo { or_chain.count }
-      if record_count > bulk_operations_invalidation_limit
-        nil
+      if or_chain
+        or_chain = or_chain.or(model_class.where(conditions))
       else
-        RedisMemo.without_memo { or_chain.to_a }
+        or_chain = model_class.where(conditions)
       end
     end
+
+    or_chain
   end
 
-  def self.select_by_id(model_class, ids)
+  def self.select_by_new_ids(model_class, target_id)
     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
+        model_class.where(
+          model_class.arel_table[model_class.primary_key].gt(target_id),
+        ).to_a
       end
     end
   end
 
-  def self.bulk_operations_invalidation_limit
-    ENV['REDIS_MEMO_BULK_OPERATIONS_INVALIDATION_LIMIT']&.to_i ||
-      RedisMemo::DefaultOptions.bulk_operations_invalidation_limit ||
-      10000
+  def self.select_by_conflict_target_relation(model_class, relation)
+    return [] unless relation
+
+    RedisMemo::Tracer.trace(
+      'redis_memo.memoize_query.invalidation',
+      "#{__method__}##{model_class.name}",
+    ) do
+      RedisMemo.without_memo { relation.reload }
+    end
   end
 end

data/lib/redis_memo/middleware.rb

@@ -9,7 +9,9 @@ class RedisMemo::Middleware
     result = nil
 
     RedisMemo::Cache.with_local_cache do
-      result = @app.call(env)
+      RedisMemo.with_max_connection_attempts(ENV['REDIS_MEMO_MAX_ATTEMPTS_PER_REQUEST']&.to_i) do
+        result = @app.call(env)
+      end
     end
     RedisMemo::Memoizable::Invalidation.drain_invalidation_queue
 

data/lib/redis_memo/options.rb

@@ -72,7 +72,6 @@ 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

data/lib/redis_memo/testing.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# Redis memo can be flaky due to transient network errors (e.g. Redis connection errors), or when
+# used with async handlers. This class allows users to override the default redis-memo behavior
+# to be more robust when testing their code that uses redis-memo.
+module RedisMemo
+  class Testing
+
+    def self.__test_mode
+      @__test_mode
+    end
+
+    def self.__test_mode=(mode)
+      @__test_mode = mode
+    end
+
+    def self.enable_test_mode(&blk)
+      __set_test_mode(true, &blk)
+    end
+
+    def self.disable_test_mode(&blk)
+      __set_test_mode(false, &blk)
+    end
+
+    def self.enabled?
+      __test_mode
+    end
+
+    private
+
+    def self.__set_test_mode(mode, &blk)
+      if blk.nil?
+        __test_mode = mode
+      else
+        prev_mode = __test_mode
+        begin
+          __test_mode = mode
+          yield
+        ensure
+          __test_mode = prev_mode
+        end
+      end
+    end
+  end
+
+  module TestOverrides
+    def without_memo?
+      if RedisMemo::Testing.enabled? && !RedisMemo::Memoizable::Invalidation.class_variable_get(:@@invalidation_queue).empty?
+        return true
+      end
+      super
+    end
+  end
+  singleton_class.prepend(TestOverrides)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-memo
 version: !ruby/object:Gem::Version
-  version: 0.0.0.beta.6
+  version: 0.1.4
 platform: ruby
 authors:
 - Chan Zuckerberg Initiative
@@ -192,6 +192,7 @@ files:
 - lib/redis_memo/middleware.rb
 - lib/redis_memo/options.rb
 - lib/redis_memo/redis.rb
+- lib/redis_memo/testing.rb
 - lib/redis_memo/tracer.rb
 homepage: https://github.com/chanzuckerberg/redis-memo
 licenses:
@@ -208,9 +209,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.8
 signing_key: