dalli 4.3.10 → 5.0.0

data/lib/dalli/protocol/meta.rb

@@ -30,7 +30,7 @@ module Dalli
         req = RequestFormatter.meta_get(key: encoded_key, base64: base64, skip_flags: skip_flags)
         write(req)
         @connection_manager.flush
-        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)
@@ -47,7 +47,7 @@ module Dalli
         req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, base64: base64, skip_flags: skip_flags)
         write(req)
         @connection_manager.flush
-        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)
@@ -61,13 +61,12 @@ 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,
-                                        skip_flags: raw_request?(options))
+        req = RequestFormatter.meta_get(key: encoded_key, value: true, return_cas: true, base64: base64)
         write(req)
         @connection_manager.flush
-        response_processor.meta_get_with_value_and_cas(raw: raw_request?(options))
+        response_processor.meta_get_with_value_and_cas
       end
 
       # Comprehensive meta get with support for all metadata flags.
@@ -97,7 +96,7 @@ module Dalli
       def meta_get(key, options = {})
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_get(
-          key: encoded_key, value: true, return_cas: true, base64: base64, skip_flags: raw_request?(options),
+          key: encoded_key, value: true, return_cas: true, base64: base64,
           vivify_ttl: options[:vivify_ttl], recache_ttl: options[:recache_ttl],
           return_hit_status: options[:return_hit_status],
           return_last_access: options[:return_last_access], skip_lru_bump: options[:skip_lru_bump]
@@ -106,7 +105,7 @@ module Dalli
         @connection_manager.flush
         response_processor.meta_get_with_metadata(
           cache_nils: cache_nils?(options), return_hit_status: options[:return_hit_status],
-          return_last_access: options[:return_last_access], raw: raw_request?(options)
+          return_last_access: options[:return_last_access]
         )
       end
 
@@ -147,7 +146,7 @@ module Dalli
         response_processor.meta_set_with_cas unless quiet?
       end
 
-      # rubocop:disable-next Metrics/ParameterLists
+      # rubocop:disable Metrics/ParameterLists
       def write_storage_req(mode, key, raw_value, ttl = nil, cas = nil, options = {}, quiet: quiet?)
         (value, bitflags) = @value_marshaller.store(key, raw_value, options)
         ttl = TtlSanitizer.sanitize(ttl) if ttl
@@ -160,6 +159,7 @@ module Dalli
         write(TERMINATOR)
         @connection_manager.flush unless quiet
       end
+      # rubocop:enable Metrics/ParameterLists
 
       def append(key, value)
         write_append_prepend_req(:append, key, value)
@@ -171,7 +171,7 @@ module Dalli
         response_processor.meta_set_append_prepend unless quiet?
       end
 
-      # rubocop:disable-next Metrics/ParameterLists
+      # rubocop:disable Metrics/ParameterLists
       def write_append_prepend_req(mode, key, value, ttl = nil, cas = nil, _options = {})
         ttl = TtlSanitizer.sanitize(ttl) if ttl
         encoded_key, base64 = KeyRegularizer.encode(key)
@@ -182,6 +182,7 @@ module Dalli
         write(TERMINATOR)
         @connection_manager.flush unless quiet?
       end
+      # rubocop:enable Metrics/ParameterLists
 
       # Delete Commands
       def delete(key, cas)
@@ -213,45 +214,12 @@ 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))
         @connection_manager.flush unless quiet?
         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)
-        add_options = { raw: true } # counters are stored raw
-        return quiet_decr_incr_with_add(incr, key, delta, ttl, initial, add_options) 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, add_options, quiet: false)
-          return initial if response_processor.meta_set_with_cas
-        end
-        decr_incr(incr, key, delta, nil, nil)
-      end
-
-      # rubocop:disable-next Metrics/ParameterLists
-      def quiet_decr_incr_with_add(incr, key, delta, ttl, initial, add_options)
-        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, add_options, quiet: true)
-      end
-
       # Other Commands
       def flush(delay = 0)
         write(RequestFormatter.flush(delay: delay))
@@ -263,10 +231,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.clear_quiet_responses_pending!
-        result
+        response_processor.consume_all_responses_until_mn
       end
 
       def stats(info = nil)
@@ -292,13 +257,9 @@ module Dalli
         @connection_manager.flush
       end
 
-      def authenticate_connection
-        raise Dalli::DalliError, 'Authentication not supported for the meta protocol.'
-      end
-
-      require_relative 'meta/key_regularizer'
-      require_relative 'meta/request_formatter'
-      require_relative 'meta/response_processor'
+      require_relative 'key_regularizer'
+      require_relative 'request_formatter'
+      require_relative 'response_processor'
     end
   end
 end

data/lib/dalli/protocol/{meta/request_formatter.rb → request_formatter.rb}

@@ -45,11 +45,10 @@ module Dalli
           cmd << (skip_flags ? ' v' : ' 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 << " 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 << " N#{vivify_ttl}" if vivify_ttl # Thundering herd: vivify on miss
+          cmd << " R#{recache_ttl}" if recache_ttl # Thundering herd: win recache if TTL below threshold
           cmd << ' h' if return_hit_status # Return hit status (0 or 1)
           cmd << ' l' if return_last_access # Return seconds since last access
           cmd << ' u' if skip_lru_bump # Don't bump LRU or update access stats
@@ -62,7 +61,7 @@ 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
@@ -75,7 +74,7 @@ module Dalli
           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 << ' I' if stale # Mark stale instead of deleting
           cmd << ' q' if quiet
           cmd + TERMINATOR
@@ -84,10 +83,10 @@ 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'}"
@@ -137,18 +136,6 @@ module Dalli
           end
         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.
-        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)
           cas.nil? || cas.zero? ? '' : " C#{cas}"

data/lib/dalli/protocol/response_buffer.rb

@@ -7,39 +7,38 @@ module Dalli
   module Protocol
     ##
     # Manages the buffer for responses from memcached.
-    # Uses an offset-based approach to avoid string allocations
-    # when advancing through parsed responses.
     ##
     class ResponseBuffer
-      # Compact the buffer when the consumed portion exceeds this
-      # threshold and represents more than half the buffer
-      COMPACT_THRESHOLD = 4096
-
       def initialize(io_source, response_processor)
         @io_source = io_source
         @response_processor = response_processor
         @buffer = nil
-        @offset = 0
       end
 
       def read
         @buffer << @io_source.read_nonblock
       end
 
-      # Attempts to process a single response from the buffer,
-      # advancing the offset past the consumed bytes.
+      # Attempts to process a single response from the buffer.  Starts
+      # by advancing the buffer to the specified start position
       def process_single_getk_response
-        bytes, status, cas, key, value = @response_processor.getk_response_from_buffer(@buffer, @offset)
-        @offset += bytes
-        compact_if_needed
+        bytes, status, cas, key, value = @response_processor.getk_response_from_buffer(@buffer)
+        advance(bytes)
         [status, cas, key, value]
       end
 
+      # Advances the internal response buffer by bytes_to_advance
+      # bytes.  The
+      def advance(bytes_to_advance)
+        return unless bytes_to_advance.positive?
+
+        @buffer = @buffer.byteslice(bytes_to_advance..-1)
+      end
+
       # Resets the internal buffer to an empty state,
       # so that we're ready to read pipelined responses
       def reset
         @buffer = ''.b
-        @offset = 0
       end
 
       # Ensures the buffer is initialized for reading without discarding
@@ -49,30 +48,16 @@ module Dalli
         return if in_progress?
 
         @buffer = ''.b
-        @offset = 0
       end
 
       # Clear the internal response buffer
       def clear
         @buffer = nil
-        @offset = 0
       end
 
       def in_progress?
         !@buffer.nil?
       end
-
-      private
-
-      # Only compact when we've consumed a significant portion of the buffer.
-      # This avoids per-response string allocation while preventing unbounded
-      # memory growth for large pipelines.
-      def compact_if_needed
-        return unless @offset > COMPACT_THRESHOLD && @offset > @buffer.bytesize / 2
-
-        @buffer = @buffer.byteslice(@offset..)
-        @offset = 0
-      end
     end
   end
 end

data/lib/dalli/protocol/{meta/response_processor.rb → response_processor.rb}

@@ -28,25 +28,22 @@ module Dalli
           @value_marshaller = value_marshaller
         end
 
-        # raw: true (a request made with raw: true) returns the value as stored,
-        # ignoring any flags in the reply. The request didn't ask for flags, so
-        # a reply carrying them anyway must not get the value deserialized.
-        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
 
-          retrieve(read_data(tokens[1].to_i), raw ? 0 : bitflags_from_tokens(tokens), raw)
+          @value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens))
         end
 
-        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
 
-          [retrieve(read_data(tokens[1].to_i), raw ? 0 : bitflags_from_tokens(tokens), raw), cas]
+          [@value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens)), cas]
         end
 
         def meta_get_without_value
@@ -65,13 +62,12 @@ 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,
-                                   raw: false)
+        def meta_get_with_metadata(cache_nils: false, return_hit_status: false, return_last_access: false)
           tokens = error_on_unexpected!([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[:value] = parse_value_from_tokens(tokens, cache_nils, raw)
+          result[:value] = parse_value_from_tokens(tokens, cache_nils)
           result
         end
 
@@ -83,16 +79,11 @@ module Dalli
           }
         end
 
-        def parse_value_from_tokens(tokens, cache_nils, raw = false) # rubocop:disable Style/OptionalBooleanParameter
+        def parse_value_from_tokens(tokens, cache_nils)
           return cache_nils ? ::Dalli::NOT_FOUND : nil if tokens.first == EN
           return unless tokens.first == VA
 
-          retrieve(read_data(tokens[1].to_i), raw ? 0 : bitflags_from_tokens(tokens), raw)
-        end
-
-        # Values from a raw request are returned as stored
-        def retrieve(value, bitflags, raw)
-          raw ? value : @value_marshaller.retrieve(value, bitflags)
+          @value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens))
         end
 
         def meta_set_with_cas
@@ -156,11 +147,15 @@ module Dalli
           true
         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') }
+        def tokens_from_header_buffer(buf)
+          header = header_from_buffer(buf)
+          tokens = header.split
+          header_len = header.bytesize + TERMINATOR.length
+          body_len = body_len_from_tokens(tokens)
+          [tokens, header_len, body_len]
+        end
 
+        def full_response_from_buffer(tokens, body, resp_size)
           value = @value_marshaller.retrieve(body, bitflags_from_tokens(tokens))
           [resp_size, tokens.first == VA, cas_from_tokens(tokens), key_from_tokens(tokens), value]
         end
@@ -175,55 +170,35 @@ module Dalli
         # The remaining three values in the array are the ResponseHeader,
         # key, and value.
         ##
-        def getk_response_from_buffer(buf, offset = 0)
-          # Find the header terminator starting from offset
-          term_idx = buf.index(TERMINATOR, offset)
-          return [0, nil, nil, nil, nil] unless term_idx
+        def getk_response_from_buffer(buf)
+          # There's no header in the buffer, so don't advance
+          return [0, nil, nil, nil, nil] unless contains_header?(buf)
 
-          header = buf.byteslice(offset, term_idx - offset)
-          tokens = header.split
-          header_len = header.bytesize + TERMINATOR.length
-          body_len = body_len_from_tokens(tokens)
+          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
           # a complete response, don't advance the buffer
-          return [0, nil, nil, nil, nil] unless buf.bytesize >= offset + resp_size
+          return [0, nil, nil, nil, nil] unless buf.bytesize >= resp_size
 
           # The full response is in our buffer, so parse it and return
           # the values
-          body = buf.byteslice(offset + header_len, body_len)
+          body = buf.slice(header_len, body_len)
           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"
+        def contains_header?(buf)
+          buf.include?(TERMINATOR)
         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
+        def header_from_buffer(buf)
+          buf.split(TERMINATOR, 2).first
         end
 
         def error_on_unexpected!(expected_codes)
@@ -266,11 +241,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)
@@ -290,9 +261,6 @@ module Dalli
         end
 
         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/server_config_parser.rb

@@ -6,7 +6,7 @@ module Dalli
   module Protocol
     ##
     # Dalli::Protocol::ServerConfigParser parses a server string passed to
-    # a Dalli::Protocol::Binary instance into the hostname, port, weight, and
+    # a Dalli::Protocol::Meta instance into the hostname, port, weight, and
     # socket_type.
     ##
     class ServerConfigParser

data/lib/dalli/protocol/value_compressor.rb

@@ -15,17 +15,11 @@ module Dalli
         compress: true,
         compressor: ::Dalli::Compressor,
         # min byte size to attempt compression
-        compression_min_size: 4 * 1024, # 4K
-        # max size a stored value may decompress to (nil: no limit). Guards
-        # against a small compressed value expanding into gigabytes on read.
-        decompressed_max_bytes: 128 * 1024 * 1024 # 128 MiB
+        compression_min_size: 4 * 1024 # 4K
       }.freeze
 
       OPTIONS = DEFAULTS.keys.freeze
 
-      KEYWORD_PARAMETER_TYPES = %i[key keyreq].freeze
-      private_constant :KEYWORD_PARAMETER_TYPES
-
       # https://www.hjp.at/zettel/m/memcached_flags.rxml
       # Looks like most clients use bit 1 to indicate gzip compression.
       FLAG_COMPRESSED = 0x2
@@ -44,16 +38,8 @@ module Dalli
       end
 
       def retrieve(value, bitflags)
-        return value unless bitflags.anybits?(FLAG_COMPRESSED)
-
-        max_bytes = @compression_options[:decompressed_max_bytes]
-        # Custom compressors that only define decompress(data) keep working,
-        # without the limit
-        if max_bytes && compressor_accepts_max_bytes?
-          compressor.decompress(value, max_bytes: max_bytes)
-        else
-          compressor.decompress(value)
-        end
+        compressed = bitflags.anybits?(FLAG_COMPRESSED)
+        compressed ? compressor.decompress(value) : value
 
       # TODO: We likely want to move this rescue into the Dalli::Compressor / Dalli::GzipCompressor
       # itself, since not all compressors necessarily use Zlib.  For now keep it here, so the behavior
@@ -62,19 +48,6 @@ module Dalli
         raise UnmarshalError, "Unable to uncompress value: #{$ERROR_INFO.message}"
       end
 
-      def compressor_accepts_max_bytes?
-        return @compressor_accepts_max_bytes if defined?(@compressor_accepts_max_bytes)
-
-        @compressor_accepts_max_bytes =
-          begin
-            compressor.method(:decompress).parameters.any? do |type, name|
-              name == :max_bytes && KEYWORD_PARAMETER_TYPES.include?(type)
-            end
-          rescue NameError # an object without a reflectable decompress method
-            false
-          end
-      end
-
       def compress_by_default?
         @compression_options[:compress]
       end
@@ -88,13 +61,11 @@ module Dalli
       end
 
       # Checks whether we should apply compression when serializing a value
-      # based on the specified options.  Returns false for a raw request
-      # (raw reads ignore bitflags, so the value must be stored as given) or
-      # unless the value is greater than the minimum compression size.
-      # Otherwise returns based on a method-level option if specified,
-      # falling back to the server default.
+      # based on the specified options.  Returns false unless the value
+      # is greater than the minimum compression size.  Otherwise returns
+      # based on a method-level option if specified, falling back to the
+      # server default.
       def compress_value?(value, req_options)
-        return false if req_options&.dig(:raw)
         return false unless value.bytesize >= compression_min_size
         return compress_by_default? unless req_options && !req_options[:compress].nil?
 

data/lib/dalli/protocol/value_serializer.rb

@@ -102,7 +102,7 @@ module Dalli
         Dalli.logger.warn 'SECURITY WARNING: Dalli is using Marshal for serialization. ' \
                           'Marshal can execute arbitrary code during deserialization. ' \
                           'If your memcached server could be compromised, consider using ' \
-                          'a safer serializer: Dalli::Client.new(servers, serializer: Dalli::JSONSerializer)'
+                          'a safer serializer like JSON: Dalli::Client.new(servers, serializer: JSON)'
         @@marshal_warning_logged = true # rubocop:disable Style/ClassVars
       end
     end

data/lib/dalli/protocol.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'openssl'
 require 'timeout'
 
 module Dalli
@@ -17,11 +16,14 @@ module Dalli
         [Timeout::Error]
       end
 
-    # SSL errors during the handshake or during read/write operations count as
-    # a failed request: they trigger reconnection and, after
-    # socket_max_failures, mark the server down.
-    # openssl is required above: this file loads before dalli/socket, so a
-    # defined? check here would find OpenSSL missing and leave this empty.
-    SSL_ERRORS = [OpenSSL::SSL::SSLError].freeze
+    # SSL errors that occur during read/write operations (not during initial
+    # handshake) should trigger reconnection. These indicate transient network
+    # issues, not configuration problems.
+    SSL_ERRORS =
+      if defined?(OpenSSL::SSL::SSLError)
+        [OpenSSL::SSL::SSLError]
+      else
+        []
+      end
   end
 end

data/lib/dalli/ring.rb

@@ -23,9 +23,9 @@ module Dalli
 
     attr_accessor :servers, :continuum
 
-    def initialize(servers_arg, protocol_implementation, options)
+    def initialize(servers_arg, options)
       @servers = servers_arg.map do |s|
-        protocol_implementation.new(s, options)
+        Dalli::Protocol::Meta.new(s, options)
       end
       @continuum = nil
       @continuum = build_continuum(servers) if servers.size > 1

data/lib/dalli/servers_arg_normalizer.rb

@@ -16,7 +16,7 @@ module Dalli
   #     weight are optional (e.g. 'localhost', 'abc.com:12345', 'example.org:22222:3')
   #   * A colon separated string of (UNIX socket, weight) where the weight is optional
   #     (e.g. '/var/run/memcached/socket', '/tmp/xyz:3') (not supported on Windows)
-  #   * A URI with a 'memcached' protocol, which will typically include a username/password
+  #   * A URI with a 'memcached' protocol (e.g. 'memcached://localhost:11211')
   #
   # The methods in this module do not validate the format of individual server strings, but
   # rather normalize the argument into a compact array, wherein each array entry corresponds