redis_queued_locks 1.16.2 → 1.18.0

data/lib/redis_queued_locks/acquirer/extend_lock_ttl.rb

@@ -2,6 +2,8 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
+# rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Acquirer::ExtendLockTTL
   # @return [String]
   #
@@ -12,10 +14,20 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     return redis.call("PEXPIRE", KEYS[1], new_lock_pttl);
   LUA_SCRIPT
 
+  # rubocop:disable Metrics/ClassLength
   class << self
     # @param redis_client [RedisClient]
     # @param lock_name [String]
     # @param milliseconds [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)
+    #     or all live read locks of the lock (see `all_read_locks`);
+    # @param all_read_locks [Boolean]
+    #   Extend all live read locks of the lock instead of the read lock of the given acquirer
+    #   (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 logger [::Logger,#debug]
     # @param instrumenter [#notify]
     # @param instrument [NilClass,Any]
@@ -27,15 +39,19 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     # @param instr_sampling_percent [Integer]
     # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
     # @param instr_sample_this [Boolean]
-    # @return [Hash<Symbol,Boolean|Symbol>]
+    # @return [Hash<Symbol,Boolean|Symbol|Hash<Symbol,Integer>>]
     #
     # @api private
     # @since 1.0.0
-    # @version 1.6.0
+    # @version 1.18.0
+    # rubocop:disable Metrics/MethodLength
     def extend_lock_ttl(
       redis_client,
       lock_name,
       milliseconds,
+      read_write_mode,
+      all_read_locks,
+      acquirer_id,
       logger,
       instrumenter,
       instrument,
@@ -48,18 +64,181 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
       instr_sampler,
       instr_sample_this
     )
+      if read_write_mode != :read && read_write_mode != :write
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`:read_write_mode` argument should be `:read` or `:write`, " \
+          "got #{read_write_mode.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}."
+          )
+        end
+
+        # 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)
+        end
+
+        # NOTE: (RW) read lock of the concrete acquirer
+        return extend_read_lock_ttl(redis_client, lock_name, lock_key, acquirer_id, milliseconds)
+      end
+
       # NOTE: EVAL signature -> <lua script>, (number of keys), *(keys), *(arguments)
       result = redis_client.call('EVAL', EXTEND_LOCK_PTTL, 1, lock_key, milliseconds)
       # TODO: upload scripts to the redis
 
       # @type var result: Integer
       if result == 1
-        { ok: true, result: :ttl_extended }
+        { ok: true, result: { extended_locks_count: 1 } }
+      else
+        { ok: false, result: :async_expire_or_no_lock }
+      end
+    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;
+    #   - the write lock key is watched: an expired read lock can be already replaced by a writer,
+    #     so the expired (or replaced) read lock is never "revived";
+    #
+    # @param redis_client [RedisClient]
+    # @param lock_name [String]
+    # @param lock_key [String]
+    # @param acquirer_id [String]
+    # @param milliseconds [Integer]
+    # @return [Hash<Symbol,Boolean|Symbol|Hash<Symbol,Integer>>]
+    #
+    # @api private
+    # @since 1.18.0
+    # rubocop:disable Metrics/MethodLength
+    def extend_read_lock_ttl(redis_client, lock_name, lock_key, acquirer_id, milliseconds)
+      lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
+      read_lock_key = RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+
+      result = redis_client.with do |rconn|
+        rconn.multi(watch: [lock_key]) do |transact|
+          # @type var lock_state: [Integer, Array[String], Float?]
+          lock_state = rconn.pipelined do |pipeline|
+            pipeline.call('EXISTS', lock_key)
+            pipeline.call('TIME')
+            pipeline.call('ZSCORE', lock_readers_key, acquirer_id)
+          end
+          redis_time = RedisQueuedLocks::Resource.redis_time_ms(lock_state[1])
+          read_lock_expiration = lock_state[2].to_f
+
+          # NOTE: no write lock and the read lock of the acquirer is alive
+          if lock_state[0] == 0 && read_lock_expiration > redis_time
+            extended_ttl = (read_lock_expiration + milliseconds - redis_time).ceil
+            transact.call('ZADD', lock_readers_key, 'XX', 'INCR', milliseconds, acquirer_id)
+            transact.call('PEXPIRE', lock_readers_key, extended_ttl, 'NX')
+            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')
+          end
+        end
+      end
+
+      # NOTE:
+      #   - [] => there is no live read lock of the acquirer (nothing to extend);
+      #   - nil => the write lock is changed during the extension (the read lock can be expired);
+      #   - result[0] => the new read lock expiration (nil if the read lock is removed);
+      if result.is_a?(::Array) && !result.empty? && result[0] != nil
+        { ok: true, result: { extended_locks_count: 1 } }
+      else
+        { ok: false, result: :async_expire_or_no_lock }
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Extends all live read locks of the lock (the same rules as for `extend_read_lock_ttl`):
+    #   - each live read lock expiration (readers registry score) and its read lock data TTL are
+    #     extended by the given milliseconds; the registry TTL is extended to the longest read lock;
+    #   - expired read locks are not extended ("revived");
+    #   - the write lock key is watched (a writer can replace the expired read locks), the registry
+    #     is not watched: concurrent read lock acquirements/releases do not abort the extension
+    #     (read locks obtained after the registry snapshot are not extended, read locks released
+    #     after it are not revived cuz of `ZADD XX`);
+    #
+    # @param redis_client [RedisClient]
+    # @param lock_name [String]
+    # @param lock_key [String]
+    # @param milliseconds [Integer]
+    # @return [Hash<Symbol,Boolean|Symbol|Hash<Symbol,Integer>>]
+    #
+    # @api private
+    # @since 1.18.0
+    # rubocop:disable Metrics/MethodLength
+    def extend_all_read_locks_ttl(redis_client, lock_name, lock_key, milliseconds)
+      lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
+      extended_read_locks_count = 0
+
+      result = redis_client.with do |rconn|
+        rconn.multi(watch: [lock_key]) do |transact|
+          # @type var lock_state: [Integer, Array[String], Array[[String, Float]]]
+          lock_state = rconn.pipelined do |pipeline|
+            pipeline.call('EXISTS', lock_key)
+            pipeline.call('TIME')
+            pipeline.call('ZRANGE', lock_readers_key, '0', '-1', 'WITHSCORES')
+          end
+          redis_time = RedisQueuedLocks::Resource.redis_time_ms(lock_state[1])
+
+          # NOTE: no write lock => extend all live read locks
+          if lock_state[0] == 0
+            registry_ttl = 0
+
+            lock_state[2].each do |(acquirer_id, read_lock_expiration)|
+              next unless read_lock_expiration > redis_time
+
+              read_lock_key =
+                RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+              extended_ttl = (read_lock_expiration + milliseconds - redis_time).ceil
+              registry_ttl = extended_ttl if extended_ttl > registry_ttl
+              extended_read_locks_count += 1
+
+              transact.call('ZADD', lock_readers_key, 'XX', 'INCR', milliseconds, acquirer_id)
+              transact.call('PEXPIRE', read_lock_key, extended_ttl, 'NX')
+              transact.call('PEXPIRE', read_lock_key, extended_ttl, 'GT')
+            end
+
+            if extended_read_locks_count > 0
+              transact.call('PEXPIRE', lock_readers_key, registry_ttl, 'NX')
+              transact.call('PEXPIRE', lock_readers_key, registry_ttl, 'GT')
+            end
+          end
+        end
+      end
+
+      # NOTE:
+      #   - [] => there are no live read locks (nothing to extend);
+      #   - nil => the write lock is changed during the extension (read locks can be expired);
+      #   - result[index * 3] => the new read lock expiration of each extended read lock
+      #     (nil if the read lock is released during the extension => it is not counted);
+      extended_locks_count =
+        if result.is_a?(::Array)
+          extended_read_locks_count.times.count { |index| result[index * 3] != nil }
+        else
+          0
+        end
+
+      if extended_locks_count > 0
+        { ok: true, result: { extended_locks_count: } }
       else
         { ok: false, result: :async_expire_or_no_lock }
       end
     end
+    # rubocop:enable Metrics/MethodLength
   end
+  # rubocop:enable Metrics/ClassLength
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/redis_queued_locks/acquirer/is_locked.rb

@@ -2,17 +2,34 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
 module RedisQueuedLocks::Acquirer::IsLocked
   class << self
     # @param redis_client [RedisClient]
     # @param lock_name [String]
-    # @return [Boolean]
+    # @return [Boolean] Is the lock obtained by a writer or by any reader (live read lock).
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
     def locked?(redis_client, lock_name)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
-      redis_client.call('EXISTS', lock_key) == 1
+      lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
+
+      # @type var result: [Integer, Array[String], Array[[String, Float]]]
+      result = redis_client.pipelined do |pipeline|
+        pipeline.call('EXISTS', lock_key)
+        pipeline.call('TIME')
+        pipeline.call('ZRANGE', lock_readers_key, '-1', '-1', 'WITHSCORES')
+      end
+
+      # NOTE: write lock
+      return true if result[0] == 1
+
+      # NOTE: (RW) read lock (expired read locks can live in the readers registry till the cleanup)
+      longest_read_lock = result[2].first
+      longest_read_lock != nil &&
+        longest_read_lock[1] > RedisQueuedLocks::Resource.redis_time_ms(result[1])
     end
   end
 end

data/lib/redis_queued_locks/acquirer/is_queued.rb

@@ -2,17 +2,21 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
 module RedisQueuedLocks::Acquirer::IsQueued
   class << self
     # @param redis_client [RedisClient]
     # @param lock_name [String]
-    # @return [Boolean]
+    # @return [Boolean] Are there any write or read lock requests.
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
     def queued?(redis_client, lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
-      redis_client.call('EXISTS', lock_key_queue) == 1
+      read_lock_key_queue = RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name)
+      # NOTE: EXISTS returns the number of existing keys
+      redis_client.call('EXISTS', lock_key_queue, read_lock_key_queue) > 0
     end
   end
 end

data/lib/redis_queued_locks/acquirer/lock_info.rb

@@ -2,14 +2,16 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
 module RedisQueuedLocks::Acquirer::LockInfo
   class << self
     # @param redis_client [RedisClient]
     # @param lock_name [String]
-    # @return [Hash<String,String|Numeric>,NilClass]
-    #   - `nil` is returned when lock key does not exist or expired;
-    #   - result format: {
+    # @return [Hash<String,String|Numeric|Array<Hash<String,String|Numeric>>>,NilClass]
+    #   - `nil` is returned when lock key does not exist or expired (and there are no read locks);
+    #   - result format (write lock): {
     #     'lock_key' => "rql:lock:your_lockname", # acquired lock key
+    #     'rw_mode' => 'write', # lock mode
     #     'acq_id' => "rql:acq:123/456/789/987/uniqstring", # lock acquirer identifier
     #     'hst_id' => "rql:hst:123/456/987/uniqstring", # lock host identifier
     #     'ts' => 123456789.2649841, # <locked at> time stamp (epoch, seconds.microseconds)
@@ -22,17 +24,36 @@ module RedisQueuedLocks::Acquirer::LockInfo
     #     'l_spc_ext_ini_ttl' => 5000, # (milliseconds) the last ttl of reentrant lock
     #     'l_spc_ext_ts' => 123456.789 # (epoch) <extendable reentrant lock obtained at> timestamp
     #   }
+    #   - result format (read locks, when there is no write lock): {
+    #     'lock_key' => "rql:lock:your_lockname", # lock key
+    #     'rw_mode' => 'read', # lock mode
+    #     'rem_ttl' => 123456789, # remaining ttl of the longest read lock (milliseconds)
+    #     'readers' => [ # live read locks
+    #       {
+    #         'acq_id' => "rql:acq:123/456/789/987/uniqstring", # read lock acquirer identifier
+    #         'hst_id' => "rql:hst:123/456/987/uniqstring", # read lock host identifier
+    #         'ts' => 123456789.2649841, # <locked at> time stamp (epoch, seconds.microseconds)
+    #         'ini_ttl' => 123456789, # initial read lock ttl (milliseconds)
+    #         'rem_ttl' => 123456789, # remaining read lock ttl (milliseconds)
+    #         <custom metadata (`meta`) and additional keys for reentrant locks (see above)>
+    #       },
+    #       ...
+    #     ]
+    #   }
     #
     # @api private
     # @since 1.0.0
-    # @version 1.9.0
+    # @version 1.18.0
     # rubocop:disable Metrics/MethodLength
     def lock_info(redis_client, lock_name)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
+      lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
 
       result = redis_client.pipelined do |pipeline|
         pipeline.call('HGETALL', lock_key)
         pipeline.call('PTTL', lock_key)
+        pipeline.call('TIME')
+        pipeline.call('ZRANGE', lock_readers_key, '0', '-1', 'WITHSCORES')
       end
 
       if result == nil
@@ -48,16 +69,22 @@ module RedisQueuedLocks::Acquirer::LockInfo
         #     => (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)
 
-        # @type var result: [Hash[String,String|Float|Integer],Integer]
+        # 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
-          nil
+          # 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)
@@ -73,5 +100,68 @@ module RedisQueuedLocks::Acquirer::LockInfo
       end
     end
     # rubocop:enable Metrics/MethodLength
+
+    private
+
+    # Formats live read locks of the lock (expired read locks are ignored).
+    #
+    # @param redis_client [RedisClient]
+    # @param lock_name [String]
+    # @param lock_key [String]
+    # @param redis_time [Array<String>] Result of the redis `TIME` command.
+    # @param read_locks [Array<Array<String,Float>>] Readers registry (acquirer id, expiration).
+    # @return [Hash<String,String|Numeric|Array<Hash<String,String|Numeric>>>,NilClass]
+    #   - `nil` is returned when there are no live read locks;
+    #   - each reader has the same data as the write lock (acq_id, hst_id, ts, ini_ttl, rem_ttl,
+    #     meta, reentrant lock data);
+    #
+    # @api private
+    # @since 1.18.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)
+      live_read_locks = read_locks.select { |(_acquirer_id, expiration)| expiration > now }
+      return nil if live_read_locks.empty?
+
+      # NOTE: read lock data (it 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|
+        live_read_locks.each do |(acquirer_id, _expiration)|
+          pipeline.call(
+            'HGETALL',
+            RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+          )
+        end
+      end
+
+      longest_rem_ttl = 0
+      readers = live_read_locks.each_with_index.map do |(acquirer_id, expiration), index|
+        rem_ttl = (expiration - now).ceil
+        longest_rem_ttl = rem_ttl if rem_ttl > longest_rem_ttl
+
+        # @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['ts'] = Float(reader['ts']) if reader['ts']
+        reader['ini_ttl'] = Integer(reader['ini_ttl']) if reader['ini_ttl']
+        reader['rem_ttl'] = rem_ttl
+        reader['spc_cnt'] = Integer(reader['spc_cnt']) if reader['spc_cnt']
+        reader['l_spc_ts'] = Float(reader['l_spc_ts']) if reader['l_spc_ts']
+        reader['spc_ext_ttl'] = Integer(reader['spc_ext_ttl']) if reader['spc_ext_ttl']
+        reader['l_spc_ext_ini_ttl'] =
+          Integer(reader['l_spc_ext_ini_ttl']) if reader['l_spc_ext_ini_ttl']
+        reader['l_spc_ext_ts'] = Float(reader['l_spc_ext_ts']) if reader['l_spc_ext_ts']
+        reader
+      end
+
+      {
+        'lock_key' => lock_key,
+        'rw_mode' => 'read',
+        'rem_ttl' => longest_rem_ttl,
+        'readers' => readers
+      }
+    end
+    # rubocop:enable Metrics/MethodLength
   end
 end

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

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
 # NOTE: Lock Series PoC
-# steep:ignore
 # @api private
 # @since 1.16.1
 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`).
     # @api private
     # @since 1.16.1
+    # @version 1.18.0
     def lock_series_obtained( # steep:ignore
       instrumenter,
       instr_sampled,
       lock_keys,
+      rw_mode,
       ttl,
       acq_id,
       hst_id,
@@ -22,17 +24,20 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor # steep:ignore
     )
       return unless instr_sampled
       instrumenter.notify('redis_queued_locks.lock_series_obtained', {
-        lock_keys:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
+        lock_keys:, rw_mode:, 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`).
     # @api private
     # @since 1.16.1
+    # @version 1.18.0
     def lock_series_hold_and_release( # steep:ignore
       instrumenter,
       instr_sampled,
       lock_keys,
+      rw_mode,
       ttl,
       acq_id,
       hst_id,
@@ -43,9 +48,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor # steep:ignore
     )
       return unless instr_sampled
       instrumenter.notify('redis_queued_locks.lock_series_hold_and_release', {
-        lock_keys:, hold_time:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
+        lock_keys:, rw_mode:, hold_time:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
       }) # rescue nil
     end
   end
 end
-# steep:ignore

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

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
 
 # NOTE: Lock Series PoC
-# steep:ignore
 # @api private
 # @since 1.16.1
 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
     def start_lock_series_obtaining( # steep:ignore
       logger,
       log_sampled,
@@ -16,23 +17,27 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
       queue_ttl,
       acquirer_id,
       host_id,
-      access_strategy
+      access_strategy,
+      rw_mode
     )
       return unless log_sampled
 
       logger.debug do
         "[redis_queued_locks.start_lock_series_obtaining] " \
-        "lock_keys => '#{lock_keys.inspect}'" \
+        "lock_keys => '#{lock_keys.inspect}' " \
         "queue_ttl => #{queue_ttl} " \
         "acq_id => '#{acquirer_id}' " \
         "hst_id => '#{host_id}' " \
-        "acs_strat => '#{access_strategy}'"
+        "acs_strat => '#{access_strategy}' " \
+        "rw_mode => '#{rw_mode}'"
       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
     def lock_series_obtained( # steep:ignore
       logger,
       log_sampled,
@@ -41,7 +46,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
       acquirer_id,
       host_id,
       acq_time,
-      access_strategy
+      access_strategy,
+      rw_mode
     )
       return unless log_sampled
 
@@ -52,13 +58,16 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
         "acq_id => '#{acquirer_id}' " \
         "hst_id => '#{host_id}' " \
         "acs_strat => '#{access_strategy}' " \
+        "rw_mode => '#{rw_mode}' " \
         "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`).
     # @api private
     # @since 1.16.0
+    # @version 1.18.0
     def expire_lock_series( # steep:ignore
       logger,
       log_sampled,
@@ -66,7 +75,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
       queue_ttl,
       acquirer_id,
       host_id,
-      access_strategy
+      access_strategy,
+      rw_mode
     )
       return unless log_sampled
 
@@ -76,7 +86,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
         "queue_ttl => #{queue_ttl} " \
         "acq_id => '#{acquirer_id}' " \
         "hst_id => '#{host_id}' " \
-        "acs_strat => '#{access_strategy}'"
+        "acs_strat => '#{access_strategy}' " \
+        "rw_mode => '#{rw_mode}'"
       end rescue nil
     end
   end