activesupport 6.0.3.7 → 7.0.0

data/lib/active_support/cache/redis_cache_store.rb

@@ -15,8 +15,7 @@ begin
 rescue LoadError
 end
 
-require "digest/sha2"
-require "active_support/core_ext/marshal"
+require "active_support/digest"
 
 module ActiveSupport
   module Cache
@@ -46,7 +45,7 @@ module ActiveSupport
     #   4.0.1+ for distributed mget support.
     # * +delete_matched+ support for Redis KEYS globs.
     class RedisCacheStore < Store
-      # Keys are truncated with their own SHA2 digest if they exceed 1kB
+      # Keys are truncated with the ActiveSupport digest if they exceed 1kB
       MAX_KEY_BYTESIZE = 1024
 
       DEFAULT_REDIS_OPTIONS = {
@@ -71,35 +70,7 @@ module ActiveSupport
         true
       end
 
-      # Support raw values in the local cache strategy.
-      module LocalCacheWithRaw # :nodoc:
-        private
-          def write_entry(key, entry, **options)
-            if options[:raw] && local_cache
-              raw_entry = Entry.new(serialize_entry(entry, raw: true))
-              raw_entry.expires_at = entry.expires_at
-              super(key, raw_entry, **options)
-            else
-              super
-            end
-          end
-
-          def write_multi_entries(entries, **options)
-            if options[:raw] && local_cache
-              raw_entries = entries.map do |key, entry|
-                raw_entry = Entry.new(serialize_entry(entry, raw: true))
-                raw_entry.expires_at = entry.expires_at
-              end.to_h
-
-              super(raw_entries, **options)
-            else
-              super
-            end
-          end
-      end
-
       prepend Strategy::LocalCache
-      prepend LocalCacheWithRaw
 
       class << self
         # Factory method to create a new Redis instance.
@@ -113,7 +84,7 @@ module ActiveSupport
         #   :url    String  ->  Redis.new(url: …)
         #   :url    Array   ->  Redis::Distributed.new([{ url: … }, { url: … }, …])
         #
-        def build_redis(redis: nil, url: nil, **redis_options) #:nodoc:
+        def build_redis(redis: nil, url: nil, **redis_options) # :nodoc:
           urls = Array(url)
 
           if redis.is_a?(Proc)
@@ -169,7 +140,7 @@ module ActiveSupport
       # Race condition TTL is not set by default. This can be used to avoid
       # "thundering herd" cache writes when hot cache entries are expired.
       # See <tt>ActiveSupport::Cache::Store#fetch</tt> for more.
-      def initialize(namespace: nil, compress: true, compress_threshold: 1.kilobyte, expires_in: nil, race_condition_ttl: nil, error_handler: DEFAULT_ERROR_HANDLER, **redis_options)
+      def initialize(namespace: nil, compress: true, compress_threshold: 1.kilobyte, coder: default_coder, expires_in: nil, race_condition_ttl: nil, error_handler: DEFAULT_ERROR_HANDLER, **redis_options)
         @redis_options = redis_options
 
         @max_key_bytesize = MAX_KEY_BYTESIZE
@@ -177,7 +148,8 @@ module ActiveSupport
 
         super namespace: namespace,
           compress: compress, compress_threshold: compress_threshold,
-          expires_in: expires_in, race_condition_ttl: race_condition_ttl
+          expires_in: expires_in, race_condition_ttl: race_condition_ttl,
+          coder: coder
       end
 
       def redis
@@ -195,7 +167,7 @@ module ActiveSupport
 
       def inspect
         instance = @redis || @redis_options
-        "<##{self.class} options=#{options.inspect} redis=#{instance.inspect}>"
+        "#<#{self.class} options=#{options.inspect} redis=#{instance.inspect}>"
       end
 
       # Cache Store API implementation.
@@ -238,10 +210,14 @@ module ActiveSupport
             pattern = namespace_key(matcher, options)
             cursor = "0"
             # Fetch keys in batches using SCAN to avoid blocking the Redis server.
-            begin
-              cursor, keys = c.scan(cursor, match: pattern, count: SCAN_BATCH_SIZE)
-              c.del(*keys) unless keys.empty?
-            end until cursor == "0"
+            nodes = c.respond_to?(:nodes) ? c.nodes : [c]
+
+            nodes.each do |node|
+              begin
+                cursor, keys = node.scan(cursor, match: pattern, count: SCAN_BATCH_SIZE)
+                node.del(*keys) unless keys.empty?
+              end until cursor == "0"
+            end
           end
         end
       end
@@ -314,12 +290,17 @@ module ActiveSupport
         end
       end
 
-      def mget_capable? #:nodoc:
+      # Get info from redis servers.
+      def stats
+        redis.with { |c| c.info }
+      end
+
+      def mget_capable? # :nodoc:
         set_redis_capabilities unless defined? @mget_capable
         @mget_capable
       end
 
-      def mset_capable? #:nodoc:
+      def mset_capable? # :nodoc:
         set_redis_capabilities unless defined? @mset_capable
         @mset_capable
       end
@@ -339,15 +320,18 @@ module ActiveSupport
         # Store provider interface:
         # Read an entry from the cache.
         def read_entry(key, **options)
+          deserialize_entry(read_serialized_entry(key, **options), **options)
+        end
+
+        def read_serialized_entry(key, raw: false, **options)
           failsafe :read_entry do
-            raw = options&.fetch(:raw, false)
-            deserialize_entry(redis.with { |c| c.get(key) }, raw: raw)
+            redis.with { |c| c.get(key) }
           end
         end
 
         def read_multi_entries(names, **options)
           if mget_capable?
-            read_multi_mget(*names)
+            read_multi_mget(*names, **options)
           else
             super
           end
@@ -378,9 +362,11 @@ module ActiveSupport
         # Write an entry to the cache.
         #
         # Requires Redis 2.6.12+ for extended SET options.
-        def write_entry(key, entry, unless_exist: false, raw: false, expires_in: nil, race_condition_ttl: nil, **options)
-          serialized_entry = serialize_entry(entry, raw: raw)
+        def write_entry(key, entry, raw: false, **options)
+          write_serialized_entry(key, serialize_entry(entry, raw: raw, **options), raw: raw, **options)
+        end
 
+        def write_serialized_entry(key, payload, raw: false, unless_exist: false, expires_in: nil, race_condition_ttl: nil, **options)
           # If race condition TTL is in use, ensure that cache entries
           # stick around a bit longer after they would have expired
           # so we can purposefully serve stale entries.
@@ -388,16 +374,14 @@ module ActiveSupport
             expires_in += 5.minutes
           end
 
-          failsafe :write_entry, returning: false do
-            if unless_exist || expires_in
-              modifiers = {}
-              modifiers[:nx] = unless_exist
-              modifiers[:px] = (1000 * expires_in.to_f).ceil if expires_in
+          modifiers = {}
+          if unless_exist || expires_in
+            modifiers[:nx] = unless_exist
+            modifiers[:px] = (1000 * expires_in.to_f).ceil if expires_in
+          end
 
-              redis.with { |c| c.set key, serialized_entry, modifiers }
-            else
-              redis.with { |c| c.set key, serialized_entry }
-            end
+          failsafe :write_entry, returning: false do
+            redis.with { |c| c.set key, payload, **modifiers }
           end
         end
 
@@ -414,12 +398,20 @@ module ActiveSupport
           end
         end
 
+        # Deletes multiple entries in the cache. Returns the number of entries deleted.
+        def delete_multi_entries(entries, **_options)
+          redis.with { |c| c.del(entries) }
+        end
+
         # Nonstandard store provider API to write multiple values at once.
         def write_multi_entries(entries, expires_in: nil, **options)
           if entries.any?
             if mset_capable? && expires_in.nil?
               failsafe :write_multi_entries do
-                redis.with { |c| c.mapped_mset(serialize_entries(entries, raw: options[:raw])) }
+                payload = serialize_entries(entries, **options)
+                redis.with do |c|
+                  c.mapped_mset(payload)
+                end
               end
             else
               super
@@ -429,12 +421,12 @@ module ActiveSupport
 
         # Truncate keys that exceed 1kB.
         def normalize_key(key, options)
-          truncate_key super.b
+          truncate_key super&.b
         end
 
         def truncate_key(key)
-          if key.bytesize > max_key_bytesize
-            suffix = ":sha2:#{::Digest::SHA2.hexdigest(key)}"
+          if key && key.bytesize > max_key_bytesize
+            suffix = ":hash:#{ActiveSupport::Digest.hexdigest(key)}"
             truncate_at = max_key_bytesize - suffix.bytesize
             "#{key.byteslice(0, truncate_at)}#{suffix}"
           else
@@ -442,52 +434,35 @@ module ActiveSupport
           end
         end
 
-        def deserialize_entry(serialized_entry, raw:)
-          if serialized_entry
-            entry = Marshal.load(serialized_entry) rescue serialized_entry
-
-            written_raw = serialized_entry.equal?(entry)
-            if raw != written_raw
-              ActiveSupport::Deprecation.warn(<<-MSG.squish)
-                Using a different value for the raw option when reading and writing
-                to a cache key is deprecated for :redis_cache_store and Rails 6.0
-                will stop automatically detecting the format when reading to avoid
-                marshal loading untrusted raw strings.
-              MSG
-            end
-
-            entry.is_a?(Entry) ? entry : Entry.new(entry)
+        def deserialize_entry(payload, raw: false, **)
+          if raw && !payload.nil?
+            Entry.new(payload)
+          else
+            super(payload)
           end
         end
 
-        def serialize_entry(entry, raw: false)
+        def serialize_entry(entry, raw: false, **options)
           if raw
             entry.value.to_s
           else
-            Marshal.dump(entry)
+            super(entry, raw: raw, **options)
           end
         end
 
-        def serialize_entries(entries, raw: false)
+        def serialize_entries(entries, **options)
           entries.transform_values do |entry|
-            serialize_entry entry, raw: raw
+            serialize_entry(entry, **options)
           end
         end
 
         def failsafe(method, returning: nil)
           yield
-        rescue ::Redis::BaseError => e
-          handle_exception exception: e, method: method, returning: returning
+        rescue ::Redis::BaseError => error
+          ActiveSupport.error_reporter&.report(error, handled: true, severity: :warning)
+          @error_handler&.call(method: method, exception: error, returning: returning)
           returning
         end
-
-        def handle_exception(exception:, method:, returning:)
-          if @error_handler
-            @error_handler.(method: method, exception: exception, returning: returning)
-          end
-        rescue => failsafe
-          warn "RedisCacheStore ignored exception in handle_exception: #{failsafe.class}: #{failsafe.message}\n  #{failsafe.backtrace.join("\n  ")}"
-        end
     end
   end
 end

data/lib/active_support/cache/strategy/local_cache.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/object/duplicable"
 require "active_support/core_ext/string/inflections"
-require "active_support/per_thread_registry"
 
 module ActiveSupport
   module Cache
@@ -14,74 +12,56 @@ module ActiveSupport
         autoload :Middleware, "active_support/cache/strategy/local_cache_middleware"
 
         # Class for storing and registering the local caches.
-        class LocalCacheRegistry # :nodoc:
-          extend ActiveSupport::PerThreadRegistry
-
-          def initialize
-            @registry = {}
-          end
+        module LocalCacheRegistry # :nodoc:
+          extend self
 
           def cache_for(local_cache_key)
-            @registry[local_cache_key]
+            registry = ActiveSupport::IsolatedExecutionState[:active_support_local_cache_registry] ||= {}
+            registry[local_cache_key]
           end
 
           def set_cache_for(local_cache_key, value)
-            @registry[local_cache_key] = value
+            registry = ActiveSupport::IsolatedExecutionState[:active_support_local_cache_registry] ||= {}
+            registry[local_cache_key] = value
           end
-
-          def self.set_cache_for(l, v); instance.set_cache_for l, v; end
-          def self.cache_for(l); instance.cache_for l; end
         end
 
         # Simple memory backed cache. This cache is not thread safe and is intended only
         # for serving as a temporary memory cache for a single thread.
-        class LocalStore < Store
+        class LocalStore
           def initialize
-            super
             @data = {}
           end
 
-          # Don't allow synchronizing since it isn't thread safe.
-          def synchronize # :nodoc:
-            yield
-          end
-
           def clear(options = nil)
             @data.clear
           end
 
-          def read_entry(key, **options)
+          def read_entry(key)
             @data[key]
           end
 
-          def read_multi_entries(keys, **options)
-            values = {}
-
-            keys.each do |name|
-              entry = read_entry(name, **options)
-              values[name] = entry.value if entry
-            end
-
-            values
+          def read_multi_entries(keys)
+            @data.slice(*keys)
           end
 
-          def write_entry(key, value, **options)
-            @data[key] = value
+          def write_entry(key, entry)
+            @data[key] = entry
             true
           end
 
-          def delete_entry(key, **options)
+          def delete_entry(key)
             !!@data.delete(key)
           end
 
-          def fetch_entry(key, options = nil) # :nodoc:
+          def fetch_entry(key) # :nodoc:
             @data.fetch(key) { @data[key] = yield }
           end
         end
 
         # Use a local cache for the duration of block.
-        def with_local_cache
-          use_temporary_local_cache(LocalStore.new) { yield }
+        def with_local_cache(&block)
+          use_temporary_local_cache(LocalStore.new, &block)
         end
 
         # Middleware class can be inserted as a Rack handler to be local cache for the
@@ -104,24 +84,36 @@ module ActiveSupport
           super
         end
 
+        def delete_matched(matcher, options = nil) # :nodoc:
+          return super unless cache = local_cache
+          cache.clear
+          super
+        end
+
         def increment(name, amount = 1, **options) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          write_cache_value(name, value, **options)
+          write_cache_value(name, value, raw: true, **options)
           value
         end
 
         def decrement(name, amount = 1, **options) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          write_cache_value(name, value, **options)
+          write_cache_value(name, value, raw: true, **options)
           value
         end
 
         private
-          def read_entry(key, **options)
+          def read_serialized_entry(key, raw: false, **options)
             if cache = local_cache
-              cache.fetch_entry(key) { super }
+              hit = true
+              entry = cache.fetch_entry(key) do
+                hit = false
+                super
+              end
+              options[:event][:store] = cache.class.name if hit && options[:event]
+              entry
             else
               super
             end
@@ -130,7 +122,7 @@ module ActiveSupport
           def read_multi_entries(keys, **options)
             return super unless local_cache
 
-            local_entries = local_cache.read_multi_entries(keys, **options)
+            local_entries = local_cache.read_multi_entries(keys)
             missed_keys = keys - local_entries.keys
 
             if missed_keys.any?
@@ -140,30 +132,27 @@ module ActiveSupport
             end
           end
 
-          def write_entry(key, entry, **options)
-            if options[:unless_exist]
-              local_cache.delete_entry(key, **options) if local_cache
+          def write_serialized_entry(key, payload, **)
+            if return_value = super
+              local_cache.write_entry(key, payload) if local_cache
             else
-              local_cache.write_entry(key, entry, **options) if local_cache
+              local_cache.delete_entry(key) if local_cache
             end
-
-            super
+            return_value
           end
 
-          def delete_entry(key, **options)
-            local_cache.delete_entry(key, **options) if local_cache
+          def delete_entry(key, **)
+            local_cache.delete_entry(key) if local_cache
             super
           end
 
           def write_cache_value(name, value, **options)
             name = normalize_key(name, options)
             cache = local_cache
-            cache.mute do
-              if value
-                cache.write(name, value, **options)
-              else
-                cache.delete(name, **options)
-              end
+            if value
+              cache.write_entry(name, serialize_entry(new_entry(value, **options), **options))
+            else
+              cache.delete_entry(name)
             end
           end
 
@@ -175,8 +164,8 @@ module ActiveSupport
             LocalCacheRegistry.cache_for(local_cache_key)
           end
 
-          def bypass_local_cache
-            use_temporary_local_cache(nil) { yield }
+          def bypass_local_cache(&block)
+            use_temporary_local_cache(nil, &block)
           end
 
           def use_temporary_local_cache(temporary_cache)