dalli 4.0.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 86e39b2869b7c916472e88e6cbbfb6aa1f6533aa35c9e1f1c704cffcbc680f8a
-  data.tar.gz: bf2e56610c6bae187d561ccf09105e6f5b4a29eed1308d089745ef22cf5b673b
+  metadata.gz: 7966ac393d9c0f41d61b244c6a5832fbcab5705ed4daa4189b6e1ffc92db600f
+  data.tar.gz: da320eac7a8d553f33fe81315750297f97edb75c6da79197ef1f974d47ac8081
 SHA512:
-  metadata.gz: e2faab814abb4b25a53d87048f7e4e81e49c609bd64725cb18607670110da3d5b8038544598c44575831b9038500f9d8220a56ec28c16b9517a21d442212d12b
-  data.tar.gz: 3e5a7c326c908d72d2d8ce2211b27f67acebbbf97c279c5faf3ba2914ec7409df7f259a9082d82903cc9ae6b6716a137994aba849321546b8d3d3a35f8f7f5af
+  metadata.gz: 5d29cfbe8d2ee6e2993e8a292238f2762ac1de29b8d8623f0a521f810edf866ffd9d631905d5b7cb939d44216fb7e8d6edabf4c09ba388162fef97a772254352
+  data.tar.gz: ef1c636e6aab12a630ddb7e4d7081c29b0e257203b97f78ccde207170802d1c3619db7057093d4140fcc9cbc23f979bf6f60be4a64011bde983062a724ea59fc

data/CHANGELOG.md

@@ -1,6 +1,57 @@
 Dalli Changelog
 =====================
 
+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
+==========
+
+New Features:
+
+- Add `set_multi` for efficient bulk set operations using pipelined requests
+- Add `delete_multi` for efficient bulk delete operations using pipelined requests
+- Add `fetch_with_lock` for thundering herd protection using meta protocol's vivify/recache flags (requires memcached 1.6+)
+- Add thundering herd protection support to meta protocol (requires memcached 1.6+):
+  - `N` (vivify) flag for creating stubs on cache miss
+  - `R` (recache) flag for winning recache race when TTL is below threshold
+  - Response flags `W` (won recache), `X` (stale), `Z` (lost race)
+  - `delete_stale` method for marking items as stale instead of deleting
+- Add `get_with_metadata` for advanced cache operations with metadata retrieval (requires memcached 1.6+):
+  - Returns hash with `:value`, `:cas`, `:won_recache`, `:stale`, `:lost_recache`
+  - Optional `:return_hit_status` returns `:hit_before` (true/false for previous access)
+  - Optional `:return_last_access` returns `:last_access` (seconds since last access)
+  - Optional `:skip_lru_bump` prevents LRU update on access
+  - Optional `:vivify_ttl` and `:recache_ttl` for thundering herd protection
+
+Deprecations:
+
+- Binary protocol is deprecated and will be removed in Dalli 5.0. Use `protocol: :meta` instead (requires memcached 1.6+)
+- SASL authentication is deprecated and will be removed in Dalli 5.0. Consider using network-level security or memcached's TLS support
+
+4.0.1
+==========
+
+- Add `:raw` client option to skip serialization entirely, returning raw byte strings
+- Handle `OpenSSL::SSL::SSLError` in connection manager
+
 4.0.0
 ==========
 

data/Gemfile

@@ -5,11 +5,18 @@ source 'https://rubygems.org'
 gemspec
 
 group :development, :test do
+  gem 'benchmark'
   gem 'cgi'
   gem 'connection_pool'
   gem 'debug' unless RUBY_PLATFORM == 'java'
-  gem 'minitest', '~> 5'
-  gem 'rack', '~> 2.0', '>= 2.2.0'
+  if RUBY_VERSION >= '3.2'
+    gem 'minitest', '~> 6'
+    gem 'minitest-mock'
+  else
+    gem 'minitest', '~> 5'
+  end
+  gem 'rack', '~> 3'
+  gem 'rack-session'
   gem 'rake', '~> 13.0'
   gem 'rubocop'
   gem 'rubocop-minitest'

data/README.md

@@ -11,9 +11,76 @@ 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).
 
+## Requirements
+
+* Ruby 3.1 or later
+* memcached 1.4 or later (1.6+ recommended for meta protocol support)
+
+## Protocol Options
+
+Dalli supports two protocols for communicating with memcached:
+
+* `:binary` (default) - Works with all memcached versions, supports SASL authentication
+* `:meta` - Requires memcached 1.6+, better performance for some operations, no authentication support
+
+```ruby
+Dalli::Client.new('localhost:11211', protocol: :meta)
+```
+
+## 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:
+
+```ruby
+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

@@ -41,6 +41,11 @@ module Dalli
     # - :compressor - defaults to Dalli::Compressor, a Zlib-based implementation
     # - :cache_nils - defaults to false, if true Dalli will not treat cached nil values as 'not found' for
     #                 #fetch operations.
+    # - :raw        - If set, disables serialization and compression entirely at the client level.
+    #                 Only String values are supported. This is useful when the caller handles its own
+    #                 serialization (e.g., Rails' ActiveSupport::Cache). Note: this is different from
+    #                 the per-request :raw option which converts values to strings but still uses the
+    #                 serialization pipeline.
     # - :digest_class - defaults to Digest::MD5, allows you to pass in an object that responds to the hexdigest method,
     #                   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
@@ -51,6 +56,7 @@ module Dalli
       @options = normalize_options(options)
       @key_manager = ::Dalli::KeyManager.new(@options)
       @ring = nil
+      emit_deprecation_warnings
     end
 
     #
@@ -91,24 +97,70 @@ module Dalli
       yield value, cas
     end
 
+    ##
+    # Get value with extended metadata using the meta protocol.
+    #
+    # IMPORTANT: This method requires memcached 1.6+ and the meta protocol (protocol: :meta).
+    # It will raise an error if used with the binary protocol.
+    #
+    # @param key [String] the cache key
+    # @param options [Hash] options controlling what metadata to return
+    #   - :return_cas [Boolean] return the CAS value (default: true)
+    #   - :return_hit_status [Boolean] return whether item was previously accessed
+    #   - :return_last_access [Boolean] return seconds since last access
+    #   - :skip_lru_bump [Boolean] don't bump LRU or update access stats
+    #
+    # @return [Hash] containing:
+    #   - :value - the cached value (or nil on miss)
+    #   - :cas - the CAS value
+    #   - :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)
+    #
+    # @example Get with hit status
+    #   result = client.get_with_metadata('key', return_hit_status: true)
+    #   # => { value: "data", cas: 123, hit_before: true }
+    #
+    # @example Get with all metadata without affecting LRU
+    #   result = client.get_with_metadata('key',
+    #     return_hit_status: true,
+    #     return_last_access: true,
+    #     skip_lru_bump: true
+    #   )
+    #   # => { value: "data", cas: 123, hit_before: true, last_access: 42 }
+    #
+    def get_with_metadata(key, options = {})
+      raise_unless_meta_protocol!
+
+      key = key.to_s
+      key = @key_manager.validate_key(key)
+
+      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
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { 'retrying get_with_metadata with new server' }
+      retry
+    end
+
     ##
     # 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.
@@ -144,6 +196,56 @@ module Dalli
       new_val
     end
 
+    ##
+    # Fetch the value with thundering herd protection using the meta protocol's
+    # N (vivify) and R (recache) flags.
+    #
+    # This method prevents multiple clients from simultaneously regenerating the same
+    # cache entry (the "thundering herd" problem). Only one client wins the right to
+    # regenerate; other clients receive the stale value (if available) or wait.
+    #
+    # IMPORTANT: This method requires memcached 1.6+ and the meta protocol (protocol: :meta).
+    # It will raise an error if used with the binary protocol.
+    #
+    # @param key [String] the cache key
+    # @param ttl [Integer] time-to-live for the cached value in seconds
+    # @param lock_ttl [Integer] how long the lock/stub lives (default: 30 seconds)
+    #   This is the maximum time other clients will return stale data while
+    #   waiting for regeneration. Should be longer than your expected regeneration time.
+    # @param recache_threshold [Integer, nil] if set, win the recache race when the
+    #   item's remaining TTL is below this threshold. Useful for proactive recaching.
+    # @param req_options [Hash] options passed to set operations (e.g., raw: true)
+    #
+    # @yield Block to regenerate the value (only called if this client won the race)
+    # @return [Object] the cached value (may be stale if another client is regenerating)
+    #
+    # @example Basic usage
+    #   client.fetch_with_lock('expensive_key', ttl: 300, lock_ttl: 30) do
+    #     expensive_database_query
+    #   end
+    #
+    # @example With proactive recaching (recache before expiry)
+    #   client.fetch_with_lock('key', ttl: 300, lock_ttl: 30, recache_threshold: 60) do
+    #     expensive_operation
+    #   end
+    #
+    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!
+
+      key = key.to_s
+      key = @key_manager.validate_key(key)
+
+      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
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { 'retrying fetch_with_lock with new server' }
+      retry
+    end
+
     ##
     # compare and swap values using optimistic locking.
     # Fetch the existing value for key.
@@ -201,6 +303,29 @@ module Dalli
       set_cas(key, value, 0, ttl, req_options)
     end
 
+    ##
+    # Set multiple keys and values efficiently using pipelining.
+    # This method is more efficient than calling set() in a loop because
+    # it batches requests by server and uses quiet mode.
+    #
+    # @param hash [Hash] key-value pairs to set
+    # @param ttl [Integer] time-to-live in seconds (optional, uses default if not provided)
+    # @param req_options [Hash] options passed to each set operation
+    # @return [void]
+    #
+    # Example:
+    #   client.set_multi({ 'key1' => 'value1', 'key2' => 'value2' }, 300)
+    def set_multi(hash, ttl = nil, req_options = nil)
+      return if hash.empty?
+
+      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
+
     ##
     # Set the key-value pair, verifying existing CAS.
     # Returns the resulting CAS value if succeeded, and falsy otherwise.
@@ -240,6 +365,27 @@ module Dalli
       delete_cas(key, 0)
     end
 
+    ##
+    # Delete multiple keys efficiently using pipelining.
+    # This method is more efficient than calling delete() in a loop because
+    # it batches requests by server and uses quiet mode.
+    #
+    # @param keys [Array<String>] keys to delete
+    # @return [void]
+    #
+    # Example:
+    #   client.delete_multi(['key1', 'key2', 'key3'])
+    def delete_multi(keys)
+      return if keys.empty?
+
+      Instrumentation.trace('delete_multi', {
+                              'db.operation' => 'delete_multi',
+                              'db.memcached.key_count' => keys.size
+                            }) do
+        pipelined_deleter.process(keys)
+      end
+    end
+
     ##
     # Append value to the value already stored on the server for 'key'.
     # Appending only works for values stored with :raw => true.
@@ -369,6 +515,42 @@ 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)
+      { 'db.operation' => 'get_multi', 'db.memcached.key_count' => keys.size }
+    end
+
     def check_positive!(amt)
       raise ArgumentError, "Positive values only: #{amt}" if amt.negative?
     end
@@ -381,6 +563,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
@@ -423,7 +616,12 @@ module Dalli
       key = @key_manager.validate_key(key)
 
       server = ring.server_for_key(key)
-      server.request(op, key, *args)
+      Instrumentation.trace(op.to_s, {
+                              'db.operation' => op.to_s,
+                              'server.address' => server.name
+                            }) do
+        server.request(op, key, *args)
+      end
     rescue NetworkError => e
       Dalli.logger.debug { e.inspect }
       Dalli.logger.debug { 'retrying request with new server' }
@@ -440,5 +638,23 @@ module Dalli
     def pipelined_getter
       PipelinedGetter.new(ring, @key_manager)
     end
+
+    def pipelined_setter
+      PipelinedSetter.new(ring, @key_manager)
+    end
+
+    def pipelined_deleter
+      PipelinedDeleter.new(ring, @key_manager)
+    end
+
+    def raise_unless_meta_protocol!
+      return if protocol_implementation == Dalli::Protocol::Meta
+
+      raise Dalli::DalliError,
+            'This operation requires the meta protocol (memcached 1.6+). ' \
+            'Use protocol: :meta when creating the client.'
+    end
+
+    include ProtocolDeprecations
   end
 end

data/lib/dalli/instrumentation.rb

@@ -0,0 +1,139 @@
+# 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.
+  #
+  # == Span Attributes
+  #
+  # All spans include the following default attributes:
+  # - +db.system+ - Always "memcached"
+  #
+  # Single-key operations (+get+, +set+, +delete+, +incr+, +decr+, etc.) add:
+  # - +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+ - "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+ - The operation name
+  # - +db.memcached.key_count+ - Number of keys in the operation
+  #
+  # == 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' => 'memcached'
+    DEFAULT_ATTRIBUTES = { 'db.system' => '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' - 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' => 'set', 'server.address' => 'localhost: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' => '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