redis_queued_locks 1.4.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 448f8b89e4a34bb2543b55d46877d80f76cf8e4b5d07735486f53eb1edb37432
-  data.tar.gz: 4fbefadd9a162ab298b100bca38387045c65c89918ffd70c3f4aa418aa72d22a
+  metadata.gz: dd9e0ee49d4c08d6ba572a825da792468926b2f676e872a2337b1ce2eff60836
+  data.tar.gz: ae635ac450f966539581c4b5a53098b92ba29562bb0641049571ca0ceb1461e7
 SHA512:
-  metadata.gz: 738c503d6189ca4673d1bc5af829066378654a070b78691ae7d1001e832795dbb91f1cde3e89252ff6b9831a659daf517eea1ea2ab721101c9140afe16b44974
-  data.tar.gz: cb2b4893238e55688b01c56f5f0004217d206122d5ae5ef3a0ea8f2d206323442e4c10bf78f3d504f947795864decc712f5385448b205151ccfe7ca39ab9ea0a
+  metadata.gz: b678b3fbccd5273d17d07120c144b0eb1c6be32db73ff1aa2f9fb19f485d30499645f3c4592fad0cb4cdeab1ebcd37f437b62740e01a46dce999eaaa2814f146
+  data.tar.gz: b8cb79c79767cd1d3b831992454c84c8399f6bf7ac313b8a2d0a7527711f555cb2196a172ae435103df2fc4c3e483b0a5b35775fba4baee7b7bad6234103cb0a

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 ## [Unreleased]
 
+## [1.6.0] - 2024-05-25
+### Added
+- New Feature: **Instrumentation Sampling** - configurable instrumentation sampling based on `weight` algorithm (where the weight is a percentage of RQL cases that should be logged);
+- Missing instrumenter customization in public `RedisQueuedLocks::Client` methods;
+- Documentation updates;
+
+## [1.5.0] - 2024-05-23
+### Added
+- New Feature: **Log sampling** - configurable log sampling based on `weight` algorithm (where the weight is a percentage of RQL cases that should be logged);
+
 ## [1.4.0] - 2024-05-13
 ### Added
 - `#lock`/`#lock!`: reduced memory allocaiton during `:meta` attribute type checking;

data/README.md

@@ -4,7 +4,7 @@
 
 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.
 
-Provides flexible invocation flow, parametrized limits (lock request ttl, lock ttls, queue ttls, lock attempts limit, fast failing, etc), logging and instrumentation.
+Provides flexible invocation flow, parametrized limits (lock request ttl, lock ttl, queue ttl, lock attempts limit, fast failing, etc), logging and instrumentation.
 
 ---
 
@@ -182,10 +182,10 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
 
   # (default: RedisQueuedLocks::Instrument::VoidNotifier)
   # - instrumentation layer;
-  # - you can provde your own instrumenter with `#notify(event, payload = {})`
+  # - you can provide your own instrumenter that should realize `#notify(event, payload = {})` interface:
   #   - event: <string> requried;
   #   - payload: <hash> requried;
-  # - disabled by default via VoidNotifier;
+  # - disabled by default via `VoidNotifier`;
   config.instrumenter = RedisQueuedLocks::Instrument::ActiveSupport
 
   # (default: -> { RedisQueuedLocks::Resource.calc_uniq_identity })
@@ -232,6 +232,48 @@ clinet = RedisQueuedLocks::Client.new(redis_client) do |config|
   #   - "[redis_queued_locks.try_lock.exit__lock_still_obtained]" (logs "lock_key", "queue_ttl", "acq_id", "first_acq_id_in_queue", "locked_by_acq_id", "<current_lock_data>");
   #   - "[redis_queued_locks.try_lock.obtain__free_to_acquire]" (logs "lock_key", "queue_ttl", "acq_id");
   config.log_lock_try = false
+
+  # (default: false)
+  # - enables <log sampling>: only the configured percent of RQL cases will be logged;
+  # - disabled by default;
+  # - works in tandem with <config.log_sampling_percent> and <log.sampler> configs;
+  config.log_sampling_enabled = false
+
+  # (default: 15)
+  # - the percent of cases that should be logged;
+  # - take an effect when <config.log_sampling_enalbed> is true;
+  # - works in tandem with <config.log_sampling_enabled> and <config.log_sampler> configs;
+  config.log_sampling_percent = 15
+
+  # (default: RedisQueuedLocks::Logging::Sampler)
+  # - percent-based log sampler that decides should be RQL case logged or not;
+  # - works in tandem with <config.log_sampling_enabled> and <config.log_sampling_percent> configs;
+  # - based on the ultra simple percent-based (weight-based) algorithm that uses SecureRandom.rand
+  #   method so the algorithm error is ~(0%..13%);
+  # - you can provide your own log sampler with bettter algorithm that should realize
+  #   `sampling_happened?(percent) => boolean` interface (see `RedisQueuedLocks::Logging::Sampler` for example);
+  config.log_sampler = RedisQueuedLocks::Logging::Sampler
+
+  # (default: false)
+  # - enables <instrumentaion sampling>: only the configured percent of RQL cases will be instrumented;
+  # - disabled by default;
+  # - works in tandem with <config.instr_sampling_percent and <log.instr_sampler>;
+  config.instr_sampling_enabled = false
+
+  # (default: 15)
+  # - the percent of cases that should be instrumented;
+  # - take an effect when <config.instr_sampling_enalbed> is true;
+  # - works in tandem with <config.instr_sampling_enabled> and <config.instr_sampler> configs;
+  config.instr_sampling_percent = 15
+
+  # (default: RedisQueuedLocks::Instrument::Sampler)
+  # - percent-based log sampler that decides should be RQL case instrumented or not;
+  # - works in tandem with <config.instr_sampling_enabled> and <config.instr_sampling_percent> configs;
+  # - based on the ultra simple percent-based (weight-based) algorithm that uses SecureRandom.rand
+  #   method so the algorithm error is ~(0%..13%);
+  # - you can provide your own log sampler with bettter algorithm that should realize
+  #   `sampling_happened?(percent) => boolean` interface (see `RedisQueuedLocks::Instrument::Sampler` for example);
+  config.instr_sampler = RedisQueuedLocks::Instrument::Sampler
 end
 ```
 
@@ -288,8 +330,15 @@ def lock(
   identity: uniq_identity, # (attr_accessor) calculated during client instantiation via config[:uniq_identifier] proc;
   meta: nil,
   instrument: nil,
+  instrumenter: config[:instrumenter],
   logger: config[:logger],
   log_lock_try: config[:log_lock_try],
+  log_sampling_enabled: config[:log_sampling_enabled],
+  log_sampling_percent: config[:log_sampling_percent],
+  log_sampler: config[:log_sampler],
+  instr_sampling_enabled: config[:instr_sampling_enabled],
+  instr_sampling_percent: config[:instr_sampling_percent],
+  instr_sampler: config[:instr_sampler],
   &block
 )
 ```
@@ -322,6 +371,9 @@ def lock(
   - See RedisQueuedLocks::Instrument::ActiveSupport for example;
   - See [Instrumentation](#instrumentation) section of docs;
   - pre-configured in `config[:isntrumenter]` with void notifier (`RedisQueuedLocks::Instrumenter::VoidNotifier`);
+- `instrument` - (optional) `[NilClass,Any]`
+  - Custom instrumentation data wich will be passed to the instrumenter's payload with :instrument key;
+  - `nil` by default (means "no custom instrumentation data");
 - `raise_errors` - (optional) `[Boolean]`
   - Raise errors on library-related limits (such as timeout or retry count limit) and on lock conflicts (such as same-process dead locks);
   - `false` by default;
@@ -353,9 +405,6 @@ def lock(
   - A custom metadata wich will be passed to the lock data in addition to the existing data;
   - Custom metadata can not contain reserved lock data keys (such as `lock_key`, `acq_id`, `ts`, `ini_ttl`, `rem_ttl`);
   - `nil` by default (means "no metadata");
-- `instrument` - (optional) `[NilClass,Any]`
-  - Custom instrumentation data wich will be passed to the instrumenter's payload with :instrument key;
-  - `nil` by default (means "no custom instrumentation data");
 - `logger` - (optional) `[::Logger,#debug]`
   - Logger object used for loggin internal mutation oeprations and opertioan results / process progress;
   - pre-configured in `config[:logger]` with void logger `RedisQueuedLocks::Logging::VoidLogger`;
@@ -363,6 +412,42 @@ def lock(
   - should be logged the each try of lock acquiring (a lot of logs can be generated depending on your retry configurations);
   - pre-configured in `config[:log_lock_try]`;
   - `false` by default;
+- `log_sampling_enabled` - (optional) `[Boolean]`
+  - enables **log sampling**: only the configured percent of RQL cases will be logged;
+  - disabled by default;
+  - works in tandem with `log_sampling_percent` and `log_sampler` options;
+  - pre-configured in `config[:log_sampling_enabled]`;
+- `log_sampling_percent` - (optional) `[Integer]`
+  - the percent of cases that should be logged;
+  - take an effect when `log_sampling_enalbed` is true;
+  - works in tandem with `log_sampling_enabled` and `log_sampler` options;
+  - pre-configured in `config[:log_sampling_percent]`;
+- `log_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]`
+  - percent-based log sampler that decides should be RQL case logged or not;
+  - works in tandem with `log_sampling_enabled` and `log_sampling_percent` options;
+  - based on the ultra simple percent-based (weight-based) algorithm that uses SecureRandom.rand
+    method so the algorithm error is ~(0%..13%);
+  - you can provide your own log sampler with bettter algorithm that should realize
+    `sampling_happened?(percent) => boolean` interface (see `RedisQueuedLocks::Logging::Sampler` for example);
+  - pre-configured in `config[:log_sampler]`;
+- `instr_sampling_enabled` - (optional) `[Boolean]`
+  - enables **instrumentaion sampling**: only the configured percent of RQL cases will be instrumented;
+  - disabled by default;
+  - works in tandem with `instr_sampling_percent` and `instr_sampler` options;
+  - pre-configured in `config[:instr_sampling_enabled]`;
+- `instr_sampling_percent` - (optional) `[Integer]`
+  - the percent of cases that should be instrumented;
+  - take an effect when `instr_sampling_enalbed` is true;
+  - works in tandem with `instr_sampling_enabled` and `instr_sampler` options;
+  - pre-configured in `config[:instr_sampling_percent]`;
+- `instr_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]`
+  - percent-based log sampler that decides should be RQL case instrumented or not;
+  - works in tandem with `instr_sampling_enabled` and `instr_sampling_percent` options;
+  - based on the ultra simple percent-based (weight-based) algorithm that uses SecureRandom.rand
+    method so the algorithm error is ~(0%..13%);
+  - you can provide your own log sampler with bettter algorithm that should realize
+    `sampling_happened?(percent) => boolean` interface (see `RedisQueuedLocks::Instrument::Sampler` for example);
+  - pre-configured in `config[:instr_sampler]`;
 - `block` - (optional) `[Block]`
   - A block of code that should be executed after the successfully acquired lock.
   - If block is **passed** the obtained lock will be released after the block execution or it's ttl (what will happen first);
@@ -516,7 +601,7 @@ rql.lock("my_lock", queue_ttl: 5, timeout: 10_000, retry_count: nil)
 
 # lock queue: =>
 [
- "rql:acq:123/456/567/676/374dd74324", 
+ "rql:acq:123/456/567/676/374dd74324",
  "rql:acq:123/456/567/677/374dd74322", # <- long living lock
  "rql:acq:123/456/567/679/374dd74321",
  "rql:acq:123/456/567/683/374dd74322", # <== we are here
@@ -571,7 +656,14 @@ def lock!(
   logger: config[:logger],
   log_lock_try: config[:log_lock_try],
   instrument: nil,
+  instrumenter: config[:instrumenter],
   conflict_strategy: config[:default_conflict_strategy],
+  log_sampling_enabled: config[:log_sampling_enabled],
+  log_sampling_percent: config[:log_sampling_percent],
+  log_sampler: config[:log_sampler],
+  instr_sampling_enabled: config[:instr_sampling_enabled],
+  instr_sampling_percent: config[:instr_sampling_percent],
+  instr_sampler: config[:instr_sampler],
   &block
 )
 ```
@@ -743,6 +835,24 @@ rql.queued?("your_lock_name") # => true/false
   - `:instrument` - (optional) `[NilClass,Any]`;
     - custom instrumentation data wich will be passed to the instrumenter's payload with :instrument key;
     - `nil` by default (no additional data);
+  - `:log_sampling_enabled` - (optional) `[Boolean]`
+    - enables **log sampling**;
+    - pre-configured in `config[:log_sampling_enabled]`;
+  - `:log_sampling_percent` - (optional) `[Integer]`
+    - **log sampling**:the percent of cases that should be logged;
+    - pre-configured in `config[:log_sampling_percent]`;
+  - `:log_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]`
+    - **log sampling**: percent-based log sampler that decides should be RQL case logged or not;
+    - pre-configured in `config[:log_sampler]`;
+  - `:instr_sampling_enabled` - (optional) `[Boolean]`
+    - enables **instrumentaion sampling**;
+    - pre-configured in `config[:instr_sampling_enabled]`;
+  - `instr_sampling_percent` - (optional) `[Integer]`
+    - the percent of cases that should be instrumented;
+    - pre-configured in `config[:instr_sampling_percent]`;
+  - `instr_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]`
+    - percent-based log sampler that decides should be RQL case instrumented or not;
+    - pre-configured in `config[:instr_sampler]`;
 - if you try to unlock non-existent lock you will receive `ok: true` result with operation timings
   and `:nothing_to_release` result factor inside;
 
@@ -793,6 +903,24 @@ rql.unlock("your_lock_name")
     - pre-configured value in `config[:isntrumenter]`;
   - `:instrument` - (optional) `[NilClass,Any]`
     - custom instrumentation data wich will be passed to the instrumenter's payload with `:instrument` key;
+  - `:log_sampling_enabled` - (optional) `[Boolean]`
+    - enables **log sampling**;
+    - pre-configured in `config[:log_sampling_enabled]`;
+  - `:log_sampling_percent` - (optional) `[Integer]`
+    - **log sampling**:the percent of cases that should be logged;
+    - pre-configured in `config[:log_sampling_percent]`;
+  - `:log_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]`
+    - **log sampling**: percent-based log sampler that decides should be RQL case logged or not;
+    - pre-configured in `config[:log_sampler]`;
+  - `:instr_sampling_enabled` - (optional) `[Boolean]`
+    - enables **instrumentaion sampling**;
+    - pre-configured in `config[:instr_sampling_enabled]`;
+  - `instr_sampling_percent` - (optional) `[Integer]`
+    - the percent of cases that should be instrumented;
+    - pre-configured in `config[:instr_sampling_percent]`;
+  - `instr_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]`
+    - percent-based log sampler that decides should be RQL case instrumented or not;
+    - pre-configured in `config[:instr_sampler]`;
 - returns:
   - `[Hash<Symbol,Numeric>]` - Format: `{ ok: true, result: Hash<Symbol,Numeric> }`;
   - result data:
@@ -825,9 +953,33 @@ rql.clear_locks
     - the lock name which ttl should be extended;
   - `milliseconds` - (required) `[Integer]`
     - how many milliseconds should be added to the lock's TTL;
+  - `:instrumenter` - (optional) `[#notify]`
+    - custom instrumenter object;
+    - pre-configured in `config[:instrumetner]`;
+  - `:instrument` - (optional) `[NilClass,Any]`;
+    - custom instrumentation data wich will be passed to the instrumenter's payload with :instrument key;
+    - `nil` by default (no additional data);
   - `:logger` - (optional) `[::Logger,#debug]`
     - custom logger object;
     - pre-configured in `config[:logger]`;
+  - `:log_sampling_enabled` - (optional) `[Boolean]`
+    - enables **log sampling**;
+    - pre-configured in `config[:log_sampling_enabled]`;
+  - `:log_sampling_percent` - (optional) `[Integer]`
+    - **log sampling**:the percent of cases that should be logged;
+    - pre-configured in `config[:log_sampling_percent]`;
+  - `:log_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]`
+    - **log sampling**: percent-based log sampler that decides should be RQL case logged or not;
+    - pre-configured in `config[:log_sampler]`;
+  - `:instr_sampling_enabled` - (optional) `[Boolean]`
+    - enables **instrumentaion sampling**;
+    - pre-configured in `config[:instr_sampling_enabled]`;
+  - `instr_sampling_percent` - (optional) `[Integer]`
+    - the percent of cases that should be instrumented;
+    - pre-configured in `config[:instr_sampling_percent]`;
+  - `instr_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]`
+    - percent-based log sampler that decides should be RQL case instrumented or not;
+    - pre-configured in `config[:instr_sampler]`;
 - returns `{ ok: true, result: :ttl_extended }` when ttl is extended;
 - returns `{ ok: false, result: :async_expire_or_no_lock }` when a lock not found or a lock is already expired during
   some steps of invocation (see **Important** section below);
@@ -1056,6 +1208,24 @@ Accepts:
 - `:instrument` - (optional) `[NilClass,Any]`
   - custom instrumentation data wich will be passed to the instrumenter's payload with :instrument key;
   - `nil` by default (no additional data);
+- `:log_sampling_enabled` - (optional) `[Boolean]`
+  - enables **log sampling**;
+  - pre-configured in `config[:log_sampling_enabled]`;
+- `:log_sampling_percent` - (optional) `[Integer]`
+  - **log sampling**:the percent of cases that should be logged;
+  - pre-configured in `config[:log_sampling_percent]`;
+- `:log_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]`
+  - **log sampling**: percent-based log sampler that decides should be RQL case logged or not;
+  - pre-configured in `config[:log_sampler]`;
+- `:instr_sampling_enabled` - (optional) `[Boolean]`
+  - enables **instrumentaion sampling**;
+  - pre-configured in `config[:instr_sampling_enabled]`;
+- `instr_sampling_percent` - (optional) `[Integer]`
+  - the percent of cases that should be instrumented;
+  - pre-configured in `config[:instr_sampling_percent]`;
+- `instr_sampler` - (optional) `[#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]`
+  - percent-based log sampler that decides should be RQL case instrumented or not;
+  - pre-configured in `config[:instr_sampler]`;
 
 Returns: `{ ok: true, processed_queues: Set<String> }` returns the list of processed lock queues;
 
@@ -1087,7 +1257,7 @@ rql.clear_dead_requests(dead_ttl: 60 * 60 * 1000) # 1 hour in milliseconds
   - by default behavior (`:wait_for_lock`) your lock obtaining process will work in a classic way (limits, retries, etc);
   - `:work_through`, `:extendable_work_through` works with limits too (timeouts, delays, etc), but the decision of
     "is your lock are obtained or not" is made as you work with **reentrant locks** (your process continues to use the lock without/with
-    lock's TTL accordingly);
+    lock's TTL extension accordingly);
   - for current implementation details check:
     - [Configuration](#configuration) documentation: see `config.default_conflict_strategy` config docs;
     - [#lock](#lock---obtain-a-lock) method documentation: see `conflict_strategy` attribute docs and the method result data;
@@ -1264,8 +1434,6 @@ Detalized event semantics and payload structure:
   - support for `Dragonfly` database backend (https://github.com/dragonflydb/dragonfly) (https://www.dragonflydb.io/);
 - **Minor**:
   - Semantic error objects for unexpected Redis errors;
-  - change all `::Process.clock_gettime(::Process::CLOCK_MONOTONIC)` milliseconds-related invocations to
-    `::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)` in order to reduce time-related math operations count;
   - **Experimental feature**: (non-`timed` locks): per-ruby-block-holding-the-lock sidecar `Ractor` and `in progress queue` in RedisDB that will extend
     the acquired lock for long-running blocks of code (that invoked "under" the lock
     whose ttl may expire before the block execution completes). It makes sense for non-`timed` locks *only*;

data/lib/redis_queued_locks/acquier/acquire_lock/try_to_lock.rb

@@ -28,11 +28,13 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
   # @param fail_fast [Boolean]
   # @param conflict_strategy [Symbol]
   # @param meta [NilClass,Hash<String|Symbol,Any>]
+  # @param log_sampled [Boolean]
+  # @param instr_sampled [Boolean]
   # @return [Hash<Symbol,Any>] Format: { ok: true/false, result: Symbol|Hash<Symbol,Any> }
   #
   # @api private
   # @since 1.0.0
-  # @version 1.3.0
+  # @version 1.6.0
   # rubocop:disable Metrics/MethodLength
   def try_to_lock(
     redis,
@@ -46,14 +48,16 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
     queue_ttl,
     fail_fast,
     conflict_strategy,
-    meta
+    meta,
+    log_sampled,
+    instr_sampled
   )
     # Step X: intermediate invocation results
     inter_result = nil
     timestamp = nil
     spc_processed_timestamp = nil
 
-    if log_lock_try
+    if log_sampled && log_lock_try
       run_non_critical do
         logger.debug do
           "[redis_queued_locks.try_lock.start] " \
@@ -66,7 +70,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
 
     # Step X: start to work with lock acquiring
     result = redis.with do |rconn|
-      if log_lock_try
+      if log_sampled && log_lock_try
         run_non_critical do
           logger.debug do
             "[redis_queued_locks.try_lock.rconn_fetched] " \
@@ -88,7 +92,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
 
         # SP-Conflict Step X1: calculate the current deadlock status
         if current_lock_obtainer != nil && acquier_id == current_lock_obtainer
-          if log_lock_try
+          if log_sampled && log_lock_try
             run_non_critical do
               logger.debug do
                 "[redis_queued_locks.try_lock.same_process_conflict_detected] " \
@@ -124,7 +128,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           end
           # rubocop:enable Lint/DuplicateBranch
 
-          if log_lock_try
+          if log_sampled && log_lock_try
             run_non_critical do
               logger.debug do
                 "[redis_queued_locks.try_lock.same_process_conflict_analyzed] " \
@@ -172,7 +176,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           )
           inter_result = :extendable_conflict_work_through
 
-          if log_lock_try
+          if log_sampled && log_lock_try
             run_non_critical do
               logger.debug do
                 "[redis_queued_locks.try_lock.reentrant_lock__extend_and_work_through] " \
@@ -205,7 +209,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
             'l_spc_ts', (spc_processed_timestamp = Time.now.to_f)
           )
 
-          if log_lock_try
+          if log_sampled && log_lock_try
             run_non_critical do
               logger.debug do
                 "[redis_queued_locks.try_lock.reentrant_lock__work_through] " \
@@ -222,7 +226,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           inter_result = :conflict_dead_lock
           spc_processed_timestamp = Time.now.to_f
 
-          if log_lock_try
+          if log_sampled && log_lock_try
             logger.debug do
               "[redis_queued_locks.try_lock.single_process_lock_conflict__dead_lock] " \
               "lock_key => '#{lock_key}' " \
@@ -242,7 +246,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           # Step 1: add an acquier to the lock acquirement queue
           rconn.call('ZADD', lock_key_queue, 'NX', acquier_position, acquier_id)
 
-          if log_lock_try
+          if log_sampled && log_lock_try
             run_non_critical do
               logger.debug do
                 "[redis_queued_locks.try_lock.acq_added_to_queue] " \
@@ -261,7 +265,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
             RedisQueuedLocks::Resource.acquier_dead_score(queue_ttl)
           )
 
-          if log_lock_try
+          if log_sampled && log_lock_try
             run_non_critical do
               logger.debug do
                 "[redis_queued_locks.try_lock.remove_expired_acqs] " \
@@ -275,7 +279,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           # Step 3: get the actual acquier waiting in the queue
           waiting_acquier = Array(rconn.call('ZRANGE', lock_key_queue, '0', '0')).first
 
-          if log_lock_try
+          if log_sampled && log_lock_try
             run_non_critical do
               logger.debug do
                 "[redis_queued_locks.try_lock.get_first_from_queue] " \
@@ -290,7 +294,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           # Step PRE-4.x: check if the request time limit is reached
           #   (when the current try self-removes itself from queue (queue ttl has come))
           if waiting_acquier == nil
-            if log_lock_try
+            if log_sampled && log_lock_try
               run_non_critical do
                 logger.debug do
                   "[redis_queued_locks.try_lock.exit__queue_ttl_reached] " \
@@ -306,7 +310,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
           elsif waiting_acquier != acquier_id
             # Step ROLLBACK 1.1: our time hasn't come yet. retry!
 
-            if log_lock_try
+            if log_sampled && log_lock_try
               run_non_critical do
                 logger.debug do
                   "[redis_queued_locks.try_lock.exit__no_first] " \
@@ -329,7 +333,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
             if locked_by_acquier
               # Step ROLLBACK 2: required lock is stil acquired. retry!
 
-              if log_lock_try
+              if log_sampled && log_lock_try
                 run_non_critical do
                   logger.debug do
                     "[redis_queued_locks.try_lock.exit__lock_still_obtained] " \
@@ -363,7 +367,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
               # Step 6.3: set the lock expiration time in order to prevent "infinite locks"
               transact.call('PEXPIRE', lock_key, ttl) # NOTE: in milliseconds
 
-              if log_lock_try
+              if log_sampled && log_lock_try
                 run_non_critical do
                   logger.debug do
                     "[redis_queued_locks.try_lock.obtain__free_to_acquire] " \
@@ -482,12 +486,23 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
   # @param lock_key_queue [String]
   # @param queue_ttl [Integer]
   # @param acquier_id [String]
+  # @param log_sampled [Boolean]
+  # @param instr_sampled [Boolean]
   # @return [Hash<Symbol,Any>] Format: { ok: true/false, result: Any }
   #
   # @api private
   # @since 1.0.0
-  # @version 1.3.0
-  def dequeue_from_lock_queue(redis, logger, lock_key, lock_key_queue, queue_ttl, acquier_id)
+  # @version 1.6.0
+  def dequeue_from_lock_queue(
+    redis,
+    logger,
+    lock_key,
+    lock_key_queue,
+    queue_ttl,
+    acquier_id,
+    log_sampled,
+    instr_sampled
+  )
     result = redis.call('ZREM', lock_key_queue, acquier_id)
 
     run_non_critical do
@@ -497,7 +512,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::TryToLock
         "queue_ttl => '#{queue_ttl}' " \
         "acq_id => '#{acquier_id}'"
       end
-    end
+    end if log_sampled
 
     RedisQueuedLocks::Data[ok: true, result: result]
   end

data/lib/redis_queued_locks/acquier/acquire_lock/yield_expire.rb

@@ -24,6 +24,8 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
   # @param ttl [Integer,NilClass] Lock's time to live (in ms). Nil means "without timeout".
   # @param queue_ttl [Integer] Lock request lifetime.
   # @param block [Block] Custom logic that should be invoked unter the obtained lock.
+  # @param log_sampled [Boolean] Should the logic be logged or not.
+  # @param instr_sampled [Boolean] Should the logic be instrumented or not.
   # @param should_expire [Boolean] Should the lock be expired after the block invocation.
   # @param should_decrease [Boolean]
   #   - Should decrease the lock TTL after the lock invocation;
@@ -32,6 +34,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
   #
   # @api private
   # @since 1.3.0
+  # @version 1.6.0
   # rubocop:disable Metrics/MethodLength
   def yield_expire(
     redis,
@@ -42,6 +45,8 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
     ttl_shift,
     ttl,
     queue_ttl,
+    log_sampled,
+    instr_sampled,
     should_expire,
     should_decrease,
     &block
@@ -69,12 +74,14 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
           "queue_ttl => #{queue_ttl} " \
           "acq_id => '#{acquier_id}'"
         end
-      end
+      end if log_sampled
+
       redis.call('EXPIRE', lock_key, '0')
     elsif should_decrease
       finish_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
       spent_time = (finish_time - initial_time)
       decreased_ttl = ttl - spent_time - RedisQueuedLocks::Resource::REDIS_TIMESHIFT_ERROR
+
       if decreased_ttl > 0
         run_non_critical do
           logger.debug do
@@ -84,7 +91,8 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
             "queue_ttl => #{queue_ttl} " \
             "acq_id => '#{acquier_id}' " \
           end
-        end
+        end if log_sampled
+
         # NOTE:# NOTE: EVAL signature -> <lua script>, (number of keys), *(keys), *(arguments)
         redis.call('EVAL', DECREASE_LOCK_PTTL, 1, lock_key, decreased_ttl)
         # TODO: upload scripts to the redis