redis_queued_locks 1.16.1 → 1.16.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0bd0b3bb446d6ce5af47949de25834b0c4f87a3fcb1090bf9604fba129354468
-  data.tar.gz: b9c8c49560e193db92d63fc232c31fbdf1ea03b72b28fc778c3fcc22da3af1d1
+  metadata.gz: d49a1559431c569e92cfc1a9b56bd04d9942002aa6d79efcb533370f58b0c184
+  data.tar.gz: bc8fd235df24386a92275273de91d34804452eb085bbb5a2b7118eb4508319ab
 SHA512:
-  metadata.gz: dcea0a7ee67e7a727fe0d92d88bf8f6b0a946c279fce3d43f34e6fe05844cf156e9679d91fcd12f450ebd9029a0aabd9f61b9c5224b7a88fa4551202bd716939
-  data.tar.gz: 0c0b132e65106ce28f68a41278adc7981150b3a50d73952f55bfa22d0b735e8713924a20adca4caedd0fb744587a5675cbab0a78339c02d695b516129a2bd480
+  metadata.gz: 0e7d0944406f13a7a6bac3e59153998fca9731e184ef5da83d8d415af7185f61a4b260166895d3858c501f4ae93cf160fb6b4c5c33e248d2aa82c9bac2265216
+  data.tar.gz: 8aff1a1fb28cbc510edc30efbab0eed49bbb088feff6235959b314b24d705e0058c6d1a347356874fa2a4b930f7aaba62e7f6b48bebf2622e11600998055f719

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [1.16.2] - 2026-02-06
+### Fixed
+- `lock_series` PoC:
+  - acquired locks are not released when the block of code invoked under the lock series fails with
+    an exception
+  - `raise_errors: true` option incorrectly suppresses the lock releasing when the lock series
+    reaches their obtaning limits
+
 ## [1.16.1] - 2026-01-28
 ### Changed
 - `lock_series` PoC:
@@ -30,7 +38,7 @@
   - lock series of lock simultainously (and release them all at the finish of your the invocation of block of code under the obtained locks);
   - exmaple: `client.lock_series("a", "b", "c")` (or in exceptional-based way `client.lock_series!("a", "b", "c")`;
 ### Changed
-- YARDOC documentation updates in order to prearet to the 100% yardoc-coverage;
+- YARDOC documentation updates in order to prepare to the 100% yardoc-coverage;
 - updated dev deps;
 ### Fixed
 - fixed some yardoc documentation typos;

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2024-2025 Rustam Ibragimov
+Copyright (c) 2024-2026 Rustam Ibragimov
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -8,7 +8,7 @@ Each lock request is put into the request queue (each lock is hosted by its own
 
 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.
 
-Provides flexible invocation flow, parametrized limits (lock request ttl, lock ttl, queue ttl, lock attempts limit, fast failing, etc), logging and instrumentation.
+Provides flexible invocation flow, parametrized limits (lock request ttl, lock ttl, queue ttl, lock attempts limit, fast failing, etc), **zombie locks elimination**, support for **reentrant locks**, logging and instrumentation (and much more).
 
 ---
 
@@ -23,8 +23,8 @@ Provides flexible invocation flow, parametrized limits (lock request ttl, lock t
 - [Usage](#usage)
   - [lock](#lock---obtain-a-lock)
   - [lock!](#lock---exceptional-lock-obtaining)
-  - [lock_series (PoC)](#lock_series---poc-acquire-a-series-of-locks)
-  - [lock_series! (PoC)](#lock_series---poc-exceptional-lock_series)
+  - [lock_series](#lock_series---poc-acquire-a-series-of-locks) (PoC)
+  - [lock_series!](#lock_series---poc-exceptional-lock_series) (PoC)
   - [lock_info](#lock_info)
   - [queue_info](#queue_info)
   - [locked?](#locked)
@@ -86,10 +86,10 @@ Provides flexible invocation flow, parametrized limits (lock request ttl, lock t
 
 <sup>\[[back to top](#table-of-contents)\]</sup>
 
-- Redis Version: `~> 7.x`;
+- Redis Version: `>= 7`, `~> 8.x`;
 - Redis Protocol: `RESP3`;
 - gem `redis-client`: `~> 0.20`;
-- Ruby: `>= 3.1`;
+- Ruby: `>= 3.3`;
 
 ---
 
@@ -854,13 +854,14 @@ See `#lock` method [documentation](#lock---obtain-a-lock).
 
 #### #lock_series - (PoC) acquire a series of locks
 
-> (IMPORTANT!) "Proof of Concept" realization. Will be reworked in the future (very-very soon)
+<sup>\[[back to top](#usage)\]</sup>
+
+> (IMPORTANT!) "Proof of Concept" realization. Will be reworked in the future.
 
 `lock_series` - acquire a series of locks simultaniously and hold them all while your block of code is executing
 or (if block is not passed) while all locks will not expire.
 
-If it is not possible to obtain all locks at the same time (taking into queue ttl, retry attempts count for each lock, etc)
-- no any lock will be acquired.
+If it is not possible to obtain all locks at the same time (taking into queue ttl, retry attempts count for each lock, etc) no any lock will be acquired.
 
 Method options is the same as for `lock` method: `retry_count`, `retry_jitter`, `ttl`, `queue_ttl`, etc. Each option will be
 applied with the same value to the each lock acquirement process (for each lock in a series separately).
@@ -880,7 +881,7 @@ applied with the same value to the each lock acquirement process (for each lock
 
 ##### How to use:
 
-- method signature is the same as the `lock` method;
+- method signature is the same as the `#lock`;
 
 ```ruby
 # typical logic-oriented way
@@ -937,7 +938,7 @@ client.lock_seires('c', 'a', 'b') # ... `a` is still obtained
 }
 ```
 
-##### New instrumentaiton events and logs:
+###### New instrumentaiton events:
 
 ```ruby
 # NEW instrumentation events (examples)
@@ -945,6 +946,8 @@ client.lock_seires('c', 'a', 'b') # ... `a` is still obtained
 "redis_queued_locks.lock_series_hold_and_release" => # {lock_keys: ["rql:lock:x", "rql:lock:y", "rql:lock:z"], hold_time: 0.29, ttl: 5000, acq_id: "rql:acq:4486/1696/1704/1712/e6fd0da7991e4303", hst_id: "rql:hst:4486/1696/1712/e6fd0da7991e4303", ts: 1769627106.4717052, acq_time: 4.26, instrument: nil}
 ```
 
+###### New logs:
+
 ```shell
 # NEW logs (examples)
 [redis_queued_locks.start_lock_series_obtaining] lock_keys => '["rql:lock:a", "rql:lock:b"]'queue_ttl => 15 acq_id => 'rql:acq:4486/1696/1704/1712/e6fd0da7991e4303' hst_id => 'rql:hst:4486/1696/1712/e6fd0da7991e4303' acs_strat => 'queued'
@@ -956,6 +959,8 @@ client.lock_seires('c', 'a', 'b') # ... `a` is still obtained
 
 #### #lock_series! - (PoC) exceptional `lock_series`
 
+<sup>\[[back to top](#usage)\]</sup>
+
 > (IMPORTANT!) "Proof of Concept" realization. Will be reworked in the future (very-very soon)
 
 For more details see `lock_series` [docs](#lock_series---poc-acquire-a-series-of-locks)
@@ -2430,7 +2435,8 @@ Detalized event semantics and payload structure:
     some GVL-related things and problem situations when the global watcher thread is "dead";
   - lock request prioritization;
   - **strict redlock algorithm support** (support for many `RedisClient` instances that are fully independent (distributed redis instances));
-  - `#lock_series` - acquire a series of locks:
+  - #lock_series` - acquire a series of locks:
+    - (NOTE: "Proof of Concept" implementation is ready to use);
     ```ruby
     rql.lock_series('lock_a', 'lock_b', 'lock_c') { puts 'locked' }
     ```
@@ -2477,6 +2483,8 @@ Detalized event semantics and payload structure:
   - **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 its logic) has incompatible type (means: some other program uses our key with their own type and logic and RQL can't work properly);
   - yardoc docs with CI check (full doc coverage check);
+  - split *exception* inheritance to the groups: `lock obtaining errors`, `block invocation errors`, `swarm errors`, and other groups (research possible groups):
+    - in some cases we need to intercept "Lock Obtaining Process Erros", in other cases: "Block Invocation Errors", and so on (in `Lock Serirs PoC` for example);
 
 ---
 

data/lib/redis_queued_locks/acquirer/lock_series_poc.rb

@@ -15,7 +15,7 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
   class << self
     # @api private
     # @since 1.16.0
-    # @version 1.16.1
+    # @version 1.16.2
     def lock_series_poc( # steep:ignore
       redis,
       lock_names,
@@ -175,8 +175,12 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
               instr_sampler:,
               instr_sample_this:
             )
-          rescue => error
-            if raise_errors && successfully_acquired_locks.any?
+          rescue RedisQueuedLocks::LockAlreadyObtainedError,
+                 RedisQueuedLocks::LockAcquirementIntermediateTimeoutError,
+                 RedisQueuedLocks::LockAcquirementTimeoutError,
+                 RedisQueuedLocks::LockAcquirementRetryLimitError,
+                 RedisQueuedLocks::ConflictLockObtainError => error
+            if successfully_acquired_locks.any?
               # NOTE: release all previously acquired locks if any next lock is already locked
               successfully_acquired_locks.each do |operation_result|
                 lock_key = RedisQueuedLocks::Resource.prepare_lock_key(operation_result[:lock_name])
@@ -187,7 +191,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
                 end
               end
             end
-            raise(error)
+
+            raise(error) if raise_errors
           end
 
         if result[:ok]
@@ -225,61 +230,67 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
           RedisQueuedLocks::Resource::REDIS_TIMESHIFT_ERROR
         ).ceil(2)
 
-        yield_result = yield_expire( # steep:ignore
-          redis,
-          logger,
-          lock_keys_for_instrumentation.last,
-          acquirer_id_for_instrumentation,
-          host_id_for_instrumentation,
-          access_strategy,
-          timed,
-          ttl_shift,
-          ttl,
-          queue_ttl,
-          meta,
-          log_sampled,
-          instr_sampled,
-          false, # should_expire (expire manually)
-          false, # should_decrease (expire manually)
-          &block
-        )
+        yield_result = nil
+        is_lock_manually_released = nil
+        hold_time = nil
 
-        is_lock_manually_released = false
+        begin
+          yield_result = yield_expire( # steep:ignore
+            redis,
+            logger,
+            lock_keys_for_instrumentation.last,
+            acquirer_id_for_instrumentation,
+            host_id_for_instrumentation,
+            access_strategy,
+            timed,
+            ttl_shift,
+            ttl,
+            queue_ttl,
+            meta,
+            log_sampled,
+            instr_sampled,
+            false, # should_expire (expire manually)
+            false, # should_decrease (expire manually)
+            &block
+          )
+        ensure
+          is_lock_manually_released = false
 
-        # expire locks manually
-        if block_given?
-          redis.with do |conn|
-            # use transaction in order to exclude any cross-locking during the group expiration
-            conn.multi(watch: lock_keys_for_instrumentation) do |transaction|
-              lock_keys_for_instrumentation.each do |lock_key|
-                transaction.call('EXPIRE', lock_key, '0')
+          # expire locks manually
+          if block_given?
+            redis.with do |conn|
+              # use transaction in order to exclude any cross-locking during the group expiration
+              conn.multi(watch: lock_keys_for_instrumentation) do |transaction|
+                lock_keys_for_instrumentation.each do |lock_key|
+                  transaction.call('EXPIRE', lock_key, '0')
+                end
               end
             end
+            is_lock_manually_released = true
           end
-          is_lock_manually_released = true
-        end
 
-        rel_time = RedisQueuedLocks::Utilities.clock_gettime
-        hold_time = ((rel_time - acq_end_time) / 1_000.0).ceil(2)
-        ts = Time.now.to_f
+          rel_time = RedisQueuedLocks::Utilities.clock_gettime
+          hold_time = ((rel_time - acq_end_time) / 1_000.0).ceil(2)
+          ts = Time.now.to_f
 
-        RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor.expire_lock_series( # steep:ignore
-          logger, log_sampled, lock_keys_for_instrumentation,
-          queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation, access_strategy
-        ) if is_lock_manually_released
+          RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor.expire_lock_series( # steep:ignore
+            logger, log_sampled, lock_keys_for_instrumentation,
+            queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation, access_strategy
+          ) if is_lock_manually_released
 
-        RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor.lock_series_hold_and_release( # steep:ignore
-          instrumenter,
-          instr_sampled,
-          lock_keys_for_instrumentation,
-          ttl,
-          acquirer_id_for_instrumentation,
-          host_id_for_instrumentation,
-          ts,
-          acq_time,
-          hold_time,
-          instrument
-        ) if is_lock_manually_released
+          RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor.lock_series_hold_and_release( # steep:ignore
+            instrumenter,
+            instr_sampled,
+            lock_keys_for_instrumentation,
+            ttl,
+            acquirer_id_for_instrumentation,
+            host_id_for_instrumentation,
+            ts,
+            acq_time,
+            hold_time,
+            instrument
+          ) if is_lock_manually_released
+        end
 
         if detailed_result
           {

data/lib/redis_queued_locks/version.rb

@@ -5,6 +5,6 @@ module RedisQueuedLocks
   #
   # @api public
   # @since 0.0.1
-  # @version 1.16.1
-  VERSION = '1.16.1'
+  # @version 1.16.2
+  VERSION = '1.16.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 1.16.1
+  version: 1.16.2
 platform: ruby
 authors:
 - Rustam Ibragimov