redis-cluster-client 0.15.0 → 0.16.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49e9024047bf01e4ce7a03ba26f1ba1691b123e3a7fffa1b6b33fdbf598c040a
-  data.tar.gz: 1ae28c2abffa0d566a832d7bf4745afd8ebd82f255397068d99d25520578913c
+  metadata.gz: 80b5e1d6525a06ecf8747239269b110528bf9efc99ff3424108033c85cdc011a
+  data.tar.gz: 35b5aba54bc61e3731509c7ba3959289ddcfb30e40193f365fc26f62f4c7e60d
 SHA512:
-  metadata.gz: d61ebaa012160e38ef5bd42de839a637f209a7c409b507fd6f8a6e7f5898cbb8a61960ebc5566b95bd1aedad98f767b98ab1a7d6d2a8400e48da433794b5e4f2
-  data.tar.gz: b28d1d461814dafe2e272cc65ed3be2f805b754ecf4ad3831674d7d478eeac3266513e0cdda8a0cabaf604f8292b8034a936b4693066c794a5bc558688ab287a
+  metadata.gz: ab546dc6dc75d1ec1733c5cd5f29a451881d71db8c21e587be92ab77c2f12f602100468626b742a1d87caa98aa27699906f9aefd7d9cff02512c3be1e355bdd4
+  data.tar.gz: 741326d16416834940e08c7084019080188d3e6b252c6dafdf3037bb9a40e2f9aafc0dc771fce7ac4edbb50af6d630067fb3646f4e7f1016ab72d7ceafb04940

data/lib/redis_client/cluster/command.rb

@@ -9,18 +9,57 @@ class RedisClient
     class Command
       EMPTY_STRING = ''
       EMPTY_HASH = {}.freeze
-      EMPTY_ARRAY = [].freeze
 
-      private_constant :EMPTY_STRING, :EMPTY_HASH, :EMPTY_ARRAY
+      private_constant :EMPTY_HASH
 
-      Detail = Struct.new(
-        'RedisCommand',
+      Spec = Struct.new(
+        'RedisCommandSpec',
         :first_key_position,
         :key_step,
         :write?,
         :readonly?,
         keyword_init: true
-      )
+      ) do
+        def extract_first_key(command)
+          i = first_key_position.to_i
+          return command[i] if i > 0
+
+          i = determine_first_key_position(command)
+          return ::RedisClient::Cluster::Command::EMPTY_STRING if i == 0
+
+          command[i]
+        end
+
+        def should_send_to_primary?
+          write?
+        end
+
+        def should_send_to_replica?
+          readonly?
+        end
+
+        private
+
+        def determine_first_key_position(command) # rubocop:disable Metrics/AbcSize
+          cmd_name = command.first
+          if cmd_name.casecmp('xread').zero?
+            determine_optional_key_position(command, 'streams')
+          elsif cmd_name.casecmp('xreadgroup').zero?
+            determine_optional_key_position(command, 'streams')
+          elsif cmd_name.casecmp('migrate').zero?
+            command[3].empty? ? determine_optional_key_position(command, 'keys') : 3
+          elsif cmd_name.casecmp('memory').zero?
+            command[1].to_s.casecmp('usage').zero? ? 2 : 0
+          else
+            0
+          end
+        end
+
+        def determine_optional_key_position(command, option_name)
+          i = command.index { |v| v.to_s.casecmp(option_name).zero? }
+          i.nil? ? 0 : i + 1
+        end
+      end
 
       class << self
         def load(nodes, slow_command_timeout: -1) # rubocop:disable Metrics/AbcSize
@@ -30,13 +69,14 @@ class RedisClient
             regular_timeout = node.read_timeout
             node.read_timeout = slow_command_timeout > 0.0 ? slow_command_timeout : regular_timeout
             reply = node.call('command')
-            node.read_timeout = regular_timeout
             commands = parse_command_reply(reply)
             cmd = ::RedisClient::Cluster::Command.new(commands)
             break
           rescue ::RedisClient::Error => e
             errors ||= []
             errors << e
+          ensure
+            node.read_timeout = regular_timeout
           end
 
           return cmd unless cmd.nil?
@@ -64,7 +104,7 @@ class RedisClient
                        else row[2].include?('write')
                        end
 
-            acc[row.first] = ::RedisClient::Cluster::Command::Detail.new(
+            acc[row.first] = ::RedisClient::Cluster::Command::Spec.new(
               first_key_position: pos,
               key_step: row[5],
               write?: writable,
@@ -78,53 +118,13 @@ class RedisClient
         @commands = commands || EMPTY_HASH
       end
 
-      def extract_first_key(command)
-        i = determine_first_key_position(command)
-        return EMPTY_STRING if i == 0
-
-        command[i]
-      end
-
-      def should_send_to_primary?(command)
-        find_command_info(command.first)&.write?
-      end
-
-      def should_send_to_replica?(command)
-        find_command_info(command.first)&.readonly?
+      def get_spec(name)
+        @commands[name] || @commands[name.to_s.downcase(:ascii)]
       end
 
       def exists?(name)
         @commands.key?(name) || @commands.key?(name.to_s.downcase(:ascii))
       end
-
-      private
-
-      def find_command_info(name)
-        @commands[name] || @commands[name.to_s.downcase(:ascii)]
-      end
-
-      def determine_first_key_position(command) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
-        i = find_command_info(command.first)&.first_key_position.to_i
-        return i if i > 0
-
-        cmd_name = command.first
-        if cmd_name.casecmp('xread').zero?
-          determine_optional_key_position(command, 'streams')
-        elsif cmd_name.casecmp('xreadgroup').zero?
-          determine_optional_key_position(command, 'streams')
-        elsif cmd_name.casecmp('migrate').zero?
-          command[3].empty? ? determine_optional_key_position(command, 'keys') : 3
-        elsif cmd_name.casecmp('memory').zero?
-          command[1].to_s.casecmp('usage').zero? ? 2 : 0
-        else
-          i
-        end
-      end
-
-      def determine_optional_key_position(command, option_name)
-        i = command.index { |v| v.to_s.casecmp(option_name).zero? }
-        i.nil? ? 0 : i + 1
-      end
     end
   end
 end

data/lib/redis_client/cluster/concurrent_worker/none.rb

@@ -3,17 +3,57 @@
 class RedisClient
   class Cluster
     module ConcurrentWorker
-      class None
-        def new_group(size:)
-          ::RedisClient::Cluster::ConcurrentWorker::Group.new(
-            worker: self,
-            queue: [],
-            size: size
+      module None
+        class Group
+          Task = Struct.new(
+            'RedisClusterClientSingleThreadTask',
+            :id, :result, keyword_init: true
           )
+
+          def initialize(size:)
+            @tasks = Array.new(size)
+            @idx = 0
+          end
+
+          def push(id, *args, **kwargs, &block)
+            raise InvalidNumberOfTasks, "max size reached: #{@idx}" if @idx == @tasks.size
+
+            result = exec(*args, **kwargs, &block)
+            @tasks[@idx] = Task.new(id: id, result: result)
+            @idx += 1
+            nil
+          end
+
+          def each
+            raise InvalidNumberOfTasks, "expected: #{@tasks.size}, actual: #{@idx}" if @idx != @tasks.size
+
+            @tasks.each { |task| yield(task.id, task.result) }
+            nil
+          end
+
+          def close
+            @idx = 0
+            @tasks.clear
+            nil
+          end
+
+          def inspect
+            "#<#{self.class.name} size: #{@idx}, max: #{@tasks.size}>"
+          end
+
+          private
+
+          def exec(*args, **kwargs)
+            yield(*args, **kwargs) if block_given?
+          rescue StandardError => e
+            e
+          end
         end
 
-        def push(task)
-          task.exec
+        module_function
+
+        def new_group(size:)
+          Group.new(size: size)
         end
 
         def close; end

data/lib/redis_client/cluster/concurrent_worker.rb

@@ -73,7 +73,7 @@ class RedisClient
 
       def create(model: :none, size: 5)
         case model
-        when :none then ::RedisClient::Cluster::ConcurrentWorker::None.new
+        when :none then ::RedisClient::Cluster::ConcurrentWorker::None
         when :on_demand then ::RedisClient::Cluster::ConcurrentWorker::OnDemand.new(size: size)
         when :pooled then ::RedisClient::Cluster::ConcurrentWorker::Pooled.new(size: size)
         else raise ArgumentError, "unknown model: #{model}"

data/lib/redis_client/cluster/key_slot_converter.rb

@@ -70,7 +70,7 @@ class RedisClient
         e = key.index(RIGHT_BRACKET, s + 1)
         return EMPTY_STRING if e.nil?
 
-        key[s + 1..e - 1]
+        s + 1 < e ? key[s + 1, e - s - 1] : EMPTY_STRING
       end
 
       def hash_tag_included?(key)

data/lib/redis_client/cluster/node/base_topology.rb

@@ -25,8 +25,7 @@ class RedisClient
         end
 
         def any_primary_node_key(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
-          @primary_node_keys.sample(random: random)
+          @primary_node_keys.sample(random: make_random(seed))
         end
 
         def process_topology_update!(replications, options) # rubocop:disable Metrics/AbcSize
@@ -59,6 +58,11 @@ class RedisClient
             @clients[node_key] = client
           end
         end
+
+        def make_random(seed)
+          # OPTIMIZE: Figure out the most elegant way to pin a node during a pipeline or scan.
+          seed.nil? ? Random : Random.new(seed)
+        end
       end
     end
   end

data/lib/redis_client/cluster/node/latency_replica.rb

@@ -20,8 +20,7 @@ class RedisClient
         end
 
         def any_replica_node_key(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
-          @existed_replicas.sample(random: random)&.first || any_primary_node_key(seed: seed)
+          @existed_replicas.sample(random: make_random(seed))&.first || any_primary_node_key(seed: seed)
         end
 
         def process_topology_update!(replications, options)

data/lib/redis_client/cluster/node/primary_only.rb

@@ -18,8 +18,7 @@ class RedisClient
         end
 
         def any_primary_node_key(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
-          @primary_node_keys.sample(random: random)
+          @primary_node_keys.sample(random: make_random(seed))
         end
 
         alias any_replica_node_key any_primary_node_key

data/lib/redis_client/cluster/node/random_replica.rb

@@ -12,7 +12,7 @@ class RedisClient
         end
 
         def clients_for_scanning(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
+          random = make_random(seed)
           keys = @replications.map do |primary_node_key, replica_node_keys|
             replica_node_keys.empty? ? primary_node_key : replica_node_keys.sample(random: random)
           end
@@ -21,13 +21,13 @@ class RedisClient
         end
 
         def find_node_key_of_replica(primary_node_key, seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
-          @replications.fetch(primary_node_key, EMPTY_ARRAY).sample(random: random) || primary_node_key
+          replica_node_keys = @replications.fetch(primary_node_key, EMPTY_ARRAY)
+          replica_node_key = replica_node_keys.size <= 1 ? replica_node_keys.first : replica_node_keys.sample(random: make_random(seed))
+          replica_node_key || primary_node_key
         end
 
         def any_replica_node_key(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
-          @replica_node_keys.sample(random: random) || any_primary_node_key(seed: seed)
+          @replica_node_keys.sample(random: make_random(seed)) || any_primary_node_key(seed: seed)
         end
       end
     end

data/lib/redis_client/cluster/node/random_replica_or_primary.rb

@@ -12,7 +12,7 @@ class RedisClient
         end
 
         def clients_for_scanning(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
+          random = make_random(seed)
           keys = @replications.map do |primary_node_key, replica_node_keys|
             decide_use_primary?(random, replica_node_keys.size) ? primary_node_key : replica_node_keys.sample(random: random)
           end
@@ -21,7 +21,7 @@ class RedisClient
         end
 
         def find_node_key_of_replica(primary_node_key, seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
+          random = make_random(seed)
 
           replica_node_keys = @replications.fetch(primary_node_key, EMPTY_ARRAY)
           if decide_use_primary?(random, replica_node_keys.size)
@@ -32,8 +32,7 @@ class RedisClient
         end
 
         def any_replica_node_key(seed: nil)
-          random = seed.nil? ? Random : Random.new(seed)
-          @replica_node_keys.sample(random: random) || any_primary_node_key(seed: seed)
+          @replica_node_keys.sample(random: make_random(seed)) || any_primary_node_key(seed: seed)
         end
 
         private

data/lib/redis_client/cluster/node.rb

@@ -24,10 +24,12 @@ class RedisClient
       ROLE_FLAGS = %w[master slave].freeze
       EMPTY_ARRAY = [].freeze
       EMPTY_HASH = {}.freeze
-      STATE_REFRESH_INTERVAL = (3..10).freeze
+      EMPTY_STRING = ''
+      JITTER_WINDOW = (3_000_000...10_000_000).freeze # micro seconds
 
       private_constant :USE_CHAR_ARRAY_SLOT, :SLOT_SIZE, :MIN_SLOT, :MAX_SLOT,
-                       :DEAD_FLAGS, :ROLE_FLAGS, :EMPTY_ARRAY, :EMPTY_HASH
+                       :DEAD_FLAGS, :ROLE_FLAGS, :EMPTY_ARRAY, :EMPTY_HASH, :EMPTY_STRING,
+                       :JITTER_WINDOW
 
       ReloadNeeded = Class.new(::RedisClient::Cluster::Error)
 
@@ -46,7 +48,7 @@ class RedisClient
         end
 
         def serialize(str)
-          str << id << node_key << role << primary_id << config_epoch
+          str << id << node_key << role << primary_id
         end
       end
 
@@ -106,8 +108,7 @@ class RedisClient
         @topology = klass.new(pool, @concurrent_worker, **kwargs)
         @config = config
         @mutex = Mutex.new
-        @last_reloaded_at = nil
-        @reload_times = 0
+        @next_reload_time = nil
         @random = Random.new
       end
 
@@ -193,26 +194,22 @@ class RedisClient
       end
 
       def update_slot(slot, node_key)
-        return if @mutex.locked?
+        return unless @mutex.try_lock
 
-        @mutex.synchronize do
-          @slots[slot] = node_key
-        rescue RangeError
-          @slots = Array.new(SLOT_SIZE) { |i| @slots[i] }
-          @slots[slot] = node_key
-        end
+        @slots[slot] = node_key
+      rescue RangeError
+        @slots = Array.new(SLOT_SIZE) { |i| @slots[i] }
+        @slots[slot] = node_key
+      ensure
+        @mutex.unlock if @mutex.owned?
       end
 
-      def reload!
+      def try_reload!
         with_reload_lock do
-          with_startup_clients(@config.max_startup_sample) do |startup_clients|
-            @node_info = refetch_node_info_list(startup_clients)
-            @node_configs = @node_info.to_h do |node_info|
-              [node_info.node_key, @config.client_config_for_node(node_info.node_key)]
+          with_reload_jitter do
+            with_startup_clients(@config.max_startup_sample) do |clients|
+              reload!(clients)
             end
-            @slots = build_slot_node_mappings(@node_info)
-            @replications = build_replication_mappings(@node_info)
-            @topology.process_topology_update!(@replications, @node_configs)
           end
         end
       end
@@ -312,12 +309,11 @@ class RedisClient
           work_group.push(i, raw_client) do |client|
             regular_timeout = client.read_timeout
             client.read_timeout = @config.slow_command_timeout > 0.0 ? @config.slow_command_timeout : regular_timeout
-            reply = client.call_once('cluster', 'nodes')
-            client.read_timeout = regular_timeout
-            parse_cluster_node_reply(reply)
+            fetch_cluster_state(client)
           rescue StandardError => e
             e
           ensure
+            client.read_timeout = regular_timeout
             client&.close
           end
         end
@@ -347,6 +343,16 @@ class RedisClient
         grouped.max_by { |_, v| v.size }[1].first
       end
 
+      def fetch_cluster_state(client)
+        reply = client.call_once('cluster', 'shards')
+        parse_cluster_shards_reply(reply)
+      rescue ::RedisClient::CommandError => e
+        raise unless e.message.start_with?('ERR Unknown subcommand')
+
+        reply = client.call_once('cluster', 'nodes')
+        parse_cluster_node_reply(reply)
+      end
+
       def parse_cluster_node_reply(reply) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         reply.each_line("\n", chomp: true).filter_map do |line|
           fields = line.split
@@ -390,39 +396,61 @@ class RedisClient
               id: id,
               node_key: NodeKey.build_from_host_port(ip, arr[1]),
               role: role,
-              primary_id: role == 'master' ? nil : primary_id,
+              primary_id: role == 'master' ? EMPTY_STRING : primary_id,
               slots: role == 'master' ? slots : EMPTY_ARRAY
             )
           end
-        end.freeze
+        end
       end
 
       def parse_cluster_shards_reply(reply) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         reply.each_with_object([]) do |shard, acc|
+          resp2 = shard.is_a?(Array)
+          shard = shard.each_slice(2).to_h if resp2
           nodes = shard.fetch('nodes')
+          nodes = nodes.map { |n| n.each_slice(2).to_h } if resp2
           primary_id = nodes.find { |n| n.fetch('role') == 'master' }.fetch('id')
 
           nodes.each do |node|
-            ip = node.fetch('ip')
-            next if node.fetch('health') != 'online' || ip.nil? || ip.empty? || ip == '?'
+            host = pick_shard_host(node)
+            next if node.fetch('health') != 'online' || host.nil? || host.empty? || host == '?'
 
             role = node.fetch('role')
             acc << ::RedisClient::Cluster::Node::Info.new(
               id: node.fetch('id'),
-              node_key: NodeKey.build_from_host_port(ip, node['port'] || node['tls-port']),
+              node_key: NodeKey.build_from_host_port(host, node['port'] || node['tls-port']),
               role: role == 'master' ? role : 'slave',
-              primary_id: role == 'master' ? nil : primary_id,
+              primary_id: role == 'master' ? EMPTY_STRING : primary_id,
               slots: role == 'master' ? shard.fetch('slots').each_slice(2).to_a.freeze : EMPTY_ARRAY
             )
           end
-        end.freeze
+        end
+      end
+
+      # Pick the host for a CLUSTER SHARDS node entry.
+      #
+      # `endpoint` is the server-selected preferred endpoint (driven by the
+      # `cluster-preferred-endpoint-type` config), so prefer it when present and
+      # usable. Some managed services (e.g. AWS ElastiCache Serverless) report
+      # `127.0.0.1` in `ip` while exposing the reachable address only via
+      # `endpoint` / `hostname`; falling through to `ip` in that case would build
+      # an unreachable topology. This mirrors the precedence `parse_node_key`
+      # uses for CLUSTER NODES output (see #207).
+      def pick_shard_host(node)
+        endpoint = node['endpoint']
+        return endpoint if endpoint && !endpoint.empty? && endpoint != '?'
+
+        hostname = node['hostname']
+        return hostname if hostname && !hostname.empty?
+
+        node['ip']
       end
 
       # As redirection node_key is dependent on `cluster-preferred-endpoint-type` config,
       # node_key should use hostname if present in CLUSTER NODES output.
       #
       # See https://redis.io/commands/cluster-nodes/ for details on the output format.
-      # node_address matches fhe format: <ip:port@cport[,hostname[,auxiliary_field=value]*]>
+      # node_address matches the format: <ip:port@cport[,hostname[,auxiliary_field=value]*]>
       def parse_node_key(node_address)
         ip_chunk, hostname, _auxiliaries = node_address.split(',')
         ip_port_string = ip_chunk.split('@').first
@@ -432,6 +460,16 @@ class RedisClient
         "#{hostname}:#{port}"
       end
 
+      def reload!(clients)
+        @node_info = refetch_node_info_list(clients)
+        @node_configs = @node_info.to_h do |node_info|
+          [node_info.node_key, @config.client_config_for_node(node_info.node_key)]
+        end
+        @slots = build_slot_node_mappings(@node_info)
+        @replications = build_replication_mappings(@node_info)
+        @topology.process_topology_update!(@replications, @node_configs)
+      end
+
       def with_startup_clients(count) # rubocop:disable Metrics/AbcSize
         if @config.connect_with_original_config
           # If connect_with_original_config is set, that means we need to build actual client objects
@@ -457,35 +495,43 @@ class RedisClient
         end
       end
 
+      def with_reload_jitter
+        return unless @next_reload_time.nil? || obtain_current_time >= @next_reload_time
+
+        begin
+          yield
+        ensure
+          @next_reload_time = obtain_current_time + @random.rand(JITTER_WINDOW)
+        end
+      end
+
       def with_reload_lock
-        # What should happen with concurrent calls #reload? This is a realistic possibility if the cluster goes into
+        # What should happen with concurrent calls #try_reload! This is a realistic possibility if the cluster goes into
         # a CLUSTERDOWN state, and we're using a pooled backend. Every thread will independently discover this, and
-        # call reload!.
-        # For now, if a reload is in progress, wait for that to complete, and consider that the same as us having
-        # performed the reload.
-        # Probably in the future we should add a circuit breaker to #reload itself, and stop trying if the cluster is
+        # call #try_reload!.
+        # For now, if a reload is in progress by a thread, the other threads do not wait for that to complete, and
+        # they throw an error.
+        # Probably in the future we should add a circuit breaker to #try_reload! itself, and stop trying if the cluster is
         # obviously not working.
-        wait_start = obtain_current_time
-        @mutex.synchronize do
-          return if @last_reloaded_at && @last_reloaded_at > wait_start
-
-          if @last_reloaded_at && @reload_times > 1
-            # Mitigate load of servers by naive logic. Don't sleep with exponential backoff.
-            now = obtain_current_time
-            elapsed = @last_reloaded_at + @random.rand(STATE_REFRESH_INTERVAL) * 1_000_000
-            return if now < elapsed
-          end
+        return unless @mutex.try_lock
 
-          r = yield
-          @last_reloaded_at = obtain_current_time
-          @reload_times += 1
-          r
-        end
+        yield
+      ensure
+        @mutex.unlock if @mutex.owned?
       end
 
       def obtain_current_time
         Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
       end
+
+      def bypass_reload!
+        # DO NOT USE THIS METHOD
+        with_reload_lock do
+          with_startup_clients(@config.max_startup_sample) do |clients|
+            reload!(clients)
+          end
+        end
+      end
     end
   end
 end

data/lib/redis_client/cluster/node_key.rb

@@ -18,12 +18,30 @@ class RedisClient
       end
 
       def split(node_key)
-        pos = node_key&.rindex(DELIMITER, -1)
+        return [node_key, nil] if node_key.nil? || node_key.empty?
+
+        bracketed = split_bracketed(node_key)
+        return bracketed unless bracketed.nil?
+
+        pos = node_key.rindex(DELIMITER, -1)
         return [node_key, nil] if pos.nil?
 
         [node_key[0, pos], node_key[(pos + 1)..]]
       end
 
+      def split_bracketed(node_key)
+        return nil unless node_key.start_with?('[')
+
+        end_bracket = node_key.index(']')
+        return nil if end_bracket.nil?
+
+        host = node_key[1, end_bracket - 1]
+        remainder = node_key[(end_bracket + 1)..]
+        port = remainder.start_with?(DELIMITER) ? remainder[1..] : nil
+        [host, port]
+      end
+      private_class_method :split_bracketed
+
       def build_from_uri(uri)
         return '' if uri.nil?
 

data/lib/redis_client/cluster/optimistic_locking.rb

@@ -54,7 +54,7 @@ class RedisClient
       rescue ::RedisClient::ConnectionError
         # Deduct the number of retries that happened _inside_ router#handle_redirection from our remaining
         # _external_ retries. Always deduct at least one in case handle_redirection raises without trying the block.
-        retry_count -= [times_block_executed, 1].min
+        retry_count -= times_block_executed == 0 ? 1 : [times_block_executed, 1].min
         raise if retry_count < 0
 
         retry

data/lib/redis_client/cluster/pipeline.rb

@@ -230,10 +230,10 @@ class RedisClient
 
       def append_pipeline(node_key)
         @pipelines ||= {}
-        @pipelines[node_key] ||= ::RedisClient::Cluster::Pipeline::Extended.new(::RedisClient::Cluster::NoopCommandBuilder)
-        @pipelines[node_key].add_outer_index(@size)
+        pi = (@pipelines[node_key] ||= ::RedisClient::Cluster::Pipeline::Extended.new(::RedisClient::Cluster::NoopCommandBuilder))
+        pi.add_outer_index(@size)
         @size += 1
-        @pipelines[node_key]
+        pi
       end
 
       def do_pipelining(client, pipeline)

data/lib/redis_client/cluster/pub_sub.rb

@@ -61,7 +61,17 @@ class RedisClient
       end
 
       BUF_SIZE = Integer(ENV.fetch('REDIS_CLIENT_PUBSUB_BUF_SIZE', 1024))
-      private_constant :BUF_SIZE
+      RECOVERY_BASE_INTERVAL = Float(ENV.fetch('REDIS_CLIENT_PUBSUB_RECOVERY_INTERVAL_SEC', 1.0))
+      RECOVERY_MAX_INTERVAL = Float(ENV.fetch('REDIS_CLIENT_PUBSUB_RECOVERY_MAX_INTERVAL_SEC', 30.0))
+      RECOVERY_MAX_ATTEMPTS = Integer(ENV.fetch('REDIS_CLIENT_PUBSUB_RECOVERY_MAX_ATTEMPTS', 10))
+      SUBSCRIBE_COMMANDS = %w[subscribe psubscribe ssubscribe].freeze
+      UNSUBSCRIBE_TO_SUBSCRIBE = {
+        'unsubscribe' => 'subscribe',
+        'punsubscribe' => 'psubscribe',
+        'sunsubscribe' => 'ssubscribe'
+      }.freeze
+      private_constant :BUF_SIZE, :RECOVERY_BASE_INTERVAL, :RECOVERY_MAX_INTERVAL, :RECOVERY_MAX_ATTEMPTS,
+                       :SUBSCRIBE_COMMANDS, :UNSUBSCRIBE_TO_SUBSCRIBE
 
       def initialize(router, command_builder)
         @router = router
@@ -74,14 +84,14 @@ class RedisClient
       def call(*args, **kwargs)
         command = @command_builder.generate(args, kwargs)
         _call(command)
-        @commands << command
+        remember(command)
         nil
       end
 
       def call_v(command)
         command = @command_builder.generate(command)
         _call(command)
-        @commands << command
+        remember(command)
         nil
       end
 
@@ -118,6 +128,35 @@ class RedisClient
 
       private
 
+      def remember(command)
+        cmd = command.first.to_s.downcase
+        if SUBSCRIBE_COMMANDS.include?(cmd)
+          @commands << command
+        elsif (subscribe_cmd = UNSUBSCRIBE_TO_SUBSCRIBE[cmd])
+          forget_subscriptions(subscribe_cmd, command[1..])
+        else
+          @commands << command
+        end
+      end
+
+      def forget_subscriptions(subscribe_cmd, channels)
+        if channels.nil? || channels.empty?
+          @commands.reject! { |c| c.first.to_s.casecmp(subscribe_cmd).zero? }
+        else
+          @commands.reject! { |c| prune_entry(c, subscribe_cmd, channels) }
+        end
+      end
+
+      def prune_entry(entry, subscribe_cmd, channels)
+        return false unless entry.first.to_s.casecmp(subscribe_cmd).zero?
+
+        remaining = entry[1..] - channels
+        return true if remaining.empty?
+
+        entry.replace([entry.first, *remaining])
+        false
+      end
+
       def _call(command) # rubocop:disable Metrics/AbcSize
         if command.first.casecmp('subscribe').zero?
           call_to_single_state(command)
@@ -179,6 +218,7 @@ class RedisClient
       end
 
       def start_over
+        attempt = 0
         loop do
           @router.renew_cluster_state
           @state_dict.each_value(&:close)
@@ -186,9 +226,16 @@ class RedisClient
           @commands.each { |command| _call(command) }
           break
         rescue ::RedisClient::ConnectionError, ::RedisClient::Cluster::NodeMightBeDown
-          sleep 1.0
+          attempt += 1
+          raise if attempt >= RECOVERY_MAX_ATTEMPTS
+
+          sleep recovery_interval(attempt)
         end
       end
+
+      def recovery_interval(attempt)
+        [RECOVERY_BASE_INTERVAL * (2**(attempt - 1)), RECOVERY_MAX_INTERVAL].min
+      end
     end
   end
 end

data/lib/redis_client/cluster/router.rb

@@ -84,7 +84,7 @@ class RedisClient
         @pool = pool
         @client_kwargs = kwargs
         @node = ::RedisClient::Cluster::Node.new(concurrent_worker, config: config, pool: pool, **kwargs)
-        @node.reload!
+        @node.try_reload!
         @command = ::RedisClient::Cluster::Command.load(@node.replica_clients.shuffle, slow_command_timeout: config.slow_command_timeout)
         @command_builder = @config.command_builder
       rescue ::RedisClient::Cluster::InitialSetupError => e
@@ -93,9 +93,8 @@ class RedisClient
       end
 
       def send_command(method, command, *args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        return assign_node_and_send_command(method, command, args, &block) unless DEDICATED_ACTIONS.key?(command.first)
-
         action = DEDICATED_ACTIONS[command.first]
+        return assign_node_and_send_command(method, command, args, &block) if action.nil?
         return send(action.method_name, method, command, args, &block) if action.reply_transformer.nil?
 
         reply = send(action.method_name, method, command, args)
@@ -167,8 +166,8 @@ class RedisClient
       rescue ::RedisClient::ConnectionError => e
         raise unless ::RedisClient::Cluster::ErrorIdentification.client_owns_error?(e, node)
 
-        retry_count -= 1
         renew_cluster_state
+        retry_count -= 1
 
         if retry_count >= 0
           # Find the node to use for this command - if this fails for some reason, though, re-use
@@ -180,7 +179,6 @@ class RedisClient
           retry
         end
 
-        retry if retry_count >= 0
         raise
       end
 
@@ -248,23 +246,27 @@ class RedisClient
       end
 
       def find_node_key(command, seed: nil)
-        key = @command.extract_first_key(command)
-        find_node_key_by_key(key, seed: seed, primary: @command.should_send_to_primary?(command))
+        cmd_spec = @command.get_spec(command.first)
+        find_node_key_by_key(
+          cmd_spec&.extract_first_key(command),
+          seed: seed,
+          primary: cmd_spec&.should_send_to_primary?
+        )
       end
 
       def find_primary_node_key(command)
-        key = @command.extract_first_key(command)
-        return nil unless key&.size&.> 0
+        key = @command.get_spec(command.first)&.extract_first_key(command)
+        return unless key&.size&.> 0
 
         find_node_key_by_key(key, primary: true)
       end
 
       def find_slot(command)
-        find_slot_by_key(@command.extract_first_key(command))
+        find_slot_by_key(@command.get_spec(command.first)&.extract_first_key(command))
       end
 
       def find_slot_by_key(key)
-        return if key.empty?
+        return if key.nil? || key.empty?
 
         ::RedisClient::Cluster::KeySlotConverter.convert(key)
       end
@@ -294,7 +296,7 @@ class RedisClient
       end
 
       def renew_cluster_state
-        @node.reload!
+        @node.try_reload!
       rescue ::RedisClient::Cluster::InitialSetupError
         # ignore
       end
@@ -340,8 +342,8 @@ class RedisClient
         raise if retry_count <= 0
         raise if e.errors.values.none? { |err| err.message.include?('WAIT cannot be used with replica instances') }
 
-        retry_count -= 1
         renew_cluster_state
+        retry_count -= 1
         retry
       end
 
@@ -452,7 +454,7 @@ class RedisClient
       end
 
       def send_multiple_keys_command(method, command, args, &block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        # This implementation is prioritized performance rather than readability or so.
+        # This implementation prioritizes performance over readability.
         cmd = command.first
         if cmd.casecmp('mget').zero?
           single_key_cmd = 'get'
@@ -469,8 +471,13 @@ class RedisClient
 
         return assign_node_and_send_command(method, command, args, &block) if command.size <= keys_step + 1 || ::RedisClient::Cluster::KeySlotConverter.hash_tag_included?(command[1])
 
-        seed = @config.use_replica? && @config.replica_affinity == :random ? nil : Random.new_seed
-        pipeline = ::RedisClient::Cluster::Pipeline.new(self, @command_builder, @concurrent_worker, exception: true, seed: seed)
+        pipeline = ::RedisClient::Cluster::Pipeline.new(
+          self,
+          @command_builder,
+          @concurrent_worker,
+          exception: true,
+          seed: Random.new_seed
+        )
 
         single_command = Array.new(keys_step + 1)
         single_command[0] = single_key_cmd
@@ -502,8 +509,8 @@ class RedisClient
       rescue ::RedisClient::Cluster::Node::ReloadNeeded
         raise ::RedisClient::Cluster::NodeMightBeDown.new.with_config(@config) if retry_count <= 0
 
-        retry_count -= 1
         renew_cluster_state
+        retry_count -= 1
         retry
       end
     end

data/lib/redis_client/cluster.rb

@@ -95,13 +95,12 @@ class RedisClient
     end
 
     def pipelined(exception: true)
-      seed = @config.use_replica? && @config.replica_affinity == :random ? nil : Random.new_seed
       pipeline = ::RedisClient::Cluster::Pipeline.new(
         router,
         @command_builder,
         @concurrent_worker,
         exception: exception,
-        seed: seed
+        seed: Random.new_seed
       )
 
       yield pipeline

data/lib/redis_client/cluster_config.rb

@@ -21,9 +21,9 @@ class RedisClient
     MERGE_CONFIG_KEYS = %i[ssl username password db].freeze
     IGNORE_GENERIC_CONFIG_KEYS = %i[url host port path].freeze
     MAX_WORKERS = Integer(ENV.fetch('REDIS_CLIENT_MAX_THREADS', -1)) # for backward compatibility
-    # It's used with slow queries of fetching meta data like CLUSTER NODES, COMMAND and so on.
+    # Used for slow commands that fetch metadata, e.g. CLUSTER NODES, COMMAND.
     SLOW_COMMAND_TIMEOUT = Float(ENV.fetch('REDIS_CLIENT_SLOW_COMMAND_TIMEOUT', -1))
-    # It affects to strike a balance between load and stability in initialization or changed states.
+    # Controls the balance between startup load and stability during initialization or cluster state changes.
     MAX_STARTUP_SAMPLE = Integer(ENV.fetch('REDIS_CLIENT_MAX_STARTUP_SAMPLE', 3))
 
     private_constant :DEFAULT_HOST, :DEFAULT_PORT, :DEFAULT_SCHEME, :SECURE_SCHEME, :DEFAULT_NODES,
@@ -32,6 +32,12 @@ class RedisClient
 
     InvalidClientConfigError = Class.new(::RedisClient::Cluster::Error)
 
+    SENSITIVE_INSPECT_KEYS = %i[username password].freeze
+    INSPECT_REDACTED_KEYS = %i[command_builder].freeze
+    INSPECT_PLACEHOLDER = '[FILTERED]'
+
+    private_constant :SENSITIVE_INSPECT_KEYS, :INSPECT_REDACTED_KEYS, :INSPECT_PLACEHOLDER
+
     attr_reader :command_builder, :client_config, :replica_affinity, :slow_command_timeout,
                 :connect_with_original_config, :startup_nodes, :max_startup_sample, :id
 
@@ -65,7 +71,7 @@ class RedisClient
     end
 
     def inspect
-      "#<#{self.class.name} #{startup_nodes.values.map { |v| v.reject { |k| k == :command_builder } }}>"
+      "#<#{self.class.name} #{startup_nodes.values.map { |v| redact_for_inspect(v) }}>"
     end
 
     def connect_timeout
@@ -117,6 +123,14 @@ class RedisClient
 
     private
 
+    def redact_for_inspect(node_config)
+      node_config.each_with_object({}) do |(key, value), redacted|
+        next if INSPECT_REDACTED_KEYS.include?(key)
+
+        redacted[key] = SENSITIVE_INSPECT_KEYS.include?(key) ? INSPECT_PLACEHOLDER : value
+      end
+    end
+
     def merge_concurrency_option(option)
       opts = {}
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-cluster-client
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.16.4
 platform: ruby
 authors:
 - Taishi Kasuga