identity_cache 1.0.0 → 1.2.0

data/lib/identity_cache/with_primary_index.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module IdentityCache
   module WithPrimaryIndex
     extend ActiveSupport::Concern
@@ -57,7 +58,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 +98,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

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,23 +28,25 @@ 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"
+
   include WithPrimaryIndex
 
   CACHED_NIL = :idc_cached_nil
@@ -52,29 +55,37 @@ module IdentityCache
   DELETED_TTL = 1000
 
   class AlreadyIncludedError < StandardError; end
+
   class AssociationError < StandardError; end
+
   class InverseAssociationError < StandardError; end
+
   class UnsupportedScopeError < StandardError; end
+
   class UnsupportedAssociationError < StandardError; end
+
   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
 
@@ -105,8 +116,27 @@ module IdentityCache
     end
 
     def should_use_cache? # :nodoc:
-      pool = ActiveRecord::Base.connection_pool
-      !pool.active_connection? || pool.connection.open_transactions == 0
+      ActiveRecord::Base.connection_handler.connection_pool_list.none? do |pool|
+        pool.active_connection? &&
+          # Rails wraps each of your tests in a transaction, so that any changes
+          # made to the database during the test can be rolled back afterwards.
+          # These transactions are flagged as "unjoinable", which tries to make
+          # your application behave as if they weren't there. In particular:
+          #
+          #  - Opening another transaction during the test creates a savepoint,
+          #    which can be rolled back independently of the main transaction.
+          #  - When those nested transactions complete, any `after_commit`
+          #    callbacks for records modified during the transaction will run,
+          #    even though the changes haven't actually been committed yet.
+          #
+          # By ignoring unjoinable transactions, IdentityCache's behaviour
+          # during your test suite will more closely match production.
+          #
+          # When there are no open transactions, `current_transaction` returns a
+          # special `NullTransaction` object that is unjoinable, meaning we will
+          # use the cache.
+          pool.connection.current_transaction.joinable?
+      end
     end
 
     # Cache retrieval and miss resolver primitive; given a key it will try to
@@ -115,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
@@ -144,7 +177,7 @@ module IdentityCache
       result = if should_use_cache?
         fetch_in_batches(keys.uniq) do |missed_keys|
           results = yield missed_keys
-          results.map { |e| map_cached_nil_for e }
+          results.map { |e| map_cached_nil_for(e) }
         end
       else
         results = yield keys
@@ -159,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!
@@ -172,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}")
@@ -107,28 +110,6 @@ module DeletedRunner
   end
 end
 
-module ConflictRunner
-  def prepare
-    super
-    records = (1..@count).map { |id| ::Item.find(id) }
-    orig_resolve_cache_miss = ::Item.method(:resolve_cache_miss)
-
-    ::Item.define_singleton_method(:resolve_cache_miss) do |id|
-      records[id - 1].expire_cache
-      orig_resolve_cache_miss.call(id)
-    end
-    IdentityCache.cache.clear
-  end
-end
-
-module DeletedConflictRunner
-  include ConflictRunner
-  def prepare
-    super
-    (1..@count).each { |i| ::Item.find(i).expire_cache }
-  end
-end
-
 class EmbedRunner < CacheRunner
   def setup_models
     super
@@ -161,16 +142,6 @@ class FetchEmbedDeletedRunner < EmbedRunner
 end
 CACHE_RUNNERS << FetchEmbedDeletedRunner
 
-class FetchEmbedConflictRunner < EmbedRunner
-  include ConflictRunner
-end
-CACHE_RUNNERS << FetchEmbedConflictRunner
-
-class FetchEmbedDeletedConflictRunner < EmbedRunner
-  include DeletedConflictRunner
-end
-CACHE_RUNNERS << FetchEmbedDeletedConflictRunner
-
 class NormalizedRunner < CacheRunner
   def setup_models
     super
@@ -204,13 +175,3 @@ class FetchNormalizedDeletedRunner < NormalizedRunner
   include DeletedRunner
 end
 CACHE_RUNNERS << FetchNormalizedDeletedRunner
-
-class FetchNormalizedConflictRunner < EmbedRunner
-  include ConflictRunner
-end
-CACHE_RUNNERS << FetchNormalizedConflictRunner
-
-class FetchNormalizedDeletedConflictRunner < EmbedRunner
-  include DeletedConflictRunner
-end
-CACHE_RUNNERS << FetchNormalizedDeletedConflictRunner

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
 
@@ -23,7 +24,7 @@ end
 def benchmark(runners, label_width = 0)
   IdentityCache.cache.clear
   runners.each do |runner|
-    print "#{runner.name}: ".ljust(label_width)
+    print("#{runner.name}: ".ljust(label_width))
     puts run(runner.new(RUNS))
   end
 end
@@ -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)