redis_queued_locks 1.12.1 → 1.14.0

data/README.md

@@ -1,8 +1,10 @@
-# RedisQueuedLocks · ![Gem Version](https://img.shields.io/gem/v/redis_queued_locks) ![build](https://github.com/0exp/redis_queued_locks/actions/workflows/build.yml/badge.svg??branch=master)
+# RedisQueuedLocks · ![Gem Version](https://img.shields.io/gem/v/redis_queued_locks)
 
-<a href="https://redis.io/docs/manual/patterns/distributed-locks/">Distributed locks</a> with "prioritized lock acquisition queue" capabilities based on the Redis Database.
+[![Tests (RSpec)](https://github.com/0exp/redis_queued_locks/actions/workflows/tests.yml/badge.svg?branch=master)](https://github.com/0exp/redis_queued_locks/actions) [![Lint (Rubocop)](https://github.com/0exp/redis_queued_locks/actions/workflows/lint.yml/badge.svg?branch=master)](https://github.com/0exp/redis_queued_locks/actions) [![TypeCheck (Runtime/RBS)](https://github.com/0exp/redis_queued_locks/actions/workflows/typecheck-runtime.yml/badge.svg?branch=master)](https://github.com/0exp/redis_queued_locks/actions) [![TypeCheck (Static/Steep)](https://github.com/0exp/redis_queued_locks/actions/workflows/typecheck-static.yml/badge.svg?branch=master)](https://github.com/0exp/redis_queued_locks/actions)
 
-Each lock request is put into the request queue (each lock is hosted by it's own queue separately from other queues) and processed in order of their priority (FIFO). Each lock request lives some period of time (RTTL) (with requeue capabilities) which guarantees the request queue will never be stacked.
+<a href="https://redis.io/docs/latest/develop/clients/patterns/distributed-locks/">Distributed locks</a> with "prioritized lock acquisition queue" capabilities based on the Redis Database.
+
+Each lock request is put into the request queue (each lock is hosted by its own queue separately from other queues) and processed in order of their priority (FIFO). Each lock request lives some period of time (RTTL) (with requeue capabilities) which guarantees the request queue will never be stacked.
 
 In addition to the classic `queued` (FIFO) strategy RQL supports `random` (RANDOM) lock obtaining strategy when any acquirer from the lock queue can obtain the lock regardless the position in the queue.
 
@@ -25,8 +27,10 @@ Provides flexible invocation flow, parametrized limits (lock request ttl, lock t
   - [queue_info](#queue_info)
   - [locked?](#locked)
   - [queued?](#queued)
-  - [unlock](#unlock---release-a-lock)
-  - [clear_locks](#clear_locks---release-all-locks-and-lock-queues)
+  - [unlock](#unlock---release-a-lock) (aka `release_lock`)
+  - [clear_locks](#clear_locks---release-all-locks-and-lock-queues) (aka `release_locks`)
+  - [clear_locks_of](#clear_locks_of) (aka `release_locks_of`)
+  - [clear_current_locks](#clear_current_locks) (aka `release_current_locks`)
   - [extend_lock_ttl](#extend_lock_ttl)
   - [locks](#locks---get-list-of-obtained-locks)
   - [queues](#queues---get-list-of-lock-request-queues)
@@ -50,7 +54,7 @@ Provides flexible invocation flow, parametrized limits (lock request ttl, lock t
   - [zombies_info](#zombies_info)
   - [zombie_locks](#zombie_locks)
   - [zombie_hosts](#zombie_hosts)
-  - [zombie_acquiers](#zombie_acquiers)
+  - [zombie_acquirers](#zombie_acquirers)
 - [Lock Access Strategies](#lock-access-strategies)
   - [queued](#lock-access-strategies)
   - [random](#lock-access-strategies)
@@ -60,7 +64,16 @@ Provides flexible invocation flow, parametrized limits (lock request ttl, lock t
 - [Instrumentation](#instrumentation)
   - [Instrumentation Configuration](#instrumentation-configuration)
   - [Instrumentation Events](#instrumentation-events)
+    - ["redis_queued_locks.lock_obtained"](#redis_queued_lockslock_hold_and_release)
+    - ["redis_queued_locks.extendable_reentrant_lock_obtained"](#redis_queued_locksextendable_reentrant_lock_obtained)
+    - ["redis_queued_locks.reentrant_lock_obtained"](#redis_queued_locksreentrant_lock_obtained)
+    - ["redis_queued_locks.lock_hold_and_release"](#redis_queued_lockslock_hold_and_release)
+    - ["redis_queued_locks.reentrant_lock_hold_completes"](#redis_queued_locksreentrant_lock_hold_completes)
+    - ["redis_queued_locks.explicit_lock_release"](#redis_queued_locksexplicit_lock_release)
+    - ["redis_queued_locks.explicit_all_locks_release"](#redis_queued_locksexplicit_all_locks_release)
+    - ["redis_queued_locks.release_locks_of"](#redis_queued_locksrelease_locks_of)
 - [Roadmap](#roadmap)
+- [Build and Develop](#build-and-develop)
 - [Contributing](#contributing)
 - [License](#license)
 - [Authors](#authors)
@@ -149,32 +162,32 @@ rq_lock_client.lock("some-lock") { puts "Hello, lock!" }
 ```ruby
 redis_client = RedisClient.config.new_pool # NOTE: provide your own RedisClient instance
 
-clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
+client = RedisQueuedLocks::Client.new(redis_client) do |config|
   # (default: 3) (supports nil)
   # - nil means "infinite retries" and you are only limited by the "try_to_lock_timeout" config;
-  config.retry_count = 3
+  config['retry_count'] = 3
 
   # (milliseconds) (default: 200)
-  config.retry_delay = 200
+  config['retry_delay'] = 200
 
   # (milliseconds) (default: 25)
-  config.retry_jitter = 25
+  config['retry_jitter'] = 25
 
   # (seconds) (supports nil)
   # - nil means "no timeout" and you are only limited by "retry_count" config;
-  config.try_to_lock_timeout = 10
+  config['try_to_lock_timeout'] = 10
 
   # (milliseconds) (default: 5_000)
   # - lock's time to live
-  config.default_lock_ttl = 5_000
+  config['default_lock_ttl'] = 5_000
 
   # (seconds) (default: 15)
   # - lock request timeout. after this timeout your lock request in queue will be requeued with new position (at the end of the queue);
-  config.default_queue_ttl = 15
+  config['default_queue_ttl'] = 15
 
   # (boolean) (default: false)
   # - should be all blocks of code are timed by default;
-  config.is_timed_by_default = false
+  config['is_timed_by_default'] = false
 
   # (boolean) (default: false)
   # - When the lock acquirement try reached the acquirement time limit (:timeout option) the
@@ -197,7 +210,7 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   #     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;
-  config.detailed_acq_timeout_error = false
+  config['detailed_acq_timeout_error'] = false
 
   # (symbol) (default: :queued)
   # - Defines the way in which the lock should be obitained;
@@ -208,7 +221,7 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   #   - `:queued` (FIFO): the classic queued behavior (default), your lock will be obitaned if you are first in queue and the required lock is free;
   #   - `: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;
-  config.default_access_strategy = :queued
+  config['default_access_strategy'] = :queued
 
   # (symbol) (default: :wait_for_lock)
   # - Global default conflict strategy mode;
@@ -221,24 +234,35 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   #   - `: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;
-  # - See "Dead locks and Reentrant Locks" documentation section in REDME.md for details;
-  config.default_conflict_strategy = :wait_for_lock
+  # - See "Dead locks and Reentrant Locks" documentation section in README.md for details;
+  config['default_conflict_strategy'] = :wait_for_lock
 
   # (default: 100)
   # - how many items will be released at a time in #clear_locks and in #clear_dead_requests (uses SCAN);
   # - affects the performance of your Redis and Ruby Application (configure thoughtfully);
-  config.lock_release_batch_size = 100
+  config['lock_release_batch_size'] = 100
+
+  # (default: 300)
+  # - how many items will be released at a time in #clear_locks_of and in #clear_current_locks methods (uses SCAN for batch extraction and DEL for batch deletion);
+  # - affects the ruby's memory (cuz this batch will be stored in Set object in first, and then will be splatted to the DEL redis method invocation) (configure thoughtfully);
+  # - affects the performance of your Redis (configure thoughtfully);
+  config['clear_locks_of__lock_scan_size'] = 300
+
+  # (default: 300)
+  # - how many queues will be SCAN'ned at a time in #clear_locks_of and in #clear_current_locks methods (uses SCAN);
+  # - affects the performance of your Redis (configure thoughtfully);
+  config['clear_locks_of__queue_scan_size'] = 300
 
   # (default: 500)
   # - how many items should be extracted from redis during the #locks, #queues, #keys
   #   #locks_info, and #queues_info operations (uses SCAN);
-  # - affects the performance of your Redis and Ruby Application (configure thoughtfully;)
-  config.key_extraction_batch_size = 500
+  # - affects the performance of your Redis and Ruby Application (configure thoughtfully);
+  config['key_extraction_batch_size'] = 500
 
   # (default: 1 day)
   # - the default period of time (in milliseconds) after which a lock request is considered dead;
   # - used for `#clear_dead_requests` as default vaule of `:dead_ttl` option;
-  config.dead_request_ttl = (1 * 24 * 60 * 60 * 1000) # one day in milliseconds
+  config['dead_request_ttl'] = (1 * 24 * 60 * 60 * 1000) # one day in milliseconds
 
   # (default: RedisQueuedLocks::Instrument::VoidNotifier)
   # - instrumentation layer;
@@ -246,16 +270,16 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   #   - event: <string> requried;
   #   - payload: <hash> requried;
   # - disabled by default via `VoidNotifier`;
-  config.instrumenter = RedisQueuedLocks::Instrument::ActiveSupport
+  config['instrumenter'] = RedisQueuedLocks::Instrument::ActiveSupport
 
   # (default: -> { RedisQueuedLocks::Resource.calc_uniq_identity })
   # - uniqude idenfitier that is uniq per process/pod;
   # - prevents potential lock-acquirement collisions bettween different process/pods
-  #   that have identical process_id/thread_id/fiber_id/ractor_id (identivcal acquier ids);
+  #   that have identical process_id/thread_id/fiber_id/ractor_id (identivcal acquirer ids);
   # - it is calculated once per `RedisQueudLocks::Client` instance;
   # - expects the proc object;
   # - `SecureRandom.hex(8)` by default;
-  config.uniq_identifier = -> { RedisQueuedLocks::Resource.calc_uniq_identity }
+  config['uniq_identifier'] = -> { RedisQueuedLocks::Resource.calc_uniq_identity }
 
   # (default: RedisQueuedLocks::Logging::VoidLogger)
   # - the logger object;
@@ -264,7 +288,7 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   # - at this moment the only debug logs are realised in following cases:
   #   - "[redis_queued_locks.start_lock_obtaining]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
   #   - "[redis_queued_locks.start_try_to_lock_cycle]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
-  #   - "[redis_queued_locks.dead_score_reached__reset_acquier_position]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
+  #   - "[redis_queued_locks.dead_score_reached__reset_acquirer_position]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
   #   - "[redis_queued_locks.lock_obtained]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acq_time", "acs_strat");
   #   - "[redis_queued_locks.extendable_reentrant_lock_obtained]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acq_time", "acs_strat");
   #   - "[redis_queued_locks.reentrant_lock_obtained]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acq_time", "acs_strat");
@@ -272,7 +296,7 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   #   - "[redis_queued_locks.expire_lock]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
   #   - "[redis_queued_locks.decrease_lock]" (logs "lock_key", "decreased_ttl", "queue_ttl", "acq_id", "hst_id", "acs_strat");
   # - by default uses VoidLogger that does nothing;
-  config.logger = RedisQueuedLocks::Logging::VoidLogger
+  config['logger'] = RedisQueuedLocks::Logging::VoidLogger
 
   # (default: false)
   # - adds additional debug logs;
@@ -291,49 +315,49 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   #   - "[redis_queued_locks.try_lock.exit__no_first]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat", "first_acq_id_in_queue", "<current_lock_data>");
   #   - "[redis_queued_locks.try_lock.exit__lock_still_obtained]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat", "first_acq_id_in_queue", "locked_by_acq_id", "<current_lock_data>");
   #   - "[redis_queued_locks.try_lock.obtain__free_to_acquire]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
-  config.log_lock_try = false
+  config['log_lock_try'] = false
 
   # (default: false)
   # - 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> configs;
-  config.log_sampling_enabled = false
+  # - works in tandem with <config['log_sampling_percent']> and <config['log_sampler']> configs;
+  config['log_sampling_enabled'] = false
 
   # (default: 15)
   # - 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;
-  config.log_sampling_percent = 15
+  # - take an effect when <config['log_sampling_enalbed']> is true;
+  # - works in tandem with <config['log_sampling_enabled']> and <config['log_sampler']> configs;
+  config['log_sampling_percent'] = 15
 
   # (default: 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
   #   `sampling_happened?(percent) => boolean` interface (see `RedisQueuedLocks::Logging::Sampler` for example);
-  config.log_sampler = RedisQueuedLocks::Logging::Sampler
+  config['log_sampler'] = RedisQueuedLocks::Logging::Sampler
 
   # (default: false)
   # - 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>;
-  config.instr_sampling_enabled = false
+  # - works in tandem with <config['instr_sampling_percent'] and <config['instr_sampler']>;
+  config['nstr_sampling_enabled'] = false
 
   # (default: 15)
   # - 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;
-  config.instr_sampling_percent = 15
+  # - take an effect when <config['instr_sampling_enalbed']> is true;
+  # - works in tandem with <config['instr_sampling_enabled']> and <config['instr_sampler']> configs;
+  config['instr_sampling_percent'] = 15
 
   # (default: 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
   #   `sampling_happened?(percent) => boolean` interface (see `RedisQueuedLocks::Instrument::Sampler` for example);
-  config.instr_sampler = RedisQueuedLocks::Instrument::Sampler
+  config['instr_sampler'] = RedisQueuedLocks::Instrument::Sampler
 end
 ```
 
@@ -375,36 +399,36 @@ end
   - the block's result will be returned;
 - If block is not passed:
   - the obtained lock will be released after lock's ttl;
-  - the lock information will be returned (hash with technical info that contains: lock key, acquier identifier, acquirement timestamp, lock's ttl, type of obtaining process, etc);
+  - the lock information will be returned (hash with technical info that contains: lock key, acquirer identifier, acquirement timestamp, lock's ttl, type of obtaining process, etc);
 
 ```ruby
 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'],
+  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'],
   raise_errors: false,
   fail_fast: false,
-  conflict_strategy: config[:default_conflict_strategy],
-  access_strategy: config[:default_access_strategy],
-  identity: uniq_identity, # (attr_accessor) calculated during client instantiation via config[:uniq_identifier] proc;
+  conflict_strategy: config['default_conflict_strategy'],
+  access_strategy: config['default_access_strategy'],
+  identity: uniq_identity, # (attr_accessor) calculated during client instantiation via config['uniq_identifier'] proc;
   meta: nil,
-  detailed_acq_timeout_error: config[:detailed_acq_timeout_error],
+  detailed_acq_timeout_error: config['detailed_acq_timeout_error'],
   instrument: nil,
-  instrumenter: config[:instrumenter],
-  logger: config[:logger],
-  log_lock_try: config[:log_lock_try],
-  log_sampling_enabled: config[:log_sampling_enabled],
-  log_sampling_percent: config[:log_sampling_percent],
-  log_sampler: config[:log_sampler],
+  instrumenter: config['instrumenter'],
+  logger: config['logger'],
+  log_lock_try: config['log_lock_try'],
+  log_sampling_enabled: config['log_sampling_enabled'],
+  log_sampling_percent: config['log_sampling_percent'],
+  log_sampler: config['log_sampler'],
   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'],
+  instr_sampling_percent: config['instr_sampling_percent'],
+  instr_sampler: config['instr_sampler'],
   instr_sample_this: false,
   &block
 )
@@ -414,30 +438,30 @@ def lock(
   - Lock name to be obtained.
 - `ttl` - (optional) - [Integer]
   - Lock's time to live (in milliseconds);
-  - pre-configured in `config[:default_lock_ttl]`;
+  - pre-configured in `config['default_lock_ttl']`;
 - `queue_ttl` - (optional) `[Integer]`
   - Lifetime of the acuier's lock request. In seconds.
-  - pre-configured in `config[:default_queue_ttl]`;
+  - pre-configured in `config['default_queue_ttl']`;
 - `timeout` - (optional) `[Integer,NilClass]`
   - Time period a client should try to acquire the lock (in seconds). Nil means "without timeout".
-  - pre-configured in `config[:try_to_lock_timeout]`;
+  - pre-configured in `config['try_to_lock_timeout']`;
 - `timed` - (optiona) `[Boolean]`
   - Limit the invocation time period of the passed block of code by the lock's TTL.
-  - pre-configured in `config[:is_timed_by_default]`;
+  - pre-configured in `config['is_timed_by_default']`;
   - `false` by default;
 - `retry_count` - (optional) `[Integer,NilClass]`
   - How many times we should try to acquire a lock. Nil means "infinite retries".
-  - pre-configured in `config[:retry_count]`;
+  - pre-configured in `config['retry_count']`;
 - `retry_delay` - (optional) `[Integer]`
   - A time-interval between the each retry (in milliseconds).
-  - pre-configured in `config[:retry_delay]`;
+  - pre-configured in `config['retry_delay']`;
 - `retry_jitter` - (optional) `[Integer]`
   - Time-shift range for retry-delay (in milliseconds);
-  - pre-configured in `config[:retry_jitter]`;
+  - pre-configured in `config['retry_jitter']`;
 - `instrumenter` - (optional) `[#notify]`
   - See RedisQueuedLocks::Instrument::ActiveSupport for example;
   - See [Instrumentation](#instrumentation) section of docs;
-  - pre-configured in `config[:isntrumenter]` with void notifier (`RedisQueuedLocks::Instrumenter::VoidNotifier`);
+  - pre-configured in `config['isntrumenter']` with void notifier (`RedisQueuedLocks::Instrumenter::VoidNotifier`);
 - `instrument` - (optional) `[NilClass,Any]`
   - Custom instrumentation data wich will be passed to the instrumenter's payload with :instrument key;
   - `nil` by default (means "no custom instrumentation data");
@@ -457,13 +481,13 @@ def lock(
     - `:queued` (FIFO): (default) the classic queued behavior, your lock will be obitaned if you are first in queue and the required lock is free;
     - `: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']`;
   - See [Lock Access Strategies](#lock-access-strategies) documentation section for details;
 - `conflict_strategy` - (optional) - `[Symbol]`
   - 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']`;
   - Strategies:
     - `: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;
@@ -476,7 +500,7 @@ def lock(
     pods or/and nodes of your application;
   - It is calculated once during `RedisQueuedLock::Client` instantiation and stored in `@uniq_identity`
     ivar (accessed via `uniq_dentity` accessor method);
-  - Identity calculator is pre-configured in `config[:uniq_identifier]`;
+  - Identity calculator is pre-configured in `config['uniq_identifier']`;
 - `meta` - (optional) `[NilClass,Hash<String|Symbol,Any>]`
   - A custom metadata wich will be passed to the lock data in addition to the existing data;
   - Custom metadata can not contain reserved lock data keys (such as `lock_key`, `acq_id`, `ts`, `ini_ttl`, `rem_ttl`);
@@ -499,24 +523,24 @@ def lock(
       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']`;
 - `logger` - (optional) `[::Logger,#debug]`
   - Logger object used for loggin internal mutation oeprations and opertioan results / process progress;
-  - pre-configured in `config[:logger]` with void logger `RedisQueuedLocks::Logging::VoidLogger`;
+  - pre-configured in `config['logger']` with void logger `RedisQueuedLocks::Logging::VoidLogger`;
 - `log_lock_try` - (optional) `[Boolean]`
   - should be logged the each try of lock acquiring (a lot of logs can be generated depending on your retry configurations);
-  - pre-configured in `config[:log_lock_try]`;
+  - pre-configured in `config['log_lock_try']`;
   - `false` by default;
 - `log_sampling_enabled` - (optional) `[Boolean]`
   - enables **log sampling**: only the configured percent of RQL cases will be logged;
   - disabled by default;
   - works in tandem with `log_sampling_percent` and `log_sampler` options;
-  - pre-configured in `config[:log_sampling_enabled]`;
+  - pre-configured in `config['log_sampling_enabled']`;
 - `log_sampling_percent` - (optional) `[Integer]`
   - the percent of cases that should be logged;
   - take an effect when `log_sampling_enalbed` is true;
   - works in tandem with `log_sampling_enabled` and `log_sampler` options;
-  - pre-configured in `config[:log_sampling_percent]`;
+  - pre-configured in `config['log_sampling_percent']`;
 - `log_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]`
   - percent-based log sampler that decides should be RQL case logged or not;
   - works in tandem with `log_sampling_enabled` and `log_sampling_percent` options;
@@ -524,7 +548,7 @@ def lock(
     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);
-  - pre-configured in `config[:log_sampler]`;
+  - pre-configured in `config['log_sampler']`;
 - `log_sample_this` - (optional) `[Boolean]`
   - marks the method that everything should be logged despite the enabled log sampling;
   - makes sense when log sampling is enabled;
@@ -533,12 +557,12 @@ def lock(
   - enables **instrumentaion sampling**: only the configured percent of RQL cases will be instrumented;
   - disabled by default;
   - works in tandem with `instr_sampling_percent` and `instr_sampler` options;
-  - pre-configured in `config[:instr_sampling_enabled]`;
+  - pre-configured in `config['instr_sampling_enabled']`;
 - `instr_sampling_percent` - (optional) `[Integer]`
   - the percent of cases that should be instrumented;
   - take an effect when `instr_sampling_enalbed` is true;
   - works in tandem with `instr_sampling_enabled` and `instr_sampler` options;
-  - pre-configured in `config[:instr_sampling_percent]`;
+  - pre-configured in `config['instr_sampling_percent']`;
 - `instr_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]`
   - percent-based log sampler that decides should be RQL case instrumented or not;
   - works in tandem with `instr_sampling_enabled` and `instr_sampling_percent` options;
@@ -546,7 +570,7 @@ def lock(
     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);
-  - pre-configured in `config[:instr_sampler]`;
+  - pre-configured in `config['instr_sampler']`;
 - `instr_sample_this` - (optional) `[Boolean]`
   - marks the method that everything should be instrumneted despite the enabled instrumentation sampling;
   - makes sense when instrumentation sampling is enabled;
@@ -594,8 +618,8 @@ Return value:
     {
       ok: true,
       result: {
-        lock_key: String, # acquierd lock key ("rql:lock:your_lock_name")
-        acq_id: String, # acquier identifier ("process_id/thread_id/fiber_id/ractor_id/identity")
+        lock_key: String, # acquirerd lock key ("rql:lock:your_lock_name")
+        acq_id: String, # acquirer identifier ("process_id/thread_id/fiber_id/ractor_id/identity")
         hst_id: String, # host identifier ("process_id/thread_id/ractor_id/identity")
         ts: Float, # time (epoch) when lock was obtained (float, Time#to_f)
         ttl: Integer, # lock's time to live in milliseconds (integer)
@@ -733,7 +757,7 @@ rql.lock("my_lock", queue_ttl: 5, timeout: 10_000, retry_count: nil)
 ```
 
 - obtain a lock in `:random` way (with `:random` strategy): in `:random` strategy
-  any acquirer from the lcok queue can obtain the lock regardless of the position in the lock queue;
+  any acquirer from the lock queue can obtain the lock regardless of the position in the lock queue;
 
 ```ruby
 # Current Process (process#1)
@@ -786,37 +810,37 @@ rql.lock('my_lock', retry_delay: 3000, ttl: 3000, access_strategy: :random)
 - `#lock!` - exceptional lock obtaining;
 - fails when (and with):
   - (`RedisQueuedLocks::LockAlreadyObtainedError`) when `fail_fast` is `true` and lock is already obtained;
-  - (`RedisQueuedLocks::LockAcquiermentTimeoutError`) `timeout` limit reached before lock is obtained;
-  - (`RedisQueuedLocks::LockAcquiermentRetryLimitError`) `retry_count` limit reached before lock is obtained;
+  - (`RedisQueuedLocks::LockAcquirementTimeoutError`) `timeout` limit reached before lock is obtained;
+  - (`RedisQueuedLocks::LockAcquirementRetryLimitError`) `retry_count` limit reached before lock is obtained;
   - (`RedisQueuedLocks::ConflictLockObtainError`) when `conflict_strategy: :dead_locking` is used and the "same-process-dead-lock" is happened (see [Deadlocks and Reentrant locks](#deadlocks-and-reentrant-locks) for details);
 
 ```ruby
 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'],
+  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'],
   fail_fast: false,
   identity: uniq_identity,
   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']
+  logger: config['logger'],
+  log_lock_try: config['log_lock_try'],
   instrument: nil,
-  instrumenter: config[:instrumenter],
-  access_strategy: config[:default_access_strategy],
-  conflict_strategy: config[:default_conflict_strategy],
-  log_sampling_enabled: config[:log_sampling_enabled],
-  log_sampling_percent: config[:log_sampling_percent],
-  log_sampler: config[:log_sampler],
+  instrumenter: config['instrumenter'],
+  access_strategy: config['default_access_strategy'],
+  conflict_strategy: config['default_conflict_strategy'],
+  log_sampling_enabled: config['log_sampling_enabled'],
+  log_sampling_percent: config['log_sampling_percent'],
+  log_sampler: config['log_sampler'],
   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'],
+  instr_sampling_percent: config['instr_sampling_percent'],
+  instr_sampler: config['instr_sampler'],
   instr_sample_this: false,
   &block
 )
@@ -834,7 +858,7 @@ See `#lock` method [documentation](#lock---obtain-a-lock).
 - returns `nil` if lock does not exist;
 - lock data (`Hash<String,String|Integer>`):
   - `"lock_key"` - `string` - lock key in redis;
-  - `"acq_id"` - `string` - acquier identifier (process_id/thread_id/fiber_id/ractor_id/identity);
+  - `"acq_id"` - `string` - acquirer identifier (process_id/thread_id/fiber_id/ractor_id/identity);
   - `"hst_id"` - `string` - host identifier (process_id/thread_id/ractor_id/identity);
   - `"ts"` - `numeric`/`epoch` - the time when lock was obtained;
   - `"init_ttl"` - `integer` - (milliseconds) initial lock key ttl;
@@ -885,7 +909,7 @@ rql.lock_info("your_lock_name")
 
 ```ruby
 # <for reentrant locks>
-# (see `conflict_strategy:` kwarg attribute of #lock/#lock! methods and `config.default_conflict_strategy` config)
+# (see `conflict_strategy:` kwarg attribute of #lock/#lock! methods and `config['default_conflict_strategy']` config)
 
 rql.lock("your_lock_name", ttl: 5_000)
 rql.lock("your_lock_name", ttl: 3_000)
@@ -927,12 +951,12 @@ you can receive the lock queue info with empty queue value (an empty array).
 - queue represents the ordered set of lock key reqests:
   - set is ordered by score in ASC manner (inside the Redis Set);
   - score is represented as a timestamp when the lock request was made;
-  - represents the acquier identifier and their score as an array of hashes;
+  - represents the acquirer identifier and their score as an array of hashes;
 - returns `nil` if lock queue does not exist;
 - lock queue data (`Hash<String,String|Array<Hash<String|Numeric>>`):
   - `"lock_queue"` - `string` - lock queue key in redis;
   - `"queue"` - `array` - an array of lock requests (array of hashes):
-    - `"acq_id"` - `string` - acquier identifier (process_id/thread_id/fiber_id/ractor_id/identity by default);
+    - `"acq_id"` - `string` - acquirer identifier (process_id/thread_id/fiber_id/ractor_id/identity by default);
     - `"score"` - `float`/`epoch` - time when the lock request was made (epoch);
 
 ```ruby
@@ -987,35 +1011,35 @@ rql.queued?("your_lock_name") # => true/false
   - `lock_name` - (required) `[String]` - the lock name that should be released.
   - `:logger` - (optional) `[::Logger,#debug]`
     - custom logger object;
-    - pre-configured in `config[:logger]`;
+    - pre-configured in `config['logger']`;
   - `:instrumenter` - (optional) `[#notify]`
     - custom instrumenter object;
-    - pre-configured in `config[:instrumetner]`;
+    - pre-configured in `config['instrumetner']`;
   - `:instrument` - (optional) `[NilClass,Any]`;
     - custom instrumentation data wich will be passed to the instrumenter's payload with :instrument key;
     - `nil` by default (no additional data);
   - `:log_sampling_enabled` - (optional) `[Boolean]`
     - enables **log sampling**;
-    - pre-configured in `config[:log_sampling_enabled]`;
+    - pre-configured in `config['log_sampling_enabled']`;
   - `:log_sampling_percent` - (optional) `[Integer]`
     - **log sampling**:the percent of cases that should be logged;
-    - pre-configured in `config[:log_sampling_percent]`;
+    - pre-configured in `config['log_sampling_percent']`;
   - `:log_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]`
     - **log sampling**: percent-based log sampler that decides should be RQL case logged or not;
-    - pre-configured in `config[:log_sampler]`;
+    - pre-configured in `config['log_sampler']`;
   - `log_sample_this` - (optional) `[Boolean]`
     - marks the method that everything should be logged despite the enabled log sampling;
     - makes sense when log sampling is enabled;
     - `false` by default;
   - `:instr_sampling_enabled` - (optional) `[Boolean]`
     - enables **instrumentaion sampling**;
-    - pre-configured in `config[:instr_sampling_enabled]`;
+    - pre-configured in `config['instr_sampling_enabled']`;
   - `instr_sampling_percent` - (optional) `[Integer]`
     - the percent of cases that should be instrumented;
-    - pre-configured in `config[:instr_sampling_percent]`;
+    - pre-configured in `config['instr_sampling_percent']`;
   - `instr_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]`
     - percent-based log sampler that decides should be RQL case instrumented or not;
-    - pre-configured in `config[:instr_sampler]`;
+    - pre-configured in `config['instr_sampler']`;
   - `instr_sample_this` - (optional) `[Boolean]`
     - marks the method that everything should be instrumneted despite the enabled instrumentation sampling;
     - makes sense when instrumentation sampling is enabled;
@@ -1062,37 +1086,37 @@ rql.unlock("your_lock_name")
 - accepts:
   - `:batch_size` - (optional) `[Integer]`
     - the size of batch of locks and lock queus that should be cleared under the one pipelined redis command at once;
-    - pre-configured in `config[:lock_release_batch_size]`;
+    - pre-configured in `config['lock_release_batch_size']`;
   - `:logger` - (optional) `[::Logger,#debug]`
     - custom logger object;
-    - pre-configured value in `config[:logger]`;
+    - pre-configured value in `config['logger']`;
   - `:instrumenter` - (optional) `[#notify]`
     - custom instrumenter object;
-    - pre-configured value in `config[:isntrumenter]`;
+    - pre-configured value in `config['isntrumenter']`;
   - `:instrument` - (optional) `[NilClass,Any]`
     - custom instrumentation data wich will be passed to the instrumenter's payload with `:instrument` key;
   - `:log_sampling_enabled` - (optional) `[Boolean]`
     - enables **log sampling**;
-    - pre-configured in `config[:log_sampling_enabled]`;
+    - pre-configured in `config['log_sampling_enabled']`;
   - `:log_sampling_percent` - (optional) `[Integer]`
     - **log sampling**:the percent of cases that should be logged;
-    - pre-configured in `config[:log_sampling_percent]`;
+    - pre-configured in `config['log_sampling_percent']`;
   - `:log_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]`
     - **log sampling**: percent-based log sampler that decides should be RQL case logged or not;
-    - pre-configured in `config[:log_sampler]`;
+    - pre-configured in `config['log_sampler']`;
   - `log_sample_this` - (optional) `[Boolean]`
     - marks the method that everything should be logged despite the enabled log sampling;
     - makes sense when log sampling is enabled;
     - `false` by default;
   - `:instr_sampling_enabled` - (optional) `[Boolean]`
     - enables **instrumentaion sampling**;
-    - pre-configured in `config[:instr_sampling_enabled]`;
+    - pre-configured in `config['instr_sampling_enabled']`;
   - `instr_sampling_percent` - (optional) `[Integer]`
     - the percent of cases that should be instrumented;
-    - pre-configured in `config[:instr_sampling_percent]`;
+    - pre-configured in `config['instr_sampling_percent']`;
   - `instr_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]`
     - percent-based log sampler that decides should be RQL case instrumented or not;
-    - pre-configured in `config[:instr_sampler]`;
+    - pre-configured in `config['instr_sampler']`;
   - `instr_sample_this` - (optional) `[Boolean]`
     - marks the method that everything should be instrumneted despite the enabled instrumentation sampling;
     - makes sense when instrumentation sampling is enabled;
@@ -1118,6 +1142,197 @@ rql.clear_locks
 
 ---
 
+#### #clear_locks_of
+
+<sup>\[[back to top](#usage)\]</sup>
+
+- release all locks of the passed acquirer/host and remove this acquirer/host from all queues (locks will be released first)
+- 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);
+- acquirer/host dentifiers can be extracted via:
+  - `#current_host_id`
+  - `#current_acquirer_id`
+  - `#possible_host_ids`
+  - from lock data (extracted via `#lock_info`, `#locks_info`, `#queue_info`, `#queues_info`);
+- produces `"redis_queued_locks.release_locks_of"` instrumentation event;
+- accepts:
+  - `:host_id` - (required) `[String]`
+    - host indentifier whose locks we want to release and which we want to remove from all locks queues;
+  - `:acquirer_id` - (required) `[String]`
+    - acquirer indentifier whose locks we want to release and which we want to remove from all locks queues;
+  - `:lock_scan_size` - (optional) `[Integer]`
+    - how many items will be released at a time (uses `SCAN `for batch extraction and `DEL` for batch deletion);
+    - pre-configuerd value in `config['clear_locks_of__lock_scan_size']`;
+  - `:queue_scan_size` - (optional) `[Integer]`
+    - how many queues will be SCAN'ned at a time (uses `SCAN)`;
+    - pre-configuerd value in `config['clear_locks_of__queue_scan_size']`;
+  - `:logger` - (optional) `[::Logger,#debug]`
+    - custom logger object;
+    - pre-configured value in `config['logger']`;
+  - `:instrumenter` - (optional) `[#notify]`
+    - custom instrumenter object;
+    - pre-configured value in `config['isntrumenter']`;
+  - `:instrument` - (optional) `[NilClass,Any]`
+    - custom instrumentation data wich will be passed to the instrumenter's payload with `:instrument` key;
+  - `:log_sampling_enabled` - (optional) `[Boolean]`
+    - enables **log sampling**;
+    - pre-configured in `config['log_sampling_enabled']`;
+  - `:log_sampling_percent` - (optional) `[Integer]`
+    - **log sampling**:the percent of cases that should be logged;
+    - pre-configured in `config['log_sampling_percent']`;
+  - `:log_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]`
+    - **log sampling**: percent-based log sampler that decides should be RQL case logged or not;
+    - pre-configured in `config['log_sampler']`;
+  - `log_sample_this` - (optional) `[Boolean]`
+    - marks the method that everything should be logged despite the enabled log sampling;
+    - makes sense when log sampling is enabled;
+    - `false` by default;
+  - `:instr_sampling_enabled` - (optional) `[Boolean]`
+    - enables **instrumentaion sampling**;
+    - pre-configured in `config['instr_sampling_enabled']`;
+  - `instr_sampling_percent` - (optional) `[Integer]`
+    - the percent of cases that should be instrumented;
+    - pre-configured in `config['instr_sampling_percent']`;
+  - `instr_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]`
+    - percent-based log sampler that decides should be RQL case instrumented or not;
+    - pre-configured in `config['instr_sampler']`;
+  - `instr_sample_this` - (optional) `[Boolean]`
+    - marks the method that everything should be instrumneted despite the enabled instrumentation sampling;
+    - makes sense when instrumentation sampling is enabled;
+    - `false` by default;
+- returns:
+  - `[Hash<Symbol,Numeric>]` - Format: `{ ok: true, result: Hash<Symbol,Numeric> }`;
+  - result data:
+    - `:rel_time` - `Numeric` - time spent;
+    - `:rel_key_cnt` - `Integer` - the count of released locks;
+    - `:tch_queue_cnt` - `Integer` - the count of touched (modified) queues (the number of queues from which the acquirer/host was removed);
+
+```ruby
+rql.clear_locks_of(
+  host_id: "rql:hst:41478/4320/4360/848818f09d8c3420",
+  acquirer_id: "rql:acq:41478/4320/4340/4360/848818f09d8c3420"
+)
+# -- or (alias) --
+rql.release_locks_of(
+  host_id: "rql:hst:41478/4320/4360/848818f09d8c3420",
+  acquirer_id: "rql:acq:41478/4320/4340/4360/848818f09d8c3420"
+)
+
+# -> result
+{
+  ok: true,
+  result: {
+    rel_key_cnt: 123,
+    tch_queue_cnt: 2,
+    rel_time: 0.1
+  }
+}
+```
+
+```ruby
+# clear locks and queues of the current acquirer:
+rql.clear_locks_of(
+  host_id: rql.current_host_id,
+  acquirer_id: rql.current_acquirer_id
+)
+
+# equivalent:
+rql.clear_current_locks
+
+# -> result
+{
+  ok: true,
+  result: {
+    rel_key_cnt: 43,
+    tch_queue_cnt: 3,
+    rel_time: 0.2
+  }
+}
+```
+
+---
+
+#### #clear_current_locks
+
+<sup>\[[back to top](#usage)\]</sup>
+
+- release all locks of the current acquirer/host and remove the current acquirer/host from all queues (locks will be released first);
+- 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);
+- representes an equivalent invocation:
+  ```ruby
+  rql.clear_locks_of(host_id: rql.current_host_id, acquirer_id: rql.current_acquirer_id)
+  ```
+- produces `"redis_queued_locks.release_locks_of"` instrumentation event;
+  - `:lock_scan_size` - (optional) `[Integer]`
+    - how many items will be released at a time (uses `SCAN `for batch extraction and `DEL` for batch deletion);
+    - pre-configuerd value in `config['clear_locks_of__lock_scan_size']`;
+  - `:queue_scan_size` - (optional) `[Integer]`
+    - how many queues will be SCAN'ned at a time (uses `SCAN)`;
+    - pre-configuerd value in `config['clear_locks_of__queue_scan_size']`;
+  - `:logger` - (optional) `[::Logger,#debug]`
+    - custom logger object;
+    - pre-configured value in `config['logger']`;
+  - `:instrumenter` - (optional) `[#notify]`
+    - custom instrumenter object;
+    - pre-configured value in `config['isntrumenter']`;
+  - `:instrument` - (optional) `[NilClass,Any]`
+    - custom instrumentation data wich will be passed to the instrumenter's payload with `:instrument` key;
+  - `:log_sampling_enabled` - (optional) `[Boolean]`
+    - enables **log sampling**;
+    - pre-configured in `config['log_sampling_enabled']`;
+  - `:log_sampling_percent` - (optional) `[Integer]`
+    - **log sampling**:the percent of cases that should be logged;
+    - pre-configured in `config['log_sampling_percent']`;
+  - `:log_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]`
+    - **log sampling**: percent-based log sampler that decides should be RQL case logged or not;
+    - pre-configured in `config['log_sampler']`;
+  - `log_sample_this` - (optional) `[Boolean]`
+    - marks the method that everything should be logged despite the enabled log sampling;
+    - makes sense when log sampling is enabled;
+    - `false` by default;
+  - `:instr_sampling_enabled` - (optional) `[Boolean]`
+    - enables **instrumentaion sampling**;
+    - pre-configured in `config['instr_sampling_enabled']`;
+  - `instr_sampling_percent` - (optional) `[Integer]`
+    - the percent of cases that should be instrumented;
+    - pre-configured in `config['instr_sampling_percent']`;
+  - `instr_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]`
+    - percent-based log sampler that decides should be RQL case instrumented or not;
+    - pre-configured in `config['instr_sampler']`;
+  - `instr_sample_this` - (optional) `[Boolean]`
+    - marks the method that everything should be instrumneted despite the enabled instrumentation sampling;
+    - makes sense when instrumentation sampling is enabled;
+    - `false` by default;
+- returns:
+  - `[Hash<Symbol,Numeric>]` - Format: `{ ok: true, result: Hash<Symbol,Numeric> }`;
+  - result data:
+    - `:rel_time` - `Numeric` - time spent;
+    - `:rel_key_cnt` - `Integer` - the count of released locks;
+    - `:tch_queue_cnt` - `Integer` - the count of touched (modified) queues (the number of queues from which the acquirer/host was removed);
+
+```ruby
+rql.clear_current_locks
+# -- or (alias) --
+rql.release_current_locks
+# equivalent:
+rql.release_locks_of(host_id: rql.current_host_id, acquirer_id: rql.current_acquirer_id)
+
+# -> result
+{
+  ok: true,
+  result: {
+    rel_key_cnt: 43,
+    tch_queue_cnt: 3,
+    rel_time: 0.2
+  }
+}
+```
+
+---
+
 #### #extend_lock_ttl
 
 <sup>\[[back to top](#usage)\]</sup>
@@ -1131,35 +1346,35 @@ rql.clear_locks
     - how many milliseconds should be added to the lock's TTL;
   - `:instrumenter` - (optional) `[#notify]`
     - custom instrumenter object;
-    - pre-configured in `config[:instrumetner]`;
+    - pre-configured in `config['instrumetner']`;
   - `:instrument` - (optional) `[NilClass,Any]`;
     - custom instrumentation data wich will be passed to the instrumenter's payload with :instrument key;
     - `nil` by default (no additional data);
   - `:logger` - (optional) `[::Logger,#debug]`
     - custom logger object;
-    - pre-configured in `config[:logger]`;
+    - pre-configured in `config['logger']`;
   - `:log_sampling_enabled` - (optional) `[Boolean]`
     - enables **log sampling**;
-    - pre-configured in `config[:log_sampling_enabled]`;
+    - pre-configured in `config['log_sampling_enabled']`;
   - `:log_sampling_percent` - (optional) `[Integer]`
     - **log sampling**:the percent of cases that should be logged;
-    - pre-configured in `config[:log_sampling_percent]`;
+    - pre-configured in `config['log_sampling_percent']`;
   - `:log_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]`
     - **log sampling**: percent-based log sampler that decides should be RQL case logged or not;
-    - pre-configured in `config[:log_sampler]`;
+    - pre-configured in `config['log_sampler']`;
   - `log_sample_this` - (optional) `[Boolean]`
     - marks the method that everything should be logged despite the enabled log sampling;
     - makes sense when log sampling is enabled;
     - `false` by default;
   - `:instr_sampling_enabled` - (optional) `[Boolean]`
     - enables **instrumentaion sampling**;
-    - pre-configured in `config[:instr_sampling_enabled]`;
+    - pre-configured in `config['instr_sampling_enabled']`;
   - `instr_sampling_percent` - (optional) `[Integer]`
     - the percent of cases that should be instrumented;
-    - pre-configured in `config[:instr_sampling_percent]`;
+    - pre-configured in `config['instr_sampling_percent']`;
   - `instr_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]`
     - percent-based log sampler that decides should be RQL case instrumented or not;
-    - pre-configured in `config[:instr_sampler]`;
+    - pre-configured in `config['instr_sampler']`;
   - `instr_sample_this` - (optional) `[Boolean]`
     - marks the method that everything should be instrumneted despite the enabled instrumentation sampling;
     - makes sense when instrumentation sampling is enabled;
@@ -1199,7 +1414,7 @@ rql.extend_lock_ttl("my_lock", 5_000) # NOTE: add 5_000 milliseconds
 - get list of obtained locks;
 - uses redis `SCAN` under the hood;
 - accepts:
-  - `:scan_size` - `Integer` - (`config[:key_extraction_batch_size]` by default);
+  - `:scan_size` - `Integer` - (`config['key_extraction_batch_size']` by default);
   - `:with_info` - `Boolean` - `false` by default (for details see [#locks_info](#locks_info---get-list-of-locks-with-their-info));
 - returns:
   - `Set<String>` (for `with_info: false`);
@@ -1232,7 +1447,7 @@ rql.locks # or rql.locks(scan_size: 123)
 - get list of lock request queues;
 - uses redis `SCAN` under the hood;
 - accepts
-  - `:scan_size` - `Integer` - (`config[:key_extraction_batch_size]` by default);
+  - `:scan_size` - `Integer` - (`config['key_extraction_batch_size']` by default);
   - `:with_info` - `Boolean` - `false` by default (for details see [#queues_info](#queues_info---get-list-of-queues-with-their-info));
 - returns:
   - `Set<String>` (for `with_info: false`);
@@ -1265,7 +1480,7 @@ rql.queues # or rql.queues(scan_size: 123)
 - get list of taken locks and queues;
 - uses redis `SCAN` under the hood;
 - accepts:
-  `:scan_size` - `Integer` - (`config[:key_extraction_batch_size]` by default);
+  `:scan_size` - `Integer` - (`config['key_extraction_batch_size']` by default);
 - returns: `Set<String>`
 
 ```ruby
@@ -1298,7 +1513,7 @@ rql.keys # or rql.keys(scan_size: 123)
 
 - get list of locks with their info;
 - uses redis `SCAN` under the hod;
-- accepts `scan_size:`/`Integer` option (`config[:key_extraction_batch_size]` by default);
+- accepts `scan_size:`/`Integer` option (`config['key_extraction_batch_size']` by default);
 - returns `Set<Hash<Symbol,Any>>` (see [#lock_info](#lock_info) and examples below for details).
   - contained data: `{ lock: String, status: Symbol, info: Hash<String,Any> }`;
   - `:lock` - `String` - lock key in Redis;
@@ -1318,7 +1533,7 @@ rql.locks_info # or rql.locks_info(scan_size: 123)
    :status=>:alive,
    :info=>{
     "acq_id"=>"rql:acq:41478/4320/4340/4360/848818f09d8c3420",
-    "hst_id"=>"rql:hst:41478/4320/4360/848818f09d8c3420"
+    "hst_id"=>"rql:hst:41478/4320/4360/848818f09d8c3420",
     "ts"=>1711607112.670343,
     "ini_ttl"=>15000,
     "rem_ttl"=>13998}},
@@ -1336,11 +1551,11 @@ rql.locks_info # or rql.locks_info(scan_size: 123)
 
 - get list of queues with their info;
 - uses redis `SCAN` under the hod;
-- accepts `scan_size:`/`Integer` option (`config[:key_extraction_batch_size]` by default);
+- accepts `scan_size:`/`Integer` option (`config['key_extraction_batch_size']` by default);
 - returns `Set<Hash<Symbol,Any>>` (see [#queue_info](#queue_info) and examples below for details).
   - contained data: `{ queue: String, requests: Array<Hash<String,Any>> }`
   - `:queue` - `String` - lock key queue in Redis;
-  - `:requests` - `Array<Hash<String,Any>>` - lock requests in the que with their acquier id and score.
+  - `:requests` - `Array<Hash<String,Any>>` - lock requests in the que with their acquirer id and score.
 
 ```ruby
 rql.queues_info # or rql.qeuues_info(scan_size: 123)
@@ -1371,7 +1586,7 @@ For this case your lock reuquest will be cleared only when any process will try
 to acquire this lock again (cuz lock acquirement triggers the removement of expired requests).
 
 In order to help with these dead requests you may periodically call `#clear_dead_requests`
-with corresponding `:dead_ttl` option, that is pre-configured by default via `config[:dead_request_ttl]`.
+with corresponding `:dead_ttl` option, that is pre-configured by default via `config['dead_request_ttl']`.
 
 `:dead_ttl` option is required because of it is no any **fast** and **resource-free** way to understand which request
 is dead now and is it really dead cuz each request queue can host their requests with
@@ -1380,41 +1595,41 @@ a custom queue ttl for each request differently.
 Accepts:
 - `:dead_ttl` - (optional) `[Integer]`
   - lock request ttl after which a lock request is considered dead;
-  - has a preconfigured value in `config[:dead_request_ttl]` (1 day by default);
+  - has a preconfigured value in `config['dead_request_ttl']` (1 day by default);
 - `:sacn_size` - (optional) `[Integer]`
   - the batch of scanned keys for Redis'es SCAN command;
-  - has a preconfigured valie in `config[:lock_release_batch_size]`;
+  - has a preconfigured valie in `config['lock_release_batch_size']`;
 - `:logger` - (optional) `[::Logger,#debug]`
   - custom logger object;
-  - pre-configured in `config[:logger]`;
+  - pre-configured in `config['logger']`;
 - `:instrumenter` - (optional) `[#notify]`
   - custom instrumenter object;
-  - pre-configured in `config[:isntrumenter]`;
+  - pre-configured in `config['isntrumenter']`;
 - `:instrument` - (optional) `[NilClass,Any]`
   - custom instrumentation data wich will be passed to the instrumenter's payload with :instrument key;
   - `nil` by default (no additional data);
 - `:log_sampling_enabled` - (optional) `[Boolean]`
   - enables **log sampling**;
-  - pre-configured in `config[:log_sampling_enabled]`;
+  - pre-configured in `config['log_sampling_enabled']`;
 - `:log_sampling_percent` - (optional) `[Integer]`
   - **log sampling**:the percent of cases that should be logged;
-  - pre-configured in `config[:log_sampling_percent]`;
+  - pre-configured in `config['log_sampling_percent']`;
 - `:log_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]`
   - **log sampling**: percent-based log sampler that decides should be RQL case logged or not;
-  - pre-configured in `config[:log_sampler]`;
+  - pre-configured in `config['log_sampler']`;
 - `log_sample_this` - (optional) `[Boolean]`
   - marks the method that everything should be logged despite the enabled log sampling;
   - makes sense when log sampling is enabled;
   - `false` by default;
 - `:instr_sampling_enabled` - (optional) `[Boolean]`
   - enables **instrumentaion sampling**;
-  - pre-configured in `config[:instr_sampling_enabled]`;
+  - pre-configured in `config['instr_sampling_enabled']`;
 - `instr_sampling_percent` - (optional) `[Integer]`
   - the percent of cases that should be instrumented;
-  - pre-configured in `config[:instr_sampling_percent]`;
+  - pre-configured in `config['instr_sampling_percent']`;
 - `instr_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]`
   - percent-based log sampler that decides should be RQL case instrumented or not;
-  - pre-configured in `config[:instr_sampler]`;
+  - pre-configured in `config['instr_sampler']`;
 - `instr_sample_this` - (optional) `[Boolean]`
   - marks the method that everything should be instrumneted despite the enabled instrumentation sampling;
   - makes sense when instrumentation sampling is enabled;
@@ -1443,6 +1658,7 @@ rql.clear_dead_requests(dead_ttl: 60 * 60 * 1000) # 1 hour in milliseconds
 
 <sup>\[[back to top](#usage)\]</sup>
 
+- (aliases: `#current_acq_id`, `#acq_id`);
 - get the current acquirer identifier in RQL notation that you can use for debugging purposes during the lock analyzation;
 - acquirer identifier format:
   ```ruby
@@ -1464,7 +1680,7 @@ Accepts:
 - `identity:` - (optional) `[String,Any]`;
   - this value is calculated once during `RedisQueuedLock::Client` instantiation and stored in `@uniq_identity`;
   - this value can be accessed from `RedisQueuedLock::Client#uniq_identity`;
-  - [Configuration](#configuration) documentation: see `config[:uniq_identifier]`;
+  - [Configuration](#configuration) documentation: see `config['uniq_identifier']`;
   - [#lock](#lock---obtain-a-lock) method documentation: see `uniq_identifier`;
 
 ```ruby
@@ -1480,6 +1696,7 @@ rql.current_acquirer_id
 
 <sup>\[[back to top](#usage)\]</sup>
 
+- (aliases: `#current_hst_id`, `#hst_id`);
 - get a current host identifier in RQL notation that you can use for debugging purposes during the lock analyzis;
 - the host is a ruby worker (a combination of process/thread/ractor/identity) that is alive and can obtain locks;
 - the host is limited to `process`/`thread`/`ractor` (without `fiber`) combination cuz we have no abilities to extract
@@ -1505,7 +1722,7 @@ Accepts:
 - `identity:` - (optional) `[String]`;
   - this value is calculated once during `RedisQueuedLock::Client` instantiation and stored in `@uniq_identity`;
   - this value can be accessed from `RedisQueuedLock::Client#uniq_identity`;
-  - [Configuration](#configuration) documentation: see `config[:uniq_identifier]`;
+  - [Configuration](#configuration) documentation: see `config['uniq_identifier']`;
   - [#lock](#lock---obtain-a-lock) method documentation: see `uniq_identifier`;
 
 ```ruby
@@ -1537,7 +1754,7 @@ Accepts:
 - `identity` - (optional) `[String]`;
   - this value is calculated once during `RedisQueuedLock::Client` instantiation and stored in `@uniq_identity`;
   - this value can be accessed from `RedisQueuedLock::Client#uniq_identity`;
-  - [Configuration](#configuration) documentation: see `config[:uniq_identifier]`;
+  - [Configuration](#configuration) documentation: see `config['uniq_identifier']`;
   - [#lock](#lock---obtain-a-lock) method documentation: see `uniq_identifier`;
 
 ```ruby
@@ -1576,7 +1793,7 @@ rql.possible_host_ids
 - [zombies_info](#zombies_info)
 - [zombie_locks](#zombie_locks)
 - [zombie_hosts](#zombie_hosts)
-- [zombie_acquiers](#zombie_acquiers)
+- [zombie_acquirers](#zombie_acquirers)
 
 <hr>
 
@@ -1592,31 +1809,31 @@ rql.possible_host_ids
 
   clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
     # NOTE: auto-swarm your RQL client after initalization (run swarm elements and their supervisor)
-    config.swarm.auto_swarm = false
+    config['swarm.auto_swarm'] = false
 
     # supervisor configs
-    config.swarm.supervisor.liveness_probing_period = 2 # NOTE: in seconds
+    config['swarm.supervisor.liveness_probing_period'] = 2 # NOTE: in seconds
 
     # (probe_hosts) host probing configuration
-    config.swarm.probe_hosts.enabled_for_swarm = true # NOTE: run host-probing from or not
-    config.swarm.probe_hosts.probe_period = 2 # NOTE: (in seconds) the period of time when the probing process is triggered
+    config['swarm.probe_hosts.enabled_for_swarm'] = true # NOTE: run host-probing from or not
+    config['swarm.probe_hosts.probe_period'] = 2 # NOTE: (in seconds) the period of time when the probing process is triggered
     # (probe_hosts) individual redis config
-    config.swarm.probe_hosts.redis_config.sentinel = false # NOTE: individual redis config
-    config.swarm.probe_hosts.redis_config.pooled = false # NOTE: individual redis config
-    config.swarm.probe_hosts.redis_config.config = {} # NOTE: individual redis config
-    config.swarm.probe_hosts.redis_config.pool_config = {} # NOTE: individual redis config
+    config['swarm.probe_hosts.redis_config.sentinel'] = false # NOTE: individual redis config
+    config['swarm.probe_hosts.redis_config.pooled'] = false # NOTE: individual redis config
+    config['swarm.probe_hosts.redis_config.config'] = {} # NOTE: individual redis config
+    config['swarm.probe_hosts.redis_config.pool_config'] = {} # NOTE: individual redis config
 
     # (flush_zombies) zombie flushing configuration
-    config.swarm.flush_zombies.enabled_for_swarm = true # NOTE: run zombie flushing or not
-    config.swarm.flush_zombies.zombie_flush_period = 10 # NOTE: (in seconds) period of time when the zombie flusher is triggered
-    config.swarm.flush_zombies.zombie_ttl = 15_000 # NOTE: (in milliseconds) when the lock/host/acquier is considered a zombie
-    config.swarm.flush_zombies.zombie_lock_scan_size = 500 # NOTE: scan sizec during zombie flushing
-    config.swarm.flush_zombies.zombie_queue_scan_size = 500 # NOTE: scan sizec during zombie flushing
+    config['swarm.flush_zombies.enabled_for_swarm'] = true # NOTE: run zombie flushing or not
+    config['swarm.flush_zombies.zombie_flush_period'] = 10 # NOTE: (in seconds) period of time when the zombie flusher is triggered
+    config['swarm.flush_zombies.zombie_ttl'] = 15_000 # NOTE: (in milliseconds) when the lock/host/acquirer is considered a zombie
+    config['swarm.flush_zombies.zombie_lock_scan_size'] = 500 # NOTE: scan sizec during zombie flushing
+    config['swarm.flush_zombies.zombie_queue_scan_size'] = 500 # NOTE: scan sizec during zombie flushing
     # (flush_zombies) individual redis config
-    config.swarm.flush_zombies.redis_config.sentinel = false # NOTE: individual redis config
-    config.swarm.flush_zombies.redis_config.pooled = false # NOTE: individual redis config
-    config.swarm.flush_zombies.redis_config.config = {} # NOTE: individual redis config
-    config.swarm.flush_zombies.redis_config.pool_config = {} # NOTE: individual redis config
+    config['swarm.flush_zombies.redis_config.sentinel'] = false # NOTE: individual redis config
+    config['swarm.flush_zombies.redis_config.pooled'] = false # NOTE: individual redis config
+    config['swarm.flush_zombies.redis_config.config'] = {} # NOTE: individual redis config
+    config['swarm.flush_zombies.redis_config.pool_config'] = {} # NOTE: individual redis config
   end
   ```
 </details>
@@ -1688,7 +1905,7 @@ rql.possible_host_ids
    :zombie_locks=>#<Set: {"rql:lock:kekpek"}>}
   [5] pry(main)> rql.zombie_locks
   => #<Set: {"rql:lock:kekpek"}>
-  [6] pry(main)> rql.zombie_acquiers
+  [6] pry(main)> rql.zombie_acquirers
   => #<Set: {"rql:acq:17580/2260/2380/2280/3f16b93973612580"}>
   [7] pry(main)> rql.zombie_hosts
   => #<Set:
@@ -1730,7 +1947,7 @@ rql.possible_host_ids
    :flush_zombies=>{:enabled=>true, :ractor=>{:running=>true, :state=>"running"}, :main_loop=>{:running=>true, :state=>"sleep"}}}
   [11] pry(main)> rql.zombies_info
   => {:zombie_hosts=>#<Set: {}>, :zombie_acquirers=>#<Set: {}>, :zombie_locks=>#<Set: {}>}
-  [12] pry(main)> rql.zombie_acquiers
+  [12] pry(main)> rql.zombie_acquirers
   => #<Set: {}>
   [13] pry(main)> rql.zombie_hosts
   => #<Set: {}>
@@ -1761,7 +1978,7 @@ rql.possible_host_ids
     - `:queued` (FIFO): the classic queued behavior (default), your lock will be obitaned if you are first in queue and the required lock is free;
     - `: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;
   - for current implementation detalis check:
-    - [Configuration](#configuration) documentation: see `config.default_access_strategy` config docs;
+    - [Configuration](#configuration) documentation: see `config['default_access_strategy']` config docs;
     - [#lock](#lock---obtain-a-lock) method documentation: see `access_strategy` attribute docs;
 
 ---
@@ -1779,7 +1996,7 @@ rql.possible_host_ids
     "is your lock are obtained or not" is made as you work with **reentrant locks** (your process continues to use the lock without/with
     lock's TTL extension accordingly);
   - for current implementation details check:
-    - [Configuration](#configuration) documentation: see `config.default_conflict_strategy` config docs;
+    - [Configuration](#configuration) documentation: see `config['default_conflict_strategy']` config docs;
     - [#lock](#lock---obtain-a-lock) method documentation: see `conflict_strategy` attribute docs and the method result data;
 
 ---
@@ -1796,7 +2013,7 @@ rql.possible_host_ids
 ```ruby
 "[redis_queued_locks.start_lock_obtaining]" # (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
 "[redis_queued_locks.start_try_to_lock_cycle]" # (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
-"[redis_queued_locks.dead_score_reached__reset_acquier_position]" # (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
+"[redis_queued_locks.dead_score_reached__reset_acquirer_position]" # (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
 "[redis_queued_locks.lock_obtained]" # (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acq_time");
 "[redis_queued_locks.extendable_reentrant_lock_obtained]" # (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat", "acq_time");
 "[redis_queued_locks.reentrant_lock_obtained]" # (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat", "acq_time");
@@ -1831,8 +2048,8 @@ rql.possible_host_ids
 <sup>\[[back to top](#table-of-contents)\]</sup>
 
 **NOTICE**: logging can be sampled via:
-- `config.log_samplign_enabled = true` (**false** by default);
-- `config.log_sampler = RedisQueuedLocks::Logging::Sampler` (used by default);
+- `config['log_samplign_enabled'] = true` (**false** by default);
+- `config['log_sampler'] = RedisQueuedLocks::Logging::Sampler` (used by default);
 - see **RedisQueuedLocks::Logging::Sampler** implementation in source code for customization details;
 
 ```ruby
@@ -1843,7 +2060,7 @@ rql.possible_host_ids
 # - at this moment the only debug logs are realised in following cases:
 #   - "[redis_queued_locks.start_lock_obtaining]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
 #   - "[redis_queued_locks.start_try_to_lock_cycle]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
-#   - "[redis_queued_locks.dead_score_reached__reset_acquier_position]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
+#   - "[redis_queued_locks.dead_score_reached__reset_acquirer_position]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
 #   - "[redis_queued_locks.lock_obtained]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acq_time", "acs_strat");
 #   - "[redis_queued_locks.extendable_reentrant_lock_obtained]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acq_time", "acs_strat");
 #   - "[redis_queued_locks.reentrant_lock_obtained]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acq_time", "acs_strat");
@@ -1851,7 +2068,7 @@ rql.possible_host_ids
 #   - "[redis_queued_locks.expire_lock]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
 #   - "[redis_queued_locks.decrease_lock]" (logs "lock_key", "decreased_ttl", "queue_ttl", "acq_id", "hst_id", "acs_strat");
 # - by default uses VoidLogger that does nothing;
-config.logger = RedisQueuedLocks::Logging::VoidLogger
+config['logger'] = RedisQueuedLocks::Logging::VoidLogger
 
 # (default: false)
 # - adds additional debug logs;
@@ -1870,28 +2087,28 @@ config.logger = RedisQueuedLocks::Logging::VoidLogger
 #   - "[redis_queued_locks.try_lock.exit__no_first]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat", "first_acq_id_in_queue", "<current_lock_data>");
 #   - "[redis_queued_locks.try_lock.exit__lock_still_obtained]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat", "first_acq_id_in_queue", "locked_by_acq_id", "<current_lock_data>");
 #   - "[redis_queued_locks.try_lock.obtain__free_to_acquire]" (logs "lock_key", "queue_ttl", "acq_id", "hst_id", "acs_strat");
-config.log_lock_try = false
+config['log_lock_try'] = false
 
 # (default: false)
 # - 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> configs;
-config.log_sampling_enabled = false
+# - works in tandem with <config['log_sampling_percent']> and <config['log_sampler']> configs;
+config['log_sampling_enabled'] = false
 
 # (default: 15)
 # - 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;
-config.log_sampling_percent = 15
+# - take an effect when <config['log_sampling_enalbed']> is true;
+# - works in tandem with <config['log_sampling_enabled']> and <config['log_sampler']> configs;
+config['log_sampling_percent'] = 15
 
 # (default: 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
 #   `sampling_happened?(percent) => boolean` interface (see `RedisQueuedLocks::Logging::Sampler` for example);
-config.log_sampler = RedisQueuedLocks::Logging::Sampler
+config['log_sampler'] = RedisQueuedLocks::Logging::Sampler
 ```
 
 ---
@@ -1903,19 +2120,18 @@ config.log_sampler = RedisQueuedLocks::Logging::Sampler
 - [Instrumentation Events](#instrumentation-events)
 - [Instrumentation Configuration](#instrumentation-configuration)
 
-An instrumentation layer is incapsulated in `instrumenter` object stored in [config](#configuration) (`RedisQueuedLocks::Client#config[:instrumenter]`).
+An instrumentation layer is incapsulated in `instrumenter` object stored in [config](#configuration) (`RedisQueuedLocks::Client#config['instrumenter']`).
 
-Instrumentation can be sampled. See [Instrumentation Configuration](#instrumentation-configuration) section for details.
+Instrumentation can be **sampled**. See [Instrumentation Configuration](#instrumentation-configuration) section for details.
 
 Instrumenter object should provide `notify(event, payload)` method with the following signarue:
 
 - `event` - `string`;
 - `payload` - `hash<Symbol,Any>`;
 
-`redis_queued_locks` provides two instrumenters:
+**RQL** provides two instrumenters:
 
-- `RedisQueuedLocks::Instrument::ActiveSupport` - **ActiveSupport::Notifications** instrumenter
-  that instrument events via **ActiveSupport::Notifications** API;
+- `RedisQueuedLocks::Instrument::ActiveSupport` - **ActiveSupport::Notifications** instrumenter that instrument events via **ActiveSupport::Notifications** API;
 - `RedisQueuedLocks::Instrument::VoidNotifier` - instrumenter that does nothing;
 
 By default `RedisQueuedLocks::Client` is configured with the void notifier (which means "instrumentation is disabled").
@@ -1927,8 +2143,8 @@ By default `RedisQueuedLocks::Client` is configured with the void notifier (whic
 <sup>\[[back to top](#table-of-contents)\]</sup>
 
 **NOTICE**: instrumentation can be sampled via:
-- `config.instr_sampling_enabled = true` (**false** by default);
-- `config.instr_sampler = RedisQueuedLocks::Instrument::Sampler` (used by default);
+- `config['instr_sampling_enabled'] = true` (**false** by default);
+- `config['instr_sampler'] = RedisQueuedLocks::Instrument::Sampler` (used by default);
 - see **RedisQueuedLocks::Instrument::Sampler** implementation in source code for customization details;
 
 ```ruby
@@ -1938,28 +2154,28 @@ By default `RedisQueuedLocks::Client` is configured with the void notifier (whic
 #   - event: <string> requried;
 #   - payload: <hash> requried;
 # - disabled by default via `VoidNotifier`;
-config.instrumenter = RedisQueuedLocks::Instrument::ActiveSupport
+config['instrumenter'] = RedisQueuedLocks::Instrument::ActiveSupport
 
 # (default: false)
 # - 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>;
-config.instr_sampling_enabled = false
+# - works in tandem with <config['instr_sampling_percent']> and <config['instr_sampler']>;
+config['instr_sampling_enabled'] = false
 
 # (default: 15)
 # - 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;
-config.instr_sampling_percent = 15
+# - take an effect when <config['instr_sampling_enalbed']> is true;
+# - works in tandem with <config['instr_sampling_enabled']> and <config['instr_sampler']> configs;
+config['instr_sampling_percent'] = 15
 
 # (default: 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
 #   `sampling_happened?(percent) => boolean` interface (see `RedisQueuedLocks::Instrument::Sampler` for example);
-config.instr_sampler = RedisQueuedLocks::Instrument::Sampler
+config['instr_sampler'] = RedisQueuedLocks::Instrument::Sampler
 ```
 
 ---
@@ -1970,95 +2186,113 @@ config.instr_sampler = RedisQueuedLocks::Instrument::Sampler
 
 List of instrumentation events
 
-- `redis_queued_locks.lock_obtained`;
-- `redis_queued_locks.extendable_reentrant_lock_obtained`;
-- `redis_queued_locks.reentrant_lock_obtained`;
-- `redis_queued_locks.lock_hold_and_release`;
-- `redis_queued_locks.reentrant_lock_hold_completes`;
-- `redis_queued_locks.explicit_lock_release`;
-- `redis_queued_locks.explicit_all_locks_release`;
+- ["redis_queued_locks.lock_obtained"](#redis_queued_lockslock_hold_and_release)
+- ["redis_queued_locks.extendable_reentrant_lock_obtained"](#redis_queued_locksextendable_reentrant_lock_obtained)
+- ["redis_queued_locks.reentrant_lock_obtained"](#redis_queued_locksreentrant_lock_obtained)
+- ["redis_queued_locks.lock_hold_and_release"](#redis_queued_lockslock_hold_and_release)
+- ["redis_queued_locks.reentrant_lock_hold_completes"](#redis_queued_locksreentrant_lock_hold_completes)
+- ["redis_queued_locks.explicit_lock_release"](#redis_queued_locksexplicit_lock_release)
+- ["redis_queued_locks.explicit_all_locks_release"](#redis_queued_locksexplicit_all_locks_release)
+- ["redis_queued_locks.release_locks_of"](#redis_queued_locksrelease_locks_of)
 
 Detalized event semantics and payload structure:
 
-- `"redis_queued_locks.lock_obtained"`
-  - a moment when the lock was obtained;
-  - raised from `#lock`/`#lock!`;
-  - payload:
-    - `:ttl` - `integer`/`milliseconds` - lock ttl;
-    - `:acq_id` - `string` - lock acquier identifier;
-    - `:hst_id` - `string` - lock's host identifier;
-    - `:lock_key` - `string` - lock name;
-    - `:ts` - `numeric`/`epoch` - the time when the lock was obtaiend;
-    - `:acq_time` - `float`/`milliseconds` - time spent on lock acquiring;
-    - `:instrument` - `nil`/`Any` - custom data passed to the `#lock`/`#lock!` method as `:instrument` attribute;
-
-- `"redis_queued_locks.extendable_reentrant_lock_obtained"`
-  - an event signalizes about the "extendable reentrant lock" obtaining is happened;
-  - raised from `#lock`/`#lock!` when the lock was obtained as reentrant lock;
-  - payload:
-    - `:lock_key` - `string` - lock name;
-    - `:ttl` - `integer`/`milliseconds` - last lock ttl by reentrant locking;
-    - `:acq_id` - `string` - lock acquier identifier;
-    - `:hst_id` - `string` - lock's host identifier;
-    - `:ts` - `numeric`/`epoch` - the time when the lock was obtaiend as extendable reentrant lock;
-    - `:acq_time` - `float`/`milliseconds` - time spent on lock acquiring;
-    - `:instrument` - `nil`/`Any` - custom data passed to the `#lock`/`#lock!` method as `:instrument` attribute;
-
-- `"redis_queued_locks.reentrant_lock_obtained"`
-  - an event signalizes about the "reentrant lock" obtaining is happened (without TTL extension);
-  - raised from `#lock`/`#lock!` when the lock was obtained as reentrant lock;
-  - payload:
-    - `:lock_key` - `string` - lock name;
-    - `:ttl` - `integer`/`milliseconds` - last lock ttl by reentrant locking;
-    - `:acq_id` - `string` - lock acquier identifier;
-    - `:hst_id` - `string` - lock's host identifier;
-    - `:ts` - `numeric`/`epoch` - the time when the lock was obtaiend as reentrant lock;
-    - `:acq_time` - `float`/`milliseconds` - time spent on lock acquiring;
-    - `:instrument` - `nil`/`Any` - custom data passed to the `#lock`/`#lock!` method as `:instrument` attribute;
-
-- `"redis_queued_locks.lock_hold_and_release"`
-  - an event signalizes about the "hold+and+release" process is finished;
-  - raised from `#lock`/`#lock!` when invoked with a block of code;
-  - payload:
-    - `:hold_time` - `float`/`milliseconds` - lock hold time;
-    - `:ttl` - `integer`/`milliseconds` - lock ttl;
-    - `:acq_id` - `string` - lock acquier identifier;
-    - `:hst_id` - `string` - lock's host identifier;
-    - `:lock_key` - `string` - lock name;
-    - `:ts` - `numeric`/`epoch` - the time when lock was obtained;
-    - `:acq_time` - `float`/`milliseconds` - time spent on lock acquiring;
-    - `:instrument` - `nil`/`Any` - custom data passed to the `#lock`/`#lock!` method as `:instrument` attribute;
-
-- `"redis_queued_locks.reentrant_lock_hold_completes"`
-  - an event signalizes about the "reentrant lock hold" is complete (both extendable and non-extendable);
-  - lock re-entering can happen many times and this event happens for each of them separately;
-  - raised from `#lock`/`#lock!` when the lock was obtained as reentrant lock;
-  - payload:
-    - `:hold_time` - `float`/`milliseconds` - lock hold time;
-    - `:ttl` - `integer`/`milliseconds` - last lock ttl by reentrant locking;
-    - `:acq_id` - `string` - lock acquier identifier;
-    - `:hst_id` - `string` - lock's host identifier;
-    - `:ts` - `numeric`/`epoch` - the time when the lock was obtaiend as reentrant lock;
-    - `:lock_key` - `string` - lock name;
-    - `:acq_time` - `float`/`milliseconds` - time spent on lock acquiring;
-    - `:instrument` - `nil`/`Any` - custom data passed to the `#lock`/`#lock!` method as `:instrument` attribute;
-
-- `"redis_queued_locks.explicit_lock_release"`
-  - an event signalizes about the explicit lock release (invoked via `RedisQueuedLock#unlock`);
-  - raised from `#unlock`;
-  - payload:
-    - `:at` - `float`/`epoch` - the time when the lock was released;
-    - `:rel_time` - `float`/`milliseconds` - time spent on lock releasing;
-    - `:lock_key` - `string` - released lock (lock name);
-    - `:lock_key_queue` - `string` - released lock queue (lock queue name);
-
-- `"redis_queued_locks.explicit_all_locks_release"`
-  - an event signalizes about the explicit all locks release (invoked via `RedisQueuedLock#clear_locks`);
-  - raised from `#clear_locks`;
-  - payload:
-    - `:rel_time` - `float`/`milliseconds` - time spent on "realese all locks" operation;
-    - `:at` - `float`/`epoch` - the time when the operation has ended;
-    - `:rel_keys` - `integer` - released redis keys count (`released queue keys` + `released lock keys`);
+##### `"redis_queued_locks.lock_obtained"`
+- <sup>\[[back to the list](#instrumentation-events)\]</sup>
+- a moment when the lock was obtained;
+- raised from `#lock`/`#lock!`;
+- payload:
+  - `:ttl` - `integer`/`milliseconds` - lock ttl;
+  - `:acq_id` - `string` - lock acquirer identifier;
+  - `:hst_id` - `string` - lock's host identifier;
+  - `:lock_key` - `string` - lock name;
+  - `:ts` - `numeric`/`epoch` - the time when the lock was obtaiend;
+  - `:acq_time` - `float`/`milliseconds` - time spent on lock acquiring;
+  - `:instrument` - `nil`/`Any` - custom data passed to the `#lock`/`#lock!` method as `:instrument` attribute;
+
+##### `"redis_queued_locks.extendable_reentrant_lock_obtained"`
+- <sup>\[[back to the list](#instrumentation-events)\]</sup>
+- an event signalizes about the "extendable reentrant lock" obtaining is happened;
+- raised from `#lock`/`#lock!` when the lock was obtained as reentrant lock;
+- payload:
+  - `:lock_key` - `string` - lock name;
+  - `:ttl` - `integer`/`milliseconds` - last lock ttl by reentrant locking;
+  - `:acq_id` - `string` - lock acquirer identifier;
+  - `:hst_id` - `string` - lock's host identifier;
+  - `:ts` - `numeric`/`epoch` - the time when the lock was obtaiend as extendable reentrant lock;
+  - `:acq_time` - `float`/`milliseconds` - time spent on lock acquiring;
+  - `:instrument` - `nil`/`Any` - custom data passed to the `#lock`/`#lock!` method as `:instrument` attribute;
+
+##### `"redis_queued_locks.reentrant_lock_obtained"`
+- <sup>\[[back to the list](#instrumentation-events)\]</sup>
+- an event signalizes about the "reentrant lock" obtaining is happened (without TTL extension);
+- raised from `#lock`/`#lock!` when the lock was obtained as reentrant lock;
+- payload:
+  - `:lock_key` - `string` - lock name;
+  - `:ttl` - `integer`/`milliseconds` - last lock ttl by reentrant locking;
+  - `:acq_id` - `string` - lock acquirer identifier;
+  - `:hst_id` - `string` - lock's host identifier;
+  - `:ts` - `numeric`/`epoch` - the time when the lock was obtaiend as reentrant lock;
+  - `:acq_time` - `float`/`milliseconds` - time spent on lock acquiring;
+  - `:instrument` - `nil`/`Any` - custom data passed to the `#lock`/`#lock!` method as `:instrument` attribute;
+
+##### `"redis_queued_locks.lock_hold_and_release"`
+- <sup>\[[back to the list](#instrumentation-events)\]</sup>
+- an event signalizes about the "hold+and+release" process is finished;
+- raised from `#lock`/`#lock!` when invoked with a block of code;
+- payload:
+  - `:hold_time` - `float`/`milliseconds` - lock hold time;
+  - `:ttl` - `integer`/`milliseconds` - lock ttl;
+  - `:acq_id` - `string` - lock acquirer identifier;
+  - `:hst_id` - `string` - lock's host identifier;
+  - `:lock_key` - `string` - lock name;
+  - `:ts` - `numeric`/`epoch` - the time when lock was obtained;
+  - `:acq_time` - `float`/`milliseconds` - time spent on lock acquiring;
+  - `:instrument` - `nil`/`Any` - custom data passed to the `#lock`/`#lock!` method as `:instrument` attribute;
+
+##### `"redis_queued_locks.reentrant_lock_hold_completes"`
+- <sup>\[[back to the list](#instrumentation-events)\]</sup>
+- an event signalizes about the "reentrant lock hold" is complete (both extendable and non-extendable);
+- lock re-entering can happen many times and this event happens for each of them separately;
+- raised from `#lock`/`#lock!` when the lock was obtained as reentrant lock;
+- payload:
+  - `:hold_time` - `float`/`milliseconds` - lock hold time;
+  - `:ttl` - `integer`/`milliseconds` - last lock ttl by reentrant locking;
+  - `:acq_id` - `string` - lock acquirer identifier;
+  - `:hst_id` - `string` - lock's host identifier;
+  - `:ts` - `numeric`/`epoch` - the time when the lock was obtaiend as reentrant lock;
+  - `:lock_key` - `string` - lock name;
+  - `:acq_time` - `float`/`milliseconds` - time spent on lock acquiring;
+  - `:instrument` - `nil`/`Any` - custom data passed to the `#lock`/`#lock!` method as `:instrument` attribute;
+
+##### `"redis_queued_locks.explicit_lock_release"`
+- <sup>\[[back to the list](#instrumentation-events)\]</sup>
+- an event signalizes about the explicit lock release (invoked via `RedisQueuedLock#unlock`);
+- raised from `#unlock`;
+- payload:
+  - `:at` - `float`/`epoch` - the time when the lock was released;
+  - `:rel_time` - `float`/`milliseconds` - time spent on lock releasing;
+  - `:lock_key` - `string` - released lock (lock name);
+  - `:lock_key_queue` - `string` - released lock queue (lock queue name);
+
+##### `"redis_queued_locks.explicit_all_locks_release"`
+- <sup>\[[back to the list](#instrumentation-events)\]</sup>
+- an event signalizes about the explicit all locks release (invoked via `RedisQueuedLock#clear_locks`);
+- raised from `#clear_locks`;
+- payload:
+  - `:rel_time` - `float`/`milliseconds` - time spent on "realese all locks" operation;
+  - `:at` - `float`/`epoch` - the time when the operation has ended;
+  - `:rel_keys` - `integer` - released redis keys count (`released queue keys` + `released lock keys`);
+
+##### `"redis_queued_locks.release_locks_of"`
+- <sup>\[[back to the list](#instrumentation-events)\]</sup>
+- an event signalizes about the released locks of the cocnrete host and acquirer;
+- raised from `#clear_locks_of` and `#clear_current_locks` (`#release_locks_of` and `#release_current_locks` respectively);
+- payload:
+  - `:rel_time` - `float`/`milliseconds` - time spent on "release locks of" operation;
+  - `:at` - `float`/`epoch` - the time when the opertaion has ended; 
+  - `:rel_key_cnt` - `integer` - released locks count;
+  - `:tch_queue_cnt` - `:integer` - the number of queues from which the cocnrete host/acquirer was removed;
 
 ---
 
@@ -2082,8 +2316,26 @@ Detalized event semantics and payload structure:
     ```ruby
     rql.lock_series('lock_a', 'lock_b', 'lock_c') { puts 'locked' }
     ```
-  - `light mode`: an ability to work without any debug and instrumentation logic and data (totally reduced debugging and instrumenting possibilities, but better performance);
+  - an ability to release all locks and all requests of the concrete acquirer id or host id (or both in validation-orianted combination);
+  - detailed lock informotion inside the error object in cases of exceptions (at the moment we have this info inside the error message only that hard to analyze in work);
+  - a convenient way to mark any `lock` invocation as "non-instrumentable" / "non-loggable" (as an alternative to `VoidNotifier` and to `VoidLogger`);
+  - `Read`/`Write` semantics: you can mark your locks as `read` or `write` lock in order to simulate `read`/`write` lock behavior:
+    - `read` - watis - `write`;
+    - `read` - not waits - `read`;
+    - `write` - waits - `read`;
+    - `write` - waits - `write`;
+    - **write** mode is a default behavior for all RQL locks;
 - **Minor**:
+  - add `hst_id` to all methods that works with queues info;
+  - try to return the `fiber object id` to the lock host identifier (we cant use fiber object id cuz `ObjectSpace` has no access to the fiber object space after the any ractor object initialization)
+  - named RQL's threads (`Thread#name`) and RQL's ractors (`Ractor#name`) in order to have an ability to find and work with RQL's threads and ractors outside of RQL logic (stop threads before process forking, for example);
+  - `#lock`/`#lock!` - `timeout:` option: support for granular periods (it supports only `seconds` at the moment, but we need `milliseconds`);
+  - Add `after timeout hook` ability for timeout errors with an ability to access the binding context (if it possibly) of the thread where it failed;
+  - Add `ignore timeout errors` ability (for debug purposes);
+  - A special explicit documentation section that will explain and clarify which exceptions can be occured and what cases occurs them (at the moment such cases are explained inside the lock methods documentation that is not really convinient);
+  - Renaming of some exceptions (such as `RedisQueuedLocks::TimedLockTimeoutError`) to make the related problem more quickly, faster and easier to understand;
+  - Support for detailed `OpenTelemetry` tracing;
+  - `light mode`: an ability to work without any debug and instrumentation logic and data (totally reduced debugging and instrumenting possibilities, but better performance);
   - support for `Dragonfly` database backend (https://github.com/dragonflydb/dragonfly) (https://www.dragonflydb.io/);
   - (_research_) GVL-isolation for lock acquirement logic (try to bypass Ruby's "context-switching" in order to prevent any time-based affects on lock-acquirement logic);
   - Semantic error objects for unexpected Redis errors;
@@ -2092,15 +2344,41 @@ Detalized event semantics and payload structure:
     whose ttl may expire before the block execution completes). It makes sense for non-`timed` locks *only*;
   - sized lock queues (with an ability of dynamically growing size);
   - better code stylization (+ some refactorings);
-  - `RedisQueuedLocks::Acquier::Try.try_to_lock` - detailed successful result analization;
+  - `RedisQueuedLocks::Acquirer::Try.try_to_lock` - detailed successful result analization;
   - Support for LIFO strategy;
   - better specs with 100% test coverage (total specs rework);
   - statistics with UI;
   - JSON log formatter;
-  - RBS type signatures;
   - **automatic** deadlock detection;
   - `go`-lang implementation;
   - (_research_) simplification and speedup of the internal "redis-communuication-and-data-storing"-based algorithms;
+  - `unlock_on:`-option in lock/lock! logic in order to support auto-unlocking on any exception rasaied under the invoked block (invoked under the lock);
+  - **Research**: support for `Valkey` database backend (https://github.com/valkey-io/valkey) (https://valkey.io/);
+  - **Research**: support for `Garnet` database backend (https://microsoft.github.io/) (https://github.com/microsoft/garnet);
+  - add a library-level exception, when RQL-related key in Redis (required for it's logic) has incompatible type (means: some other program uses our key with their own type and logic and RQL can't work properly);
+---
+
+## Build and Develop
+
+- Tests (`RSpec`):
+```shell
+bundle exec rake rspec
+```
+
+- Linting (`Rubocop`+`RBS`):
+```shell
+bundle exec rake rubocop
+```
+
+- `Static` TypeChecking (`Steep`):
+```shell
+bundle exec rake steep:check
+```
+
+- `Runtime` TypeChecking (`RBS`):
+```shell
+bundle exec rbs collection install && RBS_TEST_RAISE=true RUBYOPT='-rrbs/test/setup' RBS_TEST_OPT='-I sig' RBS_TEST_LOGLEVEL=error RBS_TEST_TARGET='RedisQueuedLocks::*' bundle exec rspec --failure-exit-code=0
+```
 
 ---