redis_queued_locks 1.20.0 → 1.22.0

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

@@ -13,6 +13,7 @@ module RedisQueuedLocks
         LOCK_STATE_QUEUE_REPLIES_AT: Integer
         QUEUE_HEAD_REPLY: Integer
         OPPOSITE_QUEUE_HEAD_REPLY: Integer
+        MAX_DEAD_REQUEST_REMOVALS: Integer
 
         # { ok: bool, result: Symbol }
         # { ok: bool, result: Symbol }
@@ -25,7 +26,7 @@ module RedisQueuedLocks
         #     hst_id: String,
         #     ts: Integer?,
         #     ttl: Integer?,
-        #     rw_mode: Symbol
+        #     rw_mode: RQL::readWriteMode
         #   }
         # }
 
@@ -34,7 +35,7 @@ module RedisQueuedLocks
           RQL::loggerObj logger,
           bool log_lock_try,
           String lock_key,
-          Symbol read_write_mode,
+          RQL::readWriteMode read_write_mode,
           String lock_key_queue,
           String read_lock_key_queue,
           String lock_readers_key,
@@ -43,13 +44,14 @@ module RedisQueuedLocks
           String acquirer_id,
           String host_id,
           Integer|Float acquirer_position,
+          Integer priority,
           Integer? ttl,
           Integer queue_ttl,
           bool lock_index_enabled,
           Integer lock_index_grace_period,
           bool fail_fast,
-          Symbol conflict_strategy,
-          Symbol access_strategy,
+          RQL::conflictStrategy conflict_strategy,
+          RQL::accessStrategy access_strategy,
           Hash[String|Symbol,untyped]? meta,
           bool retry_attempt,
           bool log_sampled,
@@ -63,6 +65,7 @@ module RedisQueuedLocks
           String request_queue,
           String opposite_request_queue,
           Integer|Float acquirer_position,
+          Integer priority,
           String acquirer_id,
           Float acquirer_dead_score,
           String lock_name,
@@ -71,6 +74,14 @@ module RedisQueuedLocks
           Integer lock_index_grace_period
         ) -> void
 
+        def pipeline_dead_requests_removal: (
+          RedisClient::Pipeline pipeline,
+          String request_queue,
+          String opposite_request_queue,
+          Float acquirer_dead_score,
+          Integer priority
+        ) -> void
+
         def pipeline_lock_state: (
           RedisClient::Pipeline pipeline,
           String lock_key,
@@ -81,6 +92,7 @@ module RedisQueuedLocks
           String request_queue,
           String opposite_request_queue,
           Integer|Float acquirer_position,
+          Integer priority,
           Float acquirer_dead_score,
           String lock_name,
           Integer queue_ttl,
@@ -89,7 +101,7 @@ module RedisQueuedLocks
         ) -> void
 
         def find_opposite_request_ahead: (
-          Symbol access_strategy,
+          RQL::accessStrategy access_strategy,
           [String, Float]? opposite_waiting_request,
           Integer|Float acquirer_position,
           String acquirer_id
@@ -104,7 +116,7 @@ module RedisQueuedLocks
 
         def lock_obstacle: (
           bool read_mode,
-          Symbol access_strategy,
+          RQL::accessStrategy access_strategy,
           String acquirer_id,
           String? waiting_acquirer,
           String? opposite_request_ahead,
@@ -122,20 +134,55 @@ module RedisQueuedLocks
           Integer queue_ttl,
           String acquirer_id,
           String host_id,
-          Symbol access_strategy,
-          Symbol read_write_mode,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode read_write_mode,
           String? waiting_acquirer,
-          String? opposite_request_ahead,
+          Integer? waiting_priority,
+          [String, Float]? opposite_waiting_request,
           String? current_lock_obtainer
         ) -> void
 
+        def logged_request_priority: (
+          bool log_sampled,
+          bool log_lock_try,
+          [String, Float]? lock_request
+        ) -> Integer?
+
+        def drop_dead_requests_ahead: (
+          RC::client rconn,
+          RQL::readWriteMode read_write_mode,
+          String request_queue,
+          String opposite_request_queue,
+          String acquirer_id,
+          Integer|Float acquirer_position,
+          Float acquirer_dead_score,
+          RQL::accessStrategy access_strategy,
+          [String, Float]? waiting_request,
+          [String, Float]? opposite_waiting_request
+        ) -> [[String, Float]?, [String, Float]?, Array[[String, Integer]]]?
+
+        def log_dropped_requests: (
+          RQL::loggerObj logger,
+          bool log_sampled,
+          bool log_lock_try,
+          String lock_key,
+          Integer queue_ttl,
+          String acquirer_id,
+          String host_id,
+          RQL::accessStrategy access_strategy,
+          RQL::readWriteMode read_write_mode,
+          Array[[String, Integer]] dropped_requests
+        ) -> void
+
+        def dead_request_priority: ([String, Float] lock_request, Float acquirer_dead_score) -> Integer?
+
         def precheck_lock: (
           RC::client rconn,
           RQL::loggerObj logger,
           bool log_sampled,
           bool log_lock_try,
           String lock_key,
-          Symbol read_write_mode,
+          RQL::readWriteMode read_write_mode,
           String lock_readers_key,
           String request_queue,
           String opposite_request_queue,
@@ -143,12 +190,13 @@ module RedisQueuedLocks
           String acquirer_id,
           String host_id,
           Integer|Float acquirer_position,
+          Integer priority,
           Float acquirer_dead_score,
           Integer queue_ttl,
           bool lock_index_enabled,
           Integer lock_index_grace_period,
           bool fail_fast,
-          Symbol access_strategy
+          RQL::accessStrategy access_strategy
         ) -> (lockObstacle | :fail_fast_no_try)?
       end
     end

data/sig/redis_queued_locks/acquirer/acquire_lock/{yield_with_expire → yield_expire}/log_visitor.rbs

@@ -12,8 +12,8 @@ module RedisQueuedLocks
             Integer queue_ttl,
             String acquirer_id,
             String host_id,
-            Symbol access_strategy,
-            Symbol rw_mode
+            RQL::accessStrategy access_strategy,
+            RQL::readWriteMode rw_mode
           ) -> void
 
           def self.decrease_lock: (
@@ -24,8 +24,8 @@ module RedisQueuedLocks
             Integer queue_ttl,
             String acquirer_id,
             String host_id,
-            Symbol access_strategy,
-            Symbol rw_mode
+            RQL::accessStrategy access_strategy,
+            RQL::readWriteMode rw_mode
           ) -> void
         end
       end

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

@@ -13,13 +13,13 @@ module RedisQueuedLocks
           String lock_key,
           String lock_readers_key,
           String? read_lock_key,
-          Symbol rw_mode,
+          RQL::readWriteMode rw_mode,
           String acquirer_id,
           String host_id,
-          Symbol access_strategy,
+          RQL::accessStrategy 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,
@@ -37,9 +37,11 @@ module RedisQueuedLocks
         logger: RQL::loggerObj,
         log_lock_try: bool,
         instrument: untyped?,
-        conflict_strategy: Symbol,
-        read_write_mode: Symbol,
-        access_strategy: Symbol,
+        conflict_strategy: RQL::conflictStrategy,
+        read_write_mode: Symbol, # NOTE: (rbs test) validated at runtime (Step 0.1 (RW)): any Symbol is accepted here
+        access_strategy: RQL::accessStrategy,
+        priority: RQL::lockPriority,
+        lock_priorities: Hash[Symbol, Integer],
         log_sampling_enabled: bool,
         log_sampling_percent: Integer,
         log_sampler: RQL::Logging::samplerObj,

data/sig/redis_queued_locks/acquirer/clear_dead_requests.rbs

@@ -4,11 +4,14 @@ 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,
         Integer scan_size,
         Integer dead_ttl,
+        bool by_priority,
         bool lock_index_enabled,
         RQL::loggerObj logger,
         RQL::instrObj instrumenter,
@@ -23,12 +26,31 @@ 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 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

@@ -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 }
@@ -11,23 +13,34 @@ 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,
         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,
+        RQL::readWriteMode 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/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/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

@@ -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]?,
@@ -141,7 +143,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: (
@@ -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,
@@ -236,12 +238,13 @@ 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: (
       ?dead_ttl: Integer,
       ?scan_size: Integer,
+      ?by_priority: bool,
       ?logger: RQL::loggerObj,
       ?instrumenter: RQL::instrObj,
       ?instrument: untyped?,
@@ -258,7 +261,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/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/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,9 +1,9 @@
 module RedisQueuedLocks
   module Instrument
     module Sampler
-      SAMPLING_PERCENT_RANGE: Range[Integer]
-
-      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,9 +1,9 @@
 module RedisQueuedLocks
   module Logging
     module Sampler
-      SAMPLING_PERCENT_RANGE: Range[Integer]
-
-      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