identity_cache 1.0.1 → 1.1.0

data/lib/identity_cache.rb

@@ -44,6 +44,8 @@ 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,10 +54,15 @@ 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
 
   mattr_accessor :cache_namespace
@@ -105,8 +112,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
@@ -118,7 +144,7 @@ module IdentityCache
     #
     def fetch(key)
       if should_use_cache?
-        unmap_cached_nil_for(cache.fetch(key) { map_cached_nil_for yield })
+        unmap_cached_nil_for(cache.fetch(key) { map_cached_nil_for(yield) })
       else
         yield
       end
@@ -144,7 +170,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

data/lib/identity_cache/cache_invalidation.rb

@@ -11,7 +11,7 @@ module IdentityCache
     private
 
     def clear_cached_associations
-      self.class.send(:all_cached_associations).each_value do |association|
+      self.class.all_cached_associations.each_value do |association|
         association.clear(self)
       end
     end

data/lib/identity_cache/cache_key_generation.rb

@@ -10,7 +10,7 @@ module IdentityCache
 
     def self.denormalized_schema_string(klass)
       schema_to_string(klass.columns).tap do |schema_string|
-        klass.send(:all_cached_associations).sort.each do |name, association|
+        klass.all_cached_associations.sort.each do |name, association|
           klass.send(:check_association_scope, name)
           association.validate if association.embedded?
           case association

data/lib/identity_cache/cached/belongs_to.rb

@@ -27,34 +27,41 @@ module IdentityCache
         end
       end
 
+      def write(owner_record, associated_record)
+        owner_record.instance_variable_set(records_variable_name, associated_record)
+      end
+
       def fetch(records)
         fetch_async(LoadStrategy::Eager, records) { |associated_records| associated_records }
       end
 
       def fetch_async(load_strategy, records)
         if reflection.polymorphic?
-          cache_keys_to_associated_ids = {}
+          type_fetcher_to_db_ids_hash = {}
 
           records.each do |owner_record|
             associated_id = owner_record.send(reflection.foreign_key)
             next unless associated_id && !owner_record.instance_variable_defined?(records_variable_name)
-            associated_cache_key = Object.const_get(
+            foreign_type_fetcher = Object.const_get(
               owner_record.send(reflection.foreign_type)
             ).cached_model.cached_primary_index
-            unless cache_keys_to_associated_ids[associated_cache_key]
-              cache_keys_to_associated_ids[associated_cache_key] = {}
-            end
-            cache_keys_to_associated_ids[associated_cache_key][associated_id] = owner_record
+            db_ids = type_fetcher_to_db_ids_hash[foreign_type_fetcher] ||= []
+            db_ids << associated_id
           end
 
-          load_strategy.load_batch(cache_keys_to_associated_ids) do |associated_records_by_cache_key|
+          load_strategy.load_batch(type_fetcher_to_db_ids_hash) do |batch_load_result|
             batch_records = []
-            associated_records_by_cache_key.each do |cache_key, associated_records|
-              associated_records.keys.each do |id, associated_record|
-                owner_record = cache_keys_to_associated_ids.fetch(cache_key).fetch(id)
-                batch_records << owner_record
-                owner_record.instance_variable_set(records_variable_name, associated_record)
-              end
+
+            records.each do |owner_record|
+              associated_id = owner_record.send(reflection.foreign_key)
+              next unless associated_id && !owner_record.instance_variable_defined?(records_variable_name)
+              foreign_type_fetcher = Object.const_get(
+                owner_record.send(reflection.foreign_type)
+              ).cached_model.cached_primary_index
+
+              associated_record = batch_load_result.fetch(foreign_type_fetcher).fetch(associated_id)
+              batch_records << owner_record
+              write(owner_record, associated_record)
             end
 
             yield batch_records
@@ -73,7 +80,7 @@ module IdentityCache
           ) do |associated_records_by_id|
             associated_records_by_id.each do |id, associated_record|
               owner_record = ids_to_owner_record.fetch(id)
-              owner_record.instance_variable_set(records_variable_name, associated_record)
+              write(owner_record, associated_record)
             end
 
             yield associated_records_by_id.values.compact

data/lib/identity_cache/cached/prefetcher.rb

@@ -37,14 +37,24 @@ module IdentityCache
         private
 
         def fetch_association(load_strategy, klass, association, records, &block)
-          unless records.first.class.should_use_cache?
-            ActiveRecord::Associations::Preloader.new.preload(records, association)
+          unless klass.should_use_cache?
+            preload_records(records, association)
             return yield
           end
 
           cached_association = klass.cached_association(association)
           cached_association.fetch_async(load_strategy, records, &block)
         end
+
+        if ActiveRecord.gem_version < Gem::Version.new("6.2.0.alpha")
+          def preload_records(records, association)
+            ActiveRecord::Associations::Preloader.new.preload(records, association)
+          end
+        else
+          def preload_records(records, association)
+            ActiveRecord::Associations::Preloader.new(records: records, associations: association).call
+          end
+        end
       end
     end
   end

data/lib/identity_cache/cached/primary_index.rb

@@ -60,7 +60,6 @@ module IdentityCache
       def load_multi_from_db(ids)
         return {} if ids.empty?
 
-        ids = ids.map { |id| model.connection.type_cast(id, id_column) }
         records = build_query(ids).to_a
         model.send(:setup_embedded_associations_on_miss, records)
         records.index_by(&:id)

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

@@ -11,25 +11,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 +75,30 @@ 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/reference/has_many.rb

@@ -20,8 +20,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

@@ -21,8 +21,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/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

@@ -12,6 +12,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
@@ -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

@@ -2,6 +2,7 @@
 module IdentityCache
   module ParentModelExpiration # :nodoc:
     extend ActiveSupport::Concern
+    include ArTransactionChanges
 
     class << self
       def add_parent_expiry_hook(cached_association)
@@ -20,6 +21,7 @@ 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 +38,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 +49,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

data/lib/identity_cache/query_api.rb

@@ -3,10 +3,6 @@ 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 +14,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
@@ -81,7 +82,7 @@ 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?
@@ -126,10 +127,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 +148,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 +182,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)