dalli 4.1.0 → 4.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e342d39d58d552607783486a9c9f0ffa23d9c479079c62cb760ec84a97d064da
-  data.tar.gz: 1ae923ede204d0a3e82426404cfb4882f4414a12cb351cf3d04b9ef8653051ce
+  metadata.gz: 533bed149f02ca2960fa436d776b920cce0c95b841296c678a247141f8f7f239
+  data.tar.gz: cd3ca6a066d005fd177726b3c29ab460cba9d8ddc9937c1809053bf22b20e387
 SHA512:
-  metadata.gz: aeb1bec84092f4e07db884b415d6b25375dc995fff04cc58a1764d9ad0937986ba7ff5db5a665a831bd8ab488b3fa4868fce79834e93a26848bc37ac1c9f9855
-  data.tar.gz: 8c5a4e21f4b0a86279bf28edc729c0a1981964438342117f3bc180d15d5cdfc93e395913267db7af66b3907416051be7629e687708c163f4d4015d4e2a768508
+  metadata.gz: cc927b7e0f8906d326ede287b9d0fb9b3c1fb216b271350bc1e02cd4531b86d365e286da73cb8be9082646d747a494ccc0cdd81d0f9f053cf2439dd58bc40157
+  data.tar.gz: ce17e49264f9cf1550f709eb6d67a3f0f2f7fefaecfab04bf2c3f4356b7636ff95e2d6f76a44abcd8f0efae79ab8bbf21c5ba7d59a802735626af73e7bf0d777

data/CHANGELOG.md

@@ -1,6 +1,41 @@
 Dalli Changelog
 =====================
 
+4.2.1
+==========
+
+OpenTelemetry:
+
+- 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
+
+4.2.0
+==========
+
+Performance:
+
+- Buffered I/O: Use `socket.sync = false` with explicit flush to reduce syscalls for pipelined operations
+- get_multi optimizations: Use Set for O(1) server tracking lookups
+- Raw mode optimization: Skip bitflags request in meta protocol when in raw mode (saves 2 bytes per request)
+
+New Features:
+
+- OpenTelemetry tracing support: Automatically instruments operations when OpenTelemetry SDK is present
+  - Zero overhead when OpenTelemetry is not loaded
+  - Traces `get`, `set`, `delete`, `get_multi`, `set_multi`, `delete_multi`, `get_with_metadata`, and `fetch_with_lock`
+  - Spans include `db.system: memcached` and `db.operation` attributes
+  - Single-key operations include `server.address` attribute
+  - Multi-key operations include `db.memcached.key_count` attribute
+  - `get_multi` spans include `db.memcached.hit_count` and `db.memcached.miss_count` for cache efficiency metrics
+  - Exceptions are automatically recorded on spans with error status
+
 4.1.0
 ==========
 

data/README.md

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

data/lib/dalli/client.rb

@@ -50,6 +50,10 @@ 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)
@@ -135,7 +139,9 @@ module Dalli
       key = @key_manager.validate_key(key)
 
       server = ring.server_for_key(key)
-      server.request(:meta_get, key, options)
+      Instrumentation.trace('get_with_metadata', trace_attrs('get_with_metadata', key, server)) do
+        server.request(:meta_get, key, options)
+      end
     rescue NetworkError => e
       Dalli.logger.debug { e.inspect }
       Dalli.logger.debug { 'retrying get_with_metadata with new server' }
@@ -146,20 +152,19 @@ module Dalli
     # Fetch multiple keys efficiently.
     # If a block is given, yields key/value pairs one at a time.
     # Otherwise returns a hash of { 'key' => 'value', 'key2' => 'value1' }
+    # rubocop:disable Style/ExplicitBlockArgument
     def get_multi(*keys)
       keys.flatten!
       keys.compact!
-
       return {} if keys.empty?
 
       if block_given?
-        pipelined_getter.process(keys) { |k, data| yield k, data.first }
+        get_multi_yielding(keys) { |k, v| yield k, v }
       else
-        {}.tap do |hash|
-          pipelined_getter.process(keys) { |k, data| hash[k] = data.first }
-        end
+        get_multi_hash(keys)
       end
     end
+    # rubocop:enable Style/ExplicitBlockArgument
 
     ##
     # Fetch multiple keys efficiently, including available metadata such as CAS.
@@ -228,7 +233,7 @@ module Dalli
     #     expensive_operation
     #   end
     #
-    def fetch_with_lock(key, ttl: nil, lock_ttl: 30, recache_threshold: nil, req_options: nil)
+    def fetch_with_lock(key, ttl: nil, lock_ttl: 30, recache_threshold: nil, req_options: nil, &block)
       raise ArgumentError, 'Block is required for fetch_with_lock' unless block_given?
 
       raise_unless_meta_protocol!
@@ -237,20 +242,8 @@ module Dalli
       key = @key_manager.validate_key(key)
 
       server = ring.server_for_key(key)
-      result = server.request(:meta_get, key, {
-                                vivify_ttl: lock_ttl,
-                                recache_ttl: recache_threshold
-                              })
-
-      if result[:won_recache]
-        # This client won the race - regenerate the value
-        new_val = yield
-        set(key, new_val, ttl_or_default(ttl), req_options)
-        new_val
-      else
-        # Another client is regenerating, or value exists and isn't stale
-        # Return the existing value
-        result[:value]
+      Instrumentation.trace('fetch_with_lock', trace_attrs('fetch_with_lock', key, server)) do
+        fetch_with_lock_request(key, ttl, lock_ttl, recache_threshold, req_options, &block)
       end
     rescue NetworkError => e
       Dalli.logger.debug { e.inspect }
@@ -330,7 +323,9 @@ module Dalli
     def set_multi(hash, ttl = nil, req_options = nil)
       return if hash.empty?
 
-      pipelined_setter.process(hash, ttl_or_default(ttl), req_options)
+      Instrumentation.trace('set_multi', multi_trace_attrs('set_multi', hash.size, hash.keys)) do
+        pipelined_setter.process(hash, ttl_or_default(ttl), req_options)
+      end
     end
 
     ##
@@ -385,7 +380,9 @@ module Dalli
     def delete_multi(keys)
       return if keys.empty?
 
-      pipelined_deleter.process(keys)
+      Instrumentation.trace('delete_multi', multi_trace_attrs('delete_multi', keys.size, keys)) do
+        pipelined_deleter.process(keys)
+      end
     end
 
     ##
@@ -517,6 +514,65 @@ module Dalli
 
     private
 
+    # Records hit/miss metrics on a span for cache observability.
+    # @param span [OpenTelemetry::Trace::Span, nil] the span to record on
+    # @param key_count [Integer] total keys requested
+    # @param hit_count [Integer] keys found in cache
+    def record_hit_miss_metrics(span, key_count, hit_count)
+      return unless span
+
+      span.set_attribute('db.memcached.hit_count', hit_count)
+      span.set_attribute('db.memcached.miss_count', key_count - hit_count)
+    end
+
+    def get_multi_yielding(keys)
+      Instrumentation.trace_with_result('get_multi', get_multi_attributes(keys)) do |span|
+        hit_count = 0
+        pipelined_getter.process(keys) do |k, data|
+          hit_count += 1
+          yield k, data.first
+        end
+        record_hit_miss_metrics(span, keys.size, hit_count)
+        nil
+      end
+    end
+
+    def get_multi_hash(keys)
+      Instrumentation.trace_with_result('get_multi', get_multi_attributes(keys)) do |span|
+        {}.tap do |hash|
+          pipelined_getter.process(keys) { |k, data| hash[k] = data.first }
+          record_hit_miss_metrics(span, keys.size, hash.size)
+        end
+      end
+    end
+
+    def get_multi_attributes(keys)
+      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
+    end
+
     def check_positive!(amt)
       raise ArgumentError, "Positive values only: #{amt}" if amt.negative?
     end
@@ -529,6 +585,17 @@ module Dalli
       perform(:set, key, newvalue, ttl_or_default(ttl), cas, req_options)
     end
 
+    def fetch_with_lock_request(key, ttl, lock_ttl, recache_threshold, req_options)
+      server = ring.server_for_key(key)
+      result = server.request(:meta_get, key, { vivify_ttl: lock_ttl, recache_ttl: recache_threshold })
+
+      return result[:value] unless result[:won_recache]
+
+      new_val = yield
+      set(key, new_val, ttl_or_default(ttl), req_options)
+      new_val
+    end
+
     ##
     # Uses the argument TTL or the client-wide default.  Ensures
     # that the value is an integer
@@ -571,7 +638,9 @@ module Dalli
       key = @key_manager.validate_key(key)
 
       server = ring.server_for_key(key)
-      server.request(op, key, *args)
+      Instrumentation.trace(op.to_s, trace_attrs(op.to_s, key, server)) do
+        server.request(op, key, *args)
+      end
     rescue NetworkError => e
       Dalli.logger.debug { e.inspect }
       Dalli.logger.debug { 'retrying request with new server' }

data/lib/dalli/instrumentation.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Dalli
+  ##
+  # Instrumentation support for Dalli. Provides hooks for distributed tracing
+  # via OpenTelemetry when the SDK is available.
+  #
+  # When OpenTelemetry is loaded, Dalli automatically creates spans for cache operations.
+  # When OpenTelemetry is not available, all tracing methods are no-ops with zero overhead.
+  #
+  # 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"
+  #
+  # 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
+  #
+  # Multi-key operations (+get_multi+) add:
+  # - +db.operation.name+ - "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.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:
+  # - The exception is recorded on the span via +record_exception+
+  # - The span status is set to error with the exception message
+  # - The exception is re-raised to the caller
+  #
+  # @example Checking if tracing is enabled
+  #   Dalli::Instrumentation.enabled? # => true if OpenTelemetry is loaded
+  #
+  ##
+  module Instrumentation
+    # Default attributes included on all memcached spans.
+    # @return [Hash] frozen hash with 'db.system.name' => 'memcached'
+    DEFAULT_ATTRIBUTES = { 'db.system.name' => 'memcached' }.freeze
+
+    class << self
+      # Returns the OpenTelemetry tracer if available, nil otherwise.
+      #
+      # The tracer is cached after first lookup for performance.
+      # Uses the library name 'dalli' and current Dalli::VERSION.
+      #
+      # @return [OpenTelemetry::Trace::Tracer, nil] the tracer or nil if OTel unavailable
+      def tracer
+        return @tracer if defined?(@tracer)
+
+        @tracer = (OpenTelemetry.tracer_provider.tracer('dalli', Dalli::VERSION) if defined?(OpenTelemetry))
+      end
+
+      # Returns true if instrumentation is enabled (OpenTelemetry SDK is available).
+      #
+      # @return [Boolean] true if tracing is active, false otherwise
+      def enabled?
+        !tracer.nil?
+      end
+
+      # Wraps a block with a span if instrumentation is enabled.
+      #
+      # Creates a client span with the given name and attributes merged with
+      # DEFAULT_ATTRIBUTES. The block is executed within the span context.
+      # If an exception occurs, it is recorded on the span before re-raising.
+      #
+      # When tracing is disabled (OpenTelemetry not loaded), this method
+      # simply yields directly with zero overhead.
+      #
+      # @param name [String] the span name (e.g., 'get', 'set', 'delete')
+      # @param attributes [Hash] span attributes to merge with defaults.
+      #   Common attributes include:
+      #   - 'db.operation.name' - the operation name
+      #   - 'server.address' - the server hostname
+      #   - 'server.port' - the server port (integer)
+      #   - '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
+      #     server.set(key, value, ttl)
+      #   end
+      #
+      def trace(name, attributes = {})
+        return yield unless enabled?
+
+        tracer.in_span(name, attributes: DEFAULT_ATTRIBUTES.merge(attributes), kind: :client) do |span|
+          yield
+        rescue StandardError => e
+          span.record_exception(e)
+          span.status = OpenTelemetry::Trace::Status.error(e.message)
+          raise
+        end
+      end
+
+      # Like trace, but yields the span to allow adding attributes after execution.
+      #
+      # This is useful for operations where metrics are only known after the
+      # operation completes, such as get_multi where hit/miss counts depend
+      # on the cache response.
+      #
+      # When tracing is disabled, yields nil as the span argument.
+      #
+      # @param name [String] the span name (e.g., 'get_multi')
+      # @param attributes [Hash] initial span attributes to merge with defaults
+      # @yield [OpenTelemetry::Trace::Span, nil] the span object, or nil if disabled
+      # @return [Object] the result of the block
+      # @raise [StandardError] re-raises any exception from the block
+      #
+      # @example Recording hit/miss metrics after get_multi
+      #   trace_with_result('get_multi', { 'db.operation.name' => 'get_multi' }) do |span|
+      #     results = fetch_from_cache(keys)
+      #     if span
+      #       span.set_attribute('db.memcached.hit_count', results.size)
+      #       span.set_attribute('db.memcached.miss_count', keys.size - results.size)
+      #     end
+      #     results
+      #   end
+      #
+      def trace_with_result(name, attributes = {})
+        return yield(nil) unless enabled?
+
+        tracer.in_span(name, attributes: DEFAULT_ATTRIBUTES.merge(attributes), kind: :client) do |span|
+          yield(span)
+        rescue StandardError => e
+          span.record_exception(e)
+          span.status = OpenTelemetry::Trace::Status.error(e.message)
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/dalli/pipelined_getter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module Dalli
   ##
   # Contains logic for the pipelined gets implemented by the client.
@@ -57,7 +59,7 @@ module Dalli
     # our set, sending the noop to terminate the set of queries.
     ##
     def finish_queries(servers)
-      deleted = []
+      deleted = Set.new
 
       servers.each do |server|
         next unless server.connected?
@@ -67,7 +69,7 @@ module Dalli
         rescue Dalli::NetworkError
           raise
         rescue Dalli::DalliError
-          deleted.append(server)
+          deleted << server
         end
       end
 
@@ -94,7 +96,7 @@ module Dalli
 
     def fetch_responses(servers, start_time, timeout, &block)
       # Remove any servers which are not connected
-      servers.delete_if { |s| !s.connected? }
+      servers.select!(&:connected?)
       return [] if servers.empty?
 
       time_left = remaining_time(start_time, timeout)

data/lib/dalli/protocol/base.rb

@@ -23,10 +23,17 @@ module Dalli
       def initialize(attribs, client_options = {})
         hostname, port, socket_type, @weight, user_creds = ServerConfigParser.parse(attribs)
         @options = client_options.merge(user_creds)
-        @value_marshaller = client_options[:raw] ? StringMarshaller.new(@options) : ValueMarshaller.new(@options)
+        @raw_mode = client_options[:raw]
+        @value_marshaller = @raw_mode ? StringMarshaller.new(@options) : ValueMarshaller.new(@options)
         @connection_manager = ConnectionManager.new(hostname, port, socket_type, @options)
       end
 
+      # Returns true if client is in raw mode (no serialization/compression).
+      # In raw mode, we can skip requesting bitflags from the server.
+      def raw_mode?
+        @raw_mode
+      end
+
       # Chokepoint method for error handling and ensuring liveness
       def request(opkey, *args)
         verify_state(opkey)

data/lib/dalli/protocol/binary.rb

@@ -22,6 +22,7 @@ module Dalli
       def get(key, options = nil)
         req = RequestFormatter.standard_request(opkey: :get, key: key)
         write(req)
+        @connection_manager.flush
         response_processor.get(cache_nils: cache_nils?(options))
       end
 
@@ -33,12 +34,14 @@ module Dalli
         ttl = TtlSanitizer.sanitize(ttl)
         req = RequestFormatter.standard_request(opkey: :gat, key: key, ttl: ttl)
         write(req)
+        @connection_manager.flush
         response_processor.get(cache_nils: cache_nils?(options))
       end
 
       def touch(key, ttl)
         ttl = TtlSanitizer.sanitize(ttl)
         write(RequestFormatter.standard_request(opkey: :touch, key: key, ttl: ttl))
+        @connection_manager.flush
         response_processor.generic_response
       end
 
@@ -47,6 +50,7 @@ module Dalli
       def cas(key)
         req = RequestFormatter.standard_request(opkey: :get, key: key)
         write(req)
+        @connection_manager.flush
         response_processor.data_cas_response
       end
 
@@ -81,6 +85,7 @@ module Dalli
                                                 value: value, bitflags: bitflags,
                                                 ttl: ttl, cas: cas)
         write(req)
+        @connection_manager.flush unless quiet?
         response_processor.storage_response unless quiet?
       end
       # rubocop:enable Metrics/ParameterLists
@@ -97,6 +102,7 @@ module Dalli
 
       def write_append_prepend(opkey, key, value)
         write(RequestFormatter.standard_request(opkey: opkey, key: key, value: value))
+        @connection_manager.flush unless quiet?
         response_processor.no_body_response unless quiet?
       end
 
@@ -105,6 +111,7 @@ module Dalli
         opkey = quiet? ? :deleteq : :delete
         req = RequestFormatter.standard_request(opkey: opkey, key: key, cas: cas)
         write(req)
+        @connection_manager.flush unless quiet?
         response_processor.delete unless quiet?
       end
 
@@ -139,6 +146,7 @@ module Dalli
         initial ||= 0
         write(RequestFormatter.decr_incr_request(opkey: opkey, key: key,
                                                  count: count, initial: initial, expiry: expiry))
+        @connection_manager.flush unless quiet?
         response_processor.decr_incr unless quiet?
       end
 
@@ -146,6 +154,7 @@ module Dalli
       def flush(ttl = 0)
         opkey = quiet? ? :flushq : :flush
         write(RequestFormatter.standard_request(opkey: opkey, ttl: ttl))
+        @connection_manager.flush unless quiet?
         response_processor.no_body_response unless quiet?
       end
 
@@ -159,22 +168,26 @@ module Dalli
       def stats(info = '')
         req = RequestFormatter.standard_request(opkey: :stat, key: info)
         write(req)
+        @connection_manager.flush
         response_processor.stats
       end
 
       def reset_stats
         write(RequestFormatter.standard_request(opkey: :stat, key: 'reset'))
+        @connection_manager.flush
         response_processor.reset
       end
 
       def version
         write(RequestFormatter.standard_request(opkey: :version))
+        @connection_manager.flush
         response_processor.version
       end
 
       def write_noop
         req = RequestFormatter.standard_request(opkey: :noop)
         write(req)
+        @connection_manager.flush
       end
 
       require_relative 'binary/request_formatter'

data/lib/dalli/protocol/connection_manager.rb

@@ -53,6 +53,7 @@ module Dalli
         Dalli.logger.debug { "Dalli::Server#connect #{name}" }
 
         @sock = memcached_socket
+        @sock.sync = false # Enable buffered I/O for better performance
         @pid = PIDCache.pid
         @request_in_progress = false
       rescue SystemCallError, *TIMEOUT_ERRORS, EOFError, SocketError => e
@@ -166,6 +167,12 @@ module Dalli
         error_on_request!(e)
       end
 
+      def flush
+        @sock.flush
+      rescue SystemCallError, *TIMEOUT_ERRORS, *SSL_ERRORS => e
+        error_on_request!(e)
+      end
+
       # Non-blocking read.  Here to support the operation
       # of the get_multi operation
       def read_nonblock

data/lib/dalli/protocol/meta/request_formatter.rb

@@ -37,9 +37,12 @@ module Dalli
         # - 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)
+                          return_hit_status: false, return_last_access: false, skip_lru_bump: false,
+                          skip_flags: false)
           cmd = "mg #{key}"
-          cmd << ' v f' if value
+          # 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

data/lib/dalli/protocol/meta.rb

@@ -25,21 +25,28 @@ module Dalli
       # Retrieval Commands
       def get(key, options = nil)
         encoded_key, base64 = KeyRegularizer.encode(key)
-        req = RequestFormatter.meta_get(key: encoded_key, base64: base64)
+        # 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)
         write(req)
+        @connection_manager.flush
         response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
       def quiet_get_request(key)
         encoded_key, base64 = KeyRegularizer.encode(key)
-        RequestFormatter.meta_get(key: encoded_key, return_cas: true, base64: base64, quiet: true)
+        # 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?)
       end
 
       def gat(key, ttl, options = nil)
         ttl = TtlSanitizer.sanitize(ttl)
         encoded_key, base64 = KeyRegularizer.encode(key)
-        req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, base64: base64)
+        skip_flags = raw_mode? || (options && options[:raw])
+        req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, base64: base64, skip_flags: skip_flags)
         write(req)
+        @connection_manager.flush
         response_processor.meta_get_with_value(cache_nils: cache_nils?(options))
       end
 
@@ -48,6 +55,7 @@ module Dalli
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_get(key: encoded_key, ttl: ttl, value: false, base64: base64)
         write(req)
+        @connection_manager.flush
         response_processor.meta_get_without_value
       end
 
@@ -57,6 +65,7 @@ module Dalli
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_get(key: encoded_key, value: true, return_cas: true, base64: base64)
         write(req)
+        @connection_manager.flush
         response_processor.meta_get_with_value_and_cas
       end
 
@@ -93,6 +102,7 @@ module Dalli
           return_last_access: options[:return_last_access], skip_lru_bump: options[:skip_lru_bump]
         )
         write(req)
+        @connection_manager.flush
         response_processor.meta_get_with_metadata(
           cache_nils: cache_nils?(options), return_hit_status: options[:return_hit_status],
           return_last_access: options[:return_last_access]
@@ -110,6 +120,7 @@ module Dalli
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_delete(key: encoded_key, cas: cas, base64: base64, stale: true)
         write(req)
+        @connection_manager.flush
         response_processor.meta_delete
       end
 
@@ -146,6 +157,7 @@ module Dalli
         write(req)
         write(value)
         write(TERMINATOR)
+        @connection_manager.flush unless quiet
       end
       # rubocop:enable Metrics/ParameterLists
 
@@ -168,6 +180,7 @@ module Dalli
         write(req)
         write(value)
         write(TERMINATOR)
+        @connection_manager.flush unless quiet?
       end
       # rubocop:enable Metrics/ParameterLists
 
@@ -177,6 +190,7 @@ module Dalli
         req = RequestFormatter.meta_delete(key: encoded_key, cas: cas,
                                            base64: base64, quiet: quiet?)
         write(req)
+        @connection_manager.flush unless quiet?
         response_processor.meta_delete unless quiet?
       end
 
@@ -202,12 +216,14 @@ module Dalli
         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))
+        @connection_manager.flush unless quiet?
         response_processor.decr_incr unless quiet?
       end
 
       # Other Commands
       def flush(delay = 0)
         write(RequestFormatter.flush(delay: delay))
+        @connection_manager.flush unless quiet?
         response_processor.flush unless quiet?
       end
 
@@ -220,21 +236,25 @@ module Dalli
 
       def stats(info = nil)
         write(RequestFormatter.stats(info))
+        @connection_manager.flush
         response_processor.stats
       end
 
       def reset_stats
         write(RequestFormatter.stats('reset'))
+        @connection_manager.flush
         response_processor.reset
       end
 
       def version
         write(RequestFormatter.version)
+        @connection_manager.flush
         response_processor.version
       end
 
       def write_noop
         write(RequestFormatter.meta_noop)
+        @connection_manager.flush
       end
 
       def authenticate_connection

data/lib/dalli/socket.rb

@@ -107,7 +107,7 @@ module Dalli
         # aliases TCPSocket#initialize method to #original_resolv_initialize.
         # https://github.com/ruby/resolv-replace/blob/v0.1.1/lib/resolv-replace.rb#L21
         if RUBY_VERSION >= '3.0' &&
-           !::TCPSocket.private_instance_methods.include?(:original_resolv_initialize)
+           !::TCPSocket.private_method_defined?(:original_resolv_initialize)
           sock = new(host, port, connect_timeout: options[:socket_timeout])
           yield(sock)
         else

data/lib/dalli/version.rb

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

data/lib/dalli.rb

@@ -56,6 +56,7 @@ module Dalli
 end
 
 require_relative 'dalli/version'
+require_relative 'dalli/instrumentation'
 
 require_relative 'dalli/compressor'
 require_relative 'dalli/protocol_deprecations'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 4.2.1
 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/instrumentation.rb
 - lib/dalli/key_manager.rb
 - lib/dalli/options.rb
 - lib/dalli/pid_cache.rb
@@ -92,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.4
+rubygems_version: 4.0.6
 specification_version: 4
 summary: High performance memcached client for Ruby
 test_files: []