redis_queued_locks 1.19.0 → 1.20.0

data/lib/redis_queued_locks/swarm/zombie_info.rb

@@ -2,11 +2,16 @@
 
 # @api private
 # @since 1.9.0
+# @version 1.20.0
+# rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Swarm::ZombieInfo
+  # rubocop:disable Metrics/ClassLength
   class << self
     # @param redis_client [RedisClient]
     # @param zombie_ttl [Integer]
     # @param lock_scan_size [Integer]
+    # @param lock_index_enabled [Boolean]
+    #   Find zombie locks via the lock index instead of the keyspace SCAN.
     # @return [Hash<Symbol,Set<String>>]
     #   Format: {
     #     zombie_hosts: <Set<String>>,
@@ -16,22 +21,25 @@ module RedisQueuedLocks::Swarm::ZombieInfo
     #
     # @api private
     # @since 1.9.0
-    def zombies_info(redis_client, zombie_ttl, lock_scan_size)
+    # @version 1.20.0
+    def zombies_info(redis_client, zombie_ttl, lock_scan_size, lock_index_enabled)
       redis_client.with do |rconn|
-        extract_all(rconn, zombie_ttl, lock_scan_size)
+        extract_all(rconn, zombie_ttl, lock_scan_size, lock_index_enabled)
       end
     end
 
     # @param redis_client [RedisClient]
     # @param zombie_ttl [Integer]
     # @param lock_scan_size [Integer]
+    # @param lock_index_enabled [Boolean]
     # @return [Set<String>]
     #
     # @api private
     # @since 1.9.0
-    def zombie_locks(redis_client, zombie_ttl, lock_scan_size)
+    # @version 1.20.0
+    def zombie_locks(redis_client, zombie_ttl, lock_scan_size, lock_index_enabled)
       redis_client.with do |rconn|
-        extract_zombie_locks(rconn, zombie_ttl, lock_scan_size)
+        extract_zombie_locks(rconn, zombie_ttl, lock_scan_size, lock_index_enabled)
       end
     end
 
@@ -50,13 +58,15 @@ module RedisQueuedLocks::Swarm::ZombieInfo
     # @param redis_client [RedisClient]
     # @param zombie_ttl [Integer]
     # @param lock_scan_size [Integer]
+    # @param lock_index_enabled [Boolean]
     # @return [Set<String>]
     #
     # @api private
     # @since 1.9.0
-    def zombie_acquirers(redis_client, zombie_ttl, lock_scan_size)
+    # @version 1.20.0
+    def zombie_acquirers(redis_client, zombie_ttl, lock_scan_size, lock_index_enabled)
       redis_client.with do |rconn|
-        extract_zombie_acquirers(rconn, zombie_ttl, lock_scan_size)
+        extract_zombie_acquirers(rconn, zombie_ttl, lock_scan_size, lock_index_enabled)
       end
     end
 
@@ -79,23 +89,20 @@ module RedisQueuedLocks::Swarm::ZombieInfo
     # @param rconn [RedisClient] redis connection obtained via `#with` from RedisClient instance;
     # @param zombie_ttl [Integer]
     # @param lock_scan_size [Integer]
+    # @param lock_index_enabled [Boolean]
     # @return [Set<String>]
     #
     # @api private
     # @since 1.9.0
-    # @version 1.18.0
-    def extract_zombie_locks(rconn, zombie_ttl, lock_scan_size)
+    # @version 1.20.0
+    def extract_zombie_locks(rconn, zombie_ttl, lock_scan_size, lock_index_enabled)
       zombie_hosts = extract_zombie_hosts(rconn, zombie_ttl)
-      zombie_locks = Set.new
-      rconn.scan(
-        'MATCH', RedisQueuedLocks::Resource::LOCK_PATTERN, count: lock_scan_size
-      ) do |lock_key|
-        _acquirer_id, host_id = rconn.call('HMGET', lock_key, 'acq_id', 'hst_id')
-        zombie_locks << lock_key if zombie_hosts.include?(host_id)
-      end
-      # NOTE: (RW) readers registries with zombie read locks
-      each_zombie_read_lock(rconn, zombie_hosts, lock_scan_size) do |lock_readers_key, _acquirer_id|
-        zombie_locks << lock_readers_key
+      zombie_locks = Set.new #: Set[String]
+      # NOTE: (RW) readers registries with zombie read locks are zombie locks too
+      each_zombie_lock(
+        rconn, zombie_hosts, lock_scan_size, lock_index_enabled
+      ) do |lock_key, _acquirer_id|
+        zombie_locks << lock_key
       end
       zombie_locks
     end
@@ -103,22 +110,19 @@ module RedisQueuedLocks::Swarm::ZombieInfo
     # @param rconn [RedisClient] redis connection obtained via `#with` from RedisClient instance;
     # @param zombie_ttl [Integer]
     # @param lock_scan_size [Integer]
+    # @param lock_index_enabled [Boolean]
     # @return [Set<String>]
     #
     # @api private
     # @since 1.9.0
-    # @version 1.18.0
-    def extract_zombie_acquirers(rconn, zombie_ttl, lock_scan_size)
+    # @version 1.20.0
+    def extract_zombie_acquirers(rconn, zombie_ttl, lock_scan_size, lock_index_enabled)
       zombie_hosts = extract_zombie_hosts(rconn, zombie_ttl)
-      zombie_acquirers = Set.new
-      rconn.scan(
-        'MATCH', RedisQueuedLocks::Resource::LOCK_PATTERN, count: lock_scan_size
-      ) do |lock_key|
-        acquirer_id, host_id = rconn.call('HMGET', lock_key, 'acq_id', 'hst_id')
-        zombie_acquirers << acquirer_id if zombie_hosts.include?(host_id)
-      end
-      # NOTE: (RW) zombie read lock acquirers
-      each_zombie_read_lock(rconn, zombie_hosts, lock_scan_size) do |_lock_readers_key, acquirer_id|
+      zombie_acquirers = Set.new #: Set[String]
+      # NOTE: (RW) zombie read lock acquirers are zombie acquirers too
+      each_zombie_lock(
+        rconn, zombie_hosts, lock_scan_size, lock_index_enabled
+      ) do |_lock_key, acquirer_id|
         zombie_acquirers << acquirer_id
       end
       zombie_acquirers
@@ -127,6 +131,7 @@ module RedisQueuedLocks::Swarm::ZombieInfo
     # @param rconn [RedisClient] redis connection obtained via `#with` from RedisClient instance;
     # @param zombie_ttl [Integer]
     # @param lock_scan_size [Integer]
+    # @param lock_index_enabled [Boolean]
     # @return [Hash<Symbol,<Set<String>>]
     #   Format: {
     #     zombie_hosts: <Set<String>>,
@@ -136,34 +141,172 @@ module RedisQueuedLocks::Swarm::ZombieInfo
     #
     # @api private
     # @since 1.9.0
-    # @version 1.18.0
-    def extract_all(rconn, zombie_ttl, lock_scan_size)
+    # @version 1.20.0
+    def extract_all(rconn, zombie_ttl, lock_scan_size, lock_index_enabled)
       zombie_hosts = extract_zombie_hosts(rconn, zombie_ttl)
-      zombie_locks = Set.new
-      zombie_acquirers = Set.new
+      zombie_locks = Set.new #: Set[String]
+      zombie_acquirers = Set.new #: Set[String]
+      # NOTE: (RW) zombie read locks are reported by their readers registries
+      each_zombie_lock(
+        rconn, zombie_hosts, lock_scan_size, lock_index_enabled
+      ) do |lock_key, acquirer_id|
+        zombie_acquirers << acquirer_id
+        zombie_locks << lock_key
+      end
+      { zombie_hosts:, zombie_acquirers:, zombie_locks: }
+    end
+
+    # Iterates over the locks of zombie hosts in one pass (the keyspace SCAN or the lock index
+    # ZSCAN, see `each_keyspace_zombie_lock` and `each_lock_index_zombie_lock`). Nothing is scanned
+    # when there are no zombie hosts.
+    #
+    # @param rconn [RedisClient] redis connection obtained via `#with` from RedisClient instance;
+    # @param zombie_hosts [Set<String>]
+    # @param lock_scan_size [Integer]
+    # @param lock_index_enabled [Boolean]
+    # @yield [lock_key, acquirer_id]
+    # @yieldparam lock_key [String] Zombie write lock or readers registry with a zombie read lock.
+    # @yieldparam acquirer_id [String] Zombie lock acquirer.
+    # @return [void]
+    #
+    # @api private
+    # @since 1.20.0
+    def each_zombie_lock(rconn, zombie_hosts, lock_scan_size, lock_index_enabled, &block)
+      return if zombie_hosts.empty?
+
+      if lock_index_enabled
+        each_lock_index_zombie_lock(rconn, zombie_hosts, lock_scan_size, &block)
+      else
+        each_keyspace_zombie_lock(rconn, zombie_hosts, lock_scan_size, &block)
+      end
+    end
+
+    # (keyspace) Iterates over the locks of zombie hosts in one SCAN pass over the RQL keys
+    # (`KEY_PATTERN`, the disabled lock index): write locks and readers registries are processed
+    # in batches of `lock_scan_size` keys with one round trip per batch (batches are collected
+    # across SCAN pages).
+    #
+    # @param rconn [RedisClient] redis connection obtained via `#with` from RedisClient instance;
+    # @param zombie_hosts [Set<String>]
+    # @param lock_scan_size [Integer]
+    # @yield [lock_key, acquirer_id]
+    # @yieldparam lock_key [String] Zombie write lock or readers registry with a zombie read lock.
+    # @yieldparam acquirer_id [String] Zombie lock acquirer.
+    # @return [void]
+    #
+    # @api private
+    # @since 1.20.0
+    def each_keyspace_zombie_lock(rconn, zombie_hosts, lock_scan_size, &block)
+      # @type var lock_keys: Array[String]
+      lock_keys = []
+      # @type var lock_readers_keys: Array[String]
+      lock_readers_keys = []
+
       rconn.scan(
-        'MATCH', RedisQueuedLocks::Resource::LOCK_PATTERN, count: lock_scan_size
-      ) do |lock_key|
-        acquirer_id, host_id = rconn.call('HMGET', lock_key, 'acq_id', 'hst_id')
-        if zombie_hosts.include?(host_id)
-          zombie_acquirers << acquirer_id
-          zombie_locks << lock_key
+        'MATCH', RedisQueuedLocks::Resource::KEY_PATTERN, count: lock_scan_size
+      ) do |key|
+        case RedisQueuedLocks::Resource.lock_key_family(key)
+        when :lock
+          lock_keys << key
+          next if lock_keys.size < lock_scan_size
+
+          each_zombie_write_lock(rconn, lock_keys, zombie_hosts, &block)
+          lock_keys.clear
+        when :lock_readers
+          lock_readers_keys << key
+          next if lock_readers_keys.size < lock_scan_size
+
+          each_zombie_read_lock(rconn, lock_readers_keys, zombie_hosts, &block)
+          lock_readers_keys.clear
         end
       end
-      # NOTE: (RW) zombie read locks
-      each_zombie_read_lock(rconn, zombie_hosts, lock_scan_size) do |lock_readers_key, acquirer_id|
-        zombie_acquirers << acquirer_id
-        zombie_locks << lock_readers_key
+
+      each_zombie_write_lock(rconn, lock_keys, zombie_hosts, &block) unless lock_keys.empty?
+      unless lock_readers_keys.empty?
+        each_zombie_read_lock(rconn, lock_readers_keys, zombie_hosts, &block)
       end
-      { zombie_hosts:, zombie_acquirers:, zombie_locks: }
     end
 
-    # Iterates over read locks of zombie hosts
-    # (read locks store acquirer ids only: the host is a part of the acquirer id).
+    # (lock index) Iterates over the locks of zombie hosts in one ZSCAN pass over the lock index
+    # (`LOCK_INDEX_KEY`: lock names, the enabled lock index; lock keys are derived from the lock
+    # names, the full keyspace is never scanned): write locks and readers registries are processed
+    # in batches of `lock_scan_size` locks with one round trip per batch and per key family
+    # (batches are collected across ZSCAN pages). Expired lock names of the index are skipped
+    # (all their keys are expired).
     #
     # @param rconn [RedisClient] redis connection obtained via `#with` from RedisClient instance;
     # @param zombie_hosts [Set<String>]
     # @param lock_scan_size [Integer]
+    # @yield [lock_key, acquirer_id]
+    # @yieldparam lock_key [String] Zombie write lock or readers registry with a zombie read lock.
+    # @yieldparam acquirer_id [String] Zombie lock acquirer.
+    # @return [void]
+    #
+    # @api private
+    # @since 1.20.0
+    def each_lock_index_zombie_lock(rconn, zombie_hosts, lock_scan_size, &block)
+      # @type var lock_keys: Array[String]
+      lock_keys = []
+      # @type var lock_readers_keys: Array[String]
+      lock_readers_keys = []
+      lock_index_time = RedisQueuedLocks::Resource.lock_index_time
+
+      rconn.zscan(
+        RedisQueuedLocks::Resource::LOCK_INDEX_KEY, count: lock_scan_size
+      ) do |lock_name, lock_index_score|
+        # NOTE: the expired lock name (not dropped from the index yet): its keys are expired
+        next if lock_index_score.to_f < lock_index_time
+
+        lock_keys << RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
+        lock_readers_keys << RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
+        next if lock_keys.size < lock_scan_size
+
+        each_zombie_write_lock(rconn, lock_keys, zombie_hosts, &block)
+        each_zombie_read_lock(rconn, lock_readers_keys, zombie_hosts, &block)
+        lock_keys.clear
+        lock_readers_keys.clear
+      end
+
+      return if lock_keys.empty?
+
+      each_zombie_write_lock(rconn, lock_keys, zombie_hosts, &block)
+      each_zombie_read_lock(rconn, lock_readers_keys, zombie_hosts, &block)
+    end
+
+    # Iterates over the write locks of zombie hosts in the given batch of write locks
+    # (one round trip).
+    #
+    # @param rconn [RedisClient] redis connection obtained via `#with` from RedisClient instance;
+    # @param lock_keys [Array<String>]
+    # @param zombie_hosts [Set<String>]
+    # @yield [lock_key, acquirer_id]
+    # @yieldparam lock_key [String] Zombie write lock.
+    # @yieldparam acquirer_id [String] Zombie write lock acquirer.
+    # @return [void]
+    #
+    # @api private
+    # @since 1.20.0
+    def each_zombie_write_lock(rconn, lock_keys, zombie_hosts)
+      # NOTE: (pipeline layout) one reply (acquirer and host) per lock in the batch order
+      # @type var lock_owners: Array[[String?, String?]]
+      lock_owners = rconn.pipelined do |pipeline|
+        lock_keys.each { |lock_key| pipeline.call('HMGET', lock_key, 'acq_id', 'hst_id') }
+      end
+
+      lock_keys.each_with_index do |lock_key, index|
+        acquirer_id, host_id = lock_owners[index]
+        next unless acquirer_id && host_id && zombie_hosts.include?(host_id)
+
+        yield(lock_key, acquirer_id)
+      end
+    end
+
+    # Iterates over read locks of zombie hosts in the given batch of readers registries
+    # (one round trip; read locks store acquirer ids only: the host is a part of the acquirer id).
+    #
+    # @param rconn [RedisClient] redis connection obtained via `#with` from RedisClient instance;
+    # @param lock_readers_keys [Array<String>]
+    # @param zombie_hosts [Set<String>]
     # @yield [lock_readers_key, acquirer_id]
     # @yieldparam lock_readers_key [String] Readers registry with a zombie read lock.
     # @yieldparam acquirer_id [String] Zombie read lock acquirer.
@@ -171,17 +314,24 @@ module RedisQueuedLocks::Swarm::ZombieInfo
     #
     # @api private
     # @since 1.18.0
-    def each_zombie_read_lock(rconn, zombie_hosts, lock_scan_size)
-      rconn.scan(
-        'MATCH', RedisQueuedLocks::Resource::LOCK_READERS_PATTERN, count: lock_scan_size
-      ) do |lock_readers_key|
-        # @type var read_lock_acquirers: Array[String]
-        read_lock_acquirers = rconn.call('ZRANGE', lock_readers_key, '0', '-1')
-        read_lock_acquirers.each do |acquirer_id|
+    # @version 1.20.0
+    def each_zombie_read_lock(rconn, lock_readers_keys, zombie_hosts)
+      # NOTE: (pipeline layout) one reply (read lock acquirers) per registry in the batch order
+      # @type var read_lock_acquirers: Array[Array[String]]
+      read_lock_acquirers = rconn.pipelined do |pipeline|
+        lock_readers_keys.each do |lock_readers_key|
+          pipeline.call('ZRANGE', lock_readers_key, '0', '-1')
+        end
+      end
+
+      lock_readers_keys.each_with_index do |lock_readers_key, index|
+        read_lock_acquirers[index].each do |acquirer_id|
           host_id = RedisQueuedLocks::Resource.host_identifier_from_acquirer(acquirer_id)
           yield(lock_readers_key, acquirer_id) if zombie_hosts.include?(host_id)
         end
       end
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/redis_queued_locks/swarm.rb

@@ -94,6 +94,9 @@ class RedisQueuedLocks::Swarm
     )
   end
 
+  # NOTE: zombie locks are found via the lock index or via the keyspace SCAN
+  #   (`config['lock_index_enabled']`, the client-wide mode);
+  #
   # @option zombie_ttl [Integer]
   # @option lock_scan_size [Integer]
   # @option queue_scan_size [Integer]
@@ -101,6 +104,7 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
+  # @version 1.20.0
   def flush_zombies(
     zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'],
     lock_scan_size: rql_client.config['swarm.flush_zombies.zombie_lock_scan_size'],
@@ -110,7 +114,8 @@ class RedisQueuedLocks::Swarm
       rql_client.redis_client,
       zombie_ttl,
       lock_scan_size,
-      queue_scan_size
+      queue_scan_size,
+      rql_client.config['lock_index_enabled']
     )
   end
 
@@ -120,6 +125,7 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
+  # @version 1.20.0
   def zombie_locks(
     zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'],
     lock_scan_size: rql_client.config['swarm.flush_zombies.zombie_lock_scan_size']
@@ -127,7 +133,8 @@ class RedisQueuedLocks::Swarm
     RedisQueuedLocks::Swarm::ZombieInfo.zombie_locks(
       rql_client.redis_client,
       zombie_ttl,
-      lock_scan_size
+      lock_scan_size,
+      rql_client.config['lock_index_enabled']
     )
   end
 
@@ -137,6 +144,7 @@ class RedisQueuedLocks::Swarm
   #
   # @api ppublic
   # @since 1.9.0
+  # @version 1.20.0
   def zombie_acquirers(
     zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'],
     lock_scan_size: rql_client.config['swarm.flush_zombies.zombie_lock_scan_size']
@@ -144,7 +152,8 @@ class RedisQueuedLocks::Swarm
     RedisQueuedLocks::Swarm::ZombieInfo.zombie_acquirers(
       rql_client.redis_client,
       zombie_ttl,
-      lock_scan_size
+      lock_scan_size,
+      rql_client.config['lock_index_enabled']
     )
   end
 
@@ -163,6 +172,7 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
+  # @version 1.20.0
   def zombies_info(
     zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'],
     lock_scan_size: rql_client.config['swarm.flush_zombies.zombie_lock_scan_size']
@@ -170,7 +180,8 @@ class RedisQueuedLocks::Swarm
     RedisQueuedLocks::Swarm::ZombieInfo.zombies_info(
       rql_client.redis_client,
       zombie_ttl,
-      lock_scan_size
+      lock_scan_size,
+      rql_client.config['lock_index_enabled']
     )
   end
 

data/lib/redis_queued_locks/version.rb

@@ -5,6 +5,6 @@ module RedisQueuedLocks
   #
   # @api public
   # @since 0.0.1
-  # @version 1.19.0
-  VERSION = '1.19.0'
+  # @version 1.20.0
+  VERSION = '1.20.0'
 end

data/sig/redis_queued_locks/acquirer/acquire_lock/try_to_lock.rbs

@@ -6,6 +6,13 @@ module RedisQueuedLocks
     module AcquireLock
       module TryToLock
         EXTEND_LOCK_PTTL: String
+        NO_LOCK_DATA: Hash[String, untyped]
+        LOCK_STATE_OBTAINER_REPLY: Integer
+        LOCK_STATE_REDIS_TIME_REPLY: Integer
+        LOCK_STATE_OWN_READ_LOCK_REPLY: Integer
+        LOCK_STATE_QUEUE_REPLIES_AT: Integer
+        QUEUE_HEAD_REPLY: Integer
+        OPPOSITE_QUEUE_HEAD_REPLY: Integer
 
         # { ok: bool, result: Symbol }
         # { ok: bool, result: Symbol }
@@ -31,19 +38,118 @@ module RedisQueuedLocks
           String lock_key_queue,
           String read_lock_key_queue,
           String lock_readers_key,
-          String read_lock_key,
+          String? read_lock_key,
+          String lock_name,
           String acquirer_id,
           String host_id,
           Integer|Float acquirer_position,
           Integer? ttl,
           Integer queue_ttl,
+          bool lock_index_enabled,
+          Integer lock_index_grace_period,
           bool fail_fast,
           Symbol conflict_strategy,
           Symbol access_strategy,
           Hash[String|Symbol,untyped]? meta,
+          bool retry_attempt,
           bool log_sampled,
           bool instr_sampled
         ) -> { ok: bool, result: Symbol|Hash[Symbol,untyped] }
+
+        private
+
+        def queue_lock_request: (
+          RedisClient::Pipeline pipeline,
+          String request_queue,
+          String opposite_request_queue,
+          Integer|Float acquirer_position,
+          String acquirer_id,
+          Float acquirer_dead_score,
+          String lock_name,
+          Integer queue_ttl,
+          bool lock_index_enabled,
+          Integer lock_index_grace_period
+        ) -> void
+
+        def pipeline_lock_state: (
+          RedisClient::Pipeline pipeline,
+          String lock_key,
+          String lock_readers_key,
+          String acquirer_id,
+          bool read_mode,
+          bool queueing,
+          String request_queue,
+          String opposite_request_queue,
+          Integer|Float acquirer_position,
+          Float acquirer_dead_score,
+          String lock_name,
+          Integer queue_ttl,
+          bool lock_index_enabled,
+          Integer lock_index_grace_period
+        ) -> void
+
+        def find_opposite_request_ahead: (
+          Symbol access_strategy,
+          [String, Float]? opposite_waiting_request,
+          Integer|Float acquirer_position,
+          String acquirer_id
+        ) -> String?
+
+        type lockObstacle = :dead_score_reached
+                          | :acquirer_is_not_first_in_queue
+                          | :write_request_is_ahead
+                          | :read_request_is_ahead
+                          | :lock_is_still_acquired
+                          | :read_lock_is_still_acquired
+
+        def lock_obstacle: (
+          bool read_mode,
+          Symbol access_strategy,
+          String acquirer_id,
+          String? waiting_acquirer,
+          String? opposite_request_ahead,
+          String? current_lock_obtainer,
+          bool read_locked
+        ) -> lockObstacle?
+
+        def log_lock_obstacle: (
+          RC::client rconn,
+          Symbol obstacle,
+          RQL::loggerObj logger,
+          bool log_sampled,
+          bool log_lock_try,
+          String lock_key,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Symbol access_strategy,
+          Symbol read_write_mode,
+          String? waiting_acquirer,
+          String? opposite_request_ahead,
+          String? current_lock_obtainer
+        ) -> void
+
+        def precheck_lock: (
+          RC::client rconn,
+          RQL::loggerObj logger,
+          bool log_sampled,
+          bool log_lock_try,
+          String lock_key,
+          Symbol read_write_mode,
+          String lock_readers_key,
+          String request_queue,
+          String opposite_request_queue,
+          String lock_name,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acquirer_position,
+          Float acquirer_dead_score,
+          Integer queue_ttl,
+          bool lock_index_enabled,
+          Integer lock_index_grace_period,
+          bool fail_fast,
+          Symbol access_strategy
+        ) -> (lockObstacle | :fail_fast_no_try)?
       end
     end
   end

data/sig/redis_queued_locks/acquirer/acquire_lock/yield_expire.rbs

@@ -12,7 +12,7 @@ module RedisQueuedLocks
           RQL::loggerObj logger,
           String lock_key,
           String lock_readers_key,
-          String read_lock_key,
+          String? read_lock_key,
           Symbol rw_mode,
           String acquirer_id,
           String host_id,

data/sig/redis_queued_locks/acquirer/acquire_lock.rbs

@@ -21,6 +21,8 @@ module RedisQueuedLocks
         ractor_id: Integer|String,
         ttl: Integer?,
         queue_ttl: Integer,
+        lock_index_enabled: bool,
+        lock_index_grace_period: Integer,
         timeout: Integer?,
         timed: bool,
         retry_count: Integer?,

data/sig/redis_queued_locks/acquirer/clear_dead_requests.rbs

@@ -9,6 +9,7 @@ module RedisQueuedLocks
         RC::client redis_client,
         Integer scan_size,
         Integer dead_ttl,
+        bool lock_index_enabled,
         RQL::loggerObj logger,
         RQL::instrObj instrumenter,
         untyped? instrument,
@@ -22,7 +23,15 @@ module RedisQueuedLocks
         bool instr_sample_this
       ) -> clearResult
 
-      private def self.each_lock_queue: (RC::client redis_client, Integer scan_size) { (String lock_queue) -> untyped } -> Enumerator[String]
+      private def self.each_lock_queue: (RC::client redis_client, Integer scan_size) { (String lock_queue) -> void } -> void
+      private def self.drop_dead_requests: (RC::client redis_client, Array[String] lock_queues, Float dead_score) -> void
+      private def self.drop_dead_requests_of_locks: (
+        RC::client redis_client,
+        Array[String] lock_names,
+        Float dead_score,
+        Set[String] processed_queues
+      ) -> void
+      private def self.each_lock_name_batch: (RC::client redis_client, Integer scan_size) { (Array[String] lock_names) -> void } -> void
     end
   end
 end

data/sig/redis_queued_locks/acquirer/extend_lock_ttl.rbs

@@ -14,6 +14,7 @@ module RedisQueuedLocks
         Symbol read_write_mode,
         bool all_read_locks,
         String acquirer_id,
+        bool lock_index_enabled,
         RQL::loggerObj logger,
         RQL::instrObj instrumenter,
         untyped? instrument,
@@ -32,14 +33,16 @@ module RedisQueuedLocks
         String lock_name,
         String lock_key,
         String acquirer_id,
-        Integer milliseconds
+        Integer milliseconds,
+        bool lock_index_enabled
       ) -> extendResult
 
       private def self.extend_all_read_locks_ttl: (
         RC::client redis_client,
         String lock_name,
         String lock_key,
-        Integer milliseconds
+        Integer milliseconds,
+        bool lock_index_enabled
       ) -> extendResult
     end
   end

data/sig/redis_queued_locks/acquirer/keys.rbs

@@ -4,7 +4,17 @@ module RedisQueuedLocks
   module Acquirer
     module Keys
       type keyList = Set[String]
-      def self.keys: (RC::client redis_client, scan_size: Integer) -> keyList
+
+      KEY_STATE_REPLIES: Integer
+
+      def self.keys: (
+        RC::client redis_client,
+        scan_size: Integer,
+        lock_index_enabled: bool
+      ) -> keyList
+
+      private def self.collect_lock_keys: (RC::client redis_client, Array[String] lock_names, keyList keyset) -> void
+      private def self.each_lock_name_batch: (RC::client redis_client, Integer scan_size) { (Array[String] lock_names) -> void } -> void
     end
   end
 end