redis_queued_locks 1.20.0 → 1.21.0

data/lib/redis_queued_locks/swarm.rb

@@ -2,6 +2,7 @@
 
 # @api public
 # @since 1.9.0
+# @version 1.13.0
 # rubocop:disable Metrics/ClassLength
 class RedisQueuedLocks::Swarm
   require_relative 'swarm/redis_client_builder'
@@ -76,7 +77,16 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
+  # @version 1.21.0
   def swarm_info(zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'])
+    # NOTE: (arguments) the same ranges as the config keys;
+    if !zombie_ttl.is_a?(::Integer) || zombie_ttl <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:zombie_ttl` argument should be a positive Integer, got #{zombie_ttl.inspect}."
+      )
+    end
+
     RedisQueuedLocks::Swarm::Acquirers.acquirers(
       rql_client.redis_client,
       zombie_ttl
@@ -104,12 +114,32 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
-  # @version 1.20.0
+  # @version 1.21.0
   def flush_zombies(
     zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'],
     lock_scan_size: rql_client.config['swarm.flush_zombies.zombie_lock_scan_size'],
     queue_scan_size: rql_client.config['swarm.flush_zombies.zombie_queue_scan_size']
   )
+    # NOTE: (arguments) the same ranges as the config keys;
+    if !zombie_ttl.is_a?(::Integer) || zombie_ttl <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:zombie_ttl` argument should be a positive Integer, got #{zombie_ttl.inspect}."
+      )
+    end
+    if !lock_scan_size.is_a?(::Integer) || lock_scan_size <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:lock_scan_size` argument should be a positive Integer, got #{lock_scan_size.inspect}."
+      )
+    end
+    if !queue_scan_size.is_a?(::Integer) || queue_scan_size <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:queue_scan_size` argument should be a positive Integer, got #{queue_scan_size.inspect}."
+      )
+    end
+
     RedisQueuedLocks::Swarm::FlushZombies.flush_zombies(
       rql_client.redis_client,
       zombie_ttl,
@@ -125,11 +155,25 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
-  # @version 1.20.0
+  # @version 1.21.0
   def zombie_locks(
     zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'],
     lock_scan_size: rql_client.config['swarm.flush_zombies.zombie_lock_scan_size']
   )
+    # NOTE: (arguments) the same ranges as the config keys;
+    if !zombie_ttl.is_a?(::Integer) || zombie_ttl <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:zombie_ttl` argument should be a positive Integer, got #{zombie_ttl.inspect}."
+      )
+    end
+    if !lock_scan_size.is_a?(::Integer) || lock_scan_size <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:lock_scan_size` argument should be a positive Integer, got #{lock_scan_size.inspect}."
+      )
+    end
+
     RedisQueuedLocks::Swarm::ZombieInfo.zombie_locks(
       rql_client.redis_client,
       zombie_ttl,
@@ -142,13 +186,27 @@ class RedisQueuedLocks::Swarm
   # @option lock_scan_size [Integer]
   # @return [Set<String>]
   #
-  # @api ppublic
+  # @api public
   # @since 1.9.0
-  # @version 1.20.0
+  # @version 1.21.0
   def zombie_acquirers(
     zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'],
     lock_scan_size: rql_client.config['swarm.flush_zombies.zombie_lock_scan_size']
   )
+    # NOTE: (arguments) the same ranges as the config keys;
+    if !zombie_ttl.is_a?(::Integer) || zombie_ttl <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:zombie_ttl` argument should be a positive Integer, got #{zombie_ttl.inspect}."
+      )
+    end
+    if !lock_scan_size.is_a?(::Integer) || lock_scan_size <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:lock_scan_size` argument should be a positive Integer, got #{lock_scan_size.inspect}."
+      )
+    end
+
     RedisQueuedLocks::Swarm::ZombieInfo.zombie_acquirers(
       rql_client.redis_client,
       zombie_ttl,
@@ -162,7 +220,16 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
+  # @version 1.21.0
   def zombie_hosts(zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'])
+    # NOTE: (arguments) the same ranges as the config keys;
+    if !zombie_ttl.is_a?(::Integer) || zombie_ttl <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:zombie_ttl` argument should be a positive Integer, got #{zombie_ttl.inspect}."
+      )
+    end
+
     RedisQueuedLocks::Swarm::ZombieInfo.zombie_hosts(rql_client.redis_client, zombie_ttl)
   end
 
@@ -172,11 +239,25 @@ class RedisQueuedLocks::Swarm
   #
   # @api public
   # @since 1.9.0
-  # @version 1.20.0
+  # @version 1.21.0
   def zombies_info(
     zombie_ttl: rql_client.config['swarm.flush_zombies.zombie_ttl'],
     lock_scan_size: rql_client.config['swarm.flush_zombies.zombie_lock_scan_size']
   )
+    # NOTE: (arguments) the same ranges as the config keys;
+    if !zombie_ttl.is_a?(::Integer) || zombie_ttl <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:zombie_ttl` argument should be a positive Integer, got #{zombie_ttl.inspect}."
+      )
+    end
+    if !lock_scan_size.is_a?(::Integer) || lock_scan_size <= 0
+      raise(
+        RedisQueuedLocks::SwarmArgumentError,
+        "`:lock_scan_size` argument should be a positive Integer, got #{lock_scan_size.inspect}."
+      )
+    end
+
     RedisQueuedLocks::Swarm::ZombieInfo.zombies_info(
       rql_client.redis_client,
       zombie_ttl,

data/lib/redis_queued_locks/utilities.rb

@@ -39,7 +39,7 @@ module RedisQueuedLocks::Utilities
   # @return [Boolean]
   #
   # @api public
-  # @since ?.?.?
+  # @since 1.16.0
   RUBY_OVER_4 = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('4.0.0')
 
   # @yield

data/lib/redis_queued_locks/version.rb

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

data/sig/redis_queued_locks/acquirer/acquire_lock/instr_visitor.rbs

@@ -70,6 +70,20 @@ module RedisQueuedLocks
           Integer|Float hold_time,
           untyped? instrument
         ) -> void
+
+        def self.lock_obtaining_failed: (
+          RQL::instrObj instrumenter,
+          bool instr_sampled,
+          String lock_key,
+          Symbol rw_mode,
+          Integer ttl,
+          String acq_id,
+          String hst_id,
+          Integer|Float ts,
+          Integer|Float acq_time,
+          Symbol result,
+          untyped? instrument
+        ) -> void
       end
     end
   end

data/sig/redis_queued_locks/acquirer/acquire_lock/log_visitor.rbs

@@ -72,6 +72,19 @@ module RedisQueuedLocks
           Symbol access_strategy,
           Symbol rw_mode
         ) -> void
+
+        def self.lock_obtaining_failed: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          String lock_key,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          Integer|Float acq_time,
+          Symbol access_strategy,
+          Symbol rw_mode,
+          Symbol result
+        ) -> void
       end
     end
   end

data/sig/redis_queued_locks/acquirer/acquire_lock/yield_expire.rbs

@@ -19,7 +19,7 @@ module RedisQueuedLocks
           Symbol access_strategy,
           bool timed,
           Integer|Float ttl_shift,
-          Integer? ttl,
+          Integer ttl,
           Integer queue_ttl,
           Hash[String|Symbol,untyped]? meta,
           bool log_sampled,
@@ -33,7 +33,7 @@ module RedisQueuedLocks
         def yield_with_timeout: (
           Float timeout,
           String lock_key,
-          Integer? lock_ttl,
+          Integer lock_ttl,
           String acquirer_id,
           String host_id,
           Hash[String|Symbol,untyped]? meta,

data/sig/redis_queued_locks/acquirer/acquire_lock.rbs

@@ -19,7 +19,7 @@ module RedisQueuedLocks
         thread_id: Integer|String,
         fiber_id: Integer|String,
         ractor_id: Integer|String,
-        ttl: Integer?,
+        ttl: Integer,
         queue_ttl: Integer,
         lock_index_enabled: bool,
         lock_index_grace_period: Integer,

data/sig/redis_queued_locks/acquirer/clear_dead_requests.rbs

@@ -4,6 +4,8 @@ use RedisClient as RC
 module RedisQueuedLocks
   module Acquirer
     module ClearDeadRequests
+      extend RQL::Utilities
+
       type clearResult = { ok: bool, result: { processed_queues: Set[String] } }
       def self.clear_dead_requests: (
         RC::client redis_client,
@@ -23,6 +25,13 @@ module RedisQueuedLocks
         bool instr_sample_this
       ) -> clearResult
 
+      private def self.fully_clear_dead_requests: (
+        RC::client redis_client,
+        Integer scan_size,
+        Integer dead_ttl,
+        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_of_locks: (

data/sig/redis_queued_locks/acquirer/extend_lock_ttl.rbs

@@ -4,6 +4,8 @@ use RedisClient as RC
 module RedisQueuedLocks
   module Acquirer
     module ExtendLockTTL
+      extend RQL::Utilities
+
       EXTEND_LOCK_PTTL: String
 
       type extendResult = { ok: bool, result: { extended_locks_count: Integer } | Symbol }
@@ -18,16 +20,27 @@ module RedisQueuedLocks
         RQL::loggerObj logger,
         RQL::instrObj instrumenter,
         untyped? instrument,
-        bool log_samling_enabled,
+        bool log_sampling_enabled,
         Integer log_sampling_percent,
         RQL::Logging::samplerObj log_sampler,
-        bool sample_this,
+        bool log_sample_this,
         bool instr_sampling_enabled,
         Integer instr_sampling_percent,
         RQL::Instrument::samplerObj instr_sampler,
         bool instr_sample_this
       ) -> extendResult
 
+      private def self.fully_extend_lock_ttl: (
+        RC::client redis_client,
+        String lock_name,
+        String lock_key,
+        Integer milliseconds,
+        Symbol read_write_mode,
+        bool all_read_locks,
+        String acquirer_id,
+        bool lock_index_enabled
+      ) -> extendResult
+
       private def self.extend_read_lock_ttl: (
         RC::client redis_client,
         String lock_name,

data/sig/redis_queued_locks/acquirer/reindex_locks.rbs

@@ -1,16 +1,37 @@
+use RedisQueuedLocks as RQL
 use RedisClient as RC
 
 module RedisQueuedLocks
   module Acquirer
     module ReindexLocks
+      extend RQL::Utilities
+
       type reindexResult = { ok: bool, result: { idx_key_cnt: Integer } }
       def self.reindex_locks: (
         RC::client redis_client,
         Integer scan_size,
         Integer queue_ttl,
-        Integer lock_index_grace_period
+        Integer lock_index_grace_period,
+        RQL::loggerObj logger,
+        RQL::instrObj instrumenter,
+        untyped? instrument,
+        bool log_sampling_enabled,
+        Integer log_sampling_percent,
+        RQL::Logging::samplerObj log_sampler,
+        bool log_sample_this,
+        bool instr_sampling_enabled,
+        Integer instr_sampling_percent,
+        RQL::Instrument::samplerObj instr_sampler,
+        bool instr_sample_this
       ) -> reindexResult
 
+      private def self.fully_reindex_locks: (
+        RC::client redis_client,
+        Integer scan_size,
+        Integer queue_ttl,
+        Integer lock_index_grace_period
+      ) -> Integer
+
       private def self.index_lock_keys: (
         RC::client redis_client,
         Array[String] lock_keys,

data/sig/redis_queued_locks/acquirer/release_lock.rbs

@@ -20,10 +20,11 @@ module RedisQueuedLocks
         RC::client redis,
         String lock_name,
         bool lock_index_enabled,
-        RQL::instrObj instrumenter,
         RQL::loggerObj logger,
+        RQL::instrObj instrumenter,
+        untyped? instrument,
         bool log_sampling_enabled,
-        Integer log_samplingPercent,
+        Integer log_sampling_percent,
         RQL::Logging::samplerObj log_sampler,
         bool log_sample_this,
         bool instr_sampling_enabled,

data/sig/redis_queued_locks/acquirer/release_read_lock.rbs

@@ -19,8 +19,8 @@ module RedisQueuedLocks
         RC::client redis,
         String lock_name,
         String acquirer_id,
-        RQL::instrObj instrumenter,
         RQL::loggerObj logger,
+        RQL::instrObj instrumenter,
         untyped? instrument,
         bool log_sampling_enabled,
         Integer log_sampling_percent,

data/sig/redis_queued_locks/client.rbs

@@ -141,7 +141,7 @@ module RedisQueuedLocks
       ?ractor_id: Integer|String,
       ?identity: String
     ) -> String
-    alias ccurrent_acq_id current_acquirer_id
+    alias current_acq_id current_acquirer_id
     alias acq_id current_acquirer_id
 
     def current_host_id: (
@@ -236,7 +236,7 @@ module RedisQueuedLocks
               | (?scan_size: Integer, ?with_info: true) -> RQL::Acquirer::Queues::queuesInfo
               | (?scan_size: Integer, ?with_info: false) -> RQL::Acquirer::Queues::queueList
 
-    def queues_info: (?scan_size: Integer) -> RQL::Acquirer::Queues::queues
+    def queues_info: (?scan_size: Integer) -> RQL::Acquirer::Queues::queuesInfo
     def keys: (?scan_size: Integer) -> RQL::Acquirer::Keys::keyList
 
     def clear_dead_requests: (
@@ -258,7 +258,18 @@ module RedisQueuedLocks
     def reindex_locks: (
       ?scan_size: Integer,
       ?queue_ttl: Integer,
-      ?lock_index_grace_period: Integer
+      ?lock_index_grace_period: Integer,
+      ?logger: RQL::loggerObj,
+      ?instrumenter: RQL::instrObj,
+      ?instrument: untyped?,
+      ?log_sampling_enabled: bool,
+      ?log_sampling_percent: Integer,
+      ?log_sampler: RQL::Logging::samplerObj,
+      ?log_sample_this: bool,
+      ?instr_sampling_enabled: bool,
+      ?instr_sampling_percent: Integer,
+      ?instr_sampler: RQL::Instrument::samplerObj,
+      ?instr_sample_this: bool
     ) -> RQL::Acquirer::ReindexLocks::reindexResult
   end
 end

data/sig/redis_queued_locks/errors.rbs

@@ -5,10 +5,13 @@ module RedisQueuedLocks
   class ArgumentError < ::ArgumentError
   end
 
+  class Exception < ::Exception
+  end
+
   class LockAlreadyObtainedError < Error
   end
 
-  class LockAcquirementIntermediateTimeoutError < ::Timeout::Error
+  class LockAcquirementIntermediateTimeoutError < Exception
   end
 
   class LockAcquirementTimeoutError < Error
@@ -17,7 +20,7 @@ module RedisQueuedLocks
   class LockAcquirementRetryLimitError < Error
   end
 
-  class TimedLockIntermediateTimeoutError < ::Timeout::Error
+  class TimedLockIntermediateTimeoutError < Exception
   end
 
   class TimedLockTimeoutError < Error

data/sig/redis_queued_locks/instrument/sampler.rbs

@@ -1,8 +1,6 @@
 module RedisQueuedLocks
   module Instrument
     module Sampler
-      SAMPLING_PERCENT_RANGE: Range[Integer]
-
       def self.sampling_happened?: (Integer sampling_percent) -> bool
     end
   end

data/sig/redis_queued_locks/logging/sampler.rbs

@@ -1,8 +1,6 @@
 module RedisQueuedLocks
   module Logging
     module Sampler
-      SAMPLING_PERCENT_RANGE: Range[Integer]
-
       def self.sampling_happened?: (Integer sampling_percent) -> bool
     end
   end

data/sig/redis_queued_locks/resource.rbs

@@ -45,7 +45,7 @@ module RedisQueuedLocks
     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_key_from_queue: (String lock_queue) -> String
+    def self.lock_key_from_queue: (String lock_queue) -> String?
     def self.get_thread_id: () -> Integer
     def self.get_fiber_id: () -> Integer
     def self.get_ractor_id: () -> Integer

data/sig/vendor/redis_client.rbs

@@ -6,6 +6,7 @@ class RedisClient
     def zscan: (String key, *untyped) { (String member, String score) -> untyped } -> untyped
     def multi: (?watch: Array[String]) { (Multi transact) -> untyped } -> untyped
     def with: (?untyped) { (::RedisClient|::RedisClient::Pooled rconn) -> untyped } -> untyped
+    def close: () -> void
   end
 
   include _Client

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 1.20.0
+  version: 1.21.0
 platform: ruby
 authors:
 - Rustam Ibragimov