identity_cache 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dedbf4998ab4c83ea5d6198af733c3165b9978bd509d9cb135aefd1c1979415d
-  data.tar.gz: 03cda95c71ef97b89d2b321cbbf8737f12cb841a7eb89bc072419e3fb06b9b9d
+  metadata.gz: 0d167207235c4ac1deec2f1d6f383949b4c74031733c72ab700471b7f5a66407
+  data.tar.gz: 55e77933d0fbc095d1cad6ba038b2900edecb268504ff2238628828b10de9d39
 SHA512:
-  metadata.gz: 9e81b1259c650b6043e890ea3cdcba24c8e27442ae1609868c82eb1ec2fc2cfb89aae26693bda3cd5489937e78ab959d2fc8c101528238ebdb02bd20832d1408
-  data.tar.gz: f5bec7a26ff5d896915c6644d475f92429934f179e5d51e8eff9cfa491c117451d542ef6c745509bfead84b631df08ff8f9c8f5dba4b6076ee5b1baf789e94c6
+  metadata.gz: 270532b8a523b9f14f1d55c6a147d83844b4b4fb0b4b954d696bacc6de0437835dd3244126f136013450160de488e4c834211e86d9a2da8b191042fdaea63d93
+  data.tar.gz: 3bba5cd0734150975ef4b475c00f1c15d72c3a0d919dc84c6abd6b51ed7c9dc309dcb647d01212d6028f1c37a73a23cbab00daa3521a4aeaccbffcf9a01f3d09

data/CHANGELOG.md

@@ -1,6 +1,16 @@
 # Identity Cache Changelog
 
-## unreleased
+## Unreleased
+
+## 1.4.0
+
+### Features
+- Add `fetch_multi_by` support for composite-key indexes. (#534)
+
+## 1.3.1
+
+### Fixes
+- Remove N+1 queries from embedded associations when using `fetch` while `should_use_cache` is false. (#531)
 
 ## 1.3.0
 

data/README.md

@@ -101,7 +101,15 @@ product = Product.fetch_by_handle(handle)
 # Fetch multiple products by providing an array of index values.
 products = Product.fetch_multi_by_handle(handles)
 
+# Fetch a single product by providing composite attributes.
 products = Product.fetch_by_vendor_and_product_type(vendor, product_type)
+
+# Fetch multiple products by providing an array of composite attributes.
+products = Product.fetch_multi_by_vendor_and_product_type([
+  [vendor_1, product_type_1],
+  [vendor_2, product_type_2],
+  # ...
+])
 ```
 
 This gives you a lot of freedom to use your objects the way you want to, and doesn't get in your way. This does keep an independent cache copy in Memcached so you might want to watch the number of different caches that are being added.
@@ -254,11 +262,26 @@ Cache keys include a version number by default, specified in `IdentityCache::CAC
 
 ## Caveats
 
-A word of warning. If an `after_commit` fails before the cache expiry `after_commit` the cache will not be expired and you will be left with stale data.
-
-Since everything is being marshalled and unmarshalled from Memcached changing Ruby or Rails versions could mean your objects cannot be unmarshalled from Memcached. There are a number of ways to get around this such as namespacing keys when you upgrade or rescuing marshal load errors and treating it as a cache miss. Just something to be aware of if you are using IdentityCache and upgrade Ruby or Rails.
-
-IdentityCache is also very much _opt-in_ by deliberate design. This means IdentityCache does not mess with the way normal Rails associations work, and including it in a model won't change any clients of that model until you switch them to use `fetch` instead of `find`. This is because there is no way IdentityCache is ever going to be 100% consistent. Processes die, exceptions happen, and network blips occur, which means there is a chance that some database transaction might commit but the corresponding memcached cache invalidation operation does not make it. This means that you need to think carefully about when you use `fetch` and when you use `find`. For example, at Shopify, we never use any `fetch`ers on the path which moves money around, because IdentityCache could simply be wrong, and we want to charge people the right amount of money. We do however use the fetchers on performance critical paths where absolute correctness isn't the most important thing, and this is what IdentityCache is intended for.
+IdentityCache is never going to be 100% consistent, since cache invalidations can be lost. As such, it was intentionally designed to be _opt-in_, so it is only used where cache inconsistency is tolerated. This means IdentityCache does not mess with the way normal Rails associations work, and including it in a model won't change any clients of that model until you switch them to use `fetch` instead of `find`. This means that you need to think carefully about when you use `fetch` and when you use `find`.
+
+Expected sources of lost cache invalidations include:
+* Database write performed that doesn't trigger an after_commit callback
+* Process/system getting killed or crashing between the database commit and cache invalidation
+* Network unavailability, including transient failures, preventing the delivery of the cache invalidation
+* Memcached unavailability or failure preventing the processing of the cache invalidation request
+* Memcached flush / restart could remove a cache invalidation that would normally interrupt a cache fill that started when the cache key was absent. E.g.
+  1. cache key absent (not just invalidated)
+  2. process 1 reads cache key
+  3. process 1 starts reading from the database
+  4. process 2 writes to the database
+  5. process 2 writes a cache invalidation marker to cache key
+  6. memcached flush
+  7. process 1 uses an `ADD` operation, which succeeds in filling the cache with the now stale data
+* Rollout of cache namespace changes (e.g. from upgrading IdentityCache, adding columns, cached associations or from application changes to IdentityCache.cache_namespace) can result in cache fills to the new namespace that aren't invalidated by cache invalidations from a process still using the old namespace
+
+Cache expiration is meant to be used to help the system recover, but it only works if the application avoids using the cache data as a transaction to write data. IdentityCache avoids loading cached data from its methods during an open transaction, but can't prevent cache data that was loaded before the transaction was opened from being used in a transaction. IdentityCache won't help with scaling write traffic, it was intended for scaling database queries from read-only requests.
+
+IdentityCache also caches the absence of database values (e.g. to avoid performance problems when it is destroyed), so lost cache invalidations can also result in that value continuing to remain absent. As such, avoid sending the id of an uncommitted database record to another process (e.g. queuing it to a background job), since that could result in an attempt to read the record by its id before it has been created. A cache invalidation will still be attempted when the record is created, but that could be lost.
 
 ## Notes
 

data/lib/identity_cache/cached/attribute.rb

@@ -63,6 +63,48 @@ module IdentityCache
         unique ? results.first : results
       end
 
+      def fetch_multi(keys)
+        keys = keys.map { |key| cast_db_key(key) }
+
+        unless model.should_use_cache?
+          return load_multi_from_db(keys)
+        end
+
+        unordered_hash = CacheKeyLoader.load_multi(self, keys)
+
+        # Calling `values` on the result is expected to return the values in the same order as their
+        # corresponding keys. The fetch_multi_by_#{field_list} generated methods depend on this.
+        keys.each_with_object({}) do |key, ordered_hash|
+          ordered_hash[key] = unordered_hash.fetch(key)
+        end
+      end
+
+      def load_multi_from_db(keys)
+        result = {}
+        return result if keys.empty?
+
+        rows = load_multi_rows(keys)
+        default = unique ? nil : []
+        keys.each do |index_value|
+          result[index_value] = default.try!(:dup)
+        end
+        if unique
+          rows.each do |index_value, attribute_value|
+            result[index_value] = attribute_value
+          end
+        else
+          rows.each do |index_value, attribute_value|
+            result[index_value] << attribute_value
+          end
+        end
+        result
+      end
+
+      def cache_encode(db_value)
+        db_value
+      end
+      alias_method :cache_decode, :cache_encode
+
       private
 
       # @abstract
@@ -80,6 +122,11 @@ module IdentityCache
         raise NotImplementedError
       end
 
+      # @abstract
+      def load_multi_rows(_index_keys)
+        raise NotImplementedError
+      end
+
       # @abstract
       def cache_key_from_key_values(_key_values)
         raise NotImplementedError

data/lib/identity_cache/cached/attribute_by_multi.rb

@@ -6,9 +6,14 @@ module IdentityCache
       def build
         cached_attribute = self
 
-        model.define_singleton_method(:"fetch_#{fetch_method_suffix}") do |*key_values|
+        model.define_singleton_method(:"fetch_#{fetch_method_suffix}") do |*keys|
           raise_if_scoped
-          cached_attribute.fetch(key_values)
+          cached_attribute.fetch(keys)
+        end
+
+        model.define_singleton_method(:"fetch_multi_#{fetch_method_suffix}") do |keys|
+          raise_if_scoped
+          cached_attribute.fetch_multi(keys)
         end
       end
 
@@ -16,22 +21,102 @@ module IdentityCache
 
       # Attribute method overrides
 
-      def cast_db_key(key_values)
+      def cast_db_key(keys)
         field_types.each_with_index do |type, i|
-          key_values[i] = type.cast(key_values[i])
+          keys[i] = type.cast(keys[i])
         end
-        key_values
+        keys
       end
 
-      def unhashed_values_cache_key_string(key_values)
-        key_values.map { |v| v.try!(:to_s).inspect }.join("/")
+      def unhashed_values_cache_key_string(keys)
+        keys.map { |v| v.try!(:to_s).inspect }.join("/")
       end
 
-      def load_from_db_where_conditions(key_values)
-        Hash[key_fields.zip(key_values)]
+      def load_from_db_where_conditions(keys)
+        Hash[key_fields.zip(keys)]
+      end
+
+      def load_multi_rows(keys)
+        query = load_multi_rows_query(keys)
+        fields = key_fields
+        if (attribute_index = key_fields.index(attribute))
+          fields = fields.dup
+          fields.delete(attribute)
+        end
+
+        query.pluck(attribute, *fields).map do |attribute, *key_values|
+          key_values.insert(attribute_index, attribute) if attribute_index
+          [key_values, attribute]
+        end
       end
 
       alias_method :cache_key_from_key_values, :cache_key
+
+      # Helper methods
+
+      def load_multi_rows_query(keys)
+        # Find fields with a common value for the below common_query optimization
+        common_conditions = {}
+        other_field_indexes = []
+        key_fields.each_with_index do |field, i|
+          first_value = keys.first[i]
+          is_unique = keys.all? { |key_values| first_value == key_values[i] }
+
+          if is_unique
+            common_conditions[field] = first_value
+          else
+            other_field_indexes << i
+          end
+        end
+
+        common_query = if common_conditions.any?
+          # Optimization for the case of fields in which the key being searched
+          # for is always the same. This results in simple equality conditions
+          # being produced for these fields (e.g. "WHERE field = value").
+          unsorted_model.where(common_conditions)
+        end
+
+        case other_field_indexes.size
+        when 0
+          common_query
+        when 1
+          # Micro-optimization for the case of a single unique field.
+          # This results in a single "WHERE field IN (values)" statement being
+          # produced from a single query.
+          field_idx = other_field_indexes.first
+          field_name = key_fields[i]
+          field_values = keys.map { |key| key[field_idx] }
+          (common_query || unsorted_model).where(field_name => field_values)
+        else
+          # More than one unique field, so we need to generate a query for each
+          # set of values for each unique field.
+          #
+          # This results in multiple
+          #   "WHERE field = value AND field_2 = value_2 OR ..."
+          # statements being produced from an object like
+          #   [{ field: value, field_2: value_2 }, ...]
+          query = keys.reduce(nil) do |query, key|
+            condition = {}
+            other_field_indexes.each do |field_idx|
+              field = key_fields[field_idx]
+              condition[field] = key[field_idx]
+            end
+            subquery = unsorted_model.where(condition)
+
+            query ? query.or(subquery) : subquery
+          end
+
+          if common_query
+            common_query.merge(query)
+          else
+            query
+          end
+        end
+      end
+
+      def unsorted_model
+        model.reorder(nil)
+      end
     end
   end
 end

data/lib/identity_cache/cached/attribute_by_one.rb

@@ -24,46 +24,6 @@ module IdentityCache
         end
       end
 
-      def fetch_multi(keys)
-        keys = keys.map { |key| cast_db_key(key) }
-
-        unless model.should_use_cache?
-          return load_multi_from_db(keys)
-        end
-
-        unordered_hash = CacheKeyLoader.load_multi(self, keys)
-
-        # Calling `values` on the result is expected to return the values in the same order as their
-        # corresponding keys. The fetch_multi_by_#{field_list} generated methods depend on this.
-        ordered_hash = {}
-        keys.each { |key| ordered_hash[key] = unordered_hash.fetch(key) }
-        ordered_hash
-      end
-
-      def load_multi_from_db(keys)
-        rows = model.reorder(nil).where(load_from_db_where_conditions(keys)).pluck(key_field, attribute)
-        result = {}
-        default = unique ? nil : []
-        keys.each do |index_value|
-          result[index_value] = default.try!(:dup)
-        end
-        if unique
-          rows.each do |index_value, attribute_value|
-            result[index_value] = attribute_value
-          end
-        else
-          rows.each do |index_value, attribute_value|
-            result[index_value] << attribute_value
-          end
-        end
-        result
-      end
-
-      def cache_encode(db_value)
-        db_value
-      end
-      alias_method :cache_decode, :cache_encode
-
       private
 
       # Attribute method overrides
@@ -80,6 +40,10 @@ module IdentityCache
         { key_field => key_values }
       end
 
+      def load_multi_rows(keys)
+        model.reorder(nil).where(load_from_db_where_conditions(keys)).pluck(key_field, attribute)
+      end
+
       def cache_key_from_key_values(key_values)
         cache_key(key_values.first)
       end

data/lib/identity_cache/query_api.rb

@@ -70,6 +70,8 @@ module IdentityCache
         readonly: IdentityCache.fetch_read_only_records && should_use_cache?)
         return if records.empty?
 
+        return unless should_use_cache?
+
         records.each(&:readonly!) if readonly
         each_id_embedded_association do |cached_association|
           preload_id_embedded_association(records, cached_association)

data/lib/identity_cache/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module IdentityCache
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
   CACHE_VERSION = 8
 end

data/lib/identity_cache/with_primary_index.rb

@@ -35,8 +35,8 @@ module IdentityCache
       # Declares a new index in the cache for the class where IdentityCache was
       # included.
       #
-      # IdentityCache will add a fetch_by_field1_and_field2_and_...field for every
-      # index.
+      # IdentityCache will add a fetch_by_field1_and_field2_and_...field and
+      # fetch_multi_by_field1_and_field2_and_...field for every index.
       #
       # == Example:
       #
@@ -45,7 +45,10 @@ module IdentityCache
       #    cache_index :name, :vendor
       #  end
       #
-      # Will add Product.fetch_by_name_and_vendor
+      # Will add:
+      #
+      #   Product.fetch_by_name_and_vendor
+      #   Product.fetch_multi_by_name_and_vendor
       #
       # == Parameters
       #
@@ -82,15 +85,13 @@ module IdentityCache
           CODE
         end
 
-        if fields.length == 1
-          instance_eval(<<-CODE, __FILE__, __LINE__ + 1)
-            def fetch_multi_by_#{field_list}(index_values, includes: nil)
-              ids = fetch_multi_id_by_#{field_list}(index_values).values.flatten(1)
-              return ids if ids.empty?
-              fetch_multi(ids, includes: includes)
-            end
-          CODE
-        end
+        instance_eval(<<-CODE, __FILE__, __LINE__ + 1)
+          def fetch_multi_by_#{field_list}(index_values, includes: nil)
+            ids = fetch_multi_id_by_#{field_list}(index_values).values.flatten(1)
+            return ids if ids.empty?
+            fetch_multi(ids, includes: includes)
+          end
+        CODE
       end
 
       # Similar to ActiveRecord::Base#exists? will return true if the id can be

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: identity_cache
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Camilo Lopez
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-16 00:00:00.000000000 Z
+date: 2023-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -190,7 +190,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.10
 signing_key: 
 specification_version: 4
 summary: IdentityCache lets you specify how you want to cache your model objects,