identity_cache 0.5.1 → 1.0.0

data/lib/identity_cache/fallback_fetcher.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module IdentityCache
   class FallbackFetcher
     attr_accessor :cache_backend
@@ -18,7 +19,7 @@ module IdentityCache
       @cache_backend.clear
     end
 
-    def fetch_multi(keys, &block)
+    def fetch_multi(keys)
       results = @cache_backend.read_multi(*keys)
       missed_keys = keys - results.keys
       unless missed_keys.empty?

data/lib/identity_cache/load_strategy/eager.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  module LoadStrategy
+    module Eager
+      extend self
+
+      def load(cache_fetcher, db_key)
+        yield CacheKeyLoader.load(cache_fetcher, db_key)
+      end
+
+      def load_multi(cache_fetcher, db_keys)
+        yield CacheKeyLoader.load_multi(cache_fetcher, db_keys)
+      end
+
+      def load_batch(db_keys_by_cache_fetcher)
+        yield CacheKeyLoader.load_batch(db_keys_by_cache_fetcher)
+      end
+
+      def lazy_load
+        lazy_loader = Lazy.new
+        yield lazy_loader
+        lazy_loader.load_now
+        nil
+      end
+    end
+  end
+end

data/lib/identity_cache/load_strategy/lazy.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  module LoadStrategy
+    class Lazy
+      def initialize
+        @pending_loads = {}
+      end
+
+      def load(cache_fetcher, db_key)
+        load_multi(cache_fetcher, [db_key]) do |results|
+          yield results.fetch(db_key)
+        end
+        nil
+      end
+
+      def load_multi(cache_fetcher, db_keys, &callback)
+        load_request = LoadRequest.new(db_keys, callback)
+
+        if (prev_load_request = @pending_loads[cache_fetcher])
+          if prev_load_request.instance_of?(MultiLoadRequest)
+            prev_load_request.load_requests << load_request
+          else
+            @pending_loads[cache_fetcher] = MultiLoadRequest.new([prev_load_request, load_request])
+          end
+        else
+          @pending_loads[cache_fetcher] = LoadRequest.new(db_keys, callback)
+        end
+        nil
+      end
+
+      def load_batch(db_keys_by_cache_fetcher)
+        batch_result = {}
+        db_keys_by_cache_fetcher.each do |cache_fetcher, db_keys|
+          load_multi(cache_fetcher, db_keys) do |load_result|
+            batch_result[cache_fetcher] = load_result
+            if batch_result.size == db_keys_by_cache_fetcher.size
+              yield batch_result
+            end
+          end
+        end
+        nil
+      end
+
+      def lazy_load
+        yield self
+        nil
+      end
+
+      def load_now
+        until @pending_loads.empty?
+          pending_loads = @pending_loads
+          @pending_loads = {}
+          load_pending(pending_loads)
+        end
+      end
+
+      private
+
+      def load_pending(pending_loads)
+        result = CacheKeyLoader.load_batch(pending_loads.transform_values(&:db_keys))
+        result.each do |cache_fetcher, load_result|
+          load_request = pending_loads.fetch(cache_fetcher)
+          load_request.after_load(load_result)
+        end
+      end
+    end
+
+    private_constant :Lazy
+  end
+end

data/lib/identity_cache/load_strategy/load_request.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  module LoadStrategy
+    class LoadRequest
+      attr_reader :db_keys
+
+      def initialize(db_keys, callback)
+        @db_keys = db_keys
+        @callback = callback
+      end
+
+      def after_load(results)
+        @callback.call(results)
+      end
+    end
+
+    private_constant :LoadRequest
+  end
+end

data/lib/identity_cache/load_strategy/multi_load_request.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module IdentityCache
+  module LoadStrategy
+    class MultiLoadRequest
+      def initialize(load_requests)
+        @load_requests = load_requests
+      end
+
+      def db_keys
+        @load_requests.flat_map(&:db_keys).tap(&:uniq!)
+      end
+
+      def after_load(all_results)
+        @load_requests.each do |load_request|
+          load_result = {}
+          load_request.db_keys.each do |key|
+            load_result[key] = all_results[key]
+          end
+          load_request.after_load(load_result)
+        end
+      end
+    end
+
+    private_constant :MultiLoadRequest
+  end
+end

data/lib/identity_cache/memoized_cache_proxy.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
 require 'monitor'
+require 'benchmark'
 
 module IdentityCache
   class MemoizedCacheProxy
@@ -6,13 +8,20 @@ module IdentityCache
 
     def initialize(cache_adaptor = nil)
       self.cache_backend = cache_adaptor || Rails.cache
-      @key_value_maps = Hash.new {|h, k| h[k] = {} }
+      @key_value_maps = Hash.new { |h, k| h[k] = {} }
     end
 
     def cache_backend=(cache_adaptor)
       if cache_adaptor.respond_to?(:cas) && cache_adaptor.respond_to?(:cas_multi)
         @cache_fetcher = CacheFetcher.new(cache_adaptor)
       else
+        case cache_adaptor
+        when ActiveSupport::Cache::MemoryStore, ActiveSupport::Cache::NullStore
+          # no need for CAS support
+        else
+          warn("[IdentityCache] Missing CAS support in cache backend #{cache_adaptor.class} "\
+               "which is needed for cache consistency")
+        end
         @cache_fetcher = FallbackFetcher.new(cache_adaptor)
       end
     end
@@ -21,7 +30,7 @@ module IdentityCache
       @key_value_maps[Thread.current]
     end
 
-    def with_memoization(&block)
+    def with_memoization
       Thread.current[:memoizing_idc] = true
       yield
     ensure
@@ -30,101 +39,161 @@ module IdentityCache
     end
 
     def write(key, value)
-      memoized_key_values[key] = value if memoizing?
-      @cache_fetcher.write(key, value)
+      memoizing = memoizing?
+      ActiveSupport::Notifications.instrument('cache_write.identity_cache', memoizing: memoizing) do
+        memoized_key_values[key] = value if memoizing
+        @cache_fetcher.write(key, value)
+      end
     end
 
     def delete(key)
-      memoized_key_values.delete(key) if memoizing?
-      result = @cache_fetcher.delete(key)
-      IdentityCache.logger.debug { "[IdentityCache] delete #{ result ? 'recorded'  : 'failed'  } for #{key}" }
-      result
+      memoizing = memoizing?
+      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}" }
+        else
+          IdentityCache.logger.error { "[IdentityCache] delete failed for #{key}" }
+        end
+        result
+      end
     end
 
     def fetch(key)
-      used_cache_backend = true
-      missed = false
-      value = if memoizing?
-        used_cache_backend = false
-        memoized_key_values.fetch(key) do
-          used_cache_backend = true
-          memoized_key_values[key] = @cache_fetcher.fetch(key) do
-            missed = true
-            yield
+      memo_misses = 0
+      cache_misses = 0
+
+      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_misses = 1
+            instrument_duration(payload, :resolve_miss_time) do
+              yield
+            end
           end
         end
-      else
-        @cache_fetcher.fetch(key) do
-          missed = true
-          yield
-        end
+        set_instrumentation_payload(payload, num_keys: 1, memo_misses: memo_misses, cache_misses: cache_misses)
+        value
       end
 
-      if missed
+      if cache_misses > 0
         IdentityCache.logger.debug { "[IdentityCache] cache miss for #{key}" }
       else
-        IdentityCache.logger.debug { "[IdentityCache] #{ used_cache_backend ? '(cache_backend)' : '(memoized)' } cache hit for #{key}" }
+        IdentityCache.logger.debug do
+          "[IdentityCache] #{memo_misses > 0 ? '(cache_backend)' : '(memoized)'} cache hit for #{key}"
+        end
       end
 
       value
     end
 
     def fetch_multi(*keys)
-      memoized_keys, missed_keys = [], [] if IdentityCache.logger.debug?
-
-      result = if memoizing?
-        hash = {}
-        mkv = memoized_key_values
-
-        non_memoized_keys = keys.reject do |key|
-          if mkv.has_key?(key)
-            memoized_keys << key if IdentityCache.logger.debug?
-            hit = mkv[key]
-            hash[key] = hit unless hit.nil?
-            true
+      memo_miss_keys = EMPTY_ARRAY
+      cache_miss_keys = EMPTY_ARRAY
+
+      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|
+          memo_miss_keys = non_memoized_keys
+          @cache_fetcher.fetch_multi(non_memoized_keys) do |missing_keys|
+            cache_miss_keys = missing_keys
+            instrument_duration(payload, :resolve_miss_time) do
+              yield missing_keys
+            end
           end
         end
 
-        unless non_memoized_keys.empty?
-          results = @cache_fetcher.fetch_multi(non_memoized_keys) do |missing_keys|
-            missed_keys.concat(missing_keys) if IdentityCache.logger.debug?
-            yield missing_keys
-          end
-          mkv.merge! results
-          hash.merge! results
-        end
-        hash
-      else
-        @cache_fetcher.fetch_multi(keys) do |missing_keys|
-          missed_keys.concat(missing_keys) if IdentityCache.logger.debug?
-          yield missing_keys
-        end
+        set_instrumentation_payload(
+          payload,
+          num_keys: keys.length,
+          memo_misses: memo_miss_keys.length,
+          cache_misses: cache_miss_keys.length
+        )
+        result
       end
 
-      log_multi_result(memoized_keys, keys - missed_keys - memoized_keys, missed_keys) if IdentityCache.logger.debug?
+      log_multi_result(keys, memo_miss_keys, cache_miss_keys)
 
       result
     end
 
     def clear
-      clear_memoization
-      @cache_fetcher.clear
+      ActiveSupport::Notifications.instrument('cache_clear.identity_cache') do
+        clear_memoization
+        @cache_fetcher.clear
+      end
     end
 
     private
 
+    EMPTY_ARRAY = [].freeze
+    private_constant :EMPTY_ARRAY
+
+    def set_instrumentation_payload(payload, num_keys:, memo_misses:, cache_misses:)
+      payload[:memoizing] = memoizing?
+      payload[:memo_hits] = num_keys - memo_misses
+      payload[:cache_hits] = memo_misses - cache_misses
+      payload[:cache_misses] = cache_misses
+    end
+
+    def fetch_memoized(key)
+      return yield unless memoizing?
+      if memoized_key_values.key?(key)
+        return memoized_key_values[key]
+      end
+      memoized_key_values[key] = yield
+    end
+
+    def fetch_multi_memoized(keys)
+      return yield keys unless memoizing?
+
+      result = {}
+      missing_keys = keys.reject do |key|
+        if memoized_key_values.key?(key)
+          result[key] = memoized_key_values[key]
+          true
+        end
+      end
+
+      unless missing_keys.empty?
+        block_result = yield missing_keys
+        memoized_key_values.merge!(block_result)
+        result.merge!(block_result)
+      end
+
+      result
+    end
+
+    def instrument_duration(payload, key)
+      value = nil
+      payload[key] += Benchmark.realtime do
+        value = yield
+      end
+      value
+    end
+
     def clear_memoization
       @key_value_maps.delete(Thread.current)
     end
 
     def memoizing?
-      Thread.current[:memoizing_idc]
+      !!Thread.current[:memoizing_idc]
     end
 
-    def log_multi_result(memoized_keys, backend_keys, missed_keys)
-      memoized_keys.each {|k| IdentityCache.logger.debug "[IdentityCache] (memoized) cache hit for #{k} (multi)" }
-      backend_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)" }
+    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
     end
   end
 end

data/lib/identity_cache/parent_model_expiration.rb

@@ -1,17 +1,50 @@
+# frozen_string_literal: true
 module IdentityCache
   module ParentModelExpiration # :nodoc:
     extend ActiveSupport::Concern
 
-    included do |base|
-      base.class_attribute :parent_expiration_entries
-      base.parent_expiration_entries = Hash.new{ |hash, key| hash[key] = [] }
+    class << self
+      def add_parent_expiry_hook(cached_association)
+        name = cached_association.reflection.class_name.demodulize
+        lazy_hooks[name] << ExpiryHook.new(cached_association)
+      end
+
+      def install_all_pending_parent_expiry_hooks
+        until lazy_hooks.empty?
+          lazy_hooks.keys.each do |name|
+            if (hooks = lazy_hooks.delete(name))
+              hooks.each(&:install)
+            end
+          end
+        end
+      end
+
+      def install_pending_parent_expiry_hooks(model)
+        name = model.name.demodulize
+        if (hooks = lazy_hooks.delete(name))
+          hooks.each(&:install)
+        end
+      end
+
+      private
+
+      def lazy_hooks
+        @lazy_hooks ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+    end
+
+    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
-      parents_to_expire = {}
+      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_value do |parent|
-        parent.send(:expire_primary_index)
+      parents_to_expire.each do |parent|
+        parent.expire_primary_index if parent.class.primary_cache_index_enabled
       end
     end
 
@@ -22,9 +55,7 @@ module IdentityCache
     end
 
     def add_record_to_cache_expiry_set(parents_to_expire, record)
-      key = record.primary_cache_index_key
-      unless parents_to_expire[key]
-        parents_to_expire[key] = record
+      if parents_to_expire.add?(record)
         record.add_parents_to_cache_expiry_set(parents_to_expire)
       end
     end
@@ -52,11 +83,12 @@ module IdentityCache
       end
 
       cached_associations.each do |parent_class, only_on_foreign_key_change|
-        if new_parent && new_parent.is_a?(parent_class) && should_expire_identity_cache_parent?(foreign_key, only_on_foreign_key_change)
+        if new_parent&.is_a?(parent_class) &&
+           should_expire_identity_cache_parent?(foreign_key, only_on_foreign_key_change)
           add_record_to_cache_expiry_set(parents_to_expire, new_parent)
         end
 
-        if old_parent && old_parent.is_a?(parent_class)
+        if old_parent&.is_a?(parent_class)
           add_record_to_cache_expiry_set(parents_to_expire, old_parent)
         end
       end
@@ -70,4 +102,6 @@ module IdentityCache
       end
     end
   end
+
+  private_constant :ParentModelExpiration
 end