dalli 3.2.15 → 4.0.0

data/lib/dalli/protocol/binary.rb

@@ -22,7 +22,7 @@ module Dalli
       def get(key, options = nil)
         req = RequestFormatter.standard_request(opkey: :get, key: key)
         write(req)
-        response_processor.get(cache_nils: cache_nils?(options), raw: raw_request?(options))
+        response_processor.get(cache_nils: cache_nils?(options))
       end
 
       def quiet_get_request(key)
@@ -33,7 +33,7 @@ module Dalli
         ttl = TtlSanitizer.sanitize(ttl)
         req = RequestFormatter.standard_request(opkey: :gat, key: key, ttl: ttl)
         write(req)
-        response_processor.get(cache_nils: cache_nils?(options), raw: raw_request?(options))
+        response_processor.get(cache_nils: cache_nils?(options))
       end
 
       def touch(key, ttl)
@@ -44,10 +44,10 @@ module Dalli
 
       # TODO: This is confusing, as there's a cas command in memcached
       # and this isn't it.  Maybe rename?  Maybe eliminate?
-      def cas(key, options = nil)
+      def cas(key)
         req = RequestFormatter.standard_request(opkey: :get, key: key)
         write(req)
-        response_processor.data_cas_response(raw: raw_request?(options))
+        response_processor.data_cas_response
       end
 
       # Storage Commands
@@ -119,6 +119,7 @@ module Dalli
       # if the key doesn't already exist, rather than
       # setting the initial value
       NOT_FOUND_EXPIRY = 0xFFFFFFFF
+      private_constant :NOT_FOUND_EXPIRY
 
       def decr_incr(opkey, key, count, ttl, initial)
         expiry = initial ? TtlSanitizer.sanitize(ttl) : NOT_FOUND_EXPIRY
@@ -139,10 +140,7 @@ module Dalli
       # We need to read all the responses at once.
       def noop
         write_noop
-        result = response_processor.consume_all_responses_until_noop
-        # Everything up to and including the noop reply has been read
-        @connection_manager.quiet_responses_pending = false
-        result
+        response_processor.consume_all_responses_until_noop
       end
 
       def stats(info = '')

data/lib/dalli/protocol/connection_manager.rb

@@ -28,7 +28,6 @@ module Dalli
 
       attr_accessor :hostname, :port, :socket_type, :options
       attr_reader :sock
-      attr_writer :quiet_responses_pending
 
       def initialize(hostname, port, socket_type, client_options)
         @hostname = hostname
@@ -36,11 +35,9 @@ module Dalli
         @socket_type = socket_type
         @options = DEFAULTS.merge(client_options)
         @request_in_progress = false
-        @quiet_responses_pending = false
         @sock = nil
         @pid = nil
 
-        @fail_count = 0
         reset_down_info
       end
 
@@ -56,11 +53,10 @@ module Dalli
         Dalli.logger.debug { "Dalli::Server#connect #{name}" }
 
         @sock = memcached_socket
-        @pid = Process.pid
+        @pid = PIDCache.pid
         @request_in_progress = false
-        @quiet_responses_pending = false
-      rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, EOFError, SocketError => e
-        # SocketError = DNS resolution failure; SSL_ERRORS = failed TLS handshake
+      rescue SystemCallError, *TIMEOUT_ERRORS, EOFError, SocketError => e
+        # SocketError = DNS resolution failure
         error_on_request!(e)
       end
 
@@ -88,8 +84,6 @@ module Dalli
       def down!
         close
         log_down_detected
-        # Once down_retry_delay passes, the server gets a full set of attempts
-        @fail_count = 0
 
         @error = $ERROR_INFO&.class&.name
         @msg ||= $ERROR_INFO&.message
@@ -106,47 +100,32 @@ module Dalli
 
       def confirm_ready!
         close if request_in_progress?
-        close_on_fork if fork_detected?
+        reconnect_on_fork if fork_detected?
       end
 
       def confirm_in_progress!
         raise '[Dalli] No request in progress. This may be a bug in Dalli.' unless request_in_progress?
 
-        close_on_fork if fork_detected?
+        reconnect_on_fork if fork_detected?
       end
 
       def close
         return unless @sock
 
         begin
-          close_socket
+          @sock.close
         rescue StandardError
           nil
         end
         @sock = nil
         @pid = nil
-        @quiet_responses_pending = false
         abort_request!
       end
 
-      # A forked child shares the parent's connection, so it closes only its
-      # own file descriptor. Closing the TLS socket itself would send
-      # close_notify and end the parent's TLS session.
-      def close_socket
-        fork_detected? ? @sock.to_io.close : @sock.close
-      end
-
       def connected?
         !@sock.nil?
       end
 
-      # True when a quiet request was written on this connection and its
-      # replies (memcached only suppresses some of them) haven't been
-      # consumed by a noop yet.
-      def quiet_responses_pending?
-        @quiet_responses_pending
-      end
-
       def request_in_progress?
         @request_in_progress
       end
@@ -161,50 +140,21 @@ module Dalli
         raise '[Dalli] No request in progress. This may be a bug in Dalli.' unless @request_in_progress
 
         @request_in_progress = false
-        # A completed request is what proves the server healthy again, so the
-        # failure count resets here rather than on reconnect: a server that
-        # accepts connections but never answers would otherwise reset it on
-        # every retry and never reach socket_max_failures.
-        @fail_count = 0
       end
 
       def abort_request!
         @request_in_progress = false
       end
 
-      # The longest reply line Dalli reads, in bytes, CRLF included. A meta
-      # reply header is at most about 500 bytes: "VA <size>" plus its flags,
-      # the largest being a 250-byte key base64-encoded to 336 bytes, a
-      # 20-digit CAS, a 32-byte opaque and a few numeric fields. The longest
-      # stats line (stats settings) carries a file path such as ext_path, up
-      # to PATH_MAX (4096). 8 KiB leaves room for both, while a server that
-      # never sends CRLF can't grow the read buffer without bound.
-      MAX_LINE_BYTES = 8 * 1024
-
       def read_line
-        data = @sock.gets("\r\n", MAX_LINE_BYTES)
+        data = @sock.gets("\r\n")
         error_on_request!('EOF in read_line') if data.nil?
-        # Without its CRLF the line either ran past MAX_LINE_BYTES or was cut
-        # short by EOF; either way the connection is out of step
-        error_on_request!("Reply line without CRLF in the first #{MAX_LINE_BYTES} bytes") unless data.end_with?("\r\n")
         data
       rescue SystemCallError, *TIMEOUT_ERRORS, EOFError => e
         error_on_request!(e)
       end
 
-      # memcached can't store an item larger than 1 GiB (its -I maximum), so a
-      # reply claiming more (or a negative size) is malformed or hostile.
-      # Reading allocates the full count up front, so check before reading.
-      MAX_READ_BYTES = (1024 * 1024 * 1024) + 2 # plus the value's trailing "\r\n"
-
-      def check_read_size!(count)
-        return if count.between?(0, MAX_READ_BYTES)
-
-        raise Dalli::DalliError, "Reply size #{count} from #{name} is out of range"
-      end
-
       def read(count)
-        check_read_size!(count)
         @sock.readfull(count)
       rescue SystemCallError, *TIMEOUT_ERRORS, EOFError => e
         error_on_request!(e)
@@ -245,9 +195,8 @@ module Dalli
         raise Dalli::NetworkError, message
       end
 
-      # Called on connect. Deliberately leaves @fail_count alone; see
-      # finish_request!.
       def reset_down_info
+        @fail_count = 0
         @down_at = nil
         @last_down_at = nil
         @msg = nil
@@ -263,28 +212,22 @@ module Dalli
       end
 
       def log_warn_message(err_or_string)
-        detail = err_or_string.is_a?(String) ? err_or_string : "#{err_or_string.class}: #{err_or_string.message}"
         Dalli.logger.warn do
           detail = err_or_string.is_a?(String) ? err_or_string : "#{err_or_string.class}: #{err_or_string.message}"
           "#{name} failed (count: #{@fail_count}) #{detail}"
         end
       end
 
-      def close_on_fork
+      def reconnect_on_fork
         message = 'Fork detected, re-connecting child process...'
         Dalli.logger.info { message }
-        # Closes the inherited socket without touching the parent's
-        # connection, setting us up for reconnect on next request.
+        # Close socket on a fork and reconnect immediately
         close
-        raise Dalli::NetworkError, message
+        establish_connection
       end
 
       def fork_detected?
-        # Process.pid rather than PIDCache: PIDCache is refreshed by a
-        # Process._fork hook, and another library's fork hook (such as
-        # connection_pool closing its connections) can run in the child before
-        # it, which would close the parent's TLS session as if it were ours.
-        @pid && @pid != Process.pid
+        @pid && @pid != PIDCache.pid
       end
 
       def log_down_detected

data/lib/dalli/protocol/meta/key_regularizer.rb

@@ -10,7 +10,7 @@ module Dalli
       # memcached supports the use of base64 hashes for keys containing
       # whitespace or non-ASCII characters, provided the 'b' flag is included in the request.
       class KeyRegularizer
-        WHITESPACE = /\s/.freeze
+        WHITESPACE = /\s/
 
         def self.encode(key)
           return [key, false] if key.ascii_only? && !WHITESPACE.match(key)

data/lib/dalli/protocol/meta/request_formatter.rb

@@ -13,7 +13,6 @@ module Dalli
         # and introducing an intermediate object seems like overkill.
         #
         # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/MethodLength
         # rubocop:disable Metrics/ParameterLists
         # rubocop:disable Metrics/PerceivedComplexity
         def self.meta_get(key:, value: true, return_cas: false, ttl: nil, base64: false, quiet: false)
@@ -21,7 +20,7 @@ module Dalli
           cmd << ' v f' if value
           cmd << ' c' if return_cas
           cmd << ' b' if base64
-          cmd << " T#{integer_flag(:ttl, ttl)}" if ttl
+          cmd << " T#{ttl}" if ttl
           cmd << ' k q s' if quiet # Return the key in the response if quiet
           cmd + TERMINATOR
         end
@@ -32,19 +31,17 @@ module Dalli
           cmd << ' b' if base64
           cmd << " F#{bitflags}" if bitflags
           cmd << cas_string(cas)
-          cmd << " T#{integer_flag(:ttl, ttl)}" if ttl
+          cmd << " T#{ttl}" if ttl
           cmd << " M#{mode_to_token(mode)}"
           cmd << ' q' if quiet
           cmd << TERMINATOR
-          cmd << value
-          cmd + TERMINATOR
         end
 
         def self.meta_delete(key:, cas: nil, ttl: nil, base64: false, quiet: false)
           cmd = "md #{key}"
           cmd << ' b' if base64
           cmd << cas_string(cas)
-          cmd << " T#{integer_flag(:ttl, ttl)}" if ttl
+          cmd << " T#{ttl}" if ttl
           cmd << ' q' if quiet
           cmd + TERMINATOR
         end
@@ -52,17 +49,16 @@ module Dalli
         def self.meta_arithmetic(key:, delta:, initial:, incr: true, cas: nil, ttl: nil, base64: false, quiet: false)
           cmd = "ma #{key} v"
           cmd << ' b' if base64
-          cmd << " D#{integer_flag(:delta, delta)}" if delta
-          cmd << " J#{integer_flag(:initial, initial)}" if initial
+          cmd << " D#{delta}" if delta
+          cmd << " J#{initial}" if initial
           # Always set a TTL if an initial value is specified
-          cmd << " N#{ttl ? integer_flag(:ttl, ttl) : 0}" if ttl || initial
+          cmd << " N#{ttl || 0}" if ttl || initial
           cmd << cas_string(cas)
           cmd << ' q' if quiet
           cmd << " M#{incr ? 'I' : 'D'}"
           cmd + TERMINATOR
         end
         # rubocop:enable Metrics/CyclomaticComplexity
-        # rubocop:enable Metrics/MethodLength
         # rubocop:enable Metrics/ParameterLists
         # rubocop:enable Metrics/PerceivedComplexity
 
@@ -81,13 +77,16 @@ module Dalli
           cmd + TERMINATOR
         end
 
+        ALLOWED_STATS_ARGS = [nil, '', 'items', 'slabs', 'settings', 'reset'].freeze
+
         def self.stats(arg = nil)
+          raise ArgumentError, "Invalid stats argument: #{arg.inspect}" unless ALLOWED_STATS_ARGS.include?(arg)
+
           cmd = +'stats'
-          cmd << " #{arg}" if arg
+          cmd << " #{arg}" if arg && !arg.empty?
           cmd + TERMINATOR
         end
 
-        # rubocop:disable Metrics/MethodLength
         def self.mode_to_token(mode)
           case mode
           when :add
@@ -102,19 +101,6 @@ module Dalli
             'S'
           end
         end
-        # rubocop:enable Metrics/MethodLength
-
-        # 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.
-        def self.integer_flag(name, value)
-          value.is_a?(String) ? Integer(value, 10) : Integer(value)
-        rescue ArgumentError, TypeError, FloatDomainError
-          raise ArgumentError, "#{name} must be an Integer, got #{value.inspect}"
-        end
 
         def self.cas_string(cas)
           cas = parse_to_64_bit_int(cas, nil)

data/lib/dalli/protocol/meta/response_processor.rb

@@ -21,33 +21,29 @@ module Dalli
         STAT = 'STAT'
         VA = 'VA'
         VERSION = 'VERSION'
+        SERVER_ERROR = 'SERVER_ERROR'
 
         def initialize(io_source, value_marshaller)
           @io_source = io_source
           @value_marshaller = value_marshaller
         end
 
-        # raw: true returns the value as stored, without deserializing or
-        # decompressing it, whatever flags it was stored with
-        def meta_get_with_value(cache_nils: false, raw: false)
+        def meta_get_with_value(cache_nils: false)
           tokens = error_on_unexpected!([VA, EN, HD])
           return cache_nils ? ::Dalli::NOT_FOUND : nil if tokens.first == EN
           return true unless tokens.first == VA
 
-          value = read_data(tokens[1].to_i)
-          raw ? value : @value_marshaller.retrieve(value, bitflags_from_tokens(tokens))
+          @value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens))
         end
 
-        # raw: true returns the value as stored; see #meta_get_with_value
-        def meta_get_with_value_and_cas(raw: false)
+        def meta_get_with_value_and_cas
           tokens = error_on_unexpected!([VA, EN, HD])
           return [nil, 0] if tokens.first == EN
 
           cas = cas_from_tokens(tokens)
           return [nil, cas] unless tokens.first == VA
 
-          value = read_data(tokens[1].to_i)
-          [raw ? value : @value_marshaller.retrieve(value, bitflags_from_tokens(tokens)), cas]
+          [@value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens)), cas]
         end
 
         def meta_get_without_value
@@ -125,10 +121,6 @@ module Dalli
         end
 
         def full_response_from_buffer(tokens, body, resp_size)
-          # A hit with no key can't be matched to a request: skip it (false
-          # status) rather than yield it, or take it for the end of the pipeline
-          return [resp_size, false, nil, nil, nil] unless tokens.any? { |t| t.start_with?('k') }
-
           value = @value_marshaller.retrieve(body, bitflags_from_tokens(tokens))
           [resp_size, tokens.first == VA, cas_from_tokens(tokens), key_from_tokens(tokens), value]
         end
@@ -149,14 +141,11 @@ module Dalli
 
           tokens, header_len, body_len = tokens_from_header_buffer(buf)
 
-          # A complete response with no body. Only the terminating noop's MN
-          # ends the pipeline. Any other bodyless reply (CLIENT_ERROR,
-          # SERVER_ERROR, ...) answers one key's request: report it with a
-          # false status so the caller skips it and keeps reading. Treating it
-          # as the end would leave the remaining replies on the connection for
-          # later commands to read as their own. A hit on an empty value (VA 0)
-          # still has a body -- just its terminator -- so it's parsed below.
-          return [header_len, tokens.first == MN, nil, nil, nil] if no_body?(tokens, body_len)
+          # We have a complete response that has no body.
+          # This is either the response to the terminating
+          # noop or, if the status is not MN, an intermediate
+          # error response that needs to be discarded.
+          return [header_len, true, nil, nil, nil] if body_len.zero?
 
           resp_size = header_len + body_len + TERMINATOR.length
           # The header is in the buffer, but the body is not.  As we don't have
@@ -169,27 +158,6 @@ module Dalli
           full_response_from_buffer(tokens, body, resp_size)
         end
 
-        # memcached can't store an item larger than 1 GiB (its -I maximum). A
-        # pipelined reply claiming an impossible size would otherwise have the
-        # buffer wait for (and accumulate) that many bytes.
-        MAX_VALUE_BYTES = 1024 * 1024 * 1024
-
-        # The size given right after "VA", or 0 when it isn't a number
-        def positional_size(tokens)
-          tokens.first == VA && tokens[1]&.match?(/\A\d+\z/) ? tokens[1].to_i : 0
-        end
-
-        def check_value_size!(size)
-          return if size.between?(0, MAX_VALUE_BYTES)
-
-          raise Dalli::DalliError, "Reply value size #{size} is out of range"
-        end
-
-        # A zero-size reply has no body unless it's a VA (a hit on an empty value)
-        def no_body?(tokens, body_len)
-          body_len.zero? && tokens.first != VA
-        end
-
         def contains_header?(buf)
           buf.include?(TERMINATOR)
         end
@@ -200,9 +168,12 @@ module Dalli
 
         def error_on_unexpected!(expected_codes)
           tokens = next_line_to_tokens
-          raise Dalli::DalliError, "Response error: #{tokens.first}" unless expected_codes.include?(tokens.first)
 
-          tokens
+          return tokens if expected_codes.include?(tokens.first)
+
+          raise Dalli::ServerError, tokens.join(' ').to_s if tokens.first == SERVER_ERROR
+
+          raise Dalli::DalliError, "Response error: #{tokens.first}"
         end
 
         def bitflags_from_tokens(tokens)
@@ -220,11 +191,7 @@ module Dalli
         end
 
         def body_len_from_tokens(tokens)
-          # memcached also gives the size positionally ("VA <size> ..."); use it
-          # when there's no s flag rather than reading the value as replies
-          size = tokens.any? { |t| t.start_with?('s') } ? value_from_tokens(tokens, 's')&.to_i : positional_size(tokens)
-          check_value_size!(size) if size
-          size
+          value_from_tokens(tokens, 's')&.to_i
         end
 
         def value_from_tokens(tokens, flag)
@@ -243,12 +210,7 @@ module Dalli
           line&.split || []
         end
 
-        # Values are read by the size in the VA line, not up to the next CRLF:
-        # a value can contain CRLF and can be longer than MAX_LINE_BYTES
         def read_data(data_size)
-          # Checked before the terminator is added: -1 or -2 would otherwise
-          # read 1 or 0 bytes and leave the connection out of step
-          check_value_size!(data_size)
           @io_source.read(data_size + TERMINATOR.bytesize)&.chomp!(TERMINATOR)
         end
       end

data/lib/dalli/protocol/meta.rb

@@ -13,7 +13,6 @@ module Dalli
     ##
     class Meta < Base
       TERMINATOR = "\r\n"
-      COUNTER_ADD_OPTIONS = { raw: true }.freeze # counters are stored raw
 
       def response_processor
         @response_processor ||= ResponseProcessor.new(@connection_manager, @value_marshaller)
@@ -28,7 +27,7 @@ module Dalli
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_get(key: encoded_key, base64: base64)
         write(req)
-        response_processor.meta_get_with_value(cache_nils: cache_nils?(options), raw: raw_request?(options))
+        response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
       def quiet_get_request(key)
@@ -41,7 +40,7 @@ module Dalli
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, base64: base64)
         write(req)
-        response_processor.meta_get_with_value(cache_nils: cache_nils?(options), raw: raw_request?(options))
+        response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
       def touch(key, ttl)
@@ -54,11 +53,11 @@ module Dalli
 
       # TODO: This is confusing, as there's a cas command in memcached
       # and this isn't it.  Maybe rename?  Maybe eliminate?
-      def cas(key, options = nil)
+      def cas(key)
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_get(key: encoded_key, value: true, return_cas: true, base64: base64)
         write(req)
-        response_processor.meta_get_with_value_and_cas(raw: raw_request?(options))
+        response_processor.meta_get_with_value_and_cas
       end
 
       # Storage Commands
@@ -86,6 +85,8 @@ module Dalli
                                         bitflags: bitflags, cas: cas,
                                         ttl: ttl, mode: mode, quiet: quiet?, base64: base64)
         write(req)
+        write(value)
+        write(TERMINATOR)
       end
       # rubocop:enable Metrics/ParameterLists
 
@@ -106,6 +107,8 @@ module Dalli
         req = RequestFormatter.meta_set(key: encoded_key, value: value, base64: base64,
                                         cas: cas, ttl: ttl, mode: mode, quiet: quiet?)
         write(req)
+        write(value)
+        write(TERMINATOR)
       end
       # rubocop:enable Metrics/ParameterLists
 
@@ -130,42 +133,11 @@ module Dalli
       def decr_incr(incr, key, delta, ttl, initial)
         ttl = initial ? TtlSanitizer.sanitize(ttl) : nil # Only set a TTL if we want to set a value on miss
         encoded_key, base64 = KeyRegularizer.encode(key)
-        # memcached stores an item created by ma's auto-create (N/J) for a
-        # base64-encoded key without its binary-key flag, and later replies
-        # name it with the raw key bytes. Create such counters with an add.
-        return decr_incr_with_add(incr, key, delta, ttl, initial) if initial && base64
-
         write(RequestFormatter.meta_arithmetic(key: encoded_key, delta: delta, initial: initial, incr: incr, ttl: ttl,
                                                quiet: quiet?, base64: base64))
         response_processor.decr_incr unless quiet?
       end
 
-      # Like decr_incr with an initial value, without memcached's auto-create:
-      # on a miss the counter is added with the initial value (which is
-      # returned, as auto-create would), and the add losing a race to another
-      # client means the counter now exists, so the incr is tried again. In a
-      # quiet block both requests are sent and whichever applies takes effect.
-      def decr_incr_with_add(incr, key, delta, ttl, initial)
-        return quiet_decr_incr_with_add(incr, key, delta, ttl, initial) if quiet?
-
-        2.times do
-          value = decr_incr(incr, key, delta, nil, nil)
-          return value unless value.nil?
-
-          write_storage_req(:add, key, initial.to_s, ttl, nil, COUNTER_ADD_OPTIONS)
-          return initial if response_processor.meta_set_with_cas
-        end
-        decr_incr(incr, key, delta, nil, nil)
-      end
-
-      def quiet_decr_incr_with_add(incr, key, delta, ttl, initial)
-        encoded_key, base64 = KeyRegularizer.encode(key)
-        write(RequestFormatter.meta_arithmetic(key: encoded_key, delta: delta, initial: nil, incr: incr, ttl: nil,
-                                               quiet: true, base64: base64))
-        # Sent with the rest of the quiet block, by its closing noop
-        write_storage_req(:add, key, initial.to_s, ttl, nil, COUNTER_ADD_OPTIONS)
-      end
-
       # Other Commands
       def flush(delay = 0)
         write(RequestFormatter.flush(delay: delay))
@@ -176,10 +148,7 @@ module Dalli
       # We need to read all the responses at once.
       def noop
         write_noop
-        result = response_processor.consume_all_responses_until_mn
-        # Everything up to and including the MN has been read
-        @connection_manager.quiet_responses_pending = false
-        result
+        response_processor.consume_all_responses_until_mn
       end
 
       def stats(info = nil)

data/lib/dalli/protocol/server_config_parser.rb

@@ -16,7 +16,7 @@ module Dalli
       # can limit character set to LDH + '.'.  Hex digit section
       # is there to support IPv6 addresses, which need to be specified with
       # a bounding []
-      SERVER_CONFIG_REGEXP = /\A(\[([\h:]+)\]|[^:]+)(?::(\d+))?(?::(\d+))?\z/.freeze
+      SERVER_CONFIG_REGEXP = /\A(\[([\h:]+)\]|[^:]+)(?::(\d+))?(?::(\d+))?\z/
 
       DEFAULT_PORT = 11_211
       DEFAULT_WEIGHT = 1

data/lib/dalli/protocol/ttl_sanitizer.rb

@@ -31,7 +31,7 @@ module Dalli
         return ttl_as_i if ttl_as_i > now # Already a timestamp
 
         Dalli.logger.debug "Expiration interval (#{ttl_as_i}) too long for Memcached " \
-                           'and too short to be a future timestamp,' \
+                           'and too short to be a future timestamp, ' \
                            'converting to an expiration timestamp'
         now + ttl_as_i
       end