redis_queued_locks 0.0.15 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3270e2a14a4eed87379d84fe0622f4a231a681fb1e48325a1d6e22becafb5a60
-  data.tar.gz: b67274aeec060e1bef07d64933928c5be3632cc68f88f12cbe01b9105ae41478
+  metadata.gz: eb745a97296f4661f7a68d7719d7bdb894521348d6aa25b92b23b4fcffce56cd
+  data.tar.gz: e12566b1c653ad97bf973887d4511482c628d8ec27fd265901d1d4bfba9c112b
 SHA512:
-  metadata.gz: a40531666d37dc44d738fba4e67e027520a58f029c392a46db8a2e465200d4162ad1fdd44e16b17001edab183b8f9f90621d35f6b026a9c2628abc00ab9ea5b3
-  data.tar.gz: 40392bb5de7d615e52e4a92b5f193c7c72970d220a9963ef89346364788c2dc1d11ef5664b20d0864dd3b151aba6a1f6bb76b45cdc5c016882dd51883df25281
+  metadata.gz: c3e6f4c421c8e6fb9b3933c01ebcd23d5762f0bdb0581333e2d85ab478a8002d8bce360bfabaab29d819c92a4f148e6562d0fa426e5999b0fc2d1c9b59f3eaa7
+  data.tar.gz: 42a5800757191ea80797c7462b765c5dd4187771ce73c6c9af70f6653dea5599710d8569b5a2fc1a0c30cb0b3483abfac557bd888a7f4bcbde4ac4a7de308021

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [0.0.17] - 2024-02-29
+### Added
+- `RedisQueuedLocks::Client#locks` - list of obtained locks;
+- `RedisQueuedLocks::Client#queues` - list of existing lock request queus;
+- `RedisQueuedLocks::Client#keys` - get list of taken locks and queues;
+
+## [0.0.16] - 2024-02-29
+### Fixed
+- Execution delay formula returns the value "in seconds" (should be "in milliseconds");
+
 ## [0.0.15] - 2024-02-28
 ### Added
 - An ability to fail fast if the required lock is already obtained;

data/README.md

@@ -1,4 +1,4 @@
-# RedisQueuedLocks
+# RedisQueuedLocks · [![Gem Version](https://badge.fury.io/rb/redis_queued_locks.svg)](https://badge.fury.io/rb/redis_queued_locks)
 
 Distributed locks with "lock acquisition queue" capabilities based on the Redis Database.
 
@@ -21,6 +21,10 @@ Each lock request is put into the request queue and processed in order of their
   - [queued?](#queued)
   - [unlock](#unlock---release-a-lock)
   - [clear_locks](#clear_locks---release-all-locks-and-lock-queues)
+  - [extend_lock_ttl](#extend_lock_ttl)
+  - [locks](#locks---get-list-of-obtained-locks)
+  - [queues](#queues---get-list-of-lock-request-queues)
+  - [keys](#keys---get-list-of-taken-locks-and-queues)
 - [Instrumentation](#instrumentation)
   - [Instrumentation Events](#instrumentation-events)
 - [Roadmap](#roadmap)
@@ -32,7 +36,7 @@ Each lock request is put into the request queue and processed in order of their
 
 ### Algorithm
 
-- soon;
+- soon
 
 ---
 
@@ -88,8 +92,8 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   # (milliseconds) (default: 200)
   config.retry_delay = 200
 
-  # (milliseconds) (default: 50)
-  config.retry_jitter = 50
+  # (milliseconds) (default: 25)
+  config.retry_jitter = 25
 
   # (seconds) (supports nil)
   # - nil means "no timeout" and you are only limited by "retry_count" config;
@@ -104,10 +108,15 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   config.default_queue_ttl = 15
 
   # (default: 100)
-  # - how many items will be released at a time in RedisQueuedLocks::Client#clear_locks logic;
-  # - affects the performancs capabilites (redis, rubyvm);
+  # - how many items will be released at a time in RedisQueuedLocks::Client#clear_locks logic (uses SCAN);
+  # - affects the performancs of your Redis and Ruby Application (configure thoughtfully);
   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);
+  # - affects the performance of your Redis and Ruby Application (configure thoughtfully;)
+  config.key_extraction_batch_size = 500
+
   # (default: RedisQueuedLocks::Instrument::VoidNotifier)
   # - instrumentation layer;
   # - you can provde your own instrumenter with `#notify(event, payload = {})`
@@ -138,6 +147,10 @@ end
 - [queued?](#queued)
 - [unlock](#unlock---release-a-lock)
 - [clear_locks](#clear_locks---release-all-locks-and-lock-queues)
+- [extend_lock_ttl](#extend_lock_ttl)
+- [locks](#locks---get-list-of-obtained-locks)
+- [queues](#queues---get-list-of-lock-request-queues)
+- [keys](#keys---get-list-of-taken-locks-and-queues)
 
 ---
 
@@ -393,6 +406,94 @@ Return:
 
 ---
 
+#### #extend_lock_ttl
+
+- soon
+
+---
+
+#### #locks - get list of obtained locks
+
+- uses redis `SCAN` under the hood;
+- accepts `scan_size:`/`Integer` option (`config[:key_extraction_batch_size]` by default);
+- returns `Set<String>`
+
+```ruby
+rql.locks # or rql.locks(scan_size: 123)
+
+=>
+#<Set:
+ {"rql:lock:locklock75",
+  "rql:lock:locklock9",
+  "rql:lock:locklock108",
+  "rql:lock:locklock7",
+  "rql:lock:locklock48",
+  "rql:lock:locklock104",
+  "rql:lock:locklock13",
+  "rql:lock:locklock62",
+  "rql:lock:locklock80",
+  "rql:lock:locklock28",
+  ...}>
+```
+
+---
+
+#### #queues - get list of lock request queues
+
+- uses redis `SCAN` under the hood;
+- accepts `scan_size:`/`Integer` option (`config[:key_extraction_batch_size]` by default);
+- returns `Set<String>`
+
+```ruby
+rql.queues # or rql.queues(scan_size: 123)
+
+=>
+#<Set:
+ {"rql:lock_queue:locklock75",
+  "rql:lock_queue:locklock9",
+  "rql:lock_queue:locklock108",
+  "rql:lock_queue:locklock7",
+  "rql:lock_queue:locklock48",
+  "rql:lock_queue:locklock104",
+  "rql:lock_queue:locklock13",
+  "rql:lock_queue:locklock62",
+  "rql:lock_queue:locklock80",
+  "rql:lock_queue:locklock28",
+  ...}>
+```
+
+---
+
+#### #keys - get list of taken locks and queues
+
+- uses redis `SCAN` under the hood;
+- accepts `scan_size:`/`Integer` option (`config[:key_extraction_batch_size]` by default);
+- returns `Set<String>`
+
+```ruby
+rql.keys # or rql.keys(scan_size: 123)
+
+=>
+#<Set:
+ {"rql:lock_queue:locklock75",
+  "rql:lock_queue:locklock9",
+  "rql:lock:locklock9",
+  "rql:lock_queue:locklock108",
+  "rql:lock_queue:locklock7",
+  "rql:lock:locklock7",
+  "rql:lock_queue:locklock48",
+  "rql:lock_queue:locklock104",
+  "rql:lock:locklock104",
+  "rql:lock_queue:locklock13",
+  "rql:lock_queue:locklock62",
+  "rql:lock_queue:locklock80",
+  "rql:lock:locklock80",
+  "rql:lock_queue:locklock28",
+  ...}>
+```
+
+---
+
 ## Instrumentation
 
 An instrumentation layer is incapsulated in `instrumenter` object stored in [config](#configuration) (`RedisQueuedLocks::Client#config[:instrumenter]`).
@@ -467,6 +568,7 @@ Detalized event semantics and payload structure:
     whose ttl may expire before the block execution completes);
   - an ability to add custom metadata to the lock and an ability to read this data;
 - **Minor**
+  - GitHub Actions CI;
   - `RedisQueuedLocks::Acquier::Try.try_to_lock` - detailed successful result analization;
   - better code stylization and interesting refactorings;
 

data/lib/redis_queued_locks/acquier/delay.rb

@@ -12,7 +12,7 @@ module RedisQueuedLocks::Acquier::Delay
   # @api private
   # @since 0.1.0
   def delay_execution(retry_delay, retry_jitter)
-    delay = (retry_delay + rand(retry_jitter)) / 1_000
+    delay = (retry_delay + rand(retry_jitter)).to_f / 1_000
     sleep(delay)
   end
 end

data/lib/redis_queued_locks/acquier/release.rb

@@ -37,6 +37,7 @@ module RedisQueuedLocks::Acquier::Release
         RedisQueuedLocks::Resource::LOCK_QUEUE_PATTERN,
         count: batch_size
       ) do |lock_queue|
+        # TODO: reduce unnecessary iterations
         pipeline.call('ZREMRANGEBYSCORE', lock_queue, '-inf', '+inf')
         pipeline.call('EXPIRE', RedisQueuedLocks::Resource.lock_key_from_queue(lock_queue), '0')
       end
@@ -47,6 +48,7 @@ module RedisQueuedLocks::Acquier::Release
         RedisQueuedLocks::Resource::LOCK_PATTERN,
         count: batch_size
       ) do |lock_key|
+        # TODO: reduce unnecessary iterations
         pipeline.call('EXPIRE', lock_key, '0')
       end
     end

data/lib/redis_queued_locks/acquier.rb

@@ -437,7 +437,66 @@ module RedisQueuedLocks::Acquier
     #
     # @api private
     # @since 0.1.0
-    def extend_lock_ttl(redis_client, lock_name, milliseconds); end
+    def extend_lock_ttl(redis_client, lock_name, milliseconds)
+      # TODO: realize
+    end
+
+    # @param redis_client [RedisClient]
+    # @option scan_size [Integer]
+    # @return [Set<String>]
+    #
+    # @api private
+    # @since 0.1.0
+    def locks(redis_client, scan_size:)
+      Set.new.tap do |lock_keys|
+        redis_client.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::LOCK_PATTERN,
+          count: scan_size
+        ) do |lock_key|
+          # TODO: reduce unnecessary iterations
+          lock_keys.add(lock_key)
+        end
+      end
+    end
+
+    # @param redis_client [RedisClient]
+    # @param scan_size [Integer]
+    # @return [Set<String>]
+    #
+    # @api private
+    # @since 0.1.0
+    def queues(redis_client, scan_size:)
+      Set.new.tap do |lock_queues|
+        redis_client.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::LOCK_QUEUE_PATTERN,
+          count: scan_size
+        ) do |lock_queue|
+          # TODO: reduce unnecessary iterations
+          lock_queues.add(lock_queue)
+        end
+      end
+    end
+
+    # @param redis_client [RedisClient]
+    # @option scan_size [Integer]
+    # @return [Array<String>]
+    #
+    # @api private
+    # @since 0.1.0
+    def keys(redis_client, scan_size:)
+      Set.new.tap do |keys|
+        redis_client.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::KEY_PATTERN,
+          count: scan_size
+        ) do |key|
+          # TODO: reduce unnecessary iterations
+          keys.add(key)
+        end
+      end
+    end
 
     private
 

data/lib/redis_queued_locks/client.rb

@@ -10,11 +10,12 @@ class RedisQueuedLocks::Client
   configuration do
     setting :retry_count, 3
     setting :retry_delay, 200 # NOTE: milliseconds
-    setting :retry_jitter, 50 # NOTE: milliseconds
+    setting :retry_jitter, 25 # NOTE: milliseconds
     setting :try_to_lock_timeout, 10 # NOTE: seconds
     setting :default_lock_ttl, 5_000 # NOTE: milliseconds
     setting :default_queue_ttl, 15 # NOTE: seconds
     setting :lock_release_batch_size, 100
+    setting :key_extraction_batch_size, 500
     setting :instrumenter, RedisQueuedLocks::Instrument::VoidNotifier
     setting :uniq_identifier, -> { RedisQueuedLocks::Resource.calc_uniq_identity }
 
@@ -225,5 +226,32 @@ class RedisQueuedLocks::Client
   def clear_locks(batch_size: config[:lock_release_batch_size])
     RedisQueuedLocks::Acquier.release_all_locks!(redis_client, batch_size, config[:instrumenter])
   end
+
+  # @option scan_size [Integer]
+  # @return [Set<String>]
+  #
+  # @api public
+  # @since 0.1.0
+  def locks(scan_size: config[:key_extraction_batch_size])
+    RedisQueuedLocks::Acquier.locks(redis_client, scan_size:)
+  end
+
+  # @option scan_size [Integer]
+  # @return [Set<String>]
+  #
+  # @api public
+  # @since 0.1.0
+  def queues(scan_size: config[:key_extraction_batch_size])
+    RedisQueuedLocks::Acquier.queues(redis_client, scan_size:)
+  end
+
+  # @option scan_size [Integer]
+  # @return [Set<String>]
+  #
+  # @api public
+  # @since 0.1.0
+  def keys(scan_size: config[:key_extraction_batch_size])
+    RedisQueuedLocks::Acquier.keys(redis_client, scan_size:)
+  end
 end
 # rubocop:enable Metrics/ClassLength

data/lib/redis_queued_locks/resource.rb

@@ -3,6 +3,12 @@
 # @api private
 # @since 0.1.0
 module RedisQueuedLocks::Resource
+  # @return [String]
+  #
+  # @api private
+  # @since 0.1.0
+  KEY_PATTERN = 'rql:lock*'
+
   # @return [String]
   #
   # @api private

data/lib/redis_queued_locks/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.17
 platform: ruby
 authors:
 - Rustam Ibragimov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-28 00:00:00.000000000 Z
+date: 2024-02-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client