redis_queued_locks 1.11.0 → 1.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7161dbfaa5660709705978e003201b12c4684d5c271fc700710802b10586e00
-  data.tar.gz: efaf7103b6bddfd708aceca2d967f282e60b6a74b43c7de2314512cdc963fd19
+  metadata.gz: 419bb42dc0f90c9cfac1107f3eb93ab4e5185d17efa53f78012eed09aee03931
+  data.tar.gz: c9e1471bc65375cbabe88276c7144460b05bb3e0cb4880a75b061514578a4e3d
 SHA512:
-  metadata.gz: 4736b2cf3ec4fa9a121425769a5037aa78d2f5765829533fd4cb830f3e184b856d03a5fc2e7653df3a49c47975de074120f55ddc88476d78b623131ffc718f48
-  data.tar.gz: eb2e86d9764606a11f7c547e8e1ff6b126a26a3cbfd3ea6cff0f670625d6845a441eb7ef6ad9c0e9ce125e0f5fb983feb068205b04bb5a27b85307d5119140d9
+  metadata.gz: aa5e610820ffb105003d09918ee5df8c51989de24a0473eb0d9056deb5e0c2de0cc8c23c220bd4b8da14a7ff0d2b2c7271cc521862263251c03382d4f246f302
+  data.tar.gz: dc14d292c361c798c1cd5a375ff48f271d96a35246c2e463d331dfe9dcb116b64f3b17ad95e12a5e5f72f8aad2a243a17cc0ed10a2ab4521773385bc51d2c77d

data/CHANGELOG.md

@@ -1,6 +1,20 @@
 ## [Unreleased]
 
-### [1.11.0] - 2024-08-11
+## [1.12.1]
+### Changed
+- Internal Private API: an internal Reentrant's Lock utility (`RedisQueuedLocks::Utilities::Lock`) basis
+  is changed from `::Mutex` to `::Monitor` in order to use Ruby's Core C-based
+  implementation (prevent some Ruby-runtime based GVL-oriented locking) of re-entrant locks
+  instead of the custom Ruby-based implementation;
+### Fixed
+- `redis_queued_locks.lock_hold_and_release` instrumentation event has incorrect `acq_time` payload value
+  (it incorrectly stores `lock_key` payload value);
+
+## [1.12.0] - 2024-08-11
+### Changed
+- Timed blocks of code and their timeout errors: reduced error message object allocations;
+
+## [1.11.0] - 2024-08-11
 ### Changed
 - Lock Acquierment Timeout (`acq_timeout`/`queue_ttl`): more correct timeout error interception
   inside the `RedisQueuedLocks::Acquier::AcquireLock::WithAcqTimeout` logic that now raises and

data/README.md

@@ -2073,25 +2073,34 @@ Detalized event semantics and payload structure:
       trying to ressurect unexpectedly terminated swarm elements, and will notify about this;
     - swarm logs (thread/ractor has some limitations so the initial implementation does not include swarm logging);
     - swarm instrumentation (thread/ractor has some limitations so the initial implementation does not include swarm instrumentation);
+  - isolated timeouts which are independent of internal Ruby's timeout implementation (where all timeouts are hostend inside
+    the global "timeout request" queue and managed by a single global "timeout wathcer" thread). it should prevent any logic and timeout intersections,
+    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);
+  - **strict redlock algorithm support** (support for many `RedisClient` instances that are fully independent (distributed redis instances));
   - `#lock_series` - acquire a series of locks:
     ```ruby
     rql.lock_series('lock_a', 'lock_b', 'lock_c') { puts 'locked' }
     ```
-  - support for `Dragonfly` database backend (https://github.com/dragonflydb/dragonfly) (https://www.dragonflydb.io/);
+  - `light mode`: an ability to work without any debug and instrumentation logic and data (totally reduced debugging and instrumenting possibilities, but better performance);
 - **Minor**:
+  - support for `Dragonfly` database backend (https://github.com/dragonflydb/dragonfly) (https://www.dragonflydb.io/);
+  - (_research_) GVL-isolation for lock acquirement logic (try to bypass Ruby's "context-switching" in order to prevent any time-based affects on lock-acquirement logic);
   - Semantic error objects for unexpected Redis errors;
   - **Experimental feature**: (non-`timed` locks): per-ruby-block-holding-the-lock sidecar `Ractor` and `in progress queue` in RedisDB that will extend
     the acquired lock for long-running blocks of code (that invoked "under" the lock
     whose ttl may expire before the block execution completes). It makes sense for non-`timed` locks *only*;
+  - sized lock queues (with an ability of dynamically growing size);
   - better code stylization (+ some refactorings);
   - `RedisQueuedLocks::Acquier::Try.try_to_lock` - detailed successful result analization;
   - Support for LIFO strategy;
   - better specs with 100% test coverage (total specs rework);
   - statistics with UI;
   - JSON log formatter;
+  - RBS type signatures;
+  - **automatic** deadlock detection;
   - `go`-lang implementation;
+  - (_research_) simplification and speedup of the internal "redis-communuication-and-data-storing"-based algorithms;
 
 ---
 

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

@@ -19,6 +19,8 @@ module RedisQueuedLocks::Acquier::AcquireLock::WithAcqTimeout
   #   Callback invoked on Timeout::Error.
   # @return [Any]
   #
+  # @raise [RedisQueuedLocks::LockAcquiermentIntermediateTimeoutError]
+  #
   # @api private
   # @since 1.0.0
   # @version 1.11.0
@@ -32,10 +34,6 @@ module RedisQueuedLocks::Acquier::AcquireLock::WithAcqTimeout
     on_timeout: nil,
     &block
   )
-    # TODO:
-    #   think about the runtime error class-object creation that perevent any timeout error
-    #   interception collisions (but remember: it can lead to regular internal ruby method/constant
-    #   cache invalidation);
     ::Timeout.timeout(timeout, RedisQueuedLocks::LockAcquiermentIntermediateTimeoutError, &block)
   rescue RedisQueuedLocks::LockAcquiermentIntermediateTimeoutError
     on_timeout.call unless on_timeout == nil

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

@@ -107,28 +107,22 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
   # @param block [Blcok]
   # @return [Any]
   #
+  # @raise [RedisQueuedLocks::TimedLockTimeoutError]
+  #
   # @api private
   # @since 1.3.0
-  # @version 1.10.0
+  # @version 1.12.0
   def yield_with_timeout(timeout, lock_key, lock_ttl, acquier_id, host_id, meta, &block)
-    ::Timeout.timeout(
-      timeout,
+    ::Timeout.timeout(timeout, RedisQueuedLocks::TimedLockIntermediateTimeoutError, &block)
+  rescue RedisQueuedLocks::TimedLockIntermediateTimeoutError
+    raise(
       RedisQueuedLocks::TimedLockTimeoutError,
-      # NOTE:
-      #   - this string is generated on each invocation cuz we need to raise custom exception
-      #     from the Timeout API in order to prevent incorred Timeout::Error interception when
-      #     the intercepted error is caused from the block not from the RQL;
-      #   - we can't omit this string object creation at the moment via original Ruby's Timeout API;
-      # TODO:
-      #   - refine Timeout#timeout (via Ruby's Refinement API) in order to provide lazy exception
-      #     message initialization;
       "Passed <timed> block of code exceeded the lock TTL " \
       "(lock: \"#{lock_key}\", " \
       "ttl: #{lock_ttl}, " \
       "meta: #{meta ? meta.inspect : '<no-meta>'}, " \
       "acq_id: \"#{acquier_id}\", " \
-      "hst_id: \"#{host_id}\")",
-      &block
+      "hst_id: \"#{host_id}\")"
     )
   end
 end

data/lib/redis_queued_locks/acquier/acquire_lock.rb

@@ -154,7 +154,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.9.0
+    # @version 1.12.1
     def acquire_lock(
       redis,
       lock_name,
@@ -531,8 +531,8 @@ module RedisQueuedLocks::Acquier::AcquireLock
                 acq_process[:lock_info][:acq_id],
                 acq_process[:lock_info][:hst_id],
                 acq_process[:lock_info][:ts],
-                acq_process[:lock_info][:lock_key],
                 acq_process[:acq_time],
+                acq_process[:hold_time],
                 instrument
               )
             end

data/lib/redis_queued_locks/errors.rb

@@ -25,6 +25,10 @@ module RedisQueuedLocks
   # @since 1.0.0
   LockAcquiermentRetryLimitError = Class.new(Error)
 
+  # @api private
+  # @since 1.12.0
+  TimedLockIntermediateTimeoutError = Class.new(::Timeout::Error)
+
   # @api pulic
   # @since 1.0.0
   TimedLockTimeoutError = Class.new(Error)

data/lib/redis_queued_locks/utilities/lock.rb

@@ -7,8 +7,9 @@ class RedisQueuedLocks::Utilities::Lock
   #
   # @api private
   # @since 1.9.0
+  # @version 1.13.0
   def initialize
-    @lock = ::Mutex.new
+    @lock = ::Monitor.new
   end
 
   # @param block [Block]
@@ -16,7 +17,8 @@ class RedisQueuedLocks::Utilities::Lock
   #
   # @api private
   # @since 1.9.0
+  # @version 1.13.0
   def synchronize(&block)
-    @lock.owned? ? yield : @lock.synchronize(&block)
+    @lock.synchronize(&block)
   end
 end

data/lib/redis_queued_locks/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 1.11.0
+  version: 1.12.1
 platform: ruby
 authors:
 - Rustam Ibragimov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-11 00:00:00.000000000 Z
+date: 2024-09-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -135,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.17
 signing_key:
 specification_version: 4
 summary: Distributed locks with "prioritized lock acquisition queue" capabilities