second_level_cache 2.5.3 → 2.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57109a059ebed4c9d448fa28e474f19eef4ebf7b67e4ebbd728f2be852b61480
-  data.tar.gz: '049303d75a982adf35dfea344af63577dd9df1c09a28613bb4dec4332ef95de4'
+  metadata.gz: 9401e1e025a3e955471ae743711371608400fe8c7f451f74f8b4f73bbb7c9dd6
+  data.tar.gz: 47c05c11d57d26dfe5c990bf111a173d0864956d788c5c5ace70ca812ef3d629
 SHA512:
-  metadata.gz: 553a34ea48e7b3100ae819282c354ee0eb51e2d609b7c090bf477035b975a0e497158ca6f4b282add76c882fa7e94277fb39486aaf4e45c35c9e98088a2bbb34
-  data.tar.gz: 28a7f7ea7f32467e92097824559fbaebaf3d9dd0fe49443d7779e666cce3270f3378c8e77dae91bffbc5248c8fadd10f00a08ebbbe390641fa9e42007b917ba5
+  metadata.gz: 516d74db202dbd5d12f866b36a16b30e763a75fa88001c4ac5ab04ce1c73a2a2e412472ceda957401f9da303094d83c5a944b9c062d69e56116abdae76359256
+  data.tar.gz: b0f3440ffd9333d49ac957cc1db3c988f41276d57f18f874fa84fc664134a14ba0acfcc8b9f5001bab99243ef51c2492ca2ea8fe2768ac461b398a1b06504e65

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+2.6.4
+-------
+
+- Fix `undefined method klass` error for has_one through. (#123)
+
+2.6.3
+-------
+
+- Fix paranoia load error.
+
+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
 -------
 

data/README.md

@@ -4,7 +4,7 @@
 [![Build Status](https://travis-ci.org/hooopo/second_level_cache.svg?branch=master)](https://travis-ci.org/hooopo/second_level_cache)
 [![Code Climate](https://codeclimate.com/github/hooopo/second_level_cache.svg)](https://codeclimate.com/github/hooopo/second_level_cache)
 
-SecondLevelCache is a write-through and read-through caching library inspired by Cache Money and cache_fu, support ActiveRecord 4.
+SecondLevelCache is a write-through and read-through caching library inspired by Cache Money and cache_fu, support ActiveRecord 4, ActiveRecord 5 and ActiveRecord 6.
 
 Read-Through: Queries by ID, like `current_user.articles.find(params[:id])`, will first look in cache store and then look in the database for the results of that query. If there is a cache miss, it will populate the cache.
 
@@ -15,10 +15,10 @@ Write-Through: As objects are created, updated, and deleted, all of the caches a
 
 In your gem file:
 
-ActiveRecord 5.2:
+ActiveRecord 5.2 and 6.0:
 
 ```ruby
-gem 'second_level_cache', '~> 2.4.0'
+gem 'second_level_cache', '~> 2.6.3'
 ```
 
 ActiveRecord 5.0.x, 5.1.x:
@@ -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.dependencies.find { |x| x.name == "paranoia" }
+    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

@@ -14,14 +14,14 @@ module SecondLevelCache
                      nil
                    end
         end
-        return record if compare_record_attributes_with_where_values(record, where_values)
+        return record if record_attributes_equal_where_values?(record, where_values)
         record = where(where_values).first
         if record
           SecondLevelCache.cache_store.write(cache_key, record.id)
-          return record
+          record
         else
           SecondLevelCache.cache_store.delete(cache_key)
-          return nil
+          nil
         end
       end
 
@@ -42,33 +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("_")
+        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
+
+          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 compare_record_attributes_with_where_values(record, where_values)
-        return false unless record
-        where_values.all? do |k, v|
-          attribute_value = record.read_attribute(k)
-          attribute_value == case attribute_value
-                             when String
-                               v.to_s
-                             when Numeric
-                               v.to_f
-                             when Date
-                               v.to_date
-                             else # Maybe NilClass/?
-                               v
-                             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
 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,26 @@ 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 if klass.reflections[through.to_s].nil?
+            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/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