redis-memo 0.0.0.alpha → 0.0.0.beta

data/lib/redis_memo/memoizable.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+require 'securerandom'
+
+class RedisMemo::Memoizable
+  require_relative 'memoizable/dependency'
+  require_relative 'memoizable/invalidation'
+
+  attr_accessor :props
+  attr_reader :depends_on
+
+  def initialize(**props, &depends_on)
+    @props = props
+    @depends_on = depends_on
+    @cache_key = nil
+  end
+
+  def extra_props(**args)
+    instance = dup
+    instance.props = props.dup.merge(**args)
+    instance
+  end
+
+  def cache_key
+    @cache_key ||= [
+      self.class.name,
+      RedisMemo.checksum(
+        RedisMemo.deep_sort_hash(@props).to_json,
+      ),
+    ].join(':')
+  end
+
+  # Calculate the checksums for all memoizable groups in one Redis round trip
+  def self.checksums(instances_groups)
+    dependents_cache_keys = []
+    cache_key_groups = instances_groups.map do |instances|
+      cache_keys = instances.map(&:cache_key)
+      dependents_cache_keys += cache_keys
+      cache_keys
+    end
+
+    dependents_cache_keys.uniq!
+    dependents_versions = find_or_create_versions(dependents_cache_keys)
+    version_hash = dependents_cache_keys.zip(dependents_versions).to_h
+
+    cache_key_groups.map do |cache_keys|
+      RedisMemo.checksum(version_hash.slice(*cache_keys).to_json)
+    end
+  end
+
+  def self.invalidate(instances)
+    instances.each do |instance|
+      cache_key = instance.cache_key
+      RedisMemo::Memoizable::Invalidation.bump_version_later(
+        cache_key,
+        SecureRandom.uuid,
+      )
+    end
+
+    RedisMemo::Memoizable::Invalidation.drain_invalidation_queue
+  end
+
+  private
+
+  def self.find_or_create_versions(keys)
+    need_to_bump_versions = false
+
+    # Must check the local pending_memo_versions first in order to generate
+    # memo checksums. The pending_memo_versions are the expected versions that
+    # would be used if a transaction commited. With checksums consistent of
+    # pending versions, the method results would only be visible after a
+    # transaction commited (we bump the pending_memo_versions on redis as an
+    # after_commit callback)
+    if RedisMemo::AfterCommit.in_transaction?
+      memo_versions = RedisMemo::AfterCommit.pending_memo_versions.slice(*keys)
+    else
+      memo_versions = {}
+    end
+
+    keys_to_fetch = keys
+    keys_to_fetch -= memo_versions.keys unless memo_versions.empty?
+
+    cached_versions =
+      if keys_to_fetch.empty?
+        {}
+      else
+        RedisMemo::Cache.read_multi(*keys_to_fetch, raise_error: true)
+      end
+    memo_versions.merge!(cached_versions) unless cached_versions.empty?
+
+    versions = keys.map do |key|
+      version = memo_versions[key]
+      if version.nil?
+        # If a version does not exist, we assume it's because the version has
+        # expired due to TTL or it's evicted by a cache eviction policy. In
+        # this case, we will create a new version and use it for memoizing the
+        # cached result.
+        need_to_bump_versions = true
+
+        new_version = SecureRandom.uuid
+        RedisMemo::Memoizable::Invalidation.bump_version_later(
+          key,
+          new_version,
+          previous_version: '',
+        )
+        new_version
+      else
+        version
+      end
+    end
+
+    # Flush out the versions to Redis (async) if we created new versions
+    RedisMemo::Memoizable::Invalidation.drain_invalidation_queue if need_to_bump_versions
+
+    versions
+  end
+end

data/lib/redis_memo/memoizable/dependency.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# A Directed Acyclic Graph (DAG) of Memoizables
+class RedisMemo::Memoizable::Dependency
+  attr_accessor :nodes
+
+  def initialize
+    @nodes = {}
+  end
+
+  def memos
+    @nodes.values
+  end
+
+  def depends_on(memo_or_model, **conditions)
+    if !memo_or_model.is_a?(RedisMemo::Memoizable)
+      [
+        memo_or_model.redis_memo_class_memoizable,
+        RedisMemo::MemoizeRecords.create_memo(memo_or_model, **conditions),
+      ].each do |memo|
+        nodes[memo.cache_key] = memo
+      end
+
+      return
+    end
+
+    memo = memo_or_model
+    return if nodes.include?(memo.cache_key)
+    nodes[memo.cache_key] = memo
+
+    if memo.depends_on
+      # Extract dependencies from the current memoizable and recurse
+      instance_exec(&memo.depends_on)
+    end
+  end
+end

data/lib/redis_memo/memoizable/invalidation.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+require_relative '../after_commit'
+require_relative '../cache'
+
+module RedisMemo::Memoizable::Invalidation
+  # This is a thread safe data structure
+  #
+  # Handle transient network errors during cache invalidation
+  # Each item in the queue is a tuple:
+  #
+  #   [key, version (a UUID), previous_version (a UUID)]
+  #
+  # When an invalidation call arrives at Redis, we only bump to the specified
+  # version (so the cached results using that version will become visible) if
+  # the actual and expected previous_version on Redis match, to ensure eventual
+  # consistency: If the versions mismatch, we will use a new version that has
+  # not been associated with any cached_results.
+  #
+  #   - No invalid cached results will be read
+  #
+  #   - New memoized calculations will write back the fresh_results using the
+  #     new version as part of their checksums.
+  #
+  # Note: Cached data is not guaranteed to be consistent by design. Between the
+  # moment we should invalidate a version and the moment we actually
+  # invalidated a version, we would serve out-dated cached results, as if the
+  # operations that triggered the invalidation has not yet happened.
+  @@invalidation_queue = Queue.new
+
+  def self.bump_version_later(key, version, previous_version: nil)
+    RedisMemo::DefaultOptions.logger&.info("[received] Bump memo key #{key}")
+
+    if RedisMemo::AfterCommit.in_transaction?
+      previous_version ||= RedisMemo::AfterCommit.pending_memo_versions[key]
+    end
+
+    local_cache = RedisMemo::Cache.local_cache
+    if previous_version.nil? && local_cache&.include?(key)
+      previous_version = local_cache[key]
+    elsif RedisMemo::AfterCommit.in_transaction?
+      # Fill an expected previous version so the later calculation results
+      # based on this version can still be rolled out if this version
+      # does not change
+      previous_version ||= RedisMemo::Cache.read_multi(key)[key]
+    end
+
+    local_cache&.send(:[]=, key, version)
+    if RedisMemo::AfterCommit.in_transaction?
+      RedisMemo::AfterCommit.bump_memo_version_after_commit(
+        key,
+        version,
+        previous_version: previous_version,
+      )
+    else
+      @@invalidation_queue << [key, version, previous_version]
+    end
+  end
+
+  def self.drain_invalidation_queue
+    async_handler = RedisMemo::DefaultOptions.async
+    if async_handler.nil?
+      drain_invalidation_queue_now
+    else
+      async_handler.call do
+        drain_invalidation_queue_now
+      end
+    end
+  end
+
+  LUA_BUMP_VERSION = <<~LUA
+    local key = KEYS[1]
+    local expected_prev_version,
+          desired_new_version,
+          version_on_mismatch,
+          ttl = unpack(ARGV)
+
+    local actual_prev_version = redis.call('get', key)
+    local new_version = version_on_mismatch
+    local px = {}
+
+    if (not actual_prev_version and expected_prev_version == '') or expected_prev_version == actual_prev_version then
+      new_version = desired_new_version
+    end
+
+    if ttl ~= '' then
+      px = {'px', ttl}
+    end
+
+    return redis.call('set', key, new_version, unpack(px))
+  LUA
+
+  def self.bump_version(cache_key, version, previous_version:)
+    RedisMemo::Tracer.trace('redis_memo.memoizable.bump_version', nil) do
+      ttl = RedisMemo::DefaultOptions.expires_in
+      ttl = (ttl * 1000.0).to_i if ttl
+      RedisMemo::Cache.redis.eval(
+        LUA_BUMP_VERSION,
+        keys: [cache_key],
+        argv: [previous_version, version, SecureRandom.uuid, ttl],
+      )
+    end
+    RedisMemo::DefaultOptions.logger&.info("[performed] Bump memo key #{cache_key}")
+  end
+
+  def self.drain_invalidation_queue_now
+    retry_queue = []
+    until @@invalidation_queue.empty?
+      tuple = @@invalidation_queue.pop
+      begin
+        bump_version(tuple[0], tuple[1], previous_version: tuple[2])
+      rescue SignalException, Redis::BaseConnectionError
+        retry_queue << tuple
+      end
+    end
+  ensure
+    retry_queue.each { |t| @@invalidation_queue << t }
+  end
+
+  at_exit do
+    # The best effort
+    drain_invalidation_queue_now
+  end
+end

data/lib/redis_memo/memoize_method.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+require_relative 'batch'
+require_relative 'future'
+require_relative 'memoizable'
+require_relative 'middleware'
+require_relative 'options'
+
+module RedisMemo::MemoizeMethod
+  def memoize_method(method_name, **options, &depends_on)
+    method_name_without_memo = :"_redis_memo_#{method_name}_without_memo"
+    method_name_with_memo = :"_redis_memo_#{method_name}_with_memo"
+
+    alias_method method_name_without_memo, method_name
+
+    define_method method_name_with_memo do |*args|
+      return send(method_name_without_memo, *args) if RedisMemo.without_memo?
+
+      future = RedisMemo::Future.new(
+        self,
+        RedisMemo::MemoizeMethod.method_id(self, method_name),
+        args,
+        depends_on,
+        options,
+        method_name_without_memo,
+      )
+
+      if RedisMemo::Batch.current
+        RedisMemo::Batch.current << future
+        return future
+      end
+
+      future.execute
+    end
+
+    alias_method method_name, method_name_with_memo
+  end
+
+  def self.method_id(ref, method_name)
+    is_class_method = ref.class == Class
+    class_name = is_class_method ? ref.name : ref.class.name
+
+    "#{class_name}#{is_class_method ? '::' : '#'}#{method_name}"
+  end
+
+  def self.method_cache_keys(future_contexts)
+    memos = Array.new(future_contexts.size)
+    future_contexts.each_with_index do |(ref, _, method_args, depends_on), i|
+      if depends_on
+        dependency = RedisMemo::Memoizable::Dependency.new
+
+        # Resolve the dependency recursively
+        dependency.instance_exec(ref, *method_args, &depends_on)
+
+        memos[i] = dependency.memos
+      end
+    end
+
+    j = 0
+    memo_checksums = RedisMemo::Memoizable.checksums(memos.compact)
+    method_cache_key_versions = Array.new(future_contexts.size)
+    future_contexts.each_with_index do |(_, method_id, method_args, _), i|
+      if memos[i]
+        method_cache_key_versions[i] = [method_id, memo_checksums[j]]
+        j += 1
+      else
+        ordered_method_args = method_args.map do |arg|
+          arg.is_a?(Hash) ? RedisMemo.deep_sort_hash(arg) : arg
+        end
+
+        method_cache_key_versions[i] = [
+          method_id,
+          RedisMemo.checksum(ordered_method_args.to_json),
+        ]
+      end
+    end
+
+    method_cache_key_versions.map do |method_id, method_cache_key_version|
+      # Example:
+      #
+      #   RedisMemo:MyModel#slow_calculation:<global cache version>:<local
+      #   cache version>
+      #
+      [
+        RedisMemo.name,
+        method_id,
+        RedisMemo::DefaultOptions.global_cache_key_version,
+        method_cache_key_version,
+      ].join(':')
+    end
+  rescue RedisMemo::Cache::Rescuable
+    nil
+  end
+end

data/lib/redis_memo/memoize_method.rbi

@@ -0,0 +1,10 @@
+# typed: true
+
+module RedisMemo::MemoizeMethod
+  include Kernel
+
+  def class; end
+  def name; end
+  def alias_method(*); end
+  def define_method(*); end
+end

data/lib/redis_memo/memoize_records.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+require_relative 'memoize_method'
+
+#
+# Automatically invalidate memoizable when modifying ActiveRecords objects.
+# You still need to invalidate memos when you are using SQL queries to perform
+# update / delete (does not trigger record callbacks)
+#
+module RedisMemo::MemoizeRecords
+  require_relative 'memoize_records/cached_select'
+  require_relative 'memoize_records/invalidation'
+  require_relative 'memoize_records/model_callback'
+
+  # TODO: MemoizeRecords -> MemoizeQuery
+  def memoize_records
+    RedisMemo::MemoizeRecords.using_active_record!(self)
+
+    memoize_table_column(primary_key.to_sym, editable: false)
+  end
+
+  # Only editable columns will be used to create memos that are invalidatable
+  # after each record save
+  def memoize_table_column(*raw_columns, editable: true)
+    RedisMemo::MemoizeRecords.using_active_record!(self)
+
+    columns = raw_columns.map(&:to_sym).sort
+
+    RedisMemo::MemoizeRecords.memoized_columns(self, editable_only: true) << columns if editable
+    RedisMemo::MemoizeRecords.memoized_columns(self, editable_only: false) << columns
+
+    RedisMemo::MemoizeRecords::ModelCallback.install(self)
+    RedisMemo::MemoizeRecords::Invalidation.install(self)
+
+    if ENV['REDIS_MEMO_DISABLE_CACHED_SELECT'] != 'true'
+      RedisMemo::MemoizeRecords::CachedSelect.install(ActiveRecord::Base.connection)
+    end
+
+    columns.each do |column|
+      unless self.columns_hash.include?(column.to_s)
+        raise(
+          RedisMemo::ArgumentError,
+          "'#{self.name}' does not contain column '#{column}'",
+        )
+      end
+    end
+  rescue ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
+    # no-opts: models with memoize_table_column decleared might be loaded in
+    # rake tasks that are used to create databases
+  end
+
+  def self.using_active_record!(model_class)
+    unless model_class.respond_to?(:<) && model_class < ActiveRecord::Base
+      raise RedisMemo::ArgumentError, "'#{model_class.name}' does not use ActiveRecord"
+    end
+  end
+
+  @@memoized_columns = Hash.new { |h, k| h[k] = [Set.new, Set.new] }
+
+  def self.memoized_columns(model_or_table, editable_only: false)
+    table = model_or_table.is_a?(Class) ? model_or_table.table_name : model_or_table
+    @@memoized_columns[table.to_sym][editable_only ? 1 : 0]
+  end
+
+  # extra_props are considered as AND conditions on the model class
+  def self.create_memo(model_class, **extra_props)
+    RedisMemo::MemoizeRecords.using_active_record!(model_class)
+
+    keys = extra_props.keys.sort
+    if !keys.empty? && !RedisMemo::MemoizeRecords.memoized_columns(model_class).include?(keys)
+      raise(
+        RedisMemo::ArgumentError,
+        "'#{model_class.name}' has not memoized columns: #{keys}",
+      )
+    end
+
+    extra_props.each do |key, values|
+      # The data type is ensured by the database, thus we don't need to cast
+      # types here for better performance
+      column_name = key.to_s
+      values = [values] unless values.is_a?(Enumerable)
+      extra_props[key] =
+        if model_class.defined_enums.include?(column_name)
+          enum_mapping = model_class.defined_enums[column_name]
+          values.map do |value|
+            # Assume a value is a converted enum if it does not exist in the
+            # enum mapping
+            (enum_mapping[value.to_s] || value).to_s
+          end
+        else
+          values.map(&:to_s)
+        end
+    end
+
+    RedisMemo::Memoizable.new(
+      __redis_memo_memoize_records_model_class_name__: model_class.name,
+      **extra_props,
+    )
+  end
+
+  def self.invalidate_all(model_class)
+    RedisMemo::Tracer.trace(
+      'redis_memo.memoizable.invalidate_all',
+      model_class.name,
+    ) do
+      RedisMemo::Memoizable.invalidate([model_class.redis_memo_class_memoizable])
+    end
+  end
+
+  def self.invalidate(record)
+    # Invalidate memos with current values
+    memos_to_invalidate = memoized_columns(record.class).map do |columns|
+      props = {}
+      columns.each do |column|
+        props[column] = record.send(column)
+      end
+
+      RedisMemo::MemoizeRecords.create_memo(record.class, **props)
+    end
+
+    # Create memos with previous values if
+    #  - there are saved changes
+    #  - this is not creating a new record
+    if !record.saved_changes.empty? && !record.saved_changes.include?(record.class.primary_key)
+      previous_values = {}
+      record.saved_changes.each do |column, (previous_value, _)|
+        previous_values[column.to_sym] = previous_value
+      end
+
+      memoized_columns(record.class, editable_only: true).each do |columns|
+        props = previous_values.slice(*columns)
+        next if props.empty?
+
+        # Fill the column values that have not changed
+        columns.each do |column|
+          next if props.include?(column)
+
+          props[column] = record.send(column)
+        end
+
+        memos_to_invalidate << RedisMemo::MemoizeRecords.create_memo(record.class, **props)
+      end
+    end
+
+    RedisMemo::Memoizable.invalidate(memos_to_invalidate)
+  end
+end