dalli 2.7.0 → 2.7.11

data/lib/active_support/cache/dalli_store.rb

@@ -1,4 +1,5 @@
 # encoding: ascii
+# frozen_string_literal: true
 require 'dalli'
 
 module ActiveSupport
@@ -8,6 +9,10 @@ module ActiveSupport
       attr_reader :silence, :options
       alias_method :silence?, :silence
 
+      def self.supports_cache_versioning?
+        true
+      end
+
       # Silence the logger.
       def silence!
         @silence = true
@@ -45,6 +50,11 @@ module ActiveSupport
       # wish to use pool support.
       #
       def initialize(*addresses)
+        puts <<-EOS
+DEPRECATION: :dalli_store will be removed in Dalli 3.0.
+Please use Rails' official :mem_cache_store instead.
+https://guides.rubyonrails.org/caching_with_rails.html
+EOS
         addresses = addresses.flatten
         options = addresses.extract_options!
         @options = options.dup
@@ -54,6 +64,8 @@ module ActiveSupport
         pool_options[:timeout] = options[:pool_timeout] if options[:pool_timeout]
 
         @options[:compress] ||= @options[:compression]
+
+        addresses.compact!
         servers = if addresses.empty?
                     nil # use the default from Dalli::Client
                   else
@@ -66,6 +78,7 @@ module ActiveSupport
         end
 
         extend Strategy::LocalCache
+        extend LocalCacheEntryUnwrapAndRaw
       end
 
       ##
@@ -79,31 +92,41 @@ module ActiveSupport
         @data.with(&block)
       end
 
+      # Fetch the value associated with the key.
+      # If a value is found, then it is returned.
+      #
+      # If a value is not found and no block is given, then nil is returned.
+      #
+      # If a value is not found (or if the found value is nil and :cache_nils is false)
+      # and a block is given, the block will be invoked and its return value
+      # written to the cache and returned.
       def fetch(name, options=nil)
         options ||= {}
-        name = expanded_key name
-
+        options[:cache_nils] = true if @options[:cache_nils]
+        namespaced_name = namespaced_key(name, options)
+        not_found = options[:cache_nils] ? Dalli::Server::NOT_FOUND : nil
         if block_given?
+          entry = not_found
           unless options[:force]
-            entry = instrument(:read, name, options) do |payload|
-              read_entry(name, options).tap do |result|
+            entry = instrument_with_log(:read, namespaced_name, options) do |payload|
+              read_entry(namespaced_name, options).tap do |result|
                 if payload
                   payload[:super_operation] = :fetch
-                  payload[:hit] = !!result
+                  payload[:hit] = not_found != result
                 end
               end
             end
           end
 
-          if !entry.nil?
-            instrument(:fetch_hit, name, options) { |payload| }
-            entry
-          else
-            result = instrument(:generate, name, options) do |payload|
-              yield
+          if not_found == entry
+            result = instrument_with_log(:generate, namespaced_name, options) do |payload|
+              yield(name)
             end
             write(name, result, options)
             result
+          else
+            instrument_with_log(:fetch_hit, namespaced_name, options) { |payload| }
+            entry
           end
         else
           read(name, options)
@@ -112,20 +135,20 @@ module ActiveSupport
 
       def read(name, options=nil)
         options ||= {}
-        name = expanded_key name
+        name = namespaced_key(name, options)
 
-        instrument(:read, name, options) do |payload|
+        instrument_with_log(:read, name, options) do |payload|
           entry = read_entry(name, options)
-          payload[:hit] = !!entry if payload
+          payload[:hit] = !entry.nil? if payload
           entry
         end
       end
 
       def write(name, value, options=nil)
         options ||= {}
-        name = expanded_key name
+        name = namespaced_key(name, options)
 
-        instrument(:write, name, options) do |payload|
+        instrument_with_log(:write, name, options) do |payload|
           with do |connection|
             options = options.merge(:connection => connection)
             write_entry(name, value, options)
@@ -135,7 +158,7 @@ module ActiveSupport
 
       def exist?(name, options=nil)
         options ||= {}
-        name = expanded_key name
+        name = namespaced_key(name, options)
 
         log(:exist, name, options)
         !read_entry(name, options).nil?
@@ -143,9 +166,9 @@ module ActiveSupport
 
       def delete(name, options=nil)
         options ||= {}
-        name = expanded_key name
+        name = namespaced_key(name, options)
 
-        instrument(:delete, name, options) do |payload|
+        instrument_with_log(:delete, name, options) do |payload|
           delete_entry(name, options)
         end
       end
@@ -153,12 +176,12 @@ module ActiveSupport
       # Reads multiple keys from the cache using a single call to the
       # servers for all keys. Keys must be Strings.
       def read_multi(*names)
-        names.extract_options!
-        mapping = names.inject({}) { |memo, name| memo[expanded_key(name)] = name; memo }
-        instrument(:read_multi, names) do
+        options  = names.extract_options!
+        mapping = names.inject({}) { |memo, name| memo[namespaced_key(name, options)] = name; memo }
+        instrument_with_log(:read_multi, mapping.keys) do
           results = {}
           if local_cache
-            mapping.keys.each do |key|
+            mapping.each_key do |key|
               if value = local_cache.read_entry(key, options)
                 results[key] = value
               end
@@ -184,9 +207,9 @@ module ActiveSupport
       # and the result will be written to the cache and returned.
       def fetch_multi(*names)
         options = names.extract_options!
-        mapping = names.inject({}) { |memo, name| memo[expanded_key(name)] = name; memo }
+        mapping = names.inject({}) { |memo, name| memo[namespaced_key(name, options)] = name; memo }
 
-        instrument(:fetch_multi, names) do
+        instrument_with_log(:fetch_multi, mapping.keys) do
           with do |connection|
             results = connection.get_multi(mapping.keys)
 
@@ -214,14 +237,15 @@ module ActiveSupport
       # memcached counters cannot hold negative values.
       def increment(name, amount = 1, options=nil)
         options ||= {}
-        name = expanded_key name
+        name = namespaced_key(name, options)
         initial = options.has_key?(:initial) ? options[:initial] : amount
         expires_in = options[:expires_in]
-        instrument(:increment, name, :amount => amount) do
+        instrument_with_log(:increment, name, :amount => amount) do
           with { |c| c.incr(name, amount, expires_in, initial) }
         end
       rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}") if logger
+        log_dalli_error(e)
+        instrument_error(e) if instrument_errors?
         raise if raise_errors?
         nil
       end
@@ -233,14 +257,15 @@ module ActiveSupport
       # memcached counters cannot hold negative values.
       def decrement(name, amount = 1, options=nil)
         options ||= {}
-        name = expanded_key name
+        name = namespaced_key(name, options)
         initial = options.has_key?(:initial) ? options[:initial] : 0
         expires_in = options[:expires_in]
-        instrument(:decrement, name, :amount => amount) do
+        instrument_with_log(:decrement, name, :amount => amount) do
           with { |c| c.decr(name, amount, expires_in, initial) }
         end
       rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}") if logger
+        log_dalli_error(e)
+        instrument_error(e) if instrument_errors?
         raise if raise_errors?
         nil
       end
@@ -248,11 +273,12 @@ module ActiveSupport
       # Clear the entire cache on all memcached servers. This method should
       # be used with care when using a shared cache.
       def clear(options=nil)
-        instrument(:clear, 'flushing all keys') do
+        instrument_with_log(:clear, 'flushing all keys') do
           with { |c| c.flush_all }
         end
       rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}") if logger
+        log_dalli_error(e)
+        instrument_error(e) if instrument_errors?
         raise if raise_errors?
         nil
       end
@@ -286,7 +312,8 @@ module ActiveSupport
         # NB Backwards data compatibility, to be removed at some point
         entry.is_a?(ActiveSupport::Cache::Entry) ? entry.value : entry
       rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}") if logger
+        log_dalli_error(e)
+        instrument_error(e) if instrument_errors?
         raise if raise_errors?
         nil
       end
@@ -300,7 +327,8 @@ module ActiveSupport
         connection = options.delete(:connection)
         connection.send(method, key, value, expires_in, options)
       rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}") if logger
+        log_dalli_error(e)
+        instrument_error(e) if instrument_errors?
         raise if raise_errors?
         false
       end
@@ -309,16 +337,31 @@ module ActiveSupport
       def delete_entry(key, options) # :nodoc:
         with { |c| c.delete(key) }
       rescue Dalli::DalliError => e
-        logger.error("DalliError: #{e.message}") if logger
+        log_dalli_error(e)
+        instrument_error(e) if instrument_errors?
         raise if raise_errors?
         false
       end
 
       private
-      # Expand key to be a consistent string value. Invoke +cache_key+ if
-      # object responds to +cache_key+. Otherwise, to_param method will be
-      # called. If the key is a Hash, then keys will be sorted alphabetically.
+
+      def namespaced_key(key, options)
+        digest_class = @options[:digest_class] || ::Digest::MD5
+        key = expanded_key(key)
+        namespace = options[:namespace] if options
+        prefix = namespace.is_a?(Proc) ? namespace.call : namespace
+        key = "#{prefix}:#{key}" if prefix
+        key = "#{key[0, 213]}:md5:#{digest_class.hexdigest(key)}" if key && key.size > 250
+        key
+      end
+      alias :normalize_key :namespaced_key
+
+      # Expand key to be a consistent string value. Invokes +cache_key_with_version+
+      # first to support Rails 5.2 cache versioning.
+      # Invoke +cache_key+ if object responds to +cache_key+. Otherwise, to_param method
+      # will be called. If the key is a Hash, then keys will be sorted alphabetically.
       def expanded_key(key) # :nodoc:
+        return key.cache_key_with_version.to_s if key.respond_to?(:cache_key_with_version)
         return key.cache_key.to_s if key.respond_to?(:cache_key)
 
         case key
@@ -340,12 +383,26 @@ module ActiveSupport
         key
       end
 
-      def instrument(operation, key, options=nil)
+      def log_dalli_error(error)
+        logger.error("DalliError: #{error.message}") if logger
+      end
+
+      def instrument_with_log(operation, key, options=nil)
         log(operation, key, options)
 
         payload = { :key => key }
         payload.merge!(options) if options.is_a?(Hash)
-        ActiveSupport::Notifications.instrument("cache_#{operation}.active_support", payload){ yield(payload) }
+        instrument(operation, payload) { |p| yield(p) }
+      end
+
+      def instrument_error(error)
+        instrument(:error, { :key => 'DalliError', :message => error.message })
+      end
+
+      def instrument(operation, payload)
+        ActiveSupport::Notifications.instrument("cache_#{operation}.active_support", payload) do
+          yield(payload) if block_given?
+        end
       end
 
       def log(operation, key, options=nil)
@@ -356,6 +413,29 @@ module ActiveSupport
       def raise_errors?
         !!@options[:raise_errors]
       end
+
+      def instrument_errors?
+        !!@options[:instrument_errors]
+      end
+
+      # Make sure LocalCache is giving raw values, not `Entry`s, and
+      # respect `raw` option.
+      module LocalCacheEntryUnwrapAndRaw # :nodoc:
+        protected
+          def read_entry(key, options)
+            retval = super(key, **options)
+            if retval.is_a? ActiveSupport::Cache::Entry
+              # Must have come from LocalStore, unwrap it
+              if options[:raw]
+                retval.value.to_s
+              else
+                retval.value
+              end
+            else
+              retval
+            end
+          end
+      end
     end
   end
 end

data/lib/dalli/cas/client.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'dalli/client'
 
 module Dalli
@@ -33,7 +34,7 @@ module Dalli
 
     ##
     # Set the key-value pair, verifying existing CAS.
-    # Returns the resulting CAS value if succeeded, and false otherwise.
+    # Returns the resulting CAS value if succeeded, and falsy otherwise.
     def set_cas(key, value, cas, ttl=nil, options=nil)
       ttl ||= @options[:expires_in].to_i
       perform(:set, key, value, ttl, cas, options)
@@ -42,17 +43,17 @@ module Dalli
     ##
     # Conditionally add a key/value pair, verifying existing CAS, only if the
     # key already exists on the server.  Returns the new CAS value if the
-    # operation succeeded, or false otherwise.
+    # operation succeeded, or falsy otherwise.
     def replace_cas(key, value, cas, ttl=nil, options=nil)
       ttl ||= @options[:expires_in].to_i
       perform(:replace, key, value, ttl, cas, options)
     end
 
     # Delete a key/value pair, verifying existing CAS.
-    # Returns true if succeeded, and false otherwise.
+    # Returns true if succeeded, and falsy otherwise.
     def delete_cas(key, cas=0)
       perform(:delete, key, cas)
     end
 
   end
-end
+end