dalli 5.0.7 → 5.1.1

data/lib/dalli/protocol/request_formatter.rb

@@ -36,36 +36,59 @@ module Dalli
         # - l<N>: Seconds since last access
         def meta_get(key:, value: true, return_cas: false, ttl: nil, quiet: false,
                      vivify_ttl: nil, recache_ttl: nil,
-                     return_hit_status: false, return_last_access: false, skip_lru_bump: false,
-                     skip_flags: false)
+                     return_hit_status: false, return_last_access: false, return_ttl_remaining: false,
+                     skip_lru_bump: false, skip_flags: false, p_token: nil, l_token: nil)
           cmd = "mg #{encoded_key(key)}"
           # In raw mode (skip_flags: true), we don't request bitflags since they're not used.
           # This saves 2 bytes per request and skips parsing on response.
           cmd << (skip_flags ? ' v' : ' v f') if value
           cmd << ' c' if return_cas
           cmd << " T#{integer_flag(:ttl, ttl)}" if ttl
+          cmd << routing_tokens(p_token: p_token, l_token: l_token)
           cmd << ' k q s' if quiet # Return the key in the response if quiet
           cmd << " N#{integer_flag(:vivify_ttl, vivify_ttl)}" if vivify_ttl # Thundering herd: vivify on miss
           # Thundering herd: win recache if TTL below threshold
           cmd << " R#{integer_flag(:recache_ttl, recache_ttl)}" if recache_ttl
           cmd << ' h' if return_hit_status # Return hit status (0 or 1)
           cmd << ' l' if return_last_access # Return seconds since last access
+          cmd << ' t' if return_ttl_remaining # Return seconds of TTL remaining (-1 = no TTL)
           cmd << ' u' if skip_lru_bump # Don't bump LRU or update access stats
           cmd << TERMINATOR
         end
 
-        def multi_meta_get(keys, skip_flags: false)
+        # Fast path for the common single-key get with no optional flags.
+        # Produces the same bytes as meta_get(key: key, skip_flags: skip_flags)
+        # without the keyword-argument handling and incremental string building.
+        def plain_meta_get(key, skip_flags)
+          skip_flags ? "mg #{encoded_key(key)} v#{TERMINATOR}" : "mg #{encoded_key(key)} v f#{TERMINATOR}"
+        end
+
+        # Pass terminate: false to leave off the trailing noop, for callers
+        # (the pipelined get) that send it separately.
+        def multi_meta_get(keys, skip_flags: false, return_cas: false, terminate: true, p_token: nil, l_token: nil)
           # In raw mode: "mg <key> v k q s\r\n" (no f flag, key at index 2)
           # Normal mode: "mg <key> v f k q s\r\n" (key at index 3)
-          post_get = skip_flags ? " v k q s\r\n" : " v f k q s\r\n"
+          # With return_cas a "c" flag follows, which shifts those indexes --
+          # callers of that variant locate tokens by flag rather than position.
+          # Routing tokens apply to every key in the batch, so the suffix is
+          # built once rather than per key.
+          post_get = if return_cas
+                       skip_flags ? ' v c' : ' v f c'
+                     else
+                       skip_flags ? ' v' : ' v f'
+                     end
+          post_get += routing_tokens(p_token: p_token, l_token: l_token)
+          post_get += " k q s#{TERMINATOR}"
+
           buffer = ''.b
           keys.each do |key|
             buffer << 'mg ' << encoded_key(key) << post_get
           end
-          buffer << 'mn' << TERMINATOR
+          terminate ? buffer << 'mn' << TERMINATOR : buffer
         end
 
-        def meta_set(key:, value:, bitflags: nil, cas: nil, ttl: nil, mode: :set, quiet: false)
+        def meta_set(key:, value:, bitflags: nil, cas: nil, ttl: nil, mode: :set, quiet: false,
+                     p_token: nil, l_token: nil)
           base64 = KeyRegularizer.required?(key)
           key = KeyRegularizer.encode(key) if base64
           cmd = "ms #{key} #{value.bytesize}"
@@ -78,11 +101,16 @@ module Dalli
           cmd << " T#{integer_flag(:ttl, ttl)}" if ttl
           cmd << " M#{mode_to_token(mode)}"
           cmd << ' q' if quiet
+          cmd << routing_tokens(p_token: p_token, l_token: l_token)
           cmd << TERMINATOR
         end
 
-        def multi_meta_set(entries, ttl: nil)
+        def multi_meta_set(entries, ttl: nil, p_token: nil, l_token: nil)
+          # Routing tokens apply to every entry in the batch, so the suffix is
+          # built once rather than per entry.
+          token_suffix = routing_tokens(p_token: p_token, l_token: l_token)
           ttl = integer_flag(:ttl, ttl) if ttl
+
           buffer = ''.b
           entries.each do |key, pair|
             value, bitflags = pair
@@ -90,12 +118,12 @@ module Dalli
             base64 = KeyRegularizer.required?(key)
             key = KeyRegularizer.encode(key) if base64
 
-            # Inline format: "ms <key> <size> c [b] F<flags> T<ttl> MS q\r\n"
+            # Inline format: "ms <key> <size> c [b] F<flags> T<ttl> MS q [P/L]\r\n"
             buffer << "ms #{key} #{value.bytesize} c"
             buffer << ' b' if base64
             buffer << " F#{bitflags}" if bitflags
             buffer << " T#{ttl}" if ttl
-            buffer << ' MS q' << TERMINATOR << value << TERMINATOR
+            buffer << ' MS q' << token_suffix << TERMINATOR << value << TERMINATOR
           end
           buffer << META_NOOP
         end
@@ -103,24 +131,55 @@ module Dalli
         # Thundering herd protection flag:
         # - stale (I flag): Instead of deleting the item, mark it as stale. Other clients
         #   using N/R flags will see the X flag and know the item is being regenerated.
-        def meta_delete(key:, cas: nil, ttl: nil, quiet: false, stale: false)
+        # Tombstone flags:
+        # - stale (I flag): mark the item stale instead of removing it.  Readers
+        #   using N/R flags, or get_with_metadata, see the X flag and know the
+        #   item is being regenerated.
+        # - ttl (T flag): how long the stale marker lives.  memcached only honors
+        #   T on a delete when it is paired with I, so this raises rather than
+        #   emitting a request the server would apply differently than intended.
+        # - drop_value (x flag): remove the item's value but leave the item, so a
+        #   tombstone can be left without retaining the old payload.
+        def meta_delete(key:, cas: nil, ttl: nil, quiet: false, stale: false, drop_value: false,
+                        p_token: nil, l_token: nil)
+          # Message uses this method's own parameter names (ttl/stale), not the
+          # client-facing tombstone_ttl/invalidate names Dalli::Client validates
+          # against -- this guard is also reachable by internal callers (tests,
+          # direct RequestFormatter use) that never go through the client.
+          raise ArgumentError, 'ttl requires stale: true' if ttl && !stale
+
           cmd = "md #{encoded_key(key)}"
           cmd << cas_string(cas)
-          cmd << " T#{integer_flag(:ttl, ttl)}" if ttl
           cmd << ' I' if stale # Mark stale instead of deleting
+          cmd << " T#{integer_flag(:ttl, ttl)}" if ttl
+          cmd << ' x' if drop_value # Drop the value but keep the item
           cmd << ' q' if quiet
+          cmd << routing_tokens(p_token: p_token, l_token: l_token)
           cmd << TERMINATOR
         end
 
-        def multi_meta_delete(keys)
+        # Tombstone and routing-token flags apply to every key in the batch;
+        # see meta_delete.
+        def multi_meta_delete(keys, stale: false, ttl: nil, drop_value: false, p_token: nil, l_token: nil)
+          raise ArgumentError, 'tombstone_ttl requires invalidate: true' if ttl && !stale
+
+          suffix = +''
+          suffix << ' I' if stale
+          suffix << " T#{integer_flag(:ttl, ttl)}" if ttl
+          suffix << ' x' if drop_value
+          suffix << ' q'
+          suffix << routing_tokens(p_token: p_token, l_token: l_token)
+          suffix << TERMINATOR
+
           buffer = ''.b
           keys.each do |key|
-            buffer << 'md ' << encoded_key(key) << ' q' << TERMINATOR
+            buffer << 'md ' << encoded_key(key) << suffix
           end
           buffer << META_NOOP
         end
 
-        def meta_arithmetic(key:, delta:, initial:, incr: true, cas: nil, ttl: nil, quiet: false)
+        def meta_arithmetic(key:, delta:, initial:, incr: true, cas: nil, ttl: nil, quiet: false,
+                            p_token: nil, l_token: nil)
           cmd = "ma #{encoded_key(key)} v"
           cmd << " D#{integer_flag(:delta, delta)}" if delta
           cmd << " J#{integer_flag(:initial, initial)}" if initial
@@ -129,8 +188,39 @@ module Dalli
           cmd << cas_string(cas)
           cmd << ' q' if quiet
           cmd << " M#{incr ? 'I' : 'D'}"
+          cmd << routing_tokens(p_token: p_token, l_token: l_token)
           cmd << TERMINATOR
         end
+
+        # Builds the wire-format suffix for opaque routing tokens (P and L).
+        # memcached itself ignores these; they exist as hints for a proxy or
+        # router sitting between the client and memcached. See protocol.txt:
+        # "All commands accept tokens 'P' and 'L' which are completely ignored.
+        # The arguments to 'P' and 'L' can be used as hints or path
+        # specifications to a proxy or router inbetween a client and a
+        # memcached daemon."
+        #
+        # Empty / nil tokens are treated as no-ops. CRLF and null bytes are
+        # rejected with ArgumentError to prevent the token from being used as a
+        # wire-protocol injection vector (e.g. "foo\r\nflush_all\r\n" would
+        # otherwise be parsed as a second command by memcached or any
+        # intermediate proxy/LB).
+        def routing_tokens(p_token: nil, l_token: nil)
+          # Only an empty *String* is a no-op. Checking respond_to?(:empty?)
+          # instead would also swallow p_token: [] / {} before the type check
+          # below ever runs, silently dropping caller mistakes that should
+          # raise "must be a String".
+          p_token = nil if p_token.is_a?(String) && p_token.empty?
+          l_token = nil if l_token.is_a?(String) && l_token.empty?
+          validate_routing_token!('p_token', p_token)
+          validate_routing_token!('l_token', l_token)
+          return '' unless p_token || l_token
+
+          s = +''
+          s << " P#{p_token}" if p_token
+          s << " L#{l_token}" if l_token
+          s
+        end
         # rubocop:enable Metrics/CyclomaticComplexity
         # rubocop:enable Metrics/ParameterLists
         # rubocop:enable Metrics/PerceivedComplexity
@@ -171,12 +261,22 @@ module Dalli
 
         private
 
+        # Disallowed bytes: CR, LF, NUL. Any of these embedded in a routing
+        # token would let the caller inject a second wire-protocol command.
+        ROUTING_TOKEN_FORBIDDEN = /[\r\n\0]/
+        private_constant :ROUTING_TOKEN_FORBIDDEN
+
+        def validate_routing_token!(name, value)
+          return if value.nil?
+          raise ArgumentError, "#{name} must be a String, got #{value.class}" unless value.is_a?(String)
+          raise ArgumentError, "#{name} must not contain CRLF or null bytes" if value.match?(ROUTING_TOKEN_FORBIDDEN)
+        end
+
         # Numeric flag values are written straight into the command line, so a
         # value that isn't an integer -- e.g. a String carrying CRLF -- would let
-        # the caller inject further memcached commands (GHSA-6wmv-xq9m-fmp7).
-        # Converting to Integer means only digits ever reach the wire. Strings
-        # are parsed as base 10 so "010" means 10, as memcached would read it,
-        # rather than octal 8.
+        # the caller inject further memcached commands. Converting to Integer
+        # means only digits ever reach the wire. Strings are parsed as base 10 so
+        # "010" means 10, as memcached would read it, rather than octal 8.
         def integer_flag(name, value)
           value.is_a?(String) ? Integer(value, 10) : Integer(value)
         rescue ArgumentError, TypeError, FloatDomainError

data/lib/dalli/protocol/response_processor.rb

@@ -23,6 +23,14 @@ module Dalli
         VERSION = 'VERSION'
         SERVER_ERROR = 'SERVER_ERROR'
 
+        VA_PREFIX = 'VA '
+        FLAGS_TOKEN_PREFIX = ' f'
+        BYTE_B = 'b'.ord
+        BYTE_C = 'c'.ord
+        BYTE_F = 'f'.ord
+        BYTE_K = 'k'.ord
+        BYTE_S = 's'.ord
+
         T_OK = [OK].freeze
         T_RESET = [RESET].freeze
         T_EN_HD = [EN, HD].freeze
@@ -39,11 +47,24 @@ module Dalli
         end
 
         def meta_get_with_value(cache_nils: false)
-          tokens = error_on_unexpected!(T_VA_EN_HD)
-          return cache_nils ? ::Dalli::NOT_FOUND : nil if tokens.first == EN
-          return true unless tokens.first == VA
+          line = read_line
+          # A hit ("VA <size> f<flags>") is parsed in place rather than split
+          # into tokens, which saves several allocations on the hottest path.
+          if line&.start_with?(VA_PREFIX)
+            return @value_marshaller.retrieve(read_data(size_from_va_line(line)), bitflags_from_va_line(line))
+          end
 
-          @value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens))
+          tokens = line&.split || []
+          case tokens.first
+          when EN
+            cache_nils ? ::Dalli::NOT_FOUND : nil
+          when VA # only reached for an unusually formatted hit line
+            @value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens))
+          when HD
+            true
+          else
+            raise_unexpected!(tokens)
+          end
         end
 
         def meta_get_with_value_and_cas
@@ -72,11 +93,13 @@ module Dalli
         #
         # Used by meta_get for comprehensive metadata retrieval.
         # Supports thundering herd protection (N/R flags) and metadata flags (h/l/u).
-        def meta_get_with_metadata(cache_nils: false, return_hit_status: false, return_last_access: false)
+        def meta_get_with_metadata(cache_nils: false, return_hit_status: false, return_last_access: false,
+                                   return_ttl_remaining: false)
           tokens = error_on_unexpected!(T_VA_EN_HD)
           result = build_metadata_result(tokens)
           result[:hit_before] = hit_status_from_tokens(tokens) if return_hit_status
           result[:last_access] = last_access_from_tokens(tokens) if return_last_access
+          result[:ttl_remaining] = ttl_remaining_from_tokens(tokens) if return_ttl_remaining
           result[:value] = parse_value_from_tokens(tokens, cache_nils)
           result
         end
@@ -85,7 +108,12 @@ module Dalli
           {
             value: nil, cas: cas_from_tokens(tokens),
             won_recache: tokens.include?('W'), stale: tokens.include?('X'),
-            lost_recache: tokens.include?('Z')
+            lost_recache: tokens.include?('Z'),
+            # Explicit miss marker: EN means the key does not exist.  A tombstoned
+            # item is NOT a miss -- it answers VA/HD with the X flag set -- and a
+            # stored nil under cache_nils is not one either, so neither can be
+            # inferred from value or cas alone.
+            miss: tokens.first == EN
           }
         end
 
@@ -174,11 +202,6 @@ module Dalli
           non_deletions
         end
 
-        def full_response_from_buffer(tokens, body, resp_size)
-          value = @value_marshaller.retrieve(body, bitflags_from_tokens(tokens))
-          [tokens.first == VA, cas_from_tokens(tokens), key_from_tokens(tokens), value, resp_size]
-        end
-
         ##
         # This method returns an array of values used in a pipelined
         # getk process.  The first value is the number of bytes by
@@ -198,8 +221,20 @@ module Dalli
           tokens = header.split
           header_len = header.bytesize + TERMINATOR.length
 
-          # The body len is removed from the tokens array
-          body_len = body_len_from_tokens(tokens)
+          # Read the s, f, c and k flags and the b marker in one pass. As with
+          # value_from_tokens, the first token for each flag wins.
+          size = bitflags = cas = key = nil
+          base64 = false
+          tokens.each do |token|
+            case token.getbyte(0)
+            when BYTE_S then size ||= token
+            when BYTE_F then bitflags ||= token
+            when BYTE_C then cas ||= token
+            when BYTE_K then key ||= token
+            when BYTE_B then base64 ||= token == 'b'
+            end
+          end
+          body_len = flag_int(size, 's')
 
           # We have a complete response that has no body.
           # This is either the response to the terminating
@@ -215,7 +250,16 @@ module Dalli
           # The full response is in our buffer, so parse it and return
           # the values
           body = buf.byteslice(offset + header_len, body_len)
-          full_response_from_buffer(tokens, body, resp_size)
+          value = @value_marshaller.retrieve(body, flag_int(bitflags, 'f'))
+          key = key ? key.delete_prefix!('k') : 0
+          key = KeyRegularizer.decode(key) if base64
+          [tokens.first == VA, flag_int(cas, 'c'), key, value, resp_size]
+        end
+
+        # Integer value of a flag token such as "f123", or 0 when absent.
+        # Strips the prefix in place, like value_from_tokens.
+        def flag_int(token, flag)
+          token ? token.delete_prefix!(flag).to_i : 0
         end
 
         def error_on_unexpected!(expected_codes)
@@ -223,6 +267,10 @@ module Dalli
 
           return tokens if expected_codes.include?(tokens.first)
 
+          raise_unexpected!(tokens)
+        end
+
+        def raise_unexpected!(tokens)
           raise Dalli::ServerError, tokens.join(' ').to_s if tokens.first == SERVER_ERROR
 
           raise Dalli::DalliError, "Response error: #{tokens.first}"
@@ -232,10 +280,29 @@ module Dalli
           value_from_tokens(tokens, 'f').to_i
         end
 
+        # String#to_i stops at the first non-digit, so these read one token's
+        # integer straight out of the header line without splitting it.
+        def size_from_va_line(line)
+          line.byteslice(VA_PREFIX.bytesize, line.bytesize).to_i
+        end
+
+        def bitflags_from_va_line(line)
+          idx = line.index(FLAGS_TOKEN_PREFIX, VA_PREFIX.bytesize)
+          idx ? line.byteslice(idx + FLAGS_TOKEN_PREFIX.bytesize, line.bytesize).to_i : 0
+        end
+
         def cas_from_tokens(tokens)
           value_from_tokens(tokens, 'c').to_i
         end
 
+        # Detects the X presence flag, set when an item has been marked stale by a
+        # prior `md key I`.  Uses strict equality (Array#any? with a String pattern
+        # compares with ==) so a future value-bearing flag beginning with X cannot
+        # be mistaken for it.
+        def stale_from_tokens(tokens)
+          tokens.any?('X')
+        end
+
         def key_from_tokens(tokens)
           encoded_key = value_from_tokens(tokens, 'k')
           if tokens.delete('b')
@@ -260,8 +327,10 @@ module Dalli
           value_from_tokens(tokens, 'l').to_i
         end
 
-        def body_len_from_tokens(tokens)
-          value_from_tokens(tokens, 's').to_i
+        # Returns seconds of TTL remaining; -1 when the item has no expiry.
+        # The t flag returns t<seconds>.
+        def ttl_remaining_from_tokens(tokens)
+          value_from_tokens(tokens, 't').to_i
         end
 
         def value_from_tokens(tokens, flag)

data/lib/dalli/ring.rb

@@ -21,41 +21,46 @@ module Dalli
     # in an equally weighted scenario.
     POINTS_PER_SERVER = 160 # this is the default in libmemcached
 
-    attr_accessor :servers, :continuum
+    attr_accessor :servers
+    attr_reader :continuum
 
     def initialize(servers_arg, options)
       @servers = servers_arg.map do |s|
         Dalli::Protocol::Meta.new(s, options)
       end
-      @continuum = nil
-      @continuum = build_continuum(servers) if servers.size > 1
+      self.continuum = (build_continuum(servers) if servers.size > 1)
 
       threadsafe! unless options[:threadsafe] == false
       @failover = options[:failover] != false
     end
 
-    def server_for_key(key)
+    def continuum=(entries)
+      @continuum = entries
+      # Plain integers, so the binary search in server_for_hash_key needn't
+      # call Entry#value at each step
+      @continuum_values = entries&.map(&:value)
+    end
+
+    # alive_cache (optional) remembers each server's alive? result, so a
+    # caller routing many keys checks each server once rather than per key.
+    def server_for_key(key, alive_cache = nil)
+      # server_from_continuum only returns a server that is alive
       server = if @continuum
-                 server_from_continuum(key)
-               else
-                 @servers.first
+                 server_from_continuum(key, alive_cache)
+               elsif (first = @servers.first) && server_alive?(first, alive_cache)
+                 first
                end
-
-      # Note that the call to alive? has the side effect of initializing
-      # the socket
-      return server if server&.alive?
+      return server if server
 
       raise Dalli::RingError, 'No server available'
     end
 
-    def server_from_continuum(key)
+    def server_from_continuum(key, alive_cache = nil)
       hkey = hash_for(key)
       20.times do |try|
         server = server_for_hash_key(hkey)
 
-        # Note that the call to alive? has the side effect of initializing
-        # the socket
-        return server if server.alive?
+        return server if server_alive?(server, alive_cache)
         break unless @failover
 
         hkey = hash_for("#{try}#{key}")
@@ -64,8 +69,9 @@ module Dalli
     end
 
     def keys_grouped_by_server(key_arr)
+      alive_cache = {}.compare_by_identity
       key_arr.group_by do |key|
-        server_for_key(key)
+        server_for_key(key, alive_cache)
       rescue Dalli::RingError
         Dalli.logger.debug { "unable to get key #{key}" }
         nil
@@ -110,13 +116,21 @@ module Dalli
       Zlib.crc32(key)
     end
 
+    # Note that the call to alive? has the side effect of initializing
+    # the socket
+    def server_alive?(server, alive_cache)
+      return server.alive? unless alive_cache
+
+      alive_cache.fetch(server) { alive_cache[server] = server.alive? }
+    end
+
     def entry_count_for(server, total_servers, total_weight)
       ((total_servers * POINTS_PER_SERVER * server.weight) / Float(total_weight)).floor
     end
 
     def server_for_hash_key(hash_key)
       # Find the closest index in the Ring with value <= the given value
-      entryidx = @continuum.bsearch_index { |entry| entry.value > hash_key }
+      entryidx = @continuum_values.bsearch_index { |value| value > hash_key }
       if entryidx.nil?
         entryidx = @continuum.size - 1
       else

data/lib/dalli/socket.rb

@@ -124,7 +124,7 @@ module Dalli
       # Returns true for an unmodified TCPSocket on Ruby 3.0+, or for resolv-replace >= 0.2.0
       # which forwards keyword arguments through its patch.
       # Returns false when monkey-patched by gems like socksify or resolv-replace < 0.2.0.
-      # rubocop:disable ThreadSafety/ClassInstanceVariable
+      # rubocop:disable-next ThreadSafety/ClassInstanceVariable
       def self.supports_connect_timeout?
         return @supports_connect_timeout if defined?(@supports_connect_timeout)
 
@@ -135,7 +135,6 @@ module Dalli
                                       end
                                     end
       end
-      # rubocop:enable ThreadSafety/ClassInstanceVariable
 
       def self.create_socket_with_timeout(host, port, options)
         if supports_connect_timeout?
@@ -192,14 +191,13 @@ module Dalli
 
       # Detect and cache the correct pack format for struct timeval on this platform.
       # Different architectures have different sizes for time_t and suseconds_t.
-      # rubocop:disable ThreadSafety/ClassInstanceVariable
+      # rubocop:disable-next ThreadSafety/ClassInstanceVariable
       def self.timeval_pack_format(sock)
         @timeval_pack_format ||= begin
           expected_size = sock.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVTIMEO).data.bytesize
           TIMEVAL_PACK_FORMATS.find { |fmt| TIMEVAL_TEST_VALUES.pack(fmt).bytesize == expected_size } || 'll'
         end
       end
-      # rubocop:enable ThreadSafety/ClassInstanceVariable
 
       def self.pack_timeval(sock, seconds, microseconds)
         [seconds, microseconds].pack(timeval_pack_format(sock))

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '5.0.7'
+  VERSION = '5.1.1'
 
-  MIN_SUPPORTED_MEMCACHED_VERSION = '1.6'
+  MIN_SUPPORTED_MEMCACHED_VERSION = '1.6.27'
 end

data/lib/rack/session/dalli.rb

@@ -16,11 +16,10 @@ module Rack
       attr_reader :data
 
       # Don't freeze this until we fix the specs/implementation
-      # rubocop:disable Style/MutableConstant
+      # rubocop:disable-next Style/MutableConstant
       DEFAULT_DALLI_OPTIONS = {
         namespace: 'rack:session'
       }
-      # rubocop:enable Style/MutableConstant
 
       # Brings in a new Rack::Session::Dalli middleware with the given
       # `:memcache_server`. The server is either a hostname, or a

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 5.0.7
+  version: 5.1.1
 platform: ruby
 authors:
 - Peter M. Goldstein