dalli 5.0.2 → 5.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae3cbae2603955279bb78b75682ac1f56105d5ec2b2e0d464ab15255ed23369b
-  data.tar.gz: 2e5a3960e638293cfdf5663ef959d1ab9690620e09f0151a844cdeb9424cbf80
+  metadata.gz: b211a810c4d54d2d4d92203b390e8b29260f725e6dae699ca04703ac42cef8e9
+  data.tar.gz: 4d765c4491412ad4b9c8ab6038232436cae5824db2abaffc20119f2dfb7fa1ee
 SHA512:
-  metadata.gz: 243382482bc345bf982f2cb96fae28b974f37b2eee653a71c7f3a85518ef5acdbfda6f2fddacfa31da6252774000e11a1c96d3707d29808c636951d85ace17be
-  data.tar.gz: 5938608c26cd307e397cad4fdf6e2fda4519fdbd8df2b7d75352b691996fec4dca59632cc0053b8bf410612c8e6cada73ccad7baf5c000a183bd04bb196d056e
+  metadata.gz: a09168f456e5ce4691d0e24b128997c3f87bee7e046592a600490bc8e9526d1ce681d156fc9997c7045e623017ee0df1273d46c16656820b0f4933b8acc42cbb
+  data.tar.gz: 14e72c85d60582e03b19f04b4fd822a2e789fc6f780ae3f55944271dc25f0eeb7d6de0acade39bedf4729710731d273f8501f2078dc690fa3093926041b8d178

data/CHANGELOG.md

@@ -1,6 +1,41 @@
 Dalli Changelog
 =====================
 
+Unreleased
+==========
+
+5.0.4
+==========
+
+Bug fixes:
+
+- Fix `string_fastpath` flag collision with compression (#1099)
+  - `ValueSerializer::FLAG_UTF8` and `ValueCompressor::FLAG_COMPRESSED` were both `0x2`, causing `Dalli::UnmarshalError` on any UTF-8 string written with `string_fastpath: true` when compression is enabled, and silent encoding corruption for binary strings
+  - Introduces `Dalli::Flags` to centralise bit flag constants; UTF8 is reassigned to `0x4`
+  - Adds regression test covering short/long UTF-8, binary, and cross-client read scenarios
+  - Thanks to Jean Boussier and Mikael Henriksson for the fix and regression test
+
+- Fix client-level `string_fastpath: true` being silently ignored (#1101)
+  - `Dalli::Client.new(servers, string_fastpath: true)` had no effect; the fast path was only taken when `string_fastpath: true` was passed as a per-request option on each `set` call
+  - Per-request option continues to take precedence over the client-level setting in both directions
+
+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
 ==========
 

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

@@ -650,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/flags.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Dalli
+  module Flags
+    # https://www.hjp.at/zettel/m/memcached_flags.rxml
+    # Looks like most clients use bit 0 to indicate native language serialization
+    SERIALIZED = 0x1
+
+    # https://www.hjp.at/zettel/m/memcached_flags.rxml
+    # Looks like most clients use bit 1 to indicate gzip compression.
+    COMPRESSED = 0x2
+
+    UTF8 = 0x4
+  end
+end

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/value_compressor.rb

@@ -20,10 +20,6 @@ module Dalli
 
       OPTIONS = DEFAULTS.keys.freeze
 
-      # https://www.hjp.at/zettel/m/memcached_flags.rxml
-      # Looks like most clients use bit 1 to indicate gzip compression.
-      FLAG_COMPRESSED = 0x2
-
       def initialize(client_options)
         @compression_options =
           DEFAULTS.merge(client_options.slice(*OPTIONS))
@@ -32,13 +28,13 @@ module Dalli
       def store(value, req_options, bitflags)
         do_compress = compress_value?(value, req_options)
         store_value = do_compress ? compressor.compress(value) : value
-        bitflags |= FLAG_COMPRESSED if do_compress
+        bitflags |= Flags::COMPRESSED if do_compress
 
         [store_value, bitflags]
       end
 
       def retrieve(value, bitflags)
-        compressed = bitflags.anybits?(FLAG_COMPRESSED)
+        compressed = bitflags.anybits?(Flags::COMPRESSED)
         compressed ? compressor.decompress(value) : value
 
       # TODO: We likely want to move this rescue into the Dalli::Compressor / Dalli::GzipCompressor

data/lib/dalli/protocol/value_serializer.rb

@@ -10,16 +10,12 @@ module Dalli
     ##
     class ValueSerializer
       DEFAULTS = {
-        serializer: Marshal
+        serializer: Marshal,
+        string_fastpath: false
       }.freeze
 
       OPTIONS = DEFAULTS.keys.freeze
 
-      # https://www.hjp.at/zettel/m/memcached_flags.rxml
-      # Looks like most clients use bit 0 to indicate native language serialization
-      FLAG_SERIALIZED = 0x1
-      FLAG_UTF8 = 0x2
-
       # Class variable to track whether the Marshal warning has been logged
       @@marshal_warning_logged = false # rubocop:disable Style/ClassVars
 
@@ -35,18 +31,18 @@ module Dalli
         return store_raw(value, bitflags) if req_options&.dig(:raw)
         return store_string_fastpath(value, bitflags) if use_string_fastpath?(value, req_options)
 
-        [serialize_value(value), bitflags | FLAG_SERIALIZED]
+        [serialize_value(value), bitflags | Flags::SERIALIZED]
       end
 
       def retrieve(value, bitflags)
-        serialized = bitflags.anybits?(FLAG_SERIALIZED)
+        serialized = bitflags.anybits?(Flags::SERIALIZED)
         if serialized
           begin
             serializer.load(value)
           rescue StandardError
             raise UnmarshalError, 'Unable to unmarshal value'
           end
-        elsif bitflags.anybits?(FLAG_UTF8)
+        elsif bitflags.anybits?(Flags::UTF8)
           value.force_encoding(Encoding::UTF_8)
         else
           value
@@ -86,13 +82,15 @@ module Dalli
       def store_string_fastpath(value, bitflags)
         case value.encoding
         when Encoding::BINARY then [value, bitflags]
-        when Encoding::UTF_8 then [value, bitflags | FLAG_UTF8]
-        else [serialize_value(value), bitflags | FLAG_SERIALIZED]
+        when Encoding::UTF_8 then [value, bitflags | Flags::UTF8]
+        else [serialize_value(value), bitflags | Flags::SERIALIZED]
         end
       end
 
       def use_string_fastpath?(value, req_options)
-        req_options&.dig(:string_fastpath) && value.instance_of?(String)
+        fastpath = req_options&.dig(:string_fastpath)
+        fastpath = @serialization_options[:string_fastpath] if fastpath.nil?
+        fastpath && value.instance_of?(String)
       end
 
       def warn_if_marshal_default(protocol_options)

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.2'
+  VERSION = '5.0.4'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.6'
 end

data/lib/dalli.rb

@@ -61,6 +61,7 @@ end
 require_relative 'dalli/version'
 require_relative 'dalli/instrumentation'
 
+require_relative 'dalli/flags'
 require_relative 'dalli/compressor'
 require_relative 'dalli/client'
 require_relative 'dalli/key_manager'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 5.0.2
+  version: 5.0.4
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -40,6 +40,7 @@ files:
 - lib/dalli/cas/client.rb
 - lib/dalli/client.rb
 - lib/dalli/compressor.rb
+- lib/dalli/flags.rb
 - lib/dalli/instrumentation.rb
 - lib/dalli/key_manager.rb
 - lib/dalli/options.rb
@@ -87,7 +88,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: []