redis_queued_locks 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06ddeeb8f9ef0bd0c24742e68e83d10b237f8233ca5183c7f9612e7aebadd874
-  data.tar.gz: df9a7ba009357fc3fa80efc9b5837cec56f10cb9004f54df19e5d08fd06f7f26
+  metadata.gz: 448f8b89e4a34bb2543b55d46877d80f76cf8e4b5d07735486f53eb1edb37432
+  data.tar.gz: 4fbefadd9a162ab298b100bca38387045c65c89918ffd70c3f4aa418aa72d22a
 SHA512:
-  metadata.gz: 722aff2cb859419913d8f47c6118acaab378db70e49034290043cb1f9c3b4df115d15020d37effe815399d389fb360b68f2692a50537165043eb8a659428b6ba
-  data.tar.gz: ef370212d73abc96b1fed6962e274b616bb9b1ed232576ebee0b1e2e2b98d62cbdbe7dbb113ac32b28e489d4142a3a2f91b7f96be1be6c11d285cb948711bfee
+  metadata.gz: 738c503d6189ca4673d1bc5af829066378654a070b78691ae7d1001e832795dbb91f1cde3e89252ff6b9831a659daf517eea1ea2ab721101c9140afe16b44974
+  data.tar.gz: cb2b4893238e55688b01c56f5f0004217d206122d5ae5ef3a0ea8f2d206323442e4c10bf78f3d504f947795864decc712f5385448b205151ccfe7ca39ab9ea0a

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [1.4.0] - 2024-05-13
+### Added
+- `#lock`/`#lock!`: reduced memory allocaiton during `:meta` attribute type checking;
+### Changed
+- More accurate time analyzis operations;
+
+## [1.3.1] - 2024-05-10
+### Fixed
+- `:meta` attribute type validation of `#lock`/`#lock!` was incorrect;
+### Added
+- documentation updates and clarifications;
+
 ## [1.3.0] - 2024-05-08
 ### Added
 - **Major Feature**: support for **Reentrant Locks**;

data/README.md

@@ -151,7 +151,9 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   config.is_timed_by_default = false
 
   # (symbol) (default: :wait_for_lock)
-  # - The conflict strategy mode for cases when the process that obtained the lock want to acquire this lock again;
+  # - Global default conflict strategy mode;
+  # - Can be customized in methods `#lock` and `#lock` via `:conflict_strategy` attribute (see method signatures of #lock and #lock! methods);
+  # - Conflict strategy is a logical behavior for cases when the process that obtained the lock want to acquire this lock again;
   # - Realizes "reentrant locks" abstraction (same process conflict / same process deadlock);
   # - By default uses `:wait_for_lock` strategy (classic way);
   # - Strategies:
@@ -159,7 +161,6 @@ 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;
-  # - Can be customized in methods via `:conflict_strategy` attribute (see method signatures of #lock and #lock! methods);
   # - See "Dead locks and Reentrant Locks" documentation section in REDME.md for details;
   config.default_conflict_strategy = :wait_for_lock
 
@@ -262,10 +263,14 @@ end
 
 <sup>\[[back to top](#usage)\]</sup>
 
-- If block is passed the obtained lock will be released after the block execution or the lock's ttl (what will happen first);
-- If block is not passed the obtained lock will be released after lock's ttl;
-- If block is passed the block's yield result will be returned;
-- If block is not passed the lock information will be returned;
+- `#lock` - obtain a lock;
+- If block is passed:
+  - the obtained lock will be released after the block execution or the lock's ttl (what will happen first);
+    - if you want to timeout (fail with timeout) the block execution with lock's TTL use `timed: true` option;
+  - 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);
 
 ```ruby
 def lock(
@@ -543,10 +548,12 @@ rql.lock("my_lock", queue_ttl: 5, timeout: 10_000, retry_count: nil)
 
 <sup>\[[back to top](#usage)\]</sup>
 
+- `#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::ConflictLockObtainError`) when `conflict_strategy: :dead_locking` is used and the "same-process-dead-lock" is happened (see [Dead locks and Reentrant locks](#dead-locks-and-reentrant-locks) for details);
 
 ```ruby
 def lock!(
@@ -648,7 +655,7 @@ rql.lock_info("your_lock_name")
   # ==> keys for extendable reentarnt locks with `:extendable_work_through` strategy:
   "spc_ext_ttl" => 5_000, # sum of TTL of the each <extendable> reentrant lock (3_000 + 2_000)
   "l_spc_ext_ini_ttl" => 2_000, # TTL of the last <extendable> reentrant lock
-  "l_spc_ext_ts" =>  123456792.12345 # timestamp of the last <extendable> reentrant lock obtaining
+  "l_spc_ext_ts" =>  123456792.12345, # timestamp of the last <extendable> reentrant lock obtaining
   # ==> keys for non-extendable locks with `:work_through` strategy:
   "l_spc_ts" => 123456.789 # timestamp of the last <non-extendable> reentrant lock obtaining
 }
@@ -1073,13 +1080,17 @@ rql.clear_dead_requests(dead_ttl: 60 * 60 * 1000) # 1 hour in milliseconds
 
 <sup>\[[back to top](#table-of-contents)\]</sup>
 
-- **documentation is in progress**
-- (little details for a context of current implementation and feautres):
-  - at this moment we support only **reentrant locks**: they works via customizable conflict strategy behavior;
-  - in non-reentrant conflict cases your lock obtaining process will work in a classic way (some dead lock conflict => work in "wait for lock" style);
+- **this documentation section is in progress**;
+- (little details for a context of the current implementation and feautres):
+  - at this moment we support only **reentrant locks**: they works via customizable conflict strategy behavior
+    (`:wait_for_lock` (default), `:work_through`, `:extendable_work_through`, `:dead_locking`);
+  - by default behavior (`:wait_for_lock`) your lock obtaining process will work in a classic way (limits, retries, etc);
+  - `:work_through`, `:extendable_work_through` works with limits too (timeouts, delays, etc), but the decision of
+    "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 accordingly);
   - for current implementation details check:
-    - (Configuration)[#configuration] documentation: see `config.default_conflict_strategy` config docs;
-    - (#lock)[#lock] method documentation: see `conflict_strategy` attribute 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;
 
 ---
 

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

@@ -49,7 +49,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
     initial_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
 
     if block_given?
-      timeout = ((ttl - ttl_shift) / 1000.0).yield_self do |time|
+      timeout = ((ttl - ttl_shift) / 1_000.0).yield_self do |time|
         # NOTE: time in <seconds> cuz Ruby's Timeout requires <seconds>
         (time < 0) ? 0.0 : time
       end

data/lib/redis_queued_locks/acquier/acquire_lock.rb

@@ -94,7 +94,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.3.0
+    # @version 1.4.0
     def acquire_lock(
       redis,
       lock_name,
@@ -132,7 +132,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
       end
 
       # Step 0.2: prevent :meta incompatabiltiies (structure)
-      if meta == ::Hash && (meta.keys.any? do |key|
+      if meta.is_a?(::Hash) && (meta.any? do |key, _value|
         key == 'acq_id' ||
         key == 'ts' ||
         key == 'ini_ttl' ||
@@ -198,7 +198,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
 
       # Step 2: try to lock with timeout
       with_acq_timeout(timeout, lock_key, raise_errors, on_timeout: acq_dequeue) do
-        acq_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        acq_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
 
         # Step 2.1: cyclically try to obtain the lock
         while acq_process[:should_try]
@@ -241,8 +241,8 @@ module RedisQueuedLocks::Acquier::AcquireLock
             meta
           ) => { ok:, result: }
 
-          acq_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-          acq_time = ((acq_end_time - acq_start_time) * 1_000).ceil(2)
+          acq_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+          acq_time = ((acq_end_time - acq_start_time) / 1_000.0).ceil(2)
 
           # Step X: save the intermediate results to the result observer
           acq_process[:result] = result
@@ -403,10 +403,10 @@ module RedisQueuedLocks::Acquier::AcquireLock
         # Step 3.a: acquired successfully => run logic or return the result of acquirement
         if block_given?
           begin
-            yield_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            yield_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
 
             ttl_shift = (
-              (yield_time - acq_process[:acq_end_time]) * 1000 -
+              (yield_time - acq_process[:acq_end_time]) / 1_000.0 -
               RedisQueuedLocks::Resource::REDIS_TIMESHIFT_ERROR
             ).ceil(2)
 
@@ -431,9 +431,11 @@ module RedisQueuedLocks::Acquier::AcquireLock
               &block
             )
           ensure
-            acq_process[:rel_time] = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            acq_process[:rel_time] = ::Process.clock_gettime(
+              ::Process::CLOCK_MONOTONIC, :microsecond
+            )
             acq_process[:hold_time] = (
-              (acq_process[:rel_time] - acq_process[:acq_end_time]) * 1000
+              (acq_process[:rel_time] - acq_process[:acq_end_time]) / 1_000.0
             ).ceil(2)
 
             if acq_process[:result][:process] == :extendable_conflict_work_through ||

data/lib/redis_queued_locks/acquier/clear_dead_requests.rb

@@ -15,7 +15,7 @@ module RedisQueuedLocks::Acquier::ClearDeadRequests
     # @api private
     # @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)
+      dead_score = RedisQueuedLocks::Resource.acquier_dead_score(dead_ttl / 1_000.0)
 
       result = Set.new.tap do |processed_queues|
         redis_client.with do |rconn|

data/lib/redis_queued_locks/acquier/release_all_locks.rb

@@ -28,12 +28,13 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     #
     # @api private
     # @since 1.0.0
+    # @version 1.4.0
     def release_all_locks(redis, batch_size, logger, instrumenter, instrument)
-      rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
       fully_release_all_locks(redis, batch_size) => { ok:, result: }
       time_at = Time.now.to_f
-      rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-      rel_time = ((rel_end_time - rel_start_time) * 1_000).ceil(2)
+      rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+      rel_time = ((rel_end_time - rel_start_time) / 1_000).ceil(2)
 
       run_non_critical do
         instrumenter.notify('redis_queued_locks.explicit_all_locks_release', {

data/lib/redis_queued_locks/acquier/release_lock.rb

@@ -28,15 +28,16 @@ module RedisQueuedLocks::Acquier::ReleaseLock
     #
     # @api private
     # @since 1.0.0
+    # @version 1.4.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)
 
-      rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
       fully_release_lock(redis, lock_key, lock_key_queue) => { ok:, result: }
       time_at = Time.now.to_f
-      rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-      rel_time = ((rel_end_time - rel_start_time) * 1_000).ceil(2)
+      rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+      rel_time = ((rel_end_time - rel_start_time) / 1_000).ceil(2)
 
       run_non_critical do
         instrumenter.notify('redis_queued_locks.explicit_lock_release', {

data/lib/redis_queued_locks/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Rustam Ibragimov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-08 00:00:00.000000000 Z
+date: 2024-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -108,7 +108,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.1
 signing_key:
 specification_version: 4
 summary: Queued distributed locks based on Redis.