redis_queued_locks 1.16.2 → 1.18.0

data/lib/redis_queued_locks/client.rb

@@ -2,7 +2,7 @@
 
 # @api public
 # @since 1.0.0
-# @version 1.16.0
+# @version 1.18.0
 # rubocop:disable Metrics/ClassLength
 class RedisQueuedLocks::Client
   # @return [RedisClient]
@@ -79,7 +79,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.9.0
-  def swarm_info(zombie_ttl: config['swarm.flush_zombies.zombie_ttl']) # steep:ignore
+  def swarm_info(zombie_ttl: config['swarm.flush_zombies.zombie_ttl'])
     swarm.swarm_info(zombie_ttl:)
   end
 
@@ -108,9 +108,9 @@ class RedisQueuedLocks::Client
   # @api public
   # @since 1.9.0
   def flush_zombies(
-    zombie_ttl: config['swarm.flush_zombies.zombie_ttl'], # steep:ignore
-    lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size'], # steep:ignore
-    queue_scan_size: config['swarm.flush_zombies.zombie_queue_scan_size'] # steep:ignore
+    zombie_ttl: config['swarm.flush_zombies.zombie_ttl'],
+    lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size'],
+    queue_scan_size: config['swarm.flush_zombies.zombie_queue_scan_size']
   )
     swarm.flush_zombies(zombie_ttl:, lock_scan_size:, queue_scan_size:)
   end
@@ -122,8 +122,8 @@ class RedisQueuedLocks::Client
   # @api public
   # @since 1.9.0
   def zombie_locks(
-    zombie_ttl: config['swarm.flush_zombies.zombie_ttl'], # steep:ignore
-    lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size'] # steep:ignore
+    zombie_ttl: config['swarm.flush_zombies.zombie_ttl'],
+    lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size']
   )
     swarm.zombie_locks(zombie_ttl:, lock_scan_size:)
   end
@@ -135,8 +135,8 @@ class RedisQueuedLocks::Client
   # @api ppublic
   # @since 1.9.0
   def zombie_acquirers(
-    zombie_ttl: config['swarm.flush_zombies.zombie_ttl'], # steep:ignore
-    lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size'] # steep:ignore
+    zombie_ttl: config['swarm.flush_zombies.zombie_ttl'],
+    lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size']
   )
     swarm.zombie_acquirers(zombie_ttl:, lock_scan_size:)
   end
@@ -146,7 +146,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.9.0
-  def zombie_hosts(zombie_ttl: config['swarm.flush_zombies.zombie_ttl']) # steep:ignore
+  def zombie_hosts(zombie_ttl: config['swarm.flush_zombies.zombie_ttl'])
     swarm.zombie_hosts(zombie_ttl:)
   end
 
@@ -159,9 +159,10 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.9.0
+  # @version 1.17.0
   def zombies_info(
-    zombie_ttl: config['swarm.flush_zombies.zombie_ttl'], # steep:ignore
-    lock_scan_size: config['swarm.flush_zombies.zombie_ttl'] # steep:ignore
+    zombie_ttl: config['swarm.flush_zombies.zombie_ttl'],
+    lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size']
   )
     swarm.zombies_info(zombie_ttl:, lock_scan_size:)
   end
@@ -206,7 +207,28 @@ class RedisQueuedLocks::Client
   #       (with timeouts, retry delays, retry limits, etc - in classic way :));
   #     - `:dead_locking` - fail with deadlock exception;
   # @option read_write_mode [Symbol]
-  #   - ?
+  #   - The lock mode (read/write lock semantics);
+  #   - `:write` mode is used by default;
+  #   - Supports:
+  #     - `:write` - exclusive lock: waits for the write lock and for all read locks;
+  #     - `:read` - shared lock: waits for the write lock only (read locks of different
+  #       acquirers do not block each other);
+  #   - `:queued` access strategy orders read and write lock requests in FIFO between modes
+  #     (read lock request waits for earlier write lock requests, write lock request waits for
+  #     earlier read and write lock requests) so writers are not starved by readers;
+  #   - `:random` access strategy ignores lock queues (a continuous flow of readers can starve
+  #     writers);
+  #   - read lock specifics:
+  #     - read lock is released (with a block of code) or expired (by `ttl`) independently
+  #       of other read locks; `#unlock` releases all read locks and the write lock;
+  #     - each read lock has its own data (acquirer, host, timestamp, ttl, `:meta`, reentrant
+  #       lock data) that is returned by `#lock_info` for each reader;
+  #   - same-process conflicts (`conflict_strategy`) work for both modes:
+  #     - read lock request under the obtained write lock (or read lock) works as a reentrant
+  #       lock of the obtained lock;
+  #     - write lock request under the obtained read lock (read-to-write lock upgrade) fails with
+  #       `RedisQueuedLocks::ConflictLockObtainError` for any conflict strategy except
+  #       `:wait_for_lock` (it waits for the read lock expiration);
   # @option access_strategy [Symbol]
   #   - The way in which the lock will be obtained;
   #   - By default it uses `:queued` strategy;
@@ -309,36 +331,36 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.13.0
+  # @version 1.18.0
   # rubocop:disable Metrics/MethodLength
   def lock(
     lock_name,
-    ttl: config['default_lock_ttl'], # steep:ignore
-    queue_ttl: config['default_queue_ttl'], # steep:ignore
-    timeout: config['try_to_lock_timeout'], # steep:ignore
-    timed: config['is_timed_by_default'], # steep:ignore
-    retry_count: config['retry_count'], # steep:ignore
-    retry_delay: config['retry_delay'], # steep:ignore
-    retry_jitter: config['retry_jitter'], # steep:ignore
+    ttl: config['default_lock_ttl'],
+    queue_ttl: config['default_queue_ttl'],
+    timeout: config['try_to_lock_timeout'],
+    timed: config['is_timed_by_default'],
+    retry_count: config['retry_count'],
+    retry_delay: config['retry_delay'],
+    retry_jitter: config['retry_jitter'],
     raise_errors: false,
     fail_fast: false,
-    conflict_strategy: config['default_conflict_strategy'], # steep:ignore
+    conflict_strategy: config['default_conflict_strategy'],
     read_write_mode: :write,
-    access_strategy: config['default_access_strategy'], # steep:ignore
+    access_strategy: config['default_access_strategy'],
     identity: uniq_identity,
     meta: nil,
-    detailed_acq_timeout_error: config['detailed_acq_timeout_error'], # steep:ignore
-    logger: config['logger'], # steep:ignore
-    log_lock_try: config['log_lock_try'], # steep:ignore
-    instrumenter: config['instrumenter'], # steep:ignore
+    detailed_acq_timeout_error: config['detailed_acq_timeout_error'],
+    logger: config['logger'],
+    log_lock_try: config['log_lock_try'],
+    instrumenter: config['instrumenter'],
     instrument: nil,
-    log_sampling_enabled: config['log_sampling_enabled'], # steep:ignore
-    log_sampling_percent: config['log_sampling_percent'], # steep:ignore
-    log_sampler: config['log_sampler'], # steep:ignore
+    log_sampling_enabled: config['log_sampling_enabled'],
+    log_sampling_percent: config['log_sampling_percent'],
+    log_sampler: config['log_sampler'],
     log_sample_this: false,
-    instr_sampling_enabled: config['instr_sampling_enabled'], # steep:ignore
-    instr_sampling_percent: config['instr_sampling_percent'], # steep:ignore
-    instr_sampler: config['instr_sampler'], # steep:ignore
+    instr_sampling_enabled: config['instr_sampling_enabled'],
+    instr_sampling_percent: config['instr_sampling_percent'],
+    instr_sampler: config['instr_sampler'],
     instr_sample_this: false,
     &block
   )
@@ -388,32 +410,32 @@ class RedisQueuedLocks::Client
   def lock_series( # steep:ignore
     *lock_names,
     detailed_result: false,
-    ttl: config['default_lock_ttl'], # steep:ignore
-    queue_ttl: config['default_queue_ttl'], # steep:ignore
-    timeout: config['try_to_lock_timeout'], # steep:ignore
-    timed: config['is_timed_by_default'], # steep:ignore
-    retry_count: config['retry_count'], # steep:ignore
-    retry_delay: config['retry_delay'], # steep:ignore
-    retry_jitter: config['retry_jitter'], # steep:ignore
+    ttl: config['default_lock_ttl'],
+    queue_ttl: config['default_queue_ttl'],
+    timeout: config['try_to_lock_timeout'],
+    timed: config['is_timed_by_default'],
+    retry_count: config['retry_count'],
+    retry_delay: config['retry_delay'],
+    retry_jitter: config['retry_jitter'],
     raise_errors: false,
     fail_fast: false,
-    conflict_strategy: config['default_conflict_strategy'], # steep:ignore
+    conflict_strategy: config['default_conflict_strategy'],
     read_write_mode: :write,
-    access_strategy: config['default_access_strategy'], # steep:ignore
+    access_strategy: config['default_access_strategy'],
     identity: uniq_identity,
     meta: nil,
-    detailed_acq_timeout_error: config['detailed_acq_timeout_error'], # steep:ignore
-    logger: config['logger'], # steep:ignore
-    log_lock_try: config['log_lock_try'], # steep:ignore
-    instrumenter: config['instrumenter'], # steep:ignore
+    detailed_acq_timeout_error: config['detailed_acq_timeout_error'],
+    logger: config['logger'],
+    log_lock_try: config['log_lock_try'],
+    instrumenter: config['instrumenter'],
     instrument: nil,
-    log_sampling_enabled: config['log_sampling_enabled'], # steep:ignore
-    log_sampling_percent: config['log_sampling_percent'], # steep:ignore
-    log_sampler: config['log_sampler'], # steep:ignore
+    log_sampling_enabled: config['log_sampling_enabled'],
+    log_sampling_percent: config['log_sampling_percent'],
+    log_sampler: config['log_sampler'],
     log_sample_this: false,
-    instr_sampling_enabled: config['instr_sampling_enabled'], # steep:ignore
-    instr_sampling_percent: config['instr_sampling_percent'], # steep:ignore
-    instr_sampler: config['instr_sampler'], # steep:ignore
+    instr_sampling_enabled: config['instr_sampling_enabled'],
+    instr_sampling_percent: config['instr_sampling_percent'],
+    instr_sampler: config['instr_sampler'],
     instr_sample_this: false,
     &block
   )
@@ -464,31 +486,31 @@ class RedisQueuedLocks::Client
   def lock_series!( # steep:ignore
     *lock_names,
     detailed_result: false,
-    ttl: config['default_lock_ttl'], # steep:ignore
-    queue_ttl: config['default_queue_ttl'], # steep:ignore
-    timeout: config['try_to_lock_timeout'], # steep:ignore
-    timed: config['is_timed_by_default'], # steep:ignore
-    retry_count: config['retry_count'], # steep:ignore
-    retry_delay: config['retry_delay'], # steep:ignore
-    retry_jitter: config['retry_jitter'], # steep:ignore
+    ttl: config['default_lock_ttl'],
+    queue_ttl: config['default_queue_ttl'],
+    timeout: config['try_to_lock_timeout'],
+    timed: config['is_timed_by_default'],
+    retry_count: config['retry_count'],
+    retry_delay: config['retry_delay'],
+    retry_jitter: config['retry_jitter'],
     fail_fast: false,
-    conflict_strategy: config['default_conflict_strategy'], # steep:ignore
+    conflict_strategy: config['default_conflict_strategy'],
     read_write_mode: :write,
-    access_strategy: config['default_access_strategy'], # steep:ignore
+    access_strategy: config['default_access_strategy'],
     identity: uniq_identity,
     meta: nil,
-    detailed_acq_timeout_error: config['detailed_acq_timeout_error'], # steep:ignore
-    logger: config['logger'], # steep:ignore
-    log_lock_try: config['log_lock_try'], # steep:ignore
-    instrumenter: config['instrumenter'], # steep:ignore
+    detailed_acq_timeout_error: config['detailed_acq_timeout_error'],
+    logger: config['logger'],
+    log_lock_try: config['log_lock_try'],
+    instrumenter: config['instrumenter'],
     instrument: nil,
-    log_sampling_enabled: config['log_sampling_enabled'], # steep:ignore
-    log_sampling_percent: config['log_sampling_percent'], # steep:ignore
-    log_sampler: config['log_sampler'], # steep:ignore
+    log_sampling_enabled: config['log_sampling_enabled'],
+    log_sampling_percent: config['log_sampling_percent'],
+    log_sampler: config['log_sampler'],
     log_sample_this: false,
-    instr_sampling_enabled: config['instr_sampling_enabled'], # steep:ignore
-    instr_sampling_percent: config['instr_sampling_percent'], # steep:ignore
-    instr_sampler: config['instr_sampler'], # steep:ignore
+    instr_sampling_enabled: config['instr_sampling_enabled'],
+    instr_sampling_percent: config['instr_sampling_percent'],
+    instr_sampler: config['instr_sampler'],
     instr_sample_this: false,
     &block
   )
@@ -530,34 +552,34 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.13.0
+  # @version 1.18.0
   def lock!(
     lock_name,
-    ttl: config['default_lock_ttl'], # steep:ignore
-    queue_ttl: config['default_queue_ttl'], # steep:ignore
-    timeout: config['try_to_lock_timeout'], # steep:ignore
-    timed: config['is_timed_by_default'], # steep:ignore
-    retry_count: config['retry_count'], # steep:ignore
-    retry_delay: config['retry_delay'], # steep:ignore
-    retry_jitter: config['retry_jitter'], # steep:ignore
+    ttl: config['default_lock_ttl'],
+    queue_ttl: config['default_queue_ttl'],
+    timeout: config['try_to_lock_timeout'],
+    timed: config['is_timed_by_default'],
+    retry_count: config['retry_count'],
+    retry_delay: config['retry_delay'],
+    retry_jitter: config['retry_jitter'],
     fail_fast: false,
-    conflict_strategy: config['default_conflict_strategy'], # steep:ignore
+    conflict_strategy: config['default_conflict_strategy'],
     read_write_mode: :write,
-    access_strategy: config['default_access_strategy'], # steep:ignore
+    access_strategy: config['default_access_strategy'],
     identity: uniq_identity,
-    instrumenter: config['instrumenter'], # steep:ignore
+    instrumenter: config['instrumenter'],
     meta: nil,
-    detailed_acq_timeout_error: config['detailed_acq_timeout_error'], # steep:ignore
-    logger: config['logger'], # steep:ignore
-    log_lock_try: config['log_lock_try'], # steep:ignore
+    detailed_acq_timeout_error: config['detailed_acq_timeout_error'],
+    logger: config['logger'],
+    log_lock_try: config['log_lock_try'],
     instrument: nil,
-    log_sampling_enabled: config['log_sampling_enabled'], # steep:ignore
-    log_sampling_percent: config['log_sampling_percent'], # steep:ignore
-    log_sampler: config['log_sampler'], # steep:ignore
+    log_sampling_enabled: config['log_sampling_enabled'],
+    log_sampling_percent: config['log_sampling_percent'],
+    log_sampler: config['log_sampler'],
     log_sample_this: false,
-    instr_sampling_enabled: config['instr_sampling_enabled'], # steep:ignore
-    instr_sampling_percent: config['instr_sampling_percent'], # steep:ignore
-    instr_sampler: config['instr_sampler'], # steep:ignore
+    instr_sampling_enabled: config['instr_sampling_enabled'],
+    instr_sampling_percent: config['instr_sampling_percent'],
+    instr_sampler: config['instr_sampler'],
     instr_sample_this: false,
     &block
   )
@@ -595,6 +617,8 @@ class RedisQueuedLocks::Client
   end
   # rubocop:enable Metrics/MethodLength
 
+  # Releases the lock: the write lock, all read locks and all lock requests (write and read).
+  #
   # @param lock_name [String] The lock name that should be released.
   # @option logger [::Logger,#debug]
   # @option instrumenter [#notify]
@@ -614,26 +638,26 @@ class RedisQueuedLocks::Client
   #       rel_time: Integer, # <millisecnds>
   #       rel_key: String, # lock key
   #       rel_queue: String, # lock queue
-  #       queue_res: Symbol, # :released or :nothing_to_release
-  #       lock_res: Symbol # :released or :nothing_to_release
+  #       queue_res: Symbol, # :released or :nothing_to_release (write or read lock requests)
+  #       lock_res: Symbol # :released or :nothing_to_release (write lock or read locks)
   #     }
   #   }
   #
   # @api public
   # @since 1.0.0
-  # @version 1.6.0
+  # @version 1.18.0
   def unlock(
     lock_name,
-    logger: config['logger'], # steep:ignore
-    instrumenter: config['instrumenter'], # steep:ignore
+    logger: config['logger'],
+    instrumenter: config['instrumenter'],
     instrument: nil,
-    log_sampling_enabled: config['log_sampling_enabled'], # steep:ignore
-    log_sampling_percent: config['log_sampling_percent'], # steep:ignore
-    log_sampler: config['log_sampler'], # steep:ignore
+    log_sampling_enabled: config['log_sampling_enabled'],
+    log_sampling_percent: config['log_sampling_percent'],
+    log_sampler: config['log_sampler'],
     log_sample_this: false,
-    instr_sampling_enabled: config['instr_sampling_enabled'], # steep:ignore
-    instr_sampling_percent: config['instr_sampling_percent'], # steep:ignore
-    instr_sampler: config['instr_sampler'], # steep:ignore
+    instr_sampling_enabled: config['instr_sampling_enabled'],
+    instr_sampling_percent: config['instr_sampling_percent'],
+    instr_sampler: config['instr_sampler'],
     instr_sample_this: false
   )
     RedisQueuedLocks::Acquirer::ReleaseLock.release_lock(
@@ -653,38 +677,112 @@ class RedisQueuedLocks::Client
   end
   alias_method :release_lock, :unlock
 
+  # Releases the read lock of the current acquirer only: other read locks, the write lock and
+  # lock requests are not affected (`#unlock` releases the lock entirely). It is suitable for
+  # read locks obtained without a block of code.
+  #
+  # @param lock_name [String] The lock name whose read lock should be released.
+  # @option identity [String]
+  #   Unique acquirer identity (the same as for `#lock`) that is used to calculate the current
+  #   acquirer id (see `#current_acquirer_id`).
+  # @option logger [::Logger,#debug]
+  # @option instrumenter [#notify]
+  # @option instrument [NilClass,Any]
+  # @option log_sampling_enabled [Boolean]
+  # @option log_sampling_percent [Integer]
+  # @option log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
+  # @option log_sample_this [Boolean]
+  # @option instr_sampling_enabled [Boolean]
+  # @option instr_sampling_percent [Integer]
+  # @option instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
+  # @option instr_sample_this [Boolean]
+  # @return [Hash<Symbol,Any>]
+  #   Format: {
+  #     ok: true,
+  #     result: {
+  #       rel_time: Numeric, # <milliseconds>
+  #       rel_key: String, # lock key
+  #       rel_acq_id: String, # read lock acquirer
+  #       lock_res: Symbol # :released or :nothing_to_release
+  #     }
+  #   }
+  #
+  # @api public
+  # @since 1.18.0
+  def unlock_read(
+    lock_name,
+    identity: uniq_identity,
+    logger: config['logger'],
+    instrumenter: config['instrumenter'],
+    instrument: nil,
+    log_sampling_enabled: config['log_sampling_enabled'],
+    log_sampling_percent: config['log_sampling_percent'],
+    log_sampler: config['log_sampler'],
+    log_sample_this: false,
+    instr_sampling_enabled: config['instr_sampling_enabled'],
+    instr_sampling_percent: config['instr_sampling_percent'],
+    instr_sampler: config['instr_sampler'],
+    instr_sample_this: false
+  )
+    RedisQueuedLocks::Acquirer::ReleaseReadLock.release_read_lock(
+      redis_client,
+      lock_name,
+      current_acquirer_id(identity:),
+      instrumenter,
+      logger,
+      instrument,
+      log_sampling_enabled,
+      log_sampling_percent,
+      log_sampler,
+      log_sample_this,
+      instr_sampling_enabled,
+      instr_sampling_percent,
+      instr_sampler,
+      instr_sample_this
+    )
+  end
+  alias_method :release_read_lock, :unlock_read
+
   # @param lock_name [String]
-  # @return [Boolean]
+  # @return [Boolean] Is the lock obtained by a writer or by any reader.
   #
   # @api public
   # @since 1.0.0
+  # @version 1.18.0
   def locked?(lock_name)
     RedisQueuedLocks::Acquirer::IsLocked.locked?(redis_client, lock_name)
   end
 
   # @param lock_name [String]
-  # @return [Boolean]
+  # @return [Boolean] Are there any write or read lock requests.
   #
   # @api public
   # @since 1.0.0
+  # @version 1.18.0
   def queued?(lock_name)
     RedisQueuedLocks::Acquirer::IsQueued.queued?(redis_client, lock_name)
   end
 
   # @param lock_name [String]
-  # @return [Hash<String,String|Numeric>,NilClass]
+  # @return [Hash<String,String|Numeric|Array<Hash<String,String|Numeric>>>,NilClass]
+  #   - write lock info or read locks info (when there is no write lock);
+  #   - see `RedisQueuedLocks::Acquirer::LockInfo.lock_info` for details;
   #
   # @api public
   # @since 1.0.0
+  # @version 1.18.0
   def lock_info(lock_name)
     RedisQueuedLocks::Acquirer::LockInfo.lock_info(redis_client, lock_name)
   end
 
   # @param lock_name [String]
   # @return [Hash<String|Array<Hash<String,String|Numeric>>,NilClass]
+  #   - write lock requests and read lock requests (when they exist);
+  #   - see `RedisQueuedLocks::Acquirer::QueueInfo.queue_info` for details;
   #
   # @api public
   # @since 1.0.0
+  # @version 1.18.0
   def queue_info(lock_name)
     RedisQueuedLocks::Acquirer::QueueInfo.queue_info(redis_client, lock_name)
   end
@@ -782,6 +880,16 @@ class RedisQueuedLocks::Client
   #
   # @param lock_name [String]
   # @param milliseconds [Integer] How many milliseconds should be added.
+  # @option read_write_mode [Symbol]
+  #   - `:write` (default) - extends the write lock (the method description above);
+  #   - `:read` - extends the read lock of the current acquirer only (an expired read lock or
+  #     a read lock replaced by a writer is not extended);
+  # @option all_read_locks [Boolean]
+  #   `:read` mode only (ignored for `:write` mode): extends all live read locks of the lock
+  #   instead of the read lock of the current acquirer (`false` by default).
+  # @option identity [String]
+  #   Unique acquirer identity (the same as for `#lock`) that is used to calculate the current
+  #   acquirer id for `:read` mode (see `#current_acquirer_id`).
   # @option logger [::Logger,#debug]
   # @option instrumenter [#notify] See `config['instrumenter']` docs for details.
   # @option instrument [NilClass,Any]
@@ -793,32 +901,40 @@ class RedisQueuedLocks::Client
   # @option instr_sampling_percent [Integer]
   # @option instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
   # @option instr_sample_this [Boolean]
-  # @return [Hash<Symbol,Boolean|Symbol>]
-  #   - { ok: true, result: :ttl_extended }
+  # @return [Hash<Symbol,Boolean|Symbol|Hash<Symbol,Integer>>]
+  #   - { ok: true, result: { extended_locks_count: Integer } } - the number of extended locks:
+  #     `1` for the write lock and for the read lock of the current acquirer,
+  #     the number of extended read locks for `all_read_locks: true`;
   #   - { ok: false, result: :async_expire_or_no_lock }
   #
   # @api public
   # @since 1.0.0
-  # @version 1.6.0
+  # @version 1.18.0
   def extend_lock_ttl(
     lock_name,
     milliseconds,
-    logger: config['logger'], # steep:ignore
-    instrumenter: config['instrumenter'], # steep:ignore
+    read_write_mode: :write,
+    all_read_locks: false,
+    identity: uniq_identity,
+    logger: config['logger'],
+    instrumenter: config['instrumenter'],
     instrument: nil,
-    log_sampling_enabled: config['log_sampling_enabled'], # steep:ignore
-    log_sampling_percent: config['log_sampling_percent'], # steep:ignore
-    log_sampler: config['log_sampler'], # steep:ignore
+    log_sampling_enabled: config['log_sampling_enabled'],
+    log_sampling_percent: config['log_sampling_percent'],
+    log_sampler: config['log_sampler'],
     log_sample_this: false,
-    instr_sampling_enabled: config['instr_sampling_enabled'], # steep:ignore
-    instr_sampling_percent: config['instr_sampling_percent'], # steep:ignore
-    instr_sampler: config['instr_sampler'], # steep:ignore
+    instr_sampling_enabled: config['instr_sampling_enabled'],
+    instr_sampling_percent: config['instr_sampling_percent'],
+    instr_sampler: config['instr_sampler'],
     instr_sample_this: false
   )
     RedisQueuedLocks::Acquirer::ExtendLockTTL.extend_lock_ttl(
       redis_client,
       lock_name,
       milliseconds,
+      read_write_mode,
+      all_read_locks,
+      current_acquirer_id(identity:),
       logger,
       instrumenter,
       instrument,
@@ -857,17 +973,17 @@ class RedisQueuedLocks::Client
   # @since 1.0.0
   # @version 1.6.0
   def clear_locks(
-    batch_size: config['lock_release_batch_size'], # steep:ignore
-    logger: config['logger'], # steep:ignore
-    instrumenter: config['instrumenter'], # steep:ignore
+    batch_size: config['lock_release_batch_size'],
+    logger: config['logger'],
+    instrumenter: config['instrumenter'],
     instrument: nil,
-    log_sampling_enabled: config['log_sampling_enabled'], # steep:ignore
-    log_sampling_percent: config['log_sampling_percent'], # steep:ignore
-    log_sampler: config['log_sampler'], # steep:ignore
+    log_sampling_enabled: config['log_sampling_enabled'],
+    log_sampling_percent: config['log_sampling_percent'],
+    log_sampler: config['log_sampler'],
     log_sample_this: false,
-    instr_sampling_enabled: config['instr_sampling_enabled'], # steep:ignore
-    instr_sampling_percent: config['instr_sampling_percent'], # steep:ignore
-    instr_sampler: config['instr_sampler'], # steep:ignore
+    instr_sampling_enabled: config['instr_sampling_enabled'],
+    instr_sampling_percent: config['instr_sampling_percent'],
+    instr_sampler: config['instr_sampler'],
     instr_sample_this: false
   )
     RedisQueuedLocks::Acquirer::ReleaseAllLocks.release_all_locks(
@@ -927,7 +1043,7 @@ class RedisQueuedLocks::Client
   # @example Release locks of a different host/acquirer:
   #   client.clear_locks_of(
   #     host_id: "rql:hst:62681/2016/2032/b30ec5e4bea10512",
-  #     acquirer_id: "ral:acq:62681/2016/2024/2032/b30ec5e4bea10512"
+  #     acquirer_id: "rql:acq:62681/2016/2024/2032/b30ec5e4bea10512"
   #   )
   #
   # @see #clear_current_locks
@@ -944,18 +1060,18 @@ class RedisQueuedLocks::Client
   def clear_locks_of(
     host_id:,
     acquirer_id:,
-    lock_scan_size: config['clear_locks_of__lock_scan_size'], # steep:ignore
+    lock_scan_size: config['clear_locks_of__lock_scan_size'],
     queue_scan_size: config['clear_locks_of__queue_scan_size'], # steep:ingore
-    logger: config['logger'], # steep:ignore
-    instrumenter: config['instrumenter'], # steep:ignore
+    logger: config['logger'],
+    instrumenter: config['instrumenter'],
     instrument: nil,
-    log_sampling_enabled: config['log_sampling_enabled'], # steep:ignore
-    log_sampling_percent: config['log_sampling_percent'], # steep:ignore
-    log_sampler: config['log_sampler'], # steep:ignore
+    log_sampling_enabled: config['log_sampling_enabled'],
+    log_sampling_percent: config['log_sampling_percent'],
+    log_sampler: config['log_sampler'],
     log_sample_this: false,
-    instr_sampling_enabled: config['instr_sampling_enabled'], # steep:ignore
-    instr_sampling_percent: config['instr_sampling_percent'], # steep:ignore
-    instr_sampler: config['instr_sampler'], # steep:ignore
+    instr_sampling_enabled: config['instr_sampling_enabled'],
+    instr_sampling_percent: config['instr_sampling_percent'],
+    instr_sampler: config['instr_sampler'],
     instr_sample_this: false
   )
     RedisQueuedLocks::Acquirer::ReleaseLocksOf.release_locks_of(
@@ -1002,18 +1118,18 @@ class RedisQueuedLocks::Client
   # @api public
   # @since 1.14.0
   def clear_current_locks(
-    lock_scan_size: config['clear_locks_of__lock_scan_size'], # steep:ignore
+    lock_scan_size: config['clear_locks_of__lock_scan_size'],
     queue_scan_size: config['clear_locks_of__queue_scan_size'], # steep:ingore
-    logger: config['logger'], # steep:ignore
-    instrumenter: config['instrumenter'], # steep:ignore
+    logger: config['logger'],
+    instrumenter: config['instrumenter'],
     instrument: nil,
-    log_sampling_enabled: config['log_sampling_enabled'], # steep:ignore
-    log_sampling_percent: config['log_sampling_percent'], # steep:ignore
-    log_sampler: config['log_sampler'], # steep:ignore
+    log_sampling_enabled: config['log_sampling_enabled'],
+    log_sampling_percent: config['log_sampling_percent'],
+    log_sampler: config['log_sampler'],
     log_sample_this: false,
-    instr_sampling_enabled: config['instr_sampling_enabled'], # steep:ignore
-    instr_sampling_percent: config['instr_sampling_percent'], # steep:ignore
-    instr_sampler: config['instr_sampler'], # steep:ignore
+    instr_sampling_enabled: config['instr_sampling_enabled'],
+    instr_sampling_percent: config['instr_sampling_percent'],
+    instr_sampler: config['instr_sampler'],
     instr_sample_this: false
   )
     clear_locks_of(
@@ -1055,7 +1171,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  def locks(scan_size: config['key_extraction_batch_size'], with_info: false) # steep:ignore
+  def locks(scan_size: config['key_extraction_batch_size'], with_info: false)
     RedisQueuedLocks::Acquirer::Locks.locks(redis_client, scan_size:, with_info:)
   end
 
@@ -1086,7 +1202,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  def queues(scan_size: config['key_extraction_batch_size'], with_info: false) # steep:ignore
+  def queues(scan_size: config['key_extraction_batch_size'], with_info: false)
     RedisQueuedLocks::Acquirer::Queues.queues(redis_client, scan_size:, with_info:)
   end
 
@@ -1097,7 +1213,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  def queues_info(scan_size: config['key_extraction_batch_size']) # steep:ignore
+  def queues_info(scan_size: config['key_extraction_batch_size'])
     queues(scan_size:, with_info: true)
   end
 
@@ -1106,7 +1222,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  def keys(scan_size: config['key_extraction_batch_size']) # steep:ignore
+  def keys(scan_size: config['key_extraction_batch_size'])
     RedisQueuedLocks::Acquirer::Keys.keys(redis_client, scan_size:)
   end
 
@@ -1135,18 +1251,18 @@ class RedisQueuedLocks::Client
   # @since 1.0.0
   # @version 1.6.0
   def clear_dead_requests(
-    dead_ttl: config['dead_request_ttl'], # steep:ignore
-    scan_size: config['lock_release_batch_size'], # steep:ignore
-    logger: config['logger'], # steep:ignore
-    instrumenter: config['instrumenter'], # steep:ignore
+    dead_ttl: config['dead_request_ttl'],
+    scan_size: config['lock_release_batch_size'],
+    logger: config['logger'],
+    instrumenter: config['instrumenter'],
     instrument: nil,
-    log_sampling_enabled: config['log_sampling_enabled'], # steep:ignore
-    log_sampling_percent: config['log_sampling_percent'], # steep:ignore
-    log_sampler: config['log_sampler'], # steep:ignore
+    log_sampling_enabled: config['log_sampling_enabled'],
+    log_sampling_percent: config['log_sampling_percent'],
+    log_sampler: config['log_sampler'],
     log_sample_this: false,
-    instr_sampling_enabled: config['instr_sampling_enabled'], # steep:ignore
-    instr_sampling_percent: config['instr_sampling_percent'], # steep:ignore
-    instr_sampler: config['instr_sampler'], # steep:ignore
+    instr_sampling_enabled: config['instr_sampling_enabled'],
+    instr_sampling_percent: config['instr_sampling_percent'],
+    instr_sampler: config['instr_sampler'],
     instr_sample_this: false
   )
     RedisQueuedLocks::Acquirer::ClearDeadRequests.clear_dead_requests(