redis_queued_locks 1.12.1 → 1.14.0

data/lib/redis_queued_locks/{acquier → acquirer}/locks.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.0.0
-module RedisQueuedLocks::Acquier::Locks
+module RedisQueuedLocks::Acquirer::Locks
   class << self
     # @param redis_client [RedisClient]
     # @option scan_size [Integer]
@@ -50,23 +50,36 @@ module RedisQueuedLocks::Acquier::Locks
     def extract_locks_info(redis_client, lock_keys)
       # TODO: refactor with RedisQueuedLocks::Acquier::LockInfo
       Set.new.tap do |seeded_locks|
+        # rubocop:disable Layout/LineLength
+        # @type var seeded_locks: Set[{ lock: String, status: :released|:alive, info: Hash[String,untyped] }]
+        # rubocop:enable Layout/LineLength
+
         # Step X: iterate each lock and extract their info
         lock_keys.each do |lock_key|
           # Step 1: extract lock info from redis
+
+          # @type var lock_info: Hash[String,String|Float|Integer]
           lock_info = redis_client.pipelined do |pipeline|
             pipeline.call('HGETALL', lock_key)
             pipeline.call('PTTL', lock_key)
           end.yield_self do |result| # Step 2: format the result
             # Step 2.X: lock is released
             if result == nil
-              {}
+              {} #: Hash[String,String|Float|Integer]
             else
+              # NOTE: the result of MULTI-command is an array of results of each internal command
+              #   - result[0] (HGETALL) (Hash<String,String>)
+              #     => (will be mutated further with different value types)
+              #   - result[1] (PTTL) (Integer)
+              #     => (without any mutation, integer is atomic)
+
+              # @type var result: [Hash[String,String|Float|Integer],Integer]
               hget_cmd_res = result[0] # NOTE: HGETALL result (hash)
               pttl_cmd_res = result[1] # NOTE: PTTL result (integer)
 
               # Step 2.Y: lock is released
               if hget_cmd_res == {} || pttl_cmd_res == -2 # NOTE: key does not exist
-                {}
+                {} #: Hash[String,String|Float|Integer]
               else
                 # Step 2.Z: lock is alive => format received info + add additional rem_ttl info
                 hget_cmd_res.tap do |lock_data|

data/lib/redis_queued_locks/{acquier → acquirer}/queue_info.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.0.0
-module RedisQueuedLocks::Acquier::QueueInfo
+module RedisQueuedLocks::Acquirer::QueueInfo
   class << self
     # Returns an information about the required lock queue by the lock name. The result
     # represnts the ordered lock request queue that is ordered by score (Redis sets) and shows
@@ -12,14 +12,15 @@ module RedisQueuedLocks::Acquier::QueueInfo
     #
     # @param redis_client [RedisClient]
     # @param lock_name [String]
-    # @return [Hash<String|Array<Hash<String,String|Numeric>>,NilClass]
+    # @return [Hash<String,Array<Hash<String,String|Numeric>>,NilClass]
     #   - `nil` is returned when lock queue does not exist;
     #   - result format: {
     #     "lock_queue" => "rql:lock_queue:your_lock_name", # lock queue key in redis,
-    #     queue: [
-    #       { "acq_id" => "rql:acq:123/456/789/987/identity", "score" => 123 },
-    #       { "acq_id" => "rql:acq:123/686/789/987/identity", "score" => 456 },
-    #     ] # ordered set (by score) with information about an acquier and their position in queue
+    #     "queue" => [
+    #       { "acq_id" => "rql:acq:123/456/789/987/identity", "score" => 123.456 },
+    #       { "acq_id" => "rql:acq:123/686/789/987/identity", "score" => 456.789 },
+    #       ...
+    #     ] # ordered set (by score) with information about an acquirer and their position in queue
     #   }
     #
     # @api private
@@ -32,6 +33,7 @@ module RedisQueuedLocks::Acquier::QueueInfo
         pipeline.call('ZRANGE', lock_key_queue, '0', '-1', 'WITHSCORES')
       end
 
+      # @type var result: [Integer,Array[[String,Integer|Float]]]
       exists_cmd_res = result[0]
       zrange_cmd_res = result[1]
 

data/lib/redis_queued_locks/{acquier → acquirer}/queues.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.0.0
-module RedisQueuedLocks::Acquier::Queues
+module RedisQueuedLocks::Acquirer::Queues
   class << self
     # @param redis_client [RedisClient]
     # @option scan_size [Integer]
@@ -28,12 +28,14 @@ module RedisQueuedLocks::Acquier::Queues
     # @since 1.0.0
     def scan_queues(redis_client, scan_size)
       Set.new.tap do |lock_queues|
+        # @type var lock_queues: Set[String]
         redis_client.scan(
           'MATCH',
           RedisQueuedLocks::Resource::LOCK_QUEUE_PATTERN,
           count: scan_size
         ) do |lock_queue|
           # TODO: reduce unnecessary iterations
+          # @type var lock_queue: String
           lock_queues.add(lock_queue)
         end
       end
@@ -49,12 +51,15 @@ module RedisQueuedLocks::Acquier::Queues
       # TODO: refactor with RedisQueuedLocks::Acquier::QueueInfo
       Set.new.tap do |seeded_queues|
         # Step X: iterate over each lock queue and extract their info
+        # @type var seeded_queues: Set[Hash[Symbol,untyped]]
         lock_queues.each do |lock_queue|
           # Step 1: extract lock queue info from reids
           queue_info = redis_client.pipelined do |pipeline|
             pipeline.call('EXISTS', lock_queue)
             pipeline.call('ZRANGE', lock_queue, '0', '-1', 'WITHSCORES')
           end.yield_self do |result| # Step 2: format the result
+            # @type var result: [Integer, Array[[String,Float]]]
+
             exists_cmd_res = result[0]
             zrange_cmd_res = result[1]
 
@@ -62,10 +67,12 @@ module RedisQueuedLocks::Acquier::Queues
               zrange_cmd_res.map { |val| { 'acq_id' => val[0], 'score' => val[1] } }
             else
               # Step 2.Y: lock queue did not exist during the pipeline invocation
-              []
+              [] #: Array[Hash[String,Float]]
             end
           end
 
+          # @type var queue_info: Array[Hash[String,Float]]
+
           # Step 3: push the lock queue info to the result store
           seeded_queues << {
             queue: lock_queue,

data/lib/redis_queued_locks/{acquier → acquirer}/release_all_locks.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.0.0
-module RedisQueuedLocks::Acquier::ReleaseAllLocks
+module RedisQueuedLocks::Acquirer::ReleaseAllLocks
   # @since 1.0.0
   extend RedisQueuedLocks::Utilities
 
@@ -16,7 +16,7 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     # @param batch_size [Integer]
     #   The number of lock keys that should be released in a time.
     # @param logger [::Logger,#debug]
-    #   - Logger object used from `configuration` layer (see config[:logger]);
+    #   - Logger object used from `configuration` layer (see config['logger']);
     #   - See RedisQueuedLocks::Logging::VoidLogger for example;
     # @param isntrumenter [#notify]
     #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
@@ -26,15 +26,15 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     # @param log_sampling_enabled [Boolean]
     #   - enables <log sampling>: only the configured percent of RQL cases will be logged;
     #   - disabled by default;
-    #   - works in tandem with <config.log_sampling_percent and <log.sampler>;
+    #   - works in tandem with <config['log_sampling_percent']> and <config['log_sampler']>;
     # @param log_sampling_percent [Integer]
     #   - the percent of cases that should be logged;
-    #   - take an effect when <config.log_sampling_enalbed> is true;
-    #   - works in tandem with <config.log_sampling_enabled> and <config.log_sampler> configs;
+    #   - take an effect when <config['log_sampling_enalbed']> is true;
+    #   - works in tandem with <config['log_sampling_enabled']> and <config['log_sampler']> configs;
     # @param log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
     #   - percent-based log sampler that decides should be RQL case logged or not;
-    #   - works in tandem with <config.log_sampling_enabled> and
-    #     <config.log_sampling_percent> configs;
+    #   - works in tandem with <config['log_sampling_enabled']> and
+    #     <config['log_sampling_percent']> configs;
     #   - based on the ultra simple percent-based (weight-based) algorithm that uses
     #     SecureRandom.rand method so the algorithm error is ~(0%..13%);
     #   - you can provide your own log sampler with bettter algorithm that should realize
@@ -47,15 +47,16 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     #   - enables <instrumentaion sampling>: only the configured percent
     #     of RQL cases will be instrumented;
     #   - disabled by default;
-    #   - works in tandem with <config.instr_sampling_percent and <log.instr_sampler>;
+    #   - works in tandem with <config['instr_sampling_percent']> and <config['instr_sampler']>;
     # @param instr_sampling_percent [Integer]
     #   - the percent of cases that should be instrumented;
-    #   - take an effect when <config.instr_sampling_enalbed> is true;
-    #   - works in tandem with <config.instr_sampling_enabled> and <config.instr_sampler> configs;
+    #   - take an effect when <config['instr_sampling_enalbed']> is true;
+    #   - works in tandem with <config['instr_sampling_enabled']>
+    #     and <config['instr_sampler']> configs;
     # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
     #   - percent-based log sampler that decides should be RQL case instrumented or not;
-    #   - works in tandem with <config.instr_sampling_enabled> and
-    #     <config.instr_sampling_percent> configs;
+    #   - works in tandem with <config['instr_sampling_enabled']> and
+    #     <config['instr_sampling_percent']> configs;
     #   - based on the ultra simple percent-based (weight-based) algorithm that uses
     #     SecureRandom.rand method so the algorithm error is ~(0%..13%);
     #   - you can provide your own log sampler with bettter algorithm that should realize
@@ -65,12 +66,12 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     #   - marks the method that everything should be instrumneted
     #     despite the enabled instrumentation sampling;
     #   - makes sense when instrumentation sampling is enabled;
-    # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>]
+    # @return [Hash<Symbol,Any>]
     #   Format: { ok: true, result: Hash<Symbol,Numeric> }
     #
     # @api private
     # @since 1.0.0
-    # @version 1.6.0
+    # @version 1.14.0
     def release_all_locks(
       redis,
       batch_size,
@@ -86,10 +87,14 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
       instr_sampler,
       instr_sample_this
     )
-      rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
-      fully_release_all_locks(redis, batch_size) => { ok:, result: }
+      rel_start_time = clock_gettime
+      fully_release_all_locks(redis, batch_size) => { ok:, result: } # steep:ignore
+
+      # @type var ok: bool
+      # @type var result: Hash[Symbol,Integer]
+
       time_at = Time.now.to_f
-      rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+      rel_end_time = clock_gettime
       rel_time = ((rel_end_time - rel_start_time) / 1_000.0).ceil(2)
 
       instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
@@ -107,10 +112,10 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
         })
       end if instr_sampled
 
-      RedisQueuedLocks::Data[
+      {
         ok: true,
         result: { rel_key_cnt: result[:rel_key_cnt], rel_time: rel_time }
-      ]
+      }
     end
 
     private
@@ -119,7 +124,7 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     #
     # @param redis [RedisClient]
     # @param batch_size [Integer]
-    # @return [RedisQueuedLocks::Data,Hash<Symbol,Boolean|Hash<Symbol,Integer>>]
+    # @return [Hash<Symbol,Boolean|Hash<Symbol,Integer>>]
     #   - Exmaple: { ok: true, result: { rel_key_cnt: 12345 } }
     #
     # @api private
@@ -149,7 +154,7 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
         end
       end
 
-      RedisQueuedLocks::Data[ok: true, result: { rel_key_cnt: result.sum }]
+      { ok: true, result: { rel_key_cnt: result.sum } }
     end
   end
 end

data/lib/redis_queued_locks/{acquier → acquirer}/release_lock.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.0.0
-module RedisQueuedLocks::Acquier::ReleaseLock
+module RedisQueuedLocks::Acquirer::ReleaseLock
   # @since 1.0.0
   extend RedisQueuedLocks::Utilities
 
@@ -21,20 +21,20 @@ module RedisQueuedLocks::Acquier::ReleaseLock
     # @param isntrumenter [#notify]
     #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
     # @param logger [::Logger,#debug]
-    #   - Logger object used from `configuration` layer (see config[:logger]);
+    #   - Logger object used from `configuration` layer (see config['logger']);
     #   - See RedisQueuedLocks::Logging::VoidLogger for example;
     # @param log_sampling_enabled [Boolean]
     #   - enables <log sampling>: only the configured percent of RQL cases will be logged;
     #   - disabled by default;
-    #   - works in tandem with <config.log_sampling_percent and <log.sampler>;
+    #   - works in tandem with <config['log_sampling_percent']> and <config['log_sampler']>;
     # @param log_sampling_percent [Integer]
     #   - the percent of cases that should be logged;
-    #   - take an effect when <config.log_sampling_enalbed> is true;
-    #   - works in tandem with <config.log_sampling_enabled> and <config.log_sampler> configs;
+    #   - take an effect when <config['log_sampling_enalbed']> is true;
+    #   - works in tandem with <config['log_sampling_enabled']> and <config['log_sampler']> configs;
     # @param log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
     #   - percent-based log sampler that decides should be RQL case logged or not;
-    #   - works in tandem with <config.log_sampling_enabled> and
-    #     <config.log_sampling_percent> configs;
+    #   - works in tandem with <config['log_sampling_enabled']> and
+    #     <config['log_sampling_percent']> configs;
     #   - based on the ultra simple percent-based (weight-based) algorithm that uses
     #     SecureRandom.rand method so the algorithm error is ~(0%..13%);
     #   - you can provide your own log sampler with bettter algorithm that should realize
@@ -47,15 +47,16 @@ module RedisQueuedLocks::Acquier::ReleaseLock
     #   - enables <instrumentaion sampling>: only the configured percent
     #     of RQL cases will be instrumented;
     #   - disabled by default;
-    #   - works in tandem with <config.instr_sampling_percent and <log.instr_sampler>;
+    #   - works in tandem with <config['instr_sampling_percent']> and <config['instr_sampler']>;
     # @param instr_sampling_percent [Integer]
     #   - the percent of cases that should be instrumented;
-    #   - take an effect when <config.instr_sampling_enalbed> is true;
-    #   - works in tandem with <config.instr_sampling_enabled> and <config.instr_sampler> configs;
+    #   - take an effect when <config['instr_sampling_enalbed']> is true;
+    #   - works in tandem with <config['instr_sampling_enabled']>
+    #     and <config['instr_sampler']> configs;
     # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
     #   - percent-based log sampler that decides should be RQL case instrumented or not;
-    #   - works in tandem with <config.instr_sampling_enabled> and
-    #     <config.instr_sampling_percent> configs;
+    #   - works in tandem with <config['instr_sampling_enabled']> and
+    #     <config['instr_sampling_percent']> configs;
     #   - based on the ultra simple percent-based (weight-based) algorithm that uses
     #     SecureRandom.rand method so the algorithm error is ~(0%..13%);
     #   - you can provide your own log sampler with bettter algorithm that should realize
@@ -65,12 +66,12 @@ module RedisQueuedLocks::Acquier::ReleaseLock
     #   - marks the method that everything should be instrumneted
     #     despite the enabled instrumentation sampling;
     #   - makes sense when instrumentation sampling is enabled;
-    # @return [RedisQueuedLocks::Data,Hash<Symbol,Boolean<Hash<Symbol,Numeric|String|Symbol>>]
+    # @return [Hash<Symbol,Boolean<Hash<Symbol,Numeric|String|Symbol>>]
     #   Format: { ok: true/false, result: Hash<Symbol,Numeric|String|Symbol> }
     #
     # @api private
     # @since 1.0.0
-    # @version 1.6.0
+    # @version 1.14.0
     # rubocop:disable Metrics/MethodLength
     def release_lock(
       redis,
@@ -89,10 +90,14 @@ module RedisQueuedLocks::Acquier::ReleaseLock
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
 
-      rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
-      fully_release_lock(redis, lock_key, lock_key_queue) => { ok:, result: }
+      rel_start_time = clock_gettime
+      fully_release_lock(redis, lock_key, lock_key_queue) => { ok:, result: } # steep:ignore
+
+      # @type var ok: bool
+      # @type var result: Hash[Symbol,Symbol]
+
       time_at = Time.now.to_f
-      rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+      rel_end_time = clock_gettime
       rel_time = ((rel_end_time - rel_start_time) / 1_000.0).ceil(2)
 
       instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
@@ -111,7 +116,7 @@ module RedisQueuedLocks::Acquier::ReleaseLock
         })
       end if instr_sampled
 
-      RedisQueuedLocks::Data[
+      {
         ok: true,
         result: {
           rel_time: rel_time,
@@ -120,7 +125,7 @@ module RedisQueuedLocks::Acquier::ReleaseLock
           queue_res: result[:queue],
           lock_res: result[:lock]
         }
-      ]
+      }
     end
     # rubocop:enable Metrics/MethodLength
 
@@ -131,7 +136,7 @@ module RedisQueuedLocks::Acquier::ReleaseLock
     # @param redis [RedisClient]
     # @param lock_key [String]
     # @param lock_key_queue [String]
-    # @return [RedisQueuedLocks::Data,Hash<Symbol,Boolean|Hash<Symbol,Symbol>>]
+    # @return [Hash<Symbol,Boolean|Hash<Symbol,Symbol>>]
     #   Format: {
     #     ok: true/false,
     #     result: {
@@ -143,6 +148,7 @@ module RedisQueuedLocks::Acquier::ReleaseLock
     # @api private
     # @since 1.0.0
     def fully_release_lock(redis, lock_key, lock_key_queue)
+      # @type var result: [Integer,Integer]
       result = redis.with do |rconn|
         rconn.multi do |transact|
           transact.call('ZREMRANGEBYSCORE', lock_key_queue, '-inf', '+inf')
@@ -150,13 +156,13 @@ module RedisQueuedLocks::Acquier::ReleaseLock
         end
       end
 
-      RedisQueuedLocks::Data[
+      {
         ok: true,
         result: {
           queue: (result[0] != 0) ? :released : :nothing_to_release,
           lock: (result[1] != 0) ? :released : :nothing_to_release
         }
-      ]
+      }
     end
   end
 end

data/lib/redis_queued_locks/acquirer/release_locks_of.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 1.14.0
+module RedisQueuedLocks::Acquirer::ReleaseLocksOf
+  # @since 1.14.0
+  extend RedisQueuedLocks::Utilities
+
+  class << self
+    # Release all queues and locks that belong to the given host and its associated acquirer.
+    #
+    # @param refused_host_id [String]
+    #   A host whose locks and queues should be released.
+    # @param refused_acquirer_id [String]
+    #   An acquirer (of the passed host) whose locks and queues should be released.
+    # @param redis [RedisClient]
+    #   Redis connection client.
+    # @param lock_scan_size [Integer]
+    #   The number of lock keys that should be released in a time.
+    #   Affects the RubyVM memmory (cuz each found lock will be temporary stored in memory for
+    #   subsequent removal from redis in one query at a time).
+    # @param queue_scan_size [Integer]
+    #   The number of lock queues that should be scanned removing an acquirer from them (at a time).
+    # @param logger [::Logger,#debug]
+    #   - Logger object used from `configuration` layer (see config['logger']);
+    #   - See RedisQueuedLocks::Logging::VoidLogger for example;
+    # @param isntrumenter [#notify]
+    #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
+    # @param instrument [NilClass,Any]
+    #    - Custom instrumentation data wich will be passed to the instrumenter's payload
+    #      with :instrument key;
+    # @param log_sampling_enabled [Boolean]
+    #   - enables <log sampling>: only the configured percent of RQL cases will be logged;
+    #   - disabled by default;
+    #   - works in tandem with <config['log_sampling_percent']> and <config['log_sampler']>;
+    # @param log_sampling_percent [Integer]
+    #   - the percent of cases that should be logged;
+    #   - take an effect when <config['log_sampling_enalbed']> is true;
+    #   - works in tandem with <config['log_sampling_enabled']> and <config['log_sampler']> configs;
+    # @param log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
+    #   - percent-based log sampler that decides should be RQL case logged or not;
+    #   - works in tandem with <config['log_sampling_enabled']> and
+    #     <config['log_sampling_percent']> configs;
+    #   - based on the ultra simple percent-based (weight-based) algorithm that uses
+    #     SecureRandom.rand method so the algorithm error is ~(0%..13%);
+    #   - you can provide your own log sampler with bettter algorithm that should realize
+    #     `sampling_happened?(percent) => boolean` interface
+    #     (see `RedisQueuedLocks::Logging::Sampler` for example);
+    # @param log_sample_this [Boolean]
+    #   - marks the method that everything should be logged despite the enabled log sampling;
+    #   - makes sense when log sampling is enabled;
+    # @param instr_sampling_enabled [Boolean]
+    #   - enables <instrumentaion sampling>: only the configured percent
+    #     of RQL cases will be instrumented;
+    #   - disabled by default;
+    #   - works in tandem with <config['instr_sampling_percent']> and <config['instr_sampler']>;
+    # @param instr_sampling_percent [Integer]
+    #   - the percent of cases that should be instrumented;
+    #   - take an effect when <config['instr_sampling_enalbed']> is true;
+    #   - works in tandem with <config['instr_sampling_enabled']>
+    #     and <config['instr_sampler']> configs;
+    # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
+    #   - percent-based log sampler that decides should be RQL case instrumented or not;
+    #   - works in tandem with <config['instr_sampling_enabled']> and
+    #     <config['instr_sampling_percent']> configs;
+    #   - based on the ultra simple percent-based (weight-based) algorithm that uses
+    #     SecureRandom.rand method so the algorithm error is ~(0%..13%);
+    #   - you can provide your own log sampler with bettter algorithm that should realize
+    #     `sampling_happened?(percent) => boolean` interface
+    #     (see `RedisQueuedLocks::Instrument::Sampler` for example);
+    # @param instr_sample_this [Boolean]
+    #   - marks the method that everything should be instrumneted
+    #     despite the enabled instrumentation sampling;
+    #   - makes sense when instrumentation sampling is enabled;
+    # @return [Hash<Symbol,Any>]
+    #   Format: { ok: true, result: Hash<Symbol,Numeric> }
+    #
+    # @api private
+    # @since 1.14.0
+    # rubocop:disable Metrics/MethodLength
+    def release_locks_of(
+      refused_host_id,
+      refused_acquirer_id,
+      redis,
+      lock_scan_size,
+      queue_scan_size,
+      logger,
+      instrumenter,
+      instrument,
+      log_sampling_enabled,
+      log_sampling_percent,
+      log_sampler,
+      log_sample_this,
+      instr_sampling_enabled,
+      instr_sampling_percent,
+      instr_sampler,
+      instr_sample_this
+    ) # TODO: move from SCAN to indexes :thinking:
+      rel_start_time = clock_gettime
+
+      # steep:ignore:start
+      fully_release_locks_of(
+        refused_host_id,
+        refused_acquirer_id,
+        redis,
+        lock_scan_size,
+        queue_scan_size
+      ) => { ok:, result: }
+      # steep:ignore:end
+
+      # @type var ok: bool
+      # @type var result: Hash[Symbol,Integer]
+
+      time_at = Time.now.to_f
+      rel_end_time = clock_gettime
+      rel_time = ((rel_end_time - rel_start_time) / 1_000.0).ceil(2)
+
+      instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
+        instr_sampling_enabled,
+        instr_sample_this,
+        instr_sampling_percent,
+        instr_sampler
+      )
+
+      run_non_critical do
+        instrumenter.notify('redis_queued_locks.release_locks_of', {
+          at: time_at,
+          rel_time: rel_time,
+          rel_key_cnt: result[:rel_key_cnt],
+          tch_queue_cnt: result[:tch_queue_cnt]
+        })
+      end if instr_sampled
+
+      {
+        ok: true,
+        result: {
+          rel_key_cnt: result[:rel_key_cnt],
+          tch_queue_cnt: result[:tch_queue_cnt],
+          rel_time: rel_time
+        }
+      }
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    private
+
+    # @param refused_host_id [String]
+    # @param refused_acquirer_id [String]
+    # @param redis [RedisClient]
+    # @param lock_scan_size [Integer]
+    # @param queue_scan_size [Integer]
+    # @return [Hash<Symbol,Boolean|Hash<Symbol,Integer>>]
+    #   - Example: { ok: true, result: { rel_key_cnt: 12345, tch_queue_cnt: 321 } }
+    #
+    # @api private
+    # @since 1.14.0
+    # rubocop:disable Metrics/MethodLength
+    def fully_release_locks_of(
+      refused_host_id,
+      refused_acquirer_id,
+      redis,
+      lock_scan_size,
+      queue_scan_size
+    )
+      # TODO: some indexing approach isntead of <scan>
+      rel_key_cnt = 0
+      tch_queue_cnt = 0
+
+      redis.with do |rconn|
+        # Step A: drop locks of the passed host/acquirer
+        refused_locks = Set.new #: Set[String]
+        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 refused_host_id == host_id && refused_acquirer_id == acquirer_id
+            refused_locks << lock_key
+          end
+
+          if refused_locks.size >= lock_scan_size
+            # NOTE: steep can not recognize the `*`-splat operator on Set objects
+            rconn.call('DEL', *refused_locks) # steep:ignore
+            rel_key_cnt += refused_locks.size
+            refused_locks.clear
+          end
+        end
+
+        if refused_locks.any?
+          # NOTE: steep can not recognize the `*`-splat operator on Set objects
+          rconn.call('DEL', *refused_locks) # steep:ignore
+          rel_key_cnt += refused_locks.size
+        end
+
+        # Step B: drop passed host/acquirer from lock queues
+        rconn.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::LOCK_QUEUE_PATTERN,
+          count: queue_scan_size
+        ) do |lock_queue|
+          res = rconn.call('ZREM', lock_queue, refused_acquirer_id)
+          tch_queue_cnt += 1 if res != 0
+        end
+      end
+
+      { ok: true, result: { rel_key_cnt:, tch_queue_cnt: } }
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+end

data/lib/redis_queued_locks/acquirer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 1.0.0
+module RedisQueuedLocks::Acquirer
+  require_relative 'acquirer/acquire_lock'
+  require_relative 'acquirer/release_lock'
+  require_relative 'acquirer/release_all_locks'
+  require_relative 'acquirer/release_locks_of'
+  require_relative 'acquirer/is_locked'
+  require_relative 'acquirer/is_queued'
+  require_relative 'acquirer/lock_info'
+  require_relative 'acquirer/queue_info'
+  require_relative 'acquirer/locks'
+  require_relative 'acquirer/queues'
+  require_relative 'acquirer/keys'
+  require_relative 'acquirer/extend_lock_ttl'
+  require_relative 'acquirer/clear_dead_requests'
+end