redis_queued_locks 0.0.40 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b46bd07dab8fc9ce3228eb7bb804569a99dfc8f7f65a1eaf085c3af9061ae09e
-  data.tar.gz: 2c9470b5dd4b41a112c93bb891f33ff68f930dc47fd78a37516540249ded415d
+  metadata.gz: 6b175564df436902d56e07a376f0257118eced8d7c81dbb81837e63cdef74938
+  data.tar.gz: f88d3e83045cb4dd4dcd10b12744399ce45d3b99a84f6ca492d801a678db55f0
 SHA512:
-  metadata.gz: a7e0740247300cf79385c477a66bc823621888104887de33c3868cf4d06a2087ae6b2ea972e8844fd148e8e3b0da9468cfaf276f68f5d1be7e3b80f72e0c31fe
-  data.tar.gz: d920cda1d4f89da24123df0cf95595c87c21e1e4ed18495765ae0f78c1714af325f94e8e88a7971e4bb10250dde4f392095e8d19f010e9a5f0341d3d3201dc0c
+  metadata.gz: ae486564a408bc9039d6b09f3fe08ba37e733bae902ec2c3f55eae84b22a05e6c6f31bc9ceafc5ee78a10ae34dfdc0b3e7dcbfb09a41f74795ed29dce823a6bc
+  data.tar.gz: ba40ab572fb1863b0bcddee6536385d19e3b3c7c9df07b2e2d71d74ad740eccb05a18847222be70bf6796596ce2b93266dbf462dccab294c6200a4441ca1f1a7

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [1.1.0] - 2024-04-01
+### Added
+- Documentation updates:
+  - more `#lock` examples;
+  - added missing docs for `config.dead_request_ttl`;
+  - some minor updates;
+### Changed
+- `#clear_dead_requests`: `:scan_size` is equal to `config[:lock_release_batch_size]` now (instead of to `config[:key_extraction_batch_size]`);
+  cuz `#clear_dead_requests` works with lock releasing;
+
+## [1.0.0] - 2024-04-01
+- First Major Release;
+
 ## [0.0.40] - 2024-04-01
 ### Added
 - `RedisQueuedLocks::Client#clear_dead_requests` implementation;

data/README.md

@@ -1,4 +1,4 @@
-# RedisQueuedLocks · [![Gem Version](https://badge.fury.io/rb/redis_queued_locks.svg)](https://badge.fury.io/rb/redis_queued_locks)
+# RedisQueuedLocks · ![Gem Version](https://img.shields.io/gem/v/redis_queued_locks) ![build](https://github.com/0exp/redis_queued_locks/actions/workflows/build.yml/badge.svg??branch=master)
 
 <a href="https://redis.io/docs/manual/patterns/distributed-locks/">Distributed locks</a> with "lock acquisition queue" capabilities based on the Redis Database.
 
@@ -155,10 +155,16 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   config.lock_release_batch_size = 100
 
   # (default: 500)
-  # - how many items should be extracted from redis during the #locks, #queues and #keys operations (uses SCAN);
+  # - how many items should be extracted from redis during the #locks, #queues, #keys
+  #   #locks_info, and #queues_info operations (uses SCAN);
   # - affects the performance of your Redis and Ruby Application (configure thoughtfully;)
   config.key_extraction_batch_size = 500
 
+  # (default: 1 day)
+  # - the default period of time (in milliseconds) after which a lock request is considered dead;
+  # - used for `#clear_dead_requests` as default vaule of `:dead_ttl` option;
+  config.dead_request_ttl = (1 * 24 * 60 * 60 * 1000) # one day in milliseconds
+
   # (default: RedisQueuedLocks::Instrument::VoidNotifier)
   # - instrumentation layer;
   # - you can provde your own instrumenter with `#notify(event, payload = {})`
@@ -245,7 +251,7 @@ def lock(
   ttl: config[:default_lock_ttl],
   queue_ttl: config[:default_queue_ttl],
   timeout: config[:try_to_lock_timeout],
-  timed: false,
+  timed: config[:is_timed_by_default],
   retry_count: config[:retry_count],
   retry_delay: config[:retry_delay],
   retry_jitter: config[:retry_jitter],
@@ -429,6 +435,24 @@ rql.lock("my_lock", ttl: 6_500) # blocks execution until the lock is obtained
 puts "Let's go" # will be called immediately after the lock is obtained
 ```
 
+- add custom metadata to the lock (via `:meta` option):
+
+```ruby
+rql.lock("my_lock", ttl: 123456, meta: { "some" => "data", key: 123.456 })
+
+rql.lock_info("my_lock")
+# =>
+{
+  "lock_key" => "rql:lock:my_lock",
+  "acq_id" => "rql:acq:123/456/567/678/374dd74324",
+  "ts" => 123456789,
+  "ini_ttl" => 123456,
+  "rem_ttl" => 123440,
+  "some" => "data",
+  "key" => "123.456" # NOTE: returned as a raw string directly from Redis
+}
+```
+
 ---
 
 #### #lock! - exceptional lock obtaining
@@ -632,12 +656,12 @@ rql.unlock("your_lock_name")
     - pre-configured in `config[:lock_release_batch_size]`;
   - `:logger` - (optional) `[::Logger,#debug]`
     - custom logger object;
-    - has a preconfigured value in `config[:logger]`;
+    - pre-configured value in `config[:logger]`;
   - `:instrumenter` - (optional) `[#notify]`
     - custom instrumenter object;
-    - has a preconfigured value in `config[:isntrumenter]`;
+    - pre-configured value in `config[:isntrumenter]`;
   - `:instrument` - (optional) `[NilClass,Any]`
-    - custom instrumentation data wich will be passed to the instrumenter's payload with :instrument key;
+    - custom instrumentation data wich will be passed to the instrumenter's payload with `:instrument` key;
 
 - returns:
  - `[Hash<Symbol,Numeric>]` - Format: `{ ok: true, result: Hash<Symbol,Numeric> }`;
@@ -865,15 +889,16 @@ rql.queues_info # or rql.qeuues_info(scan_size: 123)
 
 <sup>\[[back to top](#usage)\]</sup>
 
-In some cases your lock requests may become "dead". It can happen when your processs
-that are enqueeud to the lock queue is failed unexpectedly (for some reason) before the lock acquire moment
-and when no any other process does not need this lock anymore. For this case your lock will be cleared only when any process
-will try to acquire this lock again (cuz lock acquirement triggers the removement of expired requests).
+In some cases your lock requests may become "dead". It means that your lock request lives in lock queue in Redis without
+any processing. It can happen when your processs that are enqueeud to the lock queue is failed unexpectedly (for some reason)
+before the lock acquire moment occurs and when no any other process does not need this lock anymore.
+For this case your lock reuquest will be cleared only when any process will try
+to acquire this lock again (cuz lock acquirement triggers the removement of expired requests).
 
 In order to help with these dead requests you may periodically call `#clear_dead_requests`
-with corresponding `dead_ttl` option, that is pre-configured by default via `config[:dead_request_ttl]`.
+with corresponding `:dead_ttl` option, that is pre-configured by default via `config[:dead_request_ttl]`.
 
-An option is required because of it is no any **fast** way to understand which request
+`:dead_ttl` option is required because of it is no any **fast** and **resource-free** way to understand which request
 is dead now and is it really dead cuz each request queue can host their requests with
 a custom queue ttl for each request differently.
 
@@ -1026,15 +1051,15 @@ Detalized event semantics and payload structure:
 
 <sup>\[[back to top](#table-of-contents)\]</sup>
 
+- **strict redlock algorithm support** (support for many `RedisClient` instances);
 - Semantic Error objects for unexpected Redis errors;
-- better specs with 100% test coverage;
-- per-block-holding-the-lock sidecar `Ractor` and `in progress queue` in RedisDB that will extend
+- better specs with 100% test coverage (total rework);
+- (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 only makes sense for non-`timed` locks;
-- lock prioritization;
+  whose ttl may expire before the block execution completes). It makes sense for non-`timed` locks *only*;
+- lock request prioritization;
 - support for LIFO strategy;
-- structured logging (separated docs);
-- GitHub Actions CI;
+- more structured logging (separated docs);
 - `RedisQueuedLocks::Acquier::Try.try_to_lock` - detailed successful result analization;
 - better code stylization (+ some refactorings);
 - statistics with UI;

data/lib/redis_queued_locks/acquier/acquire_lock.rb

@@ -186,7 +186,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
       with_acq_timeout(timeout, lock_key, raise_errors, on_timeout: acq_dequeue) do
         acq_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
 
-        # Step 2.1: caclically try to obtain the lock
+        # Step 2.1: cyclically try to obtain the lock
         while acq_process[:should_try]
           run_non_critical do
             logger.debug do

data/lib/redis_queued_locks/client.rb

@@ -402,11 +402,12 @@ class RedisQueuedLocks::Client
   end
 
   # @option dead_ttl [Integer]
-  #  - the time period (in millsiecnds) after whcih the lock request is
-  #    considered as dead;
-  #  - `config[:dead_request_ttl]` is used by default;
+  #   - the time period (in millsiecnds) after whcih the lock request is
+  #     considered as dead;
+  #   - `config[:dead_request_ttl]` is used by default;
   # @option scan_size [Integer]
-  #   The batch of scanned keys for Redis'es SCAN command.
+  #   - the batch of scanned keys for Redis'es SCAN command;
+  #   - `config[:lock_release_batch_size]` is used by default;
   # @option logger [::Logger,#debug]
   # @option instrumenter [#notify]
   # @option instrument [NilClass,Any]
@@ -417,7 +418,7 @@ class RedisQueuedLocks::Client
   # @since 0.1.0
   def clear_dead_requests(
     dead_ttl: config[:dead_request_ttl],
-    scan_size: config[:key_extraction_batch_size],
+    scan_size: config[:lock_release_batch_size],
     logger: config[:logger],
     instrumenter: config[:instrumenter],
     instrument: nil

data/lib/redis_queued_locks/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 0.0.40
+  version: 1.1.0
 platform: ruby
 authors:
 - Rustam Ibragimov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-31 00:00:00.000000000 Z
+date: 2024-04-02 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.