dalli 4.2.1 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 533bed149f02ca2960fa436d776b920cce0c95b841296c678a247141f8f7f239
-  data.tar.gz: cd3ca6a066d005fd177726b3c29ab460cba9d8ddc9937c1809053bf22b20e387
+  metadata.gz: e97e2a407956737b411c33627d1f771be758017b881c68fab66edee95dc3249e
+  data.tar.gz: b57638f133a592e9d57b71530bc925ff6589b27549e8785bc6c7f334906636ff
 SHA512:
-  metadata.gz: cc927b7e0f8906d326ede287b9d0fb9b3c1fb216b271350bc1e02cd4531b86d365e286da73cb8be9082646d747a494ccc0cdd81d0f9f053cf2439dd58bc40157
-  data.tar.gz: ce17e49264f9cf1550f709eb6d67a3f0f2f7fefaecfab04bf2c3f4356b7636ff95e2d6f76a44abcd8f0efae79ab8bbf21c5ba7d59a802735626af73e7bf0d777
+  metadata.gz: 7dd43e9e5b09b65174f2e46b84de40e4e5bcfae9645c6bb67017ca81a64d344e7345cc4bf685f11d4779aeaafd7c7163df5a67bf8410153034f4adf523385b95
+  data.tar.gz: b57506702dbdcb387490b3c0c56d2407aff4f0f789aec01e2b1a92c9f8d925a0225b8563e3dbc1ccf3c3ca72a25ca58f4199f1738d93bdf65a07893ed2930b6d

data/CHANGELOG.md

@@ -1,20 +1,35 @@
 Dalli Changelog
 =====================
 
-4.2.1
+4.3.0
 ==========
 
-OpenTelemetry:
+New Features:
+
+- Add `namespace_separator` option to customize the separator between namespace and key (#1019)
+  - Default is `:` for backward compatibility
+  - Must be a single non-alphanumeric character (e.g., `:`, `/`, `|`, `.`)
+  - Example: `Dalli::Client.new(servers, namespace: 'myapp', namespace_separator: '/')`
+
+Bug Fixes:
+
+- Fix architecture-dependent struct timeval packing for socket timeouts (#1034)
+  - Detects correct pack format for time_t and suseconds_t on each platform
+  - Fixes timeout issues on architectures with 64-bit time_t
+
+- Fix get_multi hanging with large key counts (#776, #941)
+  - Add interleaved read/write for pipelined gets to prevent socket buffer deadlock
+  - For batches over 10,000 keys per server, requests are now sent in chunks
+
+- **Breaking:** Enforce string-only values in raw mode (#1022)
+  - `set(key, nil, raw: true)` now raises `MarshalError` instead of storing `""`
+  - `set(key, 123, raw: true)` now raises `MarshalError` instead of storing `"123"`
+  - This matches the behavior of client-level `raw: true` mode
+  - To store counters, use string values: `set('counter', '0', raw: true)`
+
+CI:
 
-- Migrate to stable OTel semantic conventions
-  - `db.system` renamed to `db.system.name`
-  - `db.operation` renamed to `db.operation.name`
-  - `server.address` now contains hostname only; `server.port` is a separate integer attribute
-  - `get_with_metadata` and `fetch_with_lock` now include `server.address`/`server.port`
-- Add `db.query.text` span attribute with configurable modes
-  - `:otel_db_statement` option: `:include`, `:obfuscate`, or `nil` (default: omitted)
-- Add `peer.service` span attribute
-  - `:otel_peer_service` option for logical service naming
+- Add TruffleRuby to CI test matrix (#988)
 
 4.2.0
 ==========

data/README.md

@@ -31,6 +31,31 @@ Dalli supports two protocols for communicating with memcached:
 Dalli::Client.new('localhost:11211', protocol: :meta)
 ```
 
+## Configuration Options
+
+### Namespace
+
+Use namespaces to partition your cache and avoid key collisions between different applications or environments:
+
+```ruby
+# All keys will be prefixed with "myapp:"
+Dalli::Client.new('localhost:11211', namespace: 'myapp')
+
+# Dynamic namespace using a Proc (evaluated on each operation)
+Dalli::Client.new('localhost:11211', namespace: -> { "tenant:#{Thread.current[:tenant_id]}" })
+```
+
+### Namespace Separator
+
+By default, the namespace and key are joined with a colon (`:`). You can customize this with the `namespace_separator` option:
+
+```ruby
+# Keys will be prefixed with "myapp/" instead of "myapp:"
+Dalli::Client.new('localhost:11211', namespace: 'myapp', namespace_separator: '/')
+```
+
+The separator must be a single non-alphanumeric character. Valid examples: `:`, `/`, `|`, `.`, `-`, `_`, `#`
+
 ## Security Note
 
 By default, Dalli uses Ruby's Marshal for serialization. Deserializing untrusted data with Marshal can lead to remote code execution. If you cache user-controlled data, consider using a safer serializer:

data/lib/dalli/client.rb

@@ -50,10 +50,6 @@ module Dalli
     #                   useful for injecting a FIPS compliant hash object.
     # - :protocol - one of either :binary or :meta, defaulting to :binary.  This sets the protocol that Dalli uses
     #               to communicate with memcached.
-    # - :otel_db_statement - controls the +db.query.text+ span attribute when OpenTelemetry is loaded.
-    #                        +:include+ logs the full operation and key(s), +:obfuscate+ replaces keys with "?",
-    #                        +nil+ (default) omits the attribute entirely.
-    # - :otel_peer_service - when set, adds a +peer.service+ span attribute with this value for logical service naming.
     #
     def initialize(servers = nil, options = {})
       @normalized_servers = ::Dalli::ServersArgNormalizer.normalize_servers(servers)
@@ -138,8 +134,8 @@ module Dalli
       key = key.to_s
       key = @key_manager.validate_key(key)
 
-      server = ring.server_for_key(key)
-      Instrumentation.trace('get_with_metadata', trace_attrs('get_with_metadata', key, server)) do
+      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
@@ -241,8 +237,7 @@ module Dalli
       key = key.to_s
       key = @key_manager.validate_key(key)
 
-      server = ring.server_for_key(key)
-      Instrumentation.trace('fetch_with_lock', trace_attrs('fetch_with_lock', key, server)) do
+      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
@@ -323,7 +318,10 @@ module Dalli
     def set_multi(hash, ttl = nil, req_options = nil)
       return if hash.empty?
 
-      Instrumentation.trace('set_multi', multi_trace_attrs('set_multi', hash.size, hash.keys)) do
+      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
@@ -380,7 +378,10 @@ module Dalli
     def delete_multi(keys)
       return if keys.empty?
 
-      Instrumentation.trace('delete_multi', multi_trace_attrs('delete_multi', keys.size, keys)) do
+      Instrumentation.trace('delete_multi', {
+                              'db.operation' => 'delete_multi',
+                              'db.memcached.key_count' => keys.size
+                            }) do
         pipelined_deleter.process(keys)
       end
     end
@@ -547,30 +548,7 @@ module Dalli
     end
 
     def get_multi_attributes(keys)
-      multi_trace_attrs('get_multi', keys.size, keys)
-    end
-
-    def trace_attrs(operation, key, server)
-      attrs = { 'db.operation.name' => operation, 'server.address' => server.hostname }
-      attrs['server.port'] = server.port if server.socket_type == :tcp
-      attrs['peer.service'] = @options[:otel_peer_service] if @options[:otel_peer_service]
-      add_query_text(attrs, operation, key)
-    end
-
-    def multi_trace_attrs(operation, key_count, keys)
-      attrs = { 'db.operation.name' => operation, 'db.memcached.key_count' => key_count }
-      attrs['peer.service'] = @options[:otel_peer_service] if @options[:otel_peer_service]
-      add_query_text(attrs, operation, keys)
-    end
-
-    def add_query_text(attrs, operation, key_or_keys)
-      case @options[:otel_db_statement]
-      when :include
-        attrs['db.query.text'] = "#{operation} #{Array(key_or_keys).join(' ')}"
-      when :obfuscate
-        attrs['db.query.text'] = "#{operation} ?"
-      end
-      attrs
+      { 'db.operation' => 'get_multi', 'db.memcached.key_count' => keys.size }
     end
 
     def check_positive!(amt)
@@ -638,7 +616,10 @@ 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
+      Instrumentation.trace(op.to_s, {
+                              'db.operation' => op.to_s,
+                              'server.address' => server.name
+                            }) do
         server.request(op, key, *args)
       end
     rescue NetworkError => e

data/lib/dalli/instrumentation.rb

@@ -8,36 +8,25 @@ module Dalli
   # 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.
   #
-  # Dalli 4.2.1 uses the stable OTel semantic conventions for database spans.
-  #
   # == Span Attributes
   #
   # All spans include the following default attributes:
-  # - +db.system.name+ - Always "memcached"
+  # - +db.system+ - Always "memcached"
   #
   # Single-key operations (+get+, +set+, +delete+, +incr+, +decr+, etc.) add:
-  # - +db.operation.name+ - The operation name (e.g., "get", "set")
-  # - +server.address+ - The server hostname (e.g., "localhost")
-  # - +server.port+ - The server port as an integer (e.g., 11211); omitted for Unix sockets
+  # - +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.name+ - "get_multi"
+  # - +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.name+ - The operation name
+  # - +db.operation+ - The operation name
   # - +db.memcached.key_count+ - Number of keys in the operation
   #
-  # == Optional Attributes
-  #
-  # - +db.query.text+ - The operation and key(s), controlled by the +:otel_db_statement+ client option:
-  #   - +:include+ - Full text (e.g., "get mykey")
-  #   - +:obfuscate+ - Obfuscated (e.g., "get ?")
-  #   - +nil+ (default) - Attribute omitted
-  # - +peer.service+ - Logical service name, set via the +:otel_peer_service+ client option
-  #
   # == Error Handling
   #
   # When an exception occurs during a traced operation:
@@ -51,8 +40,8 @@ module Dalli
   ##
   module Instrumentation
     # Default attributes included on all memcached spans.
-    # @return [Hash] frozen hash with 'db.system.name' => 'memcached'
-    DEFAULT_ATTRIBUTES = { 'db.system.name' => 'memcached' }.freeze
+    # @return [Hash] frozen hash with 'db.system' => 'memcached'
+    DEFAULT_ATTRIBUTES = { 'db.system' => 'memcached' }.freeze
 
     class << self
       # Returns the OpenTelemetry tracer if available, nil otherwise.
@@ -86,16 +75,15 @@ module Dalli
       # @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.name' - the operation name
-      #   - 'server.address' - the server hostname
-      #   - 'server.port' - the server port (integer)
+      #   - '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.name' => 'set', 'server.address' => 'localhost', 'server.port' => 11211 }) do
+      #   trace('set', { 'db.operation' => 'set', 'server.address' => 'localhost:11211' }) do
       #     server.set(key, value, ttl)
       #   end
       #
@@ -126,7 +114,7 @@ module Dalli
       # @raise [StandardError] re-raises any exception from the block
       #
       # @example Recording hit/miss metrics after get_multi
-      #   trace_with_result('get_multi', { 'db.operation.name' => 'get_multi' }) do |span|
+      #   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)

data/lib/dalli/key_manager.rb

@@ -12,7 +12,7 @@ module Dalli
   class KeyManager
     MAX_KEY_LENGTH = 250
 
-    NAMESPACE_SEPARATOR = ':'
+    DEFAULT_NAMESPACE_SEPARATOR = ':'
 
     # This is a hard coded md5 for historical reasons
     TRUNCATED_KEY_SEPARATOR = ':md5:'
@@ -21,19 +21,26 @@ module Dalli
     TRUNCATED_KEY_TARGET_SIZE = 249
 
     DEFAULTS = {
-      digest_class: ::Digest::MD5
+      digest_class: ::Digest::MD5,
+      namespace_separator: DEFAULT_NAMESPACE_SEPARATOR
     }.freeze
 
-    OPTIONS = %i[digest_class namespace].freeze
+    OPTIONS = %i[digest_class namespace namespace_separator].freeze
 
-    attr_reader :namespace
+    attr_reader :namespace, :namespace_separator
+
+    # Valid separators: non-alphanumeric, single printable ASCII characters
+    # Excludes: alphanumerics, whitespace, control characters
+    VALID_NAMESPACE_SEPARATORS = /\A[^a-zA-Z0-9\s\x00-\x1F\x7F]\z/
 
     def initialize(client_options)
       @key_options =
         DEFAULTS.merge(client_options.slice(*OPTIONS))
       validate_digest_class_option(@key_options)
+      validate_namespace_separator_option(@key_options)
 
       @namespace = namespace_from_options
+      @namespace_separator = @key_options[:namespace_separator]
     end
 
     ##
@@ -61,7 +68,7 @@ module Dalli
     def key_with_namespace(key)
       return key if namespace.nil?
 
-      "#{evaluate_namespace}#{NAMESPACE_SEPARATOR}#{key}"
+      "#{evaluate_namespace}#{namespace_separator}#{key}"
     end
 
     def key_without_namespace(key)
@@ -75,9 +82,9 @@ module Dalli
     end
 
     def namespace_regexp
-      return /\A#{Regexp.escape(evaluate_namespace)}:/ if namespace.is_a?(Proc)
+      return /\A#{Regexp.escape(evaluate_namespace)}#{Regexp.escape(namespace_separator)}/ if namespace.is_a?(Proc)
 
-      @namespace_regexp ||= /\A#{Regexp.escape(namespace)}:/ unless namespace.nil?
+      @namespace_regexp ||= /\A#{Regexp.escape(namespace)}#{Regexp.escape(namespace_separator)}/ unless namespace.nil?
     end
 
     def validate_digest_class_option(opts)
@@ -86,6 +93,14 @@ module Dalli
       raise ArgumentError, 'The digest_class object must respond to the hexdigest method'
     end
 
+    def validate_namespace_separator_option(opts)
+      sep = opts[:namespace_separator]
+      return if VALID_NAMESPACE_SEPARATORS.match?(sep)
+
+      raise ArgumentError,
+            'namespace_separator must be a single non-alphanumeric character (e.g., ":", "/", "|")'
+    end
+
     def namespace_from_options
       raw_namespace = @key_options[:namespace]
       return nil unless raw_namespace

data/lib/dalli/pipelined_getter.rb

@@ -7,6 +7,13 @@ module Dalli
   # Contains logic for the pipelined gets implemented by the client.
   ##
   class PipelinedGetter
+    # For large batches, interleave sends with response draining to prevent
+    # socket buffer deadlock. Only kicks in above this threshold.
+    INTERLEAVE_THRESHOLD = 10_000
+
+    # Number of keys to send before draining responses during interleaved mode
+    CHUNK_SIZE = 10_000
+
     def initialize(ring, key_manager)
       @ring = ring
       @key_manager = key_manager
@@ -19,8 +26,14 @@ module Dalli
       return {} if keys.empty?
 
       @ring.lock do
+        # Stores partial results collected during interleaved send phase
+        @partial_results = {}
         servers = setup_requests(keys)
         start_time = Time.now
+
+        # First yield any partial results collected during interleaved send
+        yield_partial_results(&block)
+
         servers = fetch_responses(servers, start_time, @ring.socket_timeout, &block) until servers.empty?
       end
     rescue NetworkError => e
@@ -29,6 +42,15 @@ module Dalli
       retry
     end
 
+    private
+
+    def yield_partial_results
+      @partial_results.each_pair do |key, value_list|
+        yield @key_manager.key_without_namespace(key), value_list
+      end
+      @partial_results.clear
+    end
+
     def setup_requests(keys)
       groups = groups_for_keys(keys)
       make_getkq_requests(groups)
@@ -47,7 +69,14 @@ module Dalli
     ##
     def make_getkq_requests(groups)
       groups.each do |server, keys_for_server|
-        server.request(:pipelined_get, keys_for_server)
+        if keys_for_server.size <= INTERLEAVE_THRESHOLD
+          # Small batch - send all at once (existing behavior)
+          server.request(:pipelined_get, keys_for_server)
+        else
+          # Large batch - interleave sends with response draining
+          # Pass @partial_results directly to avoid hash allocation/merge overhead
+          server.request(:pipelined_get_interleaved, keys_for_server, CHUNK_SIZE, @partial_results)
+        end
       rescue DalliError, NetworkError => e
         Dalli.logger.debug { e.inspect }
         Dalli.logger.debug { "unable to get keys for server #{server.name}" }

data/lib/dalli/protocol/base.rb

@@ -42,8 +42,8 @@ module Dalli
           @connection_manager.start_request!
           response = send(opkey, *args)
 
-          # pipelined_get emit query but doesn't read the response(s)
-          @connection_manager.finish_request! unless opkey == :pipelined_get
+          # 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)
 
           response
         rescue Dalli::MarshalError => e
@@ -81,7 +81,9 @@ module Dalli
       def pipeline_response_setup
         verify_pipelined_state(:getkq)
         write_noop
-        response_buffer.reset
+        # Use ensure_ready instead of reset to preserve any data already buffered
+        # during interleaved pipelined get draining
+        response_buffer.ensure_ready
       end
 
       # Attempt to receive and parse as many key/value pairs as possible
@@ -220,6 +222,11 @@ module Dalli
       end
 
       def pipelined_get(keys)
+        # Clear buffer to remove any stale data from interrupted operations.
+        # Use clear (not reset) to keep pipeline_complete? = true, which is
+        # the expected state before pipeline_response_setup is called.
+        response_buffer.clear
+
         req = +''
         keys.each do |key|
           req << quiet_get_request(key)
@@ -228,6 +235,51 @@ module Dalli
         write(req)
       end
 
+      # For large batches, interleave writing requests with draining responses.
+      # This prevents socket buffer deadlock when sending many keys.
+      # Populates the provided results hash with any responses drained during send.
+      def pipelined_get_interleaved(keys, chunk_size, results)
+        # Initialize the response buffer for draining during send phase
+        response_buffer.ensure_ready
+
+        keys.each_slice(chunk_size) do |chunk|
+          # Build and write this chunk of requests
+          req = +''
+          chunk.each do |key|
+            req << quiet_get_request(key)
+          end
+          write(req)
+          @connection_manager.flush
+
+          # Drain any available responses directly into results hash
+          drain_pipeline_responses(results)
+        end
+      end
+
+      # Non-blocking read and processing of any available pipeline responses.
+      # Used during interleaved pipelined gets to prevent buffer deadlock.
+      # Populates the provided results hash directly to avoid allocation overhead.
+      def drain_pipeline_responses(results)
+        return unless connected?
+
+        # Non-blocking check if socket has data available
+        return unless sock.wait_readable(0)
+
+        # Read available data without blocking
+        response_buffer.read
+
+        # Process any complete responses in the buffer
+        loop do
+          status, cas, key, value = response_buffer.process_single_getk_response
+          break if status.nil? # No complete response available
+
+          results[key] = [value, cas] unless key.nil?
+        end
+      rescue SystemCallError, Dalli::NetworkError
+        # Ignore errors during drain - they'll be handled in fetch_responses
+        nil
+      end
+
       def response_buffer
         @response_buffer ||= ResponseBuffer.new(@connection_manager, response_processor)
       end

data/lib/dalli/protocol/response_buffer.rb

@@ -41,6 +41,15 @@ module Dalli
         @buffer = ''.b
       end
 
+      # Ensures the buffer is initialized for reading without discarding
+      # existing data. Used by interleaved pipelined get which may have
+      # already buffered partial responses during the send phase.
+      def ensure_ready
+        return if in_progress?
+
+        @buffer = ''.b
+      end
+
       # Clear the internal response buffer
       def clear
         @buffer = nil

data/lib/dalli/protocol/value_serializer.rb

@@ -32,22 +32,8 @@ module Dalli
       end
 
       def store(value, req_options, bitflags)
-        if req_options
-          return [value.to_s, bitflags] if req_options[:raw]
-
-          # If the value is a simple string, going through serialization is costly
-          # for no benefit other than preserving encoding.
-          # Assuming most strings are either UTF-8 or BINARY we can just store
-          # that information in the bitflags.
-          if req_options[:string_fastpath] && value.instance_of?(String)
-            case value.encoding
-            when Encoding::BINARY
-              return [value, bitflags]
-            when Encoding::UTF_8
-              return [value, bitflags | FLAG_UTF8]
-            end
-          end
-        end
+        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]
       end
@@ -85,6 +71,30 @@ module Dalli
 
       private
 
+      def store_raw(value, bitflags)
+        unless value.is_a?(String)
+          raise Dalli::MarshalError, "Dalli raw mode requires string values, got: #{value.class}"
+        end
+
+        [value, bitflags]
+      end
+
+      # If the value is a simple string, going through serialization is costly
+      # for no benefit other than preserving encoding.
+      # Assuming most strings are either UTF-8 or BINARY we can just store
+      # that information in the bitflags.
+      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]
+        end
+      end
+
+      def use_string_fastpath?(value, req_options)
+        req_options&.dig(:string_fastpath) && value.instance_of?(String)
+      end
+
       def warn_if_marshal_default(protocol_options)
         return if protocol_options.key?(:serializer)
         return if @@marshal_warning_logged

data/lib/dalli/socket.rb

@@ -138,16 +138,40 @@ module Dalli
         return unless options[:socket_timeout]
 
         if sock.respond_to?(:timeout=)
+          # Ruby 3.2+ has IO#timeout for reliable cross-platform timeout handling
           sock.timeout = options[:socket_timeout]
         else
+          # Ruby 3.1 fallback using socket options
+          # struct timeval has architecture-dependent sizes (time_t, suseconds_t)
           seconds, fractional = options[:socket_timeout].divmod(1)
-          timeval = [seconds, fractional * 1_000_000].pack('l_2')
+          microseconds = (fractional * 1_000_000).to_i
+          timeval = pack_timeval(sock, seconds, microseconds)
 
           sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVTIMEO, timeval)
           sock.setsockopt(::Socket::SOL_SOCKET, ::Socket::SO_SNDTIMEO, timeval)
         end
       end
 
+      # Pack formats for struct timeval across architectures.
+      # Uses fixed-size formats for JRuby compatibility (JRuby doesn't support _ modifier on q).
+      # - ll: 8 bytes (32-bit time_t, 32-bit suseconds_t)
+      # - qq: 16 bytes (64-bit time_t, 64-bit suseconds_t or padded 32-bit)
+      TIMEVAL_PACK_FORMATS = %w[ll qq].freeze
+      TIMEVAL_TEST_VALUES = [0, 0].freeze
+
+      # Detect and cache the correct pack format for struct timeval on this platform.
+      # Different architectures have different sizes for time_t and suseconds_t.
+      def self.timeval_pack_format(sock)
+        @timeval_pack_format ||= begin
+          expected_size = sock.getsockopt(::Socket::SOL_SOCKET, ::Socket::SO_RCVTIMEO).data.bytesize
+          TIMEVAL_PACK_FORMATS.find { |fmt| TIMEVAL_TEST_VALUES.pack(fmt).bytesize == expected_size } || 'll'
+        end
+      end
+
+      def self.pack_timeval(sock, seconds, microseconds)
+        [seconds, microseconds].pack(timeval_pack_format(sock))
+      end
+
       def self.wrapping_ssl_socket(tcp_socket, host, ssl_context)
         ssl_socket = Dalli::Socket::SSLSocket.new(tcp_socket, ssl_context)
         ssl_socket.hostname = host

data/lib/dalli/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Dalli
-  VERSION = '4.2.1'
+  VERSION = '4.3.0'
 
   MIN_SUPPORTED_MEMCACHED_VERSION = '1.4'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 4.2.1
+  version: 4.3.0
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -93,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.4
 specification_version: 4
 summary: High performance memcached client for Ruby
 test_files: []