redis 5.4.0 → 6.0.0

data/lib/redis/lib_identity.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "redis-client"
+require "redis/version"
+
+class Redis
+  # Reports `redis-rb` as the connecting library via `CLIENT SETINFO`.
+  #
+  # `redis-client` builds its own `LIB-NAME` as `redis-client(<driver_info>)` and always
+  # reports its own version as `LIB-VER`, which would identify `redis-client` rather than
+  # `redis-rb` to the server. We append a second pair of `CLIENT SETINFO` commands, which wins
+  # because the command is last-write-wins, so that `CLIENT LIST` / `CLIENT INFO` report
+  # `lib-name=redis-rb` and `lib-ver=<Redis::VERSION>`.
+  #
+  # Libraries built on top of `redis-rb` can still identify themselves by passing `driver_info`,
+  # in which case they are reported inside the parentheses, e.g. `lib-name=redis-rb(my-gem_v1.0.0)`.
+  # The official convention for such suffixes is `<name>_v<version>` (matching
+  # `(?<custom-name>[ -~]+)[ -~]v(?<custom-version>[\d\.]+)`), with `;` delimiting multiple
+  # suffixes and parentheses avoided inside them — see
+  # https://redis.io/docs/latest/commands/client-setinfo/. Passing `driver_info: false` disables
+  # `CLIENT SETINFO` entirely, for peers that can't tolerate unknown commands during the handshake
+  # (e.g. some proxies).
+  #
+  # Applications that use `redis-client` directly are left untouched: the override only applies
+  # to configurations whose `driver_info` was built by this module.
+  module LibIdentity
+    # Follows the official suffix convention, so that the transient pair `redis-client` itself
+    # builds from this value (`lib-name=redis-client(redis-rb_v<version>)`) is well-formed too.
+    MARKER = "redis-rb_v"
+    LIB_NAME = "redis-rb"
+    SEPARATOR = ";"
+    # Interpolated strings are not frozen by the magic comment; explicit freezes keep these
+    # constants Ractor-shareable (lazy module ivars here would raise Ractor::IsolationError).
+    OWN_INFO = "#{MARKER}#{Redis::VERSION}".freeze
+    OWN_PREFIX = "#{OWN_INFO}#{SEPARATOR}".freeze
+    # `CLIENT SETINFO` values must be printable ASCII with no spaces — the server rejects anything
+    # else, and `redis-client` swallows that error, which would silently leave `lib-name` empty.
+    # Parentheses are excluded as well: they delimit the suffix in `lib-name=redis-rb(<suffix>)`,
+    # so a suffix containing them would corrupt the reported name.
+    INVALID_CHARS = /(?:[^!-~]|[()])+/
+
+    class << self
+      # Combines redis-rb's own identity with the `driver_info` a downstream library passed in,
+      # so that both can be recovered when the connection prelude is built. `false` is passed
+      # through untouched and, being falsy, turns `CLIENT SETINFO` off wholesale (`redis-client`
+      # gates its own commands on `driver_info` too). Any other non-String, non-Array value is
+      # also passed through, leaving `redis-client` to reject it.
+      def driver_info(downstream = nil)
+        case downstream
+        when nil then OWN_INFO
+        when String then combine(downstream)
+        when Array then combine(downstream.join(SEPARATOR))
+        else downstream
+        end
+      end
+
+      # True only for values `driver_info` produced: exactly our own identity, or our identity
+      # followed by a downstream library's. Matching on the bare `MARKER` prefix instead would
+      # also capture a direct `redis-client` user whose own `driver_info` merely starts with
+      # `redis-rb_v` (say `redis-rb_viewer-1.0`) and would silently discard their identity.
+      def ours?(info)
+        info.is_a?(String) && (info == OWN_INFO || info.start_with?(OWN_PREFIX))
+      end
+
+      def setinfo_commands(info)
+        [
+          ["CLIENT", "SETINFO", "LIB-NAME", lib_name(info)].freeze,
+          ["CLIENT", "SETINFO", "LIB-VER", Redis::VERSION].freeze,
+        ].freeze
+      end
+
+      private
+
+      def combine(downstream)
+        downstream = downstream.scrub(" ") # invalid byte sequences would make gsub raise
+                               .gsub(/\A#{INVALID_CHARS}|#{INVALID_CHARS}\z/o, "")
+                               .gsub(INVALID_CHARS, "_")
+        downstream.empty? ? OWN_INFO : "#{OWN_PREFIX}#{downstream}"
+      end
+
+      def lib_name(info)
+        downstream = info == OWN_INFO ? nil : info.delete_prefix(OWN_PREFIX)
+        downstream.nil? || downstream.empty? ? LIB_NAME : "#{LIB_NAME}(#{downstream})".freeze
+      end
+    end
+
+    def connection_prelude
+      prelude = super
+      info = driver_info
+      return prelude unless LibIdentity.ours?(info)
+
+      # `CLIENT SETINFO` is last-write-wins, so appending after the commands `redis-client`
+      # already built overrides them, without having to recognise or remove them.
+      (prelude + LibIdentity.setinfo_commands(info)).freeze
+    end
+  end
+end
+
+# Prepended to the concrete config classes rather than to `RedisClient::Config::Common`, so that
+# the two `redis-client` entry points are covered without altering the shared module for anything
+# else that includes it. `RedisClient::SentinelConfig` is NOT a `RedisClient::Config` subclass, so
+# both lines are required. `RedisClient::Cluster::Node::Config` does subclass `RedisClient::Config`
+# and calls `super` in its own `connection_prelude`, so cluster nodes are covered by the first.
+RedisClient::Config.prepend(Redis::LibIdentity)
+RedisClient::SentinelConfig.prepend(Redis::LibIdentity)

data/lib/redis/subscribe.rb

@@ -80,7 +80,7 @@ class Redis
   end
 
   class Subscription
-    attr :callbacks
+    attr_reader :callbacks
 
     def initialize
       @callbacks = {}

data/lib/redis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Redis
-  VERSION = '5.4.0'
+  VERSION = '6.0.0'
 end

data/lib/redis.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "redis-client"
+
 require "monitor"
 require "redis/errors"
 require "redis/commands"
@@ -51,8 +53,14 @@ class Redis
   # @option options [String] :password Password to authenticate against server
   # @option options [Integer] :db (0) Database to select after connect and on reconnects
   # @option options [Symbol] :driver Driver to use, currently supported: `:ruby`, `:hiredis`
+  # @option options [Integer] :protocol (3) RESP protocol version to negotiate (`HELLO`). Defaults
+  #   to RESP3; set to `2` for RESP2. Servers without RESP3 support automatically fall back to RESP2.
   # @option options [String] :id ID for the client connection, assigns name to current connection by sending
   #   `CLIENT SETNAME`
+  # @option options [String, Array<String>, false] :driver_info Identity a library built on top of `redis-rb`
+  #   reports to the server via `CLIENT SETINFO`, shown as `lib-name=redis-rb(<driver_info>)` in `CLIENT LIST`.
+  #   The recommended format is `<name>_v<version>`; an Array is joined with `;`. Pass `false` to disable
+  #   client identification entirely.
   # @option options [Integer, Array<Integer, Float>] :reconnect_attempts Number of attempts trying to connect,
   #   or a list of sleep duration between attempts.
   # @option options [Boolean] :inherit_socket (false) Whether to use socket in forked process or not
@@ -67,16 +75,29 @@ class Redis
     if ENV["REDIS_URL"] && SERVER_URL_OPTIONS.none? { |o| @options.key?(o) }
       @options[:url] = ENV["REDIS_URL"]
     end
-    inherit_socket = @options.delete(:inherit_socket)
+    # Kept as state, not just a local: the RESP3->RESP2 fallback rebuilds @client and must re-apply
+    # socket inheritance, otherwise fork safety would be silently lost after a downgrade.
+    @inherit_socket = @options.delete(:inherit_socket)
+    # HIMPORT fieldsets are server session state that dies with the physical connection; the
+    # registry remembers each prepared schema so a lost session can be repaired (see the
+    # himport_* overrides below). Deleted from @options so it never reaches RedisClient::Config.
+    @himport_auto_prepare = @options.delete(:himport_auto_prepare) != false
+    @himport_fieldsets = {}
     @subscription_client = nil
 
-    @client = initialize_client(@options)
-    @client.inherit_socket! if inherit_socket
+    @client = build_client
   end
 
   # Run code without the client reconnecting
   def without_reconnect(&block)
-    @client.disable_reconnection(&block)
+    # Route through #synchronize like every other @client access: it holds @monitor and applies the
+    # RESP3->RESP2 fallback. disable_reconnection establishes the connection eagerly, so if that
+    # handshake fails the fallback rebuilds @client and the whole block re-runs against the new
+    # (RESP2) client — keeping disable_reconnection bound to the live @client rather than a discarded
+    # one. Referencing the block argument (not @client) is what makes the retry pick up the rebuild.
+    synchronize do |client|
+      client.disable_reconnection(&block)
+    end
   end
 
   # Test whether or not the client is connected
@@ -116,7 +137,10 @@ class Redis
   end
 
   def dup
-    self.class.new(@options)
+    # inherit_socket and himport_auto_prepare are stripped from @options before the client config
+    # is built (RedisClient::Config doesn't know them); merge the live values back so the
+    # duplicate keeps the caller's settings instead of silently reverting to defaults.
+    self.class.new(@options.merge(inherit_socket: @inherit_socket, himport_auto_prepare: @himport_auto_prepare))
   end
 
   def connection
@@ -129,8 +153,70 @@ class Redis
     }
   end
 
+  # HIMPORT overrides adding fieldset-loss recovery on top of the transport-pure methods in
+  # Commands::Hashes. The connection can be transparently replaced under the caller (reconnect
+  # after a network error, failover, RESET by a proxy), destroying every prepared fieldset. The
+  # server then answers HIMPORT SET with "no such fieldset" — the authoritative signal that the
+  # session was lost. These overrides remember the last schema prepared per fieldset name and,
+  # on that error, re-prepare it and retry the SET exactly once. An explicitly discarded
+  # fieldset is removed from the registry and is never resurrected. Disable the recovery with
+  # `Redis.new(himport_auto_prepare: false)`; the registry is still recorded for manual use.
+
+  # Each method holds @monitor across the server command AND its registry mutation: the two must
+  # be atomic with respect to other threads, otherwise a himport_set failing between another
+  # thread's DISCARD reply and its registry delete would still see the schema and re-prepare,
+  # resurrecting the fieldset the discard just removed. @monitor is reentrant, so the nested
+  # send_command/himport_prepare calls re-enter it safely.
+
+  def himport_prepare(fieldset_name, *fields)
+    fields.flatten!(1)
+    @monitor.synchronize do
+      reply = super(fieldset_name, fields)
+      @himport_fieldsets[fieldset_name.to_s] = fields.dup.freeze
+      reply
+    end
+  end
+
+  def himport_set(key, fieldset_name, *values)
+    @monitor.synchronize do
+      super
+    rescue CommandError => error
+      fields = @himport_fieldsets[fieldset_name.to_s]
+      raise unless @himport_auto_prepare && fields && error.message.include?("no such fieldset")
+
+      himport_prepare(fieldset_name, fields)
+      # `super` (not himport_set) so a second failure propagates instead of recovering again.
+      super
+    end
+  end
+
+  def himport_discard(fieldset_name)
+    @monitor.synchronize do
+      reply = super
+      @himport_fieldsets.delete(fieldset_name.to_s)
+      reply
+    end
+  end
+
+  def himport_discard_all
+    @monitor.synchronize do
+      reply = super
+      @himport_fieldsets.clear
+      reply
+    end
+  end
+
   private
 
+  # Builds @client from @options and applies any instance-level settings (socket inheritance) that
+  # live outside @options. Used both at construction and when the RESP3->RESP2 fallback rebuilds the
+  # client, so those settings survive a protocol downgrade.
+  def build_client
+    client = initialize_client(@options)
+    client.inherit_socket! if @inherit_socket
+    client
+  end
+
   def initialize_client(options)
     if options.key?(:cluster)
       raise "Redis Cluster support was moved to the `redis-clustering` gem."
@@ -143,22 +229,64 @@ class Redis
     end
   end
 
+  # All access to @client funnels through here: it serializes on @monitor and applies the RESP3
+  # protocol fallback. Routing pipelined/multi/watch (which all call synchronize) through the same
+  # path means they fall back to RESP2 against pre-HELLO servers just like single commands do.
   def synchronize
-    @monitor.synchronize { yield(@client) }
+    @monitor.synchronize do
+      with_protocol_fallback do
+        yield(@client)
+      end
+    end
   end
 
   def send_command(command, &block)
-    @monitor.synchronize do
-      @client.call_v(command, &block)
+    synchronize do |client|
+      client.call_v(command, &block)
     end
   rescue ::RedisClient::Error => error
     Client.translate_error!(error)
   end
 
   def send_blocking_command(command, timeout, &block)
-    @monitor.synchronize do
-      @client.blocking_call_v(timeout, command, &block)
+    synchronize do |client|
+      client.blocking_call_v(timeout, command, &block)
+    end
+  rescue ::RedisClient::Error => error
+    Client.translate_error!(error)
+  end
+
+  # We default to RESP3. Servers that don't support it reject the `HELLO 3` handshake (most
+  # notably Redis < 6.0, which has no HELLO command). Rebuild the client as RESP2 once so those
+  # servers keep working without the user setting `protocol: 2`.
+  #
+  # This is the single fallback point for every client type. Each one surfaces the resp3-unsupported
+  # error here untranslated (still a RedisClient::Error): standalone/distributed via
+  # Redis::Client#call_v et al., sentinel via the plain RedisClient (which never translates), and
+  # cluster via Redis::Cluster::Client#handle_errors. Because every @client access — single commands,
+  # pipelined, multi, watch, and the pub/sub socket — flows through #synchronize, wrapping it here
+  # covers them all.
+  #
+  # Must be called while holding @monitor: it closes and replaces @client, so it has to be
+  # serialized with the command execution that uses @client. The retried block re-reads @client, so
+  # callers must reference the rebuilt instance (via the synchronize block argument), not a cached
+  # one.
+  def with_protocol_fallback
+    yield
+  rescue ::RedisClient::Error => error
+    if @options.fetch(:protocol, 3).to_i == 3 && Client.resp3_unsupported?(error)
+      @options = @options.merge(protocol: 2)
+      @client.close
+      @client = build_client
+      # Warn only once the RESP2 client is actually in place — if the rebuild itself raises we
+      # haven't really fallen back. Fires once per client: @options[:protocol] is now 2, so this
+      # branch never re-enters. Passing `protocol: 2` explicitly skips it (and silences this).
+      warn("Redis: the server does not support RESP3 (the HELLO 3 handshake failed); falling back " \
+           "to RESP2. Pass `protocol: 2` to select RESP2 explicitly and silence this warning.")
+      retry
     end
+
+    raise
   end
 
   def _subscription(method, timeout, channels, block)
@@ -168,7 +296,10 @@ class Redis
       end
 
       begin
-        @subscription_client = SubscribedClient.new(@client.pubsub)
+        # The pub/sub second socket is opened via @client.pubsub, which connects through
+        # ensure_connected rather than a command path. Route it through #synchronize so the same
+        # RESP3->RESP2 fallback applies when subscribe is the first operation against an old server.
+        @subscription_client = SubscribedClient.new(synchronize(&:pubsub))
         if timeout > 0
           @subscription_client.send(method, timeout, *channels, &block)
         else
@@ -189,6 +320,7 @@ class Redis
 end
 
 require "redis/version"
+require "redis/lib_identity"
 require "redis/client"
 require "redis/pipeline"
 require "redis/subscribe"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis
 version: !ruby/object:Gem::Version
-  version: 5.4.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -15,22 +15,22 @@ authors:
 - Pieter Noordhuis
 bindir: bin
 cert_chain: []
-date: 2025-02-20 00:00:00.000000000 Z
+date: 2026-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.22.0
+        version: 0.30.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: 0.22.0
+        version: 0.30.1
 description: |2
       A Ruby client that tries to match Redis' API one-to-one, while still
       providing an idiomatic interface.
@@ -54,6 +54,18 @@ files:
 - lib/redis/commands/hyper_log_log.rb
 - lib/redis/commands/keys.rb
 - lib/redis/commands/lists.rb
+- lib/redis/commands/modules/json.rb
+- lib/redis/commands/modules/search.rb
+- lib/redis/commands/modules/search/aggregation.rb
+- lib/redis/commands/modules/search/dialect.rb
+- lib/redis/commands/modules/search/field.rb
+- lib/redis/commands/modules/search/hybrid.rb
+- lib/redis/commands/modules/search/index.rb
+- lib/redis/commands/modules/search/index_definition.rb
+- lib/redis/commands/modules/search/miscellaneous.rb
+- lib/redis/commands/modules/search/query.rb
+- lib/redis/commands/modules/search/result.rb
+- lib/redis/commands/modules/search/schema.rb
 - lib/redis/commands/pubsub.rb
 - lib/redis/commands/scripting.rb
 - lib/redis/commands/server.rb
@@ -65,6 +77,7 @@ files:
 - lib/redis/distributed.rb
 - lib/redis/errors.rb
 - lib/redis/hash_ring.rb
+- lib/redis/lib_identity.rb
 - lib/redis/pipeline.rb
 - lib/redis/subscribe.rb
 - lib/redis/version.rb
@@ -74,9 +87,9 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/redis/redis-rb/issues
   changelog_uri: https://github.com/redis/redis-rb/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/redis/5.4.0
+  documentation_uri: https://www.rubydoc.info/gems/redis/6.0.0
   homepage_uri: https://github.com/redis/redis-rb
-  source_code_uri: https://github.com/redis/redis-rb/tree/v5.4.0
+  source_code_uri: https://github.com/redis/redis-rb/tree/v6.0.0
 rdoc_options: []
 require_paths:
 - lib
@@ -84,7 +97,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="