redis_queued_locks 1.13.0 → 1.15.0

data/github_ci/ruby3.3.gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: ..
   specs:
-    redis_queued_locks (1.13.0)
+    redis_queued_locks (1.15.0)
       redis-client (~> 0.20)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (8.0.2)
+    activesupport (8.0.3)
       base64
       benchmark (>= 0.3)
       bigdecimal
@@ -34,10 +34,10 @@ GEM
     ast (2.4.3)
     base64 (0.3.0)
     benchmark (0.4.1)
-    bigdecimal (3.2.1)
+    bigdecimal (3.3.1)
     coderay (1.1.3)
     concurrent-ruby (1.3.5)
-    connection_pool (2.5.3)
+    connection_pool (2.5.4)
     csv (3.3.5)
     diff-lcs (1.6.2)
     docile (1.4.1)
@@ -56,7 +56,7 @@ GEM
     fileutils (1.7.3)
     i18n (1.14.7)
       concurrent-ruby (~> 1.0)
-    json (2.12.2)
+    json (2.15.1)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
     listen (3.9.0)
@@ -64,43 +64,43 @@ GEM
       rb-inotify (~> 0.9, >= 0.9.10)
     logger (1.7.0)
     method_source (1.1.0)
-    minitest (5.25.5)
+    minitest (5.26.0)
     mutex_m (0.3.0)
     parallel (1.27.0)
-    parser (3.3.8.0)
+    parser (3.3.9.0)
       ast (~> 2.4.1)
       racc
-    prism (1.4.0)
+    prism (1.6.0)
     pry (0.15.2)
       coderay (~> 1.1)
       method_source (~> 1.0)
     racc (1.8.1)
-    rack (3.1.15)
+    rack (3.2.3)
     rainbow (3.1.1)
     rake (13.3.0)
     rb-fsevent (0.11.2)
     rb-inotify (0.11.1)
       ffi (~> 1.0)
-    rbs (3.9.4)
+    rbs (3.9.5)
       logger
-    redis-client (0.24.0)
+    redis-client (0.26.1)
       connection_pool
-    regexp_parser (2.10.0)
+    regexp_parser (2.11.3)
     rspec (3.13.1)
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
       rspec-mocks (~> 3.13.0)
-    rspec-core (3.13.4)
+    rspec-core (3.13.5)
       rspec-support (~> 3.13.0)
     rspec-expectations (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
-    rspec-mocks (3.13.5)
+    rspec-mocks (3.13.6)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
     rspec-retry (0.6.2)
       rspec-core (> 3.3)
-    rspec-support (3.13.4)
+    rspec-support (3.13.6)
     rubocop (1.75.7)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
@@ -112,7 +112,7 @@ GEM
       rubocop-ast (>= 1.44.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 4.0)
-    rubocop-ast (1.44.1)
+    rubocop-ast (1.47.1)
       parser (>= 3.3.7.2)
       prism (~> 1.4)
     rubocop-capybara (2.22.1)
@@ -155,8 +155,8 @@ GEM
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
-    simplecov-html (0.13.1)
-    simplecov-lcov (0.8.0)
+    simplecov-html (0.13.2)
+    simplecov-lcov (0.9.0)
     simplecov_json_formatter (0.1.4)
     steep (1.10.0)
       activesupport (>= 5.1)
@@ -180,10 +180,10 @@ GEM
       unicode-display_width (>= 1.1.1, < 4)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    unicode-display_width (3.1.4)
-      unicode-emoji (~> 4.0, >= 4.0.4)
-    unicode-emoji (4.0.4)
-    uri (1.0.3)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.1.0)
+    uri (1.0.4)
     zlib (3.2.1)
 
 PLATFORMS
@@ -214,4 +214,4 @@ DEPENDENCIES
   steep
 
 BUNDLED WITH
-   2.6.9
+   2.7.2

data/lib/redis_queued_locks/acquirer/acquire_lock.rb

@@ -17,6 +17,8 @@ module RedisQueuedLocks::Acquirer::AcquireLock
   require_relative 'acquire_lock/try_to_lock'
   require_relative 'acquire_lock/dequeue_from_lock_queue'
 
+  # @since 1.14.0
+  extend RedisQueuedLocks::Utilities
   # @since 1.0.0
   extend TryToLock
   # @since 1.0.0
@@ -157,7 +159,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.13.0
+    # @version 1.14.0
     def acquire_lock(
       redis,
       lock_name,
@@ -309,7 +311,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
         detailed_acq_timeout_error,
         on_timeout: acq_dequeue
       ) do
-        acq_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+        acq_start_time = clock_gettime
 
         # Step 2.1: cyclically try to obtain the lock
         while acq_process[:should_try]
@@ -358,7 +360,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
           # @type var ok: bool
           # @type var result: Symbol|Hash[Symbol,untyped]
 
-          acq_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+          acq_end_time = clock_gettime
           acq_time = ((acq_end_time - acq_start_time) / 1_000.0).ceil(2)
 
           # Step X: save the intermediate results to the result observer
@@ -491,7 +493,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
         # Step 3.a: acquired successfully => run logic or return the result of acquirement
         if block_given?
           begin
-            yield_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+            yield_time = clock_gettime
 
             ttl_shift = (
               (yield_time - acq_process[:acq_end_time]) / 1_000.0 -
@@ -524,9 +526,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
               &block
             )
           ensure
-            acq_process[:rel_time] = ::Process.clock_gettime(
-              ::Process::CLOCK_MONOTONIC, :microsecond
-            )
+            acq_process[:rel_time] = clock_gettime
             acq_process[:hold_time] = (
               (acq_process[:rel_time] - acq_process[:acq_end_time]) / 1_000.0
             ).ceil(2)

data/lib/redis_queued_locks/acquirer/release_all_locks.rb

@@ -71,7 +71,7 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
     #
     # @api private
     # @since 1.0.0
-    # @version 1.6.0
+    # @version 1.14.0
     def release_all_locks(
       redis,
       batch_size,
@@ -87,14 +87,14 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
       instr_sampler,
       instr_sample_this
     )
-      rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+      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?(

data/lib/redis_queued_locks/acquirer/release_lock.rb

@@ -71,7 +71,7 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.6.0
+    # @version 1.14.0
     # rubocop:disable Metrics/MethodLength
     def release_lock(
       redis,
@@ -90,14 +90,14 @@ module RedisQueuedLocks::Acquirer::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)
+      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?(

data/lib/redis_queued_locks/acquirer/release_locks_of.rb

@@ -0,0 +1,221 @@
+# 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: {
+    #       rel_key_cnt: Integer,
+    #       tch_queue_cnt: Integer,
+    #       rel_time: Numeric
+    #     }
+    #   }
+    #
+    # @api private
+    # @since 1.14.0
+    # @version 1.15.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,
+          hst_id: refused_host_id,
+          acq_id: refused_acquirer_id,
+          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

@@ -6,6 +6,7 @@ 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'

data/lib/redis_queued_locks/client.rb

@@ -2,6 +2,7 @@
 
 # @api public
 # @since 1.0.0
+# @version 1.14.0
 # rubocop:disable Metrics/ClassLength
 class RedisQueuedLocks::Client
   # @return [RedisClient]
@@ -27,7 +28,7 @@ class RedisQueuedLocks::Client
   # @return [RedisQueuedLocks::Config]
   #
   # @api public
-  # @since [1.13.0]
+  # @since 1.13.0
   attr_reader :config
 
   # @param redis_client [RedisClient]
@@ -52,7 +53,7 @@ class RedisQueuedLocks::Client
   # @return [void]
   #
   # @api public
-  # @since [1.13.0]
+  # @since 1.13.0
   def configure(&configuration)
     config.configure(&configuration)
   end
@@ -577,6 +578,8 @@ class RedisQueuedLocks::Client
       identity
     )
   end
+  alias_method :current_acq_id, :current_acquirer_id
+  alias_method :acq_id, :current_acquirer_id
 
   # Retrun the current host identifier.
   #
@@ -608,6 +611,8 @@ class RedisQueuedLocks::Client
       identity
     )
   end
+  alias_method :current_hst_id, :current_host_id
+  alias_method :hst_id, :current_host_id
 
   # Return the list of possible host identifiers that can be reached from the current ractor.
   #
@@ -739,6 +744,154 @@ class RedisQueuedLocks::Client
   end
   alias_method :release_locks, :clear_locks
 
+  # Release all locks of the passed acquirer/host and remove this acquirer/host from all queues;
+  #
+  # This is a cleanup helper intended for operational and debugging scenarios (for example: your
+  # current puma request thread is killed by Rack::Timeout and you need to cleanup all zombie RQL
+  # locks and lock reuqests obtained during the request processing).
+  #
+  # Identifiers can be extracted via:
+  #   - `#current_host_id`
+  #   - `#current_acquirer_id`
+  #   - `#possible_host_ids`
+  #   - lock data (extracted from Redis via #lock_info, #locks_info, #queue_info, #queues_info)
+  #
+  # @option host_id [String] Host identifier whose locks/queues should be released.
+  # @option acquirer_id [String] Acquirer identifier, associated with the `host_id`.
+  # @option lock_scan_size [Integer]
+  # @option queue_scan_size [Integer]
+  # @option logger [::Logger,#debug]
+  # @option instrumenter [#notify] See `config['instrumenter']` docs for details.
+  # @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,Boolean|Hash<Symbol,Numeric>>]
+  #   Example: { ok: true, result: { rel_key_cnt: 100, tch_queue_cnt: 2, rel_time: 0.01 } }
+  #
+  # @example Release locks of the current process:
+  #   client.clear_locks_of(
+  #     host_id: client.current_host_id,
+  #     acquirer_id: client.current_acquirer_id
+  #   )
+  #
+  # @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"
+  #   )
+  #
+  # @see #clear_current_locks
+  # @see #current_host_id
+  # @see #current_acquirer_id
+  # @see #possible_host_ids
+  # @see #lock_info
+  # @see #locks_info
+  # @see #queue_info
+  # @see #queues_info
+  #
+  # @api public
+  # @since 1.14.0
+  def clear_locks_of(
+    host_id:,
+    acquirer_id:,
+    lock_scan_size: config['clear_locks_of__lock_scan_size'], # steep:ignore
+    queue_scan_size: config['clear_locks_of__queue_scan_size'], # steep:ingore
+    logger: config['logger'], # steep:ignore
+    instrumenter: config['instrumenter'], # steep:ignore
+    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_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_sample_this: false
+  )
+    RedisQueuedLocks::Acquirer::ReleaseLocksOf.release_locks_of(
+      host_id,
+      acquirer_id,
+      redis_client,
+      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
+    )
+  end
+  alias_method :release_locks_of, :clear_locks_of
+
+  # Release all locks of the current acquirer/host and
+  # remove the current acquirer/host from all queues;
+  #
+  # @option batch_size [Integer]
+  # @option logger [::Logger,#debug]
+  # @option instrumenter [#notify] See `config['instrumenter']` docs for details.
+  # @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,Boolean|Hash<Symbol,Numeric>>]
+  #   Example: { ok: true, result: { rel_key_cnt: 100, tch_queue_cnt: 2, rel_time: 0.01 } }
+  #
+  # @see #clear_locks_of
+  #
+  # @api public
+  # @since 1.14.0
+  def clear_current_locks(
+    lock_scan_size: config['clear_locks_of__lock_scan_size'], # steep:ignore
+    queue_scan_size: config['clear_locks_of__queue_scan_size'], # steep:ingore
+    logger: config['logger'], # steep:ignore
+    instrumenter: config['instrumenter'], # steep:ignore
+    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_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_sample_this: false
+  )
+    clear_locks_of(
+      host_id: current_host_id,
+      acquirer_id: current_acquirer_id,
+      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:
+    )
+  end
+  alias_method :release_current_locks, :clear_current_locks
+
   # @option scan_size [Integer]
   #   The batch of scanned keys for Redis'es SCAN command.
   # @option with_info [Boolean]