redis-memo 0.1.1 → 1.1.0

data/lib/redis_memo/memoize_query/cached_select/connection_adapter.rb

@@ -2,7 +2,7 @@
 
 class RedisMemo::MemoizeQuery::CachedSelect
   module ConnectionAdapter
-    def cacheable_query(*args)
+    ruby2_keywords def cacheable_query(*args)
       query, binds = super(*args)
 
       # Persist the arel object to StatementCache#execute
@@ -11,24 +11,33 @@ class RedisMemo::MemoizeQuery::CachedSelect
       [query, binds]
     end
 
-    def exec_query(*args)
+    ruby2_keywords def exec_query(*args)
       # An Arel AST in Thread local is set prior to supported query methods
-      if !RedisMemo.without_memo? &&
+      if !RedisMemo.without_memoization? &&
           RedisMemo::MemoizeQuery::CachedSelect.extract_bind_params(args[0])
+
+        time_start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        ret = super(*args)
+        time_end = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
         # [Reids $model Load] $sql $binds
-        RedisMemo::DefaultOptions.logger&.info(
-          "[Redis] \u001b[36;1m#{args[1]} \u001b[34;1m#{args[0]}\u001b[0m #{
-            args[2].map { |bind| [bind.name, bind.value_for_database]}
-          }"
+        RedisMemo::DefaultOptions.logger&.debug(
+          "[Redis] \u001b[36;1m#{
+            args[1] || 'SQL' # model name
+          } (#{format('%.1f', (time_end - time_start) * 1000.0)}ms)  \u001b[34;1m#{
+            args[0] # sql
+          }\u001b[0m #{
+            args[2].map { |bind| [bind.name, bind.value_for_database] } # binds
+          }",
         )
 
-        super(*args)
+        ret
       else
-        RedisMemo.without_memo { super(*args) }
+        RedisMemo.without_memoization { super(*args) }
       end
     end
 
-    def select_all(*args)
+    ruby2_keywords def select_all(*args)
       if args[0].is_a?(Arel::SelectManager)
         RedisMemo::MemoizeQuery::CachedSelect.current_query = args[0]
       end

data/lib/redis_memo/memoize_query/invalidation.rb

@@ -17,28 +17,29 @@ class RedisMemo::MemoizeQuery::Invalidation
         @redis_memo_class_memoizable ||= RedisMemo::MemoizeQuery.create_memo(self)
       end
 
-      %i(delete decrement! increment!).each do |method_name|
+      %i[delete decrement! increment!].each do |method_name|
         alias_method :"without_redis_memo_invalidation_#{method_name}", method_name
 
         define_method method_name do |*args|
-          result = send(:"without_redis_memo_invalidation_#{method_name}", *args)
+          result = __send__(:"without_redis_memo_invalidation_#{method_name}", *args)
 
           RedisMemo::MemoizeQuery.invalidate(self)
 
           result
         end
+        ruby2_keywords method_name
       end
     end
 
     # Methods that won't trigger model callbacks
     # https://guides.rubyonrails.org/active_record_callbacks.html#skipping-callbacks
-    %i(
+    %i[
       decrement_counter
       delete_all delete_by
       increment_counter
       touch_all
       update_column update_columns update_all update_counters
-    ).each do |method_name|
+    ].each do |method_name|
       # Example: Model.update_all
       rewrite_default_method(
         model_class,
@@ -56,27 +57,27 @@ class RedisMemo::MemoizeQuery::Invalidation
       )
     end
 
-    %i(
+    %i[
       insert insert! insert_all insert_all!
-    ).each do |method_name|
+    ].each do |method_name|
       rewrite_insert_method(
         model_class,
         method_name,
       )
     end
 
-    %i(
+    %i[
       upsert upsert_all
-    ).each do |method_name|
+    ].each do |method_name|
       rewrite_upsert_method(
         model_class,
         method_name,
       )
     end
 
-    %i(
+    %i[
       import import!
-    ).each do |method_name|
+    ].each do |method_name|
       rewrite_import_method(
         model_class,
         method_name,
@@ -116,8 +117,6 @@ class RedisMemo::MemoizeQuery::Invalidation
     result
   end
 
-  private
-
   #
   # There’s no good way to perform fine-grind cache invalidation when
   # operations are bulk update operations such as update_all, and delete_all
@@ -127,17 +126,18 @@ class RedisMemo::MemoizeQuery::Invalidation
   #
   def self.rewrite_default_method(model_class, klass, method_name, class_method:)
     methods = class_method ? :methods : :instance_methods
-    return unless klass.send(methods).include?(method_name)
+    return unless klass.__send__(methods).include?(method_name)
 
     klass = klass.singleton_class if class_method
     klass.class_eval do
       alias_method :"#{method_name}_without_redis_memo_invalidation", method_name
 
       define_method method_name do |*args|
-        result = send(:"#{method_name}_without_redis_memo_invalidation", *args)
+        result = __send__(:"#{method_name}_without_redis_memo_invalidation", *args)
         RedisMemo::MemoizeQuery.invalidate_all(model_class)
         result
       end
+      ruby2_keywords method_name
     end
   end
 
@@ -149,9 +149,10 @@ class RedisMemo::MemoizeQuery::Invalidation
 
       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)
+          __send__(:"#{method_name}_without_redis_memo_invalidation", *args, &blk)
         end
       end
+      ruby2_keywords method_name
     end
   end
 
@@ -169,7 +170,7 @@ class RedisMemo::MemoizeQuery::Invalidation
           # HEAD (6.1.3)
           conflict_target: nil,
         ) do
-          send(
+          __send__(
             :"#{method_name}_without_redis_memo_invalidation",
             attributes,
             unique_by: unique_by,
@@ -216,9 +217,10 @@ class RedisMemo::MemoizeQuery::Invalidation
           records: records,
           conflict_target: conflict_target,
         ) do
-          send(:"#{method_name}_without_redis_memo_invalidation", *args, &blk)
+          __send__(:"#{method_name}_without_redis_memo_invalidation", *args, &blk)
         end
       end
+      ruby2_keywords method_name
     end
   end
 
@@ -228,7 +230,7 @@ class RedisMemo::MemoizeQuery::Invalidation
     records.each do |record|
       conditions = {}
       conflict_target.each do |column|
-        conditions[column] = record.send(column)
+        conditions[column] = record.__send__(column)
       end
       if or_chain
         or_chain = or_chain.or(model_class.where(conditions))
@@ -245,7 +247,7 @@ class RedisMemo::MemoizeQuery::Invalidation
       'redis_memo.memoize_query.invalidation',
       "#{__method__}##{model_class.name}",
     ) do
-      RedisMemo.without_memo do
+      RedisMemo.without_memoization do
         model_class.where(
           model_class.arel_table[model_class.primary_key].gt(target_id),
         ).to_a
@@ -260,7 +262,7 @@ class RedisMemo::MemoizeQuery::Invalidation
       'redis_memo.memoize_query.invalidation',
       "#{__method__}##{model_class.name}",
     ) do
-      RedisMemo.without_memo { relation.reload }
+      RedisMemo.without_memoization { relation.reload }
     end
   end
 end

data/lib/redis_memo/memoize_query/memoize_table_column.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'memoize_method'
 
 module RedisMemo::MemoizeQuery

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,70 @@ class RedisMemo::Options
     redis_error_handler: nil,
     tracer: nil,
     global_cache_key_version: nil,
-    expires_in: nil
+    expires_in: nil,
+    max_connection_attempts: nil,
+    max_query_dependency_size: 5000,
+    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
+    @max_query_dependency_size = ENV['REDIS_MEMO_MAX_QUERY_DEPENDENCY_SIZE']&.to_i || max_query_dependency_size
+    @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 +91,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 +103,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 +120,73 @@ 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
+
+  # Only cache a SQL query when the max number of dependency is smaller or equal to this number. Configurable via an ENV var REDIS_MEMO_MAX_QUERY_DEPENDENCY_SIZE. Default at 5000.
+  attr_accessor :max_query_dependency_size
+
+  # 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,19 +8,19 @@ 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|
           if option.is_a?(Array)
             RedisMemo::Redis::WithReplicas.new(option)
           else
-            option[:logger] ||= RedisMemo::DefaultOptions.logger
             ::Redis.new(option)
           end
         end
       else
-        options[:logger] ||= RedisMemo::DefaultOptions.logger
         [::Redis.new(options)]
       end
 
@@ -30,16 +31,25 @@ 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
       primary_option = options.shift
       @replicas = options.map do |option|
-        option[:logger] ||= RedisMemo::DefaultOptions.logger
         ::Redis.new(option)
       end
 
-      primary_option[:logger] ||= RedisMemo::DefaultOptions.logger
       super(primary_option)
     end