dalli 4.0.1 → 4.2.0

data/lib/dalli/pipelined_setter.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Dalli
+  ##
+  # Contains logic for the pipelined set operations implemented by the client.
+  # Efficiently writes multiple key-value pairs by grouping requests by server
+  # and using quiet mode to minimize round trips.
+  ##
+  class PipelinedSetter
+    def initialize(ring, key_manager)
+      @ring = ring
+      @key_manager = key_manager
+    end
+
+    ##
+    # Writes multiple key-value pairs to memcached.
+    # Raises an error if any server is unavailable.
+    #
+    # @param hash [Hash] key-value pairs to set
+    # @param ttl [Integer] time-to-live in seconds
+    # @param req_options [Hash] options passed to each set operation
+    # @return [void]
+    ##
+    def process(hash, ttl, req_options)
+      return if hash.empty?
+
+      @ring.lock do
+        servers = setup_requests(hash, ttl, req_options)
+        finish_requests(servers)
+      end
+    rescue NetworkError => e
+      Dalli.logger.debug { e.inspect }
+      Dalli.logger.debug { 'retrying pipelined sets because of network error' }
+      retry
+    end
+
+    private
+
+    def setup_requests(hash, ttl, req_options)
+      groups = groups_for_keys(hash.keys)
+      make_set_requests(groups, hash, ttl, req_options)
+      groups.keys
+    end
+
+    ##
+    # Loop through the server-grouped sets of keys, writing
+    # the corresponding quiet set requests to the appropriate servers
+    ##
+    def make_set_requests(groups, hash, ttl, req_options)
+      groups.each do |server, keys_for_server|
+        keys_for_server.each do |key|
+          original_key = @key_manager.key_without_namespace(key)
+          value = hash[original_key]
+          server.request(:pipelined_set, key, value, ttl, req_options)
+        rescue DalliError, NetworkError => e
+          Dalli.logger.debug { e.inspect }
+          Dalli.logger.debug { "unable to set key #{key} for server #{server.name}" }
+        end
+      end
+    end
+
+    ##
+    # Sends noop to each server to flush responses and ensure all writes complete.
+    ##
+    def finish_requests(servers)
+      servers.each do |server|
+        server.request(:noop)
+      rescue DalliError, NetworkError => e
+        Dalli.logger.debug { e.inspect }
+        Dalli.logger.debug { "unable to complete pipelined set on server #{server.name}" }
+      end
+    end
+
+    def groups_for_keys(keys)
+      validated_keys = keys.map { |k| @key_manager.validate_key(k.to_s) }
+      groups = @ring.keys_grouped_by_server(validated_keys)
+
+      if (unfound_keys = groups.delete(nil))
+        Dalli.logger.debug do
+          "unable to set #{unfound_keys.length} keys because no matching server was found"
+        end
+      end
+
+      groups
+    end
+  end
+end

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
 
@@ -56,6 +60,12 @@ module Dalli
         storage_req(opkey, key, value, ttl, cas, options)
       end
 
+      # Pipelined set - writes a quiet set request without reading response.
+      # Used by PipelinedSetter for bulk operations.
+      def pipelined_set(key, value, ttl, options)
+        storage_req(:setq, key, value, ttl, 0, options)
+      end
+
       def add(key, value, ttl, options)
         opkey = quiet? ? :addq : :add
         storage_req(opkey, key, value, ttl, 0, options)
@@ -75,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
@@ -91,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
 
@@ -99,9 +111,17 @@ 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
 
+      # Pipelined delete - writes a quiet delete request without reading response.
+      # Used by PipelinedDeleter for bulk operations.
+      def pipelined_delete(key)
+        req = RequestFormatter.standard_request(opkey: :deleteq, key: key, cas: 0)
+        write(req)
+      end
+
       # Arithmetic Commands
       def decr(key, count, ttl, initial)
         opkey = quiet? ? :decrq : :decr
@@ -126,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
 
@@ -133,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
 
@@ -146,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

@@ -15,13 +15,43 @@ module Dalli
         # rubocop:disable Metrics/CyclomaticComplexity
         # rubocop:disable Metrics/ParameterLists
         # rubocop:disable Metrics/PerceivedComplexity
-        def self.meta_get(key:, value: true, return_cas: false, ttl: nil, base64: false, quiet: false)
+        #
+        # Meta get flags:
+        #
+        # Thundering herd protection:
+        # - vivify_ttl (N flag): On miss, create a stub item and return W flag. The TTL
+        #   specifies how long the stub lives. Other clients see X (stale) and Z (lost race).
+        # - recache_ttl (R flag): If item's remaining TTL is below this threshold, return W
+        #   flag to indicate this client should recache. Other clients get Z (lost race).
+        #
+        # Metadata flags:
+        # - return_hit_status (h flag): Return whether item has been hit before (0 or 1)
+        # - return_last_access (l flag): Return seconds since item was last accessed
+        # - skip_lru_bump (u flag): Don't bump item in LRU, don't update hit status or last access
+        #
+        # Response flags (parsed by response processor):
+        # - W: Client won the right to recache this item
+        # - X: Item is stale (another client is regenerating)
+        # - Z: Client lost the recache race (another client is already regenerating)
+        # - h0/h1: Hit status (0 = first access, 1 = previously accessed)
+        # - 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,
+                          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
           cmd << ' k q s' if quiet # Return the key in the response if quiet
+          cmd << " N#{vivify_ttl}" if vivify_ttl # Thundering herd: vivify on miss
+          cmd << " R#{recache_ttl}" if recache_ttl # Thundering herd: win recache if TTL below threshold
+          cmd << ' h' if return_hit_status # Return hit status (0 or 1)
+          cmd << ' l' if return_last_access # Return seconds since last access
+          cmd << ' u' if skip_lru_bump # Don't bump LRU or update access stats
           cmd + TERMINATOR
         end
 
@@ -37,11 +67,15 @@ module Dalli
           cmd << TERMINATOR
         end
 
-        def self.meta_delete(key:, cas: nil, ttl: nil, base64: false, quiet: false)
+        # Thundering herd protection flag:
+        # - stale (I flag): Instead of deleting the item, mark it as stale. Other clients
+        #   using N/R flags will see the X flag and know the item is being regenerated.
+        def self.meta_delete(key:, cas: nil, ttl: nil, base64: false, quiet: false, stale: false)
           cmd = "md #{key}"
           cmd << ' b' if base64
           cmd << cas_string(cas)
           cmd << " T#{ttl}" if ttl
+          cmd << ' I' if stale # Mark stale instead of deleting
           cmd << ' q' if quiet
           cmd + TERMINATOR
         end

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

@@ -51,6 +51,41 @@ module Dalli
           tokens.first == EN ? nil : true
         end
 
+        # Returns a hash with all requested metadata:
+        # - :value - the cached value (or nil if miss)
+        # - :cas - the CAS value (if return_cas was requested)
+        # - :won_recache - true if client won the right to recache (W flag)
+        # - :stale - true if the item is stale (X flag)
+        # - :lost_recache - true if another client is already recaching (Z flag)
+        # - :hit_before - true/false if item was previously accessed (h flag, if requested)
+        # - :last_access - seconds since last access (l flag, if requested)
+        #
+        # Used by meta_get for comprehensive metadata retrieval.
+        # Supports thundering herd protection (N/R flags) and metadata flags (h/l/u).
+        def meta_get_with_metadata(cache_nils: false, return_hit_status: false, return_last_access: false)
+          tokens = error_on_unexpected!([VA, EN, HD])
+          result = build_metadata_result(tokens)
+          result[:hit_before] = hit_status_from_tokens(tokens) if return_hit_status
+          result[:last_access] = last_access_from_tokens(tokens) if return_last_access
+          result[:value] = parse_value_from_tokens(tokens, cache_nils)
+          result
+        end
+
+        def build_metadata_result(tokens)
+          {
+            value: nil, cas: cas_from_tokens(tokens),
+            won_recache: tokens.include?('W'), stale: tokens.include?('X'),
+            lost_recache: tokens.include?('Z')
+          }
+        end
+
+        def parse_value_from_tokens(tokens, cache_nils)
+          return cache_nils ? ::Dalli::NOT_FOUND : nil if tokens.first == EN
+          return unless tokens.first == VA
+
+          @value_marshaller.retrieve(read_data(tokens[1].to_i), bitflags_from_tokens(tokens))
+        end
+
         def meta_set_with_cas
           tokens = error_on_unexpected!([HD, NS, NF, EX])
           return false unless tokens.first == HD
@@ -190,6 +225,21 @@ module Dalli
           KeyRegularizer.decode(encoded_key, base64_encoded)
         end
 
+        # Returns true if item was previously hit, false if first access, nil if not requested
+        # The h flag returns h0 (first access) or h1 (previously accessed)
+        def hit_status_from_tokens(tokens)
+          hit_token = tokens.find { |t| t.start_with?('h') && t.length == 2 }
+          return nil unless hit_token
+
+          hit_token[1] == '1'
+        end
+
+        # Returns seconds since last access, or nil if not requested
+        # The l flag returns l<seconds>
+        def last_access_from_tokens(tokens)
+          value_from_tokens(tokens, 'l')&.to_i
+        end
+
         def body_len_from_tokens(tokens)
           value_from_tokens(tokens, 's')&.to_i
         end

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,15 +65,77 @@ 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
 
+      # Comprehensive meta get with support for all metadata flags.
+      # @note Requires memcached 1.6+ (meta protocol feature)
+      #
+      # This is the full-featured get method that supports:
+      # - Thundering herd protection (vivify_ttl, recache_ttl)
+      # - Item metadata (hit_status, last_access)
+      # - LRU control (skip_lru_bump)
+      #
+      # @param key [String] the key to retrieve
+      # @param options [Hash] options controlling what metadata to return
+      #   - :vivify_ttl [Integer] creates a stub on miss with this TTL (N flag)
+      #   - :recache_ttl [Integer] wins recache race if remaining TTL is below this (R flag)
+      #   - :return_hit_status [Boolean] return whether item was previously accessed (h flag)
+      #   - :return_last_access [Boolean] return seconds since last access (l flag)
+      #   - :skip_lru_bump [Boolean] don't bump LRU or update access stats (u flag)
+      #   - :cache_nils [Boolean] whether to cache nil values
+      # @return [Hash] containing:
+      #   - :value - the cached value (or nil on miss)
+      #   - :cas - the CAS value
+      #   - :won_recache - true if client won recache race (W flag)
+      #   - :stale - true if item is stale (X flag)
+      #   - :lost_recache - true if another client is recaching (Z flag)
+      #   - :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)
+      def meta_get(key, options = {})
+        encoded_key, base64 = KeyRegularizer.encode(key)
+        req = RequestFormatter.meta_get(
+          key: encoded_key, value: true, return_cas: true, base64: base64,
+          vivify_ttl: options[:vivify_ttl], recache_ttl: options[:recache_ttl],
+          return_hit_status: options[:return_hit_status],
+          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]
+        )
+      end
+
+      # Delete with stale invalidation instead of actual deletion.
+      # Used with thundering herd protection to mark items as stale rather than removing them.
+      # @note Requires memcached 1.6+ (meta protocol feature)
+      #
+      # @param key [String] the key to invalidate
+      # @param cas [Integer] optional CAS value for compare-and-swap
+      # @return [Boolean] true if successful
+      def delete_stale(key, cas = nil)
+        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
+
       # Storage Commands
       def set(key, value, ttl, cas, options)
         write_storage_req(:set, key, value, ttl, cas, options)
         response_processor.meta_set_with_cas unless quiet?
       end
 
+      # Pipelined set - writes a quiet set request without reading response.
+      # Used by PipelinedSetter for bulk operations.
+      def pipelined_set(key, value, ttl, options)
+        write_storage_req(:set, key, value, ttl, nil, options, quiet: true)
+      end
+
       def add(key, value, ttl, options)
         write_storage_req(:add, key, value, ttl, nil, options)
         response_processor.meta_set_with_cas unless quiet?
@@ -77,16 +147,17 @@ module Dalli
       end
 
       # rubocop:disable Metrics/ParameterLists
-      def write_storage_req(mode, key, raw_value, ttl = nil, cas = nil, options = {})
+      def write_storage_req(mode, key, raw_value, ttl = nil, cas = nil, options = {}, quiet: quiet?)
         (value, bitflags) = @value_marshaller.store(key, raw_value, options)
         ttl = TtlSanitizer.sanitize(ttl) if ttl
         encoded_key, base64 = KeyRegularizer.encode(key)
         req = RequestFormatter.meta_set(key: encoded_key, value: value,
                                         bitflags: bitflags, cas: cas,
-                                        ttl: ttl, mode: mode, quiet: quiet?, base64: base64)
+                                        ttl: ttl, mode: mode, quiet: quiet, base64: base64)
         write(req)
         write(value)
         write(TERMINATOR)
+        @connection_manager.flush unless quiet
       end
       # rubocop:enable Metrics/ParameterLists
 
@@ -109,6 +180,7 @@ module Dalli
         write(req)
         write(value)
         write(TERMINATOR)
+        @connection_manager.flush unless quiet?
       end
       # rubocop:enable Metrics/ParameterLists
 
@@ -118,9 +190,18 @@ 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
 
+      # Pipelined delete - writes a quiet delete request without reading response.
+      # Used by PipelinedDeleter for bulk operations.
+      def pipelined_delete(key)
+        encoded_key, base64 = KeyRegularizer.encode(key)
+        req = RequestFormatter.meta_delete(key: encoded_key, base64: base64, quiet: true)
+        write(req)
+      end
+
       # Arithmetic Commands
       def decr(key, count, ttl, initial)
         decr_incr false, key, count, ttl, initial
@@ -135,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
 
@@ -153,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/protocol_deprecations.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Dalli
+  ##
+  # Handles deprecation warnings for protocol and authentication features
+  # that will be removed in Dalli 5.0.
+  ##
+  module ProtocolDeprecations
+    BINARY_PROTOCOL_DEPRECATION_MESSAGE = <<~MSG.chomp
+      [DEPRECATION] The binary protocol is deprecated and will be removed in Dalli 5.0. \
+      Please use `protocol: :meta` instead. The meta protocol requires memcached 1.6+. \
+      See https://github.com/petergoldstein/dalli for migration details.
+    MSG
+
+    SASL_AUTH_DEPRECATION_MESSAGE = <<~MSG.chomp
+      [DEPRECATION] SASL authentication is deprecated and will be removed in Dalli 5.0. \
+      SASL is only supported by the binary protocol, which is being removed. \
+      Consider using network-level security (firewall rules, VPN) or memcached's TLS support instead.
+    MSG
+
+    private
+
+    def emit_deprecation_warnings
+      emit_binary_protocol_deprecation_warning
+      emit_sasl_auth_deprecation_warning
+    end
+
+    def emit_binary_protocol_deprecation_warning
+      protocol = @options[:protocol]
+      # Binary is used when protocol is nil, :binary, or 'binary'
+      return if protocol.to_s == 'meta'
+
+      warn BINARY_PROTOCOL_DEPRECATION_MESSAGE
+      Dalli.logger.warn(BINARY_PROTOCOL_DEPRECATION_MESSAGE)
+    end
+
+    def emit_sasl_auth_deprecation_warning
+      username = @options[:username] || ENV.fetch('MEMCACHE_USERNAME', nil)
+      return unless username
+
+      warn SASL_AUTH_DEPRECATION_MESSAGE
+      Dalli.logger.warn(SASL_AUTH_DEPRECATION_MESSAGE)
+    end
+  end
+end

data/lib/dalli/version.rb

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

data/lib/dalli.rb

@@ -56,11 +56,15 @@ module Dalli
 end
 
 require_relative 'dalli/version'
+require_relative 'dalli/instrumentation'
 
 require_relative 'dalli/compressor'
+require_relative 'dalli/protocol_deprecations'
 require_relative 'dalli/client'
 require_relative 'dalli/key_manager'
 require_relative 'dalli/pipelined_getter'
+require_relative 'dalli/pipelined_setter'
+require_relative 'dalli/pipelined_deleter'
 require_relative 'dalli/ring'
 require_relative 'dalli/protocol'
 require_relative 'dalli/protocol/base'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dalli
 version: !ruby/object:Gem::Version
-  version: 4.0.1
+  version: 4.2.0
 platform: ruby
 authors:
 - Peter M. Goldstein
@@ -40,10 +40,13 @@ 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
+- lib/dalli/pipelined_deleter.rb
 - lib/dalli/pipelined_getter.rb
+- lib/dalli/pipelined_setter.rb
 - lib/dalli/protocol.rb
 - lib/dalli/protocol/base.rb
 - lib/dalli/protocol/binary.rb
@@ -63,6 +66,7 @@ files:
 - lib/dalli/protocol/value_compressor.rb
 - lib/dalli/protocol/value_marshaller.rb
 - lib/dalli/protocol/value_serializer.rb
+- lib/dalli/protocol_deprecations.rb
 - lib/dalli/ring.rb
 - lib/dalli/servers_arg_normalizer.rb
 - lib/dalli/socket.rb