redis_queued_locks 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83f1a77fc07b776195720c2f06a7117baa22ea7f68be06120d3fe7befe26db84
-  data.tar.gz: 4a06cb4f59afb485331513ab01172c2836f07702bd79fdc85c95efaa459a2597
+  metadata.gz: 6b1c8d60f41d2dc4f3eda798efa02a4764b877e6666e8babd7cf1a7827a4b288
+  data.tar.gz: 983e142251b344055013aa2aac2965ad542d44f5c8f81ac410f97cdef7b216b3
 SHA512:
-  metadata.gz: ebae6ceee85253f767b0de53b70a69f00590e91bbcdb6c86860c35a00d736f59593f924eaccb13b593def1f9b504f338f786a2eeb59f9dcd4a596c9d70f2f348
-  data.tar.gz: 5e6e97c4645df750d618c778caccd80fa3eab1491e141b238e5e4c1ed15f59c72871c00f10d38269f33ada195b96ed5b407a62cc52d2543a169b150d2150c770
+  metadata.gz: 88b91754923e546767d03999601fb98bd04b00fb426e50691e2fd4ce1bf13e345c19179b534660a639d0a885d1fdad4db94ffda0fa4383d7d9dcf53981ca481b
+  data.tar.gz: f9368018c66eee962a9dd6be1b38efe7bb4359cdfb262956f4e2e43622aaf747b67b4aa6b7a9bcda6c8449e011cb1c2954d5a6e5324afdbfbb8eea0ca96085b0

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [Unreleased]
 
+## [1.2.0] - 2024-04-27
+### Added
+- Documentation updates;
+- Logging: support for `semantic_logger` loggers (see: https://logger.rocketjob.io/) (https://github.com/reidmorrison/semantic_logger)
+
+## [1.1.0] - 2024-04-01
+### Added
+- Documentation updates:
+  - more `#lock` examples;
+  - added missing docs for `config.dead_request_ttl`;
+  - some minor updates;
+### Changed
+- `#clear_dead_requests`: `:scan_size` is equal to `config[:lock_release_batch_size]` now (instead of to `config[:key_extraction_batch_size]`), cuz `#clear_dead_requests` works with lock releasing;
+
 ## [1.0.0] - 2024-04-01
 - First Major Release;
 
@@ -185,7 +199,7 @@
 ### Changed
 - The lock acquier identifier (`acq_id`) now includes the fiber id, the ractor id and an unique per-process
   10 byte string. It is added in order to prevent collisions between different processes/pods
-  that will have the same procjet id / thread id identifiers (cuz it is an object_id integers) that can lead
+  that will have the same process id / thread id identifiers (cuz it is an object_id integers) that can lead
   to the same position with the same `acq_id` for different processes/pods in the lock request queue.
 
 ## [0.0.8] - 2024-02-27

data/README.md

@@ -150,15 +150,21 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   config.is_timed_by_default = false
 
   # (default: 100)
-  # - how many items will be released at a time in RedisQueuedLocks::Client#clear_locks logic (uses SCAN);
-  # - affects the performancs of your Redis and Ruby Application (configure thoughtfully);
+  # - 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
 
   # (default: 500)
-  # - how many items should be extracted from redis during the #locks, #queues and #keys operations (uses SCAN);
+  # - 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
 
+  # (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
+
   # (default: RedisQueuedLocks::Instrument::VoidNotifier)
   # - instrumentation layer;
   # - you can provde your own instrumenter with `#notify(event, payload = {})`
@@ -245,7 +251,7 @@ def lock(
   ttl: config[:default_lock_ttl],
   queue_ttl: config[:default_queue_ttl],
   timeout: config[:try_to_lock_timeout],
-  timed: false,
+  timed: config[:is_timed_by_default],
   retry_count: config[:retry_count],
   retry_delay: config[:retry_delay],
   retry_jitter: config[:retry_jitter],
@@ -318,10 +324,12 @@ def lock(
   - 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]`;
   - `false` by default;
-- `block` - `[Block]`
+- `block` - (optional) `[Block]`
   - A block of code that should be executed after the successfully acquired lock.
   - If block is **passed** the obtained lock will be released after the block execution or it's ttl (what will happen first);
   - If block is **not passed** the obtained lock will be released after it's ttl;
+  - If you want the block to have a TTL too and this TTL to be the same as TTL of the lock
+    use `timed: true` option (`rql.lock("my_lock", timed: true, ttl: 5_000) { ... }`)
 
 Return value:
 
@@ -429,6 +437,61 @@ rql.lock("my_lock", ttl: 6_500) # blocks execution until the lock is obtained
 puts "Let's go" # will be called immediately after the lock is obtained
 ```
 
+- add custom metadata to the lock (via `:meta` option):
+
+```ruby
+rql.lock("my_lock", ttl: 123456, meta: { "some" => "data", key: 123.456 })
+
+rql.lock_info("my_lock")
+# =>
+{
+  "lock_key" => "rql:lock:my_lock",
+  "acq_id" => "rql:acq:123/456/567/678/374dd74324",
+  "ts" => 123456789,
+  "ini_ttl" => 123456,
+  "rem_ttl" => 123440,
+  "some" => "data",
+  "key" => "123.456" # NOTE: returned as a raw string directly from Redis
+}
+```
+
+- (`:queue_ttl`) setting a short limit of time to the lock request queue position (if a process fails to acquire
+  the lock within this period of time (and before timeout/retry_count limits occurs of course) -
+  it's lock request will be moved to the end of queue):
+
+```ruby
+rql.lock("my_lock", queue_ttl: 5, timeout: 10_000, retry_count: nil)
+# "queue_ttl: 5": 5 seconds time slot before the lock request moves to the end of queue;
+# "timeout" and "retry_count" is used as "endless lock try attempts" example to show the lock queue behavior;
+
+# lock queue: =>
+[
+ "rql:acq:123/456/567/676/374dd74324", 
+ "rql:acq:123/456/567/677/374dd74322", # <- long living lock
+ "rql:acq:123/456/567/679/374dd74321",
+ "rql:acq:123/456/567/683/374dd74322", # <== we are here
+ "rql:acq:123/456/567/685/374dd74329", # some other waiting process
+]
+
+# ... some period of time (2 seconds later)
+# lock queue: =>
+[
+ "rql:acq:123/456/567/677/374dd74322", # <- long living lock
+ "rql:acq:123/456/567/679/374dd74321",
+ "rql:acq:123/456/567/683/374dd74322", # <== we are here
+ "rql:acq:123/456/567/685/374dd74329", # some other waiting process
+]
+
+# ... some period of time (3 seconds later)
+# ... queue_ttl time limit is reached
+# lock queue: =>
+[
+ "rql:acq:123/456/567/685/374dd74329", # some other waiting process
+ "rql:acq:123/456/567/683/374dd74322", # <== we are here (moved to the end of the queue)
+]
+
+```
+
 ---
 
 #### #lock! - exceptional lock obtaining
@@ -539,9 +602,9 @@ rql.queue_info("your_lock_name")
 {
   "lock_queue" => "rql:lock_queue:your_lock_name",
   "queue" => [
-    { "acq_id" => "rql:acq:123/456/567/678/fa76df9cc2", "score" => 1},
-    { "acq_id" => "rql:acq:123/567/456/679/c7bfcaf4f9", "score" => 2},
-    { "acq_id" => "rql:acq:555/329/523/127/7329553b11", "score" => 3},
+    { "acq_id" => "rql:acq:123/456/567/678/fa76df9cc2", "score" => 1711606640.540842},
+    { "acq_id" => "rql:acq:123/567/456/679/c7bfcaf4f9", "score" => 1711606640.540906},
+    { "acq_id" => "rql:acq:555/329/523/127/7329553b11", "score" => 1711606640.540963},
     # ...etc
   ]
 }
@@ -563,6 +626,8 @@ rql.locked?("your_lock_name") # => true/false
 
 #### #queued?
 
+<sup>\[[back to top](#usage)\]</sup>
+
 - is the lock queued for obtain / has requests for obtain?
 
 ```ruby
@@ -611,7 +676,7 @@ rql.unlock("your_lock_name")
   result: {
     rel_time: 0.02, # time spent to lock release (in seconds)
     rel_key: "rql:lock:your_lock_name", # released lock key
-    rel_queue: "rql:lock_queue:your_lock_name" # released lock key queue
+    rel_queue: "rql:lock_queue:your_lock_name", # released lock key queue
     queue_res: :released, # or :nothing_to_release
     lock_res: :released # or :nothing_to_release
   }
@@ -638,12 +703,11 @@ rql.unlock("your_lock_name")
     - 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;
-
 - returns:
- - `[Hash<Symbol,Numeric>]` - Format: `{ ok: true, result: Hash<Symbol,Numeric> }`;
- - result data:
-  - `:rel_time` - `Numeric` - time spent to release all locks and related queus;
-  - `:rel_key_cnt` - `Integer` - the number of released Redis keys (queues+locks);
+  - `[Hash<Symbol,Numeric>]` - Format: `{ ok: true, result: Hash<Symbol,Numeric> }`;
+  - result data:
+    - `:rel_time` - `Numeric` - time spent to release all locks and related queus;
+    - `:rel_key_cnt` - `Integer` - the number of released Redis keys (queues+locks);
 
 ```ruby
 rql.clear_locks
@@ -675,13 +739,14 @@ rql.clear_locks
     - custom logger object;
     - pre-configured in `config[:logger]`;
 - returns `{ ok: true, result: :ttl_extended }` when ttl is extended;
-- returns `{ ok: false, result: :async_expire_or_no_lock }` when lock not found or lock is expired during
+- returns `{ ok: false, result: :async_expire_or_no_lock }` when a lock not found or a lock is already expired during
   some steps of invocation (see **Important** section below);
 - **Important**:
   - the method is non-atomic cuz redis does not provide an atomic function for TTL/PTTL extension;
   - the method consists of two commands:
     - (1) read current pttl;
     - (2) set new ttl that is calculated as "current pttl + additional milliseconds";
+  - the method uses Redis'es **CAS** (check-and-set) behavior;
   - what can happen during these steps:
     - lock is expired between commands or before the first command;
     - lock is expired before the second command;
@@ -884,7 +949,7 @@ Accepts:
   - 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[:key_extraction_batch_size]`;
+  - has a preconfigured valie in `config[:lock_release_batch_size]`;
 - `:logger` - (optional) `[::Logger,#debug]`
   - custom logger object;
   - pre-configured in `config[:logger]`;
@@ -970,7 +1035,7 @@ By default `RedisQueuedLocks::Client` is configured with the void notifier (whic
 
 ### Instrumentation Events
 
-<sup>\[[back to top](#instrumentation-events)\]</sup>
+<sup>\[[back to top](#instrumentation)\]</sup>
 
 List of instrumentation events
 
@@ -1028,6 +1093,7 @@ Detalized event semantics and payload structure:
 <sup>\[[back to top](#table-of-contents)\]</sup>
 
 - **strict redlock algorithm support** (support for many `RedisClient` instances);
+- deadlock detection (with some options for auto-resolving);
 - Semantic Error objects for unexpected Redis errors;
 - better specs with 100% test coverage (total rework);
 - (non-`timed` locks): per-ruby-block-holding-the-lock sidecar `Ractor` and `in progress queue` in RedisDB that will extend
@@ -1035,6 +1101,7 @@ Detalized event semantics and payload structure:
   whose ttl may expire before the block execution completes). It makes sense for non-`timed` locks *only*;
 - lock request prioritization;
 - support for LIFO strategy;
+- support for Random Access strategy;
 - more structured logging (separated docs);
 - `RedisQueuedLocks::Acquier::Try.try_to_lock` - detailed successful result analization;
 - better code stylization (+ some refactorings);

data/lib/redis_queued_locks/acquier/acquire_lock/delay_execution.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::AcquireLock::DelayExecution
   # Sleep with random time-shifting (it is necessary for empty lock-acquirement time slots).
   #
@@ -10,7 +10,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::DelayExecution
   # @return [void]
   #
   # @api private
-  # @since 0.1.0
+  # @since 1.0.0
   def delay_execution(retry_delay, retry_jitter)
     delay = (retry_delay + rand(retry_jitter)).to_f / 1_000
     sleep(delay)

data/lib/redis_queued_locks/acquier/acquire_lock/try_to_lock.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 # rubocop:disable Metrics/ModuleLength, Metrics/BlockNesting
 module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
-  # @since 0.1.0
+  # @since 1.0.0
   extend RedisQueuedLocks::Utilities
 
   # @param redis [RedisClient]
@@ -21,7 +21,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
   # @return [Hash<Symbol,Any>] Format: { ok: true/false, result: Symbol|Hash<Symbol,Any> }
   #
   # @api private
-  # @since 0.1.0
+  # @since 1.0.0
   # rubocop:disable Metrics/MethodLength
   def try_to_lock(
     redis,
@@ -259,7 +259,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
   # @return [Hash<Symbol,Any>] Format: { ok: true/false, result: Any }
   #
   # @api private
-  # @since 0.1.0
+  # @since 1.0.0
   def dequeue_from_lock_queue(redis, logger, lock_key, lock_key_queue, queue_ttl, acquier_id)
     result = redis.call('ZREM', lock_key_queue, acquier_id)
 

data/lib/redis_queued_locks/acquier/acquire_lock/with_acq_timeout.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::AcquireLock::WithAcqTimeout
   # @param timeout [NilClass,Integer]
   #   Time period after which the logic will fail with timeout error.
@@ -14,7 +14,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::WithAcqTimeout
   # @return [Any]
   #
   # @api private
-  # @since 0.1.0
+  # @since 1.0.0
   def with_acq_timeout(timeout, lock_key, raise_errors, on_timeout: nil, &block)
     ::Timeout.timeout(timeout, &block)
   rescue ::Timeout::Error

data/lib/redis_queued_locks/acquier/acquire_lock/yield_with_expire.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::AcquireLock::YieldWithExpire
-  # @since 0.1.0
+  # @since 1.0.0
   extend RedisQueuedLocks::Utilities
 
   # @param redis [RedisClient] Redis connection manager.
@@ -18,7 +18,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldWithExpire
   # @return [Any,NilClass] nil is returned no block parametr is provided.
   #
   # @api private
-  # @since 0.1.0
+  # @since 1.0.0
   def yield_with_expire(
     redis,
     logger,
@@ -59,7 +59,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldWithExpire
   # @return [Any]
   #
   # @api private
-  # @since 0.1.0
+  # @since 1.0.0
   def yield_with_timeout(timeout, lock_key, lock_ttl, &block)
     ::Timeout.timeout(timeout, &block)
   rescue ::Timeout::Error

data/lib/redis_queued_locks/acquier/acquire_lock.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 # rubocop:disable Metrics/ModuleLength
 # rubocop:disable Metrics/MethodLength
 # rubocop:disable Metrics/ClassLength
@@ -12,21 +12,21 @@ module RedisQueuedLocks::Acquier::AcquireLock
   require_relative 'acquire_lock/yield_with_expire'
   require_relative 'acquire_lock/try_to_lock'
 
-  # @since 0.1.0
+  # @since 1.0.0
   extend TryToLock
-  # @since 0.1.0
+  # @since 1.0.0
   extend DelayExecution
-  # @since 0.1.0
+  # @since 1.0.0
   extend YieldWithExpire
-  # @since 0.1.0
+  # @since 1.0.0
   extend WithAcqTimeout
-  # @since 0.1.0
+  # @since 1.0.0
   extend RedisQueuedLocks::Utilities
 
   # @return [Integer] Redis time error (in milliseconds).
   #
   # @api private
-  # @since 0.1.0
+  # @since 1.0.0
   REDIS_TIMESHIFT_ERROR = 2
 
   class << self
@@ -87,7 +87,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
     #  - If block is given the result of block's yeld will be returned.
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def acquire_lock(
       redis,
       lock_name,
@@ -186,7 +186,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
       with_acq_timeout(timeout, lock_key, raise_errors, on_timeout: acq_dequeue) do
         acq_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
 
-        # Step 2.1: caclically try to obtain the lock
+        # Step 2.1: cyclically try to obtain the lock
         while acq_process[:should_try]
           run_non_critical do
             logger.debug do

data/lib/redis_queued_locks/acquier/clear_dead_requests.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::ClearDeadRequests
   class << self
     # @param redis_client [RedisClient]
@@ -13,7 +13,7 @@ module RedisQueuedLocks::Acquier::ClearDeadRequests
     # @return [Hash<Symbol,Boolean|Hash<Symbol,Set<String>>>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def clear_dead_requests(redis_client, scan_size, dead_ttl, logger, instrumenter, instrument)
       dead_score = RedisQueuedLocks::Resource.acquier_dead_score(dead_ttl / 1000.0)
 
@@ -39,7 +39,7 @@ module RedisQueuedLocks::Acquier::ClearDeadRequests
     # @return [Enumerator]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def each_lock_queue(redis_client, scan_size, &block)
       redis_client.scan(
         'MATCH',

data/lib/redis_queued_locks/acquier/extend_lock_ttl.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::ExtendLockTTL
   # @return [String]
   #
   # @api private
-  # @since 0.1.0
+  # @since 1.0.0
   EXTEND_LOCK_PTTL = <<~LUA_SCRIPT.strip.tr("\n", '').freeze
     local new_lock_pttl = redis.call("PTTL", KEYS[1]) + ARGV[1];
     return redis.call("PEXPIRE", KEYS[1], new_lock_pttl);
@@ -20,7 +20,7 @@ module RedisQueuedLocks::Acquier::ExtendLockTTL
     # @return [Hash<Symbol,Boolean|Symbol>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def extend_lock_ttl(redis_client, lock_name, milliseconds, logger)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
 

data/lib/redis_queued_locks/acquier/is_locked.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::IsLocked
   class << self
     # @param redis_client [RedisClient]
@@ -9,7 +9,7 @@ module RedisQueuedLocks::Acquier::IsLocked
     # @return [Boolean]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def locked?(redis_client, lock_name)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
       redis_client.call('EXISTS', lock_key) == 1

data/lib/redis_queued_locks/acquier/is_queued.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::IsQueued
   class << self
     # @param redis_client [RedisClient]
@@ -9,7 +9,7 @@ module RedisQueuedLocks::Acquier::IsQueued
     # @return [Boolean]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def queued?(redis_client, lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
       redis_client.call('EXISTS', lock_key_queue) == 1

data/lib/redis_queued_locks/acquier/keys.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::Keys
   class << self
     # @param redis_client [RedisClient]
@@ -9,7 +9,7 @@ module RedisQueuedLocks::Acquier::Keys
     # @return [Array<String>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def keys(redis_client, scan_size:)
       Set.new.tap do |keys|
         redis_client.scan(

data/lib/redis_queued_locks/acquier/lock_info.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::LockInfo
   class << self
     # @param redis_client [RedisClient]
@@ -17,7 +17,7 @@ module RedisQueuedLocks::Acquier::LockInfo
     #   }
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def lock_info(redis_client, lock_name)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
 

data/lib/redis_queued_locks/acquier/locks.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::Locks
   class << self
     # @param redis_client [RedisClient]
@@ -10,7 +10,7 @@ module RedisQueuedLocks::Acquier::Locks
     # @return [Set<String>,Set<Hash<Symbol,Any>>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def locks(redis_client, scan_size:, with_info:)
       redis_client.with do |rconn|
         lock_keys = scan_locks(rconn, scan_size)
@@ -25,7 +25,7 @@ module RedisQueuedLocks::Acquier::Locks
     # @return [Set<String>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def scan_locks(redis_client, scan_size)
       Set.new.tap do |lock_keys|
         redis_client.scan(
@@ -44,7 +44,7 @@ module RedisQueuedLocks::Acquier::Locks
     # @return [Set<Hash<Symbol,Any>>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     # rubocop:disable Metrics/MethodLength
     def extract_locks_info(redis_client, lock_keys)
       # TODO: refactor with RedisQueuedLocks::Acquier::LockInfo

data/lib/redis_queued_locks/acquier/queue_info.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::QueueInfo
   class << self
     # Returns an information about the required lock queue by the lock name. The result
@@ -23,7 +23,7 @@ module RedisQueuedLocks::Acquier::QueueInfo
     #   }
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def queue_info(redis_client, lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
 

data/lib/redis_queued_locks/acquier/queues.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::Queues
   class << self
     # @param redis_client [RedisClient]
@@ -10,7 +10,7 @@ module RedisQueuedLocks::Acquier::Queues
     # @return [Set<String>,Set<Hash<Symbol,Any>>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def queues(redis_client, scan_size:, with_info:)
       redis_client.with do |rconn|
         lock_queues = scan_queues(rconn, scan_size)
@@ -25,7 +25,7 @@ module RedisQueuedLocks::Acquier::Queues
     # @return [Set<String>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def scan_queues(redis_client, scan_size)
       Set.new.tap do |lock_queues|
         redis_client.scan(
@@ -44,7 +44,7 @@ module RedisQueuedLocks::Acquier::Queues
     # @return [Set<Hash<Symbol,Any>>]
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def extract_queues_info(redis_client, lock_queues)
       # TODO: refactor with RedisQueuedLocks::Acquier::QueueInfo
       Set.new.tap do |seeded_queues|

data/lib/redis_queued_locks/acquier/release_all_locks.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::ReleaseAllLocks
-  # @since 0.1.0
+  # @since 1.0.0
   extend RedisQueuedLocks::Utilities
 
   class << self
@@ -27,7 +27,7 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     #   Format: { ok: true, result: Hash<Symbol,Numeric> }
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def release_all_locks(redis, batch_size, logger, instrumenter, instrument)
       rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       fully_release_all_locks(redis, batch_size) => { ok:, result: }
@@ -59,7 +59,7 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     #   - Exmaple: { ok: true, result: { rel_key_cnt: 12345 } }
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def fully_release_all_locks(redis, batch_size)
       result = redis.with do |rconn|
         rconn.pipelined do |pipeline|

data/lib/redis_queued_locks/acquier/release_lock.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 0.1.0
+# @since 1.0.0
 module RedisQueuedLocks::Acquier::ReleaseLock
-  # @since 0.1.0
+  # @since 1.0.0
   extend RedisQueuedLocks::Utilities
 
   class << self
@@ -27,7 +27,7 @@ module RedisQueuedLocks::Acquier::ReleaseLock
     #   Format: { ok: true/false, result: Hash<Symbol,Numeric|String|Symbol> }
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def release_lock(redis, lock_name, instrumenter, logger)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
@@ -76,7 +76,7 @@ module RedisQueuedLocks::Acquier::ReleaseLock
     #   }
     #
     # @api private
-    # @since 0.1.0
+    # @since 1.0.0
     def fully_release_lock(redis, lock_key, lock_key_queue)
       result = redis.with do |rconn|
         rconn.multi do |transact|