activesupport 4.2.11.1 → 6.0.3.1

data/lib/active_support/cache/redis_cache_store.rb

@@ -0,0 +1,493 @@
+# frozen_string_literal: true
+
+begin
+  gem "redis", ">= 4.0.1"
+  require "redis"
+  require "redis/distributed"
+rescue LoadError
+  warn "The Redis cache store requires the redis gem, version 4.0.1 or later. Please add it to your Gemfile: `gem \"redis\", \"~> 4.0\"`"
+  raise
+end
+
+# Prefer the hiredis driver but don't require it.
+begin
+  require "redis/connection/hiredis"
+rescue LoadError
+end
+
+require "digest/sha2"
+require "active_support/core_ext/marshal"
+
+module ActiveSupport
+  module Cache
+    module ConnectionPoolLike
+      def with
+        yield self
+      end
+    end
+
+    ::Redis.include(ConnectionPoolLike)
+    ::Redis::Distributed.include(ConnectionPoolLike)
+
+    # Redis cache store.
+    #
+    # Deployment note: Take care to use a *dedicated Redis cache* rather
+    # than pointing this at your existing Redis server. It won't cope well
+    # with mixed usage patterns and it won't expire cache entries by default.
+    #
+    # Redis cache server setup guide: https://redis.io/topics/lru-cache
+    #
+    # * Supports vanilla Redis, hiredis, and Redis::Distributed.
+    # * Supports Memcached-like sharding across Redises with Redis::Distributed.
+    # * Fault tolerant. If the Redis server is unavailable, no exceptions are
+    #   raised. Cache fetches are all misses and writes are dropped.
+    # * Local cache. Hot in-memory primary cache within block/middleware scope.
+    # * +read_multi+ and +write_multi+ support for Redis mget/mset. Use Redis::Distributed
+    #   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
+      MAX_KEY_BYTESIZE = 1024
+
+      DEFAULT_REDIS_OPTIONS = {
+        connect_timeout:    20,
+        read_timeout:       1,
+        write_timeout:      1,
+        reconnect_attempts: 0,
+      }
+
+      DEFAULT_ERROR_HANDLER = -> (method:, returning:, exception:) do
+        if logger
+          logger.error { "RedisCacheStore: #{method} failed, returned #{returning.inspect}: #{exception.class}: #{exception.message}" }
+        end
+      end
+
+      # The maximum number of entries to receive per SCAN call.
+      SCAN_BATCH_SIZE = 1000
+      private_constant :SCAN_BATCH_SIZE
+
+      # Advertise cache versioning support.
+      def self.supports_cache_versioning?
+        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.
+        #
+        # Handles four options: :redis block, :redis instance, single :url
+        # string, and multiple :url strings.
+        #
+        #   Option  Class       Result
+        #   :redis  Proc    ->  options[:redis].call
+        #   :redis  Object  ->  options[:redis]
+        #   :url    String  ->  Redis.new(url: …)
+        #   :url    Array   ->  Redis::Distributed.new([{ url: … }, { url: … }, …])
+        #
+        def build_redis(redis: nil, url: nil, **redis_options) #:nodoc:
+          urls = Array(url)
+
+          if redis.is_a?(Proc)
+            redis.call
+          elsif redis
+            redis
+          elsif urls.size > 1
+            build_redis_distributed_client urls: urls, **redis_options
+          else
+            build_redis_client url: urls.first, **redis_options
+          end
+        end
+
+        private
+          def build_redis_distributed_client(urls:, **redis_options)
+            ::Redis::Distributed.new([], DEFAULT_REDIS_OPTIONS.merge(redis_options)).tap do |dist|
+              urls.each { |u| dist.add_node url: u }
+            end
+          end
+
+          def build_redis_client(url:, **redis_options)
+            ::Redis.new DEFAULT_REDIS_OPTIONS.merge(redis_options.merge(url: url))
+          end
+      end
+
+      attr_reader :redis_options
+      attr_reader :max_key_bytesize
+
+      # Creates a new Redis cache store.
+      #
+      # Handles four options: :redis block, :redis instance, single :url
+      # string, and multiple :url strings.
+      #
+      #   Option  Class       Result
+      #   :redis  Proc    ->  options[:redis].call
+      #   :redis  Object  ->  options[:redis]
+      #   :url    String  ->  Redis.new(url: …)
+      #   :url    Array   ->  Redis::Distributed.new([{ url: … }, { url: … }, …])
+      #
+      # No namespace is set by default. Provide one if the Redis cache
+      # server is shared with other apps: <tt>namespace: 'myapp-cache'</tt>.
+      #
+      # Compression is enabled by default with a 1kB threshold, so cached
+      # values larger than 1kB are automatically compressed. Disable by
+      # passing <tt>compress: false</tt> or change the threshold by passing
+      # <tt>compress_threshold: 4.kilobytes</tt>.
+      #
+      # No expiry is set on cache entries by default. Redis is expected to
+      # be configured with an eviction policy that automatically deletes
+      # least-recently or -frequently used keys when it reaches max memory.
+      # See https://redis.io/topics/lru-cache for cache server setup.
+      #
+      # 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)
+        @redis_options = redis_options
+
+        @max_key_bytesize = MAX_KEY_BYTESIZE
+        @error_handler = error_handler
+
+        super namespace: namespace,
+          compress: compress, compress_threshold: compress_threshold,
+          expires_in: expires_in, race_condition_ttl: race_condition_ttl
+      end
+
+      def redis
+        @redis ||= begin
+          pool_options = self.class.send(:retrieve_pool_options, redis_options)
+
+          if pool_options.any?
+            self.class.send(:ensure_connection_pool_added!)
+            ::ConnectionPool.new(pool_options) { self.class.build_redis(**redis_options) }
+          else
+            self.class.build_redis(**redis_options)
+          end
+        end
+      end
+
+      def inspect
+        instance = @redis || @redis_options
+        "<##{self.class} options=#{options.inspect} redis=#{instance.inspect}>"
+      end
+
+      # Cache Store API implementation.
+      #
+      # Read multiple values at once. Returns a hash of requested keys ->
+      # fetched values.
+      def read_multi(*names)
+        if mget_capable?
+          instrument(:read_multi, names, options) do |payload|
+            read_multi_mget(*names).tap do |results|
+              payload[:hits] = results.keys
+            end
+          end
+        else
+          super
+        end
+      end
+
+      # Cache Store API implementation.
+      #
+      # Supports Redis KEYS glob patterns:
+      #
+      #   h?llo matches hello, hallo and hxllo
+      #   h*llo matches hllo and heeeello
+      #   h[ae]llo matches hello and hallo, but not hillo
+      #   h[^e]llo matches hallo, hbllo, ... but not hello
+      #   h[a-b]llo matches hallo and hbllo
+      #
+      # Use \ to escape special characters if you want to match them verbatim.
+      #
+      # See https://redis.io/commands/KEYS for more.
+      #
+      # Failsafe: Raises errors.
+      def delete_matched(matcher, options = nil)
+        instrument :delete_matched, matcher do
+          unless String === matcher
+            raise ArgumentError, "Only Redis glob strings are supported: #{matcher.inspect}"
+          end
+          redis.with do |c|
+            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"
+          end
+        end
+      end
+
+      # Cache Store API implementation.
+      #
+      # Increment a cached value. This method uses the Redis 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.
+      #
+      # Failsafe: Raises errors.
+      def increment(name, amount = 1, options = nil)
+        instrument :increment, name, amount: amount do
+          failsafe :increment do
+            options = merged_options(options)
+            key = normalize_key(name, options)
+
+            redis.with do |c|
+              c.incrby(key, amount).tap do
+                write_key_expiry(c, key, options)
+              end
+            end
+          end
+        end
+      end
+
+      # Cache Store API implementation.
+      #
+      # Decrement a cached value. This method uses the Redis 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.
+      #
+      # Failsafe: Raises errors.
+      def decrement(name, amount = 1, options = nil)
+        instrument :decrement, name, amount: amount do
+          failsafe :decrement do
+            options = merged_options(options)
+            key = normalize_key(name, options)
+
+            redis.with do |c|
+              c.decrby(key, amount).tap do
+                write_key_expiry(c, key, options)
+              end
+            end
+          end
+        end
+      end
+
+      # Cache Store API implementation.
+      #
+      # Removes expired entries. Handled natively by Redis least-recently-/
+      # least-frequently-used expiry, so manual cleanup is not supported.
+      def cleanup(options = nil)
+        super
+      end
+
+      # Clear the entire cache on all Redis servers. Safe to use on
+      # shared servers if the cache is namespaced.
+      #
+      # Failsafe: Raises errors.
+      def clear(options = nil)
+        failsafe :clear do
+          if namespace = merged_options(options)[:namespace]
+            delete_matched "*", namespace: namespace
+          else
+            redis.with { |c| c.flushdb }
+          end
+        end
+      end
+
+      def mget_capable? #:nodoc:
+        set_redis_capabilities unless defined? @mget_capable
+        @mget_capable
+      end
+
+      def mset_capable? #:nodoc:
+        set_redis_capabilities unless defined? @mset_capable
+        @mset_capable
+      end
+
+      private
+        def set_redis_capabilities
+          case redis
+          when Redis::Distributed
+            @mget_capable = true
+            @mset_capable = false
+          else
+            @mget_capable = true
+            @mset_capable = true
+          end
+        end
+
+        # Store provider interface:
+        # Read an entry from the cache.
+        def read_entry(key, **options)
+          failsafe :read_entry do
+            raw = options&.fetch(:raw, false)
+            deserialize_entry(redis.with { |c| c.get(key) }, raw: raw)
+          end
+        end
+
+        def read_multi_entries(names, **options)
+          if mget_capable?
+            read_multi_mget(*names)
+          else
+            super
+          end
+        end
+
+        def read_multi_mget(*names)
+          options = names.extract_options!
+          options = merged_options(options)
+          return {} if names == []
+          raw = options&.fetch(:raw, false)
+
+          keys = names.map { |name| normalize_key(name, options) }
+
+          values = failsafe(:read_multi_mget, returning: {}) do
+            redis.with { |c| c.mget(*keys) }
+          end
+
+          names.zip(values).each_with_object({}) do |(name, value), results|
+            if value
+              entry = deserialize_entry(value, raw: raw)
+              unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(name, options))
+                results[name] = entry.value
+              end
+            end
+          end
+        end
+
+        # 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)
+
+          # 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.
+          if race_condition_ttl && expires_in && expires_in > 0 && !raw
+            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
+
+              redis.with { |c| c.set key, serialized_entry, modifiers }
+            else
+              redis.with { |c| c.set key, serialized_entry }
+            end
+          end
+        end
+
+        def write_key_expiry(client, key, options)
+          if options[:expires_in] && client.ttl(key).negative?
+            client.expire key, options[:expires_in].to_i
+          end
+        end
+
+        # Delete an entry from the cache.
+        def delete_entry(key, options)
+          failsafe :delete_entry, returning: false do
+            redis.with { |c| c.del key }
+          end
+        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])) }
+              end
+            else
+              super
+            end
+          end
+        end
+
+        # Truncate keys that exceed 1kB.
+        def normalize_key(key, options)
+          truncate_key super.b
+        end
+
+        def truncate_key(key)
+          if key.bytesize > max_key_bytesize
+            suffix = ":sha2:#{::Digest::SHA2.hexdigest(key)}"
+            truncate_at = max_key_bytesize - suffix.bytesize
+            "#{key.byteslice(0, truncate_at)}#{suffix}"
+          else
+            key
+          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)
+          end
+        end
+
+        def serialize_entry(entry, raw: false)
+          if raw
+            entry.value.to_s
+          else
+            Marshal.dump(entry)
+          end
+        end
+
+        def serialize_entries(entries, raw: false)
+          entries.transform_values do |entry|
+            serialize_entry entry, raw: raw
+          end
+        end
+
+        def failsafe(method, returning: nil)
+          yield
+        rescue ::Redis::BaseError => e
+          handle_exception exception: e, method: method, 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,6 +1,8 @@
-require 'active_support/core_ext/object/duplicable'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/per_thread_registry'
+# 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
@@ -9,7 +11,7 @@ module ActiveSupport
       # duration of a block. Repeated calls to the cache for the same key will hit the
       # in-memory cache for faster access.
       module LocalCache
-        autoload :Middleware, 'active_support/cache/strategy/local_cache_middleware'
+        autoload :Middleware, "active_support/cache/strategy/local_cache_middleware"
 
         # Class for storing and registering the local caches.
         class LocalCacheRegistry # :nodoc:
@@ -39,7 +41,7 @@ module ActiveSupport
             @data = {}
           end
 
-          # Don't allow synchronizing since it isn't thread safe,
+          # Don't allow synchronizing since it isn't thread safe.
           def synchronize # :nodoc:
             yield
           end
@@ -48,24 +50,40 @@ module ActiveSupport
             @data.clear
           end
 
-          def read_entry(key, options)
+          def read_entry(key, **options)
             @data[key]
           end
 
-          def write_entry(key, value, options)
+          def read_multi_entries(keys, **options)
+            values = {}
+
+            keys.each do |name|
+              entry = read_entry(name, **options)
+              values[name] = entry.value if entry
+            end
+
+            values
+          end
+
+          def write_entry(key, value, **options)
             @data[key] = value
             true
           end
 
-          def delete_entry(key, options)
+          def delete_entry(key, **options)
             !!@data.delete(key)
           end
+
+          def fetch_entry(key, options = nil) # :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 }
         end
+
         # Middleware class can be inserted as a Rack handler to be local cache for the
         # duration of request.
         def middleware
@@ -74,68 +92,83 @@ module ActiveSupport
             local_cache_key)
         end
 
-        def clear(options = nil) # :nodoc:
-          local_cache.clear(options) if local_cache
+        def clear(**options) # :nodoc:
+          return super unless cache = local_cache
+          cache.clear(options)
           super
         end
 
-        def cleanup(options = nil) # :nodoc:
-          local_cache.clear(options) if local_cache
+        def cleanup(**options) # :nodoc:
+          return super unless cache = local_cache
+          cache.clear
           super
         end
 
-        def increment(name, amount = 1, options = nil) # :nodoc:
-          value = bypass_local_cache{super}
-          set_cache_value(value, name, amount, options)
+        def increment(name, amount = 1, **options) # :nodoc:
+          return super unless local_cache
+          value = bypass_local_cache { super }
+          write_cache_value(name, value, **options)
           value
         end
 
-        def decrement(name, amount = 1, options = nil) # :nodoc:
-          value = bypass_local_cache{super}
-          set_cache_value(value, name, amount, options)
+        def decrement(name, amount = 1, **options) # :nodoc:
+          return super unless local_cache
+          value = bypass_local_cache { super }
+          write_cache_value(name, value, **options)
           value
         end
 
-        protected
-          def read_entry(key, options) # :nodoc:
-            if local_cache
-              entry = local_cache.read_entry(key, options)
-              unless entry
-                entry = super
-                local_cache.write_entry(key, entry, options)
-              end
-              entry
+        private
+          def read_entry(key, **options)
+            if cache = local_cache
+              cache.fetch_entry(key) { super }
             else
               super
             end
           end
 
-          def write_entry(key, entry, options) # :nodoc:
-            local_cache.write_entry(key, entry, options) if local_cache
+          def read_multi_entries(keys, **options)
+            return super unless local_cache
+
+            local_entries = local_cache.read_multi_entries(keys, **options)
+            missed_keys = keys - local_entries.keys
+
+            if missed_keys.any?
+              local_entries.merge!(super(missed_keys, **options))
+            else
+              local_entries
+            end
+          end
+
+          def write_entry(key, entry, **options)
+            if options[:unless_exist]
+              local_cache.delete_entry(key, **options) if local_cache
+            else
+              local_cache.write_entry(key, entry, **options) if local_cache
+            end
+
             super
           end
 
-          def delete_entry(key, options) # :nodoc:
-            local_cache.delete_entry(key, options) if local_cache
+          def delete_entry(key, **options)
+            local_cache.delete_entry(key, **options) if local_cache
             super
           end
 
-          def set_cache_value(value, name, amount, options)
-            if local_cache
-              local_cache.mute do
-                if value
-                  local_cache.write(name, value, options)
-                else
-                  local_cache.delete(name, options)
-                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
             end
           end
 
-        private
-
           def local_cache_key
-            @local_cache_key ||= "#{self.class.name.underscore}_local_cache_#{object_id}".gsub(/[\/-]/, '_').to_sym
+            @local_cache_key ||= "#{self.class.name.underscore}_local_cache_#{object_id}".gsub(/[\/-]/, "_").to_sym
           end
 
           def local_cache