identity_cache 0.4.1 → 1.1.0

data/lib/identity_cache/encoder.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+module IdentityCache
+  module Encoder
+    DEHYDRATE_EVENT = "dehydration.identity_cache"
+    HYDRATE_EVENT   = "hydration.identity_cache"
+
+    class << self
+      def encode(record)
+        return unless record
+
+        ActiveSupport::Notifications.instrument(DEHYDRATE_EVENT, class: record.class.name) do
+          coder_from_record(record, record.class)
+        end
+      end
+
+      def decode(coder, klass)
+        return unless coder
+
+        ActiveSupport::Notifications.instrument(HYDRATE_EVENT, class: klass.name) do
+          record_from_coder(coder, klass)
+        end
+      end
+
+      private
+
+      def coder_from_record(record, klass)
+        return unless record
+
+        coder = {}
+        coder[:attributes] = record.attributes_before_type_cast.dup
+
+        recursively_embedded_associations = klass.send(:recursively_embedded_associations)
+        id_embedded_has_manys = klass.cached_has_manys.select { |_, association| association.embedded_by_reference? }
+        id_embedded_has_ones = klass.cached_has_ones.select { |_, association| association.embedded_by_reference? }
+
+        if recursively_embedded_associations.present?
+          coder[:associations] = recursively_embedded_associations.each_with_object({}) do |(name, association), hash|
+            hash[name] = IdentityCache.map_cached_nil_for(embedded_coder(record, name, association))
+          end
+        end
+
+        if id_embedded_has_manys.present?
+          coder[:association_ids] = id_embedded_has_manys.each_with_object({}) do |(name, association), hash|
+            hash[name] = record.instance_variable_get(association.ids_variable_name)
+          end
+        end
+
+        if id_embedded_has_ones.present?
+          coder[:association_id] = id_embedded_has_ones.each_with_object({}) do |(name, association), hash|
+            hash[name] = record.instance_variable_get(association.id_variable_name)
+          end
+        end
+
+        coder
+      end
+
+      def embedded_coder(record, _association, cached_association)
+        embedded_record_or_records = record.public_send(cached_association.cached_accessor_name)
+
+        if embedded_record_or_records.respond_to?(:to_ary)
+          embedded_record_or_records.map do |embedded_record|
+            coder_from_record(embedded_record, embedded_record.class)
+          end
+        else
+          coder_from_record(embedded_record_or_records, embedded_record_or_records.class)
+        end
+      end
+
+      def record_from_coder(coder, klass) #:nodoc:
+        record = klass.instantiate(coder[:attributes].dup)
+
+        if coder.key?(:associations)
+          coder[:associations].each do |name, value|
+            record.instance_variable_set(klass.cached_association(name).dehydrated_variable_name, value)
+          end
+        end
+        if coder.key?(:association_ids)
+          coder[:association_ids].each do |name, ids|
+            record.instance_variable_set(klass.cached_has_manys.fetch(name).ids_variable_name, ids)
+          end
+        end
+        if coder.key?(:association_id)
+          coder[:association_id].each do |name, id|
+            record.instance_variable_set(klass.cached_has_ones.fetch(name).id_variable_name, id)
+          end
+        end
+
+        record.readonly! if IdentityCache.fetch_read_only_records
+        record
+      end
+    end
+  end
+
+  private_constant :Encoder
+end

data/lib/identity_cache/expiry_hook.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module IdentityCache
+  class ExpiryHook
+    def initialize(cached_association)
+      @cached_association = cached_association
+    end
+
+    def install
+      cached_association.validate
+      entry = [parent_class, only_on_foreign_key_change?]
+      child_class.parent_expiration_entries[inverse_name] << entry
+    end
+
+    private
+
+    attr_reader :cached_association
+
+    def only_on_foreign_key_change?
+      cached_association.embedded_by_reference? && !cached_association.reflection.has_scope?
+    end
+
+    def inverse_name
+      cached_association.inverse_name
+    end
+
+    def parent_class
+      cached_association.reflection.active_record
+    end
+
+    def child_class
+      cached_association.reflection.klass
+    end
+  end
+
+  private_constant :ExpiryHook
+end

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/mem_cache_store_cas.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+require 'dalli/cas/client'
+
+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)
+              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.get_multi_cas(keys)
+
+          values = {}
+          raw_values.each do |key, raw_value|
+            entry = deserialize_entry(raw_value.first)
+            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.replace_cas(key, payload, cas_id, options[:expires_in].to_i, options)
+          end
+        end
+      end
+    end
+  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,30 @@ 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.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
+        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 +40,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 +49,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)
+      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