redis-memo 0.0.0.alpha → 0.0.0.beta

data/lib/redis_memo/memoize_records/invalidation.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+class RedisMemo::MemoizeRecords::Invalidation
+  def self.install(model_class)
+    var_name = :@@__redis_memo_memoize_records_invalidation_installed__
+    return if model_class.class_variable_defined?(var_name)
+
+    model_class.class_eval do
+      # A memory-persistent memoizable used for invalidating all queries of a
+      # particular model
+      def self.redis_memo_class_memoizable
+        @redis_memo_class_memoizable ||= RedisMemo::MemoizeRecords.create_memo(self)
+      end
+
+      %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)
+
+          RedisMemo::MemoizeRecords.invalidate(self)
+
+          result
+        end
+      end
+    end
+
+    # Methods that won't trigger model callbacks
+    # https://guides.rubyonrails.org/active_record_callbacks.html#skipping-callbacks
+    %i(
+      import
+      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_bulk_update_method(
+        model_class,
+        model_class,
+        method_name,
+        class_method: true,
+      )
+
+      # Example: Model.where(...).update_all
+      rewrite_bulk_update_method(
+        model_class,
+        model_class.const_get(:ActiveRecord_Relation),
+        method_name,
+        class_method: false,
+      )
+    end
+
+    model_class.class_variable_set(var_name, true)
+  end
+
+  private
+
+  #
+  # There’s no good way to perform fine-grind cache invalidation when operations
+  # are bulk update operations such as import, update_all, and destroy_all:
+  # Performing fine-grind cache invalidation would require the applications to
+  # fetch additional data from the database, which might lead to performance
+  # degradation. Thus we simply invalidate all existing cached records after each
+  # bulk_updates.
+  #
+  def self.rewrite_bulk_update_method(model_class, klass, method_name, class_method:)
+    methods = class_method ? :methods : :instance_methods
+    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)
+        RedisMemo::MemoizeRecords.invalidate_all(model_class)
+        result
+      end
+    end
+  end
+end

data/lib/redis_memo/memoize_records/model_callback.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class RedisMemo::MemoizeRecords::ModelCallback
+  def self.install(model_class)
+    var_name = :@@__redis_memo_memoize_record_after_save_callback_installed__
+    return if model_class.class_variable_defined?(var_name)
+
+    model_class.after_save(new)
+    model_class.after_destroy(new)
+
+    model_class.class_variable_set(var_name, true)
+  end
+
+  def after_save(record)
+    RedisMemo::MemoizeRecords.invalidate(record)
+  end
+
+  def after_destroy(record)
+    RedisMemo::MemoizeRecords.invalidate(record)
+  end
+end

data/lib/redis_memo/middleware.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class RedisMemo::Middleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    result = nil
+
+    RedisMemo::Cache.with_local_cache do
+      result = @app.call(env)
+    end
+    RedisMemo::Memoizable::Invalidation.drain_invalidation_queue
+
+    result
+  end
+end

data/lib/redis_memo/options.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+class RedisMemo::Options
+  def initialize(
+    async: nil,
+    compress: nil,
+    compress_threshold: nil,
+    redis: nil,
+    redis_error_handler: nil,
+    tracer: nil,
+    global_cache_key_version: nil,
+    expires_in: nil
+  )
+    @compress = compress.nil? ? true : compress
+    @compress_threshold = compress_threshold || 1.kilobyte
+    @redis = redis
+    @redis_client = nil
+    @redis_error_handler = redis_error_handler
+    @tracer = tracer
+    @logger = logger
+    @global_cache_key_version = global_cache_key_version
+    @expires_in = expires_in
+  end
+
+  def redis(&blk)
+    if blk.nil?
+      return @redis_client if @redis_client.is_a?(RedisMemo::Redis)
+
+      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
+  end
+
+  def tracer(&blk)
+    if blk.nil?
+      return @tracer if @tracer.respond_to?(:trace)
+
+      @tracer&.call
+    else
+      @tracer = blk
+    end
+  end
+
+  def logger(&blk)
+    if blk.nil?
+      return @logger if @logger.respond_to?(:warn)
+
+      @logger&.call
+    else
+      @logger = blk
+    end
+  end
+
+  def global_cache_key_version(&blk)
+    # this method takes a block to be consistent with the inline memo_method
+    # API
+    if blk.nil?
+      if !@global_cache_key_version.respond_to?(:call)
+        return @global_cache_key_version
+      end
+
+      @global_cache_key_version&.call
+    else
+      # save the global cache_key_version eagerly
+      @global_cache_key_version = blk
+    end
+  end
+
+  attr_accessor :async
+  attr_accessor :compress
+  attr_accessor :compress_threshold
+  attr_accessor :redis_error_handler
+  attr_accessor :expires_in
+  attr_accessor :cache_validation_sampler
+  attr_accessor :cache_out_of_date_handler
+
+  attr_writer :global_cache_key_version
+  attr_writer :redis
+  attr_writer :tracer
+  attr_writer :logger
+end

data/lib/redis_memo/redis.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+require 'redis'
+require 'redis/distributed'
+
+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={})
+    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
+
+    # Pass in our own hash ring to use the clients with multi-read-replica
+    # support
+    hash_ring = Redis::HashRing.new(clients)
+
+    super([], ring: hash_ring)
+  end
+
+  class WithReplicas < ::Redis
+    def initialize(options)
+      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
+
+    alias_method :get_primary, :get
+    alias_method :mget_primary, :mget
+    alias_method :mapped_mget_primary, :mapped_mget
+
+    def get(key)
+      return get_primary(key) if @replicas.empty?
+
+      @replicas.sample(1).first.get(key)
+    end
+
+    def mget(*keys, &blk)
+      return mget_primary(*keys, &blk) if @replicas.empty?
+
+      @replicas.sample(1).first.mget(*keys)
+    end
+
+    def mapped_mget(*keys)
+      return mapped_mget_primary(*keys) if @replicas.empty?
+
+      @replicas.sample(1).first.mapped_mget(*keys)
+    end
+  end
+end

data/lib/redis_memo/tracer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require_relative 'options'
+
+class RedisMemo::Tracer
+  def self.trace(span_name, method_id, &blk)
+    tracer = RedisMemo::DefaultOptions.tracer
+    return blk.call if tracer.nil?
+
+    tracer.trace(span_name, resource: method_id, service: 'redis_memo') do
+      blk.call
+    end
+  end
+
+  def self.set_tag(cache_hit:)
+    tracer = RedisMemo::DefaultOptions.tracer
+    return if tracer.nil? || !tracer.respond_to?(:active_span)
+
+    active_span = tracer.active_span
+    return if !active_span.respond_to?(:set_tag)
+
+    active_span.set_tag('cache_hit', cache_hit)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-memo
 version: !ruby/object:Gem::Version
-  version: 0.0.0.alpha
+  version: 0.0.0.beta
 platform: ruby
 authors:
 - Chan Zuckerberg Initiative
@@ -10,6 +10,20 @@ bindir: bin
 cert_chain: []
 date: 2020-10-31 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  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
@@ -25,35 +39,63 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '4'
 - !ruby/object:Gem::Dependency
-  name: sorbet
+  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
+  name: codecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.4704
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.4704
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: sorbet-static
+  name: database_cleaner-active_record
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.4704
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.4704
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: codecov
+  name: pg
+  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: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -100,7 +142,25 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/redis-memo.rb
 - lib/redis_memo.rb
+- lib/redis_memo/after_commit.rb
+- lib/redis_memo/batch.rb
+- lib/redis_memo/cache.rb
+- lib/redis_memo/future.rb
+- lib/redis_memo/memoizable.rb
+- lib/redis_memo/memoizable/dependency.rb
+- lib/redis_memo/memoizable/invalidation.rb
+- lib/redis_memo/memoize_method.rb
+- lib/redis_memo/memoize_method.rbi
+- lib/redis_memo/memoize_records.rb
+- lib/redis_memo/memoize_records/cached_select.rb
+- lib/redis_memo/memoize_records/invalidation.rb
+- lib/redis_memo/memoize_records/model_callback.rb
+- lib/redis_memo/middleware.rb
+- lib/redis_memo/options.rb
+- lib/redis_memo/redis.rb
+- lib/redis_memo/tracer.rb
 homepage: https://github.com/chanzuckerberg/redis-memo
 licenses:
 - MIT
@@ -120,9 +180,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
-summary: Redis based memoization
+summary: A Redis-based version-addressable caching system. Memoize pure functions,
+  aggregated database queries, and 3rd party API calls.
 test_files: []