redis_queued_locks 1.12.1 → 1.14.0

data/sig/redis_queued_locks/swarm/supervisor.rbs

@@ -0,0 +1,26 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  class Swarm
+    class Supervisor
+      include RQL::Utilities
+
+      @rql_client: RQL::Client
+      @visor: Thread?
+      @observable: Proc?
+
+      attr_reader rql_client: RQL::Client
+      attr_reader visor: Thread?
+      attr_reader observable: Proc?
+
+      def initialize: (RQL::Client rql_client) -> void
+
+      type supervisorStatus = { running: bool, state: String, observable: String }
+      def status: () -> supervisorStatus
+
+      def observe!: () { (?) -> untyped } -> void
+      def running?: () -> bool
+      def stop!: () -> void
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  class Swarm
+    module SwarmElement
+      class Isolated
+        include RQL::Utilities
+
+        @rql_client: RQL::Client
+        @swarm_element: Ractor?
+        @sync: RQL::Utilities::Lock
+
+        attr_reader rql_client: RQL::Client
+        attr_reader swarm_element: Ractor?
+        attr_reader sync: RQL::Utilities::Lock
+
+        def initialize: (RQL::Client rql_client) -> void
+        def try_swarm!: () -> void
+        def reswarm_if_dead!: () -> void
+        def try_kill!: () -> void
+        def enabled?: () -> bool
+
+        type elementStatus = {
+          enabled: bool,
+          ractor: { running: bool, state: String },
+          main_loop: { running: bool, state: String }
+        }
+        def status: () -> elementStatus
+
+        def self.swarm_loop: () { () -> Thread } -> void
+
+        private
+
+        def swarm!: () -> void
+        def idle?: () -> bool
+        def swarmed?: () -> bool
+        def swarmed__alive?: () -> bool
+        def swarmed__dead?: () -> bool
+        def swarmed__running?: () -> bool
+        def swarmed__stopped?: () -> bool
+        def swarm_loop__is_active: () -> bool
+
+        type swarmLoopStatus = { main_loop: { alive: bool, state: String } }
+        def swarm_loop__status: () -> swarmLoopStatus?
+
+        def swarm_loop__start: () -> void
+        def swarm_loop__pause: () -> void
+        def swarm_loop__kill: () -> void
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  class Swarm
+    module SwarmElement
+      class Threaded
+        include RQL::Utilities
+
+        @rql_client: RQL::Client
+        @swarm_element: Thread?
+        @main_loop: Thread?
+        @swarm_element_commands: Thread::SizedQueue[Symbol]?
+        @swarm_element_results: Thread::SizedQueue[{ ok: bool, result: Hash[untyped,untyped] }]?
+        @sync: RQL::Utilities::Lock
+
+        attr_reader rql_client: RQL::Client
+        attr_reader swarm_element: Thread?
+        attr_reader main_loop: Thread?
+        attr_reader swarm_element_commands: Thread::SizedQueue[Symbol]?
+        attr_reader swarm_element_results: Thread::SizedQueue[{ ok: bool, result: Hash[untyped,untyped] }]?
+        attr_reader sync: RQL::Utilities::Lock
+
+        def initialize: (RQL::Client rql_client) -> void
+
+        def try_swarm!: () -> void
+        def reswarm_if_dead!: () -> void
+        def try_kill!: () -> void
+        def enabled?: () -> bool
+
+        type elementStatus = {
+          enabled: bool,
+          thread: { running: bool, state: String },
+          main_loop: { running: bool, state: String }
+        }
+        def status: () -> elementStatus
+
+        private
+
+        def swarm!: () -> void
+        def spawn_main_loop!: () -> Thread
+        def idle?: () -> bool
+        def swarmed?: () -> bool
+        def swarmed__alive?: () -> bool
+        def swarmed__dead?: () -> bool
+        def swarmed__running?: () -> bool
+        def terminating?: () -> bool?
+        def swarmed__stopped?: () -> bool
+
+        type swarmLoopIsActive = { ok: bool, result: { is_active: bool } }
+        def swarm_loop__is_active: () -> swarmLoopIsActive?
+
+        type swarmLoopStatus = { ok: bool, result: { main_loop: { alive: bool, state: String } } }
+        def swarm_loop__status: () -> swarmLoopStatus?
+
+        def swarm_loop__start: () -> void
+        def swarm_loop__stop: () -> void
+        def swarm_element__termiante: () -> void
+      end
+    end
+  end
+end

data/sig/redis_queued_locks/swarm/swarm_element.rbs

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RedisQueuedLocks
+  class Swarm
+    module SwarmElement
+    end
+  end
+end

data/sig/redis_queued_locks/swarm/zombie_info.rbs

@@ -0,0 +1,24 @@
+use RedisClient as RC
+
+module RedisQueuedLocks
+  class Swarm
+    module ZombieInfo
+      type zombieInfo = { zombie_hosts: Set[String], zombie_acquirers: Set[String], zombie_locks: Set[String] }
+      def self.zombies_info: (RC::client redis_client, Integer zombie_ttl, Integer lock_scan_size) -> zombieInfo
+
+      type zombieLocks = Set[String]
+      def self.zombie_locks: (RC::client redis_client, Integer zombie_ttl, Integer lock_scan_size) -> zombieLocks
+
+      type zombieHosts = Set[String]
+      def self.zombie_hosts: (RC::client redis_client, Integer zombie_ttl) -> zombieHosts
+
+      type zombieAcquirers = Set[String]
+      def self.zombie_acquirers: (RC::client redis_client, Integer zombie_ttl, Integer lock_scan_size) -> zombieAcquirers
+
+      private def self.extract_zombie_hosts: (RC::client rconn, Integer zombie_ttl) -> zombieHosts
+      private def self.extract_zombie_locks: (RC::client rconn, Integer zombie_ttl, Integer lock_scan_size) -> zombieLocks
+      private def self.extract_zombie_acquirers: (RC::client rconn, Integer zombie_ttl, Integer lock_scan_size) -> zombieAcquirers
+      private def self.extract_all: (RC::client rconn, Integer zombie_ttl, Integer lock_scan_size) -> zombieInfo
+    end
+  end
+end

data/sig/redis_queued_locks/swarm.rbs

@@ -0,0 +1,41 @@
+use RedisQueuedLocks as RQL
+
+module RedisQueuedLocks
+  class Swarm
+    @rql_client: RQL::Client
+    @supervisor: RQL::Swarm::Supervisor
+    @probe_hosts_element: RQL::Swarm::ProbeHosts
+    @flush_zombies_element: RQL::Swarm::FlushZombies
+    @sync: RQL::Utilities::Lock
+
+    attr_reader rql_client: RQL::Client
+    attr_reader supervisor: RQL::Swarm::Supervisor
+    attr_reader probe_hosts_element: RQL::Swarm::ProbeHosts
+    attr_reader flush_zombies_element: RQL::Swarm::FlushZombies
+    attr_reader sync: RQL::Utilities::Lock
+
+    def initialize: (RQL::Client rql_client) -> void
+
+    type swarmStatus = {
+      auto_swarm: bool,
+      supervisor: RQL::Swarm::Supervisor::supervisorStatus,
+      probe_hosts: RQL::Swarm::SwarmElement::Threaded::elementStatus,
+      flush_zombies: RQL::Swarm::SwarmElement::Isolated::elementStatus
+    }
+    def swarm_status: () -> swarmStatus
+
+    def swarm_info: (?zombie_ttl: Integer) -> RQL::Swarm::Acquirers::acquirersList
+    def probe_hosts: () -> RQL::Swarm::ProbeHosts::livingHosts
+    def flush_zombies: (?zombie_ttl: Integer, ?lock_scan_size: Integer, ?queue_scan_size: Integer) -> RQL::Swarm::FlushZombies::flushedZombies
+    def zombie_locks: (?zombie_ttl: Integer, ?lock_scan_size: Integer) -> RQL::Swarm::ZombieInfo::zombieLocks
+    def zombie_acquirers: (?zombie_ttl: Integer, ?lock_scan_size: Integer) -> RQL::Swarm::ZombieInfo::zombieAcquirers
+    def zombie_hosts: (?zombie_ttl: Integer) -> RQL::Swarm::ZombieInfo::zombieHosts
+    def zombies_info: (?zombie_ttl: Integer, ?lock_scan_size: Integer) -> RQL::Swarm::ZombieInfo::zombieInfo
+
+    type swarmizeResult = { ok: bool, result: Symbol }
+    def swarm!: () -> swarmizeResult
+
+    type deswarmizeResult = { ok: bool, result: Symbol }
+    def deswarm!: () -> deswarmizeResult
+  end
+end

data/sig/redis_queued_locks/utilities/lock.rbs

@@ -0,0 +1,10 @@
+module RedisQueuedLocks
+  module Utilities
+    class Lock
+      @lock: Monitor
+
+      def initialize: () -> void
+      def synchronize: () { (?) -> untyped } -> untyped
+    end
+  end
+end

data/sig/redis_queued_locks/utilities.rbs

@@ -0,0 +1,12 @@
+module RedisQueuedLocks
+  module Utilities
+    RACTOR_LIVENESS_PATTERN: Regexp
+    RACTOR_STATUS_PATTERN: Regexp
+
+    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
+    def self?.clock_gettime: () -> Integer
+  end
+end

data/sig/redis_queued_locks/version.rbs

@@ -0,0 +1,3 @@
+module RedisQueuedLocks
+  VERSION: String
+end

data/sig/redis_queued_locks.rbs

@@ -0,0 +1,14 @@
+module RedisQueuedLocks
+  interface _Loggable
+    def debug: (?untyped? progname) { (?) -> untyped } -> untyped
+  end
+
+  interface _Instrumentable
+    def notify: (String event, ?Hash[untyped,untyped] payload) -> void
+  end
+
+  type loggerObj = Object & _Loggable
+  type instrObj = Object & _Instrumentable
+
+  extend ::RedisQueuedLocks::Debugger::Interface
+end

data/sig/vendor/active_support.rbs

@@ -0,0 +1,9 @@
+module ActiveSupport
+  module Notifications
+    def self.instrument: (String event, Hash[untyped,untyped] payload) -> untyped
+  end
+
+  class BroadcastLogger
+    def debug: (*untyped, **untyped) { (?) -> untyped } -> untyped
+  end
+end

data/sig/vendor/redis_client.rbs

@@ -0,0 +1,39 @@
+class RedisClient
+  interface _Client
+    def call: (*untyped) -> untyped
+    def pipelined: () { (Pipeline pipeline) -> untyped } -> untyped
+    def scan: (*untyped) { (String key) -> untyped } -> untyped
+    def multi: (?watch: Array[String]) { (Multi transact) -> untyped } -> untyped
+    def with: (?untyped) { (::RedisClient|::RedisClient::Pooled rconn) -> untyped } -> untyped
+  end
+
+  include _Client
+
+  class Pooled
+    include _Client
+  end
+
+  class Pipeline
+    def call: (*untyped) -> untyped
+  end
+
+  class Multi
+    def call: (*untyped) -> untyped
+  end
+
+  class SentinelConfig
+    def new_pool: (**untyped) -> ::RedisClient::Pooled
+    def new_client: (**untyped) -> ::RedisClient
+  end
+
+  class Config
+    def new_pool: (**untyped) -> ::RedisClient::Pooled
+    def new_client: (**untyped) -> ::RedisClient
+  end
+
+  def self.sentinel: (**untyped) -> SentinelConfig
+  def self.config: (**untyped) -> Config
+
+  type client = ::RedisClient | ::RedisClient::Pooled
+  type config = ::RedisClient::Config | ::RedisClient::SentinelConfig
+end

data/sig/vendor/semantic_logger.rbs

@@ -0,0 +1,4 @@
+module SemanticLogger
+  class Logger
+  end
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: redis_queued_locks
 version: !ruby/object:Gem::Version
-  version: 1.12.1
+  version: 1.14.0
 platform: ruby
 authors:
 - Rustam Ibragimov
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -24,30 +23,12 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.20'
-- !ruby/object:Gem::Dependency
-  name: qonfig
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.28'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.28'
-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 it''s 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: |-
+  |> 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 it's 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.
 email:
 - iamdaiver@gmail.com
 executables: []
@@ -62,31 +43,37 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- Steepfile
+- github_ci/ruby3.3.gemfile
+- github_ci/ruby3.3.gemfile.lock
 - lib/redis_queued_locks.rb
-- lib/redis_queued_locks/acquier.rb
-- lib/redis_queued_locks/acquier/acquire_lock.rb
-- lib/redis_queued_locks/acquier/acquire_lock/delay_execution.rb
-- lib/redis_queued_locks/acquier/acquire_lock/dequeue_from_lock_queue.rb
-- lib/redis_queued_locks/acquier/acquire_lock/dequeue_from_lock_queue/log_visitor.rb
-- lib/redis_queued_locks/acquier/acquire_lock/instr_visitor.rb
-- lib/redis_queued_locks/acquier/acquire_lock/log_visitor.rb
-- lib/redis_queued_locks/acquier/acquire_lock/try_to_lock.rb
-- lib/redis_queued_locks/acquier/acquire_lock/try_to_lock/log_visitor.rb
-- lib/redis_queued_locks/acquier/acquire_lock/with_acq_timeout.rb
-- lib/redis_queued_locks/acquier/acquire_lock/yield_expire.rb
-- lib/redis_queued_locks/acquier/acquire_lock/yield_expire/log_visitor.rb
-- lib/redis_queued_locks/acquier/clear_dead_requests.rb
-- lib/redis_queued_locks/acquier/extend_lock_ttl.rb
-- lib/redis_queued_locks/acquier/is_locked.rb
-- lib/redis_queued_locks/acquier/is_queued.rb
-- lib/redis_queued_locks/acquier/keys.rb
-- lib/redis_queued_locks/acquier/lock_info.rb
-- lib/redis_queued_locks/acquier/locks.rb
-- lib/redis_queued_locks/acquier/queue_info.rb
-- lib/redis_queued_locks/acquier/queues.rb
-- lib/redis_queued_locks/acquier/release_all_locks.rb
-- lib/redis_queued_locks/acquier/release_lock.rb
+- lib/redis_queued_locks/acquirer.rb
+- lib/redis_queued_locks/acquirer/acquire_lock.rb
+- lib/redis_queued_locks/acquirer/acquire_lock/delay_execution.rb
+- lib/redis_queued_locks/acquirer/acquire_lock/dequeue_from_lock_queue.rb
+- lib/redis_queued_locks/acquirer/acquire_lock/dequeue_from_lock_queue/log_visitor.rb
+- lib/redis_queued_locks/acquirer/acquire_lock/instr_visitor.rb
+- lib/redis_queued_locks/acquirer/acquire_lock/log_visitor.rb
+- lib/redis_queued_locks/acquirer/acquire_lock/try_to_lock.rb
+- lib/redis_queued_locks/acquirer/acquire_lock/try_to_lock/log_visitor.rb
+- lib/redis_queued_locks/acquirer/acquire_lock/with_acq_timeout.rb
+- lib/redis_queued_locks/acquirer/acquire_lock/yield_expire.rb
+- lib/redis_queued_locks/acquirer/acquire_lock/yield_expire/log_visitor.rb
+- lib/redis_queued_locks/acquirer/clear_dead_requests.rb
+- lib/redis_queued_locks/acquirer/extend_lock_ttl.rb
+- lib/redis_queued_locks/acquirer/is_locked.rb
+- 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/locks.rb
+- lib/redis_queued_locks/acquirer/queue_info.rb
+- lib/redis_queued_locks/acquirer/queues.rb
+- lib/redis_queued_locks/acquirer/release_all_locks.rb
+- lib/redis_queued_locks/acquirer/release_lock.rb
+- lib/redis_queued_locks/acquirer/release_locks_of.rb
 - lib/redis_queued_locks/client.rb
+- lib/redis_queued_locks/config.rb
+- lib/redis_queued_locks/config/dsl.rb
 - lib/redis_queued_locks/data.rb
 - lib/redis_queued_locks/debugger.rb
 - lib/redis_queued_locks/debugger/interface.rb
@@ -112,7 +99,66 @@ files:
 - lib/redis_queued_locks/utilities.rb
 - lib/redis_queued_locks/utilities/lock.rb
 - lib/redis_queued_locks/version.rb
+- rbs_collection.lock.yaml
+- rbs_collection.yaml
 - redis_queued_locks.gemspec
+- sig/manifest.yml
+- sig/redis_queued_locks.rbs
+- sig/redis_queued_locks/acquier.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
+- sig/redis_queued_locks/acquirer/acquire_lock/dequeue_from_lock_queue/log_visitor.rbs
+- sig/redis_queued_locks/acquirer/acquire_lock/instr_visitor.rbs
+- sig/redis_queued_locks/acquirer/acquire_lock/log_visitor.rbs
+- sig/redis_queued_locks/acquirer/acquire_lock/try_to_lock.rbs
+- 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/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/locks.rbs
+- sig/redis_queued_locks/acquirer/queue_info.rbs
+- sig/redis_queued_locks/acquirer/queues.rbs
+- sig/redis_queued_locks/acquirer/release_all_locks.rbs
+- sig/redis_queued_locks/acquirer/release_lock.rbs
+- sig/redis_queued_locks/acquirer/release_locks_of.rbs
+- sig/redis_queued_locks/client.rbs
+- sig/redis_queued_locks/config.rbs
+- sig/redis_queued_locks/config/dsl.rbs
+- sig/redis_queued_locks/data.rbs
+- sig/redis_queued_locks/debugger.rbs
+- sig/redis_queued_locks/debugger/interface.rbs
+- sig/redis_queued_locks/errors.rbs
+- sig/redis_queued_locks/instrument.rbs
+- sig/redis_queued_locks/instrument/active_support.rbs
+- sig/redis_queued_locks/instrument/sampler.rbs
+- sig/redis_queued_locks/instrument/void_notifier.rbs
+- sig/redis_queued_locks/logging.rbs
+- sig/redis_queued_locks/logging/sampler.rbs
+- sig/redis_queued_locks/logging/void_logger.rbs
+- sig/redis_queued_locks/resource.rbs
+- sig/redis_queued_locks/swarm.rbs
+- sig/redis_queued_locks/swarm/acquirers.rbs
+- sig/redis_queued_locks/swarm/flush_zombies.rbs
+- sig/redis_queued_locks/swarm/probe_hosts.rbs
+- sig/redis_queued_locks/swarm/redis_client_builder.rbs
+- sig/redis_queued_locks/swarm/supervisor.rbs
+- sig/redis_queued_locks/swarm/swarm_element.rbs
+- sig/redis_queued_locks/swarm/swarm_element/isolated.rbs
+- sig/redis_queued_locks/swarm/swarm_element/threaded.rbs
+- sig/redis_queued_locks/swarm/zombie_info.rbs
+- sig/redis_queued_locks/utilities.rbs
+- sig/redis_queued_locks/utilities/lock.rbs
+- sig/redis_queued_locks/version.rbs
+- sig/vendor/active_support.rbs
+- sig/vendor/redis_client.rbs
+- sig/vendor/semantic_logger.rbs
 homepage: https://github.com/0exp/redis_queued_locks
 licenses:
 - MIT
@@ -120,7 +166,6 @@ metadata:
   homepage_uri: https://github.com/0exp/redis_queued_locks
   source_code_uri: https://github.com/0exp/redis_queued_locks/blob/master
   changelog_uri: https://github.com/0exp/redis_queued_locks/blob/master/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -128,15 +173,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.17
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Distributed locks with "prioritized lock acquisition queue" capabilities
   based on the Redis Database.

data/lib/redis_queued_locks/acquier/acquire_lock/dequeue_from_lock_queue/log_visitor.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-# @api private
-# @since 1.7.0
-module RedisQueuedLocks::Acquier::AcquireLock::DequeueFromLockQueue::LogVisitor
-  extend self
-
-  # @param logger [::Logger,#debug]
-  # @param log_sampled [Boolean]
-  # @param lock_key [String]
-  # @param queue_ttl [Integer]
-  # @param acquier_id [String]
-  # @param host_id [String]
-  # @param access_strategy [Symbol]
-  # @return [void]
-  #
-  # @api private
-  # @since 1.7.0
-  # @version 1.9.0
-  def dequeue_from_lock_queue(
-    logger,
-    log_sampled,
-    lock_key,
-    queue_ttl,
-    acquier_id,
-    host_id,
-    access_strategy
-  )
-    return unless log_sampled
-
-    logger.debug do
-      "[redis_queued_locks.fail_fast_or_limits_reached_or_deadlock__dequeue] " \
-      "lock_key => '#{lock_key}' " \
-      "queue_ttl => #{queue_ttl} " \
-      "acq_id => '#{acquier_id}' " \
-      "hst_id => '#{host_id}' " \
-      "acs_strat => '#{access_strategy}"
-    end rescue nil
-  end
-end