redis_queued_locks 1.19.0 → 1.21.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

@@ -2,6 +2,7 @@
 
 # @api public
 # @since 1.9.0
+# @version 1.13.0
 # rubocop:disable Metrics/ClassLength
 class RedisQueuedLocks::Swarm
   require_relative 'swarm/redis_client_builder'
@@ -76,7 +77,16 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
+  # @version 1.21.0
   def swarm_info(zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'])
+    # NOTE: (arguments) the same ranges as the config keys;
+    if !zombie_ttl.is_a?(::Integer) || zombie_ttl <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:zombie_ttl` argument should be a positive Integer, got #{zombie_ttl.inspect}."
+      )
+    end
+
     RedisQueuedLocks::Swarm::Acquirers.acquirers(
       rql_client.redis_client,
       zombie_ttl
@@ -94,6 +104,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,16 +114,38 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
+  # @version 1.21.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'],
     queue_scan_size: rql_client.config['swarm.flush_zombies.zombie_queue_scan_size']
   )
+    # NOTE: (arguments) the same ranges as the config keys;
+    if !zombie_ttl.is_a?(::Integer) || zombie_ttl <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:zombie_ttl` argument should be a positive Integer, got #{zombie_ttl.inspect}."
+      )
+    end
+    if !lock_scan_size.is_a?(::Integer) || lock_scan_size <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:lock_scan_size` argument should be a positive Integer, got #{lock_scan_size.inspect}."
+      )
+    end
+    if !queue_scan_size.is_a?(::Integer) || queue_scan_size <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:queue_scan_size` argument should be a positive Integer, got #{queue_scan_size.inspect}."
+      )
+    end
+
     RedisQueuedLocks::Swarm::FlushZombies.flush_zombies(
       rql_client.redis_client,
       zombie_ttl,
       lock_scan_size,
-      queue_scan_size
+      queue_scan_size,
+      rql_client.config['lock_index_enabled']
     )
   end
 
@@ -120,14 +155,30 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
+  # @version 1.21.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']
   )
+    # NOTE: (arguments) the same ranges as the config keys;
+    if !zombie_ttl.is_a?(::Integer) || zombie_ttl <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:zombie_ttl` argument should be a positive Integer, got #{zombie_ttl.inspect}."
+      )
+    end
+    if !lock_scan_size.is_a?(::Integer) || lock_scan_size <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:lock_scan_size` argument should be a positive Integer, got #{lock_scan_size.inspect}."
+      )
+    end
+
     RedisQueuedLocks::Swarm::ZombieInfo.zombie_locks(
       rql_client.redis_client,
       zombie_ttl,
-      lock_scan_size
+      lock_scan_size,
+      rql_client.config['lock_index_enabled']
     )
   end
 
@@ -135,16 +186,32 @@ class RedisQueuedLocks::Swarm
   # @option lock_scan_size [Integer]
   # @return [Set<String>]
   #
-  # @api ppublic
+  # @api public
   # @since 1.9.0
+  # @version 1.21.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']
   )
+    # NOTE: (arguments) the same ranges as the config keys;
+    if !zombie_ttl.is_a?(::Integer) || zombie_ttl <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:zombie_ttl` argument should be a positive Integer, got #{zombie_ttl.inspect}."
+      )
+    end
+    if !lock_scan_size.is_a?(::Integer) || lock_scan_size <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:lock_scan_size` argument should be a positive Integer, got #{lock_scan_size.inspect}."
+      )
+    end
+
     RedisQueuedLocks::Swarm::ZombieInfo.zombie_acquirers(
       rql_client.redis_client,
       zombie_ttl,
-      lock_scan_size
+      lock_scan_size,
+      rql_client.config['lock_index_enabled']
     )
   end
 
@@ -153,7 +220,16 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
+  # @version 1.21.0
   def zombie_hosts(zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'])
+    # NOTE: (arguments) the same ranges as the config keys;
+    if !zombie_ttl.is_a?(::Integer) || zombie_ttl <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:zombie_ttl` argument should be a positive Integer, got #{zombie_ttl.inspect}."
+      )
+    end
+
     RedisQueuedLocks::Swarm::ZombieInfo.zombie_hosts(rql_client.redis_client, zombie_ttl)
   end
 
@@ -163,14 +239,30 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
+  # @version 1.21.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']
   )
+    # NOTE: (arguments) the same ranges as the config keys;
+    if !zombie_ttl.is_a?(::Integer) || zombie_ttl <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:zombie_ttl` argument should be a positive Integer, got #{zombie_ttl.inspect}."
+      )
+    end
+    if !lock_scan_size.is_a?(::Integer) || lock_scan_size <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:lock_scan_size` argument should be a positive Integer, got #{lock_scan_size.inspect}."
+      )
+    end
+
     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/utilities.rb

@@ -39,7 +39,7 @@ module RedisQueuedLocks::Utilities
   # @return [Boolean]
   #
   # @api public
-  # @since ?.?.?
+  # @since 1.16.0
   RUBY_OVER_4 = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('4.0.0')
 
   # @yield

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.21.0
+  VERSION = '1.21.0'
 end

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

@@ -70,6 +70,20 @@ module RedisQueuedLocks
           Integer|Float hold_time,
           untyped? instrument
         ) -> void
+
+        def self.lock_obtaining_failed: (
+          RQL::instrObj instrumenter,
+          bool instr_sampled,
+          String lock_key,
+          Symbol rw_mode,
+          Integer ttl,
+          String acq_id,
+          String hst_id,
+          Integer|Float ts,
+          Integer|Float acq_time,
+          Symbol result,
+          untyped? instrument
+        ) -> void
       end
     end
   end

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

@@ -72,6 +72,19 @@ module RedisQueuedLocks
           Symbol access_strategy,
           Symbol rw_mode
         ) -> void
+
+        def self.lock_obtaining_failed: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          String lock_key,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acq_time,
+          Symbol access_strategy,
+          Symbol rw_mode,
+          Symbol result
+        ) -> void
       end
     end
   end