redis_queued_locks 1.8.0 → 1.10.0

data/lib/redis_queued_locks/client.rb

@@ -32,6 +32,56 @@ class RedisQueuedLocks::Client
     setting :instr_sampling_percent, 15
     setting :instr_sampler, RedisQueuedLocks::Instrument::Sampler
 
+    setting :swarm do
+      setting :auto_swarm, false
+      setting :supervisor do
+        setting :liveness_probing_period, 2 # NOTE: in seconds
+      end
+      setting :probe_hosts do
+        setting :enabled_for_swarm, true
+        setting :redis_config do
+          setting :sentinel, false
+          setting :pooled, false
+          setting :config, {}
+          setting :pool_config, {}
+        end
+        setting :probe_period, 2 # NOTE: in seconds
+      end
+      setting :flush_zombies do
+        setting :enabled_for_swarm, true
+        setting :redis_config do
+          setting :sentinel, false
+          setting :pooled, false
+          setting :config, {}
+          setting :pool_config, {}
+        end
+        setting :zombie_ttl, 15_000 # NOTE: in milliseconds
+        setting :zombie_lock_scan_size, 500
+        setting :zombie_queue_scan_size, 500
+        setting :zombie_flush_period, 10 # NOTE: in seconds
+      end
+    end
+
+    validate('swarm.auto_swarm', :boolean)
+    validate('swarm.visor.liveness_probing_period', :integer)
+
+    validate('swarm.probe_hosts.enabled_for_swarm', :boolean)
+    validate('swarm.probe_hosts.redis_config.sentinel', :boolean)
+    validate('swarm.probe_hosts.redis_config.pooled', :boolean)
+    validate('swarm.probe_hosts.redis_config.config', :hash)
+    validate('swarm.probe_hosts.redis_config.pool_config', :hash)
+    validate('swarm.probe_hosts.probe_period', :integer)
+
+    validate('swarm.flush_zombies.enabled_for_swarm', :boolean)
+    validate('swarm.flush_zombies.redis_config.sentinel', :boolean)
+    validate('swarm.flush_zombies.redis_config.pooled', :boolean)
+    validate('swarm.flush_zombies.redis_config.config', :hash)
+    validate('swarm.flush_zombies.redis_config.pool_config', :hash)
+    validate('swarm.flush_zombies.zombie_ttl', :integer)
+    validate('swarm.flush_zombies.zombie_lock_scan_size', :integer)
+    validate('swarm.flush_zombies.zombie_queue_scan_size', :integer)
+    validate('swarm.flush_zombies.zombie_flush_period', :integer)
+
     validate('retry_count') { |val| val == nil || (val.is_a?(::Integer) && val >= 0) }
     validate('retry_delay') { |val| val.is_a?(::Integer) && val >= 0 }
     validate('retry_jitter') { |val| val.is_a?(::Integer) && val >= 0 }
@@ -82,6 +132,12 @@ class RedisQueuedLocks::Client
   # @since 1.0.0
   attr_accessor :uniq_identity
 
+  # @return [RedisQueuedLocks::Swarm]
+  #
+  # @api private
+  # @since 1.9.0
+  attr_reader :swarm
+
   # @param redis_client [RedisClient]
   #   Redis connection manager, which will be used for the lock acquierment and distribution.
   #   It should be an instance of RedisClient.
@@ -95,41 +151,118 @@ class RedisQueuedLocks::Client
     configure(&configs)
     @uniq_identity = config[:uniq_identifier].call
     @redis_client = redis_client
+    @swarm = RedisQueuedLocks::Swarm.new(self).tap { |s| s.swarm! if config[:swarm][:auto_swarm] }
   end
 
-  # Retrun the current acquirer identifier.
+  # @return [Hash<Symbol,Boolean|Symbol>]
   #
-  # @option process_id [Integer,Any] Process identifier.
-  # @option thread_id [Integer,Any] Thread identifier.
-  # @option fiber_id [Integer,Any] Fiber identifier.
-  # @option ractor_id [Integer,Any] Ractor identifier.
-  # @option identity [String] Unique per-process string. See `config[:uniq_identifier]`.
-  # @return [String]
+  # @api public
+  # @since 1.9.0
+  def swarmize!
+    swarm.swarm!
+  end
+
+  # @return [Hash<Symbol,Boolean|Symbol>]
   #
-  # @see RedisQueuedLocks::Resource.get_process_id
-  # @see RedisQueuedLocks::Resource.get_thread_id
-  # @see RedisQueuedLocks::Resource.get_fiber_id
-  # @see RedisQueuedLocks::Resource.get_ractor_id
-  # @see RedisQueuedLocks::Client#uniq_identity
+  # @api public
+  # @since 1.9.0
+  def deswarmize!
+    swarm.deswarm!
+  end
+
+  # @option zombie_ttl [Integer]
+  # @return [Hash<String,Hash<Symbol,Float|Time>>]
   #
   # @api public
-  # @since 1.8.0
-  def current_acquier_id(
-    process_id: RedisQueuedLocks::Resource.get_process_id,
-    thread_id: RedisQueuedLocks::Resource.get_thread_id,
-    fiber_id: RedisQueuedLocks::Resource.get_fiber_id,
-    ractor_id: RedisQueuedLocks::Resource.get_ractor_id,
-    identity: uniq_identity
+  # @since 1.9.0
+  def swarm_info(zombie_ttl: config[:swarm][:flush_zombies][:zombie_ttl])
+    swarm.swarm_info(zombie_ttl:)
+  end
+
+  # @return [Hash<Symbol,Boolean|<Hash<Symbol,Boolean>>]
+  #
+  # @api public
+  # @since 1.9.0
+  def swarm_status
+    swarm.swarm_status
+  end
+  alias_method :swarm_state, :swarm_status
+
+  # @return [Hash<Symbol,Boolean|String|Float>]
+  #
+  # @api public
+  # @since 1.9.0
+  def probe_hosts
+    swarm.probe_hosts
+  end
+
+  # @option zombie_ttl [Integer]
+  # @option lock_scan_size [Integer]
+  # @option queue_scan_size [Integer]
+  # @return [Hash<Symbol,Boolean|Set<String>>]
+  #
+  # @api public
+  # @since 1.9.0
+  def flush_zombies(
+    zombie_ttl: config[:swarm][:flush_zombies][:zombie_ttl],
+    lock_scan_size: config[:swarm][:flush_zombies][:zombie_lock_scan_size],
+    queue_scan_size: config[:swarm][:flush_zombies][:zombie_queue_scan_size]
   )
-    RedisQueuedLocks::Resource.acquier_identifier(
-      process_id,
-      thread_id,
-      fiber_id,
-      ractor_id,
-      identity
-    )
+    swarm.flush_zombies(zombie_ttl:, lock_scan_size:, queue_scan_size:)
+  end
+
+  # @option zombie_ttl [Integer]
+  # @option lock_scan_size [Integer]
+  # @return [Set<String>]
+  #
+  # @api public
+  # @since 1.9.0
+  def zombie_locks(
+    zombie_ttl: config[:swarm][:flush_zombies][:zombie_ttl],
+    lock_scan_size: config[:swarm][:flush_zombies][:zombie_lock_scan_size]
+  )
+    swarm.zombie_locks(zombie_ttl:, lock_scan_size:)
+  end
+
+  # @option zombie_ttl [Integer]
+  # @option lock_scan_size [Integer]
+  # @return [Set<String>]
+  #
+  # @api ppublic
+  # @since 1.9.0
+  def zombie_acquiers(
+    zombie_ttl: config[:swarm][:flush_zombies][:zombie_ttl],
+    lock_scan_size: config[:swarm][:flush_zombies][:zombie_lock_scan_size]
+  )
+    swarm.zombie_acquiers(zombie_ttl:, lock_scan_size:)
   end
 
+  # @option zombie_ttl [Integer]
+  # @return [Set<String>]
+  #
+  # @api public
+  # @since 1.9.0
+  def zombie_hosts(zombie_ttl: config[:swarm][:flush_zombies][:zombie_ttl])
+    swarm.zombie_hosts(zombie_ttl:)
+  end
+
+  # @return [Hash<Symbol,Set<String>>]
+  #   Format: {
+  #     zombie_hosts: <Set<String>>,
+  #     zombie_acquiers: <Set<String>>,
+  #     zombie_locks: <Set<String>>
+  #   }
+  #
+  # @api public
+  # @since 1.9.0
+  def zombies_info(
+    zombie_ttl: config[:swarm][:flush_zombies][:zombie_ttl],
+    lock_scan_size: config[:swarm][:flush_zombies][:zombie_ttl]
+  )
+    swarm.zombies_info(zombie_ttl:, lock_scan_size:)
+  end
+  alias_method :zombies, :zombies_info
+
   # @param lock_name [String]
   #   Lock name to be obtained.
   # @option ttl [Integer]
@@ -236,6 +369,9 @@ class RedisQueuedLocks::Client
   #   - you can provide your own log sampler with bettter algorithm that should realize
   #     `sampling_happened?(percent) => boolean` interface
   #     (see `RedisQueuedLocks::Logging::Sampler` for example);
+  # @option log_sample_this [Boolean]
+  #   - marks the method that everything should be logged despite the enabled log sampling;
+  #   - makes sense when log sampling is enabled;
   # @option instr_sampling_enabled [Boolean]
   #   - enables <instrumentaion sampling>: only the configured percent
   #     of RQL cases will be instrumented;
@@ -254,6 +390,10 @@ class RedisQueuedLocks::Client
   #   - you can provide your own log sampler with bettter algorithm that should realize
   #     `sampling_happened?(percent) => boolean` interface
   #     (see `RedisQueuedLocks::Instrument::Sampler` for example);
+  # @option instr_sample_this [Boolean]
+  #   - marks the method that everything should be instrumneted
+  #     despite the enabled instrumentation sampling;
+  #   - makes sense when instrumentation sampling is enabled;
   # @param block [Block]
   #   A block of code that should be executed after the successfully acquired lock.
   # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>,yield]
@@ -287,9 +427,11 @@ class RedisQueuedLocks::Client
     log_sampling_enabled: config[:log_sampling_enabled],
     log_sampling_percent: config[:log_sampling_percent],
     log_sampler: config[:log_sampler],
+    log_sample_this: false,
     instr_sampling_enabled: config[:instr_sampling_enabled],
     instr_sampling_percent: config[:instr_sampling_percent],
     instr_sampler: config[:instr_sampler],
+    instr_sample_this: false,
     &block
   )
     RedisQueuedLocks::Acquier::AcquireLock.acquire_lock(
@@ -320,9 +462,11 @@ class RedisQueuedLocks::Client
       log_sampling_enabled:,
       log_sampling_percent:,
       log_sampler:,
+      log_sample_this:,
       instr_sampling_enabled:,
       instr_sampling_percent:,
       instr_sampler:,
+      instr_sample_this:,
       &block
     )
   end
@@ -356,9 +500,11 @@ class RedisQueuedLocks::Client
     log_sampling_enabled: config[:log_sampling_enabled],
     log_sampling_percent: config[:log_sampling_percent],
     log_sampler: config[:log_sampler],
+    log_sample_this: false,
     instr_sampling_enabled: config[:instr_sampling_enabled],
     instr_sampling_percent: config[:instr_sampling_percent],
     instr_sampler: config[:instr_sampler],
+    instr_sample_this: false,
     &block
   )
     lock(
@@ -384,9 +530,11 @@ class RedisQueuedLocks::Client
       log_sampling_enabled:,
       log_sampling_percent:,
       log_sampler:,
+      log_sample_this:,
       instr_sampling_enabled:,
       instr_sampling_percent:,
       instr_sampler:,
+      instr_sample_this:,
       &block
     )
   end
@@ -399,9 +547,11 @@ class RedisQueuedLocks::Client
   # @option log_sampling_enabled [Boolean]
   # @option log_sampling_percent [Integer]
   # @option log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
+  # @option log_sample_this [Boolean]
   # @option instr_sampling_enabled [Boolean]
   # @option instr_sampling_percent [Integer]
   # @option instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
+  # @option instr_sample_this [Boolean]
   # @return [RedisQueuedLocks::Data, Hash<Symbol,Any>]
   #   Format: {
   #     ok: true/false,
@@ -425,9 +575,11 @@ class RedisQueuedLocks::Client
     log_sampling_enabled: config[:log_sampling_enabled],
     log_sampling_percent: config[:log_sampling_percent],
     log_sampler: config[:log_sampler],
+    log_sample_this: false,
     instr_sampling_enabled: config[:instr_sampling_enabled],
     instr_sampling_percent: config[:instr_sampling_percent],
-    instr_sampler: config[:instr_sampler]
+    instr_sampler: config[:instr_sampler],
+    instr_sample_this: false
   )
     RedisQueuedLocks::Acquier::ReleaseLock.release_lock(
       redis_client,
@@ -437,11 +589,14 @@ class RedisQueuedLocks::Client
       log_sampling_enabled,
       log_sampling_percent,
       log_sampler,
+      log_sample_this,
       instr_sampling_enabled,
       instr_sampling_percent,
-      instr_sampler
+      instr_sampler,
+      instr_sample_this
     )
   end
+  alias_method :release_lock, :unlock
 
   # @param lock_name [String]
   # @return [Boolean]
@@ -479,6 +634,82 @@ class RedisQueuedLocks::Client
     RedisQueuedLocks::Acquier::QueueInfo.queue_info(redis_client, lock_name)
   end
 
+  # Retrun the current acquirer identifier.
+  #
+  # @option process_id [Integer,Any] Process identifier.
+  # @option thread_id [Integer,Any] Thread identifier.
+  # @option fiber_id [Integer,Any] Fiber identifier.
+  # @option ractor_id [Integer,Any] Ractor identifier.
+  # @option identity [String] Unique per-process string. See `config[:uniq_identifier]`.
+  # @return [String]
+  #
+  # @see RedisQueuedLocks::Resource.acquier_identifier
+  # @see RedisQueuedLocks::Resource.get_process_id
+  # @see RedisQueuedLocks::Resource.get_thread_id
+  # @see RedisQueuedLocks::Resource.get_fiber_id
+  # @see RedisQueuedLocks::Resource.get_ractor_id
+  # @see RedisQueuedLocks::Client#uniq_identity
+  #
+  # @api public
+  # @since 1.8.0
+  def current_acquier_id(
+    process_id: RedisQueuedLocks::Resource.get_process_id,
+    thread_id: RedisQueuedLocks::Resource.get_thread_id,
+    fiber_id: RedisQueuedLocks::Resource.get_fiber_id,
+    ractor_id: RedisQueuedLocks::Resource.get_ractor_id,
+    identity: uniq_identity
+  )
+    RedisQueuedLocks::Resource.acquier_identifier(
+      process_id,
+      thread_id,
+      fiber_id,
+      ractor_id,
+      identity
+    )
+  end
+
+  # Retrun the current host identifier.
+  #
+  # @option process_id [Integer,Any] Process identifier.
+  # @option thread_id [Integer,Any] Thread identifier.
+  # @option fiber_id [Integer,Any] Fiber identifier.
+  # @option ractor_id [Integer,Any] Ractor identifier.
+  # @option identity [String] Unique per-process string. See `config[:uniq_identifier]`.
+  # @return [String]
+  #
+  # @see RedisQueuedLocks::Resource.host_identifier
+  # @see RedisQueuedLocks::Resource.get_process_id
+  # @see RedisQueuedLocks::Resource.get_thread_id
+  # @see RedisQueuedLocks::Resource.get_ractor_id
+  # @see RedisQueuedLocks::Client#uniq_identity
+  #
+  # @api public
+  # @since 1.9.0
+  def current_host_id(
+    process_id: RedisQueuedLocks::Resource.get_process_id,
+    thread_id: RedisQueuedLocks::Resource.get_thread_id,
+    ractor_id: RedisQueuedLocks::Resource.get_ractor_id,
+    identity: uniq_identity
+  )
+    RedisQueuedLocks::Resource.host_identifier(
+      process_id,
+      thread_id,
+      ractor_id,
+      identity
+    )
+  end
+
+  # Return the list of possible host identifiers that can be reached from the current ractor.
+  #
+  # @param identity [String] Unique identity (RedisQueuedLocks::Client#uniq_identity by default)
+  # @return [Array<String>]
+  #
+  # @api public
+  # @since 1.9.0
+  def possible_host_ids(identity = uniq_identity)
+    RedisQueuedLocks::Resource.possible_host_identifiers(identity)
+  end
+
   # This method is non-atomic cuz redis does not provide an atomic function for TTL/PTTL extension.
   # So the methid is spliited into the two commands:
   #   (1) read current pttl
@@ -498,9 +729,11 @@ class RedisQueuedLocks::Client
   # @option log_sampling_enabled [Boolean]
   # @option log_sampling_percent [Integer]
   # @option log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
+  # @option log_sample_this [Boolean]
   # @option instr_sampling_enabled [Boolean]
   # @option instr_sampling_percent [Integer]
   # @option instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
+  # @option instr_sample_this [Boolean]
   # @return [Hash<Symbol,Boolean|Symbol>]
   #   - { ok: true, result: :ttl_extended }
   #   - { ok: false, result: :async_expire_or_no_lock }
@@ -517,9 +750,11 @@ class RedisQueuedLocks::Client
     log_sampling_enabled: config[:log_sampling_enabled],
     log_sampling_percent: config[:log_sampling_percent],
     log_sampler: config[:log_sampler],
+    log_sample_this: false,
     instr_sampling_enabled: config[:instr_sampling_enabled],
     instr_sampling_percent: config[:instr_sampling_percent],
-    instr_sampler: config[:instr_sampler]
+    instr_sampler: config[:instr_sampler],
+    instr_sample_this: false
   )
     RedisQueuedLocks::Acquier::ExtendLockTTL.extend_lock_ttl(
       redis_client,
@@ -531,9 +766,11 @@ class RedisQueuedLocks::Client
       log_sampling_enabled,
       log_sampling_percent,
       log_sampler,
+      log_sample_this,
       instr_sampling_enabled,
       instr_sampling_percent,
-      instr_sampler
+      instr_sampler,
+      instr_sample_this
     )
   end
 
@@ -549,9 +786,11 @@ class RedisQueuedLocks::Client
   # @option log_sampling_enabled [Boolean]
   # @option log_sampling_percent [Integer]
   # @option log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
+  # @option log_sample_this [Boolean]
   # @option instr_sampling_enabled [Boolean]
   # @option instr_sampling_percent [Integer]
   # @option instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
+  # @option instr_sample_this [Boolean]
   # @return [RedisQueuedLocks::Data,Hash<Symbol,Boolean|Hash<Symbol,Numeric>>]
   #   Example: { ok: true, result { rel_key_cnt: 100, rel_time: 0.01 } }
   #
@@ -566,9 +805,11 @@ class RedisQueuedLocks::Client
     log_sampling_enabled: config[:log_sampling_enabled],
     log_sampling_percent: config[:log_sampling_percent],
     log_sampler: config[:log_sampler],
+    log_sample_this: false,
     instr_sampling_enabled: config[:instr_sampling_enabled],
     instr_sampling_percent: config[:instr_sampling_percent],
-    instr_sampler: config[:instr_sampler]
+    instr_sampler: config[:instr_sampler],
+    instr_sample_this: false
   )
     RedisQueuedLocks::Acquier::ReleaseAllLocks.release_all_locks(
       redis_client,
@@ -579,11 +820,14 @@ class RedisQueuedLocks::Client
       log_sampling_enabled,
       log_sampling_percent,
       log_sampler,
+      log_sample_this,
       instr_sampling_enabled,
       instr_sampling_percent,
-      instr_sampler
+      instr_sampler,
+      instr_sample_this
     )
   end
+  alias_method :release_locks, :clear_locks
 
   # @option scan_size [Integer]
   #   The batch of scanned keys for Redis'es SCAN command.
@@ -672,9 +916,11 @@ class RedisQueuedLocks::Client
   # @option log_sampling_enabled [Boolean]
   # @option log_sampling_percent [Integer]
   # @option log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
+  # @option log_sample_this [Boolean]
   # @option instr_sampling_enabled [Boolean]
   # @option instr_sampling_percent [Integer]
   # @option instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
+  # @option instr_sample_this [Boolean]
   # @return [Hash<Symbol,Boolean|Hash<Symbol,Set<String>>>]
   #   Format: { ok: true, result: { processed_queus: Set<String> } }
   #
@@ -690,9 +936,11 @@ class RedisQueuedLocks::Client
     log_sampling_enabled: config[:log_sampling_enabled],
     log_sampling_percent: config[:log_sampling_percent],
     log_sampler: config[:log_sampler],
+    log_sample_this: false,
     instr_sampling_enabled: config[:instr_sampling_enabled],
     instr_sampling_percent: config[:instr_sampling_percent],
-    instr_sampler: config[:instr_sampler]
+    instr_sampler: config[:instr_sampler],
+    instr_sample_this: false
   )
     RedisQueuedLocks::Acquier::ClearDeadRequests.clear_dead_requests(
       redis_client,
@@ -704,9 +952,11 @@ class RedisQueuedLocks::Client
       log_sampling_enabled,
       log_sampling_percent,
       log_sampler,
+      log_sample_this,
       instr_sampling_enabled,
       instr_sampling_percent,
-      instr_sampler
+      instr_sampler,
+      instr_sample_this
     )
   end
 end

data/lib/redis_queued_locks/errors.rb

@@ -28,4 +28,12 @@ module RedisQueuedLocks
   # @api public
   # @since 1.3.0
   ConflictLockObtainError = Class.new(Error)
+
+  # @api public
+  # @since 1.9.0
+  SwarmError = Class.new(Error)
+
+  # @api public
+  # @since 1.9.0
+  SwarmArgumentError = Class.new(ArgumentError)
 end

data/lib/redis_queued_locks/instrument.rb

@@ -10,14 +10,21 @@ module RedisQueuedLocks::Instrument
 
   class << self
     # @param instr_sampling_enabled [Boolean]
+    # @param instr_sample_this [Boolean]
     # @param instr_sampling_percent [Integer]
     # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
     # @return [Boolean]
     #
     # @api private
     # @since 1.6.0
-    def should_instrument?(instr_sampling_enabled, instr_sampling_percent, instr_sampler)
+    def should_instrument?(
+      instr_sampling_enabled,
+      instr_sample_this,
+      instr_sampling_percent,
+      instr_sampler
+    )
       return true unless instr_sampling_enabled
+      return true if instr_sample_this
       instr_sampler.sampling_happened?(instr_sampling_percent)
     end
 

data/lib/redis_queued_locks/logging.rb

@@ -9,14 +9,21 @@ module RedisQueuedLocks::Logging
 
   class << self
     # @param log_sampling_enabled [Boolean]
+    # @param log_sample_this [Boolean]
     # @param log_sampling_percent [Integer]
     # @param log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
     # @return [Boolean]
     #
     # @api private
     # @since 1.5.0
-    def should_log?(log_sampling_enabled, log_sampling_percent, log_sampler)
+    def should_log?(
+      log_sampling_enabled,
+      log_sample_this,
+      log_sampling_percent,
+      log_sampler
+    )
       return true unless log_sampling_enabled
+      return true if log_sample_this
       log_sampler.sampling_happened?(log_sampling_percent)
     end
 

data/lib/redis_queued_locks/resource.rb

@@ -21,6 +21,12 @@ module RedisQueuedLocks::Resource
   # @since 1.0.0
   LOCK_QUEUE_PATTERN = 'rql:lock_queue:*'
 
+  # @return [String]
+  #
+  # @api private
+  # @since 1.9.0
+  SWARM_KEY = 'rql:swarm:hsts'
+
   # @return [Integer] Redis time error (in milliseconds).
   #
   # @api private
@@ -53,6 +59,22 @@ module RedisQueuedLocks::Resource
       "rql:acq:#{process_id}/#{thread_id}/#{fiber_id}/#{ractor_id}/#{identity}"
     end
 
+    # @param process_id [Integer,String]
+    # @param thread_id [Integer,String]
+    # @param ractor_id [Integer,String]
+    # @param identity [String]
+    # @return [String]
+    #
+    # @api private
+    # @since 1.9.0
+    def host_identifier(process_id, thread_id, ractor_id, identity)
+      # NOTE:
+      #   - fiber's object_id is not used cuz we can't analyze fiber objects via ObjectSpace
+      #     after the any new Ractor object is created in the current process
+      #     (ObjectSpace no longer sees objects of Thread and Fiber classes after that);
+      "rql:hst:#{process_id}/#{thread_id}/#{ractor_id}/#{identity}"
+    end
+
     # @param lock_name [String]
     # @return [String]
     #
@@ -88,8 +110,17 @@ module RedisQueuedLocks::Resource
       Time.now.to_f - queue_ttl
     end
 
+    # @param zombie_ttl [Float] In seconds with milliseconds.
+    # @return [Float]
+    #
+    # @api private
+    # @since 1.9.0
+    def calc_zombie_score(zombie_ttl)
+      Time.now.to_f - zombie_ttl
+    end
+
     # @param acquier_position [Float]
-    #   A time (epoch, seconds.microseconds) that represents
+    #   A time (epoch, seconds.milliseconds) that represents
     #   the acquier position in lock request queue.
     # @parma queue_ttl [Integer]
     #   In second.
@@ -143,5 +174,32 @@ module RedisQueuedLocks::Resource
     def get_process_id
       ::Process.pid
     end
+
+    # @return [Array<String>]
+    #
+    # @api private
+    # @since 1.9.0
+    def possible_host_identifiers(identity)
+      # NOTE №1: we can not use ObjectSpace.each_object for Thread and Fiber cuz after the any
+      #   ractor creation the ObjectSpace stops seeing ::Thread and ::Fiber objects: each_object
+      #   for each of them returns `0`;
+      # NOTE №2: we have no any approach to count Fiber objects in the current process without
+      #   object space API (or super memory-expensive) so host identification works without fibers;
+      # NOTE №3: we still can extract thread objects via Thread.list API;
+      current_process_id = get_process_id
+      current_threads = ::Thread.list
+      current_ractor_id = get_ractor_id
+
+      [].tap do |acquiers|
+        current_threads.each do |thread|
+          acquiers << host_identifier(
+            current_process_id,
+            thread.object_id,
+            current_ractor_id,
+            identity
+          )
+        end
+      end
+    end
   end
 end