activesupport 7.1.0 → 7.2.0

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

@@ -131,17 +131,20 @@ module ActiveSupport
             end
           end
 
-          def read_multi_entries(keys, **options)
+          def read_multi_entries(names, **options)
             return super unless local_cache
 
-            local_entries = local_cache.read_multi_entries(keys)
+            keys_to_names = names.index_by { |name| normalize_key(name, options) }
+
+            local_entries = local_cache.read_multi_entries(keys_to_names.keys)
+            local_entries.transform_keys! { |key| keys_to_names[key] }
             local_entries.transform_values! do |payload|
-              deserialize_entry(payload)&.value
+              deserialize_entry(payload, **options)&.value
             end
-            missed_keys = keys - local_entries.keys
+            missed_names = names - local_entries.keys
 
-            if missed_keys.any?
-              local_entries.merge!(super(missed_keys, **options))
+            if missed_names.any?
+              local_entries.merge!(super(missed_names, **options))
             else
               local_entries
             end

data/lib/active_support/cache.rb

@@ -52,7 +52,7 @@ module ActiveSupport
       autoload :LocalCache, "active_support/cache/strategy/local_cache"
     end
 
-    @format_version = 6.1
+    @format_version = 7.0
 
     class << self
       attr_accessor :format_version
@@ -86,13 +86,7 @@ module ActiveSupport
         case store
         when Symbol
           options = parameters.extract_options!
-          # clean this up once Ruby 2.7 support is dropped
-          # see https://github.com/rails/rails/pull/41522#discussion_r581186602
-          if options.empty?
-            retrieve_store_class(store).new(*parameters)
-          else
-            retrieve_store_class(store).new(*parameters, **options)
-          end
+          retrieve_store_class(store).new(*parameters, **options)
         when Array
           lookup_store(*store)
         when nil
@@ -160,13 +154,13 @@ module ActiveSupport
     # Some implementations may not support all methods beyond the basic cache
     # methods of #fetch, #write, #read, #exist?, and #delete.
     #
-    # ActiveSupport::Cache::Store can store any Ruby object that is supported by
-    # its +coder+'s +dump+ and +load+ methods.
+    # +ActiveSupport::Cache::Store+ can store any Ruby object that is supported
+    # by its +coder+'s +dump+ and +load+ methods.
     #
     #   cache = ActiveSupport::Cache::MemoryStore.new
     #
     #   cache.read('city')   # => nil
-    #   cache.write('city', "Duckburgh")
+    #   cache.write('city', "Duckburgh") # => true
     #   cache.read('city')   # => "Duckburgh"
     #
     #   cache.write('not serializable', Proc.new {}) # => TypeError
@@ -206,24 +200,6 @@ module ActiveSupport
           def retrieve_pool_options(options)
             if options.key?(:pool)
               pool_options = options.delete(:pool)
-            elsif options.key?(:pool_size) || options.key?(:pool_timeout)
-              pool_options = {}
-
-              if options.key?(:pool_size)
-                ActiveSupport.deprecator.warn(<<~MSG)
-                  Using :pool_size is deprecated and will be removed in Rails 7.2.
-                  Use `pool: { size: #{options[:pool_size].inspect} }` instead.
-                MSG
-                pool_options[:size] = options.delete(:pool_size)
-              end
-
-              if options.key?(:pool_timeout)
-                ActiveSupport.deprecator.warn(<<~MSG)
-                  Using :pool_timeout is deprecated and will be removed in Rails 7.2.
-                  Use `pool: { timeout: #{options[:pool_timeout].inspect} }` instead.
-                MSG
-                pool_options[:timeout] = options.delete(:pool_timeout)
-              end
             else
               pool_options = true
             end
@@ -344,7 +320,7 @@ module ActiveSupport
 
       # Silences the logger within a block.
       def mute
-        previous_silence, @silence = defined?(@silence) && @silence, true
+        previous_silence, @silence = @silence, true
         yield
       ensure
         @silence = previous_silence
@@ -370,8 +346,8 @@ module ActiveSupport
       #
       # ==== Options
       #
-      # Internally, +fetch+ calls #read_entry, and calls #write_entry on a cache
-      # miss. Thus, +fetch+ supports the same options as #read and #write.
+      # Internally, +fetch+ calls +read_entry+, and calls +write_entry+ on a
+      # cache miss. Thus, +fetch+ supports the same options as #read and #write.
       # Additionally, +fetch+ supports the following options:
       #
       # * <tt>force: true</tt> - Forces a cache "miss," meaning we treat the
@@ -411,37 +387,53 @@ module ActiveSupport
       #   has elapsed.
       #
       #     # Set all values to expire after one minute.
-      #     cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 1.minute)
+      #     cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 1)
       #
-      #     cache.write('foo', 'original value')
+      #     cache.write("foo", "original value")
       #     val_1 = nil
       #     val_2 = nil
-      #     sleep 60
+      #     p cache.read("foo") # => "original value"
+      #
+      #     sleep 1 # wait until the cache expires
       #
-      #     Thread.new do
-      #       val_1 = cache.fetch('foo', race_condition_ttl: 10.seconds) do
+      #     t1 = Thread.new do
+      #       # fetch does the following:
+      #       # 1. gets an recent expired entry
+      #       # 2. extends the expiry by 2 seconds (race_condition_ttl)
+      #       # 3. regenerates the new value
+      #       val_1 = cache.fetch("foo", race_condition_ttl: 2) do
       #         sleep 1
-      #         'new value 1'
+      #         "new value 1"
       #       end
       #     end
       #
-      #     Thread.new do
-      #       val_2 = cache.fetch('foo', race_condition_ttl: 10.seconds) do
-      #         'new value 2'
-      #       end
+      #     # Wait until t1 extends the expiry of the entry
+      #     # but before generating the new value
+      #     sleep 0.1
+      #
+      #     val_2 = cache.fetch("foo", race_condition_ttl: 2) do
+      #       # This block won't be executed because t1 extended the expiry
+      #       "new value 2"
       #     end
       #
-      #     cache.fetch('foo') # => "original value"
-      #     sleep 10 # First thread extended the life of cache by another 10 seconds
-      #     cache.fetch('foo') # => "new value 1"
-      #     val_1 # => "new value 1"
-      #     val_2 # => "original value"
+      #     t1.join
+      #
+      #     p val_1 # => "new value 1"
+      #     p val_2 # => "oritinal value"
+      #     p cache.fetch("foo") # => "new value 1"
+      #
+      #     # The entry requires 3 seconds to expire (expires_in + race_condition_ttl)
+      #     # We have waited 2 seconds already (sleep(1) + t1.join) thus we need to wait 1
+      #     # more second to see the entry expire.
+      #     sleep 1
+      #
+      #     p cache.fetch("foo") # => nil
       #
       # ==== Dynamic Options
       #
-      # In some cases it may be necessary to to dynamically compute options based
-      # on the cached value. For this purpose, a ActiveSupport::Cache::WriteOptions
-      # instance is passed as a second argument to the block
+      # In some cases it may be necessary to dynamically compute options based
+      # on the cached value. To support this, an ActiveSupport::Cache::WriteOptions
+      # instance is passed as the second argument to the block. For example:
       #
       #     cache.fetch("authentication-token:#{user.id}") do |key, options|
       #       token = authenticate_to_service
@@ -449,12 +441,6 @@ module ActiveSupport
       #       token
       #     end
       #
-      # Only some options can be set dynamically:
-      #
-      #   - +:expires_in+
-      #   - +:expires_at+
-      #   - +:version+
-      #
       def fetch(name, options = nil, &block)
         if block_given?
           options = merged_options(options)
@@ -462,10 +448,20 @@ module ActiveSupport
 
           entry = nil
           unless options[:force]
-            instrument(:read, name, options) do |payload|
+            instrument(:read, key, options) do |payload|
               cached_entry = read_entry(key, **options, event: payload)
               entry = handle_expired_entry(cached_entry, key, options)
-              entry = nil if entry && entry.mismatched?(normalize_version(name, options))
+              if entry
+                if entry.mismatched?(normalize_version(name, options))
+                  entry = nil
+                else
+                  begin
+                    entry.value
+                  rescue DeserializationError
+                    entry = nil
+                  end
+                end
+              end
               payload[:super_operation] = :fetch if payload
               payload[:hit] = !!entry if payload
             end
@@ -474,7 +470,7 @@ module ActiveSupport
           if entry
             get_entry_value(entry, name, options)
           else
-            save_block_result_to_cache(name, options, &block)
+            save_block_result_to_cache(name, key, options, &block)
           end
         elsif options && options[:force]
           raise ArgumentError, "Missing block: Calling `Cache#fetch` with `force: true` requires a block."
@@ -504,7 +500,7 @@ module ActiveSupport
         key     = normalize_key(name, options)
         version = normalize_version(name, options)
 
-        instrument(:read, name, options) do |payload|
+        instrument(:read, key, options) do |payload|
           entry = read_entry(key, **options, event: payload)
 
           if entry
@@ -517,7 +513,12 @@ module ActiveSupport
               nil
             else
               payload[:hit] = true if payload
-              entry.value
+              begin
+                entry.value
+              rescue DeserializationError
+                payload[:hit] = false
+                nil
+              end
             end
           else
             payload[:hit] = false if payload
@@ -596,14 +597,14 @@ module ActiveSupport
         options = names.extract_options!
         options = merged_options(options)
 
-        instrument_multi :read_multi, names, options do |payload|
+        writes  = {}
+        ordered = instrument_multi :read_multi, names, options do |payload|
           if options[:force]
             reads = {}
           else
             reads = read_multi_entries(names, **options)
           end
 
-          writes  = {}
           ordered = names.index_with do |name|
             reads.fetch(name) { writes[name] = yield(name) }
           end
@@ -612,15 +613,20 @@ module ActiveSupport
           payload[:hits] = reads.keys
           payload[:super_operation] = :fetch_multi
 
-          write_multi(writes, options)
-
           ordered
         end
+
+        write_multi(writes, options)
+
+        ordered
       end
 
       # Writes the value to the cache with the key. The value must be supported
       # by the +coder+'s +dump+ and +load+ methods.
       #
+      # Returns +true+ if the write succeeded, +nil+ if there was an error talking
+      # to the cache backend, or +false+ if the write failed for another reason.
+      #
       # By default, cache entries larger than 1kB are compressed. Compression
       # allows more data to be stored in the same memory footprint, leading to
       # fewer cache evictions and higher hit rates.
@@ -653,10 +659,11 @@ module ActiveSupport
       # Other options will be handled by the specific cache store implementation.
       def write(name, value, options = nil)
         options = merged_options(options)
+        key = normalize_key(name, options)
 
-        instrument(:write, name, options) do
+        instrument(:write, key, options) do
           entry = Entry.new(value, **options.merge(version: normalize_version(name, options)))
-          write_entry(normalize_key(name, options), entry, **options)
+          write_entry(key, entry, **options)
         end
       end
 
@@ -666,9 +673,10 @@ module ActiveSupport
       # Options are passed to the underlying cache implementation.
       def delete(name, options = nil)
         options = merged_options(options)
+        key = normalize_key(name, options)
 
-        instrument(:delete, name) do
-          delete_entry(normalize_key(name, options), **options)
+        instrument(:delete, key) do
+          delete_entry(key, **options)
         end
       end
 
@@ -692,9 +700,10 @@ module ActiveSupport
       # Options are passed to the underlying cache implementation.
       def exist?(name, options = nil)
         options = merged_options(options)
+        key = normalize_key(name, options)
 
-        instrument(:exist?, name) do |payload|
-          entry = read_entry(normalize_key(name, options), **options, event: payload)
+        instrument(:exist?, key) do |payload|
+          entry = read_entry(key, **options, event: payload)
           (entry && !entry.expired? && !entry.mismatched?(normalize_version(name, options))) || false
         end
       end
@@ -752,14 +761,6 @@ module ActiveSupport
       private
         def default_serializer
           case Cache.format_version
-          when 6.1
-            ActiveSupport.deprecator.warn <<~EOM
-              Support for `config.active_support.cache_format_version = 6.1` has been deprecated and will be removed in Rails 7.2.
-
-              Check the Rails upgrade guide at https://guides.rubyonrails.org/upgrading_ruby_on_rails.html#new-activesupport-cache-serialization-format
-              for more information on how to upgrade.
-            EOM
-            Cache::SerializerWithFallback[:marshal_6_1]
           when 7.0
             Cache::SerializerWithFallback[:marshal_7_0]
           when 7.1
@@ -809,7 +810,7 @@ module ActiveSupport
           end
         end
 
-        def deserialize_entry(payload)
+        def deserialize_entry(payload, **)
           payload.nil? ? nil : @coder.load(payload)
         rescue DeserializationError
           nil
@@ -1007,7 +1008,7 @@ module ActiveSupport
               if multi
                 ": #{payload[:key].size} key(s) specified"
               elsif payload[:key]
-                ": #{normalize_key(payload[:key], options)}"
+                ": #{payload[:key]}"
               end
 
             debug_options = " (#{options.inspect})" unless options.blank?
@@ -1029,7 +1030,8 @@ module ActiveSupport
               # When an entry has a positive :race_condition_ttl defined, put the stale entry back into the cache
               # for a brief period while the entry is being recalculated.
               entry.expires_at = Time.now.to_f + race_ttl
-              write_entry(key, entry, expires_in: race_ttl * 2)
+              options[:expires_in] = race_ttl * 2
+              write_entry(key, entry, **options)
             else
               delete_entry(key, **options)
             end
@@ -1043,8 +1045,10 @@ module ActiveSupport
           entry.value
         end
 
-        def save_block_result_to_cache(name, options)
-          result = instrument(:generate, name, options) do
+        def save_block_result_to_cache(name, key, options)
+          options = options.dup
+
+          result = instrument(:generate, key, options) do
             yield(name, WriteOptions.new(options))
           end
 
@@ -1053,6 +1057,10 @@ module ActiveSupport
         end
     end
 
+    # Enables the dynamic configuration of Cache entry options while ensuring
+    # that conflicting options are not both set. When a block is given to
+    # ActiveSupport::Cache::Store#fetch, the second argument will be an
+    # instance of +WriteOptions+.
     class WriteOptions
       def initialize(options) # :nodoc:
         @options = options
@@ -1070,6 +1078,9 @@ module ActiveSupport
         @options[:expires_in]
       end
 
+      # Sets the Cache entry's +expires_in+ value. If an +expires_at+ option was
+      # previously set, this will unset it since +expires_in+ and +expires_at+
+      # cannot both be set.
       def expires_in=(expires_in)
         @options.delete(:expires_at)
         @options[:expires_in] = expires_in
@@ -1079,6 +1090,9 @@ module ActiveSupport
         @options[:expires_at]
       end
 
+      # Sets the Cache entry's +expires_at+ value. If an +expires_in+ option was
+      # previously set, this will unset it since +expires_at+ and +expires_in+
+      # cannot both be set.
       def expires_at=(expires_at)
         @options.delete(:expires_in)
         @options[:expires_at] = expires_at