redis-memo 0.0.0.beta → 0.0.0.beta.5

data/lib/redis_memo/redis.rb

@@ -31,7 +31,8 @@ class RedisMemo::Redis < Redis::Distributed
   end
 
   class WithReplicas < ::Redis
-    def initialize(options)
+    def initialize(orig_options)
+      options = orig_options.dup
       primary_option = options.shift
       @replicas = options.map do |option|
         option[:logger] ||= RedisMemo::DefaultOptions.logger

data/lib/redis_memo/tracer.rb

@@ -11,13 +11,15 @@ class RedisMemo::Tracer
     end
   end
 
-  def self.set_tag(cache_hit:)
+  def self.set_tag(**tags)
     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)
+    tags.each do |name, value|
+      active_span.set_tag(name, value)
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-memo
 version: !ruby/object:Gem::Version
-  version: 0.0.0.beta
+  version: 0.0.0.beta.5
 platform: ruby
 authors:
 - Chan Zuckerberg Initiative
@@ -14,44 +14,72 @@ dependencies:
   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
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: 4.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.1
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4'
+        version: 2.2.3
 - !ruby/object:Gem::Dependency
   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: activerecord-import
+  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: codecov
   requirement: !ruby/object:Gem::Requirement
@@ -147,16 +175,20 @@ files:
 - lib/redis_memo/after_commit.rb
 - lib/redis_memo/batch.rb
 - lib/redis_memo/cache.rb
+- lib/redis_memo/connection_pool.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/memoize_query.rb
+- lib/redis_memo/memoize_query/cached_select.rb
+- lib/redis_memo/memoize_query/cached_select/bind_params.rb
+- lib/redis_memo/memoize_query/cached_select/connection_adapter.rb
+- lib/redis_memo/memoize_query/cached_select/statement_cache.rb
+- lib/redis_memo/memoize_query/invalidation.rb
+- lib/redis_memo/memoize_query/memoize_table_column.rb
+- lib/redis_memo/memoize_query/model_callback.rb
 - lib/redis_memo/middleware.rb
 - lib/redis_memo/options.rb
 - lib/redis_memo/redis.rb

data/lib/redis_memo/memoize_method.rbi

@@ -1,10 +0,0 @@
-# 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

@@ -1,146 +0,0 @@
-# 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

data/lib/redis_memo/memoize_records/invalidation.rb

@@ -1,85 +0,0 @@
-# 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