activesupport 7.0.8.1 → 7.1.0.beta1

data/lib/active_support/cache/mem_cache_store.rb

@@ -3,16 +3,20 @@
 begin
   require "dalli"
 rescue LoadError => e
-  $stderr.puts "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
+  warn "You don't have dalli installed in your application. Please add it to your Gemfile and run bundle install"
   raise e
 end
 
+require "connection_pool"
 require "delegate"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/numeric/time"
 
 module ActiveSupport
   module Cache
+    # = Memcached \Cache \Store
+    #
     # A cache store implementation which stores data in Memcached:
     # https://memcached.org
     #
@@ -26,6 +30,10 @@ module ActiveSupport
     # MemCacheStore implements the Strategy::LocalCache strategy which implements
     # an in-memory cache inside of a block.
     class MemCacheStore < Store
+      # These options represent behavior overridden by this implementation and should
+      # not be allowed to get down to the Dalli client
+      OVERRIDDEN_OPTIONS = UNIVERSAL_OPTIONS
+
       # Advertise cache versioning support.
       def self.supports_cache_versioning?
         true
@@ -73,6 +81,7 @@ module ActiveSupport
       end
       prepend DupLocalCache
 
+      KEY_MAX_SIZE = 250
       ESCAPE_KEY_CHARS = /[\x00-\x20%\x7F-\xFF]/n
 
       # Creates a new Dalli::Client instance with specified addresses and options.
@@ -90,11 +99,10 @@ module ActiveSupport
         addresses = nil if addresses.compact.empty?
         pool_options = retrieve_pool_options(options)
 
-        if pool_options.empty?
-          Dalli::Client.new(addresses, options)
-        else
-          ensure_connection_pool_added!
+        if pool_options
           ConnectionPool.new(pool_options) { Dalli::Client.new(addresses, options.merge(threadsafe: false)) }
+        else
+          Dalli::Client.new(addresses, options)
         end
       end
 
@@ -106,6 +114,7 @@ module ActiveSupport
       #
       # If no addresses are provided, but <tt>ENV['MEMCACHE_SERVERS']</tt> is defined, it will be used instead. Otherwise,
       # MemCacheStore will connect to localhost:11211 (the default memcached port).
+      # Passing a +Dalli::Client+ instance is deprecated and will be removed. Please pass an address instead.
       def initialize(*addresses)
         addresses = addresses.flatten
         options = addresses.extract_options!
@@ -115,19 +124,28 @@ module ActiveSupport
         super(options)
 
         unless [String, Dalli::Client, NilClass].include?(addresses.first.class)
-          raise ArgumentError, "First argument must be an empty array, an array of hosts or a Dalli::Client instance."
+          raise ArgumentError, "First argument must be an empty array, address, or array of addresses."
         end
         if addresses.first.is_a?(Dalli::Client)
+          ActiveSupport.deprecator.warn(<<~MSG)
+            Initializing MemCacheStore with a Dalli::Client is deprecated and will be removed in Rails 7.2.
+            Use memcached server addresses instead.
+          MSG
           @data = addresses.first
         else
-          mem_cache_options = options.dup
+          @mem_cache_options = options.dup
           # The value "compress: false" prevents duplicate compression within Dalli.
-          mem_cache_options[:compress] = false
-          (UNIVERSAL_OPTIONS - %i(compress)).each { |name| mem_cache_options.delete(name) }
-          @data = self.class.build_mem_cache(*(addresses + [mem_cache_options]))
+          @mem_cache_options[:compress] = false
+          (OVERRIDDEN_OPTIONS - %i(compress)).each { |name| @mem_cache_options.delete(name) }
+          @data = self.class.build_mem_cache(*(addresses + [@mem_cache_options]))
         end
       end
 
+      def inspect
+        instance = @data || @mem_cache_options
+        "#<#{self.class} options=#{options.inspect} mem_cache=#{instance.inspect}>"
+      end
+
       ##
       # :method: write
       # :call-seq: write(name, value, options = nil)
@@ -144,28 +162,50 @@ module ActiveSupport
       # * <tt>unless_exist: true</tt> - Prevents overwriting an existing cache
       #   entry.
 
-      # Increment a cached value. This method uses the memcached incr atomic
-      # operator and can only be used on values written with the +:raw+ option.
-      # Calling it on a value not stored with +:raw+ will initialize that value
-      # to zero.
+      # Increment a cached integer value using the memcached incr atomic operator.
+      # Returns the updated value.
+      #
+      # If the key is unset or has expired, it will be set to +amount+:
+      #
+      #   cache.increment("foo") # => 1
+      #   cache.increment("bar", 100) # => 100
+      #
+      # To set a specific value, call #write passing <tt>raw: true</tt>:
+      #
+      #   cache.write("baz", 5, raw: true)
+      #   cache.increment("baz") # => 6
+      #
+      # Incrementing a non-numeric value, or a value written without
+      # <tt>raw: true</tt>, will fail and return +nil+.
       def increment(name, amount = 1, options = nil)
         options = merged_options(options)
         instrument(:increment, name, amount: amount) do
           rescue_error_with nil do
-            @data.with { |c| c.incr(normalize_key(name, options), amount, options[:expires_in]) }
+            @data.with { |c| c.incr(normalize_key(name, options), amount, options[:expires_in], amount) }
           end
         end
       end
 
-      # Decrement a cached value. This method uses the memcached decr atomic
-      # operator and can only be used on values written with the +:raw+ option.
-      # Calling it on a value not stored with +:raw+ will initialize that value
-      # to zero.
+      # Decrement a cached integer value using the memcached decr atomic operator.
+      # Returns the updated value.
+      #
+      # If the key is unset or has expired, it will be set to 0. Memcached
+      # does not support negative counters.
+      #
+      #   cache.decrement("foo") # => 0
+      #
+      # To set a specific value, call #write passing <tt>raw: true</tt>:
+      #
+      #   cache.write("baz", 5, raw: true)
+      #   cache.decrement("baz") # => 4
+      #
+      # Decrementing a non-numeric value, or a value written without
+      # <tt>raw: true</tt>, will fail and return +nil+.
       def decrement(name, amount = 1, options = nil)
         options = merged_options(options)
         instrument(:decrement, name, amount: amount) do
           rescue_error_with nil do
-            @data.with { |c| c.decr(normalize_key(name, options), amount, options[:expires_in]) }
+            @data.with { |c| c.decr(normalize_key(name, options), amount, options[:expires_in], 0) }
           end
         end
       end
@@ -182,54 +222,20 @@ module ActiveSupport
       end
 
       private
-        module Coders # :nodoc:
-          class << self
-            def [](version)
-              case version
-              when 6.1
-                Rails61Coder
-              when 7.0
-                Rails70Coder
-              else
-                raise ArgumentError, "Unknown ActiveSupport::Cache.format_version #{Cache.format_version.inspect}"
-              end
-            end
-          end
-
-          module Loader
-            def load(payload)
-              if payload.is_a?(Entry)
-                payload
-              else
-                Cache::Coders::Loader.load(payload)
-              end
-            end
-          end
-
-          module Rails61Coder
-            include Loader
-            extend self
-
-            def dump(entry)
-              entry
-            end
-
-            def dump_compressed(entry, threshold)
-              entry.compressed(threshold)
-            end
-          end
-
-          module Rails70Coder
-            include Cache::Coders::Rails70Coder
-            include Loader
-            extend self
+        def default_serializer
+          if Cache.format_version == 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[:passthrough]
+          else
+            super
           end
         end
 
-        def default_coder
-          Coders[Cache.format_version]
-        end
-
         # Read an entry from the cache.
         def read_entry(key, **options)
           deserialize_entry(read_serialized_entry(key, **options), **options)
@@ -270,7 +276,7 @@ module ActiveSupport
           raw_values.each do |key, value|
             entry = deserialize_entry(value, raw: options[:raw])
 
-            unless entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
+            unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
               values[keys_to_names[key]] = entry.value
             end
           end
@@ -299,7 +305,13 @@ module ActiveSupport
           if key
             key = key.dup.force_encoding(Encoding::ASCII_8BIT)
             key = key.gsub(ESCAPE_KEY_CHARS) { |match| "%#{match.getbyte(0).to_s(16).upcase}" }
-            key = "#{key[0, 212]}:hash:#{ActiveSupport::Digest.hexdigest(key)}" if key.size > 250
+
+            if key.size > KEY_MAX_SIZE
+              key_separator = ":hash:"
+              key_hash = ActiveSupport::Digest.hexdigest(key)
+              key_trim_size = KEY_MAX_SIZE - key_separator.size - key_hash.size
+              key = "#{key[0, key_trim_size]}#{key_separator}#{key_hash}"
+            end
           end
           key
         end
@@ -315,8 +327,12 @@ module ActiveSupport
         def rescue_error_with(fallback)
           yield
         rescue Dalli::DalliError => error
-          ActiveSupport.error_reporter&.report(error, handled: true, severity: :warning)
           logger.error("DalliError (#{error}): #{error.message}") if logger
+          ActiveSupport.error_reporter&.report(
+            error,
+            severity: :warning,
+            source: "mem_cache_store.active_support",
+          )
           fallback
         end
     end

data/lib/active_support/cache/memory_store.rb

@@ -4,10 +4,12 @@ require "monitor"
 
 module ActiveSupport
   module Cache
+    # = Memory \Cache \Store
+    #
     # A cache store implementation which stores everything into memory in the
-    # same process. If you're running multiple Ruby on Rails server processes
+    # same process. If you're running multiple Ruby on \Rails server processes
     # (which is the case if you're using Phusion Passenger or puma clustered mode),
-    # then this means that Rails server process instances won't be able
+    # then this means that \Rails server process instances won't be able
     # to share cache data with each other and this may not be the most
     # appropriate cache in that scenario.
     #
@@ -28,25 +30,49 @@ module ActiveSupport
         extend self
 
         def dump(entry)
-          entry.dup_value! unless entry.compressed?
-          entry
+          if entry.value && entry.value != true && !entry.value.is_a?(Numeric)
+            Cache::Entry.new(dump_value(entry.value), expires_at: entry.expires_at, version: entry.version)
+          else
+            entry
+          end
         end
 
         def dump_compressed(entry, threshold)
-          entry = entry.compressed(threshold)
-          entry.dup_value! unless entry.compressed?
-          entry
+          compressed_entry = entry.compressed(threshold)
+          compressed_entry.compressed? ? compressed_entry : dump(entry)
         end
 
         def load(entry)
-          entry = entry.dup
-          entry.dup_value!
-          entry
+          if !entry.compressed? && entry.value.is_a?(String)
+            Cache::Entry.new(load_value(entry.value), expires_at: entry.expires_at, version: entry.version)
+          else
+            entry
+          end
         end
+
+        private
+          MARSHAL_SIGNATURE = "\x04\x08".b.freeze
+
+          def dump_value(value)
+            if value.is_a?(String) && !value.start_with?(MARSHAL_SIGNATURE)
+              value.dup
+            else
+              Marshal.dump(value)
+            end
+          end
+
+          def load_value(string)
+            if string.start_with?(MARSHAL_SIGNATURE)
+              Marshal.load(string)
+            else
+              string.dup
+            end
+          end
       end
 
       def initialize(options = nil)
         options ||= {}
+        options[:coder] = DupCoder unless options.key?(:coder) || options.key?(:serializer)
         # Disable compression by default.
         options[:compress] ||= false
         super(options)
@@ -74,7 +100,7 @@ module ActiveSupport
       # Preemptively iterates through all stored keys and removes the ones which have expired.
       def cleanup(options = nil)
         options = merged_options(options)
-        instrument(:cleanup, size: @data.size) do
+        _instrument(:cleanup, size: @data.size) do
           keys = synchronize { @data.keys }
           keys.each do |key|
             entry = @data[key]
@@ -108,12 +134,33 @@ module ActiveSupport
         @pruning
       end
 
-      # Increment an integer value in the cache.
+      # Increment a cached integer value. Returns the updated value.
+      #
+      # If the key is unset, it will be set to +amount+:
+      #
+      #   cache.increment("foo") # => 1
+      #   cache.increment("bar", 100) # => 100
+      #
+      # To set a specific value, call #write:
+      #
+      #   cache.write("baz", 5)
+      #   cache.increment("baz") # => 6
+      #
       def increment(name, amount = 1, options = nil)
         modify_value(name, amount, options)
       end
 
-      # Decrement an integer value in the cache.
+      # Decrement a cached integer value. Returns the updated value.
+      #
+      # If the key is unset or has expired, it will be set to +-amount+.
+      #
+      #   cache.decrement("foo") # => -1
+      #
+      # To set a specific value, call #write:
+      #
+      #   cache.write("baz", 5)
+      #   cache.decrement("baz") # => 4
+      #
       def decrement(name, amount = 1, options = nil)
         modify_value(name, -amount, options)
       end
@@ -143,10 +190,6 @@ module ActiveSupport
       private
         PER_ENTRY_OVERHEAD = 240
 
-        def default_coder
-          DupCoder
-        end
-
         def cached_size(key, payload)
           key.to_s.bytesize + payload.bytesize + PER_ENTRY_OVERHEAD
         end
@@ -166,7 +209,7 @@ module ActiveSupport
         def write_entry(key, entry, **options)
           payload = serialize_entry(entry, **options)
           synchronize do
-            return false if options[:unless_exist] && @data.key?(key)
+            return false if options[:unless_exist] && exist?(key)
 
             old_payload = @data[key]
             if old_payload
@@ -188,14 +231,23 @@ module ActiveSupport
           end
         end
 
+        # Modifies the amount of an integer value that is stored in the cache.
+        # If the key is not found it is created and set to +amount+.
         def modify_value(name, amount, options)
           options = merged_options(options)
-          synchronize do
-            if num = read(name, options)
-              num = num.to_i + amount
-              write(name, num, options)
-              num
-            end
+          key     = normalize_key(name, options)
+          version = normalize_version(name, options)
+
+          entry = read_entry(key, **options)
+
+          if !entry || entry.expired? || entry.mismatched?(version)
+            write(name, Integer(amount), options)
+            amount
+          else
+            num = entry.value.to_i + amount
+            entry = Entry.new(num, expires_at: entry.expires_at, version: entry.version)
+            write_entry(key, entry)
+            num
           end
         end
     end

data/lib/active_support/cache/null_store.rb

@@ -2,6 +2,8 @@
 
 module ActiveSupport
   module Cache
+    # = Null \Cache \Store
+    #
     # A cache store implementation which doesn't actually store anything. Useful in
     # development and test environments where you don't want caching turned on but
     # need to go through the caching interface.
@@ -32,6 +34,10 @@ module ActiveSupport
       def delete_matched(matcher, options = nil)
       end
 
+      def inspect # :nodoc:
+        "#<#{self.class.name} options=#{@options.inspect}>"
+      end
+
       private
         def read_entry(key, **s)
           deserialize_entry(read_serialized_entry(key))