identity_cache 1.0.0 → 1.2.0

data/lib/identity_cache/cached/recursive/association.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module Cached
     module Recursive
@@ -11,25 +12,42 @@ module IdentityCache
         attr_reader :dehydrated_variable_name
 
         def build
-          reflection.active_record.class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-            def #{cached_accessor_name}
-              fetch_recursively_cached_association(
-                :#{records_variable_name},
-                :#{dehydrated_variable_name},
-                :#{name}
-              )
-            end
-          RUBY
+          cached_association = self
+
+          model = reflection.active_record
+          model.define_method(cached_accessor_name) do
+            cached_association.read(self)
+          end
 
           ParentModelExpiration.add_parent_expiry_hook(self)
         end
 
         def read(record)
-          record.public_send(cached_accessor_name)
+          assoc = record.association(name)
+
+          if assoc.klass.should_use_cache? && !assoc.loaded? && assoc.target.blank?
+            if record.instance_variable_defined?(records_variable_name)
+              record.instance_variable_get(records_variable_name)
+            elsif record.instance_variable_defined?(dehydrated_variable_name)
+              dehydrated_target = record.instance_variable_get(dehydrated_variable_name)
+              association_target = hydrate_association_target(assoc.klass, dehydrated_target)
+              record.remove_instance_variable(dehydrated_variable_name)
+              set_with_inverse(record, association_target)
+            else
+              assoc.load_target
+            end
+          else
+            assoc.load_target
+          end
+        end
+
+        def write(record, association_target)
+          record.instance_variable_set(records_variable_name, association_target)
         end
 
-        def write(record, records)
-          record.instance_variable_set(records_variable_name, records)
+        def set_with_inverse(record, association_target)
+          set_inverse(record, association_target)
+          write(record, association_target)
         end
 
         def clear(record)
@@ -58,6 +76,31 @@ module IdentityCache
 
         private
 
+        def set_inverse(record, association_target)
+          return if association_target.nil?
+
+          associated_class = reflection.klass
+          inverse_cached_association = associated_class.cached_belongs_tos[inverse_name]
+          return unless inverse_cached_association
+
+          if association_target.is_a?(Array)
+            association_target.each do |child_record|
+              inverse_cached_association.write(child_record, record)
+            end
+          else
+            inverse_cached_association.write(association_target, record)
+          end
+        end
+
+        def hydrate_association_target(associated_class, dehydrated_value)
+          dehydrated_value = IdentityCache.unmap_cached_nil_for(dehydrated_value)
+          if dehydrated_value.is_a?(Array)
+            dehydrated_value.map { |coder| Encoder.decode(coder, associated_class) }
+          else
+            Encoder.decode(dehydrated_value, associated_class)
+          end
+        end
+
         def embedded_fetched?(records)
           record = records.first
           super || record.instance_variable_defined?(dehydrated_variable_name)

data/lib/identity_cache/cached/recursive/has_many.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module Cached
     module Recursive

data/lib/identity_cache/cached/recursive/has_one.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module Cached
     module Recursive

data/lib/identity_cache/cached/reference/association.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module Cached
     module Reference

data/lib/identity_cache/cached/reference/has_many.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module Cached
     module Reference
@@ -20,8 +21,8 @@ module IdentityCache
             end
 
             def #{cached_accessor_name}
-              association_klass = association(:#{name}).klass
-              if association_klass.should_use_cache? && !#{name}.loaded?
+              assoc = association(:#{name})
+              if assoc.klass.should_use_cache? && !assoc.loaded? && assoc.target.blank?
                 #{records_variable_name} ||= #{reflection.class_name}.fetch_multi(#{cached_ids_name})
               else
                 #{name}.to_a

data/lib/identity_cache/cached/reference/has_one.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module Cached
     module Reference
@@ -21,8 +22,8 @@ module IdentityCache
             end
 
             def #{cached_accessor_name}
-              association_klass = association(:#{name}).klass
-              if association_klass.should_use_cache? && !association(:#{name}).loaded?
+              assoc = association(:#{name})
+              if assoc.klass.should_use_cache? && !assoc.loaded?
                 #{records_variable_name} ||= #{reflection.class_name}.fetch(#{cached_id_name}) if #{cached_id_name}
               else
                 #{name}

data/lib/identity_cache/cached.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module Cached
   end

data/lib/identity_cache/configuration_dsl.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module ConfigurationDSL
     extend ActiveSupport::Concern

data/lib/identity_cache/encoder.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module Encoder
     DEHYDRATE_EVENT = "dehydration.identity_cache"
@@ -66,7 +67,7 @@ module IdentityCache
         end
       end
 
-      def record_from_coder(coder, klass) #:nodoc:
+      def record_from_coder(coder, klass) # :nodoc:
         record = klass.instantiate(coder[:attributes].dup)
 
         if coder.key?(:associations)

data/lib/identity_cache/expiry_hook.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   class ExpiryHook
     def initialize(cached_association)
@@ -16,7 +17,7 @@ module IdentityCache
     attr_reader :cached_association
 
     def only_on_foreign_key_change?
-      cached_association.embedded_by_reference?
+      cached_association.embedded_by_reference? && !cached_association.reflection.has_scope?
     end
 
     def inverse_name

data/lib/identity_cache/fallback_fetcher.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   class FallbackFetcher
     attr_accessor :cache_backend
@@ -32,7 +33,11 @@ module IdentityCache
       results
     end
 
-    def fetch(key)
+    def fetch(key, **cache_fetcher_options)
+      unless cache_fetcher_options.empty?
+        raise ArgumentError, "unsupported cache_fetcher options: #{cache_fetcher_options.keys.join(", ")}"
+      end
+
       result = @cache_backend.read(key)
       if result.nil?
         result = yield

data/lib/identity_cache/mem_cache_store_cas.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "dalli/cas/client" unless Dalli::VERSION > "3"
+
+module IdentityCache
+  module MemCacheStoreCAS
+    def cas(name, options = nil)
+      options = merged_options(options)
+      key = normalize_key(name, options)
+
+      rescue_error_with(false) do
+        instrument(:cas, key, options) do
+          @data.with do |connection|
+            connection.cas(key, options[:expires_in].to_i, options) do |raw_value|
+              entry = deserialize_entry(raw_value, raw: options[:raw])
+              value = yield entry.value
+              entry = ActiveSupport::Cache::Entry.new(value, **options)
+              options[:raw] ? entry.value.to_s : entry
+            end
+          end
+        end
+      end
+    end
+
+    def cas_multi(*names, **options)
+      return if names.empty?
+
+      options = merged_options(options)
+      keys_to_names = names.each_with_object({}) { |name, hash| hash[normalize_key(name, options)] = name }
+      keys = keys_to_names.keys
+      rescue_error_with(false) do
+        instrument(:cas_multi, keys, options) do
+          raw_values = @data.with { |c| c.get_multi_cas(keys) }
+
+          values = {}
+          raw_values.each do |key, raw_value|
+            entry = deserialize_entry(raw_value.first, raw: options[:raw])
+            values[keys_to_names[key]] = entry.value unless entry.expired?
+          end
+
+          updates = yield values
+
+          updates.each do |name, value|
+            key = normalize_key(name, options)
+            cas_id = raw_values[key].last
+            entry = ActiveSupport::Cache::Entry.new(value, **options)
+            payload = options[:raw] ? entry.value.to_s : entry
+            @data.with { |c| c.replace_cas(key, payload, cas_id, options[:expires_in].to_i, options) }
+          end
+        end
+      end
+    end
+
+    if ActiveSupport::Cache::MemCacheStore.instance_method(:deserialize_entry).arity == 1
+
+      private
+
+      def deserialize_entry(payload, raw: nil)
+        super(payload)
+      end
+    end
+  end
+end

data/lib/identity_cache/memoized_cache_proxy.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
-require 'monitor'
-require 'benchmark'
+
+require "monitor"
+require "benchmark"
 
 module IdentityCache
   class MemoizedCacheProxy
@@ -12,6 +13,16 @@ module IdentityCache
     end
 
     def cache_backend=(cache_adaptor)
+      if cache_adaptor.class.name == "ActiveSupport::Cache::MemCacheStore"
+        if cache_adaptor.respond_to?(:cas) || cache_adaptor.respond_to?(:cas_multi)
+          unless cache_adaptor.is_a?(MemCacheStoreCAS)
+            raise "#{cache_adaptor} respond to :cas or :cas_multi, that's unexpected"
+          end
+        else
+          cache_adaptor.extend(MemCacheStoreCAS)
+        end
+      end
+
       if cache_adaptor.respond_to?(:cas) && cache_adaptor.respond_to?(:cas_multi)
         @cache_fetcher = CacheFetcher.new(cache_adaptor)
       else
@@ -20,7 +31,7 @@ module IdentityCache
           # no need for CAS support
         else
           warn("[IdentityCache] Missing CAS support in cache backend #{cache_adaptor.class} "\
-               "which is needed for cache consistency")
+            "which is needed for cache consistency")
         end
         @cache_fetcher = FallbackFetcher.new(cache_adaptor)
       end
@@ -40,7 +51,7 @@ module IdentityCache
 
     def write(key, value)
       memoizing = memoizing?
-      ActiveSupport::Notifications.instrument('cache_write.identity_cache', memoizing: memoizing) do
+      ActiveSupport::Notifications.instrument("cache_write.identity_cache", memoizing: memoizing) do
         memoized_key_values[key] = value if memoizing
         @cache_fetcher.write(key, value)
       end
@@ -48,7 +59,7 @@ module IdentityCache
 
     def delete(key)
       memoizing = memoizing?
-      ActiveSupport::Notifications.instrument('cache_delete.identity_cache', memoizing: memoizing) do
+      ActiveSupport::Notifications.instrument("cache_delete.identity_cache", memoizing: memoizing) do
         memoized_key_values.delete(key) if memoizing
         if (result = @cache_fetcher.delete(key))
           IdentityCache.logger.debug { "[IdentityCache] delete recorded for #{key}" }
@@ -59,20 +70,18 @@ module IdentityCache
       end
     end
 
-    def fetch(key)
+    def fetch(key, cache_fetcher_options = {}, &block)
       memo_misses = 0
       cache_misses = 0
 
-      value = ActiveSupport::Notifications.instrument('cache_fetch.identity_cache') do |payload|
+      value = ActiveSupport::Notifications.instrument("cache_fetch.identity_cache") do |payload|
         payload[:resolve_miss_time] = 0.0
 
         value = fetch_memoized(key) do
           memo_misses = 1
-          @cache_fetcher.fetch(key) do
+          @cache_fetcher.fetch(key, **cache_fetcher_options) do
             cache_misses = 1
-            instrument_duration(payload, :resolve_miss_time) do
-              yield
-            end
+            instrument_duration(payload, :resolve_miss_time, &block)
           end
         end
         set_instrumentation_payload(payload, num_keys: 1, memo_misses: memo_misses, cache_misses: cache_misses)
@@ -83,7 +92,7 @@ module IdentityCache
         IdentityCache.logger.debug { "[IdentityCache] cache miss for #{key}" }
       else
         IdentityCache.logger.debug do
-          "[IdentityCache] #{memo_misses > 0 ? '(cache_backend)' : '(memoized)'} cache hit for #{key}"
+          "[IdentityCache] #{memo_misses > 0 ? "(cache_backend)" : "(memoized)"} cache hit for #{key}"
         end
       end
 
@@ -94,7 +103,7 @@ module IdentityCache
       memo_miss_keys = EMPTY_ARRAY
       cache_miss_keys = EMPTY_ARRAY
 
-      result = ActiveSupport::Notifications.instrument('cache_fetch_multi.identity_cache') do |payload|
+      result = ActiveSupport::Notifications.instrument("cache_fetch_multi.identity_cache") do |payload|
         payload[:resolve_miss_time] = 0.0
 
         result = fetch_multi_memoized(keys) do |non_memoized_keys|
@@ -122,7 +131,7 @@ module IdentityCache
     end
 
     def clear
-      ActiveSupport::Notifications.instrument('cache_clear.identity_cache') do
+      ActiveSupport::Notifications.instrument("cache_clear.identity_cache") do
         clear_memoization
         @cache_fetcher.clear
       end
@@ -145,6 +154,7 @@ module IdentityCache
       if memoized_key_values.key?(key)
         return memoized_key_values[key]
       end
+
       memoized_key_values[key] = yield
     end
 
@@ -185,15 +195,15 @@ module IdentityCache
     end
 
     def log_multi_result(keys, memo_miss_keys, cache_miss_keys)
-      IdentityCache.logger.debug do
-        memoized_keys = keys - memo_miss_keys
-        cache_hit_keys = memo_miss_keys - cache_miss_keys
-        missed_keys = cache_miss_keys
-
-        memoized_keys.each { |k| IdentityCache.logger.debug("[IdentityCache] (memoized) cache hit for #{k} (multi)") }
-        cache_hit_keys.each { |k| IdentityCache.logger.debug("[IdentityCache] (backend) cache hit for #{k} (multi)") }
-        missed_keys.each { |k| IdentityCache.logger.debug("[IdentityCache] cache miss for #{k} (multi)") }
-      end
+      return unless IdentityCache.logger.debug?
+
+      memoized_keys = keys - memo_miss_keys
+      cache_hit_keys = memo_miss_keys - cache_miss_keys
+      missed_keys = cache_miss_keys
+
+      memoized_keys.each { |k| IdentityCache.logger.debug("[IdentityCache] (memoized) cache hit for #{k} (multi)") }
+      cache_hit_keys.each { |k| IdentityCache.logger.debug("[IdentityCache] (backend) cache hit for #{k} (multi)") }
+      missed_keys.each { |k| IdentityCache.logger.debug("[IdentityCache] cache miss for #{k} (multi)") }
     end
   end
 end

data/lib/identity_cache/parent_model_expiration.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module ParentModelExpiration # :nodoc:
     extend ActiveSupport::Concern
+    include ArTransactionChanges
 
     class << self
       def add_parent_expiry_hook(cached_association)
@@ -20,6 +22,8 @@ module IdentityCache
       end
 
       def install_pending_parent_expiry_hooks(model)
+        return if lazy_hooks.empty?
+
         name = model.name.demodulize
         if (hooks = lazy_hooks.delete(name))
           hooks.each(&:install)
@@ -36,11 +40,9 @@ module IdentityCache
     included do
       class_attribute(:parent_expiration_entries)
       self.parent_expiration_entries = Hash.new { |hash, key| hash[key] = [] }
-      after_commit(:expire_parent_caches)
     end
 
     def expire_parent_caches
-      ParentModelExpiration.install_pending_parent_expiry_hooks(cached_model)
       parents_to_expire = Set.new
       add_parents_to_cache_expiry_set(parents_to_expire)
       parents_to_expire.each do |parent|
@@ -49,6 +51,7 @@ module IdentityCache
     end
 
     def add_parents_to_cache_expiry_set(parents_to_expire)
+      ParentModelExpiration.install_pending_parent_expiry_hooks(cached_model)
       self.class.parent_expiration_entries.each do |association_name, cached_associations|
         parents_to_expire_on_changes(parents_to_expire, association_name, cached_associations)
       end
@@ -84,7 +87,7 @@ module IdentityCache
 
       cached_associations.each do |parent_class, only_on_foreign_key_change|
         if new_parent&.is_a?(parent_class) &&
-           should_expire_identity_cache_parent?(foreign_key, only_on_foreign_key_change)
+            should_expire_identity_cache_parent?(foreign_key, only_on_foreign_key_change)
           add_record_to_cache_expiry_set(parents_to_expire, new_parent)
         end
 

data/lib/identity_cache/query_api.rb

@@ -1,12 +1,9 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module QueryAPI
     extend ActiveSupport::Concern
 
-    included do |base|
-      base.after_commit(:expire_cache)
-    end
-
     module ClassMethods
       # Prefetches cached associations on a collection of records
       def prefetch_associations(includes, records)
@@ -18,6 +15,11 @@ module IdentityCache
         cached_has_manys[name] || cached_has_ones[name] || cached_belongs_tos.fetch(name)
       end
 
+      # @api private
+      def all_cached_associations # :nodoc:
+        cached_has_manys.merge(cached_has_ones).merge(cached_belongs_tos)
+      end
+
       private
 
       def raise_if_scoped
@@ -67,6 +69,7 @@ module IdentityCache
       def setup_embedded_associations_on_miss(records,
         readonly: IdentityCache.fetch_read_only_records && should_use_cache?)
         return if records.empty?
+
         records.each(&:readonly!) if readonly
         each_id_embedded_association do |cached_association|
           preload_id_embedded_association(records, cached_association)
@@ -81,10 +84,11 @@ module IdentityCache
             association = record.association(association_name)
             target = association.target
             target = readonly_copy(target) if readonly
-            record.send(:set_embedded_association, association_name, target)
+            cached_association.set_with_inverse(record, target)
             association.reset
             # reset inverse associations
             next unless target && association_reflection.has_inverse?
+
             inverse_name = association_reflection.inverse_of.name
             if target.is_a?(Array)
               target.each { |child_record| child_record.association(inverse_name).reset }
@@ -126,10 +130,6 @@ module IdentityCache
         all_cached_associations.select { |_name, association| association.embedded_recursively? }
       end
 
-      def all_cached_associations
-        cached_has_manys.merge(cached_has_ones).merge(cached_belongs_tos)
-      end
-
       def embedded_associations
         all_cached_associations.select { |_name, association| association.embedded? }
       end
@@ -151,6 +151,26 @@ module IdentityCache
       end
     end
 
+    no_op_callback = proc {}
+    included do |base|
+      # Make sure there is at least once after_commit callback so that _run_commit_callbacks
+      # is called, which is overridden to do an early after_commit callback
+      base.after_commit(&no_op_callback)
+    end
+
+    # Override the method that is used to call after_commit callbacks so that we can
+    # expire the caches before other after_commit callbacks. This way we can avoid stale
+    # cache reads that happen from the ordering of callbacks. For example, if an after_commit
+    # callback enqueues a background job, then we don't want it to be possible for the
+    # background job to run and load data from the cache before it is invalidated.
+    def _run_commit_callbacks
+      if destroyed? || transaction_changed_attributes.present?
+        expire_cache
+        expire_parent_caches
+      end
+      super
+    end
+
     # Invalidate the cache data associated with the record.
     def expire_cache
       expire_attribute_indexes
@@ -165,63 +185,6 @@ module IdentityCache
 
     private
 
-    def fetch_recursively_cached_association(ivar_name, dehydrated_ivar_name, association_name) # :nodoc:
-      assoc = association(association_name)
-
-      if assoc.klass.should_use_cache? && !assoc.loaded?
-        if instance_variable_defined?(ivar_name)
-          instance_variable_get(ivar_name)
-        elsif instance_variable_defined?(dehydrated_ivar_name)
-          associated_records = hydrate_association_target(assoc.klass, instance_variable_get(dehydrated_ivar_name))
-          set_embedded_association(association_name, associated_records)
-          remove_instance_variable(dehydrated_ivar_name)
-          instance_variable_set(ivar_name, associated_records)
-        else
-          assoc.load_target
-        end
-      else
-        assoc.load_target
-      end
-    end
-
-    def hydrate_association_target(associated_class, dehydrated_value) # :nodoc:
-      dehydrated_value = IdentityCache.unmap_cached_nil_for(dehydrated_value)
-      if dehydrated_value.is_a?(Array)
-        dehydrated_value.map { |coder| Encoder.decode(coder, associated_class) }
-      else
-        Encoder.decode(dehydrated_value, associated_class)
-      end
-    end
-
-    def set_embedded_association(association_name, association_target) #:nodoc:
-      model = self.class
-      cached_association = model.cached_association(association_name)
-
-      set_inverse_of_cached_association(cached_association, association_target)
-
-      instance_variable_set(cached_association.records_variable_name, association_target)
-    end
-
-    def set_inverse_of_cached_association(cached_association, association_target)
-      return if association_target.nil?
-      associated_class = cached_association.reflection.klass
-      inverse_name = cached_association.inverse_name
-      inverse_cached_association = associated_class.cached_belongs_tos[inverse_name]
-      return unless inverse_cached_association
-
-      if association_target.is_a?(Array)
-        association_target.each do |child_record|
-          child_record.instance_variable_set(
-            inverse_cached_association.records_variable_name, self
-          )
-        end
-      else
-        association_target.instance_variable_set(
-          inverse_cached_association.records_variable_name, self
-        )
-      end
-    end
-
     def expire_attribute_indexes # :nodoc:
       cache_indexes.each do |cached_attribute|
         cached_attribute.expire(self)

data/lib/identity_cache/railtie.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   class Railtie < Rails::Railtie
     initializer "identity_cache.setup" do |app|

data/lib/identity_cache/should_use_cache.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module ShouldUseCache
     extend ActiveSupport::Concern

data/lib/identity_cache/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
+
 module IdentityCache
-  VERSION = "1.0.0"
+  VERSION = "1.2.0"
   CACHE_VERSION = 8
 end