dalli 5.2.6 → 5.3.0

data/lib/dalli/key_grouping.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Dalli
+  ##
+  # Groups a multi-key operation's keys by server, for PipelinedGetter,
+  # PipelinedSetter and PipelinedDeleter. Each of them is created for one
+  # operation, and retries the whole operation after a RetryableNetworkError.
+  #
+  # A key with no server to go to is left out, as it always has been: a
+  # server that was down before the operation started is skipped, and with
+  # failover its keys go to another server. Without failover a retry is
+  # different. The server was there for the first attempt and failed while
+  # serving it, so if the retry finds it unreachable, the operation raises
+  # Dalli::NetworkError rather than returning that server's keys as misses or
+  # leaving them unwritten. With failover the keys go to another server, or
+  # are left out when none is left, as for a server down from the start.
+  ##
+  module KeyGrouping
+    NO_KEYS = [].freeze
+    private_constant :NO_KEYS
+
+    private
+
+    # action names the operation in the debug log ('get', 'set', 'delete')
+    def groups_for_keys(keys, action)
+      groups = @ring.keys_grouped_by_server(keys)
+      unrouted = groups.delete(nil)
+      check_unrouted!(unrouted) unless @ring.failover?
+      if unrouted
+        Dalli.logger.debug do
+          "unable to #{action} #{unrouted.length} keys because no matching server was found"
+        end
+      end
+      groups
+    end
+
+    # The first attempt records the keys that already had no server; a retry
+    # raises for any other key that has none now
+    def check_unrouted!(unrouted)
+      return @unrouted_on_first_attempt = unrouted || NO_KEYS unless @unrouted_on_first_attempt
+      return unless unrouted
+
+      lost = unrouted - @unrouted_on_first_attempt
+      return if lost.empty?
+
+      raise Dalli::NetworkError, "#{lost.length} keys had a server that failed during this request " \
+                                 'and is still unreachable after retrying'
+    end
+  end
+end

data/lib/dalli/key_manager.rb

@@ -71,6 +71,31 @@ module Dalli
       "#{evaluate_namespace}#{namespace_separator}#{key}"
     end
 
+    ##
+    # Validates the keys for a multi-get. Returns a Hash from each key as
+    # sent to the caller's key (as a String) it came from, for #caller_key.
+    # A reply names the key as sent: namespaced, digested when too long, and
+    # decoded from base64 as UTF-8 when it was encoded, so it can't be turned
+    # back into the caller's key on its own. Keys are compared as bytes, and
+    # a key given more than once is sent once.
+    ##
+    def caller_keys_by_wire_key(keys)
+      keys.each_with_object({}) do |key, caller_keys|
+        key = key.to_s
+        caller_keys[bytes_form(validate_key(key))] ||= key
+      end
+    end
+
+    ##
+    # The caller's key for a multi-get reply's key, using the Hash from
+    # #caller_keys_by_wire_key. Returns nil for a key that wasn't requested.
+    ##
+    def caller_key(caller_keys, reply_key)
+      # A non-ASCII key in the Hash is binary, and a reply's key decoded from
+      # base64 is UTF-8; ASCII keys, the usual case, are found as is
+      caller_keys[reply_key] || caller_keys[reply_key.b]
+    end
+
     def key_without_namespace(key)
       return key if namespace.nil?
 
@@ -146,6 +171,11 @@ module Dalli
       ((key.bytesize + 2) / 3) * 4
     end
 
+    # ASCII keys compare equal in any encoding as is
+    def bytes_form(key)
+      key.ascii_only? ? key : key.b
+    end
+
     def prefix_length(digest)
       return TRUNCATED_KEY_TARGET_SIZE - (TRUNCATED_KEY_SEPARATOR.length + digest.length) if namespace.nil?
 

data/lib/dalli/pipelined_deleter.rb

@@ -7,6 +7,8 @@ module Dalli
   # and using quiet mode to minimize round trips.
   ##
   class PipelinedDeleter
+    include KeyGrouping
+
     def initialize(ring, key_manager)
       @ring = ring
       @key_manager = key_manager
@@ -25,8 +27,9 @@ module Dalli
     #   tombstoned rather than removed. This is best-effort: a transient
     #   network error is retried automatically, and keys handled before the
     #   error are not recounted, so the result may under-report when a retry
-    #   occurs. If a server remains unreachable after retrying, raises
-    #   Dalli::NetworkError.
+    #   occurs. If a server stops during the call and is still unreachable
+    #   after retrying, raises Dalli::NetworkError without failover (see
+    #   KeyGrouping).
     ##
     def process(keys, req_options = nil)
       return 0 if keys.empty?
@@ -44,7 +47,8 @@ module Dalli
     private
 
     def setup_requests(keys, req_options = nil)
-      groups = groups_for_keys(keys)
+      validated_keys = keys.map { |k| @key_manager.validate_key(k.to_s) }
+      groups = groups_for_keys(validated_keys, 'delete')
       make_delete_requests(groups, req_options)
       groups
     end
@@ -89,18 +93,5 @@ module Dalli
         0
       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

@@ -5,6 +5,8 @@ module Dalli
   # Contains logic for the pipelined gets implemented by the client.
   ##
   class PipelinedGetter
+    include KeyGrouping
+
     # For large batches, interleave sends with response draining to prevent
     # socket buffer deadlock. Only kicks in above this threshold.
     INTERLEAVE_THRESHOLD = 10_000
@@ -25,8 +27,14 @@ module Dalli
     # With return_cas: false the CAS value is not requested, and each yielded
     # CAS is 0.
     #
-    # A transient network error is retried automatically. If a server remains
-    # unreachable after retrying, raises Dalli::NetworkError.
+    # A transient network error is retried automatically, starting the batch
+    # again, so a key can be yielded twice. If a server stops during the call
+    # and is still unreachable after retrying, raises Dalli::NetworkError
+    # without failover (see KeyGrouping).
+    #
+    # A value that can't be deserialized raises Dalli::UnmarshalError, as get
+    # does, once every server's replies are read, so the connections stay in
+    # step. The other values are yielded first.
     #
     def process(keys, req_options = nil, return_cas: true, &block)
       return {} if keys.empty?
@@ -37,13 +45,15 @@ module Dalli
         begin
           # Stores partial results collected during interleaved send phase
           @partial_results = {}
-          setup_requests(servers, keys, req_options, return_cas: return_cas)
-          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @unmarshal_error = nil
+          @caller_keys = @key_manager.caller_keys_by_wire_key(keys.flatten)
+          setup_requests(servers, @caller_keys.keys, req_options, return_cas: return_cas)
 
           # First yield any partial results collected during interleaved send
           yield_partial_results(&block)
 
-          fetch_responses(servers, start_time, @ring.socket_timeout, &block) until servers.empty?
+          fetch_responses(servers, @ring.socket_timeout, &block) until servers.empty?
+          raise @unmarshal_error if @unmarshal_error
         ensure
           abort_unfinished(servers)
         end
@@ -64,6 +74,9 @@ module Dalli
     # metadata path has no interleaving support, and the stale-aware callers it
     # serves fetch far smaller batches than get_multi does.
     #
+    # A value that can't be deserialized raises Dalli::UnmarshalError, once its
+    # server's replies are read. The servers after it aren't asked.
+    #
     # `req_options` accepts :p_token/:l_token, applied to every key in the batch.
     #
     # A transient network error is retried automatically. A terminal
@@ -74,15 +87,18 @@ module Dalli
 
       @ring.lock do
         results = {}
-        groups_for_keys(keys).each do |server, keys_for_server|
-          results.merge!(server.request(:read_multi_with_metadata_req, keys_for_server, req_options))
-        rescue Dalli::NetworkError
+        caller_keys = @key_manager.caller_keys_by_wire_key(keys)
+        groups_for_keys(caller_keys.keys, 'get').each do |server, keys_for_server|
+          server.request(:read_multi_with_metadata_req, keys_for_server, req_options).each_pair do |key, metadata|
+            caller_key = @key_manager.caller_key(caller_keys, key)
+            results[caller_key] = metadata if caller_key
+          end
+        rescue Dalli::NetworkError, Dalli::UnmarshalError
           raise
         rescue DalliError => e
           Dalli.logger.debug { e.inspect }
           Dalli.logger.debug { "unable to get keys for server #{server.name}" }
         end
-        results.transform_keys! { |key| @key_manager.key_without_namespace(key) }
         results
       end
     rescue Dalli::RetryableNetworkError => e
@@ -95,7 +111,8 @@ module Dalli
 
     def yield_partial_results
       @partial_results.each_pair do |key, value_list|
-        yield @key_manager.key_without_namespace(key), value_list
+        caller_key = @key_manager.caller_key(@caller_keys, key)
+        yield caller_key, value_list if caller_key
       end
       @partial_results.clear
     end
@@ -104,15 +121,15 @@ module Dalli
     # the next server's, so memcached is already answering the first servers
     # while the rest are prepared. Adds the servers with a pending response
     # to started.
-    def setup_requests(started, keys, req_options = nil, return_cas: true)
-      groups_for_keys(keys).each do |server, keys_for_server|
+    def setup_requests(started, wire_keys, req_options = nil, return_cas: true)
+      groups_for_keys(wire_keys, 'get').each do |server, keys_for_server|
         make_getkq_request(server, keys_for_server, req_options, return_cas: return_cas)
         next unless server.connected?
 
         started << server
         finish_query_for_server(server)
       rescue Dalli::NetworkError
-        abort_without_timeout(started)
+        abort_unfinished(started)
         raise
       rescue Dalli::DalliError
         started.delete(server)
@@ -160,33 +177,26 @@ module Dalli
       raise
     end
 
-    # Swallows Dalli::NetworkError. Empties servers, so they aren't aborted
-    # again.
-    def abort_without_timeout(servers)
-      servers.each(&:pipeline_abort)
-      servers.clear
-    end
-
-    # When #process stops before reading every server's replies (the caller's
-    # block raises or breaks, a Timeout.timeout fires, a value can't be
-    # deserialized), the rest are still on the socket and some may be in the
-    # response buffer. Closing those connections keeps them from being read
-    # as a later request's replies. Aborts that #process already handled
-    # emptied servers.
+    # When #process stops before reading every server's replies (a server
+    # fails, the caller's block raises or breaks, a Timeout.timeout fires),
+    # the rest are still on the socket and some may be in the response buffer.
+    # Closing those connections keeps them from being read as a later
+    # request's replies. Empties servers, so they aren't aborted again.
     def abort_unfinished(servers)
-      servers.each { |server| server.pipeline_abort(timed_out: false) }
+      servers.each(&:pipeline_abort)
       servers.clear
     end
 
-    # Reads the replies available, removing finished servers from servers
-    def fetch_responses(servers, start_time, timeout, &block)
+    # Reads the replies available, removing finished servers from servers.
+    # The wait is for any server to send something, so it starts again after
+    # each read: a large batch that keeps arriving isn't cut off.
+    def fetch_responses(servers, timeout, &block)
       # Remove any servers which are not connected
       servers.select!(&:connected?)
       return if servers.empty?
 
-      time_left = remaining_time(start_time, timeout)
-      readable_servers = servers_with_response(servers, time_left)
-      return abort_with_timeout(servers) if readable_servers.empty?
+      readable_servers = servers_with_response(servers, timeout)
+      time_out(servers) if readable_servers.empty?
 
       # Loop through the servers with responses, and
       # delete any from our list that are finished
@@ -196,33 +206,42 @@ module Dalli
     rescue NetworkError
       # Abort and raise if we encountered a network error.  This triggers
       # a retry at the top level on RetryableNetworkError.
-      abort_without_timeout(servers)
+      abort_unfinished(servers)
       raise
     end
 
-    def remaining_time(start, timeout)
-      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
-      return 0 if elapsed > timeout
-
-      timeout - elapsed
-    end
-
-    # Swallows Dalli::NetworkError
-    def abort_with_timeout(servers)
+    # No server sent anything for socket_timeout. Each counts it as a failed
+    # read, as get does, so it's retried and, after socket_max_failures,
+    # marked down. Raises the first server's error.
+    def time_out(servers)
+      error = nil
       servers.each do |server|
-        Dalli.logger.debug { "memcached at #{server.name} did not response within timeout" }
+        server.pipeline_timed_out!
+      rescue Dalli::NetworkError => e
+        error ||= e
       end
-      abort_without_timeout(servers)
+      raise error
     end
 
     # Processes responses from a server.  Returns true if there are no
     # additional responses from this server.
+    #
+    # A value that couldn't be deserialized is raised once the server's
+    # replies are all read; it's held until the other servers' are too.
     def process_server(server)
+      # A reply names the key as sent; it's yielded under the caller's key
       server.pipeline_next_responses do |key, value, cas|
-        yield @key_manager.key_without_namespace(key), [value, cas]
+        caller_key = @key_manager.caller_key(@caller_keys, key)
+        yield caller_key, [value, cas] if caller_key
       end
 
       server.pipeline_complete?
+    rescue Dalli::UnmarshalError => e
+      # Raised by the caller's block, with replies still to read
+      raise unless server.pipeline_complete?
+
+      @unmarshal_error ||= e
+      true
     end
 
     def servers_with_response(servers, timeout)
@@ -237,18 +256,5 @@ module Dalli
       # reuses the sockets already fetched above.
       readable.filter_map { |sock| (idx = sockets.index(sock)) && servers[idx] }
     end
-
-    def groups_for_keys(*keys)
-      keys.flatten!
-      keys.map! { |a| @key_manager.validate_key(a.to_s) }
-      groups = @ring.keys_grouped_by_server(keys)
-      if (unfound_keys = groups.delete(nil))
-        Dalli.logger.debug do
-          "unable to get keys for #{unfound_keys.length} keys " \
-            'because no matching server was found'
-        end
-      end
-      groups
-    end
   end
 end

data/lib/dalli/pipelined_setter.rb

@@ -7,6 +7,8 @@ module Dalli
   # and using quiet mode to minimize round trips.
   ##
   class PipelinedSetter
+    include KeyGrouping
+
     def initialize(ring, key_manager)
       @ring = ring
       @key_manager = key_manager
@@ -15,8 +17,9 @@ module Dalli
     ##
     # Writes multiple key-value pairs to memcached.
     #
-    # A transient network error is retried automatically. If a server remains
-    # unreachable after retrying, raises Dalli::NetworkError.
+    # A transient network error is retried automatically. If a server stops
+    # during the call and is still unreachable after retrying, raises
+    # Dalli::NetworkError without failover (see KeyGrouping).
     #
     # A value that can't be marshalled or is over value_max_bytes is skipped;
     # the other keys are still stored, then the first such error is raised.
@@ -47,7 +50,7 @@ module Dalli
     # rebuilt from it: a long key is digested, and a Symbol becomes a String.
     def setup_requests(hash, ttl, req_options)
       pairs = hash.transform_keys { |k| @key_manager.validate_key(k.to_s) }
-      groups = groups_for_keys(pairs.keys)
+      groups = groups_for_keys(pairs.keys, 'set')
       make_set_requests(groups, pairs, ttl, req_options)
       groups.keys
     end
@@ -92,17 +95,5 @@ module Dalli
         Dalli.logger.debug { "unable to complete pipelined set on server #{server.name}" }
       end
     end
-
-    def groups_for_keys(keys)
-      groups = @ring.keys_grouped_by_server(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

@@ -39,8 +39,9 @@ module Dalli
 
       def initialize(attribs, client_options = {})
         hostname, port, socket_type, @weight, user_creds = ServerConfigParser.parse(attribs)
+        # Credentials are unused since Dalli 5: warned about, and not kept
         warn_uri_credentials(user_creds)
-        @options = client_options.merge(user_creds)
+        @options = client_options
         @raw_mode = client_options[:raw]
         @defer_drain = client_options[:defer_drain] ? true : false
         @verify_reply_keys = client_options[:verify_reply_keys] ? true : false
@@ -68,24 +69,25 @@ module Dalli
 
         begin
           request_completed = false
-          @connection_manager.start_request!
+          # Drained before the request starts, so a failure while draining
+          # isn't taken for one after this request was sent
           drain_pending_quiet_responses(opkey)
+          @connection_manager.start_request!
           response = send(opkey, *args)
-          # Quiet requests can leave replies on the socket; remember that so the
-          # end of the quiet block knows this server needs draining
-          @connection_manager.mark_quiet_responses_pending! if quiet? && opkey != :noop
-
-          # 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)
-
+          finish_request(opkey)
           request_completed = true
           response
-        rescue Dalli::MarshalError, Dalli::ValueOverMaxSize => e
+        rescue Dalli::RetryableNetworkError => e
+          raise_unless_resend_safe!(e, opkey, args)
+          raise
+        rescue Dalli::MarshalError, Dalli::UnmarshalError, Dalli::ValueOverMaxSize => e
           log_marshal_err(args.first, e) if e.is_a?(Dalli::MarshalError)
           # Raised only while the connection is clean: a value is marshalled
           # before any of its request is written, and write_multi_req raises
-          # only after reading every reply. Closing the connection would
-          # discard earlier quiet writes still waiting in the write buffer.
+          # only after reading every reply. Likewise a value is unmarshalled
+          # only after its reply is read, and the multi-gets raise only after
+          # reading every reply. Closing the connection would discard earlier
+          # quiet writes still waiting in the write buffer.
           @connection_manager.abort_request!
           request_completed = true
           raise
@@ -191,8 +193,9 @@ module Dalli
           end
 
           # 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
-          unless key.nil?
+          # getkq response with a value that we want to set in the response hash.
+          # A false status is a reply to skip (see getk_response_from_buffer).
+          if status && key
             if block
               yield key, value, cas
             else
@@ -211,31 +214,38 @@ module Dalli
 
         values || {}
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-      # Abort current pipelined get. Generally used to signal an external
-      # timeout during pipelined get, or that the get_multi stopped before
-      # reading all its replies (timed_out: false).  The underlying socket is
+      # Abort current pipelined get, when the get_multi stopped before reading
+      # all its replies: the caller's block raised or broke, an external
+      # timeout fired, or another server failed. The underlying socket is
       # disconnected, and the exception is swallowed.
       #
       # Returns nothing.
-      def pipeline_abort(timed_out: true)
-        response_buffer.clear
-        @pipeline_out_of_step = false
-        @expected_reply_keys = nil
+      def pipeline_abort
+        clear_pipeline
         @connection_manager.abort_request!
         return true unless connected?
 
         # Closes the connection, which ensures that our connection is in a
-        # clean state for future requests. The get_multi ran out of time
-        # overall, or stopped early, rather than hitting a socket error, so it
-        # doesn't count toward socket_max_failures: two slow get_multis in a
-        # row would otherwise mark a healthy server down.
-        log_pipeline_abort(timed_out)
+        # clean state for future requests. This server didn't fail, so it
+        # doesn't count toward socket_max_failures.
+        Dalli.logger.debug { "#{name} get_multi stopped before reading all replies; closing the connection" }
         @connection_manager.close
         true
       end
 
+      # A pipelined get waited socket_timeout for this server to send
+      # anything. Counted as a failed read, like a get's read timeout: raises
+      # Dalli::RetryableNetworkError, or Dalli::NetworkError once the server
+      # reaches socket_max_failures and is marked down.
+      def pipeline_timed_out!
+        clear_pipeline
+        # Raised and rescued so that down! records it as the reason
+        raise IO::TimeoutError, "No reply to get_multi within #{@connection_manager.socket_timeout}s"
+      rescue IO::TimeoutError => e
+        @connection_manager.error_on_request!(e)
+      end
+
       # Did the last call to #pipeline_response_setup complete successfully?
       def pipeline_complete?
         !response_buffer.in_progress?
@@ -250,14 +260,74 @@ module Dalli
 
       private
 
-      URI_CREDENTIAL_WARNING = 'Dalli 5.0 removed SASL authentication. ' \
-                               'Credentials in memcached:// URIs are ignored.'
-      private_constant :URI_CREDENTIAL_WARNING
-
+      # Dalli::Client strips credentials before a server is built, so this is
+      # only for a server built directly from a URI with them
       def warn_uri_credentials(user_creds)
         return if user_creds[:username].nil? && user_creds[:password].nil?
 
-        Dalli.logger.warn(URI_CREDENTIAL_WARNING)
+        Dalli.logger.warn(ServersArgNormalizer::URI_CREDENTIAL_WARNING)
+      end
+
+      # Requests that leave memcached in the same state, and get the same kind
+      # of reply, when it applies them twice. Only these are retried after a
+      # failure that came once some of the request was sent, since memcached
+      # may have applied it and only the reply was lost. A set, replace or
+      # delete is in this group only without a CAS (see #resend_safe?). :cas
+      # is the read behind get_cas.
+      RESEND_SAFE_OPS = %i[get gat touch cas version stats reset_stats noop flush
+                           read_multi_req read_multi_with_metadata_req pipelined_get pipelined_get_interleaved
+                           write_multi_req pipelined_set delete_multi_req pipelined_delete
+                           finish_pipelined_delete].freeze
+      private_constant :RESEND_SAFE_OPS
+
+      # A request that may have been applied, and can't safely be sent again,
+      # fails with a NetworkError the callers don't retry. Sending it again
+      # would apply an incr, decr, append or prepend twice, or report an add
+      # or CAS write that succeeded as failed.
+      def raise_unless_resend_safe!(err, opkey, args)
+        return unless err.request_sent?
+        return if resend_safe?(opkey, args)
+
+        raise Dalli::NetworkError, "#{name}: #{opkey} failed after it was sent, so it may have been applied; " \
+                                   "not retrying it. #{err.message}"
+      end
+
+      def resend_safe?(opkey, args)
+        case opkey
+        # A replace sent again stores the same value, as a set does
+        when :set, :replace then no_cas?(args[3])
+        when :delete then no_cas?(args[1])
+        # With N or R, only the first request wins the recache race; a resent
+        # one would report the race lost to the caller that won it
+        when :meta_get then !(args[1] && (args[1][:vivify_ttl] || args[1][:recache_ttl]))
+        else RESEND_SAFE_OPS.include?(opkey)
+        end
+      end
+
+      # A CAS of 0 or nil means an unconditional write
+      def no_cas?(cas)
+        cas.nil? || cas.to_i.zero?
+      end
+
+      # Only a request whose reply was read resets the failure count. Otherwise
+      # a server that takes set_multi's writes, then drops the connection before
+      # the noop's reply, would be back at zero on every retry, never reach
+      # socket_max_failures, and be retried forever.
+      def finish_request(opkey)
+        case opkey
+        # Finished by finish_pipeline, once the replies are read
+        when :pipelined_get, :pipelined_get_interleaved then nil
+        when :pipelined_set, :pipelined_delete then @connection_manager.finish_unanswered_request!
+        else
+          if quiet? && opkey != :noop
+            # Its reply is left on the socket; the end of the quiet block, or
+            # the next non-quiet request, reads it
+            @connection_manager.mark_quiet_responses_pending!
+            @connection_manager.finish_unanswered_request!
+          else
+            @connection_manager.finish_request!
+          end
+        end
       end
 
       ALLOWED_QUIET_OPS = %i[add replace set delete incr decr append prepend flush noop].freeze
@@ -354,7 +424,7 @@ module Dalli
 
         kwargs = {}
         kwargs[:stale] = true if opts[:invalidate]
-        kwargs[:ttl] = TtlSanitizer.sanitize(Integer(opts[:tombstone_ttl])) if opts[:tombstone_ttl]
+        kwargs[:ttl] = TtlSanitizer.sanitize(opts[:tombstone_ttl]) if opts[:tombstone_ttl]
         kwargs[:drop_value] = true if opts[:drop_value]
         kwargs
       end
@@ -374,6 +444,8 @@ module Dalli
         # the expected state before pipeline_response_setup is called.
         response_buffer.clear
         response_buffer.raw = raw_request?(options)
+        # Drops an error held from a get_multi that stopped early
+        response_processor.take_unmarshal_error
         expect_reply_keys(keys)
 
         # The terminating noop is sent by pipeline_response_setup
@@ -388,6 +460,8 @@ module Dalli
         # left by an earlier get_multi that stopped early belong to its replies.
         response_buffer.reset
         response_buffer.raw = raw_request?(options)
+        # Drops an error held from a get_multi that stopped early
+        response_processor.take_unmarshal_error
         expect_reply_keys(keys)
 
         keys.each_slice(chunk_size) do |chunk|
@@ -427,7 +501,7 @@ module Dalli
             break
           end
 
-          results[key] = [value, cas] unless key.nil?
+          results[key] = [value, cas] if status && key
         end
       rescue SystemCallError, Dalli::NetworkError
         # Ignore errors during drain - they'll be handled in fetch_responses
@@ -479,10 +553,14 @@ module Dalli
       end
 
       # Called after the noop response is received at the end of a set
-      # of pipelined gets
+      # of pipelined gets. A value that couldn't be deserialized is raised
+      # here, once all of this server's replies are read, so the connection
+      # is left in step.
       def finish_pipeline
         response_buffer.clear
         @connection_manager.finish_request!
+        unmarshal_error = response_processor.take_unmarshal_error
+        raise unmarshal_error if unmarshal_error
 
         true # to simplify response
       end
@@ -496,12 +574,10 @@ module Dalli
                                  '(a request made from inside the get_multi block?)'
       end
 
-      def log_pipeline_abort(timed_out)
-        if timed_out
-          Dalli.logger.warn { "#{name} didn't finish a get_multi within socket_timeout; closing the connection" }
-        else
-          Dalli.logger.debug { "#{name} get_multi stopped before reading all replies; closing the connection" }
-        end
+      def clear_pipeline
+        response_buffer.clear
+        @pipeline_out_of_step = false
+        @expected_reply_keys = nil
       end
 
       # The single-server set_multi path passes its whole pairs hash as the