dalli 5.0.5 → 5.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c110d569b03993cefe140fdc4b54fb5720ef407e15c0fe100e4a49f90b5ce36
-  data.tar.gz: 8a3967c3d9d82dd3a28172fdb06e7f235a8ebb6598fd742e04770b458d24d041
+  metadata.gz: 54f211dbcca14abc18e7e9ffc7e9fe5c992c1e95afab2b6a64e46b6ec32efa8a
+  data.tar.gz: f655e7c63cc622876ae47400afd59139eea3b8e19f6585af223fafccad94e659
 SHA512:
-  metadata.gz: 486715371411ddcf9118f87296abaaf7a30597a340bba41f26d26a750268d85751fef62be52f332662d427fa79e0ed3ea9bf0e503747203f5039194875a878de
-  data.tar.gz: d1bdf88817ba281d7b88525b1e0579c6efefdd68cb1b437dbbc0cf4fa2f386a6d9612e579cbfc409b1c1458a05ee5b4c7af841599e1930433912a909550b84f1
+  metadata.gz: de1470d516e61e2b970c0cfaa0de3afe572124081b300ce643405813c3ba232be08da32fbc3748fbc86b39e2aaea0d6e5803d34cd9722f50c3fc47b325970c67
+  data.tar.gz: 1835dc76b3cfebe33a4a8eca38d37dcfa8af84495e0d5af523402ddd4ffa1e3a2a8c808ce4c6e2605325f8d6eded6faa4a574022680528016f091e330e987a3e

data/CHANGELOG.md

@@ -4,6 +4,121 @@ Dalli Changelog
 Unreleased
 ==========
 
+5.0.6
+==========
+
+Performance:
+
+- Skip the cas-return flag on quiet `meta_set` requests (#1131)
+  - In quiet mode memcached suppresses the `ms` response entirely, so the CAS requested by the `c` flag can never be read; sending it only added two bytes to every request
+  - Applies to the bulk-write paths, where quiet sets are emitted: `Dalli::Client#multi` blocks and the pipelined setter
+  - Extracted from #1130; thanks to Jianbin Chen for this contribution
+
+- Reduce allocations in `KeyRegularizer` and multi-key request paths (#1120)
+  - Decomposed `KeyRegularizer#encode` into separate `needs_encoding?` and `encode` calls so the common happy path avoids allocating an intermediate array for the two-element return value
+  - Refactored `multi_get`/`multi_set`/`multi_delete` command generation into `RequestFormatter` to share its key-encoding helpers
+  - Thanks to Jean Boussier for this contribution
+
+- Reduce allocations in `ResponseBuffer` pipelined getk parsing (#1117)
+  - `process_single_getk_response` was building a fresh array to return results alongside the updated offset; refactored to store the offset as the last element of the existing tokens array and pop it, saving one allocation per response
+  - Also skips trailing nils in the token array
+  - Thanks to Jean Boussier for this contribution
+
+- Enable frozen string literals in `RequestFormatter` (#1118)
+  - Frozen string literals had been inadvertently disabled; re-enabling reduces allocations by ~300,000 objects in a 10,000-iteration `get_multi_cas` benchmark (562 MB → 550 MB total allocated)
+  - Thanks to Jean Boussier for this contribution
+
+- Reduce allocations in `ResponseProcessor#value_from_tokens` (#1113)
+  - `token[1..].to_i` was allocating a new string for every token parsed; replaced with in-place `slice!` followed by a token reset to avoid poisoning subsequent token comparisons
+  - Saves 4 allocations per entry in `get_multi_cas` workloads (a hotspot for IdentityCache)
+  - Thanks to Jean Boussier for this contribution
+
+- Reduce allocations in common operation paths (#1111)
+  - Use `Symbol#name` over `Symbol#to_s` to return a frozen string without allocation
+  - Skip trace attribute hash construction when OpenTelemetry instrumentation is disabled
+  - Use argument forwarding (`...`) in `Client#perform` and `Threadsafe#request` to avoid splat array allocation
+  - Use `match?` in `KeyRegularizer#encode` to avoid `MatchData` object allocation
+  - Reduces objects allocated by ~26% and memory by ~6% for a simple `get` workload
+  - Thanks to Jean Boussier for this contribution
+
+- Fix pathological memory behavior in `ResponseBuffer` (#1114)
+  - `compact_if_needed` was intended to reclaim memory by slicing off consumed bytes, but `buffer.byteslice(@offset..)` on an unfrozen string causes Ruby to allocate a hidden third string as the copy-on-write owner rather than freeing the original
+  - Redesigns buffer management to pass reusable buffer objects directly to `read`/`read_nonblock`, avoiding reallocation on each response read
+  - Reduces allocations from ~2.38 GB to ~649 MB in a `get_multi_cas` benchmark over 10,000 iterations
+  - Accompanied by new unit tests for `ResponseBuffer` (#1115)
+  - Thanks to Jean Boussier for this contribution
+
+Features:
+
+- `delete_multi` now returns the number of keys found and deleted (#1126)
+  - Previously the return value was unspecified; callers (e.g. Rails, see rails/rails#58071) had no way to tell how many keys were actually removed
+  - The count is derived from the meta protocol's quiet-mode delete responses with no extra round-trips: successful deletes are suppressed while misses report `NF`, so any response received before the terminator is a key that was not deleted
+  - The single-server fast path now shares the pipelined path's bounded retry on transient (`RetryableNetworkError`) network errors, so both paths behave consistently; the returned count is best-effort and may under-report if a network error triggers a retry, since keys deleted before the error are not recounted
+  - Thanks to Iliana Hadzhiatanasova for this contribution
+
+Bug Fixes:
+
+- Raise instead of returning a truncated value when the peer closes mid-response (#1135)
+  - `IO#read(count)` on a blocking socket accumulates across TCP chunks and hands back a shorter buffer (or `nil`) in only one case: the stream hit EOF. That short buffer was passed through as the response body, so a memcached restart, proxy drop, or load balancer timeout partway through a response could surface a truncated but still decodable value to the caller, indistinguishable from a real one
+  - A short read is now treated as the premature EOF it is, raising and closing the dirty socket so the request is retried on a fresh connection
+  - CRuby only; the JRuby path already used `Socket#readfull`, which enforces the same contract
+  - Extracted from #1130; thanks to Ian Ker-Seymer for the original fix and Jianbin Chen for the port
+
+- Tear down the connection when a non-`StandardError` aborts a request (#1136)
+  - `Async::Stop` and `Thread#kill` descend from `Exception` rather than `StandardError`, so the rescue clauses in `Protocol::Base#request` never saw them; a scheduler cancelling a fiber parked on a response read skipped `close` entirely, leaving the connection marked as having a request in progress with partial response bytes still unread on the wire, and returning that half-used client to the pool under `connection_pool`
+  - `Protocol::Base#request` now closes in an `ensure` unless the request ran to completion, and `ConnectionManager#close` performs its state cleanup in an `ensure` so a second cancellation landing inside `@sock.close` cannot leave the socket non-nil with the request still marked in progress
+  - `Dalli::DalliError` and `Dalli::MarshalError` now close the connection at the point of failure rather than at the start of the next request; those paths already left the request in progress and `ConnectionManager#confirm_ready!` closed on the next call, so this changes when the close happens rather than adding one
+  - Extracted from #1130; thanks to Dan Mayer for the original fix and Jianbin Chen for the port
+
+- Fix `ResponseBuffer` compaction logic (#1119)
+  - `COMPACT_THRESHOLD` was removed in #1116 as apparently unused, but the constant was referenced by the compaction guard; its absence silently disabled buffer compaction
+  - Restored the constant, corrected the compaction condition, and improved the buffer-shrinking implementation to use `String#bytesplice` (backed by `memmove`) for true in-place compaction
+  - Adds targeted tests covering the compaction threshold and shrink behavior
+  - Thanks to Jean Boussier for this contribution
+
+Maintenance:
+
+- Scope `StrictWarnings` to Dalli's own source (#1134)
+  - The test suite runs under `-w` and prepends a hook to `Warning.singleton_class` that turns warnings into failures, but that hook is global: a warning emitted while loading any third-party gem aborted the whole suite before a single test ran
+  - `json` 2.21.2's pure-Ruby generator (used on JRuby, where the C extension is unavailable) warns `method redefined; discarding old to_hash` at require time, which took the `jruby-10` CI job red with no change to Dalli
+  - Warnings are now attributed to a source file and only raise for `lib/` and `test/`; attribution prefers the location Ruby embeds in the message, since the stack at that point describes the require chain rather than the offending code
+  - Portable attribution of `Kernel#warn` callers also required walking the stack rather than indexing it (Ruby 3.3/3.4 push an `<internal:warning>` frame that 4.0 does not), skipping RubyGems' `Kernel#warn` shim (active on JRuby but not CRuby), and resolving relative backtrace paths
+
+- Make raw and namespace fast path tests actually use those options (#1129)
+  - Followup to #1127: the `raw` and `namespace` variants passed those options to the helper that starts memcached, which configures the client the tests then discarded, so neither option was ever exercised
+  - Passes the options to the client under test and adds assertions that fail if they are absent
+  - Thanks to Iliana Hadzhiatanasova for this contribution
+
+- Benchmark `set_multi` and add a `delete_multi` target (#1132)
+  - Enables the two `set_multi` reports that were commented out pending the arrival of `set_multi`, resolving the accompanying TODO
+  - Adds a `delete_multi` target comparing the pipelined path against N single deletes
+  - Extracted from #1130; thanks to Jianbin Chen for this contribution
+
+- Bump CI memcached to 1.6.41 and run benchmarks on pull requests (#1133)
+  - The tests workflow moves from 1.6.40 to 1.6.41; the benchmarks and profile workflows had drifted back on 1.6.23
+  - Extracted from #1130; thanks to Jianbin Chen for this contribution
+
+- Disable RuboCop metrics cops (#1128)
+  - Thanks to Jean Boussier for this contribution
+
+- Remove `PIDCache` module (#1125)
+  - `Process.pid` is cached natively by Ruby 3.3+ (via https://bugs.ruby-lang.org/issues/19443), making the manual cache unnecessary now that Dalli requires Ruby 3.3+
+  - Thanks to Jean Boussier for this contribution
+
+- Remove unused `COMPACT_THRESHOLD` constant from `ResponseBuffer` (#1116)
+  - Followup cleanup after the buffer management redesign in #1114
+  - Note: subsequently found to be in use; restored and corrected in #1119
+  - Thanks to Jean Boussier for this contribution
+
+- Use `String#byteindex` instead of `String#index` when searching for the response terminator in `getk_response_from_buffer` (#1112)
+  - The result feeds directly into `byteslice`; `byteindex` makes the intent explicit, though both return the same value since the buffer encoding is always `BINARY`
+  - Thanks to Jean Boussier for this contribution
+
+- Make single-server fast path tests actually exercise the fast path (#1127)
+  - The batch-operation tests built clients through a helper that registers two address aliases for the same memcached process, so every client had a 2-server ring and the tests always ran through the pipelined path instead of the single-server fast path
+  - Adds a `single_server_client` test helper that builds a client with a single address, and uses it in the affected `get_multi`, `set_multi`, and `delete_multi` tests
+  - Thanks to Iliana Hadzhiatanasova for this contribution
+
 5.0.5
 ==========
 

data/lib/dalli/client.rb

@@ -364,12 +364,15 @@ module Dalli
     # it batches requests by server and uses quiet mode.
     #
     # @param keys [Array<String>] keys to delete
-    # @return [void]
+    # @return [Integer] the number of keys that were found and deleted. This is
+    #   best-effort: on a network error the operation is retried, and keys
+    #   deleted before the error are not recounted, so the result may
+    #   under-report the number actually removed when a failure occurs.
     #
     # Example:
     #   client.delete_multi(['key1', 'key2', 'key3'])
     def delete_multi(keys)
-      return if keys.empty?
+      return 0 if keys.empty?
 
       Instrumentation.trace('delete_multi', multi_trace_attrs('delete_multi', keys.size, keys)) do
         if ring.servers.size == 1
@@ -569,11 +572,18 @@ module Dalli
 
     def single_server_delete_multi(keys)
       validated_keys = keys.map { |k| @key_manager.validate_key(k.to_s) }
-      return unless (server = single_server)
+      return 0 unless (server = single_server)
 
       server.request(:delete_multi_req, validated_keys)
+    rescue Dalli::RetryableNetworkError => e
+      # Mirror the pipelined path: retry transient errors so a momentary blip
+      # still yields a real count. Bounded by the server's socket_max_failures,
+      # after which a hard NetworkError is raised and handled below.
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { 'retrying single-server delete_multi because of network error' }
+      retry
     rescue Dalli::NetworkError
-      nil
+      0
     end
 
     def get_multi_attributes(keys)
@@ -651,7 +661,7 @@ module Dalli
     # operation times out.
     ##
     # rubocop:disable Naming/MethodParameterName
-    def perform(op, key, *args)
+    def perform(op, key, ...)
       # rubocop:enable Naming/MethodParameterName
       return yield if block_given?
 
@@ -659,8 +669,14 @@ module Dalli
       key = @key_manager.validate_key(key)
 
       server = ring.server_for_key(key)
-      Instrumentation.trace(op.to_s, trace_attrs(op.to_s, key, server)) do
-        server.request(op, key, *args)
+
+      if Instrumentation.enabled?
+        op_name = op.name
+        Instrumentation.trace(op_name, trace_attrs(op_name, key, server)) do
+          server.request(op, key, ...)
+        end
+      else
+        server.request(op, key, ...)
       end
     rescue RetryableNetworkError => e
       Dalli.logger.debug { e.inspect }

data/lib/dalli/options.rb

@@ -13,7 +13,7 @@ module Dalli
       obj.init_threadsafe
     end
 
-    def request(opcode, *args)
+    def request(...)
       @lock.synchronize do
         super
       end

data/lib/dalli/pipelined_deleter.rb

@@ -16,16 +16,19 @@ module Dalli
     # Deletes multiple keys from memcached.
     #
     # @param keys [Array<String>] keys to delete
-    # @return [void]
+    # @return [Integer] the number of keys that were deleted. This is
+    #   best-effort: on a network error the operation is retried, and keys
+    #   deleted before the error are not recounted, so the result may
+    #   under-report the number actually removed when a failure occurs.
     ##
     def process(keys)
-      return if keys.empty?
+      return 0 if keys.empty?
 
       @ring.lock do
-        servers = setup_requests(keys)
-        finish_requests(servers)
+        groups = setup_requests(keys)
+        finish_requests(groups)
       end
-    rescue NetworkError => e
+    rescue Dalli::RetryableNetworkError => e
       Dalli.logger.debug { e.inspect }
       Dalli.logger.debug { 'retrying pipelined deletes because of network error' }
       retry
@@ -36,7 +39,7 @@ module Dalli
     def setup_requests(keys)
       groups = groups_for_keys(keys)
       make_delete_requests(groups)
-      groups.keys
+      groups
     end
 
     ##
@@ -45,24 +48,28 @@ module Dalli
     ##
     def make_delete_requests(groups)
       groups.each do |server, keys_for_server|
-        keys_for_server.each do |key|
+        keys_for_server.select! do |key|
           server.request(:pipelined_delete, key)
+          true
         rescue DalliError, NetworkError => e
           Dalli.logger.debug { e.inspect }
           Dalli.logger.debug { "unable to delete key #{key} for server #{server.name}" }
+          false
         end
       end
     end
 
     ##
     # Sends noop to each server to flush responses and ensure all deletes complete.
+    # Returns the total successful deletes across servers.
     ##
-    def finish_requests(servers)
-      servers.each do |server|
-        server.request(:noop)
+    def finish_requests(groups)
+      groups.sum do |server, keys_for_server|
+        server.request(:finish_pipelined_delete, keys_for_server.size)
       rescue DalliError, NetworkError => e
         Dalli.logger.debug { e.inspect }
         Dalli.logger.debug { "unable to complete pipelined delete on server #{server.name}" }
+        0
       end
     end
 

data/lib/dalli/protocol/base.rb

@@ -40,12 +40,14 @@ module Dalli
         verify_state(opkey)
 
         begin
+          request_completed = false
           @connection_manager.start_request!
           response = send(opkey, *args)
 
           # 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)
 
+          request_completed = true
           response
         rescue Dalli::MarshalError => e
           log_marshal_err(args.first, e)
@@ -56,6 +58,18 @@ module Dalli
           log_unexpected_err(e)
           close
           raise
+        ensure
+          # If the begin block didn't complete -- any exception, including a
+          # non-StandardError such as Async::Stop or Thread#kill, which the
+          # rescue clauses above never see -- tear down the connection so a
+          # half-used client isn't returned to the pool.
+          #
+          # The local flag is deliberate: reading $ERROR_INFO here would see
+          # the *outer* exception when `request` is called from inside a
+          # rescue clause (a common cache-fallback shape), and would then
+          # falsely tear down the pipelined_get happy path, which leaves
+          # @request_in_progress true on purpose until the caller drains.
+          close unless request_completed
         end
       end
 
@@ -95,7 +109,6 @@ module Dalli
       # 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 = nil

data/lib/dalli/protocol/connection_manager.rb

@@ -4,8 +4,6 @@ require 'English'
 require 'socket'
 require 'timeout'
 
-require 'dalli/pid_cache'
-
 module Dalli
   module Protocol
     ##
@@ -54,7 +52,7 @@ module Dalli
 
         @sock = memcached_socket
         @sock.sync = false # Enable buffered I/O for better performance
-        @pid = PIDCache.pid
+        @pid = Process.pid
         @request_in_progress = false
       rescue SystemCallError, *TIMEOUT_ERRORS, EOFError, SocketError => e
         # SocketError = DNS resolution failure
@@ -117,10 +115,16 @@ module Dalli
           @sock.close
         rescue StandardError
           nil
+        ensure
+          # A non-StandardError (e.g. a second Async::Stop fired into the
+          # fiber while it is already inside this cleanup) can escape
+          # @sock.close; run the state cleanup unconditionally so the client
+          # isn't returned to the pool with a half-closed socket and
+          # @request_in_progress == true.
+          @sock = nil
+          @pid = nil
+          abort_request!
         end
-        @sock = nil
-        @pid = nil
-        abort_request!
       end
 
       def connected?
@@ -165,12 +169,16 @@ module Dalli
         end
       else
         def read(count)
-          @sock.read(count)
+          read_bytes(count)
         rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, EOFError => e
           error_on_request!(e)
         end
       end
 
+      # Alias for callers that want to make the exact-length contract explicit
+      # at the call site.
+      alias read_exact read
+
       def write(bytes)
         @sock.write(bytes)
       rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS, IOError => e
@@ -193,8 +201,8 @@ module Dalli
 
       # Non-blocking read.  Here to support the operation
       # of the get_multi operation
-      def read_nonblock
-        @sock.read_available
+      def read_available(...)
+        @sock.read_available(...)
       end
 
       def max_allowed_failures
@@ -252,7 +260,7 @@ module Dalli
       end
 
       def fork_detected?
-        @pid && @pid != PIDCache.pid
+        @pid && @pid != Process.pid
       end
 
       def log_down_detected
@@ -273,6 +281,22 @@ module Dalli
         time = Time.now - @down_at
         Dalli.logger.warn { format('%<name>s is back (downtime was %<time>.3f seconds)', name: name, time: time) }
       end
+
+      private
+
+      # Reads exactly `count` bytes. IO#read(count) on a blocking socket blocks
+      # until it has `count` bytes, accumulating across TCP chunks internally,
+      # and only hands back a shorter (or nil) buffer when the stream hits EOF.
+      # So a short read means the peer closed mid-response: raise EOFError and
+      # let read's existing `rescue EOFError` route it through
+      # error_on_request!, which closes the dirty socket for a retry on a fresh
+      # connection (and preserves the $ERROR_INFO context down! relies on).
+      def read_bytes(count)
+        buffer = @sock.read(count)
+        return buffer if buffer && buffer.bytesize == count
+
+        raise EOFError, "EOF reading #{count} bytes; received #{buffer ? buffer.bytesize : 0}"
+      end
     end
   end
 end

data/lib/dalli/protocol/key_regularizer.rb

@@ -9,19 +9,18 @@ module Dalli
       # allowed.
       # memcached supports the use of base64 hashes for keys containing
       # whitespace or non-ASCII characters, provided the 'b' flag is included in the request.
-      class KeyRegularizer
-        WHITESPACE = /\s/
+      module KeyRegularizer
+        module_function
 
-        def self.encode(key)
-          return [key, false] if key.ascii_only? && !WHITESPACE.match(key)
-
-          strict_base64_encoded = [key].pack('m0')
-          [strict_base64_encoded, true]
+        def required?(key)
+          !key.ascii_only? || /\s/.match?(key)
         end
 
-        def self.decode(encoded_key, base64_encoded)
-          return encoded_key unless base64_encoded
+        def encode(key)
+          [key].pack('m0')
+        end
 
+        def decode(encoded_key)
           strict_base64_decoded = encoded_key.unpack1('m0')
           strict_base64_decoded.force_encoding(Encoding::UTF_8)
         end

data/lib/dalli/protocol/meta.rb

@@ -24,34 +24,29 @@ module Dalli
 
       # Retrieval Commands
       def get(key, options = nil)
-        encoded_key, base64 = KeyRegularizer.encode(key)
         # 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: encoded_key, base64: base64, skip_flags: skip_flags)
+        req = RequestFormatter.meta_get(key: key, skip_flags: skip_flags)
         flushed_write(req)
         response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
       def quiet_get_request(key)
-        encoded_key, base64 = KeyRegularizer.encode(key)
         # Skip bitflags in raw mode - saves 2 bytes per request and skips parsing
-        RequestFormatter.meta_get(key: encoded_key, return_cas: true, base64: base64, quiet: true,
-                                  skip_flags: raw_mode?)
+        RequestFormatter.meta_get(key: key, return_cas: true, quiet: true, skip_flags: raw_mode?)
       end
 
       def gat(key, ttl, options = nil)
         ttl = TtlSanitizer.sanitize(ttl)
-        encoded_key, base64 = KeyRegularizer.encode(key)
         skip_flags = raw_mode? || (options && options[:raw])
-        req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, base64: base64, skip_flags: skip_flags)
+        req = RequestFormatter.meta_get(key: key, ttl: ttl, skip_flags: skip_flags)
         flushed_write(req)
         response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
       def touch(key, ttl)
         ttl = TtlSanitizer.sanitize(ttl)
-        encoded_key, base64 = KeyRegularizer.encode(key)
-        req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, value: false, base64: base64)
+        req = RequestFormatter.meta_get(key: key, ttl: ttl, value: false)
         flushed_write(req)
         response_processor.meta_get_without_value
       end
@@ -59,8 +54,7 @@ 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)
-        encoded_key, base64 = KeyRegularizer.encode(key)
-        req = RequestFormatter.meta_get(key: encoded_key, value: true, return_cas: true, base64: base64)
+        req = RequestFormatter.meta_get(key: key, value: true, return_cas: true)
         flushed_write(req)
         response_processor.meta_get_with_value_and_cas
       end
@@ -90,9 +84,8 @@ module Dalli
       #   - :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)
       def meta_get(key, options = {})
-        encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_get(
-          key: encoded_key, value: true, return_cas: true, base64: base64,
+          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]
@@ -112,8 +105,7 @@ module Dalli
       # @param cas [Integer] optional CAS value for compare-and-swap
       # @return [Boolean] true if successful
       def delete_stale(key, cas = nil)
-        encoded_key, base64 = KeyRegularizer.encode(key)
-        req = RequestFormatter.meta_delete(key: encoded_key, cas: cas, base64: base64, stale: true)
+        req = RequestFormatter.meta_delete(key: key, cas: cas, stale: true)
         flushed_write(req)
         response_processor.meta_delete
       end
@@ -140,14 +132,12 @@ module Dalli
         response_processor.meta_set_with_cas unless quiet?
       end
 
-      # rubocop:disable Metrics/ParameterLists
       def write_storage_req(mode, key, raw_value, ttl = nil, cas = nil, options = {}, quiet: quiet?)
         (value, bitflags) = @value_marshaller.store(key, raw_value, options)
         ttl = TtlSanitizer.sanitize(ttl) if ttl
-        encoded_key, base64 = KeyRegularizer.encode(key)
-        req = RequestFormatter.meta_set(key: encoded_key, value: value,
+        req = RequestFormatter.meta_set(key: key, value: value,
                                         bitflags: bitflags, cas: cas,
-                                        ttl: ttl, mode: mode, quiet: quiet, base64: base64)
+                                        ttl: ttl, mode: mode, quiet: quiet)
         write("#{req}#{value}#{TERMINATOR}")
         @connection_manager.flush unless quiet
       end
@@ -166,8 +156,7 @@ module Dalli
       # rubocop:disable Metrics/ParameterLists
       def write_append_prepend_req(mode, key, value, ttl = nil, cas = nil, _options = {})
         ttl = TtlSanitizer.sanitize(ttl) if ttl
-        encoded_key, base64 = KeyRegularizer.encode(key)
-        req = RequestFormatter.meta_set(key: encoded_key, value: value, base64: base64,
+        req = RequestFormatter.meta_set(key: key, value: value,
                                         cas: cas, ttl: ttl, mode: mode, quiet: quiet?)
         write("#{req}#{value}#{TERMINATOR}")
         @connection_manager.flush unless quiet?
@@ -176,9 +165,7 @@ module Dalli
 
       # Delete Commands
       def delete(key, cas)
-        encoded_key, base64 = KeyRegularizer.encode(key)
-        req = RequestFormatter.meta_delete(key: encoded_key, cas: cas,
-                                           base64: base64, quiet: quiet?)
+        req = RequestFormatter.meta_delete(key: key, cas: cas, quiet: quiet?)
         write(req)
         @connection_manager.flush unless quiet?
         response_processor.meta_delete unless quiet?
@@ -187,11 +174,15 @@ module Dalli
       # Pipelined delete - writes a quiet delete request without reading response.
       # Used by PipelinedDeleter for bulk operations.
       def pipelined_delete(key)
-        encoded_key, base64 = KeyRegularizer.encode(key)
-        req = RequestFormatter.meta_delete(key: encoded_key, base64: base64, quiet: true)
+        req = RequestFormatter.meta_delete(key: key, quiet: true)
         write(req)
       end
 
+      def finish_pipelined_delete(sent)
+        write_noop
+        sent - response_processor.pipelined_delete_non_deletions
+      end
+
       # Arithmetic Commands
       def decr(key, count, ttl, initial)
         decr_incr false, key, count, ttl, initial
@@ -203,9 +194,8 @@ module Dalli
 
       def decr_incr(incr, key, delta, ttl, initial)
         ttl = initial ? TtlSanitizer.sanitize(ttl) : nil # Only set a TTL if we want to set a value on miss
-        encoded_key, base64 = KeyRegularizer.encode(key)
-        write(RequestFormatter.meta_arithmetic(key: encoded_key, delta: delta, initial: initial, incr: incr, ttl: ttl,
-                                               quiet: quiet?, base64: base64))
+        write(RequestFormatter.meta_arithmetic(key: key, delta: delta, initial: initial, incr: incr, ttl: ttl,
+                                               quiet: quiet?))
         @connection_manager.flush unless quiet?
         response_processor.decr_incr unless quiet?
       end
@@ -248,23 +238,9 @@ module Dalli
       # machinery (IO.select, response buffering, server grouping).
       def read_multi_req(keys)
         is_raw = raw_mode?
-        # Inline request formatting — avoids RequestFormatter.meta_get overhead per key.
-        # In raw mode: "mg <key> v k q s\r\n" (no f flag, key at index 2)
-        # Normal mode: "mg <key> v f k q s\r\n" (key at index 3)
-        post_get = is_raw ? " v k q s\r\n" : " v f k q s\r\n"
-        buffer = ''.b
-        keys.each do |key|
-          encoded_key, base64 = KeyRegularizer.encode(key)
-          if base64
-            buffer << 'mg ' << encoded_key << ' b' << post_get
-          else
-            buffer << 'mg ' << encoded_key << post_get
-          end
-        end
-        buffer << 'mn' << TERMINATOR
+        buffer = RequestFormatter.multi_meta_get(keys, skip_flags: is_raw)
         flushed_write(buffer)
         buffer.clear
-
         read_multi_get_responses(is_raw)
       end
 
@@ -287,52 +263,33 @@ module Dalli
         raw_key = tokens[key_index]
         return unless raw_key
 
-        key = KeyRegularizer.decode(raw_key[1..], tokens.include?('b'))
+        key = raw_key[1..]
+        key = KeyRegularizer.decode(key) if tokens.include?('b')
         bitflags = is_raw ? 0 : response_processor.bitflags_from_tokens(tokens)
         [key, @value_marshaller.retrieve(value, bitflags)]
       end
 
-      # rubocop:disable Metrics/AbcSize
-
       # Single-server fast path for set_multi. Inlines request formatting to
       # minimize per-key overhead. Avoids PipelinedSetter server grouping.
       def write_multi_req(pairs, ttl, req_options)
         ttl = TtlSanitizer.sanitize(ttl) if ttl
-        buffer = ''.b
-        pairs.each do |key, raw_value|
-          (value, bitflags) = @value_marshaller.store(key, raw_value, req_options)
-          encoded_key, base64 = KeyRegularizer.encode(key)
-          # Inline format: "ms <key> <size> c [b] F<flags> T<ttl> MS q\r\n"
-          buffer << "ms #{encoded_key} #{value.bytesize} c"
-          buffer << ' b' if base64
-          buffer << " F#{bitflags}" if bitflags
-          buffer << " T#{ttl}" if ttl
-          buffer << ' MS q' << TERMINATOR << value << TERMINATOR
+        entries = pairs.map do |key, raw_value|
+          [key, @value_marshaller.store(key, raw_value, req_options)]
         end
-        buffer << RequestFormatter.meta_noop
+
+        buffer = RequestFormatter.multi_meta_set(entries, ttl: ttl)
         flushed_write(buffer)
         buffer.clear
         response_processor.consume_all_responses_until_mn
       end
-      # rubocop:enable Metrics/AbcSize
 
       # 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 = ''.b
-        keys.each do |key|
-          encoded_key, base64 = KeyRegularizer.encode(key)
-          # Inline format: "md <key> [b] q\r\n"
-          if base64
-            buffer << 'md ' << encoded_key << ' b q' << TERMINATOR
-          else
-            buffer << 'md ' << encoded_key << ' q' << TERMINATOR
-          end
-        end
-        buffer << RequestFormatter.meta_noop
+        buffer = RequestFormatter.multi_meta_delete(keys)
         flushed_write(buffer)
         buffer.clear
-        response_processor.consume_all_responses_until_mn
+        keys.size - response_processor.pipelined_delete_non_deletions
       end
 
       require_relative 'key_regularizer'

data/lib/dalli/protocol/request_formatter.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 
 module Dalli
   module Protocol
@@ -7,14 +7,13 @@ module Dalli
       # Class that encapsulates logic for formatting meta protocol requests
       # to memcached.
       ##
-      class RequestFormatter
+      module RequestFormatter
+        extend self
+
         # Since these are string construction methods, we're going to disable these
         # Rubocop directives.  We really can't make this construction much simpler,
         # and introducing an intermediate object seems like overkill.
         #
-        # rubocop:disable Metrics/CyclomaticComplexity
-        # rubocop:disable Metrics/ParameterLists
-        # rubocop:disable Metrics/PerceivedComplexity
         #
         # Meta get flags:
         #
@@ -35,16 +34,15 @@ module Dalli
         # - Z: Client lost the recache race (another client is already regenerating)
         # - h0/h1: Hit status (0 = first access, 1 = previously accessed)
         # - l<N>: Seconds since last access
-        def self.meta_get(key:, value: true, return_cas: false, ttl: nil, base64: false, quiet: false,
-                          vivify_ttl: nil, recache_ttl: nil,
-                          return_hit_status: false, return_last_access: false, skip_lru_bump: false,
-                          skip_flags: false)
-          cmd = "mg #{key}"
+        def meta_get(key:, value: true, return_cas: false, ttl: nil, quiet: false,
+                     vivify_ttl: nil, recache_ttl: nil,
+                     return_hit_status: false, return_last_access: false, skip_lru_bump: false,
+                     skip_flags: false)
+          cmd = "mg #{encoded_key(key)}"
           # In raw mode (skip_flags: true), we don't request bitflags since they're not used.
           # This saves 2 bytes per request and skips parsing on response.
           cmd << (skip_flags ? ' v' : ' v f') if value
           cmd << ' c' if return_cas
-          cmd << ' b' if base64
           cmd << " T#{ttl}" if ttl
           cmd << ' k q s' if quiet # Return the key in the response if quiet
           cmd << " N#{vivify_ttl}" if vivify_ttl # Thundering herd: vivify on miss
@@ -55,9 +53,24 @@ module Dalli
           cmd << TERMINATOR
         end
 
-        def self.meta_set(key:, value:, bitflags: nil, cas: nil, ttl: nil, mode: :set, base64: false, quiet: false)
+        def multi_meta_get(keys, skip_flags: false)
+          # In raw mode: "mg <key> v k q s\r\n" (no f flag, key at index 2)
+          # Normal mode: "mg <key> v f k q s\r\n" (key at index 3)
+          post_get = skip_flags ? " v k q s\r\n" : " v f k q s\r\n"
+          buffer = ''.b
+          keys.each do |key|
+            buffer << 'mg ' << encoded_key(key) << post_get
+          end
+          buffer << 'mn' << TERMINATOR
+        end
+
+        def meta_set(key:, value:, bitflags: nil, cas: nil, ttl: nil, mode: :set, quiet: false)
+          base64 = KeyRegularizer.required?(key)
+          key = KeyRegularizer.encode(key) if base64
           cmd = "ms #{key} #{value.bytesize}"
-          cmd << ' c' unless %i[append prepend].include?(mode)
+          # Skip the cas-return flag in quiet mode: the response is suppressed,
+          # so requesting it only adds bytes to the request.
+          cmd << ' c' if !quiet && !%i[append prepend].include?(mode)
           cmd << ' b' if base64
           cmd << " F#{bitflags}" if bitflags
           cmd << cas_string(cas)
@@ -67,12 +80,29 @@ module Dalli
           cmd << TERMINATOR
         end
 
+        def multi_meta_set(entries, ttl: nil)
+          buffer = ''.b
+          entries.each do |key, pair|
+            value, bitflags = pair
+
+            base64 = KeyRegularizer.required?(key)
+            key = KeyRegularizer.encode(key) if base64
+
+            # Inline format: "ms <key> <size> c [b] F<flags> T<ttl> MS q\r\n"
+            buffer << "ms #{key} #{value.bytesize} c"
+            buffer << ' b' if base64
+            buffer << " F#{bitflags}" if bitflags
+            buffer << " T#{ttl}" if ttl
+            buffer << ' MS q' << TERMINATOR << value << TERMINATOR
+          end
+          buffer << META_NOOP
+        end
+
         # Thundering herd protection flag:
         # - stale (I flag): Instead of deleting the item, mark it as stale. Other clients
         #   using N/R flags will see the X flag and know the item is being regenerated.
-        def self.meta_delete(key:, cas: nil, ttl: nil, base64: false, quiet: false, stale: false)
-          cmd = "md #{key}"
-          cmd << ' b' if base64
+        def meta_delete(key:, cas: nil, ttl: nil, quiet: false, stale: false)
+          cmd = "md #{encoded_key(key)}"
           cmd << cas_string(cas)
           cmd << " T#{ttl}" if ttl
           cmd << ' I' if stale # Mark stale instead of deleting
@@ -80,9 +110,16 @@ module Dalli
           cmd << TERMINATOR
         end
 
-        def self.meta_arithmetic(key:, delta:, initial:, incr: true, cas: nil, ttl: nil, base64: false, quiet: false)
-          cmd = "ma #{key} v"
-          cmd << ' b' if base64
+        def multi_meta_delete(keys)
+          buffer = ''.b
+          keys.each do |key|
+            buffer << 'md ' << encoded_key(key) << ' q' << TERMINATOR
+          end
+          buffer << META_NOOP
+        end
+
+        def meta_arithmetic(key:, delta:, initial:, incr: true, cas: nil, ttl: nil, quiet: false)
+          cmd = "ma #{encoded_key(key)} v"
           cmd << " D#{delta}" if delta
           cmd << " J#{initial}" if initial
           # Always set a TTL if an initial value is specified
@@ -97,15 +134,15 @@ module Dalli
         # rubocop:enable Metrics/PerceivedComplexity
 
         META_NOOP = "mn#{TERMINATOR}".freeze
-        def self.meta_noop
+        def meta_noop
           META_NOOP
         end
 
-        def self.version
+        def version
           "version#{TERMINATOR}"
         end
 
-        def self.flush(delay: nil, quiet: false)
+        def flush(delay: nil, quiet: false)
           cmd = +'flush_all'
           cmd << " #{parse_to_64_bit_int(delay, 0)}" if delay
           cmd << ' noreply' if quiet
@@ -114,7 +151,7 @@ module Dalli
 
         ALLOWED_STATS_ARGS = [nil, '', 'items', 'slabs', 'settings', 'reset'].freeze
 
-        def self.stats(arg = nil)
+        def stats(arg = nil)
           raise ArgumentError, "Invalid stats argument: #{arg.inspect}" unless ALLOWED_STATS_ARGS.include?(arg)
 
           cmd = +'stats'
@@ -122,7 +159,17 @@ module Dalli
           cmd << TERMINATOR
         end
 
-        def self.mode_to_token(mode)
+        def encoded_key(key)
+          if KeyRegularizer.required?(key)
+            KeyRegularizer.encode(key) << ' b'
+          else
+            key
+          end
+        end
+
+        private
+
+        def mode_to_token(mode)
           case mode
           when :add
             'E'
@@ -137,12 +184,12 @@ module Dalli
           end
         end
 
-        def self.cas_string(cas)
+        def cas_string(cas)
           cas = parse_to_64_bit_int(cas, nil)
           cas.nil? || cas.zero? ? '' : " C#{cas}"
         end
 
-        def self.parse_to_64_bit_int(val, default)
+        def parse_to_64_bit_int(val, default)
           val.nil? ? nil : Integer(val)
         rescue ArgumentError
           # Sanitize to default if it isn't parsable as an integer

data/lib/dalli/protocol/response_buffer.rb

@@ -5,16 +5,16 @@ require 'timeout'
 
 module Dalli
   module Protocol
+    # Compact the buffer when the consumed portion exceeds this
+    # threshold and represents more than half the buffer
+    COMPACT_THRESHOLD = 4096
+
     ##
     # Manages the buffer for responses from memcached.
     # Uses an offset-based approach to avoid string allocations
     # when advancing through parsed responses.
     ##
     class ResponseBuffer
-      # Compact the buffer when the consumed portion exceeds this
-      # threshold and represents more than half the buffer
-      COMPACT_THRESHOLD = 4096
-
       def initialize(io_source, response_processor)
         @io_source = io_source
         @response_processor = response_processor
@@ -23,22 +23,32 @@ module Dalli
       end
 
       def read
-        @buffer << @io_source.read_nonblock
+        remaining_bytes = @buffer.bytesize - @offset
+        if remaining_bytes.zero?
+          @offset = 0
+          @buffer = @io_source.read_available(@buffer)
+        else
+          if @offset > COMPACT_THRESHOLD && @offset > (@buffer.bytesize / 2)
+            @buffer.bytesplice(0, @offset, '')
+            @offset = 0
+          end
+          @buffer << @io_source.read_available
+        end
       end
 
       # Attempts to process a single response from the buffer,
       # advancing the offset past the consumed bytes.
       def process_single_getk_response
-        bytes, status, cas, key, value = @response_processor.getk_response_from_buffer(@buffer, @offset)
-        @offset += bytes
-        compact_if_needed
-        [status, cas, key, value]
+        response = @response_processor.getk_response_from_buffer(@buffer, @offset)
+        @offset += response.pop
+        response
       end
 
       # Resets the internal buffer to an empty state,
       # so that we're ready to read pipelined responses
       def reset
-        @buffer = ''.b
+        @buffer&.clear
+        @buffer ||= ''.b
         @offset = 0
       end
 
@@ -54,6 +64,7 @@ module Dalli
 
       # Clear the internal response buffer
       def clear
+        @buffer&.clear
         @buffer = nil
         @offset = 0
       end
@@ -61,18 +72,6 @@ module Dalli
       def in_progress?
         !@buffer.nil?
       end
-
-      private
-
-      # Only compact when we've consumed a significant portion of the buffer.
-      # This avoids per-response string allocation while preventing unbounded
-      # memory growth for large pipelines.
-      def compact_if_needed
-        return unless @offset > COMPACT_THRESHOLD && @offset > @buffer.bytesize / 2
-
-        @buffer = @buffer.byteslice(@offset..)
-        @offset = 0
-      end
     end
   end
 end

data/lib/dalli/protocol/response_processor.rb

@@ -157,9 +157,26 @@ module Dalli
           true
         end
 
+        # Consumes the responses to a batch of quiet (pipelined) delete
+        # requests, which are terminated by a noop (MN). In quiet mode
+        # memcached suppresses the success response for each deleted key, so
+        # every line received before the terminator corresponds to a key that
+        # was NOT deleted -- a miss (NF) or an error. Returns that count so
+        # callers can derive the number of successful deletes as
+        # (keys_sent - non_deletions).
+        def pipelined_delete_non_deletions
+          non_deletions = 0
+          tokens = next_line_to_tokens
+          until tokens.first == MN
+            non_deletions += 1
+            tokens = next_line_to_tokens
+          end
+          non_deletions
+        end
+
         def full_response_from_buffer(tokens, body, resp_size)
           value = @value_marshaller.retrieve(body, bitflags_from_tokens(tokens))
-          [resp_size, tokens.first == VA, cas_from_tokens(tokens), key_from_tokens(tokens), value]
+          [tokens.first == VA, cas_from_tokens(tokens), key_from_tokens(tokens), value, resp_size]
         end
 
         ##
@@ -174,24 +191,26 @@ module Dalli
         ##
         def getk_response_from_buffer(buf, offset = 0)
           # Find the header terminator starting from offset
-          term_idx = buf.index(TERMINATOR, offset)
-          return [0, nil, nil, nil, nil] unless term_idx
+          term_idx = buf.byteindex(TERMINATOR, offset)
+          return [0] unless term_idx
 
           header = buf.byteslice(offset, term_idx - offset)
           tokens = header.split
           header_len = header.bytesize + TERMINATOR.length
+
+          # The body len is removed from the tokens array
           body_len = body_len_from_tokens(tokens)
 
           # We have a complete response that has no body.
           # This is either the response to the terminating
           # noop or, if the status is not MN, an intermediate
           # error response that needs to be discarded.
-          return [header_len, true, nil, nil, nil] if body_len.zero?
+          return [true, header_len] if body_len.zero?
 
           resp_size = header_len + body_len + TERMINATOR.length
           # The header is in the buffer, but the body is not.  As we don't have
           # a complete response, don't advance the buffer
-          return [0, nil, nil, nil, nil] unless buf.bytesize >= offset + resp_size
+          return [0] unless buf.bytesize >= offset + resp_size
 
           # The full response is in our buffer, so parse it and return
           # the values
@@ -210,17 +229,20 @@ module Dalli
         end
 
         def bitflags_from_tokens(tokens)
-          value_from_tokens(tokens, 'f')&.to_i
+          value_from_tokens(tokens, 'f').to_i
         end
 
         def cas_from_tokens(tokens)
-          value_from_tokens(tokens, 'c')&.to_i
+          value_from_tokens(tokens, 'c').to_i
         end
 
         def key_from_tokens(tokens)
           encoded_key = value_from_tokens(tokens, 'k')
-          base64_encoded = tokens.any?('b')
-          KeyRegularizer.decode(encoded_key, base64_encoded)
+          if tokens.delete('b')
+            KeyRegularizer.decode(encoded_key)
+          else
+            encoded_key
+          end
         end
 
         # Returns true if item was previously hit, false if first access, nil if not requested
@@ -235,18 +257,22 @@ module Dalli
         # Returns seconds since last access, or nil if not requested
         # The l flag returns l<seconds>
         def last_access_from_tokens(tokens)
-          value_from_tokens(tokens, 'l')&.to_i
+          value_from_tokens(tokens, 'l').to_i
         end
 
         def body_len_from_tokens(tokens)
-          value_from_tokens(tokens, 's')&.to_i
+          value_from_tokens(tokens, 's').to_i
         end
 
         def value_from_tokens(tokens, flag)
-          bitflags_token = tokens.find { |t| t.start_with?(flag) }
-          return 0 unless bitflags_token
-
-          bitflags_token[1..]
+          # NB: as an optimization, we're mutating the matching token in place
+          # so there is a baked assumption that we're only accessing each token at most once.
+          index = tokens.find_index { |t| t.start_with?(flag) }
+          if index
+            tokens.delete_at(index).delete_prefix!(flag)
+          else
+            0
+          end
         end
 
         def read_line

data/lib/dalli/socket.rb

@@ -12,48 +12,63 @@ module Dalli
     # Common methods for all socket implementations.
     ##
     module InstanceMethods
-      def readfull(count)
-        value = String.new(capacity: count + 1)
-        loop do
-          result = read_nonblock(count - value.bytesize, exception: false)
-          value << result if append_to_buffer?(result)
-          break if value.bytesize == count
+      def read_available(reusable_buffer = nil)
+        if reusable_buffer
+          value = read_nonblock(8196, reusable_buffer, exception: false)
+          case value
+          when :wait_writable, :wait_readable
+            return reusable_buffer.clear
+          when nil
+            raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}"
+          end
+        else
+          value = ''.b
         end
-        value
-      end
 
-      def read_available
-        value = +''
+        buffer = ''.b
         loop do
-          result = read_nonblock(8196, exception: false)
-          break if WAIT_RCS.include?(result)
-          raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}" unless result
-
-          value << result
+          result = read_nonblock(8196, buffer, exception: false)
+          case result
+          when :wait_writable, :wait_readable
+            buffer.clear
+            return value
+          when nil
+            raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}"
+          else
+            value << result
+          end
         end
-        value
-      end
-
-      WAIT_RCS = %i[wait_writable wait_readable].freeze
-
-      def append_to_buffer?(result)
-        raise Timeout::Error, "IO timeout: #{logged_options.inspect}" if nonblock_timed_out?(result)
-        raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}" unless result
-
-        !WAIT_RCS.include?(result)
-      end
-
-      def nonblock_timed_out?(result)
-        return true if result == :wait_readable && !wait_readable(options[:socket_timeout])
-
-        # TODO: Do we actually need this?  Looks to be only used in read_nonblock
-        result == :wait_writable && !wait_writable(options[:socket_timeout])
       end
 
       FILTERED_OUT_OPTIONS = %i[username password].freeze
       def logged_options
         options.except(*FILTERED_OUT_OPTIONS)
       end
+
+      # JRuby doesn't support IO#timeout=, so use custom readfull implementation
+      # CRuby 3.3+ has IO#timeout= which makes IO#read work with timeouts
+      if RUBY_ENGINE == 'jruby'
+        def readfull(count)
+          value = String.new(capacity: count + 1)
+
+          until value.bytesize == count
+            result = read_nonblock(count - value.bytesize, exception: false)
+            case result
+            when :wait_readable
+              wait_readable(options[:socket_timeout]) or raise Timeout::Error, "IO timeout: #{logged_options.inspect}"
+            when :wait_writable
+              wait_writable(options[:socket_timeout]) or raise Timeout::Error, "IO timeout: #{logged_options.inspect}"
+            when nil
+              raise Errno::ECONNRESET, "Connection reset: #{logged_options.inspect}"
+            else
+              value << result
+            end
+          end
+
+          value
+        end
+        # rubocop:enable Metrics/AbcSize
+      end
     end
 
     ##

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '5.0.5'
+  VERSION = '5.0.6'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.6'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 5.0.5
+  version: 5.0.6
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -44,7 +44,6 @@ files:
 - lib/dalli/instrumentation.rb
 - lib/dalli/key_manager.rb
 - lib/dalli/options.rb
-- lib/dalli/pid_cache.rb
 - lib/dalli/pipelined_deleter.rb
 - lib/dalli/pipelined_getter.rb
 - lib/dalli/pipelined_setter.rb
@@ -88,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.12
+rubygems_version: 4.0.16
 specification_version: 4
 summary: High performance memcached client for Ruby
 test_files: []

data/lib/dalli/pid_cache.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Dalli
-  ##
-  # Dalli::PIDCache is a wrapper class for PID checking to avoid system calls when checking the PID.
-  ##
-  module PIDCache
-    if !Process.respond_to?(:fork) # JRuby or TruffleRuby
-      @pid = Process.pid
-      singleton_class.attr_reader(:pid)
-    elsif Process.respond_to?(:_fork) # Ruby 3.1+
-      class << self
-        attr_reader :pid
-
-        def update!
-          @pid = Process.pid # rubocop:disable ThreadSafety/ClassInstanceVariable
-        end
-      end
-      update!
-
-      ##
-      # Dalli::PIDCache::CoreExt hooks into Process to be able to reset the PID cache after fork
-      ##
-      module CoreExt
-        def _fork
-          child_pid = super
-          PIDCache.update! if child_pid.zero?
-          child_pid
-        end
-      end
-      Process.singleton_class.prepend(CoreExt)
-    else # Ruby 3.0 or older
-      class << self
-        def pid
-          Process.pid
-        end
-      end
-    end
-  end
-end