redis-client 0.11.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f28d878a923f684e1ddade2a735339dc7ae55d3091b3d21b812fcf1b232b8fe
-  data.tar.gz: 5cc874fa373695185c4b5f040e8368be66550596838faadab8b3e57e45f8c0b0
+  metadata.gz: c8038f4b1f7316e16bd3561f43311334a9e69896e54a75b1a9666cb2718ba3b0
+  data.tar.gz: e37514256b44be8b0d5832c3d944c8d3be2a8228bff1fa05ac3a28347c6445ae
 SHA512:
-  metadata.gz: ba5313f360e675d1e751f6c5138290facab7e3ea043d5328b14556050ceb44155947ad670077e22b1fb04b2aa5738a6d6b77454b5d31e0a4641c1e705f3ba545
-  data.tar.gz: 45463aae9b8d188cc5d1a2c0604962001bafcd266fb526fecb7ddee5081fbc28a9a5a27b8a09525b515d69266cf7740424a50408e62cf2361debe1ffb52b3d9e
+  metadata.gz: f02d99ca8c468cf38a4527817257169104d7f64cea5110c170d434d82b7f30cfea8338e0e746504d2d8c29866f81ef6cf4e81d014400ff364d5138d7653dfdc3
+  data.tar.gz: 2a66a02666e43b17c5007f2ae99c08f331cc46eb4645330b0f3df31fec39080ab779860bebcaa40add2beacc057d7a4ce586a7bc4453c50ddb0c4a10b677281f

data/CHANGELOG.md

@@ -1,5 +1,61 @@
 # Unreleased
 
+# 0.17.0
+
+- Adds `sentinel_username` and `sentinel_password` options for `RedisClient#sentinel`
+
+# 0.16.0
+
+- Add `RedisClient#disable_reconnection`.
+- Reverted the special discard of connection. A regular `close(2)` should be enough.
+
+# 0.15.0
+
+- Discard sockets rather than explictly close them when a fork is detected. #126.
+- Allow to configure sentinel client via url. #117.
+- Fix sentinel to preverse the auth/password when refreshing the sentinel list. #107.
+
+# 0.14.1
+
+- Include the timeout value in TimeoutError messages.
+- Fix connection keep-alive on FreeBSD. #102.
+
+# 0.14.0
+
+- Implement Sentinels list automatic refresh.
+- hiredis binding now implement GC compaction and write barriers.
+- hiredis binding now properly release the GVL around `connect(2)`.
+- hiredis the client memory is now re-used on reconnection when possible to reduce allocation churn.
+
+# 0.13.0
+
+- Enable TCP keepalive on redis sockets. It sends a keep alive probe every 15 seconds for 2 minutes. #94.
+
+# 0.12.2
+
+- Cache calls to `Process.pid` on Ruby 3.1+. #91.
+
+# 0.12.1
+
+- Improve compatibility with `uri 0.12.0` (default in Ruby 3.2.0).
+
+# 0.12.0
+
+- hiredis: fix a compilation issue on macOS and Ruby 3.2.0. See: #79
+- Close connection on MASTERDOWN errors. Similar to READONLY.
+- Add a `circuit_breaker` configuration option for cache servers and other disposable Redis servers. See #55 / #70
+
+# 0.11.2
+
+- Close connection on READONLY errors. Fix: #64
+- Handle Redis 6+ servers with a missing HELLO command. See: #67
+- Validate `url` parameters a bit more strictly. Fix #61
+
+# 0.11.1
+
+- hiredis: Workaround a compilation bug with Xcode 14.0. Fix: #58
+- Accept `URI` instances as `uri` parameter.
+
 # 0.11.0
 
 - hiredis: do not eagerly close the connection on read timeout, let the caller decide if a timeout is final.
@@ -19,7 +75,7 @@
 
 - Make the client resilient to `Timeout.timeout` or `Thread#kill` use (it still is very much discouraged to use either).
   Use of async interrupts could cause responses to be interleaved.
-- hiredis: handle commands returning a top-level `false` (no command does this today, but some extensions might). 
+- hiredis: handle commands returning a top-level `false` (no command does this today, but some extensions might).
 - Workaround a bug in Ruby 2.6 causing a crash if the `debug` gem is enabled when `redis-client` is being required. Fix: #48
 
 # 0.8.0
@@ -38,7 +94,7 @@
 
 - Raise a distinct `RedisClient::OutOfMemoryError`, for Redis `OOM` errors.
 - Fix the instrumentation API to be called even for authentication commands.
-- Fix `url:` configuration to accept a trailing slash. 
+- Fix `url:` configuration to accept a trailing slash.
 
 # 0.7.1
 

data/Gemfile.lock

@@ -1,16 +1,16 @@
 PATH
   remote: .
   specs:
-    redis-client (0.11.0)
+    redis-client (0.17.0)
       connection_pool
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
-    benchmark-ips (2.10.0)
+    benchmark-ips (2.12.0)
     byebug (11.1.3)
-    connection_pool (2.3.0)
+    connection_pool (2.4.1)
     hiredis (0.6.3)
     hiredis (0.6.3-java)
     minitest (5.15.0)
@@ -19,7 +19,7 @@ GEM
       ast (~> 2.4.1)
     rainbow (3.1.1)
     rake (13.0.6)
-    rake-compiler (1.2.0)
+    rake-compiler (1.2.5)
       rake
     redis (4.6.0)
     regexp_parser (2.5.0)
@@ -38,7 +38,7 @@ GEM
     rubocop-minitest (0.19.1)
       rubocop (>= 0.90, < 2.0)
     ruby-progressbar (1.11.0)
-    stackprof (0.2.22)
+    stackprof (0.2.25)
     toxiproxy (2.0.2)
     unicode-display_width (2.2.0)
 

data/README.md

@@ -42,7 +42,7 @@ redis.with do |r|
 end
 ```
 
-If you are working in a single threaded environment, or wish to use your own connection pooling mechanism,
+If you are working in a single-threaded environment, or wish to use your own connection pooling mechanism,
 you can obtain a raw client with `#new_client`
 
 ```ruby
@@ -63,15 +63,15 @@ 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.
-  Note that all other configurations take precedence, e.g. `RedisClient.config(url: "redis://localhost:3000" port: 6380)` will connect on port `6380`.
+  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`.
 - `path`: The path to a UNIX socket, if set `url`, `host` and `port` are ignored.
-- `ssl`: Wether to connect using SSL or not.
+- `ssl`: Whether to connect using SSL or not.
 - `ssl_params`: A configuration Hash passed to [`OpenSSL::SSL::SSLContext#set_params`](https://www.rubydoc.info/stdlib/openssl/OpenSSL%2FSSL%2FSSLContext:set_params), notable options include:
   - `cert`: The path to the client certificate (e.g. `client.crt`).
   - `key`: The path to the client key (e.g. `client.key`).
-  - `ca_file`: The certificate authority to use, useful for self signed certificates (e.g. `ca.crt`),
+  - `ca_file`: The certificate authority to use, useful for self-signed certificates (e.g. `ca.crt`),
 - `db`: The database to select after connecting, defaults to `0`.
 - `id` ID for the client connection, assigns name to current connection by sending `CLIENT SETNAME`.
 - `username` Username to authenticate against server, defaults to `"default"`.
@@ -81,8 +81,9 @@ redis.call("GET", "mykey")
 - `read_timeout`: The read timeout, takes precedence over the general timeout when reading responses from the server.
 - `write_timeout`: The write timeout, takes precedence over the general timeout when sending commands to the server.
 - `reconnect_attempts`: Specify how many times the client should retry to send queries. Defaults to `0`. Makes sure to read the [reconnection section](#reconnection) before enabling it.
+- `circuit_breaker`: A Hash with circuit breaker configuration. Defaults to `nil`. See the [circuit breaker section](#circuit-breaker) for details.
 - `protocol:` The version of the RESP protocol to use. Default to `3`.
-- `custom`: A user owned value ignored by `redis-client` but available as `Config#custom`. This can be used to hold middleware configurations and other user specific metadatas.
+- `custom`: A user-owned value ignored by `redis-client` but available as `Config#custom`. This can be used to hold middleware configurations and other user-specific metadata.
 
 ### Sentinel support
 
@@ -127,6 +128,41 @@ but a few so that if one is down the client will try the next one. The client
 is able to remember the last Sentinel that was able to reply correctly and will
 use it for the next requests.
 
+To [authenticate](https://redis.io/docs/management/sentinel/#configuring-sentinel-instances-with-authentication) Sentinel itself, you can specify the `sentinel_username` and `sentinel_password` options per instance. Exclude the `sentinel_username` option if you're using password-only authentication.
+
+```ruby
+SENTINELS = [{ host: '127.0.0.1', port: 26380},
+             { host: '127.0.0.1', port: 26381}]
+
+redis_config = RedisClient.sentinel(name: 'mymaster', sentinel_username: 'appuser', sentinel_password: 'mysecret', sentinels: SENTINELS, role: :master)
+```
+
+If you specify a username and/or password at the top level for your main Redis instance, Sentinel *will not* using thouse credentials
+
+```ruby
+# Use 'mysecret' to authenticate against the mymaster instance, but skip authentication for the sentinels:
+SENTINELS = [{ host: '127.0.0.1', port: 26380 },
+             { host: '127.0.0.1', port: 26381 }]
+
+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
+
+```ruby
+# Use 'mysecret' to authenticate against the mymaster instance and sentinel
+SENTINELS = [{ host: '127.0.0.1', port: 26380 },
+             { host: '127.0.0.1', port: 26381 }]
+
+redis_config = RedisClient.sentinel(name: 'mymaster', sentinels: SENTINELS, role: :master, password: 'mysecret', sentinel_password: 'mysecret')
+```
+
+Also the `name`, `password`, `username` and `db` for Redis instance can be passed as an url:
+
+```ruby
+redis_config = RedisClient.sentinel(url: "redis://appuser:mysecret@mymaster/10", sentinels: SENTINELS, role: :master)
+```
+
 ### Type support
 
 Only a select few Ruby types are supported as arguments beside strings.
@@ -342,6 +378,10 @@ loop do
 end
 ```
 
+*Note*: pubsub connections are stateful, as such they won't ever reconnect automatically.
+The caller is responsible for reconnecting if the connection is lost and to resubscribe to
+all channels.
+
 ## Production
 
 ### Instrumentation and Middlewares
@@ -375,7 +415,7 @@ redis_config = RedisClient.config(middlewares: [AnotherRedisInstrumentation])
 redis_config.new_client
 ```
 
-If middlewares need a client specific configuration, `Config#custom` can be used
+If middlewares need a client-specific configuration, `Config#custom` can be used
 
 ```ruby
 module MyGlobalRedisInstrumentation
@@ -426,24 +466,64 @@ It can be set as a number of retries:
 redis_config = RedisClient.config(reconnect_attempts: 1)
 ```
 
-Or as a list of sleep durations for implementing exponential backoff:
-
-```ruby
-redis_config = RedisClient.config(reconnect_attempts: [0, 0.05, 0.1])
-```
-
 **Important Note**: Retrying may cause commands to be issued more than once to the server, so in the case of
 non-idempotent commands such as `LPUSH` or `INCR`, it may cause consistency issues.
 
 To selectively disable automatic retries, you can use the `#call_once` method:
 
 ```ruby
-redis_config = RedisClient.config(reconnect_attempts: [0, 0.05, 0.1])
+redis_config = RedisClient.config(reconnect_attempts: 3)
 redis = redis_config.new_client
 redis.call("GET", "counter") # Will be retried up to 3 times.
 redis.call_once("INCR", "counter") # Won't be retried.
 ```
 
+**Note**: automatic reconnection doesn't apply to pubsub clients as their connection is stateful.
+
+### Exponential backoff
+
+Alternatively, `reconnect_attempts` accepts a list of sleep durations for implementing exponential backoff:
+
+```ruby
+redis_config = RedisClient.config(reconnect_attempts: [0, 0.05, 0.1])
+```
+
+This configuration is generally used when the Redis server is expected to failover or recover relatively quickly and
+that it's not really possible to continue without issuing the command.
+
+When the Redis server is used as an ephemeral cache, circuit breakers are generally preferred.
+
+### Circuit Breaker
+
+When Redis is used as a cache and a connection error happens, you may not want to retry as it might take
+longer than to recompute the value. Instead it's likely preferable to mark the server as unavailable and let it
+recover for a while.
+
+[Circuit breakers are a pattern that does exactly that](https://en.wikipedia.org/wiki/Circuit_breaker_design_pattern).
+
+Configuation 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.
+  - `error_timeout`. The amount of time in seconds until trying to query the resource again.
+  - `success_threshold`. The amount of successes on the circuit until closing it again, that is to start accepting all requests to the circuit.
+
+```ruby
+RedisClient.config(
+  circuit_breaker: {
+    # Stop querying the server after 3 errors happened in a 2 seconds window
+    error_threshold: 3,
+    error_threshold_timeout: 2,
+
+    # Try querying again after 1 second
+    error_timeout: 1,
+
+    # Stay in half-open state until 3 queries succeeded.
+    success_threshold: 3,
+  }
+)
+```
+
 ### Drivers
 
 `redis-client` ships with a pure Ruby socket implementation.

data/Rakefile

@@ -26,6 +26,7 @@ namespace :test do
     t.libs << "test"
     t.libs << "lib"
     t.test_files = FileList["test/**/*_test.rb"].exclude("test/sentinel/*_test.rb")
+    t.options = '-v' if ENV['CI'] || ENV['VERBOSE']
   end
 
   Rake::TestTask.new(:sentinel) do |t|
@@ -33,13 +34,16 @@ namespace :test do
     t.libs << "test"
     t.libs << "lib"
     t.test_files = FileList["test/sentinel/*_test.rb"]
+    t.options = '-v' if ENV['CI'] || ENV['VERBOSE']
   end
 
   Rake::TestTask.new(:hiredis) do |t|
     t.libs << "test/hiredis"
     t.libs << "test"
+    t.libs << "hiredis-client/lib"
     t.libs << "lib"
     t.test_files = FileList["test/**/*_test.rb"].exclude("test/sentinel/*_test.rb")
+    t.options = '-v' if ENV['CI'] || ENV['VERBOSE']
   end
 end
 

data/lib/redis_client/circuit_breaker.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+class RedisClient
+  class CircuitBreaker
+    module Middleware
+      def connect(config)
+        config.circuit_breaker.protect { super }
+      end
+
+      def call(_command, config)
+        config.circuit_breaker.protect { super }
+      end
+
+      def call_pipelined(_commands, config)
+        config.circuit_breaker.protect { super }
+      end
+    end
+
+    OpenCircuitError = Class.new(CannotConnectError)
+
+    attr_reader :error_timeout, :error_threshold, :error_threshold_timeout, :success_threshold
+
+    def initialize(error_threshold:, error_timeout:, error_threshold_timeout: error_timeout, success_threshold: 0)
+      @error_threshold = Integer(error_threshold)
+      @error_threshold_timeout = Float(error_threshold_timeout)
+      @error_timeout = Float(error_timeout)
+      @success_threshold = Integer(success_threshold)
+      @errors = []
+      @successes = 0
+      @state = :closed
+      @lock = Mutex.new
+    end
+
+    def protect
+      if @state == :open
+        refresh_state
+      end
+
+      case @state
+      when :open
+        raise OpenCircuitError, "Too many connection errors happened recently"
+      when :closed
+        begin
+          yield
+        rescue ConnectionError
+          record_error
+          raise
+        end
+      when :half_open
+        begin
+          result = yield
+          record_success
+          result
+        rescue ConnectionError
+          record_error
+          raise
+        end
+      else
+        raise "[BUG] RedisClient::CircuitBreaker unexpected @state (#{@state.inspect}})"
+      end
+    end
+
+    private
+
+    def refresh_state
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @lock.synchronize do
+        if @errors.last < (now - @error_timeout)
+          if @success_threshold > 0
+            @state = :half_open
+            @successes = 0
+          else
+            @errors.clear
+            @state = :closed
+          end
+        end
+      end
+    end
+
+    def record_error
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      expiry = now - @error_timeout
+      @lock.synchronize do
+        if @state == :closed
+          @errors.reject! { |t| t < expiry }
+        end
+        @errors << now
+        @successes = 0
+        if @state == :half_open || (@state == :closed && @errors.size >= @error_threshold)
+          @state = :open
+        end
+      end
+    end
+
+    def record_success
+      return unless @state == :half_open
+
+      @lock.synchronize do
+        return unless @state == :half_open
+
+        @successes += 1
+        if @successes >= @success_threshold
+          @state = :closed
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/config.rb

@@ -14,7 +14,7 @@ class RedisClient
     module Common
       attr_reader :db, :password, :id, :ssl, :ssl_params, :command_builder, :inherit_socket,
         :connect_timeout, :read_timeout, :write_timeout, :driver, :connection_prelude, :protocol,
-        :middlewares_stack, :custom
+        :middlewares_stack, :custom, :circuit_breaker
 
       alias_method :ssl?, :ssl
 
@@ -36,7 +36,8 @@ class RedisClient
         command_builder: CommandBuilder,
         inherit_socket: false,
         reconnect_attempts: false,
-        middlewares: false
+        middlewares: false,
+        circuit_breaker: nil
       )
         @username = username
         @password = password
@@ -66,6 +67,11 @@ class RedisClient
         @reconnect_attempts = reconnect_attempts
         @connection_prelude = build_connection_prelude
 
+        circuit_breaker = CircuitBreaker.new(**circuit_breaker) if circuit_breaker.is_a?(Hash)
+        if @circuit_breaker = circuit_breaker
+          middlewares = [CircuitBreaker::Middleware] + (middlewares || [])
+        end
+
         middlewares_stack = Middlewares
         if middlewares && !middlewares.empty?
           middlewares_stack = Class.new(Middlewares)
@@ -106,7 +112,9 @@ class RedisClient
       end
 
       def ssl_context
-        @ssl_context ||= @driver.ssl_context(@ssl_params || {})
+        if ssl
+          @ssl_context ||= @driver.ssl_context(@ssl_params || {})
+        end
       end
 
       def server_url
@@ -151,28 +159,26 @@ class RedisClient
       host: nil,
       port: nil,
       path: nil,
+      username: nil,
+      password: nil,
       **kwargs
     )
       if url
-        uri = URI.parse(url)
-        kwargs[:ssl] = uri.scheme == "rediss" unless kwargs.key?(:ssl)
-
-        kwargs[:username] ||= uri.user if uri.password && !uri.user.empty?
-
-        kwargs[:password] ||= if uri.user && !uri.password
-          URI.decode_www_form_component(uri.user)
-        elsif uri.user && uri.password
-          URI.decode_www_form_component(uri.password)
-        end
-
-        db_path = uri.path&.delete_prefix("/")
-        kwargs[:db] ||= Integer(db_path) if db_path && !db_path.empty?
+        url_config = URLConfig.new(url)
+        kwargs = {
+          ssl: url_config.ssl?,
+          db: url_config.db,
+        }.compact.merge(kwargs)
+        host ||= url_config.host
+        port ||= url_config.port
+        username ||= url_config.username
+        password ||= url_config.password
       end
 
-      super(**kwargs)
+      super(username: username, password: password, **kwargs)
 
-      @host = host || uri&.host&.sub(/\A\[(.*)\]\z/, '\1') || DEFAULT_HOST
-      @port = Integer(port || uri&.port || DEFAULT_PORT)
+      @host = host || DEFAULT_HOST
+      @port = Integer(port || DEFAULT_PORT)
       @path = path
     end
   end

data/lib/redis_client/connection_mixin.rb

@@ -6,9 +6,22 @@ class RedisClient
       @pending_reads = 0
     end
 
+    def reconnect
+      close
+      connect
+    end
+
+    def close
+      @pending_reads = 0
+      nil
+    end
+
     def revalidate
-      if @pending_reads == 0 && connected?
-        self
+      if @pending_reads > 0
+        close
+        false
+      else
+        connected?
       end
     end
 
@@ -17,7 +30,7 @@ class RedisClient
       write(command)
       result = read(timeout)
       @pending_reads -= 1
-      if result.is_a?(CommandError)
+      if result.is_a?(Error)
         result._set_command(command)
         raise result
       else
@@ -37,7 +50,7 @@ class RedisClient
         timeout = timeouts && timeouts[index]
         result = read(timeout)
         @pending_reads -= 1
-        if result.is_a?(CommandError)
+        if result.is_a?(Error)
           result._set_command(commands[index])
           exception ||= result
         end

data/lib/redis_client/pid_cache.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class RedisClient
+  module PIDCache
+    if !Process.respond_to?(:fork) # JRuby or TruffleRuby
+      @pid = Process.pid
+      singleton_class.attr_reader(:pid)
+    elsif Process.respond_to?(:_fork) # Ruby 3.1+
+      class << self
+        attr_reader :pid
+
+        def update!
+          @pid = Process.pid
+        end
+      end
+      update!
+
+      module CoreExt
+        def _fork
+          child_pid = super
+          PIDCache.update! if child_pid == 0
+          child_pid
+        end
+      end
+      Process.singleton_class.prepend(CoreExt)
+    else # Ruby 3.0 or older
+      class << self
+        def pid
+          Process.pid
+        end
+      end
+    end
+  end
+end

data/lib/redis_client/ruby_connection/buffered_io.rb

@@ -70,9 +70,9 @@ class RedisClient
               return total
             end
           when :wait_readable
-            @io.to_io.wait_readable(@read_timeout) or raise ReadTimeoutError
+            @io.to_io.wait_readable(@read_timeout) or raise(ReadTimeoutError, "Waited #{@read_timeout} seconds")
           when :wait_writable
-            @io.to_io.wait_writable(@write_timeout) or raise WriteTimeoutError
+            @io.to_io.wait_writable(@write_timeout) or raise(WriteTimeoutError, "Waited #{@write_timeout} seconds")
           when nil
             raise Errno::ECONNRESET
           else
@@ -137,12 +137,12 @@ class RedisClient
             return if !strict || remaining <= 0
           when :wait_readable
             unless @io.to_io.wait_readable(@read_timeout)
-              raise ReadTimeoutError unless @blocking_reads
+              raise ReadTimeoutError, "Waited #{@read_timeout} seconds" unless @blocking_reads
             end
           when :wait_writable
-            @io.to_io.wait_writable(@write_timeout) or raise WriteTimeoutError
+            @io.to_io.wait_writable(@write_timeout) or raise(WriteTimeoutError, "Waited #{@write_timeout} seconds")
           when nil
-            raise Errno::ECONNRESET
+            raise EOFError
           else
             raise "Unexpected `read_nonblock` return: #{bytes.inspect}"
           end

data/lib/redis_client/ruby_connection.rb

@@ -42,43 +42,11 @@ class RedisClient
 
     def initialize(config, connect_timeout:, read_timeout:, write_timeout:)
       super()
-      socket = if config.path
-        UNIXSocket.new(config.path)
-      else
-        sock = if SUPPORTS_RESOLV_TIMEOUT
-          Socket.tcp(config.host, config.port, connect_timeout: connect_timeout, resolv_timeout: connect_timeout)
-        else
-          Socket.tcp(config.host, config.port, connect_timeout: connect_timeout)
-        end
-        # disables Nagle's Algorithm, prevents multiple round trips with MULTI
-        sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-        sock
-      end
-
-      if config.ssl
-        socket = OpenSSL::SSL::SSLSocket.new(socket, config.ssl_context)
-        socket.hostname = config.host
-        loop do
-          case status = socket.connect_nonblock(exception: false)
-          when :wait_readable
-            socket.to_io.wait_readable(connect_timeout) or raise CannotConnectError
-          when :wait_writable
-            socket.to_io.wait_writable(connect_timeout) or raise CannotConnectError
-          when socket
-            break
-          else
-            raise "Unexpected `connect_nonblock` return: #{status.inspect}"
-          end
-        end
-      end
-
-      @io = BufferedIO.new(
-        socket,
-        read_timeout: read_timeout,
-        write_timeout: write_timeout,
-      )
-    rescue SystemCallError, OpenSSL::SSL::SSLError, SocketError => error
-      raise CannotConnectError, error.message, error.backtrace
+      @config = config
+      @connect_timeout = connect_timeout
+      @read_timeout = read_timeout
+      @write_timeout = write_timeout
+      connect
     end
 
     def connected?
@@ -87,13 +55,16 @@ class RedisClient
 
     def close
       @io.close
+      super
     end
 
     def read_timeout=(timeout)
+      @read_timeout = timeout
       @io.read_timeout = timeout if @io
     end
 
     def write_timeout=(timeout)
+      @write_timeout = timeout
       @io.write_timeout = timeout if @io
     end
 
@@ -129,5 +100,84 @@ class RedisClient
     rescue SystemCallError, IOError, OpenSSL::SSL::SSLError => error
       raise ConnectionError, error.message
     end
+
+    def measure_round_trip_delay
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+      call(["PING"], @read_timeout)
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start
+    end
+
+    private
+
+    def connect
+      socket = if @config.path
+        UNIXSocket.new(@config.path)
+      else
+        sock = if SUPPORTS_RESOLV_TIMEOUT
+          Socket.tcp(@config.host, @config.port, connect_timeout: @connect_timeout, resolv_timeout: @connect_timeout)
+        else
+          Socket.tcp(@config.host, @config.port, connect_timeout: @connect_timeout)
+        end
+        # disables Nagle's Algorithm, prevents multiple round trips with MULTI
+        sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        enable_socket_keep_alive(sock)
+        sock
+      end
+
+      if @config.ssl
+        socket = OpenSSL::SSL::SSLSocket.new(socket, @config.ssl_context)
+        socket.hostname = @config.host
+        loop do
+          case status = socket.connect_nonblock(exception: false)
+          when :wait_readable
+            socket.to_io.wait_readable(@connect_timeout) or raise CannotConnectError
+          when :wait_writable
+            socket.to_io.wait_writable(@connect_timeout) or raise CannotConnectError
+          when socket
+            break
+          else
+            raise "Unexpected `connect_nonblock` return: #{status.inspect}"
+          end
+        end
+      end
+
+      @io = BufferedIO.new(
+        socket,
+        read_timeout: @read_timeout,
+        write_timeout: @write_timeout,
+      )
+      true
+    rescue SystemCallError, OpenSSL::SSL::SSLError, SocketError => error
+      raise CannotConnectError, error.message, error.backtrace
+    end
+
+    KEEP_ALIVE_INTERVAL = 15 # Same as hiredis defaults
+    KEEP_ALIVE_TTL = 120 # Longer than hiredis defaults
+    KEEP_ALIVE_PROBES = (KEEP_ALIVE_TTL / KEEP_ALIVE_INTERVAL) - 1
+    private_constant :KEEP_ALIVE_INTERVAL
+    private_constant :KEEP_ALIVE_TTL
+    private_constant :KEEP_ALIVE_PROBES
+
+    if %i[SOL_TCP SOL_SOCKET TCP_KEEPIDLE TCP_KEEPINTVL TCP_KEEPCNT].all? { |c| Socket.const_defined? c } # Linux
+      def enable_socket_keep_alive(socket)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+        socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPIDLE, KEEP_ALIVE_INTERVAL)
+        socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPINTVL, KEEP_ALIVE_INTERVAL)
+        socket.setsockopt(Socket::SOL_TCP, Socket::TCP_KEEPCNT, KEEP_ALIVE_PROBES)
+      end
+    elsif %i[IPPROTO_TCP TCP_KEEPINTVL TCP_KEEPCNT].all? { |c| Socket.const_defined? c } # macOS
+      def enable_socket_keep_alive(socket)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPINTVL, KEEP_ALIVE_INTERVAL)
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_KEEPCNT, KEEP_ALIVE_PROBES)
+      end
+    elsif %i[SOL_SOCKET SO_KEEPALIVE].all? { |c| Socket.const_defined? c } # unknown POSIX
+      def enable_socket_keep_alive(socket)
+        socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, true)
+      end
+    else # unknown
+      def enable_socket_keep_alive(_socket)
+      end
+    end
   end
 end

data/lib/redis_client/sentinel_config.rb

@@ -7,15 +7,44 @@ class RedisClient
     SENTINEL_DELAY = 0.25
     DEFAULT_RECONNECT_ATTEMPTS = 2
 
-    def initialize(name:, sentinels:, role: :master, **client_config)
-      unless %i(master replica slave).include?(role)
+    attr_reader :name
+
+    def initialize(
+      sentinels:,
+      sentinel_password: nil,
+      sentinel_username: nil,
+      role: :master,
+      name: nil,
+      url: nil,
+      **client_config
+    )
+      unless %i(master replica slave).include?(role.to_sym)
         raise ArgumentError, "Expected role to be either :master or :replica, got: #{role.inspect}"
       end
 
+      if url
+        url_config = URLConfig.new(url)
+        client_config = {
+          username: url_config.username,
+          password: url_config.password,
+          db: url_config.db,
+        }.compact.merge(client_config)
+        name ||= url_config.host
+      end
+
+      @name = name
+      unless @name
+        raise ArgumentError, "RedisClient::SentinelConfig requires either a name or an url with a host"
+      end
+
       @to_list_of_hash = @to_hash = nil
-      extra_config = {}
+      @extra_config = {
+        username: sentinel_username,
+        password: sentinel_password,
+        db: nil,
+      }
       if client_config[:protocol] == 2
-        extra_config[:protocol] = client_config[:protocol]
+        @extra_config[:protocol] = client_config[:protocol]
         @to_list_of_hash = lambda do |may_be_a_list|
           if may_be_a_list.is_a?(Array)
             may_be_a_list.map { |l| l.each_slice(2).to_h }
@@ -25,23 +54,15 @@ class RedisClient
         end
       end
 
-      @name = name
-      @sentinel_configs = sentinels.map do |s|
-        case s
-        when String
-          Config.new(**extra_config, url: s)
-        else
-          Config.new(**extra_config, **s)
-        end
-      end
       @sentinels = {}.compare_by_identity
-      @role = role
+      @role = role.to_sym
       @mutex = Mutex.new
       @config = nil
 
       client_config[:reconnect_attempts] ||= DEFAULT_RECONNECT_ATTEMPTS
       @client_config = client_config || {}
       super(**client_config)
+      @sentinel_configs = sentinels_to_configs(sentinels)
     end
 
     def sentinels
@@ -93,6 +114,17 @@ class RedisClient
 
     private
 
+    def sentinels_to_configs(sentinels)
+      sentinels.map do |sentinel|
+        case sentinel
+        when String
+          Config.new(**@client_config, **@extra_config, url: sentinel)
+        else
+          Config.new(**@client_config, **@extra_config, **sentinel)
+        end
+      end
+    end
+
     def config
       @mutex.synchronize do
         @config ||= if @role == :master
@@ -106,9 +138,11 @@ class RedisClient
     def resolve_master
       each_sentinel do |sentinel_client|
         host, port = sentinel_client.call("SENTINEL", "get-master-addr-by-name", @name)
-        if host && port
-          return Config.new(host: host, port: Integer(port), **@client_config)
-        end
+        next unless host && port
+
+        refresh_sentinels(sentinel_client)
+
+        return Config.new(host: host, port: Integer(port), **@client_config)
       end
     rescue ConnectionError
       raise ConnectionError, "No sentinels available"
@@ -159,5 +193,19 @@ class RedisClient
 
       raise last_error if last_error
     end
+
+    def refresh_sentinels(sentinel_client)
+      sentinel_response = sentinel_client.call("SENTINEL", "sentinels", @name, &@to_list_of_hash)
+      sentinels = sentinel_response.map do |sentinel|
+        { host: sentinel.fetch("ip"), port: Integer(sentinel.fetch("port")) }
+      end
+      new_sentinels = sentinels.select do |sentinel|
+        @sentinel_configs.none? do |sentinel_config|
+          sentinel_config.host == sentinel.fetch(:host) && sentinel_config.port == sentinel.fetch(:port)
+        end
+      end
+
+      @sentinel_configs.concat sentinels_to_configs(new_sentinels)
+    end
   end
 end

data/lib/redis_client/url_config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+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}"
+      end
+    end
+
+    def ssl?
+      @uri.scheme == SSL_SCHEMA
+    end
+
+    def db
+      db_path = uri.path&.delete_prefix("/")
+      Integer(db_path) if db_path && !db_path.empty?
+    end
+
+    def username
+      uri.user if uri.password && !uri.user.empty?
+    end
+
+    def password
+      if uri.user && !uri.password
+        URI.decode_www_form_component(uri.user)
+      elsif uri.user && uri.password
+        URI.decode_www_form_component(uri.password)
+      end
+    end
+
+    def host
+      return if uri.host.nil? || uri.host.empty?
+
+      uri.host.sub(/\A\[(.*)\]\z/, '\1')
+    end
+
+    def port
+      return unless uri.port
+
+      Integer(uri.port)
+    end
+  end
+end

data/lib/redis_client/version.rb

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

data/lib/redis_client.rb

@@ -2,7 +2,9 @@
 
 require "redis_client/version"
 require "redis_client/command_builder"
+require "redis_client/url_config"
 require "redis_client/config"
+require "redis_client/pid_cache"
 require "redis_client/sentinel_config"
 require "redis_client/middlewares"
 
@@ -62,12 +64,12 @@ class RedisClient
       write_timeout: config.write_timeout
     )
       @config = config
-      @id = id
+      @id = id&.to_s
       @connect_timeout = connect_timeout
       @read_timeout = read_timeout
       @write_timeout = write_timeout
       @command_builder = config.command_builder
-      @pid = Process.pid
+      @pid = PIDCache.pid
     end
 
     def timeout=(timeout)
@@ -90,9 +92,17 @@ class RedisClient
   WriteTimeoutError = Class.new(TimeoutError)
   CheckoutTimeoutError = Class.new(TimeoutError)
 
-  class CommandError < Error
+  module HasCommand
     attr_reader :command
 
+    def _set_command(command)
+      @command = command
+    end
+  end
+
+  class CommandError < Error
+    include HasCommand
+
     class << self
       def parse(error_message)
         code = if error_message.start_with?("ERR Error running script")
@@ -107,22 +117,24 @@ class RedisClient
         klass.new(error_message)
       end
     end
-
-    def _set_command(command)
-      @command = command
-    end
   end
 
   AuthenticationError = Class.new(CommandError)
   PermissionError = Class.new(CommandError)
-  ReadOnlyError = Class.new(CommandError)
   WrongTypeError = Class.new(CommandError)
   OutOfMemoryError = Class.new(CommandError)
 
+  ReadOnlyError = Class.new(ConnectionError)
+  ReadOnlyError.include(HasCommand)
+
+  MasterDownError = Class.new(ConnectionError)
+  MasterDownError.include(HasCommand)
+
   CommandError::ERRORS = {
     "WRONGPASS" => AuthenticationError,
     "NOPERM" => PermissionError,
     "READONLY" => ReadOnlyError,
+    "MASTERDOWN" => MasterDownError,
     "WRONGTYPE" => WrongTypeError,
     "OOM" => OutOfMemoryError,
   }.freeze
@@ -163,6 +175,10 @@ class RedisClient
     "#<#{self.class.name} #{config.server_url}#{id_string}>"
   end
 
+  def server_url
+    config.server_url
+  end
+
   def size
     1
   end
@@ -193,6 +209,14 @@ class RedisClient
     sub
   end
 
+  def measure_round_trip_delay
+    ensure_connected do |connection|
+      @middlewares.call(["PING"], config) do
+        connection.measure_round_trip_delay
+      end
+    end
+  end
+
   def call(*command, **kwargs)
     command = @command_builder.generate(command, kwargs)
     result = ensure_connected do |connection|
@@ -335,10 +359,13 @@ class RedisClient
 
   def close
     @raw_connection&.close
-    @raw_connection = nil
     self
   end
 
+  def disable_reconnection(&block)
+    ensure_connected(retryable: false, &block)
+  end
+
   def pipelined
     pipeline = Pipeline.new(@command_builder)
     yield pipeline
@@ -419,7 +446,7 @@ class RedisClient
 
     def close
       @raw_connection&.close
-      @raw_connection = nil
+      @raw_connection = nil # PubSub can't just reconnect
       self
     end
 
@@ -599,7 +626,7 @@ class RedisClient
   end
 
   def ensure_connected(retryable: true)
-    close if !config.inherit_socket && @pid != Process.pid
+    close if !config.inherit_socket && @pid != PIDCache.pid
 
     if @disable_reconnection
       if block_given?
@@ -643,52 +670,58 @@ class RedisClient
   end
 
   def raw_connection
-    @raw_connection = @raw_connection&.revalidate
-    @raw_connection ||= connect
+    if @raw_connection.nil? || !@raw_connection.revalidate
+      connect
+    end
+    @raw_connection
   end
 
   def connect
-    @pid = Process.pid
+    @pid = PIDCache.pid
 
-    connection = @middlewares.connect(config) do
-      config.driver.new(
-        config,
-        connect_timeout: connect_timeout,
-        read_timeout: read_timeout,
-        write_timeout: write_timeout,
-      )
+    if @raw_connection
+      @middlewares.connect(config) do
+        @raw_connection.reconnect
+      end
+    else
+      @raw_connection = @middlewares.connect(config) do
+        config.driver.new(
+          config,
+          connect_timeout: connect_timeout,
+          read_timeout: read_timeout,
+          write_timeout: write_timeout,
+        )
+      end
     end
 
     prelude = config.connection_prelude.dup
 
     if id
-      prelude << ["CLIENT", "SETNAME", id.to_s]
+      prelude << ["CLIENT", "SETNAME", id]
     end
 
     # The connection prelude is deliberately not sent to Middlewares
     if config.sentinel?
       prelude << ["ROLE"]
       role, = @middlewares.call_pipelined(prelude, config) do
-        connection.call_pipelined(prelude, nil).last
+        @raw_connection.call_pipelined(prelude, nil).last
       end
       config.check_role!(role)
     else
       unless prelude.empty?
         @middlewares.call_pipelined(prelude, config) do
-          connection.call_pipelined(prelude, nil)
+          @raw_connection.call_pipelined(prelude, nil)
         end
       end
     end
-
-    connection
-  rescue FailoverError
+  rescue FailoverError, CannotConnectError
     raise
   rescue ConnectionError => error
     raise CannotConnectError, error.message, error.backtrace
   rescue CommandError => error
-    if error.message.include?("ERR unknown command `HELLO`")
+    if error.message.match?(/ERR unknown command ['`]HELLO['`]/)
       raise UnsupportedServer,
-        "Your Redis server version is too old. redis-client requires Redis 6+. (#{config.server_url})"
+        "redis-client requires Redis 6+ with HELLO command available (#{config.server_url})"
     else
       raise
     end
@@ -696,5 +729,6 @@ class RedisClient
 end
 
 require "redis_client/pooled"
+require "redis_client/circuit_breaker"
 
 RedisClient.default_driver

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-client
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.17.0
 platform: ruby
 authors:
 - Jean Boussier
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-01 00:00:00.000000000 Z
+date: 2023-09-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -39,16 +39,19 @@ files:
 - Rakefile
 - lib/redis-client.rb
 - lib/redis_client.rb
+- lib/redis_client/circuit_breaker.rb
 - lib/redis_client/command_builder.rb
 - lib/redis_client/config.rb
 - lib/redis_client/connection_mixin.rb
 - lib/redis_client/decorator.rb
 - lib/redis_client/middlewares.rb
+- lib/redis_client/pid_cache.rb
 - lib/redis_client/pooled.rb
 - lib/redis_client/ruby_connection.rb
 - lib/redis_client/ruby_connection/buffered_io.rb
 - lib/redis_client/ruby_connection/resp3.rb
 - lib/redis_client/sentinel_config.rb
+- lib/redis_client/url_config.rb
 - lib/redis_client/version.rb
 - redis-client.gemspec
 homepage: https://github.com/redis-rb/redis-client
@@ -74,7 +77,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Simple low-level client for Redis 6+