redis_queued_locks 1.20.0 → 1.21.0

data/lib/redis_queued_locks/acquirer/extend_lock_ttl.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.0.0
-# @version 1.20.0
+# @version 1.21.0
 # rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Acquirer::ExtendLockTTL
   # @return [String]
@@ -14,11 +14,18 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     return redis.call("PEXPIRE", KEYS[1], new_lock_pttl);
   LUA_SCRIPT
 
+  # @since 1.21.0
+  extend RedisQueuedLocks::Utilities
+
   # rubocop:disable Metrics/ClassLength
   class << self
+    # Extends the lock TTL and reports the operation (one log and one instrumentation event
+    # `redis_queued_locks.extend_lock_ttl` with the time of the whole operation).
+    #
     # @param redis_client [RedisClient]
     # @param lock_name [String]
     # @param milliseconds [Integer]
+    #   How many milliseconds should be added: a positive Integer.
     # @param read_write_mode [Symbol]
     #   - `:write` - extends the write lock (of any acquirer);
     #   - `:read` - extends the read lock of the given acquirer (other read locks are not affected)
@@ -45,7 +52,7 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     #
     # @api private
     # @since 1.0.0
-    # @version 1.20.0
+    # @version 1.21.0
     # rubocop:disable Metrics/MethodLength
     def extend_lock_ttl(
       redis_client,
@@ -75,16 +82,105 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
         )
       end
 
+      # NOTE: a non-positive value would decrease the lock ttl or delete the lock;
+      if !milliseconds.is_a?(::Integer) || milliseconds <= 0
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`milliseconds` argument should be a positive Integer, got #{milliseconds.inspect}."
+        )
+      end
+
+      if read_write_mode == :read && all_read_locks != true && all_read_locks != false
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`:all_read_locks` argument should be a boolean, got #{all_read_locks.inspect}."
+        )
+      end
+
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
 
-      if read_write_mode == :read
-        if all_read_locks != true && all_read_locks != false
-          raise(
-            RedisQueuedLocks::ArgumentError,
-            "`:all_read_locks` argument should be a boolean, got #{all_read_locks.inspect}."
-          )
+      ext_start_time = clock_gettime
+      result = fully_extend_lock_ttl(
+        redis_client, lock_name, lock_key, milliseconds, read_write_mode, all_read_locks,
+        acquirer_id, lock_index_enabled
+      )
+      time_at = Time.now.to_f
+      ext_end_time = clock_gettime
+      ext_time = ((ext_end_time - ext_start_time) / 1_000.0).ceil(2)
+      ext_result = result[:result]
+      extended_locks_count = ext_result.is_a?(::Hash) ? ext_result[:extended_locks_count] : 0
+
+      log_sampled = RedisQueuedLocks::Logging.should_log?(
+        log_sampling_enabled,
+        log_sample_this,
+        log_sampling_percent,
+        log_sampler
+      )
+      instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
+        instr_sampling_enabled,
+        instr_sample_this,
+        instr_sampling_percent,
+        instr_sampler
+      )
+
+      run_non_critical do
+        logger.debug do
+          "[redis_queued_locks.extend_lock_ttl] " \
+          "lock_key => '#{lock_key}' " \
+          "rw_mode => '#{read_write_mode}' " \
+          "all_read_locks => #{all_read_locks} " \
+          "ext_ttl => #{milliseconds} " \
+          "extended_locks_count => #{extended_locks_count} " \
+          "ext_time => #{ext_time} " \
+          "at => #{time_at}"
         end
+      end if log_sampled
+
+      run_non_critical do
+        instrumenter.notify('redis_queued_locks.extend_lock_ttl', {
+          lock_key: lock_key,
+          rw_mode: read_write_mode,
+          all_read_locks: all_read_locks,
+          ext_ttl: milliseconds,
+          extended_locks_count: extended_locks_count,
+          ext_time: ext_time,
+          at: time_at,
+          instrument: instrument
+        })
+      end if instr_sampled
+
+      result
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    private
 
+    # Extends the write lock, the read lock of the acquirer or all read locks of the lock.
+    #
+    # @param redis_client [RedisClient]
+    # @param lock_name [String]
+    # @param lock_key [String]
+    # @param milliseconds [Integer]
+    # @param read_write_mode [Symbol]
+    # @param all_read_locks [Boolean]
+    # @param acquirer_id [String]
+    # @param lock_index_enabled [Boolean]
+    # @return [Hash<Symbol,Boolean|Symbol|Hash<Symbol,Integer>>]
+    #
+    # @api private
+    # @since 1.21.0
+    # rubocop:disable Metrics/MethodLength
+    def fully_extend_lock_ttl(
+      redis_client,
+      lock_name,
+      lock_key,
+      milliseconds,
+      read_write_mode,
+      all_read_locks,
+      acquirer_id,
+      lock_index_enabled
+    )
+      if read_write_mode == :read
         # NOTE: (RW) all live read locks of the lock
         if all_read_locks
           return extend_all_read_locks_ttl(
@@ -131,8 +227,6 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     end
     # rubocop:enable Metrics/MethodLength
 
-    private
-
     # Extends the live read lock of the acquirer:
     #   - the read lock expiration (readers registry score), the registry TTL and the read lock
     #     data TTL are extended;
@@ -149,7 +243,7 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     #
     # @api private
     # @since 1.18.0
-    # @version 1.20.0
+    # @version 1.21.0
     # rubocop:disable Metrics/MethodLength
     def extend_read_lock_ttl(
       redis_client,
@@ -191,6 +285,14 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
             end
           end
         end
+      rescue RedisQueuedLocks::LockAcquirementIntermediateTimeoutError,
+             RedisQueuedLocks::TimedLockIntermediateTimeoutError,
+             ::Timeout::ExitException
+        # NOTE: (timeouts) an interrupted WATCH block (the internal timeouts and the user's
+        #   `Timeout.timeout` without an exception class): the closed connection drops the WATCH
+        #   state (redis-client sends `UNWATCH` only on `StandardError`);
+        rconn.close
+        raise
       end
 
       # NOTE:
@@ -223,7 +325,7 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     #
     # @api private
     # @since 1.18.0
-    # @version 1.20.0
+    # @version 1.21.0
     # rubocop:disable Metrics/MethodLength
     def extend_all_read_locks_ttl(
       redis_client,
@@ -278,6 +380,14 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
             end
           end
         end
+      rescue RedisQueuedLocks::LockAcquirementIntermediateTimeoutError,
+             RedisQueuedLocks::TimedLockIntermediateTimeoutError,
+             ::Timeout::ExitException
+        # NOTE: (timeouts) an interrupted WATCH block (the internal timeouts and the user's
+        #   `Timeout.timeout` without an exception class): the closed connection drops the WATCH
+        #   state (redis-client sends `UNWATCH` only on `StandardError`);
+        rconn.close
+        raise
       end
 
       # NOTE:

data/lib/redis_queued_locks/acquirer/is_locked.rb

@@ -2,7 +2,6 @@
 
 # @api private
 # @since 1.0.0
-# @version 1.18.0
 module RedisQueuedLocks::Acquirer::IsLocked
   class << self
     # @param redis_client [RedisClient]

data/lib/redis_queued_locks/acquirer/is_queued.rb

@@ -2,7 +2,6 @@
 
 # @api private
 # @since 1.0.0
-# @version 1.18.0
 module RedisQueuedLocks::Acquirer::IsQueued
   class << self
     # @param redis_client [RedisClient]

data/lib/redis_queued_locks/acquirer/keys.rb

@@ -32,8 +32,17 @@ module RedisQueuedLocks::Acquirer::Keys
     #
     # @api private
     # @since 1.0.0
-    # @version 1.20.0
+    # @version 1.21.0
     def keys(redis_client, scan_size:, 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)`);
+      if !scan_size.is_a?(::Integer) || scan_size <= 0
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`:scan_size` argument should be a positive Integer, got #{scan_size.inspect}."
+        )
+      end
+
       Set.new.tap do |keyset|
         # @type var keyset: Set[String]
         if lock_index_enabled

data/lib/redis_queued_locks/acquirer/lock_info.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.0.0
-# @version 1.20.0
+# @version 1.18.0
 module RedisQueuedLocks::Acquirer::LockInfo
   class << self
     # @param redis_client [RedisClient]
@@ -56,46 +56,38 @@ module RedisQueuedLocks::Acquirer::LockInfo
         pipeline.call('ZRANGE', lock_readers_key, '0', '-1', 'WITHSCORES')
       end
 
-      if result == nil
-        # NOTE:
-        #   - nil result means that during transaction invocation the lock is changed (CAS):
-        #     - lock is expired;
-        #     - lock is released;
-        #     - lock is expired + re-obtained;
-        nil
-      else
-        # NOTE: the result of MULTI-command is an array of results of each internal command
-        #   - result[0] (HGETALL) (Hash<String,String>)
-        #     => (will be mutated further with different value types)
-        #   - result[1] (PTTL) (Integer)
-        #     => (without any mutation, integer is atomic)
-        #   - result[2] (TIME) (Array<String>) (redis time)
-        #   - result[3] (ZRANGE) (Array<[String,Float]>) (read locks)
+      # NOTE: (pipeline layout) the replies of the pipeline commands (`pipelined` always returns
+      #   an array of the replies):
+      #   - result[0] (HGETALL) (Hash<String,String>)
+      #     => (will be mutated further with different value types)
+      #   - result[1] (PTTL) (Integer)
+      #     => (without any mutation, integer is atomic)
+      #   - result[2] (TIME) (Array<String>) (redis time)
+      #   - result[3] (ZRANGE) (Array<[String,Float]>) (read locks)
 
-        # rubocop:disable Layout/LineLength
-        # @type var result: [Hash[String,String|Float|Integer], Integer, Array[String], Array[[String, Float]]]
-        # rubocop:enable Layout/LineLength
-        hget_cmd_res = result[0]
-        pttl_cmd_res = result[1]
+      # rubocop:disable Layout/LineLength
+      # @type var result: [Hash[String,String|Float|Integer], Integer, Array[String], Array[[String, Float]]]
+      # rubocop:enable Layout/LineLength
+      hget_cmd_res = result[0]
+      pttl_cmd_res = result[1]
 
-        if hget_cmd_res == {} || pttl_cmd_res == -2 # NOTE: key does not exist
-          # NOTE: (RW) there is no write lock => check read locks
-          read_lock_info(redis_client, lock_name, lock_key, result[2], result[3])
-        else
-          hget_cmd_res.tap do |lock_data|
-            lock_data['lock_key'] = lock_key
-            lock_data['rw_mode'] = 'write'
-            lock_data['ts'] = Float(lock_data['ts'])
-            lock_data['ini_ttl'] = Integer(lock_data['ini_ttl'])
-            lock_data['rem_ttl'] = ((pttl_cmd_res == -1) ? Float::INFINITY : pttl_cmd_res)
-            lock_data['spc_cnt'] = Integer(lock_data['spc_cnt']) if lock_data['spc_cnt']
-            lock_data['l_spc_ts'] = Float(lock_data['l_spc_ts']) if lock_data['l_spc_ts']
-            lock_data['spc_ext_ttl'] = Integer(lock_data['spc_ext_ttl']) if lock_data['spc_ext_ttl']
-            lock_data['l_spc_ext_ini_ttl'] =
-              Integer(lock_data['l_spc_ext_ini_ttl']) if lock_data.key?('l_spc_ext_ini_ttl')
-            lock_data['l_spc_ext_ts'] =
-              Float(lock_data['l_spc_ext_ts']) if lock_data['l_spc_ext_ts']
-          end
+      if hget_cmd_res == {} || pttl_cmd_res == -2 # NOTE: key does not exist
+        # NOTE: (RW) there is no write lock => check read locks
+        read_lock_info(redis_client, lock_name, lock_key, result[2], result[3])
+      else
+        hget_cmd_res.tap do |lock_data|
+          lock_data['lock_key'] = lock_key
+          lock_data['rw_mode'] = 'write'
+          lock_data['ts'] = Float(lock_data['ts'])
+          lock_data['ini_ttl'] = Integer(lock_data['ini_ttl'])
+          lock_data['rem_ttl'] = ((pttl_cmd_res == -1) ? Float::INFINITY : pttl_cmd_res)
+          lock_data['spc_cnt'] = Integer(lock_data['spc_cnt']) if lock_data['spc_cnt']
+          lock_data['l_spc_ts'] = Float(lock_data['l_spc_ts']) if lock_data['l_spc_ts']
+          lock_data['spc_ext_ttl'] = Integer(lock_data['spc_ext_ttl']) if lock_data['spc_ext_ttl']
+          lock_data['l_spc_ext_ini_ttl'] =
+            Integer(lock_data['l_spc_ext_ini_ttl']) if lock_data.key?('l_spc_ext_ini_ttl')
+          lock_data['l_spc_ext_ts'] =
+            Float(lock_data['l_spc_ext_ts']) if lock_data['l_spc_ext_ts']
         end
       end
     end

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

@@ -3,6 +3,7 @@
 # NOTE: Lock Series PoC
 # @api private
 # @since 1.16.1
+# @version 1.18.0
 module RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor # steep:ignore
   class << self
     # NOTE: Lock Series PoC
@@ -32,7 +33,7 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor # steep:ignore
     # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
     # @api private
     # @since 1.16.1
-    # @version 1.18.0
+    # @version 1.21.0
     def lock_series_hold_and_release( # steep:ignore
       instrumenter,
       instr_sampled,
@@ -49,7 +50,7 @@ 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:
-      }) # rescue nil
+      }) rescue nil
     end
   end
 end

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

@@ -3,13 +3,14 @@
 # NOTE: Lock Series PoC
 # @api private
 # @since 1.16.1
+# @version 1.18.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`).
     # @api private
     # @since 1.16.0
-    # @version 1.18.0
+    # @version 1.21.0
     def start_lock_series_obtaining( # steep:ignore
       logger,
       log_sampled,
@@ -30,14 +31,14 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
         "hst_id => '#{host_id}' " \
         "acs_strat => '#{access_strategy}' " \
         "rw_mode => '#{rw_mode}'"
-      end # rescue nil
+      end rescue nil
     end
 
     # NOTE: Lock Series PoC
     # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
     # @api private
     # @since 1.16.0
-    # @version 1.18.0
+    # @version 1.21.0
     def lock_series_obtained( # steep:ignore
       logger,
       log_sampled,
@@ -60,7 +61,7 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
         "acs_strat => '#{access_strategy}' " \
         "rw_mode => '#{rw_mode}' " \
         "acq_time => #{acq_time} (ms)"
-      end # rescue nil
+      end rescue nil
     end
 
     # NOTE: Lock Series PoC

data/lib/redis_queued_locks/acquirer/lock_series_poc.rb

@@ -4,17 +4,18 @@
 # rubocop:disable all
 # @api private
 # @since 1.16.0
+# @version 1.20.0
 module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
   require_relative 'lock_series_poc/log_visitor'
   require_relative 'lock_series_poc/instr_visitor'
 
-  # @sine 1.16.0
+  # @since 1.16.0
   extend RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire
 
   class << self
     # @api private
     # @since 1.16.0
-    # @version 1.20.0
+    # @version 1.21.0
     def lock_series_poc( # steep:ignore
       redis,
       lock_names,
@@ -66,19 +67,22 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
         )
       end
 
+      # NOTE: Symbol keys are written to the lock data as Strings (the same check as in
+      #   RedisQueuedLocks::Acquirer::AcquireLock);
       if meta.is_a?(::Hash) && (meta.any? do |key, _value|
-        key == 'acq_id' ||
-        key == 'hst_id' ||
-        key == 'ts' ||
-        key == 'ini_ttl' ||
-        key == 'lock_key' ||
-        key == 'rem_ttl' ||
-        key == 'spc_ext_ttl' ||
-        key == 'spc_cnt' ||
-        key == 'l_spc_ext_ini_ttl' ||
-        key == 'l_spc_ext_ts' ||
-        key == 'l_spc_ts' ||
-        key == 'rw_mode'
+        meta_key = key.is_a?(::Symbol) ? key.name : key
+        meta_key == 'acq_id' ||
+        meta_key == 'hst_id' ||
+        meta_key == 'ts' ||
+        meta_key == 'ini_ttl' ||
+        meta_key == 'lock_key' ||
+        meta_key == 'rem_ttl' ||
+        meta_key == 'spc_ext_ttl' ||
+        meta_key == 'spc_cnt' ||
+        meta_key == 'l_spc_ext_ini_ttl' ||
+        meta_key == 'l_spc_ext_ts' ||
+        meta_key == 'l_spc_ts' ||
+        meta_key == 'rw_mode'
       end)
         raise(
           RedisQueuedLocks::ArgumentError,
@@ -88,6 +92,34 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
         )
       end
 
+      # NOTE: the series ttl is validated before the lock ttl calculation: each lock ttl of
+      #   the series includes the retry delay and jitter (a non-positive series ttl can produce
+      #   a positive lock ttl), the series ttl limits the `timed` block (the same check as in
+      #   RedisQueuedLocks::Acquirer::AcquireLock);
+      if !ttl.is_a?(::Integer) || ttl <= 0
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`:ttl` argument should be a positive Integer, got #{ttl.inspect}."
+        )
+      end
+
+      # NOTE: the retry delay and jitter are parts of the lock ttls of the series (validated before
+      #   the lock ttl calculation; other options are validated by
+      #   RedisQueuedLocks::Acquirer::AcquireLock on the first lock of the series, before any lock
+      #   is obtained);
+      if !retry_delay.is_a?(::Integer) || retry_delay < 0
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`:retry_delay` argument should be a non-negative Integer, got #{retry_delay.inspect}."
+        )
+      end
+      if !retry_jitter.is_a?(::Integer) || retry_jitter < 0
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`:retry_jitter` argument should be a non-negative Integer, got #{retry_jitter.inspect}."
+        )
+      end
+
       locks_count = lock_names.size
 
       lock_acquirement_operations = lock_names.each_with_index.map do |lock_name, position|
@@ -374,7 +406,7 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
     #
     # @api private
     # @since 1.18.0
-    # @version 1.20.0
+    # @version 1.21.0
     def release_write_lock_series(redis, lock_names, acquirer_id) # steep:ignore
       return if lock_names.empty?
 
@@ -397,6 +429,14 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
           # NOTE: `nil` => the transaction is aborted (a watched lock is changed) => retry
           break unless released.nil?
         end
+      rescue RedisQueuedLocks::LockAcquirementIntermediateTimeoutError,
+             RedisQueuedLocks::TimedLockIntermediateTimeoutError,
+             ::Timeout::ExitException
+        # NOTE: (timeouts) an interrupted WATCH block (the internal timeouts and the user's
+        #   `Timeout.timeout` without an exception class): the closed connection drops the WATCH
+        #   state (redis-client sends `UNWATCH` only on `StandardError`);
+        conn.close
+        raise
       end
     end
 

data/lib/redis_queued_locks/acquirer/locks.rb

@@ -25,8 +25,17 @@ module RedisQueuedLocks::Acquirer::Locks
     #
     # @api private
     # @since 1.0.0
-    # @version 1.20.0
+    # @version 1.21.0
     def locks(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)`);
+      if !scan_size.is_a?(::Integer) || scan_size <= 0
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`:scan_size` argument should be a positive Integer, got #{scan_size.inspect}."
+        )
+      end
+
       redis_client.with do |rconn|
         lock_keys =
           lock_index_enabled ? index_locks(rconn, scan_size) : scan_locks(rconn, scan_size)
@@ -153,7 +162,7 @@ module RedisQueuedLocks::Acquirer::Locks
     #
     # @api private
     # @since 1.0.0
-    # @version 1.20.0
+    # @version 1.21.0
     # rubocop:disable Metrics/MethodLength
     def extract_locks_info(redis_client, lock_keys, scan_size)
       Set.new.tap do |seeded_locks|
@@ -162,6 +171,13 @@ module RedisQueuedLocks::Acquirer::Locks
         # rubocop:enable Layout/LineLength
 
         lock_keys.each_slice(scan_size) do |lock_keys_batch|
+          # Step 0: lock names of the batch (once per lock: the readers registry keys and the read
+          #   lock data keys are built from them)
+          # @type var lock_names_batch: Array[String]
+          lock_names_batch = lock_keys_batch.map do |lock_key|
+            RedisQueuedLocks::Resource.lock_name_from_key(lock_key, :lock) #: String
+          end
+
           # Step 1: extract the state of the batch of locks in one round trip
           # NOTE: (pipeline layout) [0] TIME (read locks are checked in redis time), then
           #   `LOCK_STATE_REPLIES` replies per lock in the batch order (the replies of the lock
@@ -170,10 +186,9 @@ module RedisQueuedLocks::Acquirer::Locks
           # @type var batch_state: Array[untyped]
           batch_state = redis_client.pipelined do |pipeline|
             pipeline.call('TIME')
-            lock_keys_batch.each do |lock_key|
-              lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(
-                lock_key.delete_prefix('rql:lock:')
-              )
+            lock_keys_batch.each_with_index do |lock_key, index|
+              lock_readers_key =
+                RedisQueuedLocks::Resource.prepare_lock_readers(lock_names_batch[index])
               pipeline.call('HGETALL', lock_key)
               pipeline.call('PTTL', lock_key)
               pipeline.call('ZRANGE', lock_readers_key, '0', '-1', 'WITHSCORES')
@@ -199,12 +214,13 @@ module RedisQueuedLocks::Acquirer::Locks
           #   read lock data can be absent if it is dropped during the read lock life;
           # @type var read_locks_data: Array[Hash[String,String]]
           read_locks_data = redis_client.pipelined do |pipeline|
-            lock_keys_batch.each_with_index do |lock_key, index|
-              lock_name = lock_key.delete_prefix('rql:lock:')
+            lock_keys_batch.each_index do |index|
               live_read_locks[index]&.each do |(acquirer_id, _expiration)|
                 pipeline.call(
                   'HGETALL',
-                  RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+                  RedisQueuedLocks::Resource.prepare_read_lock_key(
+                    lock_names_batch[index], acquirer_id
+                  )
                 )
               end
             end
@@ -232,6 +248,7 @@ module RedisQueuedLocks::Acquirer::Locks
                 pttl_cmd_res = batch_state[replies_at + 1] # NOTE: PTTL result (integer)
 
                 hget_cmd_res.tap do |lock_data|
+                  lock_data['lock_key'] = lock_key
                   lock_data['rw_mode'] = 'write'
                   lock_data['ts'] = Float(lock_data['ts'])
                   lock_data['ini_ttl'] = Integer(lock_data['ini_ttl'])

data/lib/redis_queued_locks/acquirer/queue_info.rb

@@ -2,7 +2,6 @@
 
 # @api private
 # @since 1.0.0
-# @version 1.20.0
 module RedisQueuedLocks::Acquirer::QueueInfo
   class << self
     # Returns an information about the required lock queue by the lock name. The result

data/lib/redis_queued_locks/acquirer/queues.rb

@@ -15,8 +15,17 @@ module RedisQueuedLocks::Acquirer::Queues
     #
     # @api private
     # @since 1.0.0
-    # @version 1.20.0
+    # @version 1.21.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)`);
+      if !scan_size.is_a?(::Integer) || scan_size <= 0
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`:scan_size` argument should be a positive Integer, got #{scan_size.inspect}."
+        )
+      end
+
       redis_client.with do |rconn|
         lock_queues =
           lock_index_enabled ? index_queues(rconn, scan_size) : scan_queues(rconn, scan_size)