redis 5.4.1 → 6.0.0

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.1'
+  VERSION = '6.0.0'
 end

data/lib/redis.rb

@@ -53,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
@@ -69,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
@@ -118,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
@@ -131,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."
@@ -145,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)
@@ -170,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
@@ -191,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.1
+  version: 6.0.0
 platform: ruby
 authors:
 - Ezra Zygmuntowicz
@@ -15,22 +15,22 @@ authors:
 - Pieter Noordhuis
 bindir: bin
 cert_chain: []
-date: 2025-07-17 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.1
+  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.1
+  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:
   - - ">="