second_level_cache 2.5.0 → 2.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3d60f7f52e3d34b0d49447bab88db697f929bf270435765ac8fed80d8d2da1c
-  data.tar.gz: 8f4cde5b59a3b37112d0471f2e0a5ccf1218745b7e63b07d125401f15203f693
+  metadata.gz: 84fecc39005beffa957b1602ff86ace6ca5419a1215d35011034ac6c78b5e0bf
+  data.tar.gz: f0a09a62d06ef9f10a1ee4559a4aac1b8e39eaa8a86ee81ce90d67212c9c1811
 SHA512:
-  metadata.gz: cddaaae90ae703a7b9ec9febdc3471b9839417a63d75c55b88d622e6d016358467ff8cc19e0a292adacc3c4391c3b7d679e56c544369bfac877d6a2f85a12dfb
-  data.tar.gz: c5968feec18ad66efa1cee8f379330695276703b65d8a36f0f4943957cdcb107cb855fa2ae660a4e91d90f64abd39556e510b108cad728085fd191f08e502bc7
+  metadata.gz: 40c406b9b4181c5e1085127bbab26b71c5a47842d685521b9fa1ec43e58e529d8591c24ae675760ed2a3dcc9644dca7fcb6db12a5e651b67670af413c16addcc
+  data.tar.gz: fc5f6ee2184884f4580123550e3d3edbb113114de4f7dacad340ef8c37711e9388335fdf029a06971fefe6a666ae0ca615f2852101384f986750333c3f85b0de

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+2.6.2
+-------
+
+- Fix activerecord association cache. (#109)
+- Fix fetch_by_uniq_key cache key with prefix. (#120)
+
+2.6.1
+-------
+
+- Improve proload debug log output, and deprecated logger method. (#106)
+
+2.6.0
+-------
+
+- Add has_one through cache support. (#98)
+- Fix string query, eager_load, includes/preload for fetch from db. ( #103, #102, #101)
+- Fix preloader if exists default scope. (#104)
+- Change cache hit log as `DEBUG` level. (#105)
+
+2.5.3
+-------
+
+- Fix `fetch_by_uniq_keys` method that cache incorrect when A record modified uniq key and B reocrd used old uniq key of A record (#96)
+
+2.5.2
+-------
+
+- Fix methods argument as keyword warning in Ruby 2.7. (#94)
+
+2.5.1
+-------
+
+- Fix cache expire issue for SoftDelete cases.
+
 2.5.0
 -------
 

data/README.md

@@ -134,7 +134,7 @@ config.cache_store = [:dalli_store, APP_CONFIG["memcached_host"], { namespace: "
 ## Tips:
 
 * When you want to clear only second level cache apart from other cache for example fragment cache in cache store,
-you can only change the `cache_key_prefix`:
+you can only change the `cache_key_prefix` (default: `slc`):
 
 ```ruby
 SecondLevelCache.configure.cache_key_prefix = "slc1"

data/lib/second_level_cache.rb

@@ -5,6 +5,7 @@ require "second_level_cache/config"
 require "second_level_cache/record_marshal"
 require "second_level_cache/record_relation"
 require "second_level_cache/active_record"
+require "second_level_cache/log_subscriber"
 
 module SecondLevelCache
   def self.configure

data/lib/second_level_cache/active_record.rb

@@ -12,7 +12,13 @@ require "second_level_cache/active_record/preloader"
 
 # http://api.rubyonrails.org/classes/ActiveSupport/LazyLoadHooks.html
 # ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
-ActiveSupport.on_load(:active_record) do
+ActiveSupport.on_load(:active_record, run_once: true) do
+  if (Bundler.definition.gem("paranoia") rescue false)
+    require "second_level_cache/adapter/paranoia"
+    include SecondLevelCache::Adapter::Paranoia::ActiveRecord
+    SecondLevelCache::Mixin.send(:prepend, SecondLevelCache::Adapter::Paranoia::Mixin)
+  end
+
   include SecondLevelCache::Mixin
   prepend SecondLevelCache::ActiveRecord::Base
   extend SecondLevelCache::ActiveRecord::FetchByUniqKey
@@ -23,5 +29,5 @@ ActiveSupport.on_load(:active_record) do
   ActiveRecord::Relation.send(:prepend, SecondLevelCache::ActiveRecord::FinderMethods)
   # Rails 5.2 has removed ActiveRecord::Associations::Preloader::BelongsTo
   # https://github.com/rails/rails/pull/31079
-  ActiveRecord::Associations::Preloader::Association.send(:prepend, SecondLevelCache::ActiveRecord::Associations::Preloader::BelongsTo)
+  ActiveRecord::Associations::Preloader::Association.send(:prepend, SecondLevelCache::ActiveRecord::Associations::Preloader)
 end

data/lib/second_level_cache/active_record/base.rb

@@ -6,11 +6,7 @@ module SecondLevelCache
       def self.prepended(base)
         base.after_commit :update_second_level_cache, on: :update
         base.after_commit :write_second_level_cache, on: :create
-        if defined?(::Paranoia)
-          base.after_destroy :expire_second_level_cache
-        else
-          base.after_commit :expire_second_level_cache, on: :destroy
-        end
+        base.after_commit :expire_second_level_cache, on: :destroy
 
         class << base
           prepend ClassMethods

data/lib/second_level_cache/active_record/belongs_to_association.rb

@@ -6,6 +6,9 @@ module SecondLevelCache
       module BelongsToAssociation
         def find_target
           return super unless klass.second_level_cache_enabled?
+          return super if klass.default_scopes.present? || reflection.scope
+          return super if reflection.active_record_primary_key.to_s != klass.primary_key
+
           cache_record = klass.read_second_level_cache(second_level_cache_key)
           if cache_record
             return cache_record.tap { |record| set_inverse_instance(record) }
@@ -21,10 +24,9 @@ module SecondLevelCache
         end
 
         private
-
-        def second_level_cache_key
-          owner[reflection.foreign_key]
-        end
+          def second_level_cache_key
+            owner[reflection.foreign_key]
+          end
       end
     end
   end

data/lib/second_level_cache/active_record/fetch_by_uniq_key.rb

@@ -6,19 +6,22 @@ module SecondLevelCache
       def fetch_by_uniq_keys(where_values)
         cache_key = cache_uniq_key(where_values)
         obj_id = SecondLevelCache.cache_store.read(cache_key)
+
         if obj_id
-          begin
-            return find(obj_id)
-          rescue StandardError
-            return nil
-          end
+          record = begin
+                     find(obj_id)
+                   rescue StandardError
+                     nil
+                   end
         end
-
+        return record if record_attributes_equal_where_values?(record, where_values)
         record = where(where_values).first
-        return nil unless record
-
-        record.tap do |r|
-          SecondLevelCache.cache_store.write(cache_key, r.id)
+        if record
+          SecondLevelCache.cache_store.write(cache_key, record.id)
+          record
+        else
+          SecondLevelCache.cache_store.delete(cache_key)
+          nil
         end
       end
 
@@ -39,16 +42,20 @@ module SecondLevelCache
       end
 
       private
+        def cache_uniq_key(where_values)
+          keys = where_values.collect do |k, v|
+            v = Digest::MD5.hexdigest(v) if v.respond_to?(:size) && v.size >= 32
+            [k, v].join("_")
+          end
 
-      def cache_uniq_key(where_values)
-        keys = where_values.collect do |k, v|
-          v = Digest::MD5.hexdigest(v) if v && v.size >= 32
-          [k, v].join("_")
+          ext_key = keys.join(",")
+          "#{SecondLevelCache.configure.cache_key_prefix}/uniq_key_#{name}_#{ext_key}"
         end
 
-        ext_key = keys.join(",")
-        "uniq_key_#{name}_#{ext_key}"
-      end
+        def record_attributes_equal_where_values?(record, where_values)
+          # https://api.rubyonrails.org/classes/ActiveRecord/ModelSchema/ClassMethods.html#method-i-type_for_attribute
+          where_values.all? { |k, v| record&.read_attribute(k) == type_for_attribute(k).cast(v) }
+        end
     end
   end
 end

data/lib/second_level_cache/active_record/finder_methods.rb

@@ -17,20 +17,13 @@ module SecondLevelCache
       #     Article.where("articles.user_id = 1").find(prams[:id])
       #     Article.where("user_id = 1 AND ...").find(params[:id])
       def find_one(id)
-        return super(id) unless second_level_cache_enabled?
-        return super(id) unless select_all_column?
+        return super unless cachable?
 
         id = id.id if ActiveRecord::Base == id
-        if cachable?
-          record = @klass.read_second_level_cache(id)
-          if record
-            if where_values_hash.blank? || where_values_match_cache?(record)
-              return record
-            end
-          end
-        end
+        record = @klass.read_second_level_cache(id)
+        return record if record && where_values_match_cache?(record)
 
-        record = super(id)
+        record = super
         record.write_second_level_cache
         record
       end
@@ -48,53 +41,62 @@ module SecondLevelCache
       #     User.where(age: 18).first
       #
       def first(limit = nil)
-        return super(limit) if limit.to_i > 1
+        return super if limit.to_i > 1
+        return super unless cachable?
         # only have primary_key condition in where
         if where_values_hash.length == 1 && where_values_hash.key?(primary_key)
           record = @klass.read_second_level_cache(where_values_hash[primary_key])
           return record if record
         end
 
-        record = super(limit)
-        record&.write_second_level_cache if select_all_column?
+        record = super
+        record&.write_second_level_cache
         record
       end
 
       private
+        # readonly_value - active_record/relation/query_methods.rb Rails 5.1 true/false
+        def cachable?
+          second_level_cache_enabled? &&
+            limit_one? &&
+            # !eager_loading? &&
+            includes_values.blank? &&
+            preload_values.blank? &&
+            eager_load_values.blank? &&
+            select_values.blank? &&
+            order_values_can_cache? &&
+            readonly_value.blank? &&
+            joins_values.blank? &&
+            !@klass.locking_enabled? &&
+            where_clause_predicates_all_equality?
+        end
 
-      # readonly_value - active_record/relation/query_methods.rb Rails 5.1 true/false
-      def cachable?
-        limit_one? &&
-          order_values.blank? &&
-          includes_values.blank? &&
-          preload_values.blank? &&
-          readonly_value.blank? &&
-          joins_values.blank? &&
-          !@klass.locking_enabled? &&
-          where_clause_match_equality?
-      end
+        def order_values_can_cache?
+          return true if order_values.empty?
+          return false unless order_values.one?
+          return true if order_values.first == klass.primary_key
+          return false unless order_values.first.is_a?(::Arel::Nodes::Ordering)
+          return true if order_values.first.expr == klass.primary_key
+          order_values.first.expr.try(:name) == klass.primary_key
+        end
 
-      def where_clause_match_equality?
-        where_values_hash.all?
-      end
+        def where_clause_predicates_all_equality?
+          where_clause.send(:predicates).size == where_values_hash.size
+        end
 
-      def where_values_match_cache?(record)
-        where_values_hash.all? do |key, value|
-          if value.is_a?(Array)
-            value.include?(record.read_attribute(key))
-          else
-            record.read_attribute(key) == value
+        def where_values_match_cache?(record)
+          where_values_hash.all? do |key, value|
+            if value.is_a?(Array)
+              value.include?(record.read_attribute(key))
+            else
+              record.read_attribute(key) == value
+            end
           end
         end
-      end
 
-      def limit_one?
-        limit_value.blank? || limit_value == 1
-      end
-
-      def select_all_column?
-        select_values.blank?
-      end
+        def limit_one?
+          limit_value.blank? || limit_value == 1
+        end
     end
   end
 end

data/lib/second_level_cache/active_record/has_one_association.rb

@@ -6,31 +6,25 @@ module SecondLevelCache
       module HasOneAssociation
         def find_target
           return super unless klass.second_level_cache_enabled?
-          return super if reflection.options[:through] || reflection.scope
-          # TODO: implement cache with has_one through, scope
+          return super if klass.default_scopes.present? || reflection.scope
+          # TODO: implement cache with has_one scope
 
-          owner_primary_key = owner[reflection.active_record_primary_key]
-          if reflection.options[:as]
-            keys = {
-              reflection.foreign_key => owner_primary_key,
-              reflection.type => owner.class.base_class.name
-            }
-            cache_record = klass.fetch_by_uniq_keys(keys)
+          through = reflection.options[:through]
+          record  = if through
+            return super unless klass.reflections[through.to_s].klass.second_level_cache_enabled?
+            begin
+              reflection.klass.find(owner.send(through).read_attribute(reflection.foreign_key))
+            rescue StandardError
+              nil
+            end
           else
-            cache_record = klass.fetch_by_uniq_key(owner_primary_key, reflection.foreign_key)
+            uniq_keys = { reflection.foreign_key => owner[reflection.active_record_primary_key] }
+            uniq_keys[reflection.type] = owner.class.base_class.name if reflection.options[:as]
+            klass.fetch_by_uniq_keys(uniq_keys)
           end
 
-          if cache_record
-            return cache_record.tap { |record| set_inverse_instance(record) }
-          end
-
-          record = super
           return nil unless record
-
-          record.tap do |r|
-            set_inverse_instance(r)
-            r.write_second_level_cache
-          end
+          record.tap { |r| set_inverse_instance(r) }
         end
       end
     end

data/lib/second_level_cache/active_record/persistence.rb

@@ -4,17 +4,21 @@ module SecondLevelCache
   module ActiveRecord
     module Persistence
       # update_column will call update_columns
+      # https://github.com/rails/rails/blob/5-0-stable/activerecord/lib/active_record/persistence.rb#L315
       def update_columns(attributes)
         super(attributes).tap { update_second_level_cache }
       end
 
+      # https://github.com/rails/rails/blob/5-0-stable/activerecord/lib/active_record/persistence.rb#L441
       def reload(options = nil)
         expire_second_level_cache
         super(options)
       end
 
-      def touch(*names)
-        super(*names).tap { update_second_level_cache }
+      # https://github.com/rails/rails/blob/5-0-stable/activerecord/lib/active_record/persistence.rb#L490
+      def touch(*names, **opts)
+        # super: touch(*names, time: nil)
+        super(*names, **opts).tap { update_second_level_cache }
       end
     end
   end

data/lib/second_level_cache/active_record/preloader.rb

@@ -3,42 +3,48 @@
 module SecondLevelCache
   module ActiveRecord
     module Associations
-      class Preloader
-        module BelongsTo
-          def records_for(ids, &block)
-            return super(ids, &block) unless reflection.is_a?(::ActiveRecord::Reflection::BelongsToReflection)
-            return super(ids, &block) unless klass.second_level_cache_enabled?
-
-            map_cache_keys = ids.map { |id| klass.second_level_cache_key(id) }
-            records_from_cache = ::SecondLevelCache.cache_store.read_multi(*map_cache_keys)
-            # NOTICE
-            # Rails.cache.read_multi return hash that has keys only hitted.
-            # eg. Rails.cache.read_multi(1,2,3) => {2 => hit_value, 3 => hit_value}
-            hitted_ids = records_from_cache.map { |key, _| key.split("/")[2] }
-            missed_ids = ids.map(&:to_s) - hitted_ids
-
-            ::SecondLevelCache.logger.info "missed ids -> #{missed_ids.join(',')} | hitted ids -> #{hitted_ids.join(',')}"
-
-            record_marshals = RecordMarshal.load_multi(records_from_cache.values)
-
-            if missed_ids.empty?
-              return SecondLevelCache::RecordRelation.new(record_marshals)
+      module Preloader
+        RAILS6 = ::ActiveRecord.version >= ::Gem::Version.new("6")
+
+        def records_for(ids, &block)
+          return super unless klass.second_level_cache_enabled?
+          return super unless reflection.is_a?(::ActiveRecord::Reflection::BelongsToReflection)
+          return super if klass.default_scopes.present? || reflection.scope
+          return super if association_key_name.to_s != klass.primary_key
+
+          map_cache_keys = ids.map { |id| klass.second_level_cache_key(id) }
+          records_from_cache = ::SecondLevelCache.cache_store.read_multi(*map_cache_keys)
+
+          record_marshals = if RAILS6
+            RecordMarshal.load_multi(records_from_cache.values) do |record|
+              # This block is copy from:
+              # https://github.com/rails/rails/blob/6-0-stable/activerecord/lib/active_record/associations/preloader/association.rb#L101
+              owner = owners_by_key[convert_key(record[association_key_name])].first
+              association = owner.association(reflection.name)
+              association.set_inverse_instance(record)
             end
+          else
+            RecordMarshal.load_multi(records_from_cache.values, &block)
+          end
 
-            records_from_db = super(missed_ids, &block)
-            records_from_db.map do |r|
-              write_cache(r)
-            end
+          # NOTICE
+          # Rails.cache.read_multi return hash that has keys only hitted.
+          # eg. Rails.cache.read_multi(1,2,3) => {2 => hit_value, 3 => hit_value}
+          hitted_ids = record_marshals.map { |record| record.read_attribute(association_key_name).to_s }
+          missed_ids = ids.map(&:to_s) - hitted_ids
+          ActiveSupport::Notifications.instrument("preload.second_level_cache", key: association_key_name, hit: hitted_ids, miss: missed_ids)
+          return SecondLevelCache::RecordRelation.new(record_marshals) if missed_ids.empty?
 
-            SecondLevelCache::RecordRelation.new(records_from_db + record_marshals)
-          end
+          records_from_db = super(missed_ids, &block)
+          records_from_db.map { |r| write_cache(r) }
 
-          private
+          SecondLevelCache::RecordRelation.new(records_from_db + record_marshals)
+        end
 
+        private
           def write_cache(record)
             record.write_second_level_cache
           end
-        end
       end
     end
   end