redis_queued_locks 1.20.0 → 1.22.0

data/lib/redis_queued_locks/config.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.13.0
-# @version 1.20.0
+# @version 1.22.0
 # rubocop:disable Metrics/ClassLength
 class RedisQueuedLocks::Config
   require_relative 'config/dsl'
@@ -32,6 +32,8 @@ class RedisQueuedLocks::Config
   setting('is_timed_by_default', false)
   setting('default_conflict_strategy', :wait_for_lock)
   setting('default_access_strategy', :queued)
+  setting('lock_priorities', { lowest: -100, low: -50, normal: 0, high: 50, highest: 100 }.freeze)
+  setting('default_lock_priority', 0)
   setting('log_sampling_enabled', false)
   setting('log_sampling_percent', 15)
   setting('log_sampler', RedisQueuedLocks::Logging::Sampler)
@@ -57,36 +59,36 @@ class RedisQueuedLocks::Config
   setting('swarm.flush_zombies.redis_config.pool_config', {})
 
   validate('swarm.auto_swarm') { |val| val == true || val == false }
-  validate('swarm.supervisor.liveness_probing_period') { |val| val.is_a?(Integer) }
+  validate('swarm.supervisor.liveness_probing_period') { |val| val.is_a?(Integer) && val > 0 }
 
   validate('swarm.probe_hosts.enabled_for_swarm') { |val| val == true || val == false }
   validate('swarm.probe_hosts.redis_config.sentinel') { |val| val == true || val == false }
   validate('swarm.probe_hosts.redis_config.pooled') { |val| val == true || val == false }
   validate('swarm.probe_hosts.redis_config.config') { |val| val.is_a?(Hash) }
   validate('swarm.probe_hosts.redis_config.pool_config') { |val| val.is_a?(Hash) }
-  validate('swarm.probe_hosts.probe_period') { |val| val.is_a?(Integer) }
+  validate('swarm.probe_hosts.probe_period') { |val| val.is_a?(Integer) && val > 0 }
 
   validate('swarm.flush_zombies.enabled_for_swarm') { |val| val == true || val == false }
   validate('swarm.flush_zombies.redis_config.sentinel') { |val| val == true || val == false }
   validate('swarm.flush_zombies.redis_config.pooled') { |val| val == true || val == false }
   validate('swarm.flush_zombies.redis_config.config') { |val| val.is_a?(Hash) }
   validate('swarm.flush_zombies.redis_config.pool_config') { |val| val.is_a?(Hash) }
-  validate('swarm.flush_zombies.zombie_ttl') { |val| val.is_a?(Integer) }
-  validate('swarm.flush_zombies.zombie_lock_scan_size') { |val| val.is_a?(Integer) }
-  validate('swarm.flush_zombies.zombie_queue_scan_size') { |val| val.is_a?(Integer) }
-  validate('swarm.flush_zombies.zombie_flush_period') { |val| val.is_a?(Integer) }
+  validate('swarm.flush_zombies.zombie_ttl') { |val| val.is_a?(Integer) && val > 0 }
+  validate('swarm.flush_zombies.zombie_lock_scan_size') { |val| val.is_a?(Integer) && val > 0 }
+  validate('swarm.flush_zombies.zombie_queue_scan_size') { |val| val.is_a?(Integer) && val > 0 }
+  validate('swarm.flush_zombies.zombie_flush_period') { |val| val.is_a?(Integer) && val > 0 }
 
   validate('retry_count') { |val| val == nil || (val.is_a?(Integer) && val >= 0) }
   validate('retry_delay') { |val| val.is_a?(Integer) && val >= 0 }
   validate('retry_jitter') { |val| val.is_a?(Integer) && val >= 0 }
   validate('try_to_lock_timeout') { |val| val == nil || (val.is_a?(Integer) && val >= 0) }
-  validate('default_lock_ttl') { |val| val.is_a?(Integer) }
-  validate('default_queue_ttl') { |val| val.is_a?(Integer) }
+  validate('default_lock_ttl') { |val| val.is_a?(Integer) && val > 0 }
+  validate('default_queue_ttl') { |val| val.is_a?(Integer) && val > 0 }
   validate('detailed_acq_timeout_error') { |val| val == true || val == false }
-  validate('lock_release_batch_size') { |val| val.is_a?(Integer) }
-  validate('clear_locks_of__lock_scan_size') { |val| val.is_a?(Integer) }
-  validate('clear_locks_of__queue_scan_size') { |val| val.is_a?(Integer) }
-  validate('key_extraction_batch_size') { |val| val.is_a?(Integer) }
+  validate('lock_release_batch_size') { |val| val.is_a?(Integer) && val > 0 }
+  validate('clear_locks_of__lock_scan_size') { |val| val.is_a?(Integer) && val > 0 }
+  validate('clear_locks_of__queue_scan_size') { |val| val.is_a?(Integer) && val > 0 }
+  validate('key_extraction_batch_size') { |val| val.is_a?(Integer) && val > 0 }
   validate('instrumenter') { |val| RedisQueuedLocks::Instrument.valid_interface?(val) }
   validate('uniq_identifier') { |val| val.is_a?(Proc) }
   validate('logger') { |val| RedisQueuedLocks::Logging.valid_interface?(val) }
@@ -115,6 +117,27 @@ class RedisQueuedLocks::Config
     val == :random
     # rubocop:enable Layout/MultilineOperationIndentation
   end
+  validate('lock_priorities') do |val|
+    val.is_a?(Hash) && val.all? do |name, priority|
+      # rubocop:disable Layout/MultilineOperationIndentation
+      name.is_a?(Symbol) &&
+      priority.is_a?(Integer) &&
+      priority >= RedisQueuedLocks::Resource::MIN_LOCK_PRIORITY &&
+      priority <= RedisQueuedLocks::Resource::MAX_LOCK_PRIORITY
+      # rubocop:enable Layout/MultilineOperationIndentation
+    end
+  end
+  # NOTE: a Symbol is a priority name of `config['lock_priorities']`: a validator gets one value,
+  #   so the name is checked by the configuration itself (`prevent_default_priority__unknown_name`:
+  #   once after a configuration block, the keys can be assigned in any order; before a direct
+  #   assignment is applied);
+  validate('default_lock_priority') do |val|
+    val.is_a?(Symbol) || (
+      val.is_a?(Integer) &&
+      val >= RedisQueuedLocks::Resource::MIN_LOCK_PRIORITY &&
+      val <= RedisQueuedLocks::Resource::MAX_LOCK_PRIORITY
+    )
+  end
 
   # @return [Hash<Symbol,Any>]
   #
@@ -124,10 +147,14 @@ class RedisQueuedLocks::Config
 
   # @return [void]
   #
+  # @raise [RedisQueuedLocks::ConfigValidationError]
+  #
   # @api private
   # @since 1.13.0
+  # @version 1.22.0
   def initialize(&configuration)
     @config_state = {}
+    @configuring = false
     config_setters.each_value { |setter| setter.call(@config_state) }
     configure(&configuration)
   end
@@ -137,10 +164,40 @@ class RedisQueuedLocks::Config
   # @yieldparam [?]
   # @return [void]
   #
+  # @raise [RedisQueuedLocks::ConfigValidationError]
+  #
   # @api private
   # @since 1.13.0
+  # @version 1.22.0
   def configure(&configuration)
-    yield(self) if block_given?
+    return unless block_given?
+
+    # NOTE: (priorities) the keys of the block can be assigned in any order: the priority name of
+    #   `default_lock_priority` is checked against `lock_priorities` once, after the block (after
+    #   the outer block for nested blocks); an inconsistent pair is never applied: both keys keep
+    #   their values from before the block (also when the block fails: its error is raised);
+    lock_priorities = config_state['lock_priorities']
+    default_lock_priority = config_state['default_lock_priority']
+    nested = @configuring
+    completed = false
+    @configuring = true
+    begin
+      yield(self)
+      completed = true
+    ensure
+      @configuring = nested
+      unless nested
+        begin
+          prevent_default_priority__unknown_name(
+            config_state['lock_priorities'], config_state['default_lock_priority']
+          )
+        rescue RedisQueuedLocks::ConfigValidationError
+          config_state['lock_priorities'] = lock_priorities
+          config_state['default_lock_priority'] = default_lock_priority
+          raise if completed
+        end
+      end
+    end
   end
 
   # @param config_key [String]
@@ -164,9 +221,21 @@ class RedisQueuedLocks::Config
   #
   # @api public
   # @since 1.13.0
+  # @version 1.22.0
   def []=(config_key, config_value)
     prevent_key__non_existent(config_key)
     prevent_key__invalid_type(config_key, config_value)
+    # NOTE: (priorities) a direct assignment (out of a configuration block) keeps the priority name
+    #   of `default_lock_priority` a key of `lock_priorities` (a configuration block checks it once
+    #   after the block, see `configure`);
+    unless @configuring
+      case config_key
+      when 'lock_priorities'
+        prevent_default_priority__unknown_name(config_value, config_state['default_lock_priority'])
+      when 'default_lock_priority'
+        prevent_default_priority__unknown_name(config_state['lock_priorities'], config_value)
+      end
+    end
     config_state[config_key] = config_value
   end
 
@@ -237,5 +306,27 @@ class RedisQueuedLocks::Config
       )
     end
   end
+
+  # A priority name of the default lock request priority should be a priority name of
+  # `lock_priorities` (an unknown name would fail each lock acquirement with the default priority).
+  #
+  # @param lock_priorities [Hash<Symbol,Integer>] The priority names.
+  # @param default_lock_priority [Integer,Symbol] The default lock request priority.
+  # @return [void]
+  #
+  # @raise [RedisQueuedLocks::ConfigValidationError]
+  #
+  # @api private
+  # @since 1.22.0
+  def prevent_default_priority__unknown_name(lock_priorities, default_lock_priority)
+    if default_lock_priority.is_a?(Symbol) && !lock_priorities.key?(default_lock_priority)
+      raise(
+        RedisQueuedLocks::ConfigValidationError,
+        "The priority name #{default_lock_priority.inspect} of the 'default_lock_priority' " \
+        "config key is not a key of the 'lock_priorities' config key " \
+        "(#{lock_priorities.keys.map(&:inspect).join(', ')})."
+      )
+    end
+  end
 end
 # rubocop:enable Metrics/ClassLength

data/lib/redis_queued_locks/errors.rb

@@ -4,6 +4,12 @@
 #   the one-line definition style (like "Error = Class.new(::StandardError)")
 #   is not used cuz that style can not be correctly defined via RBS types: we can not
 #   identify the superclass of our class for a constant;
+# NOTE: (error hierarchy) each error inherits from the global base error of its branch:
+#   - `Error` (`::StandardError`) - the main hierarchy;
+#   - `ArgumentError` (`::ArgumentError`) - invalid arguments (the Ruby core branch that can not be
+#     a part of the main hierarchy);
+#   - `Exception` (`::Exception`) - super exceptional cases only: each error of this branch
+#     describes why it is not a `StandardError`;
 module RedisQueuedLocks
   # @api public
   # @since 1.0.0
@@ -13,13 +19,29 @@ module RedisQueuedLocks
   # @since 1.0.0
   class ArgumentError < ::ArgumentError; end
 
+  # The base of the errors that should not be rescued by the code they interrupt
+  # (`rescue => e`, `rescue StandardError`, `rescue nil`): like `Timeout::ExitException`,
+  # they are rescued only by `rescue Exception` (and by the library itself).
+  # NOTE: inside `module RedisQueuedLocks` a bare `Exception` refers to this class;
+  #
+  # @api private
+  # @since 1.21.0
+  class Exception < ::Exception; end # rubocop:disable Lint/InheritException
+
   # @api public
   # @since 1.0.0
   class LockAlreadyObtainedError < Error; end
 
+  # Interrupts the lock acquirement after the `timeout` (`Timeout.timeout`); rescued by
+  # `WithAcqTimeout` (=> `LockAcquirementTimeoutError` / `:timeout_reached`).
+  # NOTE: (why `Exception`) the acquirement calls the logger and the instrumenter: a `StandardError`
+  #   that interrupts them is swallowed by `rescue nil` of the log/instrumentation events, and the
+  #   acquirement continues without the timeout (with `retry_count: nil` - without any limit);
+  #
   # @api private
   # @since 1.11.0
-  class LockAcquirementIntermediateTimeoutError < ::Timeout::Error; end
+  # @version 1.21.0
+  class LockAcquirementIntermediateTimeoutError < Exception; end
 
   # @api public
   # @since 1.0.0
@@ -29,11 +51,19 @@ module RedisQueuedLocks
   # @since 1.0.0
   class LockAcquirementRetryLimitError < Error; end
 
+  # Interrupts the `timed: true` block after the lock ttl (`Timeout.timeout`); rescued by
+  # `YieldExpire` (=> `TimedLockTimeoutError`).
+  # NOTE: (why `Exception`) a `StandardError` is swallowed by `rescue => e` / `rescue nil` of
+  #   the user block: the block continues after the lock ttl (without the mutual exclusion:
+  #   another acquirer can obtain the expired lock, and the write lock release after the block
+  #   deletes its lock);
+  #
   # @api private
   # @since 1.12.0
-  class TimedLockIntermediateTimeoutError < ::Timeout::Error; end
+  # @version 1.21.0
+  class TimedLockIntermediateTimeoutError < Exception; end
 
-  # @api pulic
+  # @api public
   # @since 1.0.0
   class TimedLockTimeoutError < Error; end
 
@@ -57,7 +87,7 @@ module RedisQueuedLocks
   # @since 1.13.0
   class ConfigNotFoundError < ConfigError; end
 
-  # @api pub;ic
+  # @api public
   # @since 1.13.0
   class ConfigValidationError < ConfigError; end
 end

data/lib/redis_queued_locks/instrument/sampler.rb

@@ -3,12 +3,6 @@
 # @api public
 # @since 1.6.0
 module RedisQueuedLocks::Instrument::Sampler
-  # @return [Range]
-  #
-  # @api private
-  # @since 1.6.0
-  SAMPLING_PERCENT_RANGE = (0..100)
-
   class << self
     # Super simple probalistic function based on the `weight` of <true>/<false> values.
     # Requires the <percent> parameter as the required percent of <true> values sampled.
@@ -20,8 +14,11 @@ module RedisQueuedLocks::Instrument::Sampler
     #
     # @api public
     # @since 1.6.0
+    # @version 1.21.0
     def sampling_happened?(sampling_percent)
-      sampling_percent >= SecureRandom.rand(SAMPLING_PERCENT_RANGE)
+      # NOTE: one of 100 equally probable values (0..99): `sampling_percent` of them are lower
+      #   (0% => never, 100% => always);
+      SecureRandom.rand(100) < sampling_percent
     end
   end
 end

data/lib/redis_queued_locks/logging/sampler.rb

@@ -3,12 +3,6 @@
 # @api public
 # @since 1.5.0
 module RedisQueuedLocks::Logging::Sampler
-  # @return [Range]
-  #
-  # @api private
-  # @since 1.6.0
-  SAMPLING_PERCENT_RANGE = (0..100)
-
   class << self
     # Super simple probalistic function based on the `weight` of <true>/<false> values.
     # Requires the <percent> parameter as the required percent of <true> values sampled.
@@ -20,9 +14,11 @@ module RedisQueuedLocks::Logging::Sampler
     #
     # @api public
     # @since 1.5.0
-    # @version 1.6.0
+    # @version 1.21.0
     def sampling_happened?(sampling_percent)
-      sampling_percent >= SecureRandom.rand(SAMPLING_PERCENT_RANGE)
+      # NOTE: one of 100 equally probable values (0..99): `sampling_percent` of them are lower
+      #   (0% => never, 100% => always);
+      SecureRandom.rand(100) < sampling_percent
     end
   end
 end

data/lib/redis_queued_locks/resource.rb

@@ -2,6 +2,7 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.22.0
 # rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Resource
   # @return [String]
@@ -89,6 +90,44 @@ module RedisQueuedLocks::Resource
   # @since 1.3.0
   REDIS_TIMESHIFT_ERROR = 2
 
+  # The lowest lock request priority (the `priority` option of `#lock`).
+  #
+  # @return [Integer]
+  #
+  # @api private
+  # @since 1.22.0
+  MIN_LOCK_PRIORITY = -100
+
+  # The highest lock request priority (the `priority` option of `#lock`).
+  #
+  # @return [Integer]
+  #
+  # @api private
+  # @since 1.22.0
+  MAX_LOCK_PRIORITY = 100
+
+  # Lock request priority band: the position of the lock request in the lock request queue (the
+  # score) is the enqueue time (epoch, seconds) shifted by `priority * LOCK_PRIORITY_BAND` down:
+  #   - each priority gets its own range of positions (the band): requests of the higher priority
+  #     are always ahead of the requests of the lower priority, requests of the same priority are
+  #     ordered by the enqueue time (FIFO);
+  #   - 2**32 seconds (~136 years) is greater than any enqueue time (epoch) up to the year 2106,
+  #     so the bands never overlap and the priority is decoded from the position unambiguously;
+  #   - the default priority (`0`) keeps the position equal to the enqueue time (the positions of
+  #     the RQL versions without priorities);
+  #   - the band of the priority `p` is `(-p * LOCK_PRIORITY_BAND, (1 - p) * LOCK_PRIORITY_BAND)`;
+  #   - the enqueue time is decoded from the position of any priority, so dead lock requests of any
+  #     band are recognized by the position (the time barrier of the band, see
+  #     `lock_priority_band_dead_score`) without the knowledge of the priority range;
+  #   - the precision of the positions (the FIFO precision inside a priority) depends on the
+  #     shift: ~1 µs for -1..1, ~61 µs for -100..100 (`MIN_LOCK_PRIORITY`..`MAX_LOCK_PRIORITY`):
+  #     requests of the same priority made within this interval are ordered by acquirer ids;
+  # @return [Integer] In seconds.
+  #
+  # @api private
+  # @since 1.22.0
+  LOCK_PRIORITY_BAND = 4_294_967_296
+
   # rubocop:disable Metrics/ClassLength
   class << self
     # Returns 16-byte unique identifier. It is used for uniquely
@@ -275,6 +314,22 @@ module RedisQueuedLocks::Resource
       ::Process.clock_gettime(::Process::CLOCK_REALTIME, :millisecond)
     end
 
+    # Is the lock name of the lock index expired (all the keys of the lock are expired)?
+    #
+    # NOTE: the lock index replies of ZSCAN have String scores: `+inf` (a key without TTL indexed
+    #   by `ReindexLocks`) is `"inf"`, and `String#to_f` turns it into `0.0` (the name would be
+    #   skipped as an expired one by every lock index lookup): it never expires;
+    #
+    # @param lock_index_score [String] The score of the lock name (a ZSCAN reply).
+    # @param lock_index_time [Integer] The current client time (see `lock_index_time`).
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 1.22.0
+    def lock_index_score_expired?(lock_index_score, lock_index_time)
+      lock_index_score != 'inf' && lock_index_score.to_f < lock_index_time
+    end
+
     # @param lock_readers_key [String]
     # @return [String]
     #
@@ -326,16 +381,23 @@ module RedisQueuedLocks::Resource
       (Integer(redis_time[0]) * 1_000) + (Integer(redis_time[1]) / 1_000)
     end
 
-    # @return [Float] Redis's <Set> score that is calculated from the time (epoch) as a float.
+    # @param priority [Integer]
+    #   The lock request priority (from `MIN_LOCK_PRIORITY` to `MAX_LOCK_PRIORITY`).
+    # @return [Float]
+    #   Redis's <Set> score: the time (epoch, as a float) shifted by the priority band (see
+    #   `LOCK_PRIORITY_BAND`; the default priority `0` keeps the time).
     #
     # @api private
     # @since 1.0.0
-    def calc_initial_acquirer_position
-      Time.now.to_f
+    # @version 1.22.0
+    def calc_initial_acquirer_position(priority)
+      Time.now.to_f - (priority * LOCK_PRIORITY_BAND)
     end
 
     # @param queue_ttl [Numeric] In seconds
-    # @return [Float] Redis's <Set> score barrier for acquirers that should be removed from queue.
+    # @return [Float]
+    #   Redis's <Set> score barrier for acquirers that should be removed from queue (the time
+    #   barrier: the barrier of the default priority band, see `lock_priority_band_dead_score`).
     #
     # @api private
     # @since 1.0.0
@@ -343,6 +405,57 @@ module RedisQueuedLocks::Resource
       Time.now.to_f - queue_ttl
     end
 
+    # The lowest position (score) of the lock requests of the given priority band (see
+    # `LOCK_PRIORITY_BAND`): the lower bound of the dead lock request removal (`ZREMRANGEBYSCORE`).
+    #
+    # @param priority [Integer] Any priority (the bands of all priorities have the same layout).
+    # @return [Integer]
+    #   The lower edge of the band (the positions of the band never reach its edges: an enqueue
+    #   time is always greater than 0 and less than `LOCK_PRIORITY_BAND`).
+    #
+    # @api private
+    # @since 1.22.0
+    def lock_priority_band_floor(priority)
+      -priority * LOCK_PRIORITY_BAND
+    end
+
+    # Requests of the given priority band queued at this position or earlier are dead (the upper
+    # bound of the dead lock request removal, see `LOCK_PRIORITY_BAND`).
+    #
+    # @param dead_score [Float] The time barrier (see `acquirer_dead_score`).
+    # @param priority [Integer]
+    # @return [Float]
+    #
+    # @api private
+    # @since 1.22.0
+    def lock_priority_band_dead_score(dead_score, priority)
+      dead_score - (priority * LOCK_PRIORITY_BAND)
+    end
+
+    # Priority of the lock request by its position in the lock request queue (the score).
+    #
+    # NOTE: (infinite positions) RQL never writes infinite positions (manual writes of the lock
+    #   request queues): they are out of all bands and are decoded to the bounds of the priority
+    #   range (the floor of an infinite Float raises `FloatDomainError`):
+    #   - `-inf`: `MAX_LOCK_PRIORITY` (ahead of all lock requests; such a request is dead: its
+    #     enqueue time is unknown, it is dropped like before priorities);
+    #   - `+inf`: `MIN_LOCK_PRIORITY` (behind all lock requests; never dead);
+    #
+    # @param acquirer_position [Numeric] The position (the score) of the lock request.
+    # @return [Integer] See `LOCK_PRIORITY_BAND`.
+    #
+    # @api private
+    # @since 1.22.0
+    def lock_request_priority(acquirer_position)
+      if acquirer_position == -Float::INFINITY
+        MAX_LOCK_PRIORITY
+      elsif acquirer_position == Float::INFINITY
+        MIN_LOCK_PRIORITY
+      else
+        -(acquirer_position / LOCK_PRIORITY_BAND).floor
+      end
+    end
+
     # @param zombie_ttl [Float] In seconds with milliseconds.
     # @return [Float]
     #
@@ -353,8 +466,10 @@ module RedisQueuedLocks::Resource
     end
 
     # @param acquirer_position [Float]
-    #   A time (epoch, seconds.milliseconds) that represents
-    #   the acquirer position in lock request queue.
+    #   A time (epoch, seconds.milliseconds) shifted by the priority band that represents
+    #   the acquirer position in lock request queue (see `calc_initial_acquirer_position`).
+    # @param priority [Integer]
+    #   The lock request priority (the band of the position).
     # @param queue_ttl [Integer]
     #   In second.
     # @return [Boolean]
@@ -362,18 +477,28 @@ module RedisQueuedLocks::Resource
     #
     # @api private
     # @since 1.0.0
-    def dead_score_reached?(acquirer_position, queue_ttl)
-      (acquirer_position + queue_ttl) < Time.now.to_f
+    # @version 1.22.0
+    def dead_score_reached?(acquirer_position, priority, queue_ttl)
+      (acquirer_position + (priority * LOCK_PRIORITY_BAND) + queue_ttl) < Time.now.to_f
     end
 
-    # @param lock_queue [String]
-    # @return [String]
+    # NOTE: (debug) not used by the library: a manual runtime check (in a console) of the lock that
+    #   a queue belongs to (e.g. `Resource.lock_key_from_queue(client.queues.first)`);
+    #
+    # @param lock_queue [String] `rql:lock_queue:<name>` or `rql:lock_read_queue:<name>`.
+    # @return [String,NilClass]
+    #   - `rql:lock:<name>` for the write lock request queue and for the read lock request queue;
+    #   - `nil` for any other key;
     #
     # @api private
     # @since 1.0.0
+    # @version 1.21.0
     def lock_key_from_queue(lock_queue)
-      # NOTE: 15 is a start position of the lock name
-      "rql:lock:#{lock_queue[15..]}"
+      key_family = lock_key_family(lock_queue)
+      return unless key_family == :lock_queue || key_family == :read_lock_queue
+
+      lock_name = lock_name_from_key(lock_queue, key_family) #: String
+      prepare_lock_key(lock_name)
     end
 
     # @return [Integer]

data/lib/redis_queued_locks/swarm/flush_zombies.rb

@@ -2,6 +2,7 @@
 
 # @api private
 # @since 1.9.0
+# @version 1.20.0
 # rubocop:disable Metrics/ClassLength
 class RedisQueuedLocks::Swarm::FlushZombies < RedisQueuedLocks::Swarm::SwarmElement::Isolated
   class << self

data/lib/redis_queued_locks/swarm/redis_client_builder.rb

@@ -7,19 +7,23 @@ module RedisQueuedLocks::Swarm::RedisClientBuilder
     # @option pooled [Boolean]
     # @option sentinel [Boolean]
     # @option config [Hash]
+    # @option pool_config [Hash]
     # @return [RedisClient|RedisClient::Pooled]
     #
     # @api private
     # @since 1.9.0
+    # @version 1.21.0
     # rubocop:disable Style/RedundantAssignment
     def build(pooled: false, sentinel: false, config: {}, pool_config: {})
-      config.transform_keys!(&:to_sym)
-      pool_config.transform_keys!(&:to_sym)
+      # NOTE: the passed hashes are not mutated: they are the values of the client config (they
+      #   can be frozen and are shared with the zombie flusher Ractor when they are shareable);
+      redis_options = config.transform_keys(&:to_sym)
+      pool_options = pool_config.transform_keys(&:to_sym)
 
       redis_config =
-        sentinel ? sentinel_config(config) : non_sentinel_config(config)
+        sentinel ? sentinel_config(redis_options) : non_sentinel_config(redis_options)
       redis_client =
-        pooled ? pooled_client(redis_config, pool_config) : non_pooled_client(redis_config)
+        pooled ? pooled_client(redis_config, pool_options) : non_pooled_client(redis_config)
 
       redis_client
     end

data/lib/redis_queued_locks/swarm/swarm_element/threaded.rb

@@ -2,6 +2,7 @@
 
 # @api private
 # @since 1.9.0
+# @version 1.21.1
 # rubocop:disable Metrics/ClassLength
 class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   # @since 1.9.0
@@ -69,7 +70,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
     return unless enabled?
 
     sync.synchronize do
-      swarm_element__termiante
+      swarm_element__terminate
       swarm!
       swarm_loop__start
     end
@@ -78,7 +79,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   # @return [void]
   #
   # @api private
-  # @since 19.0.0
+  # @since 1.9.0
   def reswarm_if_dead!
     return unless enabled?
 
@@ -98,7 +99,7 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   # @since 1.9.0
   def try_kill!
     sync.synchronize do
-      swarm_element__termiante
+      swarm_element__terminate
     end
   end
 
@@ -154,9 +155,9 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
 
   # Swarm element lifecycle have the following flow:
   # => 1) init (swarm!): create a thread, main loop is not started;
-  # => 2) start (swarm_loop__start): run the main lopp inside the created thread;
+  # => 2) start (swarm_loop__start): run the main loop inside the created thread;
   # => 3) stop (swarm_loop__stop): stop the main loop inside the created thread;
-  # => 4) terminate (swarm_element__termiante): kill the created thread;
+  # => 4) terminate (swarm_element__terminate): kill the created thread;
   # In addition you should implement `#spawn_main_loop!` method that will be the main logic
   # of the your swarm element.
   #
@@ -340,7 +341,8 @@ class RedisQueuedLocks::Swarm::SwarmElement::Threaded
   #
   # @api private
   # @since 1.9.0
-  def swarm_element__termiante
+  # @version 1.21.1
+  def swarm_element__terminate
     return if idle? || swarmed__dead?
     sync.synchronize do
       main_loop&.kill

data/lib/redis_queued_locks/swarm/zombie_info.rb

@@ -232,7 +232,8 @@ module RedisQueuedLocks::Swarm::ZombieInfo
     # names, the full keyspace is never scanned): write locks and readers registries are processed
     # in batches of `lock_scan_size` locks with one round trip per batch and per key family
     # (batches are collected across ZSCAN pages). Expired lock names of the index are skipped
-    # (all their keys are expired).
+    # (all their keys are expired; `+inf` names, keys without TTL, never expire: see
+    # `RedisQueuedLocks::Resource.lock_index_score_expired?`).
     #
     # @param rconn [RedisClient] redis connection obtained via `#with` from RedisClient instance;
     # @param zombie_hosts [Set<String>]
@@ -244,6 +245,7 @@ module RedisQueuedLocks::Swarm::ZombieInfo
     #
     # @api private
     # @since 1.20.0
+    # @version 1.22.0
     def each_lock_index_zombie_lock(rconn, zombie_hosts, lock_scan_size, &block)
       # @type var lock_keys: Array[String]
       lock_keys = []
@@ -255,7 +257,9 @@ module RedisQueuedLocks::Swarm::ZombieInfo
         RedisQueuedLocks::Resource::LOCK_INDEX_KEY, count: lock_scan_size
       ) do |lock_name, lock_index_score|
         # NOTE: the expired lock name (not dropped from the index yet): its keys are expired
-        next if lock_index_score.to_f < lock_index_time
+        next if RedisQueuedLocks::Resource.lock_index_score_expired?(
+          lock_index_score, lock_index_time
+        )
 
         lock_keys << RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
         lock_readers_keys << RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)