redis-memo 0.0.0.alpha → 0.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 185b376e32235db7e679da783c652f4bb891afa70c771a32052211a3a1269164
-  data.tar.gz: 00fe077bfe4615f8b96a0b0cb9510c48e5b4b9e5419ae1db0ce1ca4c2ccadbc1
+  metadata.gz: 1316982523363ce87b0ada30b82b8200559a07b2f1a6bea54168b40b2afd397e
+  data.tar.gz: 1278e1ff6b7cc2275416c7af9b8668a13128c105a4cde74640deccd0a4380373
 SHA512:
-  metadata.gz: 87ec80320f71c9fe2eebd6f10acb86904feb0e400b66a9197a6374d54c47c31b45cf09a938dcff12aa5a50f631028e4f55a4390549f5f11a324aabcdef5fe28c
-  data.tar.gz: ef51e78a7774686fb278ae122029ed24908dcaa5df936d05394ad364cb64fb99675f74e03843b6694d91d1c8c02f0ab8fc8ff638c79123701809e65224f5cd49
+  metadata.gz: 121069c8de985a8977234776ad15fd209c1c0db523c361a5caf9181ed7120533350af16c354d7f76dfc03168230248e37c64b37eb8ce9f6af16cfdc9160448f3
+  data.tar.gz: 133d18912a95eb599554b9cacb5c5932471772930165249381baaa8aeb403a3a6b21c6e17711a11eda56a1fa6dbf347396c7fe513cec3b53ec6f0c592d5b7d9a

data/lib/redis-memo.rb

@@ -0,0 +1 @@
+require_relative 'redis_memo'

data/lib/redis_memo.rb

@@ -1,6 +1,52 @@
 # frozen_string_literal: true
-
-# typed: true
+require 'active_support/all'
+require 'digest'
+require 'json'
 
 module RedisMemo
+  require 'redis_memo/memoize_method'
+  require 'redis_memo/memoize_records'
+
+  DefaultOptions = RedisMemo::Options.new
+
+  def self.configure(&blk)
+    blk.call(DefaultOptions)
+  end
+
+  def self.batch(&blk)
+    RedisMemo::Batch.open
+    blk.call
+    RedisMemo::Batch.execute
+  ensure
+    RedisMemo::Batch.close
+  end
+
+  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
+
+  THREAD_KEY_WITHOUT_MEMO = :__redis_memo_without_memo__
+
+  def self.without_memo?
+    Thread.current[THREAD_KEY_WITHOUT_MEMO] == true
+  end
+
+  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
+
+  class ArgumentError < ::ArgumentError; end
+  class RuntimeError < ::RuntimeError; end
 end

data/lib/redis_memo/after_commit.rb

@@ -0,0 +1,114 @@
+# 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 << [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,95 @@
+ # frozen_string_literal: true
+require_relative 'options'
+require_relative 'redis'
+
+class RedisMemo::Cache < ActiveSupport::Cache::RedisCacheStore
+  class Rescuable < Exception; end
+
+  THREAD_KEY_LOCAL_CACHE = :__redis_memo_cache_local_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 ||= RedisMemo::DefaultOptions.redis
+  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
+
+  class << self
+    def with_local_cache(&blk)
+      Thread.current[THREAD_KEY_LOCAL_CACHE] = {}
+      blk.call
+    ensure
+      Thread.current[THREAD_KEY_LOCAL_CACHE] = nil
+    end
+
+    # RedisCacheStore doesn't read from the local cache before reading from redis
+    def read_multi(*keys, 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)
+      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/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,
+    depends_on,
+    cache_options,
+    method_name_without_memo
+  )
+    @ref = ref
+    @method_id = method_id
+    @method_args = method_args
+    @depends_on = depends_on
+    @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
+    [@ref, @method_id, @method_args, @depends_on]
+  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