dalli 4.0.1 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5494b3c5f7ce6c73cb061511ab96c7dafc0ed1f5d10a865310a7adc79c8587c9
-  data.tar.gz: 1326cd38aad6ba7c7c0c65c2b0305b4c4c566e3a0050df1f8ccee6aa42ee2bc7
+  metadata.gz: 7966ac393d9c0f41d61b244c6a5832fbcab5705ed4daa4189b6e1ffc92db600f
+  data.tar.gz: da320eac7a8d553f33fe81315750297f97edb75c6da79197ef1f974d47ac8081
 SHA512:
-  metadata.gz: 5affa5731ead45a7c352628c4c3c471b1fc5c7499e9e63e58278e2c59c309e90fd550774a8808de78ff9daaa53913503810ded029d0879f3a6408f19a4bf67f2
-  data.tar.gz: 244b909ac405e2f8757b3bfa3fdcea3fb17615f6d329527f63c3392a4921dd8298fa9d6eeaab368bd80112413c593d94f305062732fb28204072526b84eba3d4
+  metadata.gz: 5d29cfbe8d2ee6e2993e8a292238f2762ac1de29b8d8623f0a521f810edf866ffd9d631905d5b7cb939d44216fb7e8d6edabf4c09ba388162fef97a772254352
+  data.tar.gz: ef1c636e6aab12a630ddb7e4d7081c29b0e257203b97f78ccde207170802d1c3619db7057093d4140fcc9cbc23f979bf6f60be4a64011bde983062a724ea59fc

data/CHANGELOG.md

@@ -1,6 +1,51 @@
 Dalli Changelog
 =====================
 
+4.2.0
+==========
+
+Performance:
+
+- Buffered I/O: Use `socket.sync = false` with explicit flush to reduce syscalls for pipelined operations
+- get_multi optimizations: Use Set for O(1) server tracking lookups
+- Raw mode optimization: Skip bitflags request in meta protocol when in raw mode (saves 2 bytes per request)
+
+New Features:
+
+- OpenTelemetry tracing support: Automatically instruments operations when OpenTelemetry SDK is present
+  - Zero overhead when OpenTelemetry is not loaded
+  - Traces `get`, `set`, `delete`, `get_multi`, `set_multi`, `delete_multi`, `get_with_metadata`, and `fetch_with_lock`
+  - Spans include `db.system: memcached` and `db.operation` attributes
+  - Single-key operations include `server.address` attribute
+  - Multi-key operations include `db.memcached.key_count` attribute
+  - `get_multi` spans include `db.memcached.hit_count` and `db.memcached.miss_count` for cache efficiency metrics
+  - Exceptions are automatically recorded on spans with error status
+
+4.1.0
+==========
+
+New Features:
+
+- Add `set_multi` for efficient bulk set operations using pipelined requests
+- Add `delete_multi` for efficient bulk delete operations using pipelined requests
+- Add `fetch_with_lock` for thundering herd protection using meta protocol's vivify/recache flags (requires memcached 1.6+)
+- Add thundering herd protection support to meta protocol (requires memcached 1.6+):
+  - `N` (vivify) flag for creating stubs on cache miss
+  - `R` (recache) flag for winning recache race when TTL is below threshold
+  - Response flags `W` (won recache), `X` (stale), `Z` (lost race)
+  - `delete_stale` method for marking items as stale instead of deleting
+- Add `get_with_metadata` for advanced cache operations with metadata retrieval (requires memcached 1.6+):
+  - Returns hash with `:value`, `:cas`, `:won_recache`, `:stale`, `:lost_recache`
+  - Optional `:return_hit_status` returns `:hit_before` (true/false for previous access)
+  - Optional `:return_last_access` returns `:last_access` (seconds since last access)
+  - Optional `:skip_lru_bump` prevents LRU update on access
+  - Optional `:vivify_ttl` and `:recache_ttl` for thundering herd protection
+
+Deprecations:
+
+- Binary protocol is deprecated and will be removed in Dalli 5.0. Use `protocol: :meta` instead (requires memcached 1.6+)
+- SASL authentication is deprecated and will be removed in Dalli 5.0. Consider using network-level security or memcached's TLS support
+
 4.0.1
 ==========
 

data/README.md

@@ -11,6 +11,7 @@ Dalli supports:
 * Thread-safe operation (either through use of a connection pool, or by using the Dalli client in threadsafe mode)
 * SSL/TLS connections to memcached
 * SASL authentication
+* OpenTelemetry distributed tracing (automatic when SDK is present)
 
 The name is a variant of Salvador Dali for his famous painting [The Persistence of Memory](http://en.wikipedia.org/wiki/The_Persistence_of_Memory).
 
@@ -40,6 +41,46 @@ Dalli::Client.new('localhost:11211', serializer: JSON)
 
 See the [4.0-Upgrade.md](4.0-Upgrade.md) guide for more information.
 
+## OpenTelemetry Tracing
+
+Dalli automatically instruments operations with [OpenTelemetry](https://opentelemetry.io/) when the SDK is present. No configuration is required - just add the OpenTelemetry gems to your application:
+
+```ruby
+# Gemfile
+gem 'opentelemetry-sdk'
+gem 'opentelemetry-exporter-otlp' # or your preferred exporter
+```
+
+When OpenTelemetry is loaded, Dalli creates spans for:
+- Single key operations: `get`, `set`, `delete`, `add`, `replace`, `incr`, `decr`, etc.
+- Multi-key operations: `get_multi`, `set_multi`, `delete_multi`
+- Advanced operations: `get_with_metadata`, `fetch_with_lock`
+
+### Span Attributes
+
+All spans include:
+- `db.system`: `memcached`
+- `db.operation`: The operation name (e.g., `get`, `set_multi`)
+
+Single-key operations also include:
+- `server.address`: The memcached server that handled the request (e.g., `localhost:11211`)
+
+Multi-key operations include cache efficiency metrics:
+- `db.memcached.key_count`: Number of keys in the request
+- `db.memcached.hit_count`: Number of keys found (for `get_multi`)
+- `db.memcached.miss_count`: Number of keys not found (for `get_multi`)
+
+### Error Handling
+
+Exceptions are automatically recorded on spans with error status. When an operation fails:
+1. The exception is recorded on the span via `span.record_exception(e)`
+2. The span status is set to error with the exception message
+3. The exception is re-raised to the caller
+
+### Zero Overhead
+
+When OpenTelemetry is not present, there is zero overhead - the tracing code checks once at startup and bypasses all instrumentation logic entirely when the SDK is not loaded.
+
 ![Persistence of Memory](https://upload.wikimedia.org/wikipedia/en/d/dd/The_Persistence_of_Memory.jpg)
 
 

data/lib/dalli/client.rb

@@ -56,6 +56,7 @@ module Dalli
       @options = normalize_options(options)
       @key_manager = ::Dalli::KeyManager.new(@options)
       @ring = nil
+      emit_deprecation_warnings
     end
 
     #
@@ -96,24 +97,70 @@ module Dalli
       yield value, cas
     end
 
+    ##
+    # Get value with extended metadata using the meta protocol.
+    #
+    # IMPORTANT: This method requires memcached 1.6+ and the meta protocol (protocol: :meta).
+    # It will raise an error if used with the binary protocol.
+    #
+    # @param key [String] the cache key
+    # @param options [Hash] options controlling what metadata to return
+    #   - :return_cas [Boolean] return the CAS value (default: true)
+    #   - :return_hit_status [Boolean] return whether item was previously accessed
+    #   - :return_last_access [Boolean] return seconds since last access
+    #   - :skip_lru_bump [Boolean] don't bump LRU or update access stats
+    #
+    # @return [Hash] containing:
+    #   - :value - the cached value (or nil on miss)
+    #   - :cas - the CAS value
+    #   - :hit_before - true/false if previously accessed (only if return_hit_status: true)
+    #   - :last_access - seconds since last access (only if return_last_access: true)
+    #
+    # @example Get with hit status
+    #   result = client.get_with_metadata('key', return_hit_status: true)
+    #   # => { value: "data", cas: 123, hit_before: true }
+    #
+    # @example Get with all metadata without affecting LRU
+    #   result = client.get_with_metadata('key',
+    #     return_hit_status: true,
+    #     return_last_access: true,
+    #     skip_lru_bump: true
+    #   )
+    #   # => { value: "data", cas: 123, hit_before: true, last_access: 42 }
+    #
+    def get_with_metadata(key, options = {})
+      raise_unless_meta_protocol!
+
+      key = key.to_s
+      key = @key_manager.validate_key(key)
+
+      Instrumentation.trace('get_with_metadata', { 'db.operation' => 'get_with_metadata' }) do
+        server = ring.server_for_key(key)
+        server.request(:meta_get, key, options)
+      end
+    rescue NetworkError => e
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { 'retrying get_with_metadata with new server' }
+      retry
+    end
+
     ##
     # Fetch multiple keys efficiently.
     # If a block is given, yields key/value pairs one at a time.
     # Otherwise returns a hash of { 'key' => 'value', 'key2' => 'value1' }
+    # rubocop:disable Style/ExplicitBlockArgument
     def get_multi(*keys)
       keys.flatten!
       keys.compact!
-
       return {} if keys.empty?
 
       if block_given?
-        pipelined_getter.process(keys) { |k, data| yield k, data.first }
+        get_multi_yielding(keys) { |k, v| yield k, v }
       else
-        {}.tap do |hash|
-          pipelined_getter.process(keys) { |k, data| hash[k] = data.first }
-        end
+        get_multi_hash(keys)
       end
     end
+    # rubocop:enable Style/ExplicitBlockArgument
 
     ##
     # Fetch multiple keys efficiently, including available metadata such as CAS.
@@ -149,6 +196,56 @@ module Dalli
       new_val
     end
 
+    ##
+    # Fetch the value with thundering herd protection using the meta protocol's
+    # N (vivify) and R (recache) flags.
+    #
+    # This method prevents multiple clients from simultaneously regenerating the same
+    # cache entry (the "thundering herd" problem). Only one client wins the right to
+    # regenerate; other clients receive the stale value (if available) or wait.
+    #
+    # IMPORTANT: This method requires memcached 1.6+ and the meta protocol (protocol: :meta).
+    # It will raise an error if used with the binary protocol.
+    #
+    # @param key [String] the cache key
+    # @param ttl [Integer] time-to-live for the cached value in seconds
+    # @param lock_ttl [Integer] how long the lock/stub lives (default: 30 seconds)
+    #   This is the maximum time other clients will return stale data while
+    #   waiting for regeneration. Should be longer than your expected regeneration time.
+    # @param recache_threshold [Integer, nil] if set, win the recache race when the
+    #   item's remaining TTL is below this threshold. Useful for proactive recaching.
+    # @param req_options [Hash] options passed to set operations (e.g., raw: true)
+    #
+    # @yield Block to regenerate the value (only called if this client won the race)
+    # @return [Object] the cached value (may be stale if another client is regenerating)
+    #
+    # @example Basic usage
+    #   client.fetch_with_lock('expensive_key', ttl: 300, lock_ttl: 30) do
+    #     expensive_database_query
+    #   end
+    #
+    # @example With proactive recaching (recache before expiry)
+    #   client.fetch_with_lock('key', ttl: 300, lock_ttl: 30, recache_threshold: 60) do
+    #     expensive_operation
+    #   end
+    #
+    def fetch_with_lock(key, ttl: nil, lock_ttl: 30, recache_threshold: nil, req_options: nil, &block)
+      raise ArgumentError, 'Block is required for fetch_with_lock' unless block_given?
+
+      raise_unless_meta_protocol!
+
+      key = key.to_s
+      key = @key_manager.validate_key(key)
+
+      Instrumentation.trace('fetch_with_lock', { 'db.operation' => 'fetch_with_lock' }) do
+        fetch_with_lock_request(key, ttl, lock_ttl, recache_threshold, req_options, &block)
+      end
+    rescue NetworkError => e
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { 'retrying fetch_with_lock with new server' }
+      retry
+    end
+
     ##
     # compare and swap values using optimistic locking.
     # Fetch the existing value for key.
@@ -206,6 +303,29 @@ module Dalli
       set_cas(key, value, 0, ttl, req_options)
     end
 
+    ##
+    # Set multiple keys and values efficiently using pipelining.
+    # This method is more efficient than calling set() in a loop because
+    # it batches requests by server and uses quiet mode.
+    #
+    # @param hash [Hash] key-value pairs to set
+    # @param ttl [Integer] time-to-live in seconds (optional, uses default if not provided)
+    # @param req_options [Hash] options passed to each set operation
+    # @return [void]
+    #
+    # Example:
+    #   client.set_multi({ 'key1' => 'value1', 'key2' => 'value2' }, 300)
+    def set_multi(hash, ttl = nil, req_options = nil)
+      return if hash.empty?
+
+      Instrumentation.trace('set_multi', {
+                              'db.operation' => 'set_multi',
+                              'db.memcached.key_count' => hash.size
+                            }) do
+        pipelined_setter.process(hash, ttl_or_default(ttl), req_options)
+      end
+    end
+
     ##
     # Set the key-value pair, verifying existing CAS.
     # Returns the resulting CAS value if succeeded, and falsy otherwise.
@@ -245,6 +365,27 @@ module Dalli
       delete_cas(key, 0)
     end
 
+    ##
+    # Delete multiple keys efficiently using pipelining.
+    # This method is more efficient than calling delete() in a loop because
+    # it batches requests by server and uses quiet mode.
+    #
+    # @param keys [Array<String>] keys to delete
+    # @return [void]
+    #
+    # Example:
+    #   client.delete_multi(['key1', 'key2', 'key3'])
+    def delete_multi(keys)
+      return if keys.empty?
+
+      Instrumentation.trace('delete_multi', {
+                              'db.operation' => 'delete_multi',
+                              'db.memcached.key_count' => keys.size
+                            }) do
+        pipelined_deleter.process(keys)
+      end
+    end
+
     ##
     # Append value to the value already stored on the server for 'key'.
     # Appending only works for values stored with :raw => true.
@@ -374,6 +515,42 @@ module Dalli
 
     private
 
+    # Records hit/miss metrics on a span for cache observability.
+    # @param span [OpenTelemetry::Trace::Span, nil] the span to record on
+    # @param key_count [Integer] total keys requested
+    # @param hit_count [Integer] keys found in cache
+    def record_hit_miss_metrics(span, key_count, hit_count)
+      return unless span
+
+      span.set_attribute('db.memcached.hit_count', hit_count)
+      span.set_attribute('db.memcached.miss_count', key_count - hit_count)
+    end
+
+    def get_multi_yielding(keys)
+      Instrumentation.trace_with_result('get_multi', get_multi_attributes(keys)) do |span|
+        hit_count = 0
+        pipelined_getter.process(keys) do |k, data|
+          hit_count += 1
+          yield k, data.first
+        end
+        record_hit_miss_metrics(span, keys.size, hit_count)
+        nil
+      end
+    end
+
+    def get_multi_hash(keys)
+      Instrumentation.trace_with_result('get_multi', get_multi_attributes(keys)) do |span|
+        {}.tap do |hash|
+          pipelined_getter.process(keys) { |k, data| hash[k] = data.first }
+          record_hit_miss_metrics(span, keys.size, hash.size)
+        end
+      end
+    end
+
+    def get_multi_attributes(keys)
+      { 'db.operation' => 'get_multi', 'db.memcached.key_count' => keys.size }
+    end
+
     def check_positive!(amt)
       raise ArgumentError, "Positive values only: #{amt}" if amt.negative?
     end
@@ -386,6 +563,17 @@ module Dalli
       perform(:set, key, newvalue, ttl_or_default(ttl), cas, req_options)
     end
 
+    def fetch_with_lock_request(key, ttl, lock_ttl, recache_threshold, req_options)
+      server = ring.server_for_key(key)
+      result = server.request(:meta_get, key, { vivify_ttl: lock_ttl, recache_ttl: recache_threshold })
+
+      return result[:value] unless result[:won_recache]
+
+      new_val = yield
+      set(key, new_val, ttl_or_default(ttl), req_options)
+      new_val
+    end
+
     ##
     # Uses the argument TTL or the client-wide default.  Ensures
     # that the value is an integer
@@ -428,7 +616,12 @@ module Dalli
       key = @key_manager.validate_key(key)
 
       server = ring.server_for_key(key)
-      server.request(op, key, *args)
+      Instrumentation.trace(op.to_s, {
+                              'db.operation' => op.to_s,
+                              'server.address' => server.name
+                            }) do
+        server.request(op, key, *args)
+      end
     rescue NetworkError => e
       Dalli.logger.debug { e.inspect }
       Dalli.logger.debug { 'retrying request with new server' }
@@ -445,5 +638,23 @@ module Dalli
     def pipelined_getter
       PipelinedGetter.new(ring, @key_manager)
     end
+
+    def pipelined_setter
+      PipelinedSetter.new(ring, @key_manager)
+    end
+
+    def pipelined_deleter
+      PipelinedDeleter.new(ring, @key_manager)
+    end
+
+    def raise_unless_meta_protocol!
+      return if protocol_implementation == Dalli::Protocol::Meta
+
+      raise Dalli::DalliError,
+            'This operation requires the meta protocol (memcached 1.6+). ' \
+            'Use protocol: :meta when creating the client.'
+    end
+
+    include ProtocolDeprecations
   end
 end

data/lib/dalli/instrumentation.rb

@@ -0,0 +1,139 @@
+# 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.
+  #
+  # == Span Attributes
+  #
+  # All spans include the following default attributes:
+  # - +db.system+ - Always "memcached"
+  #
+  # Single-key operations (+get+, +set+, +delete+, +incr+, +decr+, etc.) add:
+  # - +db.operation+ - The operation name (e.g., "get", "set")
+  # - +server.address+ - The memcached server handling the request (e.g., "localhost:11211")
+  #
+  # Multi-key operations (+get_multi+) add:
+  # - +db.operation+ - "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+ - The operation name
+  # - +db.memcached.key_count+ - Number of keys in the operation
+  #
+  # == 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' => 'memcached'
+    DEFAULT_ATTRIBUTES = { 'db.system' => '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' - the operation name
+      #   - 'server.address' - the target server
+      #   - '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' => 'set', 'server.address' => 'localhost: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
+        rescue StandardError => e
+          span.record_exception(e)
+          span.status = OpenTelemetry::Trace::Status.error(e.message)
+          raise
+        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' => '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) do |span|
+          yield(span)
+        rescue StandardError => e
+          span.record_exception(e)
+          span.status = OpenTelemetry::Trace::Status.error(e.message)
+          raise
+        end
+      end
+    end
+  end
+end

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,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module Dalli
   ##
   # Contains logic for the pipelined gets implemented by the client.
@@ -57,7 +59,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 +69,7 @@ module Dalli
         rescue Dalli::NetworkError
           raise
         rescue Dalli::DalliError
-          deleted.append(server)
+          deleted << server
         end
       end
 
@@ -94,7 +96,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)