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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 185b376e32235db7e679da783c652f4bb891afa70c771a32052211a3a1269164
-  data.tar.gz: 00fe077bfe4615f8b96a0b0cb9510c48e5b4b9e5419ae1db0ce1ca4c2ccadbc1
+  metadata.gz: 72bcf0679b811825222a6b38de0fcdadf4546640d2f61b18ebc827e37137dc41
+  data.tar.gz: 7a55c7bbd084a24afe085e85bc5cd5c486cf240094b64ca09d48e9e0ce126384
 SHA512:
-  metadata.gz: 87ec80320f71c9fe2eebd6f10acb86904feb0e400b66a9197a6374d54c47c31b45cf09a938dcff12aa5a50f631028e4f55a4390549f5f11a324aabcdef5fe28c
-  data.tar.gz: ef51e78a7774686fb278ae122029ed24908dcaa5df936d05394ad364cb64fb99675f74e03843b6694d91d1c8c02f0ab8fc8ff638c79123701809e65224f5cd49
+  metadata.gz: 5a3af887512e4b6571829fcfda719e43abb917eb4773407bd27788b0b671a42263ec31c2f6286f0a1279a354851c8c8cb48eb9701cba59863e500ca47419080e
+  data.tar.gz: feeb72b177ec07953b839e6e0759cbdf42dfd4eddd19f89599e721589462e849e7685a659b03128504d670764223f1805402cb3ee8a96411b834f229ba837d99

data/lib/redis-memo.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Automatically require the main file of the redis-memo gem when adding it to
+# the Gemfile
+require_relative 'redis_memo'

data/lib/redis_memo.rb

@@ -1,6 +1,101 @@
 # frozen_string_literal: true
 
-# typed: true
+require 'active_support/all'
+require 'digest'
+require 'json'
+require 'securerandom'
 
 module RedisMemo
+  require 'redis_memo/memoize_method'
+  require 'redis_memo/memoize_query'
+
+  # A process-level +RedisMemo::Options+ instance that stores the global
+  # options. This object can be modified by +RedisMemo.configure+.
+  #
+  # +memoize_method+ allows users to provide method-level configuration.
+  # When no callsite-level configuration specified we will use the values in
+  # +DefaultOptions+ as the default value.
+  DefaultOptions = RedisMemo::Options.new
+
+  # @todo Move thread keys to +RedisMemo::ThreadKey+
+  THREAD_KEY_WITHOUT_MEMO = :__redis_memo_without_memo__
+
+  # Configure global-level default options. Those options will be used unless
+  # some options specified at +memoize_method+ callsite level. See
+  # +RedisMemo::Options+ for all the possible options.
+  #
+  # @yieldparam [RedisMemo::Options] default_options
+  # +RedisMemo::DefaultOptions+
+  # @return [void]
+  def self.configure(&blk)
+    blk.call(DefaultOptions)
+  end
+
+  # Batch Redis calls triggered by +memoize_method+ to minimize the round trips
+  # to Redis.
+  # - Batches cannot be nested
+  # - When a batch is still open (while still in the +RedisMemo.batch+ block)
+  # the return value of any memoized method is a +RedisMemo::Future+ instead of
+  # the actual method value
+  # - The actual method values are returned as a list, in the same order as
+  # invoking, after exiting the block
+  #
+  # @example
+  #   results = RedisMemo.batch do
+  #     5.times { |i| memoized_calculation(i) }
+  #     nil # Not the return value of the block
+  #   end
+  #   results.size == 5 # true
+  #
+  # See +RedisMemo::Batch+ for more information.
+  def self.batch(&blk)
+    RedisMemo::Batch.open
+    blk.call
+    RedisMemo::Batch.execute
+  ensure
+    RedisMemo::Batch.close
+  end
+
+  # @todo Move this method out of the top namespace
+  def self.checksum(serialized)
+    Digest::SHA1.base64digest(serialized)
+  end
+
+  # @todo Move this method out of the top namespace
+  def self.uuid
+    SecureRandom.uuid
+  end
+
+  # @todo Move this method out of the top namespace
+  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
+
+  # Whether the current execution context has been configured to skip
+  # memoization and use the uncached code path.
+  #
+  # @return [Boolean]
+  def self.without_memo?
+    Thread.current[THREAD_KEY_WITHOUT_MEMO] == true
+  end
+
+  # Configure the wrapped code in the block to skip memoization.
+  #
+  # @yield [] no_args The block of code to skip memoization.
+  def self.without_memo
+    prev_value = Thread.current[THREAD_KEY_WITHOUT_MEMO]
+    Thread.current[THREAD_KEY_WITHOUT_MEMO] = true
+    yield
+  ensure
+    Thread.current[THREAD_KEY_WITHOUT_MEMO] = prev_value
+  end
+
+  # @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/after_commit.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+# TODO: -> RedisMemo::Memoizable::AfterCommit
+
+class RedisMemo::AfterCommit
+  # We assume there's only one ActiveRecord DB connection used for opening
+  # transactions
+  @@callback_added = false
+  @@pending_memo_versions = {}
+  @@previous_memo_versions = {}
+
+  def self.connection
+    ActiveRecord::Base.connection
+  end
+
+  def self.pending_memo_versions
+    # In DB transactions, the pending memo version should be used immediately
+    # as part of method checksums. method_cache_keys made of
+    # pending_memo_versions are not referencable until we bump the
+    # pending_memo_versions after commiting the current transaction
+    @@pending_memo_versions
+  end
+
+  def self.bump_memo_version_after_commit(key, version, previous_version:)
+    @@pending_memo_versions[key] = version
+    @@previous_memo_versions[key] = previous_version
+
+    reset_after_transaction
+  end
+
+  # https://github.com/Envek/after_commit_everywhere/blob/be8602f9fbb8e40b0fc8a04a47e4c2bc6b560ad5/lib/after_commit_everywhere.rb#L93
+  # Helper method to determine whether we're currently in transaction or not
+  def self.in_transaction?
+    # service transactions (tests and database_cleaner) are not joinable
+    connection.transaction_open? && connection.current_transaction.joinable?
+  end
+
+  private
+
+  def self.after_commit(&blk)
+    connection.add_transaction_record(
+      RedisMemo::AfterCommit::Callback.new(connection, committed: blk),
+    )
+  end
+
+  def self.after_rollback(&blk)
+    connection.add_transaction_record(
+      RedisMemo::AfterCommit::Callback.new(connection, rolledback: blk),
+    )
+  end
+
+  def self.reset_after_transaction
+    return if @@callback_added
+    @@callback_added = true
+
+    after_commit do
+      reset(commited: true)
+    end
+
+    after_rollback do
+      reset(commited: false)
+    end
+  end
+
+  def self.reset(commited:)
+    if commited
+      @@pending_memo_versions.each do |key, version|
+        invalidation_queue =
+          RedisMemo::Memoizable::Invalidation.class_variable_get(:@@invalidation_queue)
+
+        invalidation_queue << RedisMemo::Memoizable::Invalidation::Task.new(
+          key,
+          version,
+          @@previous_memo_versions[key],
+        )
+      end
+
+      RedisMemo::Memoizable::Invalidation.drain_invalidation_queue
+    else
+      @@pending_memo_versions.each_key do |key|
+        RedisMemo::Cache.local_cache&.delete(key)
+      end
+    end
+    @@callback_added = false
+    @@pending_memo_versions.clear
+    @@previous_memo_versions.clear
+  end
+
+  # https://github.com/Envek/after_commit_everywhere/blob/master/lib/after_commit_everywhere/wrap.rb
+  class Callback
+    def initialize(connection, committed: nil, rolledback: nil)
+      @connection = connection
+      @committed = committed
+      @rolledback = rolledback
+    end
+
+    def has_transactional_callbacks?
+      true
+    end
+
+    def trigger_transactional_callbacks?
+      true
+    end
+
+    def committed!(*)
+      @committed&.call
+    end
+
+    # Required for +transaction(requires_new: true)+
+    def add_to_transaction(*)
+      @connection.add_transaction_record(self)
+    end
+
+    def before_committed!(*); end
+
+    def rolledback!(*)
+      @rolledback&.call
+    end
+  end
+end

data/lib/redis_memo/batch.rb

@@ -0,0 +1,54 @@
+ # frozen_string_literal: true
+require_relative 'cache'
+require_relative 'tracer'
+
+class RedisMemo::Batch
+  THREAD_KEY = :__redis_memo_current_batch__
+
+  def self.open
+    if current
+      raise RedisMemo::RuntimeError, 'Batch can not be nested'
+    end
+
+    Thread.current[THREAD_KEY] = []
+  end
+
+  def self.close
+    if current
+      futures = current
+      Thread.current[THREAD_KEY] = nil
+      futures
+    end
+  end
+
+  def self.current
+    Thread.current[THREAD_KEY]
+  end
+
+  def self.execute
+    futures = close
+    return unless futures
+
+    cached_results = {}
+    method_cache_keys = nil
+
+    RedisMemo::Tracer.trace('redis_memo.cache.batch.read', nil) do
+      method_cache_keys = RedisMemo::MemoizeMethod.method_cache_keys(
+        futures.map(&:context),
+      )
+
+      if method_cache_keys
+        cached_results = RedisMemo::Cache.read_multi(*method_cache_keys)
+      end
+    end
+
+    RedisMemo::Tracer.trace('redis_memo.cache.batch.execute', nil) do
+      results = Array.new(futures.size)
+      futures.each_with_index do |future, i|
+        future.method_cache_key = method_cache_keys ? method_cache_keys[i] : ''
+        results[i] = future.execute(cached_results)
+      end
+      results
+    end
+  end
+end

data/lib/redis_memo/cache.rb

@@ -0,0 +1,108 @@
+ # frozen_string_literal: true
+require_relative 'options'
+require_relative 'redis'
+require_relative 'connection_pool'
+
+class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
+  class Rescuable < Exception; end
+
+  THREAD_KEY_LOCAL_CACHE            = :__redis_memo_cache_local_cache__
+  THREAD_KEY_LOCAL_DEPENDENCY_CACHE = :__redis_memo_local_cache_dependency_cache__
+  THREAD_KEY_RAISE_ERROR            = :__redis_memo_cache_raise_error__
+
+  @@redis = nil
+  @@redis_store = nil
+
+  @@redis_store_error_handler = proc do |method:, exception:, returning:|
+    RedisMemo::DefaultOptions.redis_error_handler&.call(exception, method)
+    RedisMemo::DefaultOptions.logger&.warn(exception.full_message)
+
+    if Thread.current[THREAD_KEY_RAISE_ERROR]
+      raise RedisMemo::Cache::Rescuable
+    else
+      returning
+    end
+  end
+
+  def self.redis
+    @@redis ||=
+      if RedisMemo::DefaultOptions.connection_pool
+        RedisMemo::ConnectionPool.new(**RedisMemo::DefaultOptions.connection_pool)
+      else
+        RedisMemo::DefaultOptions.redis
+      end
+  end
+
+  def self.redis_store
+    @@redis_store ||= new(
+      compress: RedisMemo::DefaultOptions.compress,
+      compress_threshold: RedisMemo::DefaultOptions.compress_threshold,
+      error_handler: @@redis_store_error_handler,
+      expires_in: RedisMemo::DefaultOptions.expires_in,
+      redis: redis,
+    )
+  end
+
+  # We use our own local_cache instead of the one from RedisCacheStore, because
+  # the local_cache in RedisCacheStore stores a dumped
+  # ActiveSupport::Cache::Entry object -- which is slower comparing to a simple
+  # hash storing object references
+  def self.local_cache
+    Thread.current[THREAD_KEY_LOCAL_CACHE]
+  end
+
+  def self.local_dependency_cache
+    Thread.current[THREAD_KEY_LOCAL_DEPENDENCY_CACHE]
+  end
+
+  class << self
+    def with_local_cache(&blk)
+      Thread.current[THREAD_KEY_LOCAL_CACHE] = {}
+      Thread.current[THREAD_KEY_LOCAL_DEPENDENCY_CACHE] = {}
+      blk.call
+    ensure
+      Thread.current[THREAD_KEY_LOCAL_CACHE] = nil
+      Thread.current[THREAD_KEY_LOCAL_DEPENDENCY_CACHE] = nil
+    end
+
+    # RedisCacheStore doesn't read from the local cache before reading from redis
+    def read_multi(*keys, raw: false, raise_error: false)
+      return {} if keys.empty?
+
+      Thread.current[THREAD_KEY_RAISE_ERROR] = raise_error
+
+      local_entries = local_cache&.slice(*keys) || {}
+
+      keys_to_fetch = keys
+      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, raw: raw)
+      local_cache&.merge!(remote_entries)
+
+      if local_entries.empty?
+        remote_entries
+      else
+        local_entries.merge!(remote_entries)
+      end
+    end
+
+    def write(key, value, disable_async: false, raise_error: false, **options)
+      Thread.current[THREAD_KEY_RAISE_ERROR] = raise_error
+
+      if local_cache
+        local_cache[key] = value
+      end
+
+      async = RedisMemo::DefaultOptions.async
+      if async.nil? || disable_async
+        redis_store.write(key, value, **options)
+      else
+        async.call do
+          Thread.current[THREAD_KEY_RAISE_ERROR] = raise_error
+          redis_store.write(key, value, **options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+require_relative 'cache'
+require_relative 'tracer'
+
+class RedisMemo::Future
+  attr_writer :method_cache_key
+
+  def initialize(
+    ref,
+    method_id,
+    method_args,
+    dependent_memos,
+    cache_options,
+    method_name_without_memo
+  )
+    @ref = ref
+    @method_id = method_id
+    @method_args = method_args
+    @dependent_memos = dependent_memos
+    @cache_options = cache_options
+    @method_name_without_memo = method_name_without_memo
+    @method_cache_key = nil
+    @cache_hit = false
+    @cached_result = nil
+    @computed_cached_result = false
+    @fresh_result = nil
+    @computed_fresh_result = false
+  end
+
+  def context
+    [@method_id, @method_args, @dependent_memos]
+  end
+
+  def method_cache_key
+    @method_cache_key ||=
+      RedisMemo::MemoizeMethod.method_cache_keys([context])&.first || ''
+  end
+
+  def execute(cached_results=nil)
+    if RedisMemo::Batch.current
+      raise RedisMemo::RuntimeError, 'Cannot execute future when a batch is still open'
+    end
+
+    if cache_hit?(cached_results)
+      validate_cache_result =
+        RedisMemo::DefaultOptions.cache_validation_sampler&.call(@method_id)
+
+      if validate_cache_result && cached_result != fresh_result
+        RedisMemo::DefaultOptions.cache_out_of_date_handler&.call(
+          @ref,
+          @method_id,
+          @method_args,
+          cached_result,
+          fresh_result,
+        )
+        return fresh_result
+      end
+
+      return cached_result
+    end
+
+    fresh_result
+  end
+
+  def result
+    unless @computed_cached_result
+      raise RedisMemo::RuntimeError, 'Future has not been executed'
+    end
+
+    @fresh_result || @cached_result
+  end
+
+  private
+
+  def cache_hit?(cached_results=nil)
+    cached_result(cached_results)
+
+    @cache_hit
+  end
+
+  def cached_result(cached_results=nil)
+    return @cached_result if @computed_cached_result
+
+    @cache_hit = false
+    RedisMemo::Tracer.trace('redis_memo.cache.read', @method_id) do
+      # Calculate the method_cache_key now, or use the method_cache_key obtained
+      # from batching previously
+      if !method_cache_key.empty?
+        cached_results ||= RedisMemo::Cache.read_multi(method_cache_key)
+        @cache_hit = cached_results.include?(method_cache_key)
+        @cached_result = cached_results[method_cache_key]
+      end
+      RedisMemo::Tracer.set_tag(cache_hit: @cache_hit)
+    end
+
+    @computed_cached_result = true
+    @cached_result
+  end
+
+  def fresh_result
+    return @fresh_result if @computed_fresh_result
+
+    RedisMemo::Tracer.trace('redis_memo.cache.write', @method_id) do
+      # cache miss
+      @fresh_result = @ref.send(@method_name_without_memo, *@method_args)
+      if @cache_options.include?(:expires_in) && @cache_options[:expires_in].respond_to?(:call)
+        @cache_options[:expires_in] = @cache_options[:expires_in].call(@fresh_result)
+      end
+
+      if !method_cache_key.empty? && (
+          # Write back fresh result if cache miss
+          !@cache_hit || (
+            # or cached result is out of date (sampled to validate the cache
+            # result)
+            @cache_hit && @cached_result != @fresh_result
+          )
+      )
+        RedisMemo::Cache.write(method_cache_key, @fresh_result, **@cache_options)
+      end
+    end
+
+    @computed_fresh_result = true
+    @fresh_result
+  end
+end