dalli 5.0.1 → 5.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02d0fa949b7a065f86fb3ac7b511a3feacc50b700e82dcb385e0e79c56583a9d
-  data.tar.gz: d72b9e4b014ae1ae0b0d5a1ebe09ea48cdf9fbf0a2cda000efc19f17d5d34368
+  metadata.gz: e67adaead94f1a41b7ef5554434e3d88742bdf6f80d6c6a7a8552ce325e4e212
+  data.tar.gz: 51924b636e902895274ef517305e501a79c3480a440f0be83110eb17a7c88c25
 SHA512:
-  metadata.gz: bf26484aa345df2d43a78da570027b68a7fd0dd70d7a62275ebe95a5e29ed36c11a8b1385ff0c71818f55184245e085cd75962510f9f8559aad10b0d284f8d71
-  data.tar.gz: 0b3913a33f61873d6e3da0d62ec643dbf49f679740d3469b7cb826083f02f3b32d37e2a20548634d09cecdc4389da7c5bdc43af530bb48956cb4084f91f10d9e
+  metadata.gz: b36ce658adf751963219ac3a32b14680a19fdc029be2dfc575429d17e5efd6ef2dbf377610b3f3d05dc5a13824c4bb5df8477b94973e5d210f887743f6e3886a
+  data.tar.gz: db34b04265de2c8911aae1ce20618e01375b08d769b81d965fca64e3ddd2c358b8a69ed885a821de46fe9d46d4a8f83c98f60f776a52fe8443c28ca631cfa9c6

data/CHANGELOG.md

@@ -1,6 +1,40 @@
 Dalli Changelog
 =====================
 
+Unreleased
+==========
+
+5.0.3
+==========
+
+Performance:
+
+- Eliminate double array allocation in `Client#perform` (#1093)
+  - Changed method signature from `perform(*all_args)` with destructuring to `perform(op, key, *args)`, letting Ruby decompose arguments directly without intermediate array allocations
+  - Reduces benchmark time by ~39% across all Dalli operations (get, set, delete, etc.)
+  - Thanks to Sam Obeid for this contribution
+
+Features:
+
+- Support `connect_timeout:` keyword argument with `resolv-replace` >= 0.2.0, which now correctly forwards keyword arguments through its `TCPSocket` patch (#1096)
+
+- Add `Dalli::Instrumentation.disable!` to allow disabling OpenTelemetry instrumentation at runtime (#1088)
+  - Also exposes `Dalli::Instrumentation.tracer=` for setting a custom tracer
+
+5.0.2
+==========
+
+Performance:
+
+- Add single-server fast path for `get_multi`, `set_multi`, and `delete_multi` (#1077)
+  - When only one memcached server is configured, bypass the `Pipelined*` machinery (IO.select, response buffering, server grouping) and issue all quiet meta requests inline followed by a noop terminator
+  - `get_multi` shows ~1.5x improvement at 10 keys and ~1.75x at 100–500 keys compared to the `PipelinedGetter` path
+  - Thanks to Dan Mayer (Shopify) for this contribution
+
+Development:
+
+- Add `bin/benchmark_branch` script for benchmarking against the current branch
+
 5.0.1
 ==========
 

data/README.md

@@ -90,6 +90,20 @@ Exceptions are automatically recorded on spans with error status. When an operat
 2. The span status is set to error with the exception message
 3. The exception is re-raised to the caller
 
+### Disabling Instrumentation
+
+To disable instrumentation at runtime (e.g., in tests or specific environments):
+
+```ruby
+Dalli::Instrumentation.disable!
+```
+
+You can also assign a custom tracer directly:
+
+```ruby
+Dalli::Instrumentation.tracer = my_custom_tracer
+```
+
 ### 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.

data/lib/dalli/client.rb

@@ -311,7 +311,11 @@ module Dalli
       return if hash.empty?
 
       Instrumentation.trace('set_multi', multi_trace_attrs('set_multi', hash.size, hash.keys)) do
-        pipelined_setter.process(hash, ttl_or_default(ttl), req_options)
+        if ring.servers.size == 1
+          single_server_set_multi(hash, ttl_or_default(ttl), req_options)
+        else
+          pipelined_setter.process(hash, ttl_or_default(ttl), req_options)
+        end
       end
     end
 
@@ -368,7 +372,11 @@ module Dalli
       return if keys.empty?
 
       Instrumentation.trace('delete_multi', multi_trace_attrs('delete_multi', keys.size, keys)) do
-        pipelined_deleter.process(keys)
+        if ring.servers.size == 1
+          single_server_delete_multi(keys)
+        else
+          pipelined_deleter.process(keys)
+        end
       end
     end
 
@@ -522,13 +530,52 @@ module Dalli
 
     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
+        hash = if ring.servers.size == 1
+                 single_server_get_multi(keys)
+               else
+                 {}.tap do |h|
+                   pipelined_getter.process(keys) { |k, data| h[k] = data.first }
+                 end
+               end
+        record_hit_miss_metrics(span, keys.size, hash.size)
+        hash
       end
     end
 
+    def single_server
+      server = ring.servers.first
+      server if server&.alive?
+    end
+
+    def single_server_get_multi(keys)
+      keys.map! { |k| @key_manager.validate_key(k.to_s) }
+      return {} unless (server = single_server)
+
+      result = server.request(:read_multi_req, keys)
+      result.transform_keys! { |k| @key_manager.key_without_namespace(k) }
+      result
+    rescue Dalli::NetworkError
+      {}
+    end
+
+    def single_server_set_multi(hash, ttl, req_options)
+      pairs = hash.transform_keys { |k| @key_manager.validate_key(k.to_s) }
+      return unless (server = single_server)
+
+      server.request(:write_multi_req, pairs, ttl, req_options)
+    rescue Dalli::NetworkError
+      nil
+    end
+
+    def single_server_delete_multi(keys)
+      validated_keys = keys.map { |k| @key_manager.validate_key(k.to_s) }
+      return unless (server = single_server)
+
+      server.request(:delete_multi_req, validated_keys)
+    rescue Dalli::NetworkError
+      nil
+    end
+
     def get_multi_attributes(keys)
       multi_trace_attrs('get_multi', keys.size, keys)
     end
@@ -603,11 +650,11 @@ module Dalli
     # a particular memcached instance becomes unreachable, or the
     # operation times out.
     ##
-    def perform(*all_args)
+    # rubocop:disable Naming/MethodParameterName
+    def perform(op, key, *args)
+      # rubocop:enable Naming/MethodParameterName
       return yield if block_given?
 
-      op, key, *args = all_args
-
       key = key.to_s
       key = @key_manager.validate_key(key)
 

data/lib/dalli/instrumentation.rb

@@ -61,13 +61,14 @@ module Dalli
       # Uses the library name 'dalli' and current Dalli::VERSION.
       #
       # @return [OpenTelemetry::Trace::Tracer, nil] the tracer or nil if OTel unavailable
-      # rubocop:disable ThreadSafety/ClassInstanceVariable
+      # rubocop:disable ThreadSafety/ClassInstanceVariable, ThreadSafety/ClassAndModuleAttributes
       def tracer
         return @tracer if defined?(@tracer)
 
         @tracer = (OpenTelemetry.tracer_provider.tracer('dalli', Dalli::VERSION) if defined?(OpenTelemetry))
       end
-      # rubocop:enable ThreadSafety/ClassInstanceVariable
+
+      attr_writer :tracer
 
       # Returns true if instrumentation is enabled (OpenTelemetry SDK is available).
       #
@@ -76,6 +77,15 @@ module Dalli
         !tracer.nil?
       end
 
+      # Disable instrumentation.
+      #
+      # @return [nil]
+      def disable!
+        @tracer = nil
+      end
+
+      # rubocop:enable ThreadSafety/ClassInstanceVariable, ThreadSafety/ClassAndModuleAttributes
+
       # Wraps a block with a span if instrumentation is enabled.
       #
       # Creates a client span with the given name and attributes merged with

data/lib/dalli/protocol/meta.rb

@@ -257,6 +257,82 @@ module Dalli
         @connection_manager.flush
       end
 
+      # 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)
+        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"
+        keys.each do |key|
+          encoded_key, base64 = KeyRegularizer.encode(key)
+          write(base64 ? "mg #{encoded_key} b#{post_get}" : "mg #{encoded_key}#{post_get}")
+        end
+        write("mn\r\n")
+        @connection_manager.flush
+
+        read_multi_get_responses(is_raw)
+      end
+
+      def read_multi_get_responses(is_raw)
+        hash = {}
+        key_index = is_raw ? 2 : 3
+        while (line = @connection_manager.read_line)
+          break if line.start_with?('MN')
+          next unless line.start_with?('VA ')
+
+          key, value = parse_multi_get_value(line, key_index, is_raw)
+          hash[key] = value if key
+        end
+        hash
+      end
+
+      def parse_multi_get_value(line, key_index, is_raw)
+        tokens = line.chomp!(TERMINATOR).split
+        value = @connection_manager.read(tokens[1].to_i + TERMINATOR.bytesize)&.chomp!(TERMINATOR)
+        raw_key = tokens[key_index]
+        return unless raw_key
+
+        key = KeyRegularizer.decode(raw_key[1..], tokens.include?('b'))
+        bitflags = is_raw ? 0 : response_processor.bitflags_from_tokens(tokens)
+        [key, @value_marshaller.retrieve(value, bitflags)]
+      end
+
+      # 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
+        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"
+          cmd = "ms #{encoded_key} #{value.bytesize} c"
+          cmd << ' b' if base64
+          cmd << " F#{bitflags}" if bitflags
+          cmd << " T#{ttl}" if ttl
+          cmd << " MS q\r\n"
+          write(cmd)
+          write(value)
+          write(TERMINATOR)
+        end
+        write_noop
+        response_processor.consume_all_responses_until_mn
+      end
+
+      # 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)
+        keys.each do |key|
+          encoded_key, base64 = KeyRegularizer.encode(key)
+          # Inline format: "md <key> [b] q\r\n"
+          write(base64 ? "md #{encoded_key} b q\r\n" : "md #{encoded_key} q\r\n")
+        end
+        write_noop
+        response_processor.consume_all_responses_until_mn
+      end
+
       require_relative 'key_regularizer'
       require_relative 'request_formatter'
       require_relative 'response_processor'

data/lib/dalli/socket.rb

@@ -106,14 +106,19 @@ module Dalli
       end
 
       # Detect and cache whether TCPSocket supports the connect_timeout: keyword argument.
-      # Returns false if TCPSocket#initialize has been monkey-patched by gems like
-      # socksify or resolv-replace, which don't support keyword arguments.
+      # Returns true for an unmodified TCPSocket on Ruby 3.0+, or for resolv-replace >= 0.2.0
+      # which forwards keyword arguments through its patch.
+      # Returns false when monkey-patched by gems like socksify or resolv-replace < 0.2.0.
       # rubocop:disable ThreadSafety/ClassInstanceVariable
       def self.supports_connect_timeout?
         return @supports_connect_timeout if defined?(@supports_connect_timeout)
 
-        @supports_connect_timeout = RUBY_VERSION >= '3.0' &&
-                                    ::TCPSocket.instance_method(:initialize).parameters == TCPSOCKET_NATIVE_PARAMETERS
+        @supports_connect_timeout = RUBY_ENGINE == 'ruby' && RUBY_VERSION >= '3.0' &&
+                                    ::TCPSocket.instance_method(:initialize).parameters.then do |params|
+                                      params == TCPSOCKET_NATIVE_PARAMETERS || params.any? do |type, _|
+                                        type == :keyrest
+                                      end
+                                    end
       end
       # rubocop:enable ThreadSafety/ClassInstanceVariable
 

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '5.0.1'
+  VERSION = '5.0.3'
 
   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.1
+  version: 5.0.3
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -87,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: High performance memcached client for Ruby
 test_files: []