identity_cache 1.1.0 → 1.3.0

data/lib/identity_cache/mem_cache_store_cas.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'dalli/cas/client'
+
+require "dalli/cas/client" unless Dalli::VERSION > "3"
 
 module IdentityCache
   module MemCacheStoreCAS
@@ -11,7 +12,7 @@ module IdentityCache
         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)
+              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
@@ -29,11 +30,11 @@ module IdentityCache
       keys = keys_to_names.keys
       rescue_error_with(false) do
         instrument(:cas_multi, keys, options) do
-          raw_values = @data.get_multi_cas(keys)
+          raw_values = @data.with { |c| c.get_multi_cas(keys) }
 
           values = {}
           raw_values.each do |key, raw_value|
-            entry = deserialize_entry(raw_value.first)
+            entry = deserialize_entry(raw_value.first, raw: options[:raw])
             values[keys_to_names[key]] = entry.value unless entry.expired?
           end
 
@@ -44,10 +45,19 @@ module IdentityCache
             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)
+            @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,7 +13,7 @@ module IdentityCache
     end
 
     def cache_backend=(cache_adaptor)
-      if cache_adaptor.class.name == 'ActiveSupport::Cache::MemCacheStore'
+      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"
@@ -30,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
@@ -50,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
@@ -58,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}" }
@@ -69,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)
@@ -93,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
 
@@ -104,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|
@@ -132,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
@@ -155,6 +154,7 @@ module IdentityCache
       if memoized_key_values.key?(key)
         return memoized_key_values[key]
       end
+
       memoized_key_values[key] = yield
     end
 

data/lib/identity_cache/parent_model_expiration.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module ParentModelExpiration # :nodoc:
     extend ActiveSupport::Concern
@@ -22,6 +23,7 @@ module IdentityCache
 
       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)
@@ -43,8 +45,9 @@ module IdentityCache
     def expire_parent_caches
       parents_to_expire = Set.new
       add_parents_to_cache_expiry_set(parents_to_expire)
-      parents_to_expire.each do |parent|
-        parent.expire_primary_index if parent.class.primary_cache_index_enabled
+      parents_to_expire.select! { |parent| parent.class.primary_cache_index_enabled }
+      parents_to_expire.reduce(true) do |all_expired, parent|
+        parent.expire_primary_index && all_expired
       end
     end
 
@@ -85,7 +88,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,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module QueryAPI
     extend ActiveSupport::Concern
@@ -68,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)
@@ -86,6 +88,7 @@ module IdentityCache
             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 }
@@ -163,15 +166,17 @@ module IdentityCache
     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.
+    # Invalidate the cache data associated with the record. Returns `true` on success,
+    # `false` otherwise.
     def expire_cache
-      expire_attribute_indexes
-      true
+      expired_parent_caches = expire_parent_caches
+      expired_attribute_indexes = expire_attribute_indexes
+
+      expired_parent_caches && expired_attribute_indexes
     end
 
     # @api private
@@ -182,9 +187,11 @@ module IdentityCache
 
     private
 
+    # Even if we have problems with some attributes, carry over the results and expire
+    # all possible attributes without array allocation.
     def expire_attribute_indexes # :nodoc:
-      cache_indexes.each do |cached_attribute|
-        cached_attribute.expire(self)
+      cache_indexes.reduce(true) do |all_expired, cached_attribute|
+        cached_attribute.expire(self) && all_expired
       end
     end
   end

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.1.0"
+  VERSION = "1.3.0"
   CACHE_VERSION = 8
 end

data/lib/identity_cache/with_primary_index.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module WithPrimaryIndex
     extend ActiveSupport::Concern
@@ -6,8 +7,9 @@ module IdentityCache
     include WithoutPrimaryIndex
 
     def expire_cache
-      expire_primary_index
-      super
+      expired_primary_index = expire_primary_index
+
+      super && expired_primary_index
     end
 
     # @api private
@@ -57,7 +59,7 @@ module IdentityCache
         cache_attribute_by_alias(attribute_proc, alias_name: :id, by: fields, unique: unique)
 
         field_list = fields.join("_and_")
-        arg_list = (0...fields.size).collect { |i| "arg#{i}" }.join(',')
+        arg_list = (0...fields.size).collect { |i| "arg#{i}" }.join(",")
 
         if unique
           instance_eval(<<-CODE, __FILE__, __LINE__ + 1)
@@ -97,21 +99,47 @@ module IdentityCache
         !!fetch_by_id(id)
       end
 
-      # Default fetcher added to the model on inclusion, it behaves like
-      # ActiveRecord::Base.where(id: id).first
-      def fetch_by_id(id, includes: nil)
+      # Fetch the record by its primary key from the cache or read from
+      # the database and fill the cache on a cache miss. This behaves like
+      # `where(id: id).readonly.first` being called on the model.
+      #
+      # @param id Primary key value for the record to fetch.
+      # @param includes [Hash|Array|Symbol] Cached associations to prefetch from
+      #   the cache on the returned record
+      # @param fill_lock_duration [Float] If provided, take a fill lock around cache fills
+      #   and wait for this duration for cache to be filled when reading a lock provided
+      #   by another client. Defaults to not setting the fill lock and trying to fill the
+      #   cache from the database regardless of the presence of another client's fill lock.
+      #   Set this to just above the typical amount of time it takes to do a cache fill.
+      # @param lock_wait_tries [Integer] Only applicable if fill_lock_duration is provided,
+      #   in which case it specifies the number of times to do a lock wait. After the first
+      #   lock wait it will try to take the lock, so will only do following lock waits due
+      #   to another client taking the lock first. If another lock wait would be needed after
+      #   reaching the limit, then a `LockWaitTimeout` exception is raised. Default is 2. Use
+      #   this to control the maximum total lock wait duration
+      #   (`lock_wait_tries * fill_lock_duration`).
+      # @raise [LockWaitTimeout] Timeout after waiting `lock_wait_tries * fill_lock_duration`
+      #   seconds for `lock_wait_tries` other clients to fill the cache.
+      # @return [self|nil] An instance of this model for the record with the specified id or
+      #   `nil` if no record with this `id` exists in the database
+      def fetch_by_id(id, includes: nil, **cache_fetcher_options)
         ensure_base_model
         raise_if_scoped
-        record = cached_primary_index.fetch(id)
+        record = cached_primary_index.fetch(id, cache_fetcher_options)
         prefetch_associations(includes, [record]) if record && includes
         record
       end
 
-      # Default fetcher added to the model on inclusion, it behaves like
-      # ActiveRecord::Base.find, but will raise IdentityCache::RecordNotFound
-      # if the id is not in the cache.
-      def fetch(id, includes: nil)
-        fetch_by_id(id, includes: includes) || raise(
+      # Fetch the record by its primary key from the cache or read from
+      # the database and fill the cache on a cache miss. This behaves like
+      # `readonly.find(id)` being called on the model.
+      #
+      # @param (see #fetch_by_id)
+      # @raise (see #fetch_by_id)
+      # @raise [ActiveRecord::RecordNotFound] if the record isn't found
+      # @return [self] An instance of this model for the record with the specified id
+      def fetch(id, **options)
+        fetch_by_id(id, **options) || raise(
           IdentityCache::RecordNotFound, "Couldn't find #{name} with ID=#{id}"
         )
       end
@@ -131,6 +159,15 @@ module IdentityCache
       def expire_primary_key_cache_index(id)
         cached_primary_index.expire(id)
       end
+
+      private
+
+      def inherited(subclass)
+        super
+        subclass.class_eval do
+          @cached_primary_index = nil
+        end
+      end
     end
   end
 end

data/lib/identity_cache/without_primary_index.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module WithoutPrimaryIndex
     extend ActiveSupport::Concern
@@ -12,9 +13,12 @@ module IdentityCache
     include IdentityCache::ShouldUseCache
     include ParentModelExpiration
 
-    def self.append_features(base) #:nodoc:
-      raise AlreadyIncludedError if base.include?(WithoutPrimaryIndex)
-      super
+    class << self
+      def append_features(base) # :nodoc:
+        raise AlreadyIncludedError if base.include?(WithoutPrimaryIndex)
+
+        super
+      end
     end
 
     included do

data/lib/identity_cache.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
-require 'active_record'
-require 'active_support/core_ext/module/attribute_accessors'
-require 'ar_transaction_changes'
+
+require "active_record"
+require "active_support/core_ext/module/attribute_accessors"
+require "ar_transaction_changes"
 
 require "identity_cache/version"
 require "identity_cache/record_not_found"
@@ -27,24 +28,24 @@ require "identity_cache/cached/reference/association"
 require "identity_cache/cached/reference/has_one"
 require "identity_cache/cached/reference/has_many"
 require "identity_cache/expiry_hook"
-require 'identity_cache/memoized_cache_proxy'
-require 'identity_cache/belongs_to_caching'
-require 'identity_cache/cache_key_generation'
-require 'identity_cache/configuration_dsl'
-require 'identity_cache/should_use_cache'
-require 'identity_cache/parent_model_expiration'
-require 'identity_cache/query_api'
+require "identity_cache/memoized_cache_proxy"
+require "identity_cache/belongs_to_caching"
+require "identity_cache/cache_key_generation"
+require "identity_cache/configuration_dsl"
+require "identity_cache/should_use_cache"
+require "identity_cache/parent_model_expiration"
+require "identity_cache/query_api"
 require "identity_cache/cache_hash"
 require "identity_cache/cache_invalidation"
 require "identity_cache/cache_fetcher"
 require "identity_cache/fallback_fetcher"
-require 'identity_cache/without_primary_index'
-require 'identity_cache/with_primary_index'
+require "identity_cache/without_primary_index"
+require "identity_cache/with_primary_index"
 
 module IdentityCache
   extend ActiveSupport::Concern
 
-  autoload :MemCacheStoreCAS, 'identity_cache/mem_cache_store_cas'
+  autoload :MemCacheStoreCAS, "identity_cache/mem_cache_store_cas"
 
   include WithPrimaryIndex
 
@@ -65,23 +66,26 @@ module IdentityCache
 
   class DerivedModelError < StandardError; end
 
+  class LockWaitTimeout < StandardError; end
+
   mattr_accessor :cache_namespace
   self.cache_namespace = "IDC:#{CACHE_VERSION}:"
 
   # Fetched records are not read-only and this could sometimes prevent IDC from
   # reflecting what's truly in the database when fetch_read_only_records is false.
   # When set to true, it will only return read-only records when cache is used.
-  mattr_accessor :fetch_read_only_records
-  self.fetch_read_only_records = true
+  @fetch_read_only_records = true
 
   class << self
     include IdentityCache::CacheHash
 
+    attr_writer :fetch_read_only_records
     attr_accessor :readonly
     attr_writer :logger
 
-    def append_features(base) #:nodoc:
+    def append_features(base) # :nodoc:
       raise AlreadyIncludedError if base.include?(IdentityCache)
+
       super
     end
 
@@ -141,10 +145,13 @@ module IdentityCache
     #
     # == Parameters
     # +key+ A cache key string
+    # +cache_fetcher_options+ A hash of options to pass to the cache backend
     #
-    def fetch(key)
+    def fetch(key, cache_fetcher_options = {})
       if should_use_cache?
-        unmap_cached_nil_for(cache.fetch(key) { map_cached_nil_for(yield) })
+        unmap_cached_nil_for(cache.fetch(key, cache_fetcher_options) do
+          map_cached_nil_for(yield)
+        end)
       else
         yield
       end
@@ -185,11 +192,18 @@ module IdentityCache
     end
 
     def with_fetch_read_only_records(value = true)
-      old_value = fetch_read_only_records
-      self.fetch_read_only_records = value
+      old_value = Thread.current[:identity_cache_fetch_read_only_records]
+      Thread.current[:identity_cache_fetch_read_only_records] = value
       yield
     ensure
-      self.fetch_read_only_records = old_value
+      Thread.current[:identity_cache_fetch_read_only_records] = old_value
+    end
+
+    def fetch_read_only_records
+      v = Thread.current[:identity_cache_fetch_read_only_records]
+      return v unless v.nil?
+
+      @fetch_read_only_records
     end
 
     def eager_load!
@@ -198,12 +212,12 @@ module IdentityCache
 
     private
 
-    def fetch_in_batches(keys)
+    def fetch_in_batches(keys, &block)
       keys.each_slice(BATCH_SIZE).each_with_object({}) do |slice, result|
-        result.merge!(cache.fetch_multi(*slice) { |missed_keys| yield missed_keys })
+        result.merge!(cache.fetch_multi(*slice, &block))
       end
     end
   end
 end
 
-require 'identity_cache/railtie' if defined?(Rails)
+require "identity_cache/railtie" if defined?(Rails)

data/performance/cache_runner.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
+
 $LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
-require 'active_record'
-require 'active_support/core_ext'
-require 'active_support/cache'
-require 'identity_cache'
-require 'memcached_store'
-require 'active_support/cache/memcached_store'
+require "active_record"
+require "active_support/core_ext"
+require "active_support/cache"
+require "identity_cache"
+require "memcached_store"
+require "active_support/cache/memcached_store"
 
-require File.dirname(__FILE__) + '/../test/helpers/active_record_objects'
-require File.dirname(__FILE__) + '/../test/helpers/database_connection'
-require File.dirname(__FILE__) + '/../test/helpers/cache_connection'
+require File.dirname(__FILE__) + "/../test/helpers/active_record_objects"
+require File.dirname(__FILE__) + "/../test/helpers/database_connection"
+require File.dirname(__FILE__) + "/../test/helpers/cache_connection"
 
 IdentityCache.logger = Logger.new(nil)
 CacheConnection.setup
@@ -31,6 +32,7 @@ def create_database(count)
   helper.setup_models
 
   return if database_ready(count)
+
   puts "Database not ready for performance testing, generating records"
 
   DatabaseConnection.drop_tables
@@ -38,6 +40,7 @@ def create_database(count)
   existing = Item.all
   (1..count).to_a.each do |i|
     next if existing.any? { |e| e.id == i }
+
     a = Item.new
     a.id = i
     a.associated = AssociatedRecord.new(name: "Associated for #{i}")

data/performance/cpu.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
-require 'rubygems'
-require 'benchmark'
 
-require_relative 'cache_runner'
+require "rubygems"
+require "benchmark"
+
+require_relative "cache_runner"
 
 RUNS = 400
 
@@ -32,9 +33,9 @@ def bmbm(runners)
   label_width = runners.map { |r| r.name.size }.max + 2
   width = label_width + Benchmark::CAPTION.size
 
-  puts 'Rehearsal: '.ljust(width, '-')
+  puts "Rehearsal: ".ljust(width, "-")
   benchmark(runners, label_width)
-  puts '-' * width
+  puts "-" * width
 
   benchmark(runners, label_width)
 end

data/performance/externals.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
-require 'rubygems'
-require 'benchmark'
-require 'ruby-prof'
 
-require_relative 'cache_runner'
+require "rubygems"
+require "benchmark"
+require "ruby-prof"
+
+require_relative "cache_runner"
 
 RUNS = 1000
 RubyProf.measure_mode = RubyProf::CPU_TIME
 
 EXTERNALS = { "Memcache" => ["MemCache#set", "MemCache#get"],
-              "Database" => ["Mysql2::Client#query"] }
+              "Database" => ["Mysql2::Client#query"], }
 
 def run(obj)
   obj.prepare

data/performance/profile.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
-require 'rubygems'
-require 'benchmark'
-require 'stackprof'
 
-require_relative 'cache_runner'
+require "rubygems"
+require "benchmark"
+require "stackprof"
+
+require_relative "cache_runner"
 
 RUNS = 1000
 
@@ -22,9 +23,9 @@ end
 
 create_database(RUNS)
 
-if (runner_name = ENV['RUNNER'])
+if (runner_name = ENV["RUNNER"])
   if (runner = CACHE_RUNNERS.find { |r| r.name == runner_name })
-    run(runner.new(RUNS), filename: ENV['FILENAME'])
+    run(runner.new(RUNS), filename: ENV["FILENAME"])
   else
     puts "Couldn't find cache runner #{runner_name.inspect}"
     exit(1)