dalli 5.0.7 → 5.1.1

data/lib/dalli/pipelined_getter.rb

@@ -20,13 +20,21 @@ module Dalli
     ##
     # Yields, one at a time, keys and their values+attributes.
     #
-    def process(keys, &block)
+    # `req_options` accepts :p_token/:l_token, applied to every key in the batch.
+    #
+    # 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.
+    #
+    def process(keys, req_options = nil, return_cas: true, &block)
       return {} if keys.empty?
 
       @ring.lock do
         # Stores partial results collected during interleaved send phase
         @partial_results = {}
-        servers = setup_requests(keys)
+        servers = setup_requests(keys, req_options, return_cas: return_cas)
         start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
         # First yield any partial results collected during interleaved send
@@ -40,6 +48,40 @@ module Dalli
       retry
     end
 
+    ##
+    # Stale-aware bulk get across servers.  Returns { key => metadata Hash } for
+    # the keys that were found; see Protocol::Meta#read_multi_with_metadata_req
+    # for why misses are absent rather than present with miss: true.
+    #
+    # Unlike #process this issues one request per server and reads its full
+    # response before moving on, rather than pipelining across servers: the
+    # metadata path has no interleaving support, and the stale-aware callers it
+    # serves fetch far smaller batches than get_multi does.
+    #
+    # `req_options` accepts :p_token/:l_token, applied to every key in the batch.
+    #
+    def process_with_metadata(keys, req_options = nil)
+      return {} if keys.empty?
+
+      @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::RetryableNetworkError
+          raise
+        rescue DalliError, NetworkError => 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
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { 'retrying pipelined get with metadata because of network error' }
+      retry
+    end
+
     private
 
     def yield_partial_results
@@ -49,61 +91,55 @@ module Dalli
       @partial_results.clear
     end
 
-    def setup_requests(keys)
-      groups = groups_for_keys(keys)
-      make_getkq_requests(groups)
+    # Sends each server's queries and its terminating noop before building
+    # the next server's, so memcached is already answering the first servers
+    # while the rest are prepared. Returns the servers with a pending response.
+    def setup_requests(keys, req_options = nil, return_cas: true)
+      started = []
+      groups_for_keys(keys).each do |server, keys_for_server|
+        make_getkq_request(server, keys_for_server, req_options, return_cas: return_cas)
+        next unless server.connected?
 
-      # TODO: How does this exit on a NetworkError
-      finish_queries(groups.keys)
+        started << server
+        finish_query_for_server(server)
+      rescue Dalli::NetworkError
+        abort_without_timeout(started)
+        raise
+      rescue Dalli::DalliError
+        started.delete(server)
+      end
+      started
     end
 
     ##
-    # Loop through the server-grouped sets of keys, writing
-    # the corresponding getkq requests to the appropriate servers
+    # Writes the getkq requests for one server's keys
     #
     # It's worth noting that we could potentially reduce bytes
     # on the wire by switching from getkq to getq, and using
     # the opaque value to match requests to responses.
     ##
-    def make_getkq_requests(groups)
-      groups.each do |server, 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}" }
+    def make_getkq_request(server, keys_for_server, req_options = nil, return_cas: true)
+      if keys_for_server.size <= INTERLEAVE_THRESHOLD
+        # Small batch - send all at once (existing behavior)
+        server.request(:pipelined_get, keys_for_server, req_options, return_cas)
+      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, req_options)
       end
-    end
-
-    ##
-    # This loops through the servers that have keys in
-    # our set, sending the noop to terminate the set of queries.
-    ##
-    def finish_queries(servers)
-      deleted = Set.new
-
-      servers.each do |server|
-        next unless server.connected?
-
-        begin
-          finish_query_for_server(server)
-        rescue Dalli::NetworkError
-          raise
-        rescue Dalli::DalliError
-          deleted << server
-        end
-      end
-
-      servers.delete_if { |server| deleted.include?(server) }
+    # NetworkError (which RetryableNetworkError subclasses) must propagate:
+    # #process's top-level rescue retries the whole pipelined get on it. This
+    # rescue used to catch DalliError and NetworkError together -- since
+    # NetworkError < DalliError, that silently swallowed RetryableNetworkError
+    # too, dropping this server's keys from the result on a transient hiccup
+    # instead of retrying, with nothing surfaced above debug-level logging.
+    # Only a non-network DalliError (this server genuinely can't serve these
+    # keys) should be swallowed here.
     rescue Dalli::NetworkError
-      abort_without_timeout(servers)
       raise
+    rescue DalliError => e
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { "unable to get keys for server #{server.name}" }
     end
 
     def finish_query_for_server(server)
@@ -181,8 +217,9 @@ module Dalli
       return [] if readable.nil?
 
       # 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 } }
+      # building and looking up a hash map. Array#index scans in C and
+      # reuses the sockets already fetched above.
+      readable.filter_map { |sock| (idx = sockets.index(sock)) && servers[idx] }
     end
 
     def groups_for_keys(*keys)

data/lib/dalli/pipelined_setter.rb

@@ -14,7 +14,9 @@ module Dalli
 
     ##
     # Writes multiple key-value pairs to memcached.
-    # Raises an error if any server is unavailable.
+    #
+    # A transient network error is retried automatically. If a server remains
+    # unreachable after retrying, raises Dalli::NetworkError.
     #
     # @param hash [Hash] key-value pairs to set
     # @param ttl [Integer] time-to-live in seconds
@@ -46,13 +48,21 @@ module Dalli
     # Loop through the server-grouped sets of keys, writing
     # the corresponding quiet set requests to the appropriate servers
     ##
+    # NetworkError (which RetryableNetworkError subclasses) must propagate: the
+    # top-level rescue in #process retries the whole pipelined set on it. A
+    # combined `rescue DalliError, NetworkError` would silently swallow
+    # RetryableNetworkError too -- since NetworkError < DalliError -- dropping
+    # this server's keys on a transient hiccup instead of retrying. Only a
+    # non-network DalliError should be swallowed here.
     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
+        rescue Dalli::NetworkError
+          raise
+        rescue DalliError => e
           Dalli.logger.debug { e.inspect }
           Dalli.logger.debug { "unable to set key #{key} for server #{server.name}" }
         end
@@ -65,7 +75,9 @@ module Dalli
     def finish_requests(servers)
       servers.each do |server|
         server.request(:noop)
-      rescue DalliError, NetworkError => e
+      rescue Dalli::NetworkError
+        raise
+      rescue DalliError => e
         Dalli.logger.debug { e.inspect }
         Dalli.logger.debug { "unable to complete pipelined set on server #{server.name}" }
       end

data/lib/dalli/protocol/base.rb

@@ -17,8 +17,24 @@ module Dalli
       attr_accessor :weight, :options
 
       def_delegators :@value_marshaller, :serializer, :compressor, :compression_min_size, :compress_by_default?
-      def_delegators :@connection_manager, :name, :sock, :hostname, :port, :close, :connected?, :socket_timeout,
-                     :socket_type, :up!, :down!, :write, :reconnect_down_server?, :raise_down_error, :flushed_write
+      def_delegators :@connection_manager, :name, :hostname, :port, :close, :socket_timeout,
+                     :socket_type, :up!, :down!, :write, :reconnect_down_server?, :raise_down_error
+
+      # Delegated by hand rather than with def_delegators because they run on
+      # every request, and a plain method call is cheaper than a Forwardable one.
+      def connected?
+        @connection_manager.connected?
+      end
+
+      def flushed_write(bytes)
+        @connection_manager.flushed_write(bytes)
+      end
+
+      # Written out rather than delegated: a multi-server get_multi calls it for
+      # every server, and a plain method call is cheaper than a Forwardable one.
+      def sock
+        @connection_manager.sock
+      end
 
       def initialize(attribs, client_options = {})
         hostname, port, socket_type, @weight, user_creds = ServerConfigParser.parse(attribs)
@@ -78,6 +94,19 @@ module Dalli
       # particular memcached instance is available for use.
       def alive?
         ensure_connected!
+      rescue Dalli::RetryableNetworkError => e
+        # A single connection attempt failure is retryable -- the same
+        # contract #request enforces on the send/receive path. Retrying here
+        # lets error_on_request!'s own fail-count threshold decide when to
+        # give up: it keeps raising RetryableNetworkError until
+        # socket_max_failures is reached, then raises a terminal
+        # NetworkError via down!, which the next rescue converts to false.
+        # Without this, a single transient hiccup during the liveness check
+        # itself -- as opposed to an actual request -- would report this
+        # server as not alive even though it would have reconnected fine.
+        Dalli.logger.debug { e.inspect }
+        Dalli.logger.debug { "retrying connection attempt to #{name} because of network error" }
+        retry
       rescue Dalli::NetworkError
         # ensure_connected! raises a NetworkError if connection fails.  We
         # want to capture that error and convert it to a boolean value here.
@@ -237,30 +266,63 @@ module Dalli
         opts[:cache_nils] ? true : false
       end
 
+      # Extracts opaque routing-token kwargs (:p_token, :l_token) from a
+      # request-options Hash so they can be splatted into a RequestFormatter
+      # call. Returns {} when neither is set, so the splat is a no-op on the
+      # common path. Validation (type, forbidden bytes) happens at the
+      # wire-formatter level, where it can raise uniformly regardless of how
+      # the token reached the formatter.
+      def routing_token_kwargs(opts)
+        return {} unless routing_tokens?(opts)
+
+        { p_token: opts[:p_token], l_token: opts[:l_token] }
+      end
+
+      def routing_tokens?(opts)
+        opts.is_a?(Hash) && (opts[:p_token] || opts[:l_token]) ? true : false
+      end
+
+      # Maps the client-facing meta-delete options onto RequestFormatter's flag
+      # names, so they can be splatted into a meta_delete call.  Returns {} when
+      # none are set, keeping the splat a no-op on the common path.
+      #
+      # :tombstone_ttl becomes the T flag, which is the same TTL the formatter
+      # already accepted -- deliberately not a second TTL parameter, since two
+      # would allow emitting two T tokens in one request.  It is sanitized like
+      # every other TTL Dalli sends.
+      def tombstone_kwargs(opts)
+        return {} unless opts.is_a?(Hash)
+
+        kwargs = {}
+        kwargs[:stale] = true if opts[:invalidate]
+        kwargs[:ttl] = TtlSanitizer.sanitize(Integer(opts[:tombstone_ttl])) if opts[:tombstone_ttl]
+        kwargs[:drop_value] = true if opts[:drop_value]
+        kwargs
+      end
+
       def connect
         @connection_manager.establish_connection
         @version = version
         up!
       end
 
-      def pipelined_get(keys)
+      # return_cas = false leaves the c flag off each request, for callers
+      # (plain get_multi) that discard the CAS value. It is positional because
+      # #request forwards only positional arguments.
+      def pipelined_get(keys, options = nil, return_cas = true) # rubocop:disable Style/OptionalBooleanParameter
         # 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)
-        end
-        # Could send noop here instead of in pipeline_response_setup
-        write(req)
+        # The terminating noop is sent by pipeline_response_setup
+        write(quiet_get_requests(keys, options, return_cas: return_cas))
       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)
+      def pipelined_get_interleaved(keys, chunk_size, results, options = nil)
         # Initialize the response buffer for draining during send phase
         response_buffer.ensure_ready
 
@@ -268,7 +330,7 @@ module Dalli
           # Build and write this chunk of requests
           req = +''
           chunk.each do |key|
-            req << quiet_get_request(key)
+            req << quiet_get_request(key, options)
           end
           write(req)
           @connection_manager.flush

data/lib/dalli/protocol/key_regularizer.rb

@@ -12,8 +12,32 @@ module Dalli
       module KeyRegularizer
         module_function
 
+        # protocol.txt requires that a key "must not include control
+        # characters or whitespace" -- \p{Cntrl} is C0 (0x00-0x1F) plus DEL
+        # (0x7F). \s alone misses NUL and the rest of that range: a key
+        # containing one of those bytes but no whitespace is ASCII-only, so
+        # it would otherwise be written to the wire unencoded. Not a
+        # protocol-injection risk (the text protocol splits on CRLF, not
+        # other control bytes), but a downstream consumer that treats the key
+        # specially at one of those bytes (a C string terminating at NUL, a
+        # terminal or log line interpreting an escape byte) could silently
+        # act on a different key than Dalli believes it sent.
+        #
+        # Written as \p{Cntrl} rather than the POSIX [:cntrl:] bracket class:
+        # \s and [:cntrl:] overlap (tab, newline, CR are in both), and Ruby
+        # warns "character class has duplicated range" when they're combined
+        # in one -- fatal here, since this suite's -w run treats warnings as
+        # errors (see test_strict_warnings.rb). \p{Cntrl} matches the same
+        # bytes without the overlap warning.
+        #
+        # The ascii_only? check runs first, so the regexp only ever sees ASCII
+        # keys. Over ASCII, [\p{Cntrl}\s] is exactly 0x00-0x20 plus 0x7F, and
+        # the plain byte class below is about 5x faster to match.
+        ASCII_CNTRL_OR_SPACE = /[\x00-\x20\x7F]/
+        private_constant :ASCII_CNTRL_OR_SPACE
+
         def required?(key)
-          !key.ascii_only? || /\s/.match?(key)
+          !key.ascii_only? || ASCII_CNTRL_OR_SPACE.match?(key)
         end
 
         def encode(key)

data/lib/dalli/protocol/meta.rb

@@ -24,22 +24,40 @@ module Dalli
 
       # Retrieval Commands
       def get(key, options = nil)
+        # Fast path for the common case of no per-request options (nil or false)
+        unless options
+          flushed_write(RequestFormatter.plain_meta_get(key, raw_mode?))
+          return response_processor.meta_get_with_value
+        end
+
         # Skip bitflags in raw mode - saves 2 bytes per request and skips parsing
-        skip_flags = raw_mode? || (options && options[:raw])
-        req = RequestFormatter.meta_get(key: key, skip_flags: skip_flags)
+        skip_flags = raw_mode? || options[:raw]
+        req = if routing_tokens?(options)
+                RequestFormatter.meta_get(key: key, skip_flags: skip_flags, **routing_token_kwargs(options))
+              else
+                RequestFormatter.plain_meta_get(key, skip_flags)
+              end
         flushed_write(req)
         response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
-      def quiet_get_request(key)
+      def quiet_get_request(key, options = nil)
         # Skip bitflags in raw mode - saves 2 bytes per request and skips parsing
-        RequestFormatter.meta_get(key: key, return_cas: true, quiet: true, skip_flags: raw_mode?)
+        RequestFormatter.meta_get(key: key, return_cas: true, quiet: true, skip_flags: raw_mode?,
+                                  **routing_token_kwargs(options))
+      end
+
+      # Same requests as quiet_get_request for each key, built in one pass
+      # and without the trailing noop.
+      def quiet_get_requests(keys, options = nil, return_cas: true)
+        RequestFormatter.multi_meta_get(keys, skip_flags: raw_mode?, return_cas: return_cas, terminate: false,
+                                              **routing_token_kwargs(options))
       end
 
       def gat(key, ttl, options = nil)
         ttl = TtlSanitizer.sanitize(ttl)
         skip_flags = raw_mode? || (options && options[:raw])
-        req = RequestFormatter.meta_get(key: key, ttl: ttl, skip_flags: skip_flags)
+        req = RequestFormatter.meta_get(key: key, ttl: ttl, skip_flags: skip_flags, **routing_token_kwargs(options))
         flushed_write(req)
         response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
@@ -53,8 +71,8 @@ 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)
-        req = RequestFormatter.meta_get(key: key, value: true, return_cas: true)
+      def cas(key, options = nil)
+        req = RequestFormatter.meta_get(key: key, value: true, return_cas: true, **routing_token_kwargs(options))
         flushed_write(req)
         response_processor.meta_get_with_value_and_cas
       end
@@ -88,12 +106,16 @@ module Dalli
           key: key, value: true, return_cas: true,
           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]
+          return_last_access: options[:return_last_access],
+          return_ttl_remaining: options[:return_ttl_remaining],
+          skip_lru_bump: options[:skip_lru_bump],
+          **routing_token_kwargs(options)
         )
         flushed_write(req)
         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]
+          return_last_access: options[:return_last_access],
+          return_ttl_remaining: options[:return_ttl_remaining]
         )
       end
 
@@ -137,35 +159,40 @@ module Dalli
         ttl = TtlSanitizer.sanitize(ttl) if ttl
         req = RequestFormatter.meta_set(key: key, value: value,
                                         bitflags: bitflags, cas: cas,
-                                        ttl: ttl, mode: mode, quiet: quiet)
+                                        ttl: ttl, mode: mode, quiet: quiet,
+                                        **routing_token_kwargs(options))
         write("#{req}#{value}#{TERMINATOR}")
         @connection_manager.flush unless quiet
       end
       # rubocop:enable Metrics/ParameterLists
 
-      def append(key, value)
-        write_append_prepend_req(:append, key, value)
+      def append(key, value, options = nil)
+        write_append_prepend_req(:append, key, value, nil, nil, options)
         response_processor.meta_set_append_prepend unless quiet?
       end
 
-      def prepend(key, value)
-        write_append_prepend_req(:prepend, key, value)
+      def prepend(key, value, options = nil)
+        write_append_prepend_req(:prepend, key, value, nil, nil, options)
         response_processor.meta_set_append_prepend unless quiet?
       end
 
-      # rubocop:disable Metrics/ParameterLists
-      def write_append_prepend_req(mode, key, value, ttl = nil, cas = nil, _options = {})
+      # rubocop:disable-next Metrics/ParameterLists
+      def write_append_prepend_req(mode, key, value, ttl = nil, cas = nil, options = nil)
         ttl = TtlSanitizer.sanitize(ttl) if ttl
         req = RequestFormatter.meta_set(key: key, value: value,
-                                        cas: cas, ttl: ttl, mode: mode, quiet: quiet?)
+                                        cas: cas, ttl: ttl, mode: mode, quiet: quiet?,
+                                        **routing_token_kwargs(options))
         write("#{req}#{value}#{TERMINATOR}")
         @connection_manager.flush unless quiet?
       end
-      # rubocop:enable Metrics/ParameterLists
 
       # Delete Commands
-      def delete(key, cas)
-        req = RequestFormatter.meta_delete(key: key, cas: cas, quiet: quiet?)
+      #
+      # `options` supports the meta-delete keys :invalidate, :tombstone_ttl and
+      # :drop_value, plus :p_token/:l_token; see Dalli::Client#delete.
+      def delete(key, cas, options = nil)
+        req = RequestFormatter.meta_delete(key: key, cas: cas, quiet: quiet?,
+                                           **tombstone_kwargs(options), **routing_token_kwargs(options))
         write(req)
         @connection_manager.flush unless quiet?
         response_processor.meta_delete unless quiet?
@@ -173,8 +200,9 @@ module Dalli
 
       # Pipelined delete - writes a quiet delete request without reading response.
       # Used by PipelinedDeleter for bulk operations.
-      def pipelined_delete(key)
-        req = RequestFormatter.meta_delete(key: key, quiet: true)
+      def pipelined_delete(key, req_options = nil)
+        req = RequestFormatter.meta_delete(key: key, quiet: true,
+                                           **tombstone_kwargs(req_options), **routing_token_kwargs(req_options))
         write(req)
       end
 
@@ -184,18 +212,19 @@ module Dalli
       end
 
       # Arithmetic Commands
-      def decr(key, count, ttl, initial)
-        decr_incr false, key, count, ttl, initial
+      def decr(key, count, ttl, initial, options = nil)
+        decr_incr false, key, count, ttl, initial, options
       end
 
-      def incr(key, count, ttl, initial)
-        decr_incr true, key, count, ttl, initial
+      def incr(key, count, ttl, initial, options = nil)
+        decr_incr true, key, count, ttl, initial, options
       end
 
-      def decr_incr(incr, key, delta, ttl, initial)
+      # rubocop:disable-next Metrics/ParameterLists
+      def decr_incr(incr, key, delta, ttl, initial, options = nil)
         ttl = initial ? TtlSanitizer.sanitize(ttl) : nil # Only set a TTL if we want to set a value on miss
         write(RequestFormatter.meta_arithmetic(key: key, delta: delta, initial: initial, incr: incr, ttl: ttl,
-                                               quiet: quiet?))
+                                               quiet: quiet?, **routing_token_kwargs(options)))
         @connection_manager.flush unless quiet?
         response_processor.decr_incr unless quiet?
       end
@@ -236,14 +265,52 @@ module Dalli
       # Single-server fast path for get_multi. Inlines request formatting and
       # response parsing to minimize per-key overhead. Avoids the PipelinedGetter
       # machinery (IO.select, response buffering, server grouping).
-      def read_multi_req(keys)
+      def read_multi_req(keys, options = nil)
         is_raw = raw_mode?
-        buffer = RequestFormatter.multi_meta_get(keys, skip_flags: is_raw)
+        buffer = RequestFormatter.multi_meta_get(keys, skip_flags: is_raw, **routing_token_kwargs(options))
         flushed_write(buffer)
         buffer.clear
         read_multi_get_responses(is_raw)
       end
 
+      # Stale-aware bulk get.  Returns { key => { value:, cas:, stale:, miss: } }
+      # for the keys the server returned.  Keys that were not found are absent
+      # from the hash, matching read_multi_req and the get_multi family; a
+      # tombstoned item is present (it answers VA with the X flag) with
+      # stale: true, which is the distinction callers need.
+      #
+      # Shared by both the single-server fast path and PipelinedGetter's
+      # per-server-group request, so this one change covers both routes.
+      def read_multi_with_metadata_req(keys, options = nil)
+        is_raw = raw_mode?
+        buffer = RequestFormatter.multi_meta_get(keys, skip_flags: is_raw, return_cas: true,
+                                                       **routing_token_kwargs(options))
+        flushed_write(buffer)
+        buffer.clear
+        read_multi_metadata_responses(is_raw)
+      end
+
+      # Unlike read_multi_get_responses this locates tokens by flag rather than
+      # by position, because the c flag shifts the key's index.
+      def read_multi_metadata_responses(is_raw)
+        hash = {}
+        while (line = @connection_manager.read_line)
+          break if line.start_with?('MN')
+          next unless line.start_with?('VA ')
+
+          tokens = line.chomp!(TERMINATOR).split
+          value = @connection_manager.read(tokens[1].to_i + TERMINATOR.bytesize)&.chomp!(TERMINATOR)
+          stale = response_processor.stale_from_tokens(tokens)
+          cas = response_processor.cas_from_tokens(tokens)
+          bitflags = is_raw ? 0 : response_processor.bitflags_from_tokens(tokens)
+          key = response_processor.key_from_tokens(tokens)
+          next if key.nil?
+
+          hash[key] = { value: @value_marshaller.retrieve(value, bitflags), cas: cas, stale: stale, miss: false }
+        end
+        hash
+      end
+
       def read_multi_get_responses(is_raw)
         hash = {}
         key_index = is_raw ? 2 : 3
@@ -277,7 +344,7 @@ module Dalli
           [key, @value_marshaller.store(key, raw_value, req_options)]
         end
 
-        buffer = RequestFormatter.multi_meta_set(entries, ttl: ttl)
+        buffer = RequestFormatter.multi_meta_set(entries, ttl: ttl, **routing_token_kwargs(req_options))
         flushed_write(buffer)
         buffer.clear
         response_processor.consume_all_responses_until_mn
@@ -285,8 +352,9 @@ module Dalli
 
       # Single-server fast path for delete_multi. Writes all quiet delete requests
       # terminated by a noop, then consumes all responses.
-      def delete_multi_req(keys)
-        buffer = RequestFormatter.multi_meta_delete(keys)
+      def delete_multi_req(keys, req_options = nil)
+        buffer = RequestFormatter.multi_meta_delete(keys, **tombstone_kwargs(req_options),
+                                                    **routing_token_kwargs(req_options))
         flushed_write(buffer)
         buffer.clear
         keys.size - response_processor.pipelined_delete_non_deletions