redis-client 0.19.1 → 0.22.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 920d97dcf258796ba88bb2f087fa89c1595dd245f67292c7432893848baacd0b
-  data.tar.gz: 07151d3aa036f7c513e7baa2cc94c22a7f9b4af8a09e132b1943716cd458c408
+  metadata.gz: 796fe04bd550f92d5bf2656a62de54caf1f640b45ab5d5f51fed61d0b61ee883
+  data.tar.gz: 4b34ce4e0ed5a2d4816863970789e7c23ce53fe8a561718b78b79432d09e3fe8
 SHA512:
-  metadata.gz: a6f664cf2c5fe77115606dc15e031e6bccc55c440b55d521ef5429653acb89bf55597dd4e5cd4892fb61f9452790a2ca41e32e72c6f824c7da9609987b14ff42
-  data.tar.gz: c6a34fe93aac6d5ae5c8995881e17581e64a762d0fdc3d3fe1772b07b1759196b2ca5a27e14e00c826399d03a1259f799c816ac1ca1ee001314d9b32f341ecb8
+  metadata.gz: d9dfb29603171606e71daaa43474812790988876720dd254a0069fc429ba035ede74b1b19d243967b9adb61c0d48ab4aa2931ef188cd2bb17d820b480967c897
+  data.tar.gz: e6ff3a4543991e139a26f8fa4bdb714aafe83678490f9890ca5fd0ec1a95bdddd0c8fec57dcb4ff88fb28a19d577a556172cb39e4bd4f290d41c6871de43345b

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Unreleased
 
+# 0.22.2
+
+- Fix the sentinel client to properly extend timeout for blocking commands.
+- Fix IPv6 support in `RedisClient::Config#server_url`.
+
+# 0.22.1
+
+- Fix `ProtocolError: Unknown sigil type` errors when using SSL connection. See #190.
+
+# 0.22.0
+
+- Made various performance optimizations to the Ruby driver. See #184.
+- Always assume UTF-8 encoding instead of relying on `Encoding.default_external`.
+- Add `exception` flag in `pipelined` allowing failed commands to be returned in the result array when set to `false`. See #187.
+
+# 0.21.1
+
+- Handle unresolved Sentinel master/replica error when displaying server URL in exceptions. See #182.
+
+# 0.21.0
+
+- Include redis server URL in most error messages. See #178.
+- Close Redis Sentinel connection after resolving role. See #176.
+
+# 0.20.0
+
+- Accept `unix://` schemes as well as simple paths in the `url:` config parameter. #170.
+- Make basic usage Ractor compatible.
+
 # 0.19.1
 
 - Fixed a bug in `hiredis-client` that could cause a crash if interrupted by `Timeout.timeout` or other `Thread#raise` based mecanism.

data/Gemfile

@@ -6,7 +6,7 @@ source "https://rubygems.org"
 gemspec name: "redis-client"
 
 gem "minitest"
-gem "rake", "~> 13.1"
+gem "rake", "~> 13.2"
 gem "rake-compiler"
 gem "rubocop"
 gem "rubocop-minitest"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    redis-client (0.19.1)
+    redis-client (0.22.2)
       connection_pool
 
 GEM
@@ -13,34 +13,40 @@ GEM
     connection_pool (2.4.1)
     hiredis (0.6.3)
     hiredis (0.6.3-java)
-    minitest (5.15.0)
-    parallel (1.22.1)
-    parser (3.1.2.1)
+    json (2.7.1)
+    json (2.7.1-java)
+    minitest (5.23.0)
+    parallel (1.24.0)
+    parser (3.3.0.5)
       ast (~> 2.4.1)
+      racc
+    racc (1.7.3)
+    racc (1.7.3-java)
     rainbow (3.1.1)
-    rake (13.1.0)
-    rake-compiler (1.2.5)
+    rake (13.2.1)
+    rake-compiler (1.2.7)
       rake
     redis (4.6.0)
-    regexp_parser (2.5.0)
-    rexml (3.2.5)
-    rubocop (1.28.2)
+    regexp_parser (2.9.0)
+    rexml (3.2.6)
+    rubocop (1.50.2)
+      json (~> 2.3)
       parallel (~> 1.10)
-      parser (>= 3.1.0.0)
+      parser (>= 3.2.0.0)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 1.8, < 3.0)
-      rexml
-      rubocop-ast (>= 1.17.0, < 2.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.0, < 2.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.17.0)
-      parser (>= 3.1.1.0)
-    rubocop-minitest (0.19.1)
-      rubocop (>= 0.90, < 2.0)
-    ruby-progressbar (1.11.0)
-    stackprof (0.2.25)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.30.0)
+      parser (>= 3.2.1.0)
+    rubocop-minitest (0.30.0)
+      rubocop (>= 1.39, < 2.0)
+    ruby-progressbar (1.13.0)
+    stackprof (0.2.26)
     toxiproxy (2.0.2)
-    unicode-display_width (2.2.0)
+    unicode-display_width (2.5.0)
 
 PLATFORMS
   ruby
@@ -53,7 +59,7 @@ DEPENDENCIES
   byebug
   hiredis
   minitest
-  rake (~> 13.1)
+  rake (~> 13.2)
   rake-compiler
   redis (~> 4.6)
   redis-client!

data/README.md

@@ -62,7 +62,9 @@ redis.call("GET", "mykey")
 
 ### Configuration
 
-- `url`: A Redis connection URL, e.g. `redis://example.com:6379/5`, a `rediss://` scheme enable SSL, and the path is interpreted as a database number.
+- `url`: A Redis connection URL, e.g. `redis://example.com:6379/5` - a `rediss://` scheme enables SSL, and the path is interpreted as a database number.
+  To connect to UNIX domain sockets, the `url` can also just be a path, and the database specified as query parameter: `/run/redis/foo.sock?db=5`, or optionally
+  have a `unix://` scheme: `unix:///run/redis/foo.sock?db=5`
   Note that all other configurations take precedence, e.g. `RedisClient.config(url: "redis://localhost:3000", port: 6380)` will connect on port `6380`.
 - `host`: The server hostname or IP address. Defaults to `"localhost"`.
 - `port`: The server port. Defaults to `6379`.
@@ -147,7 +149,7 @@ SENTINELS = [{ host: '127.0.0.1', port: 26380 },
 redis_config = RedisClient.sentinel(name: 'mymaster', sentinels: SENTINELS, role: :master, password: 'mysecret')
 ```
 
-So you have to provide Sentinel credential and Redis explictly even they are the same
+So you have to provide Sentinel credential and Redis explicitly even they are the same
 
 ```ruby
 # Use 'mysecret' to authenticate against the mymaster instance and sentinel
@@ -330,6 +332,27 @@ end
 # => ["OK", 1]
 ```
 
+#### Exception management
+
+The `exception` flag in the `#pipelined` method of `RedisClient` is a feature that modifies the pipeline execution
+behavior. When set to `false`, it doesn't raise an exception when a command error occurs. Instead, it allows the
+pipeline to execute all commands, and any failed command will be available in the returned array. (Defaults to `true`)
+
+```ruby
+results = redis.pipelined(exception: false) do |pipeline|
+  pipeline.call("SET", "foo", "bar") # => nil
+  pipeline.call("DOESNOTEXIST", 12) # => nil
+  pipeline.call("INCR", "baz") # => nil
+end
+# results => ["OK", #<RedisClient::CommandError: ERR unknown command 'DOESNOTEXIST', with args beginning with: '12'>, 2]
+
+results.each do |result|
+  if result.is_a?(RedisClient::CommandError)
+    # Do something with the failed result
+  end
+end
+```
+
 ### Transactions
 
 You can use [`MULTI/EXEC` to run a number of commands in an atomic fashion](https://redis.io/topics/transactions).
@@ -501,7 +524,7 @@ recover for a while.
 
 [Circuit breakers are a pattern that does exactly that](https://en.wikipedia.org/wiki/Circuit_breaker_design_pattern).
 
-Configuation options:
+Configuration options:
 
   - `error_threshold`. The amount of errors to encounter within `error_threshold_timeout` amount of time before opening the circuit, that is to start rejecting requests instantly.
   - `error_threshold_timeout`. The amount of time in seconds that `error_threshold` errors must occur to open the circuit. Defaults to `error_timeout` seconds if not set.

data/Rakefile

@@ -71,12 +71,15 @@ namespace :hiredis do
   end
 end
 
-benchmark_suites = %w(single pipelined)
+benchmark_suites = %w(single pipelined drivers)
 benchmark_modes = %i[ruby yjit hiredis]
 namespace :benchmark do
   benchmark_suites.each do |suite|
     benchmark_modes.each do |mode|
+      next if suite == "drivers" && mode == :hiredis
+
       name = "#{suite}_#{mode}"
+      desc name
       task name do
         output_path = "benchmark/#{name}.md"
         sh "rm", "-f", output_path

data/lib/redis_client/config.rb

@@ -91,6 +91,10 @@ class RedisClient
         @username || DEFAULT_USERNAME
       end
 
+      def resolved?
+        true
+      end
+
       def sentinel?
         false
       end
@@ -124,10 +128,23 @@ class RedisClient
 
       def server_url
         if path
-          "#{path}/#{db}"
+          url = "unix://#{path}"
+          if db != 0
+            url = "#{url}?db=#{db}"
+          end
         else
-          "redis#{'s' if ssl?}://#{host}:#{port}/#{db}"
+          # add brackets to IPv6 address
+          redis_host = if host.count(":") >= 2
+            "[#{host}]"
+          else
+            host
+          end
+          url = "redis#{'s' if ssl?}://#{redis_host}:#{port}"
+          if db != 0
+            url = "#{url}/#{db}"
+          end
         end
+        url
       end
 
       private
@@ -151,6 +168,12 @@ class RedisClient
         if @db && @db != 0
           prelude << ["SELECT", @db.to_s]
         end
+
+        # Deep freeze all the strings and commands
+        prelude.map! do |commands|
+          commands = commands.map { |str| str.frozen? ? str : str.dup.freeze }
+          commands.freeze
+        end
         prelude.freeze
       end
     end
@@ -176,15 +199,20 @@ class RedisClient
         }.compact.merge(kwargs)
         host ||= url_config.host
         port ||= url_config.port
+        path ||= url_config.path
         username ||= url_config.username
         password ||= url_config.password
       end
 
       super(username: username, password: password, **kwargs)
 
-      @host = host || DEFAULT_HOST
-      @port = Integer(port || DEFAULT_PORT)
-      @path = path
+      if @path = path
+        @host = nil
+        @port = nil
+      else
+        @host = host || DEFAULT_HOST
+        @port = Integer(port || DEFAULT_PORT)
+      end
     end
   end
 end

data/lib/redis_client/connection_mixin.rb

@@ -28,18 +28,19 @@ class RedisClient
     def call(command, timeout)
       @pending_reads += 1
       write(command)
-      result = read(timeout)
+      result = read(connection_timeout(timeout))
       @pending_reads -= 1
       if result.is_a?(Error)
         result._set_command(command)
+        result._set_config(config)
         raise result
       else
         result
       end
     end
 
-    def call_pipelined(commands, timeouts)
-      exception = nil
+    def call_pipelined(commands, timeouts, exception: true)
+      first_exception = nil
 
       size = commands.size
       results = Array.new(commands.size)
@@ -48,20 +49,38 @@ class RedisClient
 
       size.times do |index|
         timeout = timeouts && timeouts[index]
-        result = read(timeout)
+        result = read(connection_timeout(timeout))
         @pending_reads -= 1
-        if result.is_a?(Error)
+
+        # A multi/exec command can return an array of results.
+        # An error from a multi/exec command is handled in Multi#_coerce!.
+        if result.is_a?(Array)
+          result.each do |res|
+            res._set_config(config) if res.is_a?(Error)
+          end
+        elsif result.is_a?(Error)
           result._set_command(commands[index])
-          exception ||= result
+          result._set_config(config)
+          first_exception ||= result
         end
+
         results[index] = result
       end
 
-      if exception
-        raise exception
+      if first_exception && exception
+        raise first_exception
       else
         results
       end
     end
+
+    def connection_timeout(timeout)
+      return timeout unless timeout && timeout > 0
+
+      # Can't use the command timeout argument as the connection timeout
+      # otherwise it would be very racy. So we add the regular read_timeout on top
+      # to account for the network delay.
+      timeout + config.read_timeout
+    end
   end
 end

data/lib/redis_client/decorator.rb

@@ -47,8 +47,8 @@ class RedisClient
       end
       ruby2_keywords :with if respond_to?(:ruby2_keywords, true)
 
-      def pipelined
-        @client.pipelined { |p| yield @_pipeline_class.new(p) }
+      def pipelined(exception: true)
+        @client.pipelined(exception: exception) { |p| yield @_pipeline_class.new(p) }
       end
 
       def multi(**kwargs)

data/lib/redis_client/ruby_connection/buffered_io.rb

@@ -10,14 +10,80 @@ class RedisClient
 
       attr_accessor :read_timeout, :write_timeout
 
-      def initialize(io, read_timeout:, write_timeout:, chunk_size: 4096)
-        @io = io
-        @buffer = "".b
-        @offset = 0
-        @chunk_size = chunk_size
-        @read_timeout = read_timeout
-        @write_timeout = write_timeout
-        @blocking_reads = false
+      if String.method_defined?(:byteindex) # Ruby 3.2+
+        ENCODING = Encoding::UTF_8
+
+        def initialize(io, read_timeout:, write_timeout:, chunk_size: 4096)
+          @io = io
+          @buffer = +""
+          @offset = 0
+          @chunk_size = chunk_size
+          @read_timeout = read_timeout
+          @write_timeout = write_timeout
+          @blocking_reads = false
+        end
+
+        def gets_chomp
+          fill_buffer(false) if @offset >= @buffer.bytesize
+          until eol_index = @buffer.byteindex(EOL, @offset)
+            fill_buffer(false)
+          end
+
+          line = @buffer.byteslice(@offset, eol_index - @offset)
+          @offset = eol_index + EOL_SIZE
+          line
+        end
+
+        def read_chomp(bytes)
+          ensure_remaining(bytes + EOL_SIZE)
+          str = @buffer.byteslice(@offset, bytes)
+          @offset += bytes + EOL_SIZE
+          str
+        end
+
+        private def ensure_line
+          fill_buffer(false) if @offset >= @buffer.bytesize
+          until @buffer.byteindex(EOL, @offset)
+            fill_buffer(false)
+          end
+        end
+      else
+        ENCODING = Encoding::BINARY
+
+        def initialize(io, read_timeout:, write_timeout:, chunk_size: 4096)
+          @io = io
+          @buffer = "".b
+          @offset = 0
+          @chunk_size = chunk_size
+          @read_timeout = read_timeout
+          @write_timeout = write_timeout
+          @blocking_reads = false
+        end
+
+        def gets_chomp
+          fill_buffer(false) if @offset >= @buffer.bytesize
+          until eol_index = @buffer.index(EOL, @offset)
+            fill_buffer(false)
+          end
+
+          line = @buffer.byteslice(@offset, eol_index - @offset)
+          @offset = eol_index + EOL_SIZE
+          line
+        end
+
+        def read_chomp(bytes)
+          ensure_remaining(bytes + EOL_SIZE)
+          str = @buffer.byteslice(@offset, bytes)
+          @offset += bytes + EOL_SIZE
+          str.force_encoding(Encoding::UTF_8)
+        end
+
+        private def ensure_line
+          fill_buffer(false) if @offset >= @buffer.bytesize
+          until @buffer.index(EOL, @offset)
+            fill_buffer(false)
+          end
+        end
       end
 
       def close
@@ -82,28 +148,35 @@ class RedisClient
       end
 
       def getbyte
-        ensure_remaining(1)
-        byte = @buffer.getbyte(@offset)
+        unless byte = @buffer.getbyte(@offset)
+          ensure_remaining(1)
+          byte = @buffer.getbyte(@offset)
+        end
         @offset += 1
         byte
       end
 
-      def gets_chomp
-        fill_buffer(false) if @offset >= @buffer.bytesize
-        until eol_index = @buffer.index(EOL, @offset)
-          fill_buffer(false)
-        end
+      def gets_integer
+        int = 0
+        offset = @offset
+        while true
+          chr = @buffer.getbyte(offset)
 
-        line = @buffer.byteslice(@offset, eol_index - @offset)
-        @offset = eol_index + EOL_SIZE
-        line
-      end
+          if chr
+            if chr == 13 # "\r".ord
+              @offset = offset + 2
+              break
+            else
+              int = (int * 10) + chr - 48
+            end
+            offset += 1
+          else
+            ensure_line
+            return gets_integer
+          end
+        end
 
-      def read_chomp(bytes)
-        ensure_remaining(bytes + EOL_SIZE)
-        str = @buffer.byteslice(@offset, bytes)
-        @offset += bytes + EOL_SIZE
-        str
+        int
       end
 
       private
@@ -117,7 +190,9 @@ class RedisClient
 
       def fill_buffer(strict, size = @chunk_size)
         remaining = size
-        empty_buffer = @offset >= @buffer.bytesize
+        buffer_size = @buffer.bytesize
+        start = @offset - buffer_size
+        empty_buffer = start >= 0
 
         loop do
           bytes = if empty_buffer
@@ -125,26 +200,40 @@ class RedisClient
           else
             @io.read_nonblock([remaining, @chunk_size].max, exception: false)
           end
+
           case bytes
-          when String
-            if empty_buffer
-              @offset = 0
-              empty_buffer = false
-            else
-              @buffer << bytes
-            end
-            remaining -= bytes.bytesize
-            return if !strict || remaining <= 0
           when :wait_readable
+            # Ref: https://github.com/redis-rb/redis-client/issues/190
+            # SSLSocket always clear the provided buffer, even when it didn't
+            # read anything. So we need to reset the offset accordingly.
+            if empty_buffer && @buffer.empty?
+              @offset -= buffer_size
+            end
+
             unless @io.to_io.wait_readable(@read_timeout)
               raise ReadTimeoutError, "Waited #{@read_timeout} seconds" unless @blocking_reads
             end
           when :wait_writable
+            # Ref: https://github.com/redis-rb/redis-client/issues/190
+            # SSLSocket always clear the provided buffer, even when it didn't
+            # read anything. So we need to reset the offset accordingly.
+            if empty_buffer && @buffer.empty?
+              @offset -= buffer_size
+            end
+
             @io.to_io.wait_writable(@write_timeout) or raise(WriteTimeoutError, "Waited #{@write_timeout} seconds")
           when nil
             raise EOFError
           else
-            raise "Unexpected `read_nonblock` return: #{bytes.inspect}"
+            if empty_buffer
+              @offset = start
+              empty_buffer = false
+              @buffer.force_encoding(ENCODING) unless @buffer.encoding == ENCODING
+            else
+              @buffer << bytes.force_encoding(ENCODING)
+            end
+            remaining -= bytes.bytesize
+            return if !strict || remaining <= 0
           end
         end
       end

data/lib/redis_client/ruby_connection/resp3.rb

@@ -10,12 +10,12 @@ class RedisClient
 
     EOL = "\r\n".b.freeze
     EOL_SIZE = EOL.bytesize
-    DUMP_TYPES = { # rubocop:disable Style/MutableConstant
+    DUMP_TYPES = {
       String => :dump_string,
       Symbol => :dump_symbol,
       Integer => :dump_numeric,
       Float => :dump_numeric,
-    }
+    }.freeze
     PARSER_TYPES = {
       '#' => :parse_boolean,
       '$' => :parse_blob,
@@ -57,7 +57,7 @@ class RedisClient
     def dump_any(object, buffer)
       method = DUMP_TYPES.fetch(object.class) do |unexpected_class|
         if superclass = DUMP_TYPES.keys.find { |t| t > unexpected_class }
-          DUMP_TYPES[unexpected_class] = DUMP_TYPES[superclass]
+          DUMP_TYPES[superclass]
         else
           raise TypeError, "Unsupported command argument type: #{unexpected_class}"
         end
@@ -111,15 +111,39 @@ class RedisClient
 
     def parse(io)
       type = io.getbyte
-      method = PARSER_TYPES.fetch(type) do
+      if type == 35 # '#'.ord
+        parse_boolean(io)
+      elsif type == 36 # '$'.ord
+        parse_blob(io)
+      elsif type == 43 # '+'.ord
+        parse_string(io)
+      elsif type == 61 # '='.ord
+        parse_verbatim_string(io)
+      elsif type == 45 # '-'.ord
+        parse_error(io)
+      elsif type == 58 # ':'.ord
+        parse_integer(io)
+      elsif type == 40 # '('.ord
+        parse_integer(io)
+      elsif type == 44 # ','.ord
+        parse_double(io)
+      elsif type == 95 # '_'.ord
+        parse_null(io)
+      elsif type == 42 # '*'.ord
+        parse_array(io)
+      elsif type == 37 # '%'.ord
+        parse_map(io)
+      elsif type == 126 # '~'.ord
+        parse_set(io)
+      elsif type == 62 # '>'.ord
+        parse_array(io)
+      else
         raise UnknownType, "Unknown sigil type: #{type.chr.inspect}"
       end
-      send(method, io)
     end
 
     def parse_string(io)
       str = io.gets_chomp
-      str.force_encoding(Encoding.default_external)
       str.force_encoding(Encoding::BINARY) unless str.valid_encoding?
       str.freeze
     end
@@ -140,17 +164,17 @@ class RedisClient
     end
 
     def parse_array(io)
-      parse_sequence(io, parse_integer(io))
+      parse_sequence(io, io.gets_integer)
     end
 
     def parse_set(io)
-      parse_sequence(io, parse_integer(io))
+      parse_sequence(io, io.gets_integer)
     end
 
     def parse_map(io)
       hash = {}
-      parse_integer(io).times do
-        hash[parse(io)] = parse(io)
+      io.gets_integer.times do
+        hash[parse(io).freeze] = parse(io)
       end
       hash
     end
@@ -192,11 +216,10 @@ class RedisClient
     end
 
     def parse_blob(io)
-      bytesize = parse_integer(io)
+      bytesize = io.gets_integer
       return if bytesize < 0 # RESP2 nil type
 
       str = io.read_chomp(bytesize)
-      str.force_encoding(Encoding.default_external)
       str.force_encoding(Encoding::BINARY) unless str.valid_encoding?
       str
     end

data/lib/redis_client/ruby_connection.rb

@@ -40,6 +40,8 @@ class RedisClient
 
     SUPPORTS_RESOLV_TIMEOUT = Socket.method(:tcp).parameters.any? { |p| p.last == :resolv_timeout }
 
+    attr_reader :config
+
     def initialize(config, connect_timeout:, read_timeout:, write_timeout:)
       super()
       @config = config
@@ -72,8 +74,8 @@ class RedisClient
       buffer = RESP3.dump(command)
       begin
         @io.write(buffer)
-      rescue SystemCallError, IOError => error
-        raise ConnectionError, error.message
+      rescue SystemCallError, IOError, OpenSSL::SSL::SSLError => error
+        raise ConnectionError.with_config(error.message, config)
       end
     end
 
@@ -84,8 +86,8 @@ class RedisClient
       end
       begin
         @io.write(buffer)
-      rescue SystemCallError, IOError => error
-        raise ConnectionError, error.message
+      rescue SystemCallError, IOError, OpenSSL::SSL::SSLError => error
+        raise ConnectionError.with_config(error.message, config)
       end
     end
 
@@ -96,9 +98,9 @@ class RedisClient
         @io.with_timeout(timeout) { RESP3.load(@io) }
       end
     rescue RedisClient::RESP3::UnknownType => error
-      raise RedisClient::ProtocolError, error.message
+      raise RedisClient::ProtocolError.with_config(error.message, config)
     rescue SystemCallError, IOError, OpenSSL::SSL::SSLError => error
-      raise ConnectionError, error.message
+      raise ConnectionError.with_config(error.message, config)
     end
 
     def measure_round_trip_delay
@@ -130,9 +132,9 @@ class RedisClient
         loop do
           case status = socket.connect_nonblock(exception: false)
           when :wait_readable
-            socket.to_io.wait_readable(@connect_timeout) or raise CannotConnectError
+            socket.to_io.wait_readable(@connect_timeout) or raise CannotConnectError.with_config("", config)
           when :wait_writable
-            socket.to_io.wait_writable(@connect_timeout) or raise CannotConnectError
+            socket.to_io.wait_writable(@connect_timeout) or raise CannotConnectError.with_config("", config)
           when socket
             break
           else

data/lib/redis_client/sentinel_config.rb

@@ -112,6 +112,12 @@ class RedisClient
       end
     end
 
+    def resolved?
+      @mutex.synchronize do
+        !!@config
+      end
+    end
+
     private
 
     def sentinels_to_configs(sentinels)
@@ -188,6 +194,10 @@ class RedisClient
           if success
             @sentinel_configs.unshift(@sentinel_configs.delete(sentinel_config))
           end
+          # Redis Sentinels may be configured to have a lower maxclients setting than
+          # the Redis nodes. Close the connection to the Sentinel node to avoid using
+          # a connection.
+          sentinel_client.close
         end
       end
 

data/lib/redis_client/url_config.rb

@@ -4,26 +4,41 @@ require "uri"
 
 class RedisClient
   class URLConfig
-    DEFAULT_SCHEMA = "redis"
-    SSL_SCHEMA = "rediss"
-
     attr_reader :url, :uri
 
     def initialize(url)
       @url = url
       @uri = URI(url)
-      unless uri.scheme == DEFAULT_SCHEMA || uri.scheme == SSL_SCHEMA
-        raise ArgumentError, "Invalid URL: #{url.inspect}"
+      @unix = false
+      @ssl = false
+      case uri.scheme
+      when "redis"
+        # expected
+      when "rediss"
+        @ssl = true
+      when "unix", nil
+        @unix = true
+      else
+        raise ArgumentError, "Unknown URL scheme: #{url.inspect}"
       end
     end
 
     def ssl?
-      @uri.scheme == SSL_SCHEMA
+      @ssl
     end
 
     def db
-      db_path = uri.path&.delete_prefix("/")
-      Integer(db_path) if db_path && !db_path.empty?
+      unless @unix
+        db_path = uri.path&.delete_prefix("/")
+        return Integer(db_path) if db_path && !db_path.empty?
+      end
+
+      unless uri.query.nil? || uri.query.empty?
+        _, db_query = URI.decode_www_form(uri.query).find do |key, _|
+          key == "db"
+        end
+        return Integer(db_query) if db_query && !db_query.empty?
+      end
     end
 
     def username
@@ -44,6 +59,12 @@ class RedisClient
       uri.host.sub(/\A\[(.*)\]\z/, '\1')
     end
 
+    def path
+      if @unix
+        File.join(*[uri.host, uri.path].compact)
+      end
+    end
+
     def port
       return unless uri.port
 

data/lib/redis_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class RedisClient
-  VERSION = "0.19.1"
+  VERSION = "0.22.2"
 end

data/lib/redis_client.rb

@@ -77,7 +77,29 @@ class RedisClient
     end
   end
 
-  Error = Class.new(StandardError)
+  module HasConfig
+    attr_reader :config
+
+    def _set_config(config)
+      @config = config
+    end
+
+    def message
+      return super unless config&.resolved?
+
+      "#{super} (#{config.server_url})"
+    end
+  end
+
+  class Error < StandardError
+    include HasConfig
+
+    def self.with_config(message, config = nil)
+      new(message).tap do |error|
+        error._set_config(config)
+      end
+    end
+  end
 
   ProtocolError = Class.new(Error)
   UnsupportedServer = Class.new(Error)
@@ -114,7 +136,7 @@ class RedisClient
         end
         code ||= error_message.split(' ', 2).first
         klass = ERRORS.fetch(code, self)
-        klass.new(error_message)
+        klass.new(error_message.strip)
       end
     end
   end
@@ -399,7 +421,7 @@ class RedisClient
     ensure_connected(retryable: false, &block)
   end
 
-  def pipelined
+  def pipelined(exception: true)
     pipeline = Pipeline.new(@command_builder)
     yield pipeline
 
@@ -409,7 +431,7 @@ class RedisClient
       results = ensure_connected(retryable: pipeline._retryable?) do |connection|
         commands = pipeline._commands
         @middlewares.call_pipelined(commands, config) do
-          connection.call_pipelined(commands, pipeline._timeouts)
+          connection.call_pipelined(commands, pipeline._timeouts, exception: exception)
         end
       end
 
@@ -750,10 +772,13 @@ class RedisClient
         end
       end
     end
-  rescue FailoverError, CannotConnectError
-    raise
+  rescue FailoverError, CannotConnectError => error
+    error._set_config(config)
+    raise error
   rescue ConnectionError => error
-    raise CannotConnectError, error.message, error.backtrace
+    connect_error = CannotConnectError.with_config(error.message, config)
+    connect_error.set_backtrace(error.backtrace)
+    raise connect_error
   rescue CommandError => error
     if error.message.match?(/ERR unknown command ['`]HELLO['`]/)
       raise UnsupportedServer,

data/redis-client.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.summary = "Simple low-level client for Redis 6+"
   spec.homepage = "https://github.com/redis-rb/redis-client"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.5.0"
+  spec.required_ruby_version = ">= 2.6.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-client
 version: !ruby/object:Gem::Version
-  version: 0.19.1
+  version: 0.22.2
 platform: ruby
 authors:
 - Jean Boussier
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-12-21 00:00:00.000000000 Z
+date: 2024-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -70,14 +70,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Simple low-level client for Redis 6+