redis_queued_locks 1.12.1 → 1.14.0

data/lib/redis_queued_locks/client.rb

@@ -2,122 +2,9 @@
 
 # @api public
 # @since 1.0.0
+# @version 1.14.0
 # rubocop:disable Metrics/ClassLength
 class RedisQueuedLocks::Client
-  # @since 1.0.0
-  include Qonfig::Configurable
-
-  configuration do
-    setting :retry_count, 3
-    setting :retry_delay, 200 # NOTE: in milliseconds
-    setting :retry_jitter, 25 # NOTE: in milliseconds
-    setting :try_to_lock_timeout, 10 # NOTE: in seconds
-    setting :default_lock_ttl, 5_000 # NOTE: in milliseconds
-    setting :default_queue_ttl, 15 # NOTE: in seconds
-    setting :detailed_acq_timeout_error, false
-    setting :lock_release_batch_size, 100
-    setting :key_extraction_batch_size, 500
-    setting :instrumenter, RedisQueuedLocks::Instrument::VoidNotifier
-    setting :uniq_identifier, -> { RedisQueuedLocks::Resource.calc_uniq_identity }
-    setting :logger, RedisQueuedLocks::Logging::VoidLogger
-    setting :log_lock_try, false
-    setting :dead_request_ttl, (1 * 24 * 60 * 60 * 1000) # NOTE: 1 day in milliseconds
-    setting :is_timed_by_default, false
-    setting :default_conflict_strategy, :wait_for_lock
-    setting :default_access_strategy, :queued
-    setting :log_sampling_enabled, false
-    setting :log_sampling_percent, 15
-    setting :log_sampler, RedisQueuedLocks::Logging::Sampler
-    setting :instr_sampling_enabled, false
-    setting :instr_sampling_percent, 15
-    setting :instr_sampler, RedisQueuedLocks::Instrument::Sampler
-
-    setting :swarm do
-      setting :auto_swarm, false
-      setting :supervisor do
-        setting :liveness_probing_period, 2 # NOTE: in seconds
-      end
-      setting :probe_hosts do
-        setting :enabled_for_swarm, true
-        setting :redis_config do
-          setting :sentinel, false
-          setting :pooled, false
-          setting :config, {}
-          setting :pool_config, {}
-        end
-        setting :probe_period, 2 # NOTE: in seconds
-      end
-      setting :flush_zombies do
-        setting :enabled_for_swarm, true
-        setting :redis_config do
-          setting :sentinel, false
-          setting :pooled, false
-          setting :config, {}
-          setting :pool_config, {}
-        end
-        setting :zombie_ttl, 15_000 # NOTE: in milliseconds
-        setting :zombie_lock_scan_size, 500
-        setting :zombie_queue_scan_size, 500
-        setting :zombie_flush_period, 10 # NOTE: in seconds
-      end
-    end
-
-    validate('swarm.auto_swarm', :boolean)
-    validate('swarm.visor.liveness_probing_period', :integer)
-
-    validate('swarm.probe_hosts.enabled_for_swarm', :boolean)
-    validate('swarm.probe_hosts.redis_config.sentinel', :boolean)
-    validate('swarm.probe_hosts.redis_config.pooled', :boolean)
-    validate('swarm.probe_hosts.redis_config.config', :hash)
-    validate('swarm.probe_hosts.redis_config.pool_config', :hash)
-    validate('swarm.probe_hosts.probe_period', :integer)
-
-    validate('swarm.flush_zombies.enabled_for_swarm', :boolean)
-    validate('swarm.flush_zombies.redis_config.sentinel', :boolean)
-    validate('swarm.flush_zombies.redis_config.pooled', :boolean)
-    validate('swarm.flush_zombies.redis_config.config', :hash)
-    validate('swarm.flush_zombies.redis_config.pool_config', :hash)
-    validate('swarm.flush_zombies.zombie_ttl', :integer)
-    validate('swarm.flush_zombies.zombie_lock_scan_size', :integer)
-    validate('swarm.flush_zombies.zombie_queue_scan_size', :integer)
-    validate('swarm.flush_zombies.zombie_flush_period', :integer)
-
-    validate('retry_count') { |val| val == nil || (val.is_a?(::Integer) && val >= 0) }
-    validate('retry_delay') { |val| val.is_a?(::Integer) && val >= 0 }
-    validate('retry_jitter') { |val| val.is_a?(::Integer) && val >= 0 }
-    validate('try_to_lock_timeout') { |val| val == nil || (val.is_a?(::Integer) && val >= 0) }
-    validate('default_lock_tt', :integer)
-    validate('default_queue_ttl', :integer)
-    validate('detailed_acq_timeout_error', :boolean)
-    validate('lock_release_batch_size', :integer)
-    validate('instrumenter') { |val| RedisQueuedLocks::Instrument.valid_interface?(val) }
-    validate('uniq_identifier', :proc)
-    validate('logger') { |val| RedisQueuedLocks::Logging.valid_interface?(val) }
-    validate('log_lock_try', :boolean)
-    validate('dead_request_ttl') { |val| val.is_a?(::Integer) && val > 0 }
-    validate('is_timed_by_default', :boolean)
-    validate('log_sampler') { |val| RedisQueuedLocks::Logging.valid_sampler?(val) }
-    validate('log_sampling_enabled', :boolean)
-    validate('log_sampling_percent') { |val| val.is_a?(::Integer) && val >= 0 && val <= 100 }
-    validate('instr_sampling_enabled', :boolean)
-    validate('instr_sampling_percent') { |val| val.is_a?(::Integer) && val >= 0 && val <= 100 }
-    validate('instr_sampler') { |val| RedisQueuedLocks::Instrument.valid_sampler?(val) }
-    validate('default_conflict_strategy') do |val|
-      # rubocop:disable Layout/MultilineOperationIndentation
-      val == :work_through ||
-      val == :extendable_work_through ||
-      val == :wait_for_lock ||
-      val == :dead_locking
-      # rubocop:enable Layout/MultilineOperationIndentation
-    end
-    validate('default_access_strategy') do |val|
-      # rubocop:disable Layout/MultilineOperationIndentation
-      val == :queued ||
-      val == :random
-      # rubocop:enable Layout/MultilineOperationIndentation
-    end
-  end
-
   # @return [RedisClient]
   #
   # @api private
@@ -138,20 +25,37 @@ class RedisQueuedLocks::Client
   # @since 1.9.0
   attr_reader :swarm
 
+  # @return [RedisQueuedLocks::Config]
+  #
+  # @api public
+  # @since 1.13.0
+  attr_reader :config
+
   # @param redis_client [RedisClient]
-  #   Redis connection manager, which will be used for the lock acquierment and distribution.
+  #   Redis connection manager, which will be used for the lock acquirerment and distribution.
   #   It should be an instance of RedisClient.
-  # @param configs [Block]
+  # @param configuration [Block]
   #   Custom configs for in-runtime configuration.
   # @return [void]
   #
   # @api public
   # @since 1.0.0
-  def initialize(redis_client, &configs)
-    configure(&configs)
-    @uniq_identity = config[:uniq_identifier].call
+  # @version 1.13.0
+  def initialize(redis_client, &configuration)
+    @config = RedisQueuedLocks::Config.new(&configuration)
+    @uniq_identity = config['uniq_identifier'].call #: String
     @redis_client = redis_client
-    @swarm = RedisQueuedLocks::Swarm.new(self).tap { |s| s.swarm! if config[:swarm][:auto_swarm] }
+    @swarm = RedisQueuedLocks::Swarm.new(self)
+    @swarm.swarm! if config['swarm.auto_swarm']
+  end
+
+  # @param configuration [Block]
+  # @return [void]
+  #
+  # @api public
+  # @since 1.13.0
+  def configure(&configuration)
+    config.configure(&configuration)
   end
 
   # @return [Hash<Symbol,Boolean|Symbol>]
@@ -175,7 +79,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.9.0
-  def swarm_info(zombie_ttl: config[:swarm][:flush_zombies][:zombie_ttl])
+  def swarm_info(zombie_ttl: config['swarm.flush_zombies.zombie_ttl']) # steep:ignore
     swarm.swarm_info(zombie_ttl:)
   end
 
@@ -204,9 +108,9 @@ class RedisQueuedLocks::Client
   # @api public
   # @since 1.9.0
   def flush_zombies(
-    zombie_ttl: config[:swarm][:flush_zombies][:zombie_ttl],
-    lock_scan_size: config[:swarm][:flush_zombies][:zombie_lock_scan_size],
-    queue_scan_size: config[:swarm][:flush_zombies][:zombie_queue_scan_size]
+    zombie_ttl: config['swarm.flush_zombies.zombie_ttl'], # steep:ignore
+    lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size'], # steep:ignore
+    queue_scan_size: config['swarm.flush_zombies.zombie_queue_scan_size'] # steep:ignore
   )
     swarm.flush_zombies(zombie_ttl:, lock_scan_size:, queue_scan_size:)
   end
@@ -218,8 +122,8 @@ class RedisQueuedLocks::Client
   # @api public
   # @since 1.9.0
   def zombie_locks(
-    zombie_ttl: config[:swarm][:flush_zombies][:zombie_ttl],
-    lock_scan_size: config[:swarm][:flush_zombies][:zombie_lock_scan_size]
+    zombie_ttl: config['swarm.flush_zombies.zombie_ttl'], # steep:ignore
+    lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size'] # steep:ignore
   )
     swarm.zombie_locks(zombie_ttl:, lock_scan_size:)
   end
@@ -230,11 +134,11 @@ class RedisQueuedLocks::Client
   #
   # @api ppublic
   # @since 1.9.0
-  def zombie_acquiers(
-    zombie_ttl: config[:swarm][:flush_zombies][:zombie_ttl],
-    lock_scan_size: config[:swarm][:flush_zombies][:zombie_lock_scan_size]
+  def zombie_acquirers(
+    zombie_ttl: config['swarm.flush_zombies.zombie_ttl'], # steep:ignore
+    lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size'] # steep:ignore
   )
-    swarm.zombie_acquiers(zombie_ttl:, lock_scan_size:)
+    swarm.zombie_acquirers(zombie_ttl:, lock_scan_size:)
   end
 
   # @option zombie_ttl [Integer]
@@ -242,22 +146,22 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.9.0
-  def zombie_hosts(zombie_ttl: config[:swarm][:flush_zombies][:zombie_ttl])
+  def zombie_hosts(zombie_ttl: config['swarm.flush_zombies.zombie_ttl']) # steep:ignore
     swarm.zombie_hosts(zombie_ttl:)
   end
 
   # @return [Hash<Symbol,Set<String>>]
   #   Format: {
   #     zombie_hosts: <Set<String>>,
-  #     zombie_acquiers: <Set<String>>,
+  #     zombie_acquirers: <Set<String>>,
   #     zombie_locks: <Set<String>>
   #   }
   #
   # @api public
   # @since 1.9.0
   def zombies_info(
-    zombie_ttl: config[:swarm][:flush_zombies][:zombie_ttl],
-    lock_scan_size: config[:swarm][:flush_zombies][:zombie_ttl]
+    zombie_ttl: config['swarm.flush_zombies.zombie_ttl'], # steep:ignore
+    lock_scan_size: config['swarm.flush_zombies.zombie_ttl'] # steep:ignore
   )
     swarm.zombies_info(zombie_ttl:, lock_scan_size:)
   end
@@ -294,13 +198,15 @@ class RedisQueuedLocks::Client
   #   - The conflict strategy mode for cases when the process that obtained the lock
   #     want to acquire this lock again;
   #   - By default uses `:wait_for_lock` strategy;
-  #   - pre-confured in `config[:default_conflict_strategy]`;
+  #   - pre-confured in `config['default_conflict_strategy']`;
   #   - Supports:
   #     - `:work_through` - continue working under the lock without lock's TTL extension;
   #     - `:extendable_work_through` - continue working under the lock with lock's TTL extension;
   #     - `:wait_for_lock` - (default) - work in classic way
   #       (with timeouts, retry delays, retry limits, etc - in classic way :));
   #     - `:dead_locking` - fail with deadlock exception;
+  # @option read_write_mode [Symbol]
+  #   - ?
   # @option access_strategy [Symbol]
   #   - The way in which the lock will be obtained;
   #   - By default it uses `:queued` strategy;
@@ -310,7 +216,7 @@ class RedisQueuedLocks::Client
   #     - `:random` (RANDOM): obtain a lock without checking the positions in the queue
   #       (but with checking the limist, retries, timeouts and so on). if lock is
   #       free to obtain - it will be obtained;
-  #   - pre-configured in `config[:default_access_strategy]`;
+  #   - pre-configured in `config['default_access_strategy']`;
   # @option meta [NilClass,Hash<String|Symbol,Any>]
   #   - A custom metadata wich will be passed to the lock data in addition to the existing data;
   #   - Metadata can not contain reserved lock data keys;
@@ -334,20 +240,20 @@ class RedisQueuedLocks::Client
   #      and moved from the lock queue after the error moment and before the error message build;
   #  - You should consider the async nature of this error message and should use received data
   #    from error message correspondingly;
-  #  - pre-configred in `config[:detailed_acq_timeout_error]`;
+  #  - pre-configred in `config['detailed_acq_timeout_error']`;
   # @option logger [::Logger,#debug]
-  #   - Logger object used from the configuration layer (see config[:logger]);
+  #   - Logger object used from the configuration layer (see config['logger']);
   #   - See `RedisQueuedLocks::Logging::VoidLogger` for example;
   #   - Supports `SemanticLogger::Logger` (see "semantic_logger" gem)
   # @option log_lock_try [Boolean]
   #   - should be logged the each try of lock acquiring (a lot of logs can
   #     be generated depending on your retry configurations);
-  #   - see `config[:log_lock_try]`;
+  #   - see `config['log_lock_try']`;
   # @option instrumenter [#notify]
   #   - Custom instrumenter that will be invoked via #notify method with `event` and `payload` data;
   #   - See RedisQueuedLocks::Instrument::ActiveSupport for examples and implementation details;
   #   - See [Instrumentation](#instrumentation) section of docs;
-  #   - pre-configured in `config[:isntrumenter]` with void notifier
+  #   - pre-configured in `config['isntrumenter']` with void notifier
   #     (`RedisQueuedLocks::Instrumenter::VoidNotifier`);
   # @option instrument [NilClass,Any]
   #   - Custom instrumentation data wich will be passed to the instrumenter's payload
@@ -355,15 +261,15 @@ class RedisQueuedLocks::Client
   # @option 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']>;
   # @option 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;
   # @option 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
@@ -376,15 +282,16 @@ class RedisQueuedLocks::Client
   #   - 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']>;
   # @option 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;
   # @option 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
@@ -396,45 +303,46 @@ class RedisQueuedLocks::Client
   #   - makes sense when instrumentation sampling is enabled;
   # @param block [Block]
   #   A block of code that should be executed after the successfully acquired lock.
-  # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>,yield]
+  # @return [Hash<Symbol,Any>,yield]
   #   - Format: { ok: true/false, result: Symbol/Hash }.
   #   - If block is given the result of block's yeld will be returned.
   #
   # @api public
   # @since 1.0.0
-  # @version 1.8.0
+  # @version 1.13.0
   # rubocop:disable Metrics/MethodLength
   def lock(
     lock_name,
-    ttl: config[:default_lock_ttl],
-    queue_ttl: config[:default_queue_ttl],
-    timeout: config[:try_to_lock_timeout],
-    timed: config[:is_timed_by_default],
-    retry_count: config[:retry_count],
-    retry_delay: config[:retry_delay],
-    retry_jitter: config[:retry_jitter],
+    ttl: config['default_lock_ttl'], # steep:ignore
+    queue_ttl: config['default_queue_ttl'], # steep:ignore
+    timeout: config['try_to_lock_timeout'], # steep:ignore
+    timed: config['is_timed_by_default'], # steep:ignore
+    retry_count: config['retry_count'], # steep:ignore
+    retry_delay: config['retry_delay'], # steep:ignore
+    retry_jitter: config['retry_jitter'], # steep:ignore
     raise_errors: false,
     fail_fast: false,
-    conflict_strategy: config[:default_conflict_strategy],
-    access_strategy: config[:default_access_strategy],
+    conflict_strategy: config['default_conflict_strategy'], # steep:ignore
+    read_write_mode: :write,
+    access_strategy: config['default_access_strategy'], # steep:ignore
     identity: uniq_identity,
     meta: nil,
-    detailed_acq_timeout_error: config[:detailed_acq_timeout_error],
-    logger: config[:logger],
-    log_lock_try: config[:log_lock_try],
-    instrumenter: config[:instrumenter],
+    detailed_acq_timeout_error: config['detailed_acq_timeout_error'], # steep:ignore
+    logger: config['logger'], # steep:ignore
+    log_lock_try: config['log_lock_try'], # steep:ignore
+    instrumenter: config['instrumenter'], # steep:ignore
     instrument: nil,
-    log_sampling_enabled: config[:log_sampling_enabled],
-    log_sampling_percent: config[:log_sampling_percent],
-    log_sampler: config[:log_sampler],
+    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],
-    instr_sampling_percent: config[:instr_sampling_percent],
-    instr_sampler: config[:instr_sampler],
+    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,
     &block
   )
-    RedisQueuedLocks::Acquier::AcquireLock.acquire_lock(
+    RedisQueuedLocks::Acquirer::AcquireLock.acquire_lock(
       redis_client,
       lock_name,
       process_id: RedisQueuedLocks::Resource.get_process_id,
@@ -453,6 +361,7 @@ class RedisQueuedLocks::Client
       identity:,
       fail_fast:,
       conflict_strategy:,
+      read_write_mode:,
       access_strategy:,
       meta:,
       detailed_acq_timeout_error:,
@@ -476,34 +385,35 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.8.0
+  # @version 1.13.0
   # rubocop:disable Metrics/MethodLength
   def lock!(
     lock_name,
-    ttl: config[:default_lock_ttl],
-    queue_ttl: config[:default_queue_ttl],
-    timeout: config[:try_to_lock_timeout],
-    timed: config[:is_timed_by_default],
-    retry_count: config[:retry_count],
-    retry_delay: config[:retry_delay],
-    retry_jitter: config[:retry_jitter],
+    ttl: config['default_lock_ttl'], # steep:ignore
+    queue_ttl: config['default_queue_ttl'], # steep:ignore
+    timeout: config['try_to_lock_timeout'], # steep:ignore
+    timed: config['is_timed_by_default'], # steep:ignore
+    retry_count: config['retry_count'], # steep:ignore
+    retry_delay: config['retry_delay'], # steep:ignore
+    retry_jitter: config['retry_jitter'], # steep:ignore
     fail_fast: false,
-    conflict_strategy: config[:default_conflict_strategy],
-    access_strategy: config[:default_access_strategy],
+    conflict_strategy: config['default_conflict_strategy'], # steep:ignore
+    read_write_mode: :write,
+    access_strategy: config['default_access_strategy'], # steep:ignore
     identity: uniq_identity,
-    instrumenter: config[:instrumenter],
+    instrumenter: config['instrumenter'], # steep:ignore
     meta: nil,
-    detailed_acq_timeout_error: config[:detailed_acq_timeout_error],
-    logger: config[:logger],
-    log_lock_try: config[:log_lock_try],
+    detailed_acq_timeout_error: config['detailed_acq_timeout_error'], # steep:ignore
+    logger: config['logger'], # steep:ignore
+    log_lock_try: config['log_lock_try'], # steep:ignore
     instrument: nil,
-    log_sampling_enabled: config[:log_sampling_enabled],
-    log_sampling_percent: config[:log_sampling_percent],
-    log_sampler: config[:log_sampler],
+    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],
-    instr_sampling_percent: config[:instr_sampling_percent],
-    instr_sampler: config[:instr_sampler],
+    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,
     &block
   )
@@ -526,6 +436,7 @@ class RedisQueuedLocks::Client
       instrument:,
       instrumenter:,
       conflict_strategy:,
+      read_write_mode:,
       access_strategy:,
       log_sampling_enabled:,
       log_sampling_percent:,
@@ -552,7 +463,7 @@ class RedisQueuedLocks::Client
   # @option instr_sampling_percent [Integer]
   # @option instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
   # @option instr_sample_this [Boolean]
-  # @return [RedisQueuedLocks::Data, Hash<Symbol,Any>]
+  # @return [Hash<Symbol,Any>]
   #   Format: {
   #     ok: true/false,
   #     result: {
@@ -569,19 +480,19 @@ class RedisQueuedLocks::Client
   # @version 1.6.0
   def unlock(
     lock_name,
-    logger: config[:logger],
-    instrumenter: config[:instrumenter],
+    logger: config['logger'], # steep:ignore
+    instrumenter: config['instrumenter'], # steep:ignore
     instrument: nil,
-    log_sampling_enabled: config[:log_sampling_enabled],
-    log_sampling_percent: config[:log_sampling_percent],
-    log_sampler: config[:log_sampler],
+    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],
-    instr_sampling_percent: config[:instr_sampling_percent],
-    instr_sampler: config[:instr_sampler],
+    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::Acquier::ReleaseLock.release_lock(
+    RedisQueuedLocks::Acquirer::ReleaseLock.release_lock(
       redis_client,
       lock_name,
       instrumenter,
@@ -604,7 +515,7 @@ class RedisQueuedLocks::Client
   # @api public
   # @since 1.0.0
   def locked?(lock_name)
-    RedisQueuedLocks::Acquier::IsLocked.locked?(redis_client, lock_name)
+    RedisQueuedLocks::Acquirer::IsLocked.locked?(redis_client, lock_name)
   end
 
   # @param lock_name [String]
@@ -613,7 +524,7 @@ class RedisQueuedLocks::Client
   # @api public
   # @since 1.0.0
   def queued?(lock_name)
-    RedisQueuedLocks::Acquier::IsQueued.queued?(redis_client, lock_name)
+    RedisQueuedLocks::Acquirer::IsQueued.queued?(redis_client, lock_name)
   end
 
   # @param lock_name [String]
@@ -622,7 +533,7 @@ class RedisQueuedLocks::Client
   # @api public
   # @since 1.0.0
   def lock_info(lock_name)
-    RedisQueuedLocks::Acquier::LockInfo.lock_info(redis_client, lock_name)
+    RedisQueuedLocks::Acquirer::LockInfo.lock_info(redis_client, lock_name)
   end
 
   # @param lock_name [String]
@@ -631,7 +542,7 @@ class RedisQueuedLocks::Client
   # @api public
   # @since 1.0.0
   def queue_info(lock_name)
-    RedisQueuedLocks::Acquier::QueueInfo.queue_info(redis_client, lock_name)
+    RedisQueuedLocks::Acquirer::QueueInfo.queue_info(redis_client, lock_name)
   end
 
   # Retrun the current acquirer identifier.
@@ -640,10 +551,10 @@ class RedisQueuedLocks::Client
   # @option thread_id [Integer,Any] Thread identifier.
   # @option fiber_id [Integer,Any] Fiber identifier.
   # @option ractor_id [Integer,Any] Ractor identifier.
-  # @option identity [String] Unique per-process string. See `config[:uniq_identifier]`.
+  # @option identity [String] Unique per-process string. See `config['uniq_identifier']`.
   # @return [String]
   #
-  # @see RedisQueuedLocks::Resource.acquier_identifier
+  # @see RedisQueuedLocks::Resource.acquirer_identifier
   # @see RedisQueuedLocks::Resource.get_process_id
   # @see RedisQueuedLocks::Resource.get_thread_id
   # @see RedisQueuedLocks::Resource.get_fiber_id
@@ -652,14 +563,14 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.8.0
-  def current_acquier_id(
+  def current_acquirer_id(
     process_id: RedisQueuedLocks::Resource.get_process_id,
     thread_id: RedisQueuedLocks::Resource.get_thread_id,
     fiber_id: RedisQueuedLocks::Resource.get_fiber_id,
     ractor_id: RedisQueuedLocks::Resource.get_ractor_id,
     identity: uniq_identity
   )
-    RedisQueuedLocks::Resource.acquier_identifier(
+    RedisQueuedLocks::Resource.acquirer_identifier(
       process_id,
       thread_id,
       fiber_id,
@@ -667,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.
   #
@@ -674,7 +587,7 @@ class RedisQueuedLocks::Client
   # @option thread_id [Integer,Any] Thread identifier.
   # @option fiber_id [Integer,Any] Fiber identifier.
   # @option ractor_id [Integer,Any] Ractor identifier.
-  # @option identity [String] Unique per-process string. See `config[:uniq_identifier]`.
+  # @option identity [String] Unique per-process string. See `config['uniq_identifier']`.
   # @return [String]
   #
   # @see RedisQueuedLocks::Resource.host_identifier
@@ -698,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.
   #
@@ -724,7 +639,7 @@ class RedisQueuedLocks::Client
   # @param lock_name [String]
   # @param milliseconds [Integer] How many milliseconds should be added.
   # @option logger [::Logger,#debug]
-  # @option instrumenter [#notify] See `config[:instrumenter]` docs for details.
+  # @option instrumenter [#notify] See `config['instrumenter']` docs for details.
   # @option instrument [NilClass,Any]
   # @option log_sampling_enabled [Boolean]
   # @option log_sampling_percent [Integer]
@@ -744,19 +659,19 @@ class RedisQueuedLocks::Client
   def extend_lock_ttl(
     lock_name,
     milliseconds,
-    logger: config[:logger],
-    instrumenter: config[:instrumenter],
+    logger: config['logger'], # steep:ignore
+    instrumenter: config['instrumenter'], # steep:ignore
     instrument: nil,
-    log_sampling_enabled: config[:log_sampling_enabled],
-    log_sampling_percent: config[:log_sampling_percent],
-    log_sampler: config[:log_sampler],
+    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],
-    instr_sampling_percent: config[:instr_sampling_percent],
-    instr_sampler: config[:instr_sampler],
+    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::Acquier::ExtendLockTTL.extend_lock_ttl(
+    RedisQueuedLocks::Acquirer::ExtendLockTTL.extend_lock_ttl(
       redis_client,
       lock_name,
       milliseconds,
@@ -781,7 +696,7 @@ class RedisQueuedLocks::Client
   #
   # @option batch_size [Integer]
   # @option logger [::Logger,#debug]
-  # @option instrumenter [#notify] See `config[:instrumenter]` docs for details.
+  # @option instrumenter [#notify] See `config['instrumenter']` docs for details.
   # @option instrument [NilClass,Any]
   # @option log_sampling_enabled [Boolean]
   # @option log_sampling_percent [Integer]
@@ -791,27 +706,27 @@ class RedisQueuedLocks::Client
   # @option instr_sampling_percent [Integer]
   # @option instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
   # @option instr_sample_this [Boolean]
-  # @return [RedisQueuedLocks::Data,Hash<Symbol,Boolean|Hash<Symbol,Numeric>>]
+  # @return [Hash<Symbol,Boolean|Hash<Symbol,Numeric>>]
   #   Example: { ok: true, result { rel_key_cnt: 100, rel_time: 0.01 } }
   #
   # @api public
   # @since 1.0.0
   # @version 1.6.0
   def clear_locks(
-    batch_size: config[:lock_release_batch_size],
-    logger: config[:logger],
-    instrumenter: config[:instrumenter],
+    batch_size: config['lock_release_batch_size'], # steep:ignore
+    logger: config['logger'], # steep:ignore
+    instrumenter: config['instrumenter'], # steep:ignore
     instrument: nil,
-    log_sampling_enabled: config[:log_sampling_enabled],
-    log_sampling_percent: config[:log_sampling_percent],
-    log_sampler: config[:log_sampler],
+    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],
-    instr_sampling_percent: config[:instr_sampling_percent],
-    instr_sampler: config[:instr_sampler],
+    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::Acquier::ReleaseAllLocks.release_all_locks(
+    RedisQueuedLocks::Acquirer::ReleaseAllLocks.release_all_locks(
       redis_client,
       batch_size,
       logger,
@@ -829,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]
@@ -848,8 +911,8 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  def locks(scan_size: config[:key_extraction_batch_size], with_info: false)
-    RedisQueuedLocks::Acquier::Locks.locks(redis_client, scan_size:, with_info:)
+  def locks(scan_size: config['key_extraction_batch_size'], with_info: false) # steep:ignore
+    RedisQueuedLocks::Acquirer::Locks.locks(redis_client, scan_size:, with_info:)
   end
 
   # Extracts lock keys with their info. See #locks(with_info: true) for details.
@@ -859,7 +922,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  def locks_info(scan_size: config[:key_extraction_batch_size])
+  def locks_info(scan_size: config['key_extraction_batch_size']) # steep:ignore
     locks(scan_size:, with_info: true)
   end
 
@@ -879,8 +942,8 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  def queues(scan_size: config[:key_extraction_batch_size], with_info: false)
-    RedisQueuedLocks::Acquier::Queues.queues(redis_client, scan_size:, with_info:)
+  def queues(scan_size: config['key_extraction_batch_size'], with_info: false) # steep:ignore
+    RedisQueuedLocks::Acquirer::Queues.queues(redis_client, scan_size:, with_info:)
   end
 
   # Extracts lock queues with their info. See #queues(with_info: true) for details.
@@ -890,7 +953,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  def queues_info(scan_size: config[:key_extraction_batch_size])
+  def queues_info(scan_size: config['key_extraction_batch_size']) # steep:ignore
     queues(scan_size:, with_info: true)
   end
 
@@ -899,17 +962,17 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  def keys(scan_size: config[:key_extraction_batch_size])
-    RedisQueuedLocks::Acquier::Keys.keys(redis_client, scan_size:)
+  def keys(scan_size: config['key_extraction_batch_size']) # steep:ignore
+    RedisQueuedLocks::Acquirer::Keys.keys(redis_client, scan_size:)
   end
 
   # @option dead_ttl [Integer]
   #   - the time period (in millsiecnds) after whcih the lock request is
   #     considered as dead;
-  #   - `config[:dead_request_ttl]` is used by default;
+  #   - `config['dead_request_ttl']` is used by default;
   # @option scan_size [Integer]
   #   - the batch of scanned keys for Redis'es SCAN command;
-  #   - `config[:lock_release_batch_size]` is used by default;
+  #   - `config['lock_release_batch_size']` is used by default;
   # @option logger [::Logger,#debug]
   # @option instrumenter [#notify]
   # @option instrument [NilClass,Any]
@@ -928,21 +991,21 @@ class RedisQueuedLocks::Client
   # @since 1.0.0
   # @version 1.6.0
   def clear_dead_requests(
-    dead_ttl: config[:dead_request_ttl],
-    scan_size: config[:lock_release_batch_size],
-    logger: config[:logger],
-    instrumenter: config[:instrumenter],
+    dead_ttl: config['dead_request_ttl'], # steep:ignore
+    scan_size: config['lock_release_batch_size'], # steep:ignore
+    logger: config['logger'], # steep:ignore
+    instrumenter: config['instrumenter'], # steep:ignore
     instrument: nil,
-    log_sampling_enabled: config[:log_sampling_enabled],
-    log_sampling_percent: config[:log_sampling_percent],
-    log_sampler: config[:log_sampler],
+    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],
-    instr_sampling_percent: config[:instr_sampling_percent],
-    instr_sampler: config[:instr_sampler],
+    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::Acquier::ClearDeadRequests.clear_dead_requests(
+    RedisQueuedLocks::Acquirer::ClearDeadRequests.clear_dead_requests(
       redis_client,
       scan_size,
       dead_ttl,