redis_queued_locks 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5cac51b8b6c2a4986c188d7b419e11a282c4a18d6a32689000a2c9127f77eec3
-  data.tar.gz: d159e30574e503a714081dfda22d9085553818573ad968f745e302efe93edfde
+  metadata.gz: 448f8b89e4a34bb2543b55d46877d80f76cf8e4b5d07735486f53eb1edb37432
+  data.tar.gz: 4fbefadd9a162ab298b100bca38387045c65c89918ffd70c3f4aa418aa72d22a
 SHA512:
-  metadata.gz: 6ee000a0470297832a593a8719a192feb5fdf583003d49f8dfb3335dad4c63aff45730cc8d4481a02eb41f629e60d929349fcc1842025117bd5b35304a09c8cd
-  data.tar.gz: c7e52ef09012e29a2ac1495fedc287c7a51c5fee8ceac466f78d5de548e8231b7a5c8fc29626db28ca82629ac0294b4ded991cbf5902f97a76619279bed4e353
+  metadata.gz: 738c503d6189ca4673d1bc5af829066378654a070b78691ae7d1001e832795dbb91f1cde3e89252ff6b9831a659daf517eea1ea2ab721101c9140afe16b44974
+  data.tar.gz: cb2b4893238e55688b01c56f5f0004217d206122d5ae5ef3a0ea8f2d206323442e4c10bf78f3d504f947795864decc712f5385448b205151ccfe7ca39ab9ea0a

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [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;

data/README.md

@@ -1086,7 +1086,7 @@ rql.clear_dead_requests(dead_ttl: 60 * 60 * 1000) # 1 hour in milliseconds
     (`: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/without
+    "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;

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.1
+    # @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.is_a?(::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.1
-  VERSION = '1.3.1'
+  # @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.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Rustam Ibragimov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-10 00:00:00.000000000 Z
+date: 2024-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client