redis_queued_locks 1.21.0 → 1.22.0

data/sig/redis_queued_locks/acquirer/clear_dead_requests.rbs

@@ -11,6 +11,7 @@ module RedisQueuedLocks
         RC::client redis_client,
         Integer scan_size,
         Integer dead_ttl,
+        bool by_priority,
         bool lock_index_enabled,
         RQL::loggerObj logger,
         RQL::instrObj instrumenter,
@@ -29,15 +30,27 @@ module RedisQueuedLocks
         RC::client redis_client,
         Integer scan_size,
         Integer dead_ttl,
+        bool by_priority,
         bool lock_index_enabled
       ) -> Set[String]
 
       private def self.each_lock_queue: (RC::client redis_client, Integer scan_size) { (String lock_queue) -> void } -> void
-      private def self.drop_dead_requests: (RC::client redis_client, Array[String] lock_queues, Float dead_score) -> void
+      private def self.drop_dead_requests: (
+        RC::client redis_client,
+        Array[String] lock_queues,
+        Float dead_score,
+        bool by_priority
+      ) -> Array[Array[[String, Float]]]
+      private def self.drop_dead_requests_by_priority: (
+        RC::client redis_client,
+        Array[String] lock_queues,
+        Float dead_score
+      ) -> Array[Array[[String, Float]]]
       private def self.drop_dead_requests_of_locks: (
         RC::client redis_client,
         Array[String] lock_names,
         Float dead_score,
+        bool by_priority,
         Set[String] processed_queues
       ) -> void
       private def self.each_lock_name_batch: (RC::client redis_client, Integer scan_size) { (Array[String] lock_names) -> void } -> void

data/sig/redis_queued_locks/acquirer/extend_lock_ttl.rbs

@@ -13,7 +13,7 @@ module RedisQueuedLocks
         RC::client redis_client,
         String lock_name,
         Integer milliseconds,
-        Symbol read_write_mode,
+        Symbol read_write_mode, # NOTE: (rbs test) validated at runtime: any Symbol is accepted here
         bool all_read_locks,
         String acquirer_id,
         bool lock_index_enabled,
@@ -35,7 +35,7 @@ module RedisQueuedLocks
         String lock_name,
         String lock_key,
         Integer milliseconds,
-        Symbol read_write_mode,
+        RQL::readWriteMode read_write_mode,
         bool all_read_locks,
         String acquirer_id,
         bool lock_index_enabled

data/sig/redis_queued_locks/acquirer/queues.rbs

@@ -4,7 +4,7 @@ module RedisQueuedLocks
   module Acquirer
     module Queues
       type queueList = Set[String]
-      type queuesInfo = Set[{ queue: String, requests: Array[Hash[String,String|Float]] }]
+      type queuesInfo = Set[{ queue: String, requests: Array[Hash[String,String|Integer|Float]] }]
       type queues = queueList | queuesInfo
 
       def self.queues: (

data/sig/redis_queued_locks/client.rbs

@@ -44,9 +44,10 @@ module RedisQueuedLocks
       ?retry_jitter: Integer,
       ?raise_errors: bool,
       ?fail_fast: bool,
-      ?conflict_strategy: Symbol,
-      ?read_write_mode: :read | :write,
-      ?access_strategy: Symbol,
+      ?conflict_strategy: RQL::conflictStrategy,
+      ?read_write_mode: RQL::readWriteMode,
+      ?access_strategy: RQL::accessStrategy,
+      ?priority: RQL::lockPriority,
       ?identity: String,
       ?meta: Hash[String|Symbol,untyped]?,
       ?detailed_acq_timeout_error: bool,
@@ -75,9 +76,10 @@ module RedisQueuedLocks
       ?retry_delay: Integer,
       ?retry_jitter: Integer,
       ?fail_fast: bool,
-      ?conflict_strategy: Symbol,
-      ?read_write_mode: :read | :write,
-      ?access_strategy: Symbol,
+      ?conflict_strategy: RQL::conflictStrategy,
+      ?read_write_mode: RQL::readWriteMode,
+      ?access_strategy: RQL::accessStrategy,
+      ?priority: RQL::lockPriority,
       ?identity: String,
       ?instrumenter: RQL::instrObj,
       ?meta: Hash[String|Symbol,untyped]?,
@@ -158,7 +160,7 @@ module RedisQueuedLocks
     def extend_lock_ttl: (
       String lock_name,
       Integer milliseconds,
-      ?read_write_mode: :read | :write,
+      ?read_write_mode: RQL::readWriteMode,
       ?all_read_locks: bool,
       ?identity: String,
       ?logger: RQL::loggerObj,
@@ -242,6 +244,7 @@ module RedisQueuedLocks
     def clear_dead_requests: (
       ?dead_ttl: Integer,
       ?scan_size: Integer,
+      ?by_priority: bool,
       ?logger: RQL::loggerObj,
       ?instrumenter: RQL::instrObj,
       ?instrument: untyped?,

data/sig/redis_queued_locks/config.rbs

@@ -7,11 +7,60 @@ module RedisQueuedLocks
     type configState = Hash[String,untyped]
 
     @config_state: configState
+    @configuring: bool
     attr_reader config_state: configState
 
     def initialize: () ?{ (RedisQueuedLocks::Config) -> void } -> void
     def configure: () ?{ (RedisQueuedLocks::Config) -> void } -> void
-    def []: (String config_key) -> untyped
+    # NOTE: (typed config lookups) one overload per config key (the `setting` list of `config.rb`):
+    #   Steep checks `config['...']` defaults in `Client` and rejects unknown keys;
+    #   keep this table in sync with `setting`/`validate`;
+    def []: ("retry_count") -> Integer?
+          | ("retry_delay") -> Integer
+          | ("retry_jitter") -> Integer
+          | ("try_to_lock_timeout") -> Integer?
+          | ("default_lock_ttl") -> Integer
+          | ("default_queue_ttl") -> Integer
+          | ("detailed_acq_timeout_error") -> bool
+          | ("lock_release_batch_size") -> Integer
+          | ("clear_locks_of__lock_scan_size") -> Integer
+          | ("clear_locks_of__queue_scan_size") -> Integer
+          | ("key_extraction_batch_size") -> Integer
+          | ("instrumenter") -> RedisQueuedLocks::instrObj
+          | ("uniq_identifier") -> ^() -> String
+          | ("logger") -> RedisQueuedLocks::loggerObj
+          | ("log_lock_try") -> bool
+          | ("dead_request_ttl") -> Integer
+          | ("lock_index_enabled") -> bool
+          | ("lock_index_grace_period") -> Integer
+          | ("is_timed_by_default") -> bool
+          | ("default_conflict_strategy") -> RedisQueuedLocks::conflictStrategy
+          | ("default_access_strategy") -> RedisQueuedLocks::accessStrategy
+          | ("lock_priorities") -> Hash[Symbol, Integer]
+          | ("default_lock_priority") -> RedisQueuedLocks::lockPriority
+          | ("log_sampling_enabled") -> bool
+          | ("log_sampling_percent") -> Integer
+          | ("log_sampler") -> RedisQueuedLocks::Logging::samplerObj
+          | ("instr_sampling_enabled") -> bool
+          | ("instr_sampling_percent") -> Integer
+          | ("instr_sampler") -> RedisQueuedLocks::Instrument::samplerObj
+          | ("swarm.auto_swarm") -> bool
+          | ("swarm.supervisor.liveness_probing_period") -> Integer
+          | ("swarm.probe_hosts.enabled_for_swarm") -> bool
+          | ("swarm.probe_hosts.probe_period") -> Integer
+          | ("swarm.probe_hosts.redis_config.sentinel") -> bool
+          | ("swarm.probe_hosts.redis_config.pooled") -> bool
+          | ("swarm.probe_hosts.redis_config.config") -> Hash[untyped,untyped]
+          | ("swarm.probe_hosts.redis_config.pool_config") -> Hash[untyped,untyped]
+          | ("swarm.flush_zombies.enabled_for_swarm") -> bool
+          | ("swarm.flush_zombies.zombie_ttl") -> Integer
+          | ("swarm.flush_zombies.zombie_lock_scan_size") -> Integer
+          | ("swarm.flush_zombies.zombie_queue_scan_size") -> Integer
+          | ("swarm.flush_zombies.zombie_flush_period") -> Integer
+          | ("swarm.flush_zombies.redis_config.sentinel") -> bool
+          | ("swarm.flush_zombies.redis_config.pooled") -> bool
+          | ("swarm.flush_zombies.redis_config.config") -> Hash[untyped,untyped]
+          | ("swarm.flush_zombies.redis_config.pool_config") -> Hash[untyped,untyped]
     def []=: (String config_key, untyped config_value) -> void
     def slice: (String config_key_pattern) -> configState
 
@@ -19,5 +68,9 @@ module RedisQueuedLocks
 
     def prevent_key__non_existent: (String config_key) -> void
     def prevent_key__invalid_type: (String config_key, untyped config_value) -> void
+    def prevent_default_priority__unknown_name: (
+      Hash[Symbol, Integer] lock_priorities,
+      RedisQueuedLocks::lockPriority default_lock_priority
+    ) -> void
   end
 end

data/sig/redis_queued_locks/instrument/sampler.rbs

@@ -1,7 +1,9 @@
 module RedisQueuedLocks
   module Instrument
     module Sampler
-      def self.sampling_happened?: (Integer sampling_percent) -> bool
+      # NOTE: (rbs test) not hooked: `valid_sampler?` introspects `#parameters` of this method,
+      #   and a hooked method has the `(*rest, &block)` parameters;
+      %a{rbs:test:skip} def self.sampling_happened?: (Integer sampling_percent) -> bool
     end
   end
 end

data/sig/redis_queued_locks/instrument/void_notifier.rbs

@@ -1,7 +1,9 @@
 module RedisQueuedLocks
   module Instrument
     module VoidNotifier
-      def self.notify: (String event, ?Hash[untyped,untyped] payload) -> void
+      # NOTE: (rbs test) not hooked: `Instrument.valid_interface?` introspects `#parameters` of `notify`,
+      #   and a hooked method has the `(*rest, &block)` parameters;
+      %a{rbs:test:skip} def self.notify: (String event, ?Hash[untyped,untyped] payload) -> void
     end
   end
 end

data/sig/redis_queued_locks/logging/sampler.rbs

@@ -1,7 +1,9 @@
 module RedisQueuedLocks
   module Logging
     module Sampler
-      def self.sampling_happened?: (Integer sampling_percent) -> bool
+      # NOTE: (rbs test) not hooked: `valid_sampler?` introspects `#parameters` of this method,
+      #   and a hooked method has the `(*rest, &block)` parameters;
+      %a{rbs:test:skip} def self.sampling_happened?: (Integer sampling_percent) -> bool
     end
   end
 end

data/sig/redis_queued_locks/resource.rbs

@@ -10,6 +10,9 @@ module RedisQueuedLocks
     SWARM_KEY: String
     LOCK_INDEX_KEY: String
     REDIS_TIMESHIFT_ERROR: Integer
+    MIN_LOCK_PRIORITY: Integer
+    MAX_LOCK_PRIORITY: Integer
+    LOCK_PRIORITY_BAND: Integer
 
     def self.calc_uniq_identity: () -> String
     def self.acquirer_identifier: (
@@ -27,24 +30,31 @@ module RedisQueuedLocks
       String identity
     ) -> String
 
-    def self.prepare_lock_key: (String lock_name) -> String
-    def self.prepare_lock_queue: (String lock_name) -> String
-    def self.prepare_read_lock_queue: (String lock_name) -> String
-    def self.prepare_lock_readers: (String lock_name) -> String
-    def self.prepare_read_lock_key: (String lock_name, String acquirer_id) -> String
+    # NOTE: (rbs test) `%a{rbs:test:skip}`: these functions run inside the zombie flusher Ractor
+    #   (`FlushZombies.flush_zombies`); rbs/test hooks read `RBS.logger` and raise
+    #   `Ractor::IsolationError` there, so they are not hooked (Steep still checks them).
+    %a{rbs:test:skip} def self.prepare_lock_key: (String lock_name) -> String
+    %a{rbs:test:skip} def self.prepare_lock_queue: (String lock_name) -> String
+    %a{rbs:test:skip} def self.prepare_read_lock_queue: (String lock_name) -> String
+    %a{rbs:test:skip} def self.prepare_lock_readers: (String lock_name) -> String
+    %a{rbs:test:skip} def self.prepare_read_lock_key: (String lock_name, String acquirer_id) -> String
     def self.lock_queue_rw_mode: (String lock_queue) -> String?
     type lockKeyFamily = :lock | :lock_queue | :lock_readers | :read_lock_queue | :read_lock
-    def self.lock_key_family: (String key) -> lockKeyFamily?
+    %a{rbs:test:skip} def self.lock_key_family: (String key) -> lockKeyFamily?
     def self.lock_name_from_key: (String key, lockKeyFamily? key_family) -> String?
-    def self.lock_index_time: () -> Integer
-    def self.lock_name_from_readers: (String lock_readers_key) -> String
+    %a{rbs:test:skip} def self.lock_index_time: () -> Integer
+    def self.lock_index_score_expired?: (String lock_index_score, Integer lock_index_time) -> bool
+    %a{rbs:test:skip} def self.lock_name_from_readers: (String lock_readers_key) -> String
     def self.lock_key_from_readers: (String lock_readers_key) -> String
-    def self.host_identifier_from_acquirer: (String acquirer_id) -> String
+    %a{rbs:test:skip} def self.host_identifier_from_acquirer: (String acquirer_id) -> String
     def self.redis_time_ms: (Array[String] redis_time) -> Integer
-    def self.calc_initial_acquirer_position: () -> Float
+    def self.calc_initial_acquirer_position: (Integer priority) -> Float
     def self.acquirer_dead_score: (Integer|Float queue_ttl) -> Float
-    def self.calc_zombie_score: (Float zombie_ttl) -> Float
-    def self.dead_score_reached?: (Float acquirer_position, Integer queue_ttl) -> bool
+    def self.lock_priority_band_floor: (Integer priority) -> Integer
+    def self.lock_priority_band_dead_score: (Float dead_score, Integer priority) -> Float
+    def self.lock_request_priority: (Integer|Float acquirer_position) -> Integer
+    %a{rbs:test:skip} def self.calc_zombie_score: (Float zombie_ttl) -> Float
+    def self.dead_score_reached?: (Float acquirer_position, Integer priority, Integer queue_ttl) -> bool
     def self.lock_key_from_queue: (String lock_queue) -> String?
     def self.get_thread_id: () -> Integer
     def self.get_fiber_id: () -> Integer

data/sig/redis_queued_locks/swarm/swarm_element/threaded.rbs

@@ -54,7 +54,7 @@ module RedisQueuedLocks
         def swarm_loop__start: () -> void
         def swarm_loop__stop: () -> void
         def swarm_loop__send_command: (Symbol command) -> swarmLoopReply?
-        def swarm_element__termiante: () -> void
+        def swarm_element__terminate: () -> void
       end
     end
   end

data/sig/redis_queued_locks/utilities.rbs

@@ -7,7 +7,8 @@ module RedisQueuedLocks
     def self?.run_non_critical: () { (?) -> untyped } -> untyped?
     def self?.ractor_status: (Ractor ractor) -> String
     def self?.ractor_alive?: (Ractor ractor) -> bool
-    def self?.thread_state: (Thread thread) -> String
+    # NOTE: (rbs test) runs inside the element Ractor (`Isolated.swarm_loop`), see `resource.rbs`;
+    %a{rbs:test:skip} def self?.thread_state: (Thread thread) -> String
     def self?.clock_gettime: () -> Integer
     def self?.ruby_over_4?: () -> bool
   end

data/sig/redis_queued_locks.rbs

@@ -10,5 +10,12 @@ module RedisQueuedLocks
   type loggerObj = Object & _Loggable
   type instrObj = Object & _Instrumentable
 
+  type readWriteMode = :read | :write
+  type accessStrategy = :queued | :random
+  type conflictStrategy = :wait_for_lock | :work_through | :extendable_work_through | :dead_locking
+  # NOTE: (lock request priorities) an Integer priority or a priority name of
+  #   `config['lock_priorities']` (resolved by `AcquireLock.acquire_lock`);
+  type lockPriority = Integer | Symbol
+
   extend ::RedisQueuedLocks::Debugger::Interface
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 1.21.0
+  version: 1.22.0
 platform: ruby
 authors:
 - Rustam Ibragimov
@@ -38,6 +38,7 @@ files:
 - ".claude/project-overview.md"
 - ".claude/rules/acquirer.md"
 - ".claude/rules/arguments.md"
+- ".claude/rules/changelog.md"
 - ".claude/rules/git.md"
 - ".claude/rules/logic.md"
 - ".claude/rules/swarm.md"
@@ -122,7 +123,7 @@ files:
 - redis_queued_locks.gemspec
 - sig/manifest.yml
 - sig/redis_queued_locks.rbs
-- sig/redis_queued_locks/acquier.rbs
+- sig/redis_queued_locks/acquirer.rbs
 - sig/redis_queued_locks/acquirer/acquire_lock.rbs
 - sig/redis_queued_locks/acquirer/acquire_lock/delay_execution.rbs
 - sig/redis_queued_locks/acquirer/acquire_lock/dequeue_from_lock_queue.rbs
@@ -133,7 +134,7 @@ files:
 - sig/redis_queued_locks/acquirer/acquire_lock/try_to_lock/log_visitor.rbs
 - sig/redis_queued_locks/acquirer/acquire_lock/with_acq_timeout.rbs
 - sig/redis_queued_locks/acquirer/acquire_lock/yield_expire.rbs
-- sig/redis_queued_locks/acquirer/acquire_lock/yield_with_expire/log_visitor.rbs
+- sig/redis_queued_locks/acquirer/acquire_lock/yield_expire/log_visitor.rbs
 - sig/redis_queued_locks/acquirer/clear_dead_requests.rbs
 - sig/redis_queued_locks/acquirer/extend_lock_ttl.rbs
 - sig/redis_queued_locks/acquirer/is_locked.rbs