redis_queued_locks 1.21.0 → 1.23.0

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,
+      ?rw_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,
+      ?rw_mode: RQL::readWriteMode,
+      ?access_strategy: RQL::accessStrategy,
+      ?priority: RQL::lockPriority,
       ?identity: String,
       ?instrumenter: RQL::instrObj,
       ?meta: Hash[String|Symbol,untyped]?,
@@ -95,6 +97,73 @@ module RedisQueuedLocks
       ?instr_sample_this: bool,
     ) ?{ (?) -> untyped } -> RQL::Acquirer::AcquireLock::acquireResult
 
+    def lock_series: (
+      *String lock_names,
+      ?detailed_result: bool,
+      ?ttl: Integer,
+      ?queue_ttl: Integer,
+      ?lock_index_grace_period: Integer,
+      ?timeout: Integer?,
+      ?timed: bool,
+      ?retry_count: Integer?,
+      ?retry_delay: Integer,
+      ?retry_jitter: Integer,
+      ?raise_errors: bool,
+      ?fail_fast: bool,
+      ?conflict_strategy: RQL::conflictStrategy,
+      ?rw_mode: RQL::readWriteMode,
+      ?access_strategy: RQL::accessStrategy,
+      ?priority: RQL::lockPriority,
+      ?identity: String,
+      ?meta: Hash[String|Symbol,untyped]?,
+      ?detailed_acq_timeout_error: bool,
+      ?logger: RQL::loggerObj,
+      ?log_lock_try: bool,
+      ?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
+    ) ?{ (?) -> untyped } -> RQL::Acquirer::LockSeries::lockSeriesResult
+
+    def lock_series!: (
+      *String lock_names,
+      ?detailed_result: bool,
+      ?ttl: Integer,
+      ?queue_ttl: Integer,
+      ?lock_index_grace_period: Integer,
+      ?timeout: Integer?,
+      ?timed: bool,
+      ?retry_count: Integer?,
+      ?retry_delay: Integer,
+      ?retry_jitter: Integer,
+      ?fail_fast: bool,
+      ?conflict_strategy: RQL::conflictStrategy,
+      ?rw_mode: RQL::readWriteMode,
+      ?access_strategy: RQL::accessStrategy,
+      ?priority: RQL::lockPriority,
+      ?identity: String,
+      ?meta: Hash[String|Symbol,untyped]?,
+      ?detailed_acq_timeout_error: bool,
+      ?logger: RQL::loggerObj,
+      ?log_lock_try: bool,
+      ?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
+    ) ?{ (?) -> untyped } -> RQL::Acquirer::LockSeries::lockSeriesResult
+
     def unlock: (
       String lock_name,
       ?logger: RQL::loggerObj,
@@ -158,7 +227,7 @@ module RedisQueuedLocks
     def extend_lock_ttl: (
       String lock_name,
       Integer milliseconds,
-      ?read_write_mode: :read | :write,
+      ?rw_mode: RQL::readWriteMode,
       ?all_read_locks: bool,
       ?identity: String,
       ?logger: RQL::loggerObj,
@@ -242,6 +311,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.23.0
 platform: ruby
 authors:
 - Rustam Ibragimov
@@ -23,12 +23,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.20'
-description: |-
-  |> Distributed locks with "prioritized lock acquisition queue" capabilities based on the Redis Database.
-  |> Each lock request is put into the request queue (each lock is hosted by its own queue separately from other queues) and processed in order of their priority (FIFO).
-  |> Each lock request lives some period of time (RTTL) (with requeue capabilities) which guarantees the request queue will never be stacked.
-  |> In addition to the classic `queued` (FIFO) strategy RQL supports `random` (RANDOM) lock obtaining strategy when any acquirer from the lock queue can obtain the lock regardless the position in the queue.
-  |> Provides flexible invocation flow, parametrized limits (lock request ttl, lock ttl, queue ttl, lock attempts limit, fast failing, etc), logging and instrumentation.
+description: |
+  RedisQueuedLocks (aka RQL, aka RQL-lock) - distributed locks with
+  "prioritized lock acquisition queue" capabilities based on the Redis Database.
+
+  Each lock request is put into the request queue
+  (each lock is hosted by its own queue separately from other queues)
+  and processed in order of their priority: requests of a higher priority go first,
+  requests of the same priority are processed in FIFO order.
+  Each lock request lives some period of time (RTTL) (with requeue capabilities)
+  which guarantees the request queue will never be stacked.
+
+  In addition to the classic queued (FIFO) strategy RQL supports random (RANDOM)
+  lock obtaining strategy when any acquirer from the lock queue
+  can obtain the lock regardless the position in the queue.
+
+  Supports lock request prioritization, Read/Write locks and Reentrant locks.
+
+  Provides flexible invocation flow, parametrized limits (lock request ttl, lock ttl,
+  queue ttl, lock attempts limit, fast failing, etc), zombie locks elimination,
+  lock indexing, logging and instrumentation (and much more).
 email:
 - iamdaiver@gmail.com
 executables: []
@@ -38,6 +52,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"
@@ -78,9 +93,11 @@ files:
 - lib/redis_queued_locks/acquirer/is_queued.rb
 - lib/redis_queued_locks/acquirer/keys.rb
 - lib/redis_queued_locks/acquirer/lock_info.rb
-- lib/redis_queued_locks/acquirer/lock_series_poc.rb
-- lib/redis_queued_locks/acquirer/lock_series_poc/instr_visitor.rb
-- lib/redis_queued_locks/acquirer/lock_series_poc/log_visitor.rb
+- lib/redis_queued_locks/acquirer/lock_series.rb
+- lib/redis_queued_locks/acquirer/lock_series/instr_visitor.rb
+- lib/redis_queued_locks/acquirer/lock_series/log_visitor.rb
+- lib/redis_queued_locks/acquirer/lock_series/release_lock_series.rb
+- lib/redis_queued_locks/acquirer/lock_series/try_to_lock_series.rb
 - lib/redis_queued_locks/acquirer/locks.rb
 - lib/redis_queued_locks/acquirer/queue_info.rb
 - lib/redis_queued_locks/acquirer/queues.rb
@@ -122,7 +139,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,13 +150,18 @@ 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
 - sig/redis_queued_locks/acquirer/is_queued.rbs
 - sig/redis_queued_locks/acquirer/keys.rbs
 - sig/redis_queued_locks/acquirer/lock_info.rbs
+- sig/redis_queued_locks/acquirer/lock_series.rbs
+- sig/redis_queued_locks/acquirer/lock_series/instr_visitor.rbs
+- sig/redis_queued_locks/acquirer/lock_series/log_visitor.rbs
+- sig/redis_queued_locks/acquirer/lock_series/release_lock_series.rbs
+- sig/redis_queued_locks/acquirer/lock_series/try_to_lock_series.rbs
 - sig/redis_queued_locks/acquirer/locks.rbs
 - sig/redis_queued_locks/acquirer/queue_info.rbs
 - sig/redis_queued_locks/acquirer/queues.rbs
@@ -200,7 +222,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.22
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Distributed locks with "prioritized lock acquisition queue" capabilities
   based on the Redis Database.

data/lib/redis_queued_locks/acquirer/lock_series_poc/instr_visitor.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-# NOTE: Lock Series PoC
-# @api private
-# @since 1.16.1
-# @version 1.18.0
-module RedisQueuedLocks::Acquirer::LockSeriesPoC::InstrVisitor # steep:ignore
-  class << self
-    # NOTE: Lock Series PoC
-    # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
-    # @api private
-    # @since 1.16.1
-    # @version 1.18.0
-    def lock_series_obtained( # steep:ignore
-      instrumenter,
-      instr_sampled,
-      lock_keys,
-      rw_mode,
-      ttl,
-      acq_id,
-      hst_id,
-      ts,
-      acq_time,
-      instrument
-    )
-      return unless instr_sampled
-      instrumenter.notify('redis_queued_locks.lock_series_obtained', {
-        lock_keys:, rw_mode:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
-      }) rescue nil
-    end
-
-    # NOTE: Lock Series PoC
-    # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
-    # @api private
-    # @since 1.16.1
-    # @version 1.21.0
-    def lock_series_hold_and_release( # steep:ignore
-      instrumenter,
-      instr_sampled,
-      lock_keys,
-      rw_mode,
-      ttl,
-      acq_id,
-      hst_id,
-      ts,
-      acq_time,
-      hold_time,
-      instrument
-    )
-      return unless instr_sampled
-      instrumenter.notify('redis_queued_locks.lock_series_hold_and_release', {
-        lock_keys:, rw_mode:, hold_time:, ttl:, acq_id:, hst_id:, ts:, acq_time:, instrument:
-      }) rescue nil
-    end
-  end
-end

data/lib/redis_queued_locks/acquirer/lock_series_poc/log_visitor.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-# NOTE: Lock Series PoC
-# @api private
-# @since 1.16.1
-# @version 1.18.0
-module RedisQueuedLocks::Acquirer::LockSeriesPoC::LogVisitor # steep:ignore
-  class << self
-    # NOTE: Lock Series PoC
-    # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
-    # @api private
-    # @since 1.16.0
-    # @version 1.21.0
-    def start_lock_series_obtaining( # steep:ignore
-      logger,
-      log_sampled,
-      lock_keys,
-      queue_ttl,
-      acquirer_id,
-      host_id,
-      access_strategy,
-      rw_mode
-    )
-      return unless log_sampled
-
-      logger.debug do
-        "[redis_queued_locks.start_lock_series_obtaining] " \
-        "lock_keys => '#{lock_keys.inspect}' " \
-        "queue_ttl => #{queue_ttl} " \
-        "acq_id => '#{acquirer_id}' " \
-        "hst_id => '#{host_id}' " \
-        "acs_strat => '#{access_strategy}' " \
-        "rw_mode => '#{rw_mode}'"
-      end rescue nil
-    end
-
-    # NOTE: Lock Series PoC
-    # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
-    # @api private
-    # @since 1.16.0
-    # @version 1.21.0
-    def lock_series_obtained( # steep:ignore
-      logger,
-      log_sampled,
-      lock_keys,
-      queue_ttl,
-      acquirer_id,
-      host_id,
-      acq_time,
-      access_strategy,
-      rw_mode
-    )
-      return unless log_sampled
-
-      logger.debug do
-        "[redis_queued_locks.lock_series_obtained] " \
-        "lock_keys => '#{lock_keys.inspect}' " \
-        "queue_ttl => #{queue_ttl} " \
-        "acq_id => '#{acquirer_id}' " \
-        "hst_id => '#{host_id}' " \
-        "acs_strat => '#{access_strategy}' " \
-        "rw_mode => '#{rw_mode}' " \
-        "acq_time => #{acq_time} (ms)"
-      end rescue nil
-    end
-
-    # NOTE: Lock Series PoC
-    # @param rw_mode [Symbol] The mode of the lock series (`:read` or `:write`).
-    # @api private
-    # @since 1.16.0
-    # @version 1.18.0
-    def expire_lock_series( # steep:ignore
-      logger,
-      log_sampled,
-      lock_series,
-      queue_ttl,
-      acquirer_id,
-      host_id,
-      access_strategy,
-      rw_mode
-    )
-      return unless log_sampled
-
-      logger.debug do
-        "[redis_queued_locks.expire_lock_series] " \
-        "lock_keys => '#{lock_series.inspect}' " \
-        "queue_ttl => #{queue_ttl} " \
-        "acq_id => '#{acquirer_id}' " \
-        "hst_id => '#{host_id}' " \
-        "acs_strat => '#{access_strategy}' " \
-        "rw_mode => '#{rw_mode}'"
-      end rescue nil
-    end
-  end
-end