redis_queued_locks 1.7.0 → 1.9.0

data/lib/redis_queued_locks/acquier/release_lock.rb

@@ -40,6 +40,9 @@ module RedisQueuedLocks::Acquier::ReleaseLock
     #   - you can provide your own log sampler with bettter algorithm that should realize
     #     `sampling_happened?(percent) => boolean` interface
     #     (see `RedisQueuedLocks::Logging::Sampler` for example);
+    # @param log_sample_this [Boolean]
+    #   - marks the method that everything should be logged despite the enabled log sampling;
+    #   - makes sense when log sampling is enabled;
     # @param instr_sampling_enabled [Boolean]
     #   - enables <instrumentaion sampling>: only the configured percent
     #     of RQL cases will be instrumented;
@@ -58,6 +61,10 @@ module RedisQueuedLocks::Acquier::ReleaseLock
     #   - you can provide your own log sampler with bettter algorithm that should realize
     #     `sampling_happened?(percent) => boolean` interface
     #     (see `RedisQueuedLocks::Instrument::Sampler` for example);
+    # @param instr_sample_this [Boolean]
+    #   - marks the method that everything should be instrumneted
+    #     despite the enabled instrumentation sampling;
+    #   - makes sense when instrumentation sampling is enabled;
     # @return [RedisQueuedLocks::Data,Hash<Symbol,Boolean<Hash<Symbol,Numeric|String|Symbol>>]
     #   Format: { ok: true/false, result: Hash<Symbol,Numeric|String|Symbol> }
     #
@@ -73,9 +80,11 @@ module RedisQueuedLocks::Acquier::ReleaseLock
       log_sampling_enabled,
       log_sampling_percent,
       log_sampler,
+      log_sample_this,
       instr_sampling_enabled,
       instr_sampling_percent,
-      instr_sampler
+      instr_sampler,
+      instr_sample_this
     )
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
@@ -84,10 +93,11 @@ module RedisQueuedLocks::Acquier::ReleaseLock
       fully_release_lock(redis, lock_key, lock_key_queue) => { ok:, result: }
       time_at = Time.now.to_f
       rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
-      rel_time = ((rel_end_time - rel_start_time) / 1_000).ceil(2)
+      rel_time = ((rel_end_time - rel_start_time) / 1_000.0).ceil(2)
 
       instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
         instr_sampling_enabled,
+        instr_sample_this,
         instr_sampling_percent,
         instr_sampler
       )

data/lib/redis_queued_locks/client.rb

@@ -14,6 +14,7 @@ class RedisQueuedLocks::Client
     setting :try_to_lock_timeout, 10 # NOTE: in seconds
     setting :default_lock_ttl, 5_000 # NOTE: in milliseconds
     setting :default_queue_ttl, 15 # NOTE: in seconds
+    setting :detailed_acq_timeout_error, false
     setting :lock_release_batch_size, 100
     setting :key_extraction_batch_size, 500
     setting :instrumenter, RedisQueuedLocks::Instrument::VoidNotifier
@@ -31,12 +32,63 @@ 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 }
     validate('try_to_lock_timeout') { |val| val == nil || (val.is_a?(::Integer) && val >= 0) }
     validate('default_lock_tt', :integer)
     validate('default_queue_ttl', :integer)
+    validate('detailed_acq_timeout_error', :boolean)
     validate('lock_release_batch_size', :integer)
     validate('instrumenter') { |val| RedisQueuedLocks::Instrument.valid_interface?(val) }
     validate('uniq_identifier', :proc)
@@ -80,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.
@@ -93,8 +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
+
+  # @return [Hash<Symbol,Boolean|Symbol>]
+  #
+  # @api public
+  # @since 1.9.0
+  def swarmize!
+    swarm.swarm!
+  end
+
+  # @return [Hash<Symbol,Boolean|Symbol>]
+  #
+  # @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.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]
+  )
+    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]
@@ -146,6 +314,27 @@ class RedisQueuedLocks::Client
   # @option meta [NilClass,Hash<String|Symbol,Any>]
   #   - A custom metadata wich will be passed to the lock data in addition to the existing data;
   #   - Metadata can not contain reserved lock data keys;
+  # @option detailed_acq_timeout_error [Boolean]
+  #  - When the lock acquirement try reached the acquirement time limit (:timeout option) the
+  #    `RedisQueuedLocks::LockAcquirementTimeoutError` is raised (when `raise_errors` option
+  #    set to `true`). The error message contains the lock key name and the timeout value).
+  #  - <true> option adds the additional details to the error message:
+  #    - current lock queue state (you can see which acquirer blocks your request and
+  #      how much acquirers are in queue);
+  #    - current lock data stored inside (for example: you can check the current acquirer and
+  #      the lock meta state if you store some additional data there);
+  #  - Realized as an option because of the additional lock data requires two additional Redis
+  #    queries: (1) get the current lock from redis and (2) fetch the lock queue state;
+  #  - These two additional Redis queries has async nature so you can receive
+  #    inconsistent data of the lock and of the lock queue in your error emssage because:
+  #    - required lock can be released after the error moment and before the error message build;
+  #    - required lock can be obtained by other process after the error moment and
+  #      before the error message build;
+  #    - required lock queue can reach a state when the blocking acquirer start to obtain the lock
+  #      and moved from the lock queue after the error moment and before the error message build;
+  #  - You should consider the async nature of this error message and should use received data
+  #    from error message correspondingly;
+  #  - pre-configred in `config[:detailed_acq_timeout_error]`;
   # @option logger [::Logger,#debug]
   #   - Logger object used from the configuration layer (see config[:logger]);
   #   - See `RedisQueuedLocks::Logging::VoidLogger` for example;
@@ -180,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;
@@ -198,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]
@@ -206,7 +402,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.7.0
+  # @version 1.8.0
   # rubocop:disable Metrics/MethodLength
   def lock(
     lock_name,
@@ -223,6 +419,7 @@ class RedisQueuedLocks::Client
     access_strategy: config[:default_access_strategy],
     identity: uniq_identity,
     meta: nil,
+    detailed_acq_timeout_error: config[:detailed_acq_timeout_error],
     logger: config[:logger],
     log_lock_try: config[:log_lock_try],
     instrumenter: config[:instrumenter],
@@ -230,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(
@@ -256,15 +455,18 @@ class RedisQueuedLocks::Client
       conflict_strategy:,
       access_strategy:,
       meta:,
+      detailed_acq_timeout_error:,
       logger:,
       log_lock_try:,
       instrument:,
       log_sampling_enabled:,
       log_sampling_percent:,
       log_sampler:,
+      log_sample_this:,
       instr_sampling_enabled:,
       instr_sampling_percent:,
       instr_sampler:,
+      instr_sample_this:,
       &block
     )
   end
@@ -274,7 +476,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.7.0
+  # @version 1.8.0
   # rubocop:disable Metrics/MethodLength
   def lock!(
     lock_name,
@@ -291,15 +493,18 @@ class RedisQueuedLocks::Client
     identity: uniq_identity,
     instrumenter: config[:instrumenter],
     meta: nil,
+    detailed_acq_timeout_error: config[:detailed_acq_timeout_error],
     logger: config[:logger],
     log_lock_try: config[:log_lock_try],
     instrument: nil,
     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(
@@ -317,6 +522,7 @@ class RedisQueuedLocks::Client
       logger:,
       log_lock_try:,
       meta:,
+      detailed_acq_timeout_error:,
       instrument:,
       instrumenter:,
       conflict_strategy:,
@@ -324,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
@@ -339,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,
@@ -365,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,
@@ -377,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]
@@ -419,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
@@ -438,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 }
@@ -457,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,
@@ -471,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
 
@@ -489,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 } }
   #
@@ -506,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,
@@ -519,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.
@@ -612,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> } }
   #
@@ -630,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,
@@ -644,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