redis_queued_locks 1.21.0 → 1.22.0

data/lib/redis_queued_locks/acquirer/keys.rb

@@ -134,7 +134,8 @@ module RedisQueuedLocks::Acquirer::Keys
 
     # Iterates over the lock names of the lock index (one ZSCAN pass) in batches of `scan_size`
     # lock names (batches are collected across ZSCAN pages). Expired lock names (not dropped from
-    # the index yet) are skipped: all their keys are expired.
+    # the index yet) are skipped: all their keys are expired (`+inf` names, keys without TTL, never
+    # expire: see `RedisQueuedLocks::Resource.lock_index_score_expired?`).
     #
     # NOTE: each operation module iterates over the lock index by itself (duplicated on purpose:
     #   operation modules are independent of each other, see `Locks.each_lock_name_batch`);
@@ -147,6 +148,7 @@ module RedisQueuedLocks::Acquirer::Keys
     #
     # @api private
     # @since 1.20.0
+    # @version 1.22.0
     def each_lock_name_batch(redis_client, scan_size)
       lock_index_time = RedisQueuedLocks::Resource.lock_index_time
       # @type var lock_names: Array[String]
@@ -155,7 +157,9 @@ module RedisQueuedLocks::Acquirer::Keys
       redis_client.zscan(
         RedisQueuedLocks::Resource::LOCK_INDEX_KEY, count: scan_size
       ) do |lock_name, lock_index_score|
-        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_names << lock_name
         next if lock_names.size < scan_size

data/lib/redis_queued_locks/acquirer/lock_series_poc/instr_visitor.rb

@@ -3,19 +3,21 @@
 # NOTE: Lock Series PoC
 # @api private
 # @since 1.16.1
-# @version 1.18.0
+# @version 1.22.0
 module RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor # steep:ignore
   class << self
     # NOTE: Lock Series PoC
     # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
+    # @param priority [Integer] The lock request priority of the series.
     # @api private
     # @since 1.16.1
-    # @version 1.18.0
+    # @version 1.22.0
     def lock_series_obtained( # steep:ignore
       instrumenter,
       instr_sampled,
       lock_keys,
       rw_mode,
+      priority,
       ttl,
       acq_id,
       hst_id,
@@ -25,20 +27,22 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor # steep:ignore
     )
       return unless instr_sampled
       instrumenter.notify('redis_queued_locks.lock_series_obtained', {
-        lock_keys:, rw_mode:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
+        lock_keys:, rw_mode:, priority:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
       }) rescue nil
     end
 
     # NOTE: Lock Series PoC
     # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
+    # @param priority [Integer] The lock request priority of the series.
     # @api private
     # @since 1.16.1
-    # @version 1.21.0
+    # @version 1.22.0
     def lock_series_hold_and_release( # steep:ignore
       instrumenter,
       instr_sampled,
       lock_keys,
       rw_mode,
+      priority,
       ttl,
       acq_id,
       hst_id,
@@ -49,7 +53,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor # steep:ignore
     )
       return unless instr_sampled
       instrumenter.notify('redis_queued_locks.lock_series_hold_and_release', {
-        lock_keys:, rw_mode:, hold_time:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
+        lock_keys:, rw_mode:, priority:, hold_time:, ttl:, acq_id:, hst_id:, ts:, acq_time:,
+        instrument:
       }) rescue nil
     end
   end

data/lib/redis_queued_locks/acquirer/lock_series_poc/log_visitor.rb

@@ -3,14 +3,15 @@
 # NOTE: Lock Series PoC
 # @api private
 # @since 1.16.1
-# @version 1.18.0
+# @version 1.22.0
 module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
   class << self
     # NOTE: Lock Series PoC
     # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
+    # @param priority [Integer] The lock request priority of the series.
     # @api private
     # @since 1.16.0
-    # @version 1.21.0
+    # @version 1.22.0
     def start_lock_series_obtaining( # steep:ignore
       logger,
       log_sampled,
@@ -19,7 +20,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
       acquirer_id,
       host_id,
       access_strategy,
-      rw_mode
+      rw_mode,
+      priority
     )
       return unless log_sampled
 
@@ -30,15 +32,17 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
         "acq_id => '#{acquirer_id}' " \
         "hst_id => '#{host_id}' " \
         "acs_strat => '#{access_strategy}' " \
-        "rw_mode => '#{rw_mode}'"
+        "rw_mode => '#{rw_mode}' " \
+        "priority => #{priority}"
       end rescue nil
     end
 
     # NOTE: Lock Series PoC
     # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
+    # @param priority [Integer] The lock request priority of the series.
     # @api private
     # @since 1.16.0
-    # @version 1.21.0
+    # @version 1.22.0
     def lock_series_obtained( # steep:ignore
       logger,
       log_sampled,
@@ -48,7 +52,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
       host_id,
       acq_time,
       access_strategy,
-      rw_mode
+      rw_mode,
+      priority
     )
       return unless log_sampled
 
@@ -60,15 +65,17 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
         "hst_id => '#{host_id}' " \
         "acs_strat => '#{access_strategy}' " \
         "rw_mode => '#{rw_mode}' " \
+        "priority => #{priority} " \
         "acq_time => #{acq_time} (ms)"
       end rescue nil
     end
 
     # NOTE: Lock Series PoC
     # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
+    # @param priority [Integer] The lock request priority of the series.
     # @api private
     # @since 1.16.0
-    # @version 1.18.0
+    # @version 1.22.0
     def expire_lock_series( # steep:ignore
       logger,
       log_sampled,
@@ -77,7 +84,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
       acquirer_id,
       host_id,
       access_strategy,
-      rw_mode
+      rw_mode,
+      priority
     )
       return unless log_sampled
 
@@ -88,7 +96,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
         "acq_id => '#{acquirer_id}' " \
         "hst_id => '#{host_id}' " \
         "acs_strat => '#{access_strategy}' " \
-        "rw_mode => '#{rw_mode}'"
+        "rw_mode => '#{rw_mode}' " \
+        "priority => #{priority}"
       end rescue nil
     end
   end

data/lib/redis_queued_locks/acquirer/lock_series_poc.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 # NOTE: Lock Series PoC
-# rubocop:disable all
+# rubocop:disable Metrics/ModuleLength, Metrics/ClassLength, Metrics/MethodLength
 # @api private
 # @since 1.16.0
-# @version 1.20.0
+# @version 1.22.0
 module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
   require_relative 'lock_series_poc/log_visitor'
   require_relative 'lock_series_poc/instr_visitor'
@@ -15,7 +15,7 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
   class << self
     # @api private
     # @since 1.16.0
-    # @version 1.21.0
+    # @version 1.22.0
     def lock_series_poc( # steep:ignore
       redis,
       lock_names,
@@ -45,6 +45,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
       conflict_strategy:,
       read_write_mode:,
       access_strategy:,
+      priority:,
+      lock_priorities:,
       log_sampling_enabled:,
       log_sampling_percent:,
       log_sampler:,
@@ -57,6 +59,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
     )
       # NOTE: (RW) the lock mode is the same for all locks of the series
       #   (see RedisQueuedLocks::Acquirer::AcquireLock for read_write_mode validations);
+      # NOTE: the lock request priority is the same for all locks of the series too (validated
+      #   below: the series logs and instrumentation report it);
 
       case meta
       when Hash, NilClass then nil
@@ -120,6 +124,23 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
         )
       end
 
+      # NOTE: the priority of the series is validated before the series logs and instrumentation:
+      #   a priority name is resolved to its Integer priority (the series events report the Integer
+      #   priority; the same check as in RedisQueuedLocks::Acquirer::AcquireLock);
+      priority = lock_priorities.fetch(priority, priority) if priority.is_a?(::Symbol)
+      if !priority.is_a?(::Integer) ||
+         priority < RedisQueuedLocks::Resource::MIN_LOCK_PRIORITY ||
+         priority > RedisQueuedLocks::Resource::MAX_LOCK_PRIORITY
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`:priority` argument should be an Integer from " \
+          "#{RedisQueuedLocks::Resource::MIN_LOCK_PRIORITY} to " \
+          "#{RedisQueuedLocks::Resource::MAX_LOCK_PRIORITY} or a priority name of " \
+          "`config['lock_priorities']` (#{lock_priorities.keys.map(&:inspect).join(', ')}), " \
+          "got #{priority.inspect}."
+        )
+      end
+
       locks_count = lock_names.size
 
       lock_acquirement_operations = lock_names.each_with_index.map do |lock_name, position|
@@ -164,10 +185,10 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
         identity
       )
 
-      RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor.start_lock_series_obtaining( # steep:ignore
+      LogVisitor.start_lock_series_obtaining( # steep:ignore
         logger, log_sampled, lock_keys_for_instrumentation,
-        queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation, access_strategy,
-        read_write_mode
+        queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation,
+        access_strategy, read_write_mode, priority
       )
 
       acq_start_time = RedisQueuedLocks::Utilities.clock_gettime
@@ -208,6 +229,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
               conflict_strategy:,
               read_write_mode:,
               access_strategy:,
+              priority:,
+              lock_priorities:,
               log_sampling_enabled:,
               log_sampling_percent:,
               log_sampler:,
@@ -240,7 +263,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
         else
           failed_on_lock = lock_operation_options[:lock_name]
           failed_locks_and_errors[lock_operation_options[:lock_name]] = result
-          # NOTE: release all previously acquired locks (non-exceptional failure: raise_errors: false)
+          # NOTE: release all previously acquired locks
+          #   (non-exceptional failure: raise_errors: false)
           unless is_failed_series_released
             release_lock_series( # steep:ignore
               redis, read_write_mode, successfully_acquired_locks, acquirer_id_for_instrumentation
@@ -251,20 +275,22 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
         end
       end
 
-      if (successfully_acquired_locks.size == lock_names.size && (successfully_acquired_locks.all? { |res| res[:ok] }))
+      if successfully_acquired_locks.size == lock_names.size &&
+         successfully_acquired_locks.all? { |res| res[:ok] }
         acq_end_time = RedisQueuedLocks::Utilities.clock_gettime
         acq_time = ((acq_end_time - acq_start_time) / 1_000.0).ceil(2)
         ts = Time.now.to_f
 
-        RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor.lock_series_obtained( # steep:ignore
+        LogVisitor.lock_series_obtained( # steep:ignore
           logger, log_sampled, lock_keys_for_instrumentation,
           queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation,
-          acq_time, access_strategy, read_write_mode
+          acq_time, access_strategy, read_write_mode, priority
         )
 
-        RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor.lock_series_obtained( # steep:ignore
-          instrumenter, instr_sampled, lock_keys_for_instrumentation, read_write_mode,
-          ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation, ts, acq_time, instrument
+        InstrVisitor.lock_series_obtained( # steep:ignore
+          instrumenter, instr_sampled, lock_keys_for_instrumentation, read_write_mode, priority,
+          ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation, ts, acq_time,
+          instrument
         )
 
         yield_time = RedisQueuedLocks::Utilities.clock_gettime
@@ -274,8 +300,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
         ).ceil(2)
 
         yield_result = nil
-        is_lock_manually_released = nil
-        hold_time = nil
+        # @type var is_lock_manually_released: bool
+        # @type var hold_time: Float | Integer
 
         begin
           yield_result = yield_expire( # steep:ignore
@@ -316,17 +342,18 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
           hold_time = ((rel_time - acq_end_time) / 1_000.0).ceil(2)
           ts = Time.now.to_f
 
-          RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor.expire_lock_series( # steep:ignore
+          LogVisitor.expire_lock_series( # steep:ignore
             logger, log_sampled, lock_keys_for_instrumentation,
-            queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation, access_strategy,
-            read_write_mode
+            queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation,
+            access_strategy, read_write_mode, priority
           ) if is_lock_manually_released
 
-          RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor.lock_series_hold_and_release( # steep:ignore
+          InstrVisitor.lock_series_hold_and_release( # steep:ignore
             instrumenter,
             instr_sampled,
             lock_keys_for_instrumentation,
             read_write_mode,
+            priority,
             ttl,
             acquirer_id_for_instrumentation,
             host_id_for_instrumentation,
@@ -362,7 +389,7 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
             lock_series: lock_names,
             acquired_locks:,
             missing_locks:,
-            failed_on_lock:,
+            failed_on_lock:
           }
         }
       end
@@ -382,7 +409,9 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
     #
     # @api private
     # @since 1.18.0
-    def release_lock_series(redis, read_write_mode, successfully_acquired_locks, acquirer_id) # steep:ignore
+    def release_lock_series( # steep:ignore
+      redis, read_write_mode, successfully_acquired_locks, acquirer_id
+    )
       lock_names = obtained_lock_names(successfully_acquired_locks) # steep:ignore
 
       if read_write_mode == :read
@@ -427,7 +456,7 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
             own_lock_keys.each { |lock_key| transaction.call('DEL', lock_key) }
           end
           # NOTE: `nil` => the transaction is aborted (a watched lock is changed) => retry
-          break unless released.nil?
+          break unless released == nil
         end
       rescue RedisQueuedLocks::LockAcquirementIntermediateTimeoutError,
              RedisQueuedLocks::TimedLockIntermediateTimeoutError,
@@ -481,4 +510,4 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
     end
   end
 end
-# rubocop:enable all
+# rubocop:enable Metrics/ModuleLength, Metrics/ClassLength, Metrics/MethodLength

data/lib/redis_queued_locks/acquirer/locks.rb

@@ -115,7 +115,8 @@ module RedisQueuedLocks::Acquirer::Locks
 
     # Iterates over the lock names of the lock index (one ZSCAN pass) in batches of `scan_size`
     # lock names (batches are collected across ZSCAN pages). Expired lock names (not dropped from
-    # the index yet) are skipped: all their keys are expired.
+    # the index yet) are skipped: all their keys are expired (`+inf` names, keys without TTL, never
+    # expire: see `RedisQueuedLocks::Resource.lock_index_score_expired?`).
     #
     # NOTE: each operation module iterates over the lock index by itself (duplicated on purpose:
     #   operation modules are independent of each other, see `extract_locks_info`);
@@ -128,6 +129,7 @@ module RedisQueuedLocks::Acquirer::Locks
     #
     # @api private
     # @since 1.20.0
+    # @version 1.22.0
     def each_lock_name_batch(redis_client, scan_size)
       lock_index_time = RedisQueuedLocks::Resource.lock_index_time
       # @type var lock_names: Array[String]
@@ -136,7 +138,9 @@ module RedisQueuedLocks::Acquirer::Locks
       redis_client.zscan(
         RedisQueuedLocks::Resource::LOCK_INDEX_KEY, count: scan_size
       ) do |lock_name, lock_index_score|
-        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_names << lock_name
         next if lock_names.size < scan_size

data/lib/redis_queued_locks/acquirer/queue_info.rb

@@ -16,22 +16,34 @@ module RedisQueuedLocks::Acquirer::QueueInfo
     #   - result format: {
     #     "lock_queue" => "rql:lock_queue:your_lock_name", # lock queue key in redis,
     #     "queue" => [
-    #       { "acq_id" => "rql:acq:123/456/789/987/id", "score" => 123.456, "rw_mode" => "write" },
-    #       { "acq_id" => "rql:acq:123/686/789/987/id", "score" => 456.789, "rw_mode" => "write" },
+    #       {
+    #         "acq_id" => "rql:acq:123/456/789/987/id",
+    #         "score" => 123.456,
+    #         "rw_mode" => "write",
+    #         "priority" => 0
+    #       },
     #       ...
     #     ] # ordered set (by score) with information about an acquirer, their position in queue
-    #       # and the requested lock mode
+    #       # (the enqueue time shifted by the priority band: see
+    #       # `RedisQueuedLocks::Resource::LOCK_PRIORITY_BAND`), the requested lock mode and
+    #       # the lock request priority (decoded from the position)
     #     <additional keys when the queue of read lock requests exists>:
     #     "read_lock_queue" => "rql:lock_read_queue:your_lock_name", # read lock queue key in redis
     #     "read_queue" => [
-    #       { "acq_id" => "rql:acq:123/456/789/987/id", "score" => 123.456, "rw_mode" => "read" },
+    #       {
+    #         "acq_id" => "rql:acq:123/456/789/987/id",
+    #         "score" => 123.456,
+    #         "rw_mode" => "read",
+    #         "priority" => 0
+    #       },
     #       ...
     #     ] # read lock requests (positions are comparable with the write lock request positions)
     #   }
     #
     # @api private
     # @since 1.0.0
-    # @version 1.20.0
+    # @version 1.22.0
+    # rubocop:disable Metrics/MethodLength
     def queue_info(redis_client, lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
       read_lock_key_queue = RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name)
@@ -54,14 +66,24 @@ module RedisQueuedLocks::Acquirer::QueueInfo
         queue_info = {
           'lock_queue' => lock_key_queue,
           'queue' => zrange_cmd_res.map do |val|
-            { 'acq_id' => val[0], 'score' => val[1], 'rw_mode' => 'write' }
+            {
+              'acq_id' => val[0],
+              'score' => val[1],
+              'rw_mode' => 'write',
+              'priority' => RedisQueuedLocks::Resource.lock_request_priority(val[1])
+            }
           end
         }
         # NOTE: (RW) the queue of read lock requests
         unless read_zrange_cmd_res.empty?
           queue_info['read_lock_queue'] = read_lock_key_queue
           queue_info['read_queue'] = read_zrange_cmd_res.map do |val|
-            { 'acq_id' => val[0], 'score' => val[1], 'rw_mode' => 'read' }
+            {
+              'acq_id' => val[0],
+              'score' => val[1],
+              'rw_mode' => 'read',
+              'priority' => RedisQueuedLocks::Resource.lock_request_priority(val[1])
+            }
           end
         end
         queue_info
@@ -70,5 +92,6 @@ module RedisQueuedLocks::Acquirer::QueueInfo
         nil
       end
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/redis_queued_locks/acquirer/queues.rb

@@ -15,7 +15,7 @@ module RedisQueuedLocks::Acquirer::Queues
     #
     # @api private
     # @since 1.0.0
-    # @version 1.21.0
+    # @version 1.22.0
     def queues(redis_client, scan_size:, with_info:, lock_index_enabled:)
       # NOTE: (arguments) the same range as the config key: zero/negative sizes fail SCAN/ZSCAN
       #   (`COUNT 0`) and the batching (`each_slice(0)`);
@@ -102,7 +102,8 @@ module RedisQueuedLocks::Acquirer::Queues
 
     # Iterates over the lock names of the lock index (one ZSCAN pass) in batches of `scan_size`
     # lock names (batches are collected across ZSCAN pages). Expired lock names (not dropped from
-    # the index yet) are skipped: all their keys are expired.
+    # the index yet) are skipped: all their keys are expired (`+inf` names, keys without TTL, never
+    # expire: see `RedisQueuedLocks::Resource.lock_index_score_expired?`).
     #
     # NOTE: each operation module iterates over the lock index by itself (duplicated on purpose:
     #   operation modules are independent of each other, see `Locks.each_lock_name_batch`);
@@ -115,6 +116,7 @@ module RedisQueuedLocks::Acquirer::Queues
     #
     # @api private
     # @since 1.20.0
+    # @version 1.22.0
     def each_lock_name_batch(redis_client, scan_size)
       lock_index_time = RedisQueuedLocks::Resource.lock_index_time
       # @type var lock_names: Array[String]
@@ -123,7 +125,9 @@ module RedisQueuedLocks::Acquirer::Queues
       redis_client.zscan(
         RedisQueuedLocks::Resource::LOCK_INDEX_KEY, count: scan_size
       ) do |lock_name, lock_index_score|
-        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_names << lock_name
         next if lock_names.size < scan_size
@@ -139,11 +143,13 @@ module RedisQueuedLocks::Acquirer::Queues
     # @param lock_queues [Set<String>]
     # @param scan_size [Integer] The number of queues whose requests are read in one round trip.
     # @return [Set<Hash<Symbol,Any>>]
-    #   - each request: `{ 'acq_id' => String, 'score' => Float, 'rw_mode' => 'read'/'write' }`;
+    #   - each request: `{ 'acq_id' => String, 'score' => Float, 'rw_mode' => 'read'/'write',
+    #     'priority' => Integer }` (the priority is decoded from the position: see
+    #     `RedisQueuedLocks::Resource::LOCK_PRIORITY_BAND`);
     #
     # @api private
     # @since 1.0.0
-    # @version 1.20.0
+    # @version 1.22.0
     def extract_queues_info(redis_client, lock_queues, scan_size)
       # NOTE: the same approach as in `QueueInfo` (duplicated on purpose: public operation modules
       #   do not reuse each other, they share logic via `Resource`, `Utilities`);
@@ -171,7 +177,12 @@ module RedisQueuedLocks::Acquirer::Queues
             seeded_queues << {
               queue: lock_queue,
               requests: queues_requests[index].map do |val|
-                { 'acq_id' => val[0], 'score' => val[1], 'rw_mode' => rw_mode }
+                {
+                  'acq_id' => val[0],
+                  'score' => val[1],
+                  'rw_mode' => rw_mode,
+                  'priority' => RedisQueuedLocks::Resource.lock_request_priority(val[1])
+                }
               end
             }
           end

data/lib/redis_queued_locks/acquirer/release_all_locks.rb

@@ -272,7 +272,8 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
 
     # Iterates over the lock names of the lock index (one ZSCAN pass) in batches of `scan_size`
     # lock names (batches are collected across ZSCAN pages). Expired lock names (not dropped from
-    # the index yet) are skipped: all their keys are expired.
+    # the index yet) are skipped: all their keys are expired (`+inf` names, keys without TTL, never
+    # expire: see `RedisQueuedLocks::Resource.lock_index_score_expired?`).
     #
     # NOTE: each operation module iterates over the lock index by itself (duplicated on purpose:
     #   operation modules are independent of each other, see `Locks.each_lock_name_batch`);
@@ -285,6 +286,7 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
     #
     # @api private
     # @since 1.20.0
+    # @version 1.22.0
     def each_lock_name_batch(redis_client, scan_size)
       lock_index_time = RedisQueuedLocks::Resource.lock_index_time
       # @type var lock_names: Array[String]
@@ -293,7 +295,9 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
       redis_client.zscan(
         RedisQueuedLocks::Resource::LOCK_INDEX_KEY, count: scan_size
       ) do |lock_name, lock_index_score|
-        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_names << lock_name
         next if lock_names.size < scan_size

data/lib/redis_queued_locks/acquirer/release_locks_of.rb

@@ -427,7 +427,8 @@ module RedisQueuedLocks::Acquirer::ReleaseLocksOf
 
     # Iterates over the lock names of the lock index (one ZSCAN pass) in batches of `scan_size`
     # lock names (batches are collected across ZSCAN pages). Expired lock names (not dropped from
-    # the index yet) are skipped: all their keys are expired.
+    # the index yet) are skipped: all their keys are expired (`+inf` names, keys without TTL, never
+    # expire: see `RedisQueuedLocks::Resource.lock_index_score_expired?`).
     #
     # NOTE: each operation module iterates over the lock index by itself (duplicated on purpose:
     #   operation modules are independent of each other, see `Locks.each_lock_name_batch`);
@@ -440,6 +441,7 @@ module RedisQueuedLocks::Acquirer::ReleaseLocksOf
     #
     # @api private
     # @since 1.20.0
+    # @version 1.22.0
     def each_lock_name_batch(redis_client, scan_size)
       lock_index_time = RedisQueuedLocks::Resource.lock_index_time
       # @type var lock_names: Array[String]
@@ -448,7 +450,9 @@ module RedisQueuedLocks::Acquirer::ReleaseLocksOf
       redis_client.zscan(
         RedisQueuedLocks::Resource::LOCK_INDEX_KEY, count: scan_size
       ) do |lock_name, lock_index_score|
-        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_names << lock_name
         next if lock_names.size < scan_size