redis_queued_locks 1.16.0 → 1.16.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38fff24c73bc7a295a40e9cf9bd2b83ab59c9881690992ff8f697f01332423e6
-  data.tar.gz: abd042d5ef25b0d8745d4551ace657fbf622aab09afbc6a2162a8fea9100143a
+  metadata.gz: 0bd0b3bb446d6ce5af47949de25834b0c4f87a3fcb1090bf9604fba129354468
+  data.tar.gz: b9c8c49560e193db92d63fc232c31fbdf1ea03b72b28fc778c3fcc22da3af1d1
 SHA512:
-  metadata.gz: c06c9a81b8809bc67a7003d479efb3aba3f57a595fd05fe8e53ac94bc0150023e0b5249c1f64130b224c31e3bb08c243679e763f916ab7f3baac2feaa05a49eb
-  data.tar.gz: 869b6a0a2c2e6249a944f62f258772ca2f3346fe613597bc97090adaa2d7867f1ec2bc936690b2822f06e6d3842880a9bec601af0ff06c57a0fab008b00878be
+  metadata.gz: dcea0a7ee67e7a727fe0d92d88bf8f6b0a946c279fce3d43f34e6fe05844cf156e9679d91fcd12f450ebd9029a0aabd9f61b9c5224b7a88fa4551202bd716939
+  data.tar.gz: 0c0b132e65106ce28f68a41278adc7981150b3a50d73952f55bfa22d0b735e8713924a20adca4caedd0fb744587a5675cbab0a78339c02d695b516129a2bd480

data/CHANGELOG.md

@@ -1,4 +1,29 @@
-## [1.16.0]
+## [Unreleased]
+
+## [1.16.1] - 2026-01-28
+### Changed
+- `lock_series` PoC:
+  - added own instrumentation visitor and log ivsitor (`RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor` and
+   `RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor` respectively) and all `lock_series`-related
+   instrumentation/log methods were moved to these modules;
+  - documentaiton updates;
+- YARDOC documentaiton updates;
+### Added
+- `lock_series` PoC updates:
+  - added missing instrumentation event `lock_series_obtained`;
+  - added more data to the `detailed_event: true` lock invocation result:
+    - `locks_release_strategy` - `:immediate_release_after_yield` or `:redis_key_ttl`
+### Fixed
+- `lock_series` PoC:
+  - incorrect instrumentation/logs data:
+    - `expire_lock_series` log and instrumentation event should not be produced
+      when locks were obtained without a block of code (for this case obtained locks
+      lives in redis with their TTL);
+    - `locks_released_at` and `locks_hold_time` of the detailed invocation result (`detailed: true`)
+      has nil values in case when locks are obtained without a block of code
+      (lokcs are not released at this moment and lives in redis with their TTL);
+
+## [1.16.0] - 2026-01-27
 ### Added
 - Brand new Feature **"Lock series of locks"**
   - (*Proof of Concpet*-based implementation at the moment) 

data/README.md

@@ -859,51 +859,97 @@ See `#lock` method [documentation](#lock---obtain-a-lock).
 `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.
+
+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).
+
 **IMPORTANT DETAILS AND LIMITATIONS**:
-- (this behavior will be reworked with another algorithm);
+- (this behavior will be reworked with another algorithm in future);
 - each lock will be released with the next formula: 
   - `lock position with reverse numbering` * `ttl`
     - (positions exmaple: ["a", "b", "c"] => "a" position is 3, "b" position is 2, "c" position is 1);
-  - this means taht in case of 3 locks (`lock_series("x", "y", "z", ttl: 15_000`) with `5 seconds TTL` your locks will be with the next TTL:
+  - this means that in case of 3 locks (`lock_series("x", "y", "z", ttl: 5_000`) with `5 seconds TTL` your locks will be with the next TTL:
     - `"x"` - 15 seconds
     - `"y"` - 10 seconds
     - `"z"` - 5 seconds
 - when your block of code has completed their execution - all locks will be released immediatly;
-- if you did not pass a block - all locks will be released with their forumla-based own TTL described above;
+- if you did not pass a block - all locks will be released with their forumla-based TTL described above;
   - **HOW WILL THIS CASE WORK IN FUTURE RELESAE**: all locks will have the same TTL (`5 seconds` for our example, not `15/10/5 seconds`);
 
-###### How to use:
+##### How to use:
+
+- method signature is the same as the `lock` method;
 
 ```ruby
 # typical logic-oriented way
 client.lock_series("a", "b", "c") { ...some_code... }
 
-# result-oriented way
+# result-oriented way:
+# - (block is passed)
 detailed_result = client.lock_series('x', 'y', 'z', detailed_result: true) { 1 + 2 }
 detailed_result # =>
 {
   yield_result: 3, # result of your block of code
+  lock_release_strategy: :immediate_release_after_yield, # (block is passed)
   locks_released_at: 1769506100.676884, # (instrumentation) release time, epoch
   locks_acq_time: 7.0, # (instrumentation) time spent to acquire all locks, milliseconds
-  locks_hold_time: 0.65, # (instrumentation) lock hold period, milliseconds
+  locks_hold_time: 0.65, # (instrumentation) lock series hold period (hold preiod of all required locks), milliseconds
+  lock_series: ["x", "y", "z"], # your locks
+  rql_lock_series: ["rql:lock:x", "rql:lock:y", "rql:lock:z"] # internal RQL lock-keys of your locks
+}
+
+# - (block is not passed)
+detailed_result = client.lock_series('x', 'y', 'z', detailed_result: true)
+detailed_result # =>
+{
+  yield_result: nil, # block is not given - nothing to return
+  lock_release_strategy: :redis_key_ttl, # block is not given - locks are living in redis with their TTL
+  locks_released_at: nil, # (instrumentation) # block is not given - locks are living in redis with their TTL
+  locks_acq_time: 7.0, # (instrumentation) time spent to acquire all locks, milliseconds
+  locks_hold_time: nil, # (instrumentation) # block is not given - locks are living in redis with their TTL
   lock_series: ["x", "y", "z"], # your locks
   rql_lock_series: ["rql:lock:x", "rql:lock:y", "rql:lock:z"] # internal RQL lock-keys of your locks
 }
 ```
 
-###### New instrumentaiton events and logs:
+```ruby
+# (failed lock obtainig) when lock series can not be obtained for some reasons
+# for example: one of required lock in series is still obtained and can not be obtained now (and all retries are exhausted)
+
+# - lock 'a' is obtained with long ttl
+client.lock('a', ttl: 10_000_000)
+
+# - try to bobtain series of locks with `a` inside the series (`a` can not be obtained for now)
+client.lock_seires('c', 'a', 'b') # ... `a` is still obtained 
+# =>
+{
+  ok: false,
+  result: {
+    error: :failed_to_acquire_lock_series,
+    detailed_errors: { 'a' => { ok: false, result: :retry_limit_reached } },
+    lock_series: ["c", "a", "b"],
+    acquired_locks: ["c"],
+    missing_locks: ["a", "b"],
+    failed_on_lock: ["a"],
+  }
+}
+```
+
+##### New instrumentaiton events and logs:
 
 ```ruby
 # NEW instrumentation events (examples)
-"redis_queued_locks.lock_series_hold_and_release" => {hold_time: 6.41, ttl: 5000, acq_id: "rql:acq:57147/1696/1704/1712/70ff69bc025ace02", hst_id: "rql:hst:57147/1696/1712/70ff69bc025ace02", ts: 1769505674.958648, lock_keys: ["rql:lock:a", "rql:lock:b"], acq_time: 2.35, instrument: nil}
-"redis_queued_locks.lock_obtained" => {lock_key: "rql:lock:x", ttl: 15675, acq_id: "rql:acq:57685/1696/1704/1712/b5b8c38227c18e8a", hst_id: "rql:hst:57685/1696/1712/b5b8c38227c18e8a", ts: 1769505795.984393, acq_time: 4.15, instrument: nil}
+"redis_queued_locks.lock_series_obtained" => # {lock_keys: ["rql:lock:s", "rql:lock:t", "rql:lock:u"], ttl: 5000, acq_id: "rql:acq:4486/1696/1704/1712/e6fd0da7991e4303", hst_id: "rql:hst:4486/1696/1712/e6fd0da7991e4303", ts: "2026-01-28 22:05:06 +0300", acq_time: 2.61, instrument: nil}
+"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}
 ```
 
 ```shell
 # NEW logs (examples)
-[redis_queued_locks.start_lock_series_obtaining] lock_keys => '["rql:lock:x", "rql:lock:y", "rql:lock:c"]'queue_ttl => 15 acq_id => 'rql:acq:57685/1696/1704/1712/b5b8c38227c18e8a' hst_id => 'rql:hst:57685/1696/1712/b5b8c38227c18e8a' acs_strat => 'queued'
-[redis_queued_locks.lock_series_obtained] lock_keys => '["rql:lock:x", "rql:lock:y", "rql:lock:z"]' queue_ttl => 15 acq_id => 'rql:acq:57685/1696/1704/1712/b5b8c38227c18e8a' hst_id => 'rql:hst:57685/1696/1712/b5b8c38227c18e8a' acs_strat => 'queued' acq_time => 7.02 (ms)
-[redis_queued_locks.expire_lock_series] lock_keys => '["rql:lock:x", "rql:lock:y", "rql:lock:z"]' queue_ttl => 15 acq_id => 'rql:acq:57685/1696/1704/1712/b5b8c38227c18e8a' hst_id => 'rql:hst:57685/1696/1712/b5b8c38227c18e8a' acs_strat => 'queued'
+[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'
+[redis_queued_locks.lock_series_obtained] 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' acq_time => 2.55 (ms)
+[redis_queued_locks.expire_lock_series] lock_keys => '["rql:lock:x", "rql:lock:y", "rql:lock:z"]' queue_ttl => 15 acq_id => 'rql:acq:4486/1696/1704/1712/e6fd0da7991e4303' hst_id => 'rql:hst:4486/1696/1712/e6fd0da7991e4303' acs_strat => 'queued'
 ```
 
 ----
@@ -915,7 +961,7 @@ detailed_result # =>
 For more details see `lock_series` [docs](#lock_series---poc-acquire-a-series-of-locks)
 
 ```ruby
-client.lock_series!("x", "y", "z")
+client.lock_series!("x", "y", "z") { ...some_code... }
 ```
 
 ----

data/lib/redis_queued_locks/acquirer/acquire_lock/instr_visitor.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 1.16.0
-# rubocop:disable Metrics/ModuleLength
+# @since 1.7.0
 module RedisQueuedLocks::Acquirer::AcquireLock::InstrVisitor
   class << self
     # @param instrumenter [#notify]
@@ -163,27 +162,5 @@ module RedisQueuedLocks::Acquirer::AcquireLock::InstrVisitor
         hold_time:, ttl:, acq_id:, hst_id:, ts:, lock_key:, acq_time:, instrument:
       }) rescue nil
     end
-
-    # NOTE: Lock Series PoC
-    # @api private
-    # @since 1.16.0
-    def lock_series_hold_and_release( # steep:ignore
-      instrumenter,
-      instr_sampled,
-      lock_keys,
-      ttl,
-      acq_id,
-      hst_id,
-      ts,
-      acq_time,
-      hold_time,
-      instrument
-    )
-      return unless instr_sampled
-      instrumenter.notify('redis_queued_locks.lock_series_hold_and_release', {
-        hold_time:, ttl:, acq_id:, hst_id:, ts:, lock_keys:, acq_time:, instrument:
-      }) # rescue nil
-    end
   end
 end
-# rubocop:enable Metrics/ModuleLength

data/lib/redis_queued_locks/acquirer/acquire_lock/log_visitor.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # @api private
-# @since 1.16.0
+# @since 1.7.0
 # rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Acquirer::AcquireLock::LogVisitor
   # rubocop:disable Metrics/ClassLength
@@ -39,30 +39,6 @@ module RedisQueuedLocks::Acquirer::AcquireLock::LogVisitor
       end rescue nil
     end
 
-    # NOTE: Lock Series PoC
-    # @api private
-    # @since 1.16.0
-    def start_lock_series_obtaining( # steep:ignore
-      logger,
-      log_sampled,
-      lock_keys,
-      queue_ttl,
-      acquirer_id,
-      host_id,
-      access_strategy
-    )
-      return unless log_sampled
-
-      logger.debug do
-        "[redis_queued_locks.start_lock_series_obtaining] " \
-        "lock_keys => '#{lock_keys.inspect}'" \
-        "queue_ttl => #{queue_ttl} " \
-        "acq_id => '#{acquirer_id}' " \
-        "hst_id => '#{host_id}' " \
-        "acs_strat => '#{access_strategy}'"
-      end # rescue nil
-    end
-
     # @param logger [::Logger,#debug]
     # @param log_sampled [Boolean]
     # @param lock_key [String]
@@ -236,32 +212,6 @@ module RedisQueuedLocks::Acquirer::AcquireLock::LogVisitor
         "acq_time => #{acq_time} (ms)"
       end rescue nil
     end
-
-    # NOTE: Lock Series PoC
-    # @api private
-    # @since 1.16.0
-    def lock_series_obtained( # steep:ignore
-      logger,
-      log_sampled,
-      lock_keys,
-      queue_ttl,
-      acquirer_id,
-      host_id,
-      acq_time,
-      access_strategy
-    )
-      return unless log_sampled
-
-      logger.debug do
-        "[redis_queued_locks.lock_series_obtained] " \
-        "lock_keys => '#{lock_keys.inspect}' " \
-        "queue_ttl => #{queue_ttl} " \
-        "acq_id => '#{acquirer_id}' " \
-        "hst_id => '#{host_id}' " \
-        "acs_strat => '#{access_strategy}' " \
-        "acq_time => #{acq_time} (ms)"
-      end # rescue nil
-    end
   end
   # rubocop:enable Metrics/ClassLength
 end

data/lib/redis_queued_locks/acquirer/acquire_lock/yield_expire/log_visitor.rb

@@ -37,30 +37,6 @@ module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire::LogVisitor
       end rescue nil
     end
 
-    # NOTE: Lock Series PoC
-    # @api private
-    # @since 1.16.0
-    def expire_lock_series( # steep:ignore
-      logger,
-      log_sampled,
-      lock_series,
-      queue_ttl,
-      acquirer_id,
-      host_id,
-      access_strategy
-    )
-      return unless log_sampled
-
-      logger.debug do
-        "[redis_queued_locks.expire_lock_series] " \
-        "lock_keys => '#{lock_series.inspect}' " \
-        "queue_ttl => #{queue_ttl} " \
-        "acq_id => '#{acquirer_id}' " \
-        "hst_id => '#{host_id}' " \
-        "acs_strat => '#{access_strategy}'"
-      end rescue nil
-    end
-
     # @param logger [::Logger,#debug]
     # @param log_sampled [Boolean]
     # @param lock_key [String]

data/lib/redis_queued_locks/acquirer/lock_series_poc/instr_visitor.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# NOTE: Lock Series PoC
+# steep:ignore
+# @api private
+# @since 1.16.1
+module RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor # steep:ignore
+  class << self
+    # NOTE: Lock Series PoC
+    # @api private
+    # @since 1.16.1
+    def lock_series_obtained( # steep:ignore
+      instrumenter,
+      instr_sampled,
+      lock_keys,
+      ttl,
+      acq_id,
+      hst_id,
+      ts,
+      acq_time,
+      instrument
+    )
+      return unless instr_sampled
+      instrumenter.notify('redis_queued_locks.lock_series_obtained', {
+        lock_keys:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
+      }) rescue nil
+    end
+
+    # NOTE: Lock Series PoC
+    # @api private
+    # @since 1.16.1
+    def lock_series_hold_and_release( # steep:ignore
+      instrumenter,
+      instr_sampled,
+      lock_keys,
+      ttl,
+      acq_id,
+      hst_id,
+      ts,
+      acq_time,
+      hold_time,
+      instrument
+    )
+      return unless instr_sampled
+      instrumenter.notify('redis_queued_locks.lock_series_hold_and_release', {
+        lock_keys:, hold_time:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
+      }) # rescue nil
+    end
+  end
+end
+# steep:ignore

data/lib/redis_queued_locks/acquirer/lock_series_poc/log_visitor.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# NOTE: Lock Series PoC
+# steep:ignore
+# @api private
+# @since 1.16.1
+module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
+  class << self
+    # NOTE: Lock Series PoC
+    # @api private
+    # @since 1.16.0
+    def start_lock_series_obtaining( # steep:ignore
+      logger,
+      log_sampled,
+      lock_keys,
+      queue_ttl,
+      acquirer_id,
+      host_id,
+      access_strategy
+    )
+      return unless log_sampled
+
+      logger.debug do
+        "[redis_queued_locks.start_lock_series_obtaining] " \
+        "lock_keys => '#{lock_keys.inspect}'" \
+        "queue_ttl => #{queue_ttl} " \
+        "acq_id => '#{acquirer_id}' " \
+        "hst_id => '#{host_id}' " \
+        "acs_strat => '#{access_strategy}'"
+      end # rescue nil
+    end
+
+    # NOTE: Lock Series PoC
+    # @api private
+    # @since 1.16.0
+    def lock_series_obtained( # steep:ignore
+      logger,
+      log_sampled,
+      lock_keys,
+      queue_ttl,
+      acquirer_id,
+      host_id,
+      acq_time,
+      access_strategy
+    )
+      return unless log_sampled
+
+      logger.debug do
+        "[redis_queued_locks.lock_series_obtained] " \
+        "lock_keys => '#{lock_keys.inspect}' " \
+        "queue_ttl => #{queue_ttl} " \
+        "acq_id => '#{acquirer_id}' " \
+        "hst_id => '#{host_id}' " \
+        "acs_strat => '#{access_strategy}' " \
+        "acq_time => #{acq_time} (ms)"
+      end # rescue nil
+    end
+
+    # NOTE: Lock Series PoC
+    # @api private
+    # @since 1.16.0
+    def expire_lock_series( # steep:ignore
+      logger,
+      log_sampled,
+      lock_series,
+      queue_ttl,
+      acquirer_id,
+      host_id,
+      access_strategy
+    )
+      return unless log_sampled
+
+      logger.debug do
+        "[redis_queued_locks.expire_lock_series] " \
+        "lock_keys => '#{lock_series.inspect}' " \
+        "queue_ttl => #{queue_ttl} " \
+        "acq_id => '#{acquirer_id}' " \
+        "hst_id => '#{host_id}' " \
+        "acs_strat => '#{access_strategy}'"
+      end rescue nil
+    end
+  end
+end

data/lib/redis_queued_locks/acquirer/lock_series_poc.rb

@@ -6,12 +6,16 @@
 # @api private
 # @since 1.16.0
 module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
-  # @since 1.16.0
+  require_relative 'lock_series_poc/log_visitor'
+  require_relative 'lock_series_poc/instr_visitor'
+
+  # @sine 1.16.0
   extend RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire
 
   class << self
     # @api private
     # @since 1.16.0
+    # @version 1.16.1
     def lock_series_poc( # steep:ignore
       redis,
       lock_names,
@@ -123,7 +127,7 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
         identity
       )
 
-      RedisQueuedLocks::Acquirer::AcquireLock::LogVisitor.start_lock_series_obtaining( # steep:ignore
+      RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor.start_lock_series_obtaining( # steep:ignore
         logger, log_sampled, lock_keys_for_instrumentation,
         queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation, access_strategy
       )
@@ -202,13 +206,19 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
       if (successfully_acquired_locks.size == lock_names.size && (successfully_acquired_locks.all? { |res| res[:ok] }))
         acq_end_time = RedisQueuedLocks::Utilities.clock_gettime
         acq_time = ((acq_end_time - acq_start_time) / 1_000.0).ceil(2)
+        ts = Time.now.to_s
 
-        RedisQueuedLocks::Acquirer::AcquireLock::LogVisitor.lock_series_obtained( # steep:ignore
+        RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor.lock_series_obtained( # steep:ignore
           logger, log_sampled, lock_keys_for_instrumentation,
           queue_ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation,
           acq_time, access_strategy
         )
 
+        RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor.lock_series_obtained( # steep:ignore
+          instrumenter, instr_sampled, lock_keys_for_instrumentation,
+          ttl, acquirer_id_for_instrumentation, host_id_for_instrumentation, ts, acq_time, instrument
+        )
+
         yield_time = RedisQueuedLocks::Utilities.clock_gettime
         ttl_shift = (
           (yield_time - acq_end_time) / 1_000.0 -
@@ -234,6 +244,8 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
           &block
         )
 
+        is_lock_manually_released = false
+
         # expire locks manually
         if block_given?
           redis.with do |conn|
@@ -244,18 +256,19 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
               end
             end
           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
 
-        RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire::LogVisitor.expire_lock_series( # steep:ignore
+        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::AcquireLock::InstrVisitor.lock_series_hold_and_release( # steep:ignore
+        RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor.lock_series_hold_and_release( # steep:ignore
           instrumenter,
           instr_sampled,
           lock_keys_for_instrumentation,
@@ -266,14 +279,15 @@ module RedisQueuedLocks::Acquirer::LockSeriesPoC # steep:ignore
           acq_time,
           hold_time,
           instrument
-        )
+        ) if is_lock_manually_released
 
         if detailed_result
           {
             yield_result: yield_result,
-            locks_released_at: ts,
+            locks_release_strategy: block_given? ? :immediate_release_after_yield : :redis_key_ttl,
+            locks_released_at: block_given? ? ts : nil,
             locks_acq_time: acq_time,
-            locks_hold_time: hold_time,
+            locks_hold_time: is_lock_manually_released ? hold_time : nil,
             lock_series: lock_names,
             rql_lock_series: lock_keys_for_instrumentation
           }

data/lib/redis_queued_locks/utilities.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.0.0
-# @version 1.14.0
+# @version 1.16.0
 module RedisQueuedLocks::Utilities
   require_relative 'utilities/lock'
 

data/lib/redis_queued_locks/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 1.16.0
+  version: 1.16.1
 platform: ruby
 authors:
 - Rustam Ibragimov
@@ -66,6 +66,8 @@ files:
 - lib/redis_queued_locks/acquirer/keys.rb
 - lib/redis_queued_locks/acquirer/lock_info.rb
 - lib/redis_queued_locks/acquirer/lock_series_poc.rb
+- lib/redis_queued_locks/acquirer/lock_series_poc/instr_visitor.rb
+- lib/redis_queued_locks/acquirer/lock_series_poc/log_visitor.rb
 - lib/redis_queued_locks/acquirer/locks.rb
 - lib/redis_queued_locks/acquirer/queue_info.rb
 - lib/redis_queued_locks/acquirer/queues.rb