redis-client 0.11.2 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24ef1685664b6af416108d0994b89e1c8d70e3ba1e5d17363f9bc92a0a34137f
-  data.tar.gz: 065e1efd905230b129fe0e82569ae4691644c2126c507eb8e9c44fec556e6584
+  metadata.gz: f5e453ca140b38cff3f62e947e4168ca950117d1ff03562e5d6ed2bad0dbdd83
+  data.tar.gz: 8fe7edeb11051105d2505f95e6cda7360c2cf6a438b93e5bb0f775538456f28d
 SHA512:
-  metadata.gz: 4f1b143a96e5c5d7f96919187e8a7d7b481da1661d19044c4b699cad713761fcf371b5733ab5200d05e176f782318c6fe23a73568eeb6f610a061a97f1706181
-  data.tar.gz: b97603e2d45b1008b4920a9576315809f7d41de0cd95f05f2c2a1e1241e3e9bbdf3d57c80afc15cc823d795bb41686ad079f7cb27b203cd03d884291a165787a
+  metadata.gz: 27596015912265226cd39b7c6e27fff214e096166121aa0e8dba0a0f81a7ba45663c0d28239e3610d57c3955ace8cfc1f428c4af8f9373b80bb196eeb89c61a8
+  data.tar.gz: 91b24e94e5332f4e74ca2dbb2e9adc60f7e8f9c5b698b1af5dfd5483bf836c95f6a79f39689272b742c6693ff8b6a6dd0d275e820f4a29f6d86b4dab650be6b4

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Unreleased
 
+# 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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    redis-client (0.11.2)
+    redis-client (0.12.2)
       connection_pool
 
 GEM
@@ -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.1)
       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.23)
     toxiproxy (2.0.2)
     unicode-display_width (2.2.0)
 

data/README.md

@@ -63,7 +63,7 @@ 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.
@@ -81,6 +81,7 @@ 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.
 
@@ -426,24 +427,62 @@ 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.
 ```
 
+### 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 possibe to continue without issuing the command.
+
+When the Redis server is used as an ephemeral cache, circuit breakers are generally prefered.
+
+### 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/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)
@@ -175,7 +181,15 @@ class RedisClient
 
       super(**kwargs)
 
-      @host = host || uri&.host&.sub(/\A\[(.*)\]\z/, '\1') || DEFAULT_HOST
+      @host = host
+      unless @host
+        uri_host = uri&.host
+        uri_host = nil if uri_host&.empty?
+        if uri_host
+          @host = uri_host&.sub(/\A\[(.*)\]\z/, '\1')
+        end
+      end
+      @host ||= DEFAULT_HOST
       @port = Integer(port || uri&.port || DEFAULT_PORT)
       @path = path
     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

@@ -142,7 +142,7 @@ class RedisClient
           when :wait_writable
             @io.to_io.wait_writable(@write_timeout) or raise WriteTimeoutError
           when nil
-            raise Errno::ECONNRESET
+            raise EOFError
           else
             raise "Unexpected `read_nonblock` return: #{bytes.inspect}"
           end

data/lib/redis_client/version.rb

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

data/lib/redis_client.rb

@@ -3,6 +3,7 @@
 require "redis_client/version"
 require "redis_client/command_builder"
 require "redis_client/config"
+require "redis_client/pid_cache"
 require "redis_client/sentinel_config"
 require "redis_client/middlewares"
 
@@ -62,12 +63,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)
@@ -125,10 +126,14 @@ class RedisClient
   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
@@ -605,7 +610,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?
@@ -654,7 +659,7 @@ class RedisClient
   end
 
   def connect
-    @pid = Process.pid
+    @pid = PIDCache.pid
 
     connection = @middlewares.connect(config) do
       config.driver.new(
@@ -668,7 +673,7 @@ class RedisClient
     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
@@ -687,7 +692,7 @@ class RedisClient
     end
 
     connection
-  rescue FailoverError
+  rescue FailoverError, CannotConnectError
     raise
   rescue ConnectionError => error
     raise CannotConnectError, error.message, error.backtrace
@@ -702,5 +707,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.2
+  version: 0.12.2
 platform: ruby
 authors:
 - Jean Boussier
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-18 00:00:00.000000000 Z
+date: 2023-02-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -39,11 +39,13 @@ 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
@@ -74,7 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: Simple low-level client for Redis 6+