redis_queued_locks 1.19.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.18.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)
@@ -28,6 +35,8 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     #   (used for `:read` mode only, ignored for `:write` mode).
     # @param acquirer_id [String]
     #   The read lock acquirer (used for `:read` mode without `all_read_locks` only).
+    # @param lock_index_enabled [Boolean]
+    #   Increase the lock index score of the lock name by the extension (the enabled lock index).
     # @param logger [::Logger,#debug]
     # @param instrumenter [#notify]
     # @param instrument [NilClass,Any]
@@ -43,7 +52,7 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     #
     # @api private
     # @since 1.0.0
-    # @version 1.18.0
+    # @version 1.21.0
     # rubocop:disable Metrics/MethodLength
     def extend_lock_ttl(
       redis_client,
@@ -52,6 +61,7 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
       read_write_mode,
       all_read_locks,
       acquirer_id,
+      lock_index_enabled,
       logger,
       instrumenter,
       instrument,
@@ -72,31 +82,144 @@ 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(redis_client, lock_name, lock_key, milliseconds)
+          return extend_all_read_locks_ttl(
+            redis_client, lock_name, lock_key, milliseconds, lock_index_enabled
+          )
         end
 
         # NOTE: (RW) read lock of the concrete acquirer
-        return extend_read_lock_ttl(redis_client, lock_name, lock_key, acquirer_id, milliseconds)
+        return extend_read_lock_ttl(
+          redis_client, lock_name, lock_key, acquirer_id, milliseconds, lock_index_enabled
+        )
       end
 
-      # NOTE: EVAL signature -> <lua script>, (number of keys), *(keys), *(arguments)
-      result = redis_client.call('EVAL', EXTEND_LOCK_PTTL, 1, lock_key, milliseconds)
+      # NOTE:
+      #   - EVAL signature -> <lua script>, (number of keys), *(keys), *(arguments);
+      #   - (lock index) the enabled lock index: the lock index score is increased by the extension
+      #     in the same transaction (`ZADD XX INCR`: the upper bound of the lock lifetime stays
+      #     the upper bound, locks without the index entry (of older RQL versions) are not indexed
+      #     with a wrong score); a failed extension (no lock) increases the score of the lock name
+      #     too: the name just stays in the index a bit longer;
+      #   - the disabled lock index: one EVAL command (no transaction);
+      # @type var extended: Integer
+      extended =
+        if lock_index_enabled
+          # @type var result: [Integer, Float?]
+          result = redis_client.multi do |transact|
+            transact.call('EVAL', EXTEND_LOCK_PTTL, 1, lock_key, milliseconds)
+            transact.call(
+              'ZADD', RedisQueuedLocks::Resource::LOCK_INDEX_KEY,
+              'XX', 'INCR', milliseconds, lock_name
+            )
+          end
+          result[0]
+        else
+          redis_client.call('EVAL', EXTEND_LOCK_PTTL, 1, lock_key, milliseconds)
+        end
       # TODO: upload scripts to the redis
 
-      # @type var result: Integer
-      if result == 1
+      if extended == 1
         { ok: true, result: { extended_locks_count: 1 } }
       else
         { ok: false, result: :async_expire_or_no_lock }
@@ -104,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;
@@ -117,12 +238,21 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     # @param lock_key [String]
     # @param acquirer_id [String]
     # @param milliseconds [Integer]
+    # @param lock_index_enabled [Boolean]
     # @return [Hash<Symbol,Boolean|Symbol|Hash<Symbol,Integer>>]
     #
     # @api private
     # @since 1.18.0
+    # @version 1.21.0
     # rubocop:disable Metrics/MethodLength
-    def extend_read_lock_ttl(redis_client, lock_name, lock_key, acquirer_id, milliseconds)
+    def extend_read_lock_ttl(
+      redis_client,
+      lock_name,
+      lock_key,
+      acquirer_id,
+      milliseconds,
+      lock_index_enabled
+    )
       lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
       read_lock_key = RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
 
@@ -145,8 +275,24 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
             transact.call('PEXPIRE', lock_readers_key, extended_ttl, 'GT')
             transact.call('PEXPIRE', read_lock_key, extended_ttl, 'NX')
             transact.call('PEXPIRE', read_lock_key, extended_ttl, 'GT')
+            # NOTE: (lock index) the lock index score is increased by the extension
+            #   (the enabled lock index only; the last command: its reply is not read);
+            if lock_index_enabled
+              transact.call(
+                'ZADD', RedisQueuedLocks::Resource::LOCK_INDEX_KEY,
+                'XX', 'INCR', milliseconds, lock_name
+              )
+            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:
@@ -174,12 +320,20 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     # @param lock_name [String]
     # @param lock_key [String]
     # @param milliseconds [Integer]
+    # @param lock_index_enabled [Boolean]
     # @return [Hash<Symbol,Boolean|Symbol|Hash<Symbol,Integer>>]
     #
     # @api private
     # @since 1.18.0
+    # @version 1.21.0
     # rubocop:disable Metrics/MethodLength
-    def extend_all_read_locks_ttl(redis_client, lock_name, lock_key, milliseconds)
+    def extend_all_read_locks_ttl(
+      redis_client,
+      lock_name,
+      lock_key,
+      milliseconds,
+      lock_index_enabled
+    )
       lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
       extended_read_locks_count = 0
 
@@ -214,9 +368,26 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
             if extended_read_locks_count > 0
               transact.call('PEXPIRE', lock_readers_key, registry_ttl, 'NX')
               transact.call('PEXPIRE', lock_readers_key, registry_ttl, 'GT')
+              # NOTE: (lock index) the lock index score is increased by the extension
+              #   (each read lock is extended by the same milliseconds; the enabled lock index
+              #   only; the last command: its reply is not read);
+              if lock_index_enabled
+                transact.call(
+                  'ZADD', RedisQueuedLocks::Resource::LOCK_INDEX_KEY,
+                  'XX', 'INCR', milliseconds, lock_name
+                )
+              end
             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

@@ -2,25 +2,169 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.20.0
 module RedisQueuedLocks::Acquirer::Keys
+  # The number of replies of one lock name in the key state pipeline of a batch of lock names
+  # (`collect_lock_keys`): EXISTS (write lock), EXISTS (write lock queue), EXISTS (read lock
+  # queue), ZRANGE (readers registry).
+  #
+  # @return [Integer]
+  #
+  # @api private
+  # @since 1.20.0
+  KEY_STATE_REPLIES = 4
+
   class << self
+    # RQL keys of the locks:
+    #   - the disabled lock index: all the RQL keys (`RedisQueuedLocks::Resource::KEY_PATTERN`,
+    #     `rql:lock*`) found in one SCAN pass over the keyspace;
+    #   - the enabled lock index: all the existing keys of the locks of the lock index (write locks,
+    #     lock queues, readers registries, read lock queues, read lock data): one ZSCAN pass over
+    #     the lock names (`RedisQueuedLocks::Resource::LOCK_INDEX_KEY`, the keyspace is never
+    #     scanned), lock keys are derived from the lock names;
+    #
     # @param redis_client [RedisClient]
     # @option scan_size [Integer]
+    #   SCAN count (the disabled lock index) or ZSCAN count and the number of lock names in one
+    #   batch (the enabled lock index).
+    # @option lock_index_enabled [Boolean]
     # @return [Set<String>]
     #
     # @api private
     # @since 1.0.0
-    def keys(redis_client, scan_size:)
+    # @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]
-        redis_client.scan(
-          'MATCH',
-          RedisQueuedLocks::Resource::KEY_PATTERN,
-          count: scan_size
-        ) do |key|
-          keyset.add(key)
+        if lock_index_enabled
+          redis_client.with do |rconn|
+            each_lock_name_batch(rconn, scan_size) do |lock_names|
+              collect_lock_keys(rconn, lock_names, keyset)
+            end
+          end
+        else
+          redis_client.scan(
+            'MATCH',
+            RedisQueuedLocks::Resource::KEY_PATTERN,
+            count: scan_size
+          ) do |key|
+            keyset.add(key)
+          end
+        end
+      end
+    end
+
+    private
+
+    # (lock index) Adds the existing keys of the given batch of lock names to the key set
+    # (one round trip for the lock keys, one more for the read lock data when read locks exist).
+    #
+    # @param redis_client [RedisClient]
+    # @param lock_names [Array<String>]
+    # @param keyset [Set<String>]
+    # @return [void]
+    #
+    # @api private
+    # @since 1.20.0
+    # rubocop:disable Metrics/MethodLength
+    def collect_lock_keys(redis_client, lock_names, keyset)
+      # Step 1: the state of the lock keys of the batch
+      # NOTE: (pipeline layout) `KEY_STATE_REPLIES` replies per lock name in the batch order
+      #   (the replies of the lock name with the index N start at `N * KEY_STATE_REPLIES`):
+      #   EXISTS (write lock), EXISTS (write lock queue), EXISTS (read lock queue),
+      #   ZRANGE (readers registry: redis deletes empty sorted sets, so an empty result means
+      #   the registry does not exist);
+      # @type var key_state: Array[untyped]
+      key_state = redis_client.pipelined do |pipeline|
+        lock_names.each do |lock_name|
+          pipeline.call('EXISTS', RedisQueuedLocks::Resource.prepare_lock_key(lock_name))
+          pipeline.call('EXISTS', RedisQueuedLocks::Resource.prepare_lock_queue(lock_name))
+          pipeline.call('EXISTS', RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name))
+          pipeline.call(
+            'ZRANGE', RedisQueuedLocks::Resource.prepare_lock_readers(lock_name), '0', '-1'
+          )
         end
       end
+
+      # @type var read_lock_keys: Array[String]
+      read_lock_keys = []
+      lock_names.each_with_index do |lock_name, index|
+        replies_at = index * KEY_STATE_REPLIES
+        if key_state[replies_at] == 1
+          keyset.add(RedisQueuedLocks::Resource.prepare_lock_key(lock_name))
+        end
+        if key_state[replies_at + 1] == 1
+          keyset.add(RedisQueuedLocks::Resource.prepare_lock_queue(lock_name))
+        end
+        if key_state[replies_at + 2] == 1
+          keyset.add(RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name))
+        end
+        # @type var read_lock_acquirers: Array[String]
+        read_lock_acquirers = key_state[replies_at + 3]
+        next if read_lock_acquirers.empty?
+
+        keyset.add(RedisQueuedLocks::Resource.prepare_lock_readers(lock_name))
+        read_lock_acquirers.each do |acquirer_id|
+          read_lock_keys << RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+        end
+      end
+      return if read_lock_keys.empty?
+
+      # Step 2: (RW) read lock data of the readers registries (it can be absent: the data of an
+      #   expired read lock is expired before the registry cleanup)
+      # NOTE: (pipeline layout) one EXISTS reply per read lock data key
+      # @type var read_lock_keys_existence: Array[Integer]
+      read_lock_keys_existence = redis_client.pipelined do |pipeline|
+        read_lock_keys.each { |read_lock_key| pipeline.call('EXISTS', read_lock_key) }
+      end
+      read_lock_keys.each_with_index do |read_lock_key, index|
+        keyset.add(read_lock_key) if read_lock_keys_existence[index] == 1
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # 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.
+    #
+    # 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`);
+    #
+    # @param redis_client [RedisClient]
+    # @param scan_size [Integer] ZSCAN count and the number of lock names in one batch.
+    # @yield [lock_names]
+    # @yieldparam lock_names [Array<String>] The batch of lock names (reused between batches).
+    # @return [void]
+    #
+    # @api private
+    # @since 1.20.0
+    def each_lock_name_batch(redis_client, scan_size)
+      lock_index_time = RedisQueuedLocks::Resource.lock_index_time
+      # @type var lock_names: Array[String]
+      lock_names = []
+
+      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
+
+        lock_names << lock_name
+        next if lock_names.size < scan_size
+
+        yield(lock_names)
+        lock_names.clear
+      end
+
+      yield(lock_names) unless lock_names.empty?
     end
   end
 end

data/lib/redis_queued_locks/acquirer/lock_info.rb

@@ -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
@@ -117,6 +109,7 @@ module RedisQueuedLocks::Acquirer::LockInfo
     #
     # @api private
     # @since 1.18.0
+    # @version 1.20.0
     # rubocop:disable Metrics/MethodLength
     def read_lock_info(redis_client, lock_name, lock_key, redis_time, read_locks)
       now = RedisQueuedLocks::Resource.redis_time_ms(redis_time)
@@ -139,10 +132,15 @@ module RedisQueuedLocks::Acquirer::LockInfo
         rem_ttl = (expiration - now).ceil
         longest_rem_ttl = rem_ttl if rem_ttl > longest_rem_ttl
 
+        # NOTE: acquirer and host ids are not stored in the read lock data (both are derived from
+        #   the acquirer id): they are the first fields like in the write lock info (read lock data
+        #   of older versions contains them with the same values);
         # @type var reader: Hash[String,String|Float|Integer|nil]
-        reader = read_locks_data[index] || {}
-        reader['acq_id'] = acquirer_id
-        reader['hst_id'] ||= RedisQueuedLocks::Resource.host_identifier_from_acquirer(acquirer_id)
+        reader = {
+          'acq_id' => acquirer_id,
+          'hst_id' => RedisQueuedLocks::Resource.host_identifier_from_acquirer(acquirer_id)
+        }
+        read_locks_data[index]&.each { |field, value| reader[field] = value }
         reader['ts'] = Float(reader['ts']) if reader['ts']
         reader['ini_ttl'] = Integer(reader['ini_ttl']) if reader['ini_ttl']
         reader['rem_ttl'] = rem_ttl

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