redis-memo 0.1.0 → 1.0.0

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(RedisMemo::DefaultOptions.max_connection_attempts) do
+        result = @app.call(env)
+      end
     end
     RedisMemo::Memoizable::Invalidation.drain_invalidation_queue
 

data/lib/redis_memo/options.rb

@@ -1,5 +1,13 @@
 # frozen_string_literal: true
 
+##
+# This class allows users to configure various RedisMemo options. Options can be set in
+# your initializer +config/initializers/redis_memo.rb+
+#   RedisMemo.configure do |config|
+#     config.expires_in = 3.hours
+#     config.global_cache_key_version = SecureRandom.uuid
+#   end
+#
 class RedisMemo::Options
   def initialize(
     async: nil,
@@ -9,33 +17,68 @@ class RedisMemo::Options
     redis_error_handler: nil,
     tracer: nil,
     global_cache_key_version: nil,
-    expires_in: nil
+    expires_in: nil,
+    max_connection_attempts: nil,
+    disable_all: false,
+    disable_cached_select: false,
+    disabled_models: Set.new
   )
+    @async = async
     @compress = compress.nil? ? true : compress
     @compress_threshold = compress_threshold || 1.kilobyte
     @redis_config = redis
-    @redis_client = nil
+    @redis = nil
     @redis_error_handler = redis_error_handler
     @tracer = tracer
     @logger = logger
     @global_cache_key_version = global_cache_key_version
     @expires_in = expires_in
+    @max_connection_attempts = ENV['REDIS_MEMO_MAX_ATTEMPTS_PER_REQUEST']&.to_i || max_connection_attempts
+    @disable_all = ENV['REDIS_MEMO_DISABLE_ALL'] == 'true' || disable_all
+    @disable_cached_select = ENV['REDIS_MEMO_DISABLE_CACHED_SELECT'] == 'true' || disable_cached_select
+    @disabled_models = disabled_models
   end
 
+  # Retrieves the redis client, initializing it if it does not exist yet.
   def redis
-    @redis_client ||= RedisMemo::Redis.new(redis_config)
+    @redis ||= RedisMemo::Redis.new(redis_config)
   end
 
+  # Retrieves the config values used to initialize the Redis client.
   def redis_config
     @redis_config || {}
   end
 
+  # Set configuration values to pass to the Redis client. If multiple configurations are passed
+  # to this method, we assume that the first config corresponds to the primary node, and subsequent
+  # configurations correspond to replica nodes.
+  #
+  # For example, if your urls are specified as <tt><url>,<url>...;<url>,...;...,</tt> where <tt>;</tt> delimits
+  # different clusters and <tt>,</tt> delimits primary and read replicas, then in your configuration:
+  #
+  #   RedisMemo.configure do |config|
+  #     config.redis = redis_urls.split(';').map do |urls|
+  #       urls.split(',').map do |url|
+  #         {
+  #           url: url,
+  #           # All timeout values are specified in seconds
+  #           connect_timeout: ENV['REDIS_MEMO_CONNECT_TIMEOUT']&.to_f || 0.2,
+  #           read_timeout: ENV['REDIS_MEMO_READ_TIMEOUT']&.to_f || 0.5,
+  #           write_timeout: ENV['REDIS_MEMO_WRITE_TIMEOUT']&.to_f || 0.5,
+  #           reconnect_attempts: ENV['REDIS_MEMO_RECONNECT_ATTEMPTS']&.to_i || 0
+  #         }
+  #       end
+  #     end
+  #   end
+  #
   def redis=(config)
     @redis_config = config
-    @redis_client = nil
+    @redis = nil
     redis
   end
 
+  # Sets the tracer object. Allows the tracer to be dynamically determined at
+  # runtime if a blk is given.
   def tracer(&blk)
     if blk.nil?
       return @tracer if @tracer.respond_to?(:trace)
@@ -46,6 +89,8 @@ class RedisMemo::Options
     end
   end
 
+  # Sets the logger object in RedisMemo. Allows the logger to be dynamically
+  # determined at runtime if a blk is given.
   def logger(&blk)
     if blk.nil?
       return @logger if @logger.respond_to?(:warn)
@@ -56,6 +101,8 @@ class RedisMemo::Options
     end
   end
 
+  # Sets the global cache key version. Allows the logger to be dynamically
+  # determined at runtime if a blk is given.
   def global_cache_key_version(&blk)
     # this method takes a block to be consistent with the inline memo_method
     # API
@@ -71,16 +118,70 @@ class RedisMemo::Options
     end
   end
 
+  # Disables the model for caching and invalidation
+  def disable_model(model)
+    @disabled_models << model
+  end
+
+  # Checks if a model is disabled for redis memo caching
+  def model_disabled_for_caching?(model)
+    ENV["REDIS_MEMO_DISABLE_#{model.table_name.upcase}"] == 'true' || @disabled_models.include?(model)
+  end
+
+  # A handler used to asynchronously perform cache writes and invalidations. If no value is provided,
+  # RedisMemo will perform these operations synchronously.
   attr_accessor :async
+
+  # Specify the global sampled percentage of the chance to call the cache validation, a value between 0 to 100, when the value
+  # is 100, it will call the handler every time the cached result does not match the uncached result
+  # You can also specify inline cache validation sample percentage by memoize_method :method, cache_validation_sample_percentage: #{value}
+  attr_accessor :cache_validation_sample_percentage
+
+  # Handler called when the cached result does not match the uncached result (sampled at the
+  # `cache_validation_sample_percentage`). This might indicate that invalidation is happening too slowly or
+  # that there are incorrect dependencies specified on a cached method.
   attr_accessor :cache_out_of_date_handler
-  attr_accessor :cache_validation_sampler
+
+  # Passed along to the Rails {RedisCacheStore}[https://api.rubyonrails.org/classes/ActiveSupport/Cache/RedisCacheStore.html], determines whether or not to compress entries before storing
+  # them. default: `true`
   attr_accessor :compress
+
+  # Passed along to the Rails {RedisCacheStore}[https://api.rubyonrails.org/classes/ActiveSupport/Cache/RedisCacheStore.html], the size threshold for which to compress cached entries.
+  # default: 1.kilobyte
   attr_accessor :compress_threshold
+
+  # Configuration values for connecting to RedisMemo using a connection pool. It's recommended to use a
+  # connection pool in multi-threaded applications, or when an async handler is set.
   attr_accessor :connection_pool
+
+  # Passed along to the Rails {RedisCacheStore}[https://api.rubyonrails.org/classes/ActiveSupport/Cache/RedisCacheStore.html], sets the TTL on cache entries in Redis.
   attr_accessor :expires_in
+
+  # The max number of failed connection attempts RedisMemo will make for a single request before bypassing
+  # the caching layer. This helps make RedisMemo resilient to errors and performance issues when there's
+  # an issue with the Redis cluster itself.
+  attr_accessor :max_connection_attempts
+
+  # Passed along to the Rails {RedisCacheStore}[https://api.rubyonrails.org/classes/ActiveSupport/Cache/RedisCacheStore.html], the error handler called for Redis related errors.
   attr_accessor :redis_error_handler
 
+  # A global kill switch to disable all RedisMemo operations.
+  attr_accessor :disable_all
+
+  # A kill switch to disable RedisMemo caching on database queries. This does not disable the invalidation
+  # after_save hooks that are installed on memoized models.
+  attr_accessor :disable_cached_select
+
+  # A kill switch to set the list of models to disable caching and invalidation after_save hooks on.
+  attr_accessor :disabled_models
+
+  # A global cache key version prepended to each cached entry. For example, the commit hash of the current
+  # version deployed to your application.
   attr_writer :global_cache_key_version
+
+  # Object used to trace RedisMemo operations to collect latency and error metrics, e.g. `Datadog.tracer`
   attr_writer :tracer
+
+  # Object used to log RedisMemo operations.
   attr_writer :logger
 end

data/lib/redis_memo/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class RedisMemo::Railtie < Rails::Railtie
+  initializer 'request_store.insert_middleware' do |app|
+    if ActionDispatch.const_defined? :RequestId
+      app.config.middleware.insert_after ActionDispatch::RequestId, RedisMemo::Middleware
+    else
+      app.config.middleware.insert_after Rack::MethodOverride, RedisMemo::Middleware
+    end
+  end
+end

data/lib/redis_memo/redis.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'redis'
 require 'redis/distributed'
 
@@ -7,7 +8,9 @@ require_relative 'options'
 # Redis::Distributed does not support reading from multiple read replicas. This
 # class adds this functionality
 class RedisMemo::Redis < Redis::Distributed
-  def initialize(options={})
+  def initialize(
+    options = {} # rubocop: disable Style/OptionHash
+  )
     clients =
       if options.is_a?(Array)
         options.map do |option|
@@ -30,6 +33,17 @@ class RedisMemo::Redis < Redis::Distributed
     super([], ring: hash_ring)
   end
 
+  def run_script(script_content, script_sha, *args)
+    begin
+      return evalsha(script_sha, *args) if script_sha
+    rescue Redis::CommandError => error
+      if error.message != 'NOSCRIPT No matching script. Please use EVAL.'
+        raise error
+      end
+    end
+    eval(script_content, *args) # rubocop: disable Security/Eval
+  end
+
   class WithReplicas < ::Redis
     def initialize(orig_options)
       options = orig_options.dup

data/lib/redis_memo/testing.rb

@@ -0,0 +1,49 @@
+# 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
+    class << self
+      attr_accessor :__test_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
+
+    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_memoization?
+      if RedisMemo::Testing.enabled? && !RedisMemo::Memoizable::Invalidation.class_variable_get(:@@invalidation_queue).empty?
+        return true
+      end
+
+      super
+    end
+  end
+  singleton_class.prepend(TestOverrides)
+end

data/lib/redis_memo/thread_local_var.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RedisMemo::ThreadLocalVar
+  def self.define(var_name) # :nodoc:
+    thread_key = :"__redis_memo_#{var_name}__"
+    const_set(var_name.to_s.upcase, thread_key)
+
+    define_singleton_method var_name do
+      Thread.current[thread_key]
+    end
+
+    define_singleton_method "#{var_name}=" do |var_val|
+      Thread.current[thread_key] = var_val
+    end
+  end
+end

data/lib/redis_memo/tracer.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'options'
 
 class RedisMemo::Tracer

data/lib/redis_memo/util.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RedisMemo::Util
+  def self.checksum(serialized)
+    Digest::SHA1.base64digest(serialized)
+  end
+
+  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
+
+  def self.uuid
+    SecureRandom.uuid
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-memo
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Chan Zuckerberg Initiative
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5.2'
+- !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: redis
   requirement: !ruby/object:Gem::Requirement
@@ -39,19 +53,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 4.0.1
 - !ruby/object:Gem::Dependency
-  name: connection_pool
+  name: ruby2_keywords
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.3
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.3
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -122,6 +136,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  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
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +178,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -176,8 +246,10 @@ files:
 - lib/redis_memo/batch.rb
 - lib/redis_memo/cache.rb
 - lib/redis_memo/connection_pool.rb
+- lib/redis_memo/errors.rb
 - lib/redis_memo/future.rb
 - lib/redis_memo/memoizable.rb
+- lib/redis_memo/memoizable/bump_version.lua
 - lib/redis_memo/memoizable/dependency.rb
 - lib/redis_memo/memoizable/invalidation.rb
 - lib/redis_memo/memoize_method.rb
@@ -191,8 +263,12 @@ files:
 - lib/redis_memo/memoize_query/model_callback.rb
 - lib/redis_memo/middleware.rb
 - lib/redis_memo/options.rb
+- lib/redis_memo/railtie.rb
 - lib/redis_memo/redis.rb
+- lib/redis_memo/testing.rb
+- lib/redis_memo/thread_local_var.rb
 - lib/redis_memo/tracer.rb
+- lib/redis_memo/util.rb
 homepage: https://github.com/chanzuckerberg/redis-memo
 licenses:
 - MIT