dalli 3.2.8 → 4.3.3

data/lib/dalli/instrumentation.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Dalli
+  ##
+  # Instrumentation support for Dalli. Provides hooks for distributed tracing
+  # via OpenTelemetry when the SDK is available.
+  #
+  # When OpenTelemetry is loaded, Dalli automatically creates spans for cache operations.
+  # When OpenTelemetry is not available, all tracing methods are no-ops with zero overhead.
+  #
+  # Dalli 4.3.2 uses the stable OTel semantic conventions for database spans.
+  #
+  # == Span Attributes
+  #
+  # All spans include the following default attributes:
+  # - +db.system.name+ - Always "memcached"
+  #
+  # Single-key operations (+get+, +set+, +delete+, +incr+, +decr+, etc.) add:
+  # - +db.operation.name+ - The operation name (e.g., "get", "set")
+  # - +server.address+ - The server hostname (e.g., "localhost")
+  # - +server.port+ - The server port as an integer (e.g., 11211); omitted for Unix sockets
+  #
+  # Multi-key operations (+get_multi+) add:
+  # - +db.operation.name+ - "get_multi"
+  # - +db.memcached.key_count+ - Number of keys requested
+  # - +db.memcached.hit_count+ - Number of keys found in cache
+  # - +db.memcached.miss_count+ - Number of keys not found
+  #
+  # Bulk write operations (+set_multi+, +delete_multi+) add:
+  # - +db.operation.name+ - The operation name
+  # - +db.memcached.key_count+ - Number of keys in the operation
+  #
+  # == Optional Attributes
+  #
+  # - +db.query.text+ - The operation and key(s), controlled by the +:otel_db_statement+ client option:
+  #   - +:include+ - Full text (e.g., "get mykey")
+  #   - +:obfuscate+ - Obfuscated (e.g., "get ?")
+  #   - +nil+ (default) - Attribute omitted
+  # - +peer.service+ - Logical service name, set via the +:otel_peer_service+ client option
+  #
+  # == Error Handling
+  #
+  # When an exception occurs during a traced operation:
+  # - The exception is recorded on the span via +record_exception+
+  # - The span status is set to error with the exception message
+  # - The exception is re-raised to the caller
+  #
+  # @example Checking if tracing is enabled
+  #   Dalli::Instrumentation.enabled? # => true if OpenTelemetry is loaded
+  #
+  ##
+  module Instrumentation
+    # Default attributes included on all memcached spans.
+    # @return [Hash] frozen hash with 'db.system.name' => 'memcached'
+    DEFAULT_ATTRIBUTES = { 'db.system.name' => 'memcached' }.freeze
+
+    class << self
+      # Returns the OpenTelemetry tracer if available, nil otherwise.
+      #
+      # The tracer is cached after first lookup for performance.
+      # Uses the library name 'dalli' and current Dalli::VERSION.
+      #
+      # @return [OpenTelemetry::Trace::Tracer, nil] the tracer or nil if OTel unavailable
+      def tracer
+        return @tracer if defined?(@tracer)
+
+        @tracer = (OpenTelemetry.tracer_provider.tracer('dalli', Dalli::VERSION) if defined?(OpenTelemetry))
+      end
+
+      # Returns true if instrumentation is enabled (OpenTelemetry SDK is available).
+      #
+      # @return [Boolean] true if tracing is active, false otherwise
+      def enabled?
+        !tracer.nil?
+      end
+
+      # Wraps a block with a span if instrumentation is enabled.
+      #
+      # Creates a client span with the given name and attributes merged with
+      # DEFAULT_ATTRIBUTES. The block is executed within the span context.
+      # If an exception occurs, it is recorded on the span before re-raising.
+      #
+      # When tracing is disabled (OpenTelemetry not loaded), this method
+      # simply yields directly with zero overhead.
+      #
+      # @param name [String] the span name (e.g., 'get', 'set', 'delete')
+      # @param attributes [Hash] span attributes to merge with defaults.
+      #   Common attributes include:
+      #   - 'db.operation.name' - the operation name
+      #   - 'server.address' - the server hostname
+      #   - 'server.port' - the server port (integer)
+      #   - 'db.memcached.key_count' - number of keys (for multi operations)
+      # @yield the cache operation to trace
+      # @return [Object] the result of the block
+      # @raise [StandardError] re-raises any exception from the block
+      #
+      # @example Tracing a set operation
+      #   trace('set', { 'db.operation.name' => 'set', 'server.address' => 'localhost', 'server.port' => 11211 }) do
+      #     server.set(key, value, ttl)
+      #   end
+      #
+      def trace(name, attributes = {})
+        return yield unless enabled?
+
+        tracer.in_span(name, attributes: DEFAULT_ATTRIBUTES.merge(attributes), kind: :client) do |_span|
+          yield
+        end
+      end
+
+      # Like trace, but yields the span to allow adding attributes after execution.
+      #
+      # This is useful for operations where metrics are only known after the
+      # operation completes, such as get_multi where hit/miss counts depend
+      # on the cache response.
+      #
+      # When tracing is disabled, yields nil as the span argument.
+      #
+      # @param name [String] the span name (e.g., 'get_multi')
+      # @param attributes [Hash] initial span attributes to merge with defaults
+      # @yield [OpenTelemetry::Trace::Span, nil] the span object, or nil if disabled
+      # @return [Object] the result of the block
+      # @raise [StandardError] re-raises any exception from the block
+      #
+      # @example Recording hit/miss metrics after get_multi
+      #   trace_with_result('get_multi', { 'db.operation.name' => 'get_multi' }) do |span|
+      #     results = fetch_from_cache(keys)
+      #     if span
+      #       span.set_attribute('db.memcached.hit_count', results.size)
+      #       span.set_attribute('db.memcached.miss_count', keys.size - results.size)
+      #     end
+      #     results
+      #   end
+      #
+      def trace_with_result(name, attributes = {}, &)
+        return yield(nil) unless enabled?
+
+        tracer.in_span(name, attributes: DEFAULT_ATTRIBUTES.merge(attributes), kind: :client, &)
+      end
+    end
+  end
+end

data/lib/dalli/key_manager.rb

@@ -12,7 +12,7 @@ module Dalli
   class KeyManager
     MAX_KEY_LENGTH = 250
 
-    NAMESPACE_SEPARATOR = ':'
+    DEFAULT_NAMESPACE_SEPARATOR = ':'
 
     # This is a hard coded md5 for historical reasons
     TRUNCATED_KEY_SEPARATOR = ':md5:'
@@ -21,19 +21,26 @@ module Dalli
     TRUNCATED_KEY_TARGET_SIZE = 249
 
     DEFAULTS = {
-      digest_class: ::Digest::MD5
+      digest_class: ::Digest::MD5,
+      namespace_separator: DEFAULT_NAMESPACE_SEPARATOR
     }.freeze
 
-    OPTIONS = %i[digest_class namespace].freeze
+    OPTIONS = %i[digest_class namespace namespace_separator].freeze
 
-    attr_reader :namespace
+    attr_reader :namespace, :namespace_separator
+
+    # Valid separators: non-alphanumeric, single printable ASCII characters
+    # Excludes: alphanumerics, whitespace, control characters
+    VALID_NAMESPACE_SEPARATORS = /\A[^a-zA-Z0-9 \x00-\x1F\x7F]\z/
 
     def initialize(client_options)
       @key_options =
-        DEFAULTS.merge(client_options.select { |k, _| OPTIONS.include?(k) })
+        DEFAULTS.merge(client_options.slice(*OPTIONS))
       validate_digest_class_option(@key_options)
+      validate_namespace_separator_option(@key_options)
 
       @namespace = namespace_from_options
+      @namespace_separator = @key_options[:namespace_separator]
     end
 
     ##
@@ -61,7 +68,7 @@ module Dalli
     def key_with_namespace(key)
       return key if namespace.nil?
 
-      "#{evaluate_namespace}#{NAMESPACE_SEPARATOR}#{key}"
+      "#{evaluate_namespace}#{namespace_separator}#{key}"
     end
 
     def key_without_namespace(key)
@@ -75,9 +82,9 @@ module Dalli
     end
 
     def namespace_regexp
-      return /\A#{Regexp.escape(evaluate_namespace)}:/ if namespace.is_a?(Proc)
+      return /\A#{Regexp.escape(evaluate_namespace)}#{Regexp.escape(namespace_separator)}/ if namespace.is_a?(Proc)
 
-      @namespace_regexp ||= /\A#{Regexp.escape(namespace)}:/.freeze unless namespace.nil?
+      @namespace_regexp ||= /\A#{Regexp.escape(namespace)}#{Regexp.escape(namespace_separator)}/ unless namespace.nil?
     end
 
     def validate_digest_class_option(opts)
@@ -86,6 +93,14 @@ module Dalli
       raise ArgumentError, 'The digest_class object must respond to the hexdigest method'
     end
 
+    def validate_namespace_separator_option(opts)
+      sep = opts[:namespace_separator]
+      return if VALID_NAMESPACE_SEPARATORS.match?(sep)
+
+      raise ArgumentError,
+            'namespace_separator must be a single non-alphanumeric character (e.g., ":", "/", "|")'
+    end
+
     def namespace_from_options
       raw_namespace = @key_options[:namespace]
       return nil unless raw_namespace

data/lib/dalli/pipelined_deleter.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Dalli
+  ##
+  # Contains logic for the pipelined delete operations implemented by the client.
+  # Efficiently deletes multiple keys by grouping requests by server
+  # and using quiet mode to minimize round trips.
+  ##
+  class PipelinedDeleter
+    def initialize(ring, key_manager)
+      @ring = ring
+      @key_manager = key_manager
+    end
+
+    ##
+    # Deletes multiple keys from memcached.
+    #
+    # @param keys [Array<String>] keys to delete
+    # @return [void]
+    ##
+    def process(keys)
+      return if keys.empty?
+
+      @ring.lock do
+        servers = setup_requests(keys)
+        finish_requests(servers)
+      end
+    rescue NetworkError => e
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { 'retrying pipelined deletes because of network error' }
+      retry
+    end
+
+    private
+
+    def setup_requests(keys)
+      groups = groups_for_keys(keys)
+      make_delete_requests(groups)
+      groups.keys
+    end
+
+    ##
+    # Loop through the server-grouped sets of keys, writing
+    # the corresponding quiet delete requests to the appropriate servers
+    ##
+    def make_delete_requests(groups)
+      groups.each do |server, keys_for_server|
+        keys_for_server.each do |key|
+          server.request(:pipelined_delete, key)
+        rescue DalliError, NetworkError => e
+          Dalli.logger.debug { e.inspect }
+          Dalli.logger.debug { "unable to delete key #{key} for server #{server.name}" }
+        end
+      end
+    end
+
+    ##
+    # Sends noop to each server to flush responses and ensure all deletes complete.
+    ##
+    def finish_requests(servers)
+      servers.each do |server|
+        server.request(:noop)
+      rescue DalliError, NetworkError => e
+        Dalli.logger.debug { e.inspect }
+        Dalli.logger.debug { "unable to complete pipelined delete on server #{server.name}" }
+      end
+    end
+
+    def groups_for_keys(keys)
+      validated_keys = keys.map { |k| @key_manager.validate_key(k.to_s) }
+      groups = @ring.keys_grouped_by_server(validated_keys)
+
+      if (unfound_keys = groups.delete(nil))
+        Dalli.logger.debug do
+          "unable to delete #{unfound_keys.length} keys because no matching server was found"
+        end
+      end
+
+      groups
+    end
+  end
+end

data/lib/dalli/pipelined_getter.rb

@@ -1,10 +1,19 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module Dalli
   ##
   # Contains logic for the pipelined gets implemented by the client.
   ##
   class PipelinedGetter
+    # For large batches, interleave sends with response draining to prevent
+    # socket buffer deadlock. Only kicks in above this threshold.
+    INTERLEAVE_THRESHOLD = 10_000
+
+    # Number of keys to send before draining responses during interleaved mode
+    CHUNK_SIZE = 10_000
+
     def initialize(ring, key_manager)
       @ring = ring
       @key_manager = key_manager
@@ -17,16 +26,31 @@ module Dalli
       return {} if keys.empty?
 
       @ring.lock do
+        # Stores partial results collected during interleaved send phase
+        @partial_results = {}
         servers = setup_requests(keys)
-        start_time = Time.now
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        # First yield any partial results collected during interleaved send
+        yield_partial_results(&block)
+
         servers = fetch_responses(servers, start_time, @ring.socket_timeout, &block) until servers.empty?
       end
-    rescue NetworkError => e
+    rescue Dalli::RetryableNetworkError => e
       Dalli.logger.debug { e.inspect }
       Dalli.logger.debug { 'retrying pipelined gets because of timeout' }
       retry
     end
 
+    private
+
+    def yield_partial_results
+      @partial_results.each_pair do |key, value_list|
+        yield @key_manager.key_without_namespace(key), value_list
+      end
+      @partial_results.clear
+    end
+
     def setup_requests(keys)
       groups = groups_for_keys(keys)
       make_getkq_requests(groups)
@@ -45,7 +69,14 @@ module Dalli
     ##
     def make_getkq_requests(groups)
       groups.each do |server, keys_for_server|
-        server.request(:pipelined_get, keys_for_server)
+        if keys_for_server.size <= INTERLEAVE_THRESHOLD
+          # Small batch - send all at once (existing behavior)
+          server.request(:pipelined_get, keys_for_server)
+        else
+          # Large batch - interleave sends with response draining
+          # Pass @partial_results directly to avoid hash allocation/merge overhead
+          server.request(:pipelined_get_interleaved, keys_for_server, CHUNK_SIZE, @partial_results)
+        end
       rescue DalliError, NetworkError => e
         Dalli.logger.debug { e.inspect }
         Dalli.logger.debug { "unable to get keys for server #{server.name}" }
@@ -57,7 +88,7 @@ module Dalli
     # our set, sending the noop to terminate the set of queries.
     ##
     def finish_queries(servers)
-      deleted = []
+      deleted = Set.new
 
       servers.each do |server|
         next unless server.connected?
@@ -67,7 +98,7 @@ module Dalli
         rescue Dalli::NetworkError
           raise
         rescue Dalli::DalliError
-          deleted.append(server)
+          deleted << server
         end
       end
 
@@ -94,7 +125,7 @@ module Dalli
 
     def fetch_responses(servers, start_time, timeout, &block)
       # Remove any servers which are not connected
-      servers.delete_if { |s| !s.connected? }
+      servers.select!(&:connected?)
       return [] if servers.empty?
 
       time_left = remaining_time(start_time, timeout)
@@ -112,13 +143,13 @@ module Dalli
       servers
     rescue NetworkError
       # Abort and raise if we encountered a network error.  This triggers
-      # a retry at the top level.
+      # a retry at the top level on RetryableNetworkError.
       abort_without_timeout(servers)
       raise
     end
 
     def remaining_time(start, timeout)
-      elapsed = Time.now - start
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
       return 0 if elapsed > timeout
 
       timeout - elapsed
@@ -137,8 +168,8 @@ module Dalli
     # Processes responses from a server.  Returns true if there are no
     # additional responses from this server.
     def process_server(server)
-      server.pipeline_next_responses.each_pair do |key, value_list|
-        yield @key_manager.key_without_namespace(key), value_list
+      server.pipeline_next_responses do |key, value, cas|
+        yield @key_manager.key_without_namespace(key), [value, cas]
       end
 
       server.pipeline_complete?
@@ -147,18 +178,13 @@ module Dalli
     def servers_with_response(servers, timeout)
       return [] if servers.empty?
 
-      # TODO: - This is a bit challenging.  Essentially the PipelinedGetter
-      # is a reactor, but without the benefit of a Fiber or separate thread.
-      # My suspicion is that we may want to try and push this down into the
-      # individual servers, but I'm not sure.  For now, we keep the
-      # mapping between the alerted object (the socket) and the
-      # corrresponding server here.
-      server_map = servers.each_with_object({}) { |s, h| h[s.sock] = s }
-
-      readable, = IO.select(server_map.keys, nil, nil, timeout)
+      sockets = servers.map(&:sock)
+      readable, = IO.select(sockets, nil, nil, timeout)
       return [] if readable.nil?
 
-      readable.map { |sock| server_map[sock] }
+      # For typical server counts (1-5), linear scan is faster than
+      # building and looking up a hash map
+      readable.filter_map { |sock| servers.find { |s| s.sock == sock } }
     end
 
     def groups_for_keys(*keys)

data/lib/dalli/pipelined_setter.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Dalli
+  ##
+  # Contains logic for the pipelined set operations implemented by the client.
+  # Efficiently writes multiple key-value pairs by grouping requests by server
+  # and using quiet mode to minimize round trips.
+  ##
+  class PipelinedSetter
+    def initialize(ring, key_manager)
+      @ring = ring
+      @key_manager = key_manager
+    end
+
+    ##
+    # Writes multiple key-value pairs to memcached.
+    # Raises an error if any server is unavailable.
+    #
+    # @param hash [Hash] key-value pairs to set
+    # @param ttl [Integer] time-to-live in seconds
+    # @param req_options [Hash] options passed to each set operation
+    # @return [void]
+    ##
+    def process(hash, ttl, req_options)
+      return if hash.empty?
+
+      @ring.lock do
+        servers = setup_requests(hash, ttl, req_options)
+        finish_requests(servers)
+      end
+    rescue Dalli::RetryableNetworkError => e
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { 'retrying pipelined sets because of network error' }
+      retry
+    end
+
+    private
+
+    def setup_requests(hash, ttl, req_options)
+      groups = groups_for_keys(hash.keys)
+      make_set_requests(groups, hash, ttl, req_options)
+      groups.keys
+    end
+
+    ##
+    # Loop through the server-grouped sets of keys, writing
+    # the corresponding quiet set requests to the appropriate servers
+    ##
+    def make_set_requests(groups, hash, ttl, req_options)
+      groups.each do |server, keys_for_server|
+        keys_for_server.each do |key|
+          original_key = @key_manager.key_without_namespace(key)
+          value = hash[original_key]
+          server.request(:pipelined_set, key, value, ttl, req_options)
+        rescue DalliError, NetworkError => e
+          Dalli.logger.debug { e.inspect }
+          Dalli.logger.debug { "unable to set key #{key} for server #{server.name}" }
+        end
+      end
+    end
+
+    ##
+    # Sends noop to each server to flush responses and ensure all writes complete.
+    ##
+    def finish_requests(servers)
+      servers.each do |server|
+        server.request(:noop)
+      rescue DalliError, NetworkError => e
+        Dalli.logger.debug { e.inspect }
+        Dalli.logger.debug { "unable to complete pipelined set on server #{server.name}" }
+      end
+    end
+
+    def groups_for_keys(keys)
+      validated_keys = keys.map { |k| @key_manager.validate_key(k.to_s) }
+      groups = @ring.keys_grouped_by_server(validated_keys)
+
+      if (unfound_keys = groups.delete(nil))
+        Dalli.logger.debug do
+          "unable to set #{unfound_keys.length} keys because no matching server was found"
+        end
+      end
+
+      groups
+    end
+  end
+end

data/lib/dalli/protocol/base.rb

@@ -23,10 +23,17 @@ module Dalli
       def initialize(attribs, client_options = {})
         hostname, port, socket_type, @weight, user_creds = ServerConfigParser.parse(attribs)
         @options = client_options.merge(user_creds)
-        @value_marshaller = ValueMarshaller.new(@options)
+        @raw_mode = client_options[:raw]
+        @value_marshaller = @raw_mode ? StringMarshaller.new(@options) : ValueMarshaller.new(@options)
         @connection_manager = ConnectionManager.new(hostname, port, socket_type, @options)
       end
 
+      # Returns true if client is in raw mode (no serialization/compression).
+      # In raw mode, we can skip requesting bitflags from the server.
+      def raw_mode?
+        @raw_mode
+      end
+
       # Chokepoint method for error handling and ensuring liveness
       def request(opkey, *args)
         verify_state(opkey)
@@ -35,8 +42,8 @@ module Dalli
           @connection_manager.start_request!
           response = send(opkey, *args)
 
-          # pipelined_get emit query but doesn't read the response(s)
-          @connection_manager.finish_request! unless opkey == :pipelined_get
+          # pipelined_get/pipelined_get_interleaved emit query but don't read the response(s)
+          @connection_manager.finish_request! unless %i[pipelined_get pipelined_get_interleaved].include?(opkey)
 
           response
         rescue Dalli::MarshalError => e
@@ -74,7 +81,9 @@ module Dalli
       def pipeline_response_setup
         verify_pipelined_state(:getkq)
         write_noop
-        response_buffer.reset
+        # Use ensure_ready instead of reset to preserve any data already buffered
+        # during interleaved pipelined get draining
+        response_buffer.ensure_ready
       end
 
       # Attempt to receive and parse as many key/value pairs as possible
@@ -82,10 +91,13 @@ module Dalli
       # repeatedly whenever this server's socket is readable until
       # #pipeline_complete?.
       #
-      # Returns a Hash of kv pairs received.
-      def pipeline_next_responses
+      # When a block is given, yields (key, value, cas) for each response,
+      # avoiding intermediate Hash allocation. Returns nil.
+      # Without a block, returns a Hash of { key => [value, cas] }.
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def pipeline_next_responses(&block)
         reconnect_on_pipeline_complete!
-        values = {}
+        values = nil
 
         response_buffer.read
 
@@ -99,16 +111,24 @@ module Dalli
 
           # If the status is ok and the key is not nil, then this is a
           # getkq response with a value that we want to set in the response hash
-          values[key] = [value, cas] unless key.nil?
+          unless key.nil?
+            if block
+              yield key, value, cas
+            else
+              values ||= {}
+              values[key] = [value, cas]
+            end
+          end
 
           # Get the next response from the buffer
           status, cas, key, value = response_buffer.process_single_getk_response
         end
 
-        values
-      rescue SystemCallError, *TIMEOUT_ERRORS, EOFError => e
+        values || {}
+      rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, EOFError => e
         @connection_manager.error_on_request!(e)
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       # Abort current pipelined get. Generally used to signal an external
       # timeout during pipelined get.  The underlying socket is
@@ -154,6 +174,8 @@ module Dalli
       private
 
       ALLOWED_QUIET_OPS = %i[add replace set delete incr decr append prepend flush noop].freeze
+      private_constant :ALLOWED_QUIET_OPS
+
       def verify_allowed_quiet!(opkey)
         return if ALLOWED_QUIET_OPS.include?(opkey)
 
@@ -211,6 +233,11 @@ module Dalli
       end
 
       def pipelined_get(keys)
+        # Clear buffer to remove any stale data from interrupted operations.
+        # Use clear (not reset) to keep pipeline_complete? = true, which is
+        # the expected state before pipeline_response_setup is called.
+        response_buffer.clear
+
         req = +''
         keys.each do |key|
           req << quiet_get_request(key)
@@ -219,6 +246,51 @@ module Dalli
         write(req)
       end
 
+      # For large batches, interleave writing requests with draining responses.
+      # This prevents socket buffer deadlock when sending many keys.
+      # Populates the provided results hash with any responses drained during send.
+      def pipelined_get_interleaved(keys, chunk_size, results)
+        # Initialize the response buffer for draining during send phase
+        response_buffer.ensure_ready
+
+        keys.each_slice(chunk_size) do |chunk|
+          # Build and write this chunk of requests
+          req = +''
+          chunk.each do |key|
+            req << quiet_get_request(key)
+          end
+          write(req)
+          @connection_manager.flush
+
+          # Drain any available responses directly into results hash
+          drain_pipeline_responses(results)
+        end
+      end
+
+      # Non-blocking read and processing of any available pipeline responses.
+      # Used during interleaved pipelined gets to prevent buffer deadlock.
+      # Populates the provided results hash directly to avoid allocation overhead.
+      def drain_pipeline_responses(results)
+        return unless connected?
+
+        # Non-blocking check if socket has data available
+        return unless sock.wait_readable(0)
+
+        # Read available data without blocking
+        response_buffer.read
+
+        # Process any complete responses in the buffer
+        loop do
+          status, cas, key, value = response_buffer.process_single_getk_response
+          break if status.nil? # No complete response available
+
+          results[key] = [value, cas] unless key.nil?
+        end
+      rescue SystemCallError, Dalli::NetworkError
+        # Ignore errors during drain - they'll be handled in fetch_responses
+        nil
+      end
+
       def response_buffer
         @response_buffer ||= ResponseBuffer.new(@connection_manager, response_processor)
       end