redis_queued_locks 1.5.0 → 1.7.0

data/lib/redis_queued_locks/acquier/acquire_lock.rb

@@ -2,16 +2,20 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.7.0
 # rubocop:disable Metrics/ModuleLength
 # rubocop:disable Metrics/MethodLength
 # rubocop:disable Metrics/ClassLength
 # rubocop:disable Metrics/BlockNesting
 # rubocop:disable Style/IfInsideElse
 module RedisQueuedLocks::Acquier::AcquireLock
+  require_relative 'acquire_lock/log_visitor'
+  require_relative 'acquire_lock/instr_visitor'
   require_relative 'acquire_lock/delay_execution'
   require_relative 'acquire_lock/with_acq_timeout'
   require_relative 'acquire_lock/yield_expire'
   require_relative 'acquire_lock/try_to_lock'
+  require_relative 'acquire_lock/dequeue_from_lock_queue'
 
   # @since 1.0.0
   extend TryToLock
@@ -21,8 +25,8 @@ module RedisQueuedLocks::Acquier::AcquireLock
   extend YieldExpire
   # @since 1.0.0
   extend WithAcqTimeout
-  # @since 1.0.0
-  extend RedisQueuedLocks::Utilities
+  # @since 1.7.0
+  extend DequeueFromLockQueue
 
   class << self
     # @param redis [RedisClient]
@@ -86,20 +90,51 @@ module RedisQueuedLocks::Acquier::AcquireLock
     #     - `:extendable_work_through`;
     #     - `:wait_for_lock`;
     #     - `:dead_locking`;
+    # @option access_strategy [Symbol]
+    #   - The way in which the lock will be obtained;
+    #   - By default it uses `:queued` strategy;
+    #   - Supports following strategies:
+    #     - `:queued` (FIFO): the classic queued behavior (default), your lock will be
+    #       obitaned if you are first in queue and the required lock is free;
+    #     - `:random` (RANDOM): obtain a lock without checking the positions in the queue
+    #       (but with checking the limist, retries, timeouts and so on). if lock is
+    #       free to obtain - it will be obtained;
+    #   - pre-configured in `config[:default_access_strategy]`;
     # @option log_sampling_enabled [Boolean]
-    #   - The percent of cases that should be logged;
-    #   - Sampling algorithm is super simple and works via SecureRandom.rand method
-    #     on the base of "weight" algorithm;
-    #   - You can provide your own sampler via config[:log_sampler] config and :sampler option
-    #     (see `RedisQueuedLocks::Logging::Sampler` for examples);
-    #   - The spread of guaranteed percent is approximately +13% (rand method spread);
-    #   - Take an effect when <log_sampling_enabled> parameter has <true> value
-    #     (when log sampling is enabled);
+    #   - 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>;
     # @option log_sampling_percent [Integer]
-    #   - The percent of cases that should be logged;
-    #   - Take an effect when <log_sampling_enabled> parameter has <true> value
-    #     (when log sampling is enabled);
+    #   - 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;
     # @option log_sampler [#sampling_happened?,Module<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);
+    # @option instr_sampling_enabled [Boolean]
+    #   - 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>;
+    # @option instr_sampling_percent [Integer]
+    #   - 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;
+    # @option instr_sampler [#sampling_happened?,Module<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);
     # @param [Block]
     #   A block of code that should be executed after the successfully acquired lock.
     # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>,yield]
@@ -108,7 +143,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.4.0
+    # @version 1.7.0
     def acquire_lock(
       redis,
       lock_name,
@@ -132,9 +167,13 @@ module RedisQueuedLocks::Acquier::AcquireLock
       logger:,
       log_lock_try:,
       conflict_strategy:,
+      access_strategy:,
       log_sampling_enabled:,
       log_sampling_percent:,
       log_sampler:,
+      instr_sampling_enabled:,
+      instr_sampling_percent:,
+      instr_sampler:,
       &block
     )
       # Step 0: Prevent argument type incompatabilities
@@ -187,6 +226,11 @@ module RedisQueuedLocks::Acquier::AcquireLock
         log_sampling_percent,
         log_sampler
       )
+      instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
+        instr_sampling_enabled,
+        instr_sampling_percent,
+        instr_sampler
+      )
 
       # Step X: intermediate result observer
       acq_process = {
@@ -207,18 +251,16 @@ module RedisQueuedLocks::Acquier::AcquireLock
           lock_key_queue,
           queue_ttl,
           acquier_id,
-          log_sampled
+          access_strategy,
+          log_sampled,
+          instr_sampled
         )
       end
 
-      run_non_critical do
-        logger.debug do
-          "[redis_queued_locks.start_lock_obtaining] " \
-          "lock_key => '#{lock_key}' " \
-          "queue_ttl => #{queue_ttl} " \
-          "acq_id => '#{acquier_id}'"
-        end
-      end if log_sampled
+      LogVisitor.start_lock_obtaining(
+        logger, log_sampled,
+        lock_key, queue_ttl, acquier_id, access_strategy
+      )
 
       # Step 2: try to lock with timeout
       with_acq_timeout(timeout, lock_key, raise_errors, on_timeout: acq_dequeue) do
@@ -226,28 +268,21 @@ module RedisQueuedLocks::Acquier::AcquireLock
 
         # Step 2.1: cyclically try to obtain the lock
         while acq_process[:should_try]
-          run_non_critical do
-            logger.debug do
-              "[redis_queued_locks.start_try_to_lock_cycle] " \
-              "lock_key => '#{lock_key}' " \
-              "queue_ttl => #{queue_ttl} " \
-              "acq_id => '{#{acquier_id}'"
-            end
-          end if log_sampled
+
+          LogVisitor.start_try_to_lock_cycle(
+            logger, log_sampled,
+            lock_key, queue_ttl, acquier_id, access_strategy
+          )
 
           # Step 2.X: check the actual score: is it in queue ttl limit or not?
           if RedisQueuedLocks::Resource.dead_score_reached?(acquier_position, queue_ttl)
             # Step 2.X.X: dead score reached => re-queue the lock request with the new score;
             acquier_position = RedisQueuedLocks::Resource.calc_initial_acquier_position
 
-            run_non_critical do
-              logger.debug do
-                "[redis_queued_locks.dead_score_reached__reset_acquier_position] " \
-                "lock_key => '#{lock_key} " \
-                "queue_ttl => #{queue_ttl} " \
-                "acq_id => '#{acquier_id}'"
-              end
-            end if log_sampled
+            LogVisitor.dead_score_reached__reset_acquier_position(
+              logger, log_sampled,
+              lock_key, queue_ttl, acquier_id, access_strategy
+            )
           end
 
           try_to_lock(
@@ -262,8 +297,10 @@ module RedisQueuedLocks::Acquier::AcquireLock
             queue_ttl,
             fail_fast,
             conflict_strategy,
+            access_strategy,
             meta,
-            log_sampled
+            log_sampled,
+            instr_sampled
           ) => { ok:, result: }
 
           acq_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
@@ -278,72 +315,38 @@ module RedisQueuedLocks::Acquier::AcquireLock
             # Step X: (instrumentation)
             if acq_process[:result][:process] == :extendable_conflict_work_through
               # instrumetnation: (reentrant lock with ttl extension)
-              run_non_critical do
-                logger.debug do
-                  "[redis_queued_locks.extendable_reentrant_lock_obtained] " \
-                  "lock_key => '#{result[:lock_key]}' " \
-                  "queue_ttl => #{queue_ttl} " \
-                  "acq_id => '#{acquier_id}' " \
-                  "acq_time => #{acq_time} (ms)"
-                end
-              end if log_sampled
-
-              run_non_critical do
-                instrumenter.notify('redis_queued_locks.extendable_reentrant_lock_obtained', {
-                  lock_key: result[:lock_key],
-                  ttl: result[:ttl],
-                  acq_id: result[:acq_id],
-                  ts: result[:ts],
-                  acq_time: acq_time,
-                  instrument:
-                })
-              end
+              LogVisitor.extendable_reentrant_lock_obtained(
+                logger, log_sampled,
+                result[:lock_key], queue_ttl, acquier_id, acq_time, access_strategy
+              )
+              InstrVisitor.extendable_reentrant_lock_obtained(
+                instrumenter, instr_sampled,
+                result[:lock_key], result[:ttl], result[:acq_id], result[:ts], acq_time,
+                instrument
+              )
             elsif acq_process[:result][:process] == :conflict_work_through
               # instrumetnation: (reentrant lock without ttl extension)
-              run_non_critical do
-                logger.debug do
-                  "[redis_queued_locks.reentrant_lock_obtained] " \
-                  "lock_key => '#{result[:lock_key]}' " \
-                  "queue_ttl => #{queue_ttl} " \
-                  "acq_id => '#{acquier_id}' " \
-                  "acq_time => #{acq_time} (ms)"
-                end
-              end if log_sampled
-
-              run_non_critical do
-                instrumenter.notify('redis_queued_locks.reentrant_lock_obtained', {
-                  lock_key: result[:lock_key],
-                  ttl: result[:ttl],
-                  acq_id: result[:acq_id],
-                  ts: result[:ts],
-                  acq_time: acq_time,
-                  instrument:
-                })
-              end
+              LogVisitor.reentrant_lock_obtained(
+                logger, log_sampled,
+                result[:lock_key], queue_ttl, acquier_id, acq_time, access_strategy
+              )
+              InstrVisitor.reentrant_lock_obtained(
+                instrumenter, instr_sampled,
+                result[:lock_key], result[:ttl], result[:acq_id], result[:ts], acq_time,
+                instrument
+              )
             else
               # instrumentation: (classic lock obtain)
               # NOTE: classic is: acq_process[:result][:process] == :lock_obtaining
-              run_non_critical do
-                logger.debug do
-                  "[redis_queued_locks.lock_obtained] " \
-                  "lock_key => '#{result[:lock_key]}' " \
-                  "queue_ttl => #{queue_ttl} " \
-                  "acq_id => '#{acquier_id}' " \
-                  "acq_time => #{acq_time} (ms)"
-                end
-              end if log_sampled
-
-              # Step X (instrumentation): lock obtained
-              run_non_critical do
-                instrumenter.notify('redis_queued_locks.lock_obtained', {
-                  lock_key: result[:lock_key],
-                  ttl: result[:ttl],
-                  acq_id: result[:acq_id],
-                  ts: result[:ts],
-                  acq_time: acq_time,
-                  instrument:
-                })
-              end
+              LogVisitor.lock_obtained(
+                logger, log_sampled,
+                result[:lock_key], queue_ttl, acquier_id, acq_time, access_strategy
+              )
+              InstrVisitor.lock_obtained(
+                instrumenter, instr_sampled,
+                result[:lock_key], result[:ttl], result[:acq_id], result[:ts], acq_time,
+                instrument
+              )
             end
 
             # Step 2.1.a: successfully acquired => build the result
@@ -447,11 +450,13 @@ module RedisQueuedLocks::Acquier::AcquireLock
               logger,
               lock_key,
               acquier_id,
+              access_strategy,
               timed,
               ttl_shift,
               ttl,
               queue_ttl,
               log_sampled,
+              instr_sampled,
               should_expire, # NOTE: should expire the lock after the block execution
               should_decrease, # NOTE: should decrease the lock ttl in reentrant locks?
               &block
@@ -467,30 +472,30 @@ module RedisQueuedLocks::Acquier::AcquireLock
             if acq_process[:result][:process] == :extendable_conflict_work_through ||
                acq_process[:result][:process] == :conflict_work_through
               # Step X (instrumentation): reentrant_lock_hold_completes
-              run_non_critical do
-                instrumenter.notify('redis_queued_locks.reentrant_lock_hold_completes', {
-                  hold_time: acq_process[:hold_time],
-                  ttl: acq_process[:lock_info][:ttl],
-                  acq_id: acq_process[:lock_info][:acq_id],
-                  ts: acq_process[:lock_info][:ts],
-                  lock_key: acq_process[:lock_info][:lock_key],
-                  acq_time: acq_process[:acq_time],
-                  instrument:
-                })
-              end
+              InstrVisitor.reentrant_lock_hold_completes(
+                instrumenter,
+                instr_sampled,
+                acq_process[:lock_info][:lock_key],
+                acq_process[:lock_info][:ttl],
+                acq_process[:lock_info][:acq_id],
+                acq_process[:lock_info][:ts],
+                acq_process[:acq_time],
+                acq_process[:hold_time],
+                instrument
+              )
             else
               # Step X (instrumentation): lock_hold_and_release
-              run_non_critical do
-                instrumenter.notify('redis_queued_locks.lock_hold_and_release', {
-                  hold_time: acq_process[:hold_time],
-                  ttl: acq_process[:lock_info][:ttl],
-                  acq_id: acq_process[:lock_info][:acq_id],
-                  ts: acq_process[:lock_info][:ts],
-                  lock_key: acq_process[:lock_info][:lock_key],
-                  acq_time: acq_process[:acq_time],
-                  instrument:
-                })
-              end
+              InstrVisitor.lock_hold_and_release(
+                instrumenter,
+                instr_sampled,
+                acq_process[:lock_info][:lock_key],
+                acq_process[:lock_info][:ttl],
+                acq_process[:lock_info][:acq_id],
+                acq_process[:lock_info][:ts],
+                acq_process[:lock_info][:lock_key],
+                acq_process[:acq_time],
+                instrument
+              )
             end
           end
         else

data/lib/redis_queued_locks/acquier/clear_dead_requests.rb

@@ -13,10 +13,14 @@ module RedisQueuedLocks::Acquier::ClearDeadRequests
     # @param log_sampling_enabled [Boolean]
     # @param log_sampling_percent [Integer]
     # @param log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
+    # @param instr_sampling_enabled [Boolean]
+    # @param instr_sampling_percent [Integer]
+    # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
     # @return [Hash<Symbol,Boolean|Hash<Symbol,Set<String>>>]
     #
     # @api private
     # @since 1.0.0
+    # @version 1.6.0
     def clear_dead_requests(
       redis_client,
       scan_size,
@@ -26,7 +30,10 @@ module RedisQueuedLocks::Acquier::ClearDeadRequests
       instrument,
       log_sampling_enabled,
       log_sampling_percent,
-      log_sampler
+      log_sampler,
+      instr_sampling_enabled,
+      instr_sampling_percent,
+      instr_sampler
     )
       dead_score = RedisQueuedLocks::Resource.acquier_dead_score(dead_ttl / 1_000.0)
 

data/lib/redis_queued_locks/acquier/extend_lock_ttl.rb

@@ -17,22 +17,32 @@ module RedisQueuedLocks::Acquier::ExtendLockTTL
     # @param lock_name [String]
     # @param milliseconds [Integer]
     # @param logger [::Logger,#debug]
+    # @param instrumenter [#notify]
+    # @param instrument [NilClass,Any]
     # @param log_sampling_enabled [Boolean]
     # @param log_sampling_percent [Integer]
     # @param log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
+    # @param instr_sampling_enabled [Boolean]
+    # @param instr_sampling_percent [Integer]
+    # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
     # @return [Hash<Symbol,Boolean|Symbol>]
     #
     # @api private
     # @since 1.0.0
-    # @version 1.5.0
+    # @version 1.6.0
     def extend_lock_ttl(
       redis_client,
       lock_name,
       milliseconds,
       logger,
+      instrumenter,
+      instrument,
       log_sampling_enabled,
       log_sampling_percent,
-      log_sampler
+      log_sampler,
+      instr_sampling_enabled,
+      instr_sampling_percent,
+      instr_sampler
     )
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
 

data/lib/redis_queued_locks/acquier/release_all_locks.rb

@@ -24,19 +24,46 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     #    - Custom instrumentation data wich will be passed to the instrumenter's payload
     #      with :instrument key;
     # @param log_sampling_enabled [Boolean]
-    #   - Enables <log sampling>: only the configured percent of cases will be logged;
-    #   - Works in tandem with <log_samplng_percent> option;
+    #   - 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>;
     # @param log_sampling_percent [Integer]
-    #   - The percent of cases that should be logged;
-    #   - Take an effect when <log_sampling_enabled> parameter has <true> value
-    #     (when log sampling is enabled);
+    #   - 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;
     # @param log_sampler [#sampling_happened?,Module<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);
+    # @param instr_sampling_enabled [Boolean]
+    #   - 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>;
+    # @param instr_sampling_percent [Integer]
+    #   - 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;
+    # @param instr_sampler [#sampling_happened?,Module<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);
     # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>]
     #   Format: { ok: true, result: Hash<Symbol,Numeric> }
     #
     # @api private
     # @since 1.0.0
-    # @version 1.5.0
+    # @version 1.6.0
     def release_all_locks(
       redis,
       batch_size,
@@ -45,7 +72,10 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
       instrument,
       log_sampling_enabled,
       log_sampling_percent,
-      log_sampler
+      log_sampler,
+      instr_sampling_enabled,
+      instr_sampling_percent,
+      instr_sampler
     )
       rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
       fully_release_all_locks(redis, batch_size) => { ok:, result: }
@@ -53,13 +83,19 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
       rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
       rel_time = ((rel_end_time - rel_start_time) / 1_000).ceil(2)
 
+      instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
+        instr_sampling_enabled,
+        instr_sampling_percent,
+        instr_sampler
+      )
+
       run_non_critical do
         instrumenter.notify('redis_queued_locks.explicit_all_locks_release', {
           at: time_at,
           rel_time: rel_time,
           rel_key_cnt: result[:rel_key_cnt]
         })
-      end
+      end if instr_sampled
 
       RedisQueuedLocks::Data[
         ok: true,

data/lib/redis_queued_locks/acquier/release_lock.rb

@@ -24,25 +24,47 @@ module RedisQueuedLocks::Acquier::ReleaseLock
     #   - Logger object used from `configuration` layer (see config[:logger]);
     #   - See RedisQueuedLocks::Logging::VoidLogger for example;
     # @param log_sampling_enabled [Boolean]
-    #   - The percent of cases that should be logged;
-    #   - Sampling algorithm is super simple and works via SecureRandom.rand method
-    #     on the base of "weight" algorithm;
-    #   - You can provide your own sampler via config[:log_sampler] config and :sampler option
-    #     (see `RedisQueuedLocks::Logging::Sampler` for examples);
-    #   - The spread of guaranteed percent is approximately +13% (rand method spread);
-    #   - Take an effect when <log_sampling_enabled> parameter has <true> value
-    #     (when log sampling is enabled);
+    #   - 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>;
     # @param log_sampling_percent [Integer]
-    #   - The percent of cases that should be logged;
-    #   - Take an effect when <log_sampling_enabled> parameter has <true> value
-    #     (when log sampling is enabled);
+    #   - 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;
     # @param log_sampler [#sampling_happened?,Module<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);
+    # @param instr_sampling_enabled [Boolean]
+    #   - 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>;
+    # @param instr_sampling_percent [Integer]
+    #   - 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;
+    # @param instr_sampler [#sampling_happened?,Module<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);
     # @return [RedisQueuedLocks::Data,Hash<Symbol,Boolean<Hash<Symbol,Numeric|String|Symbol>>]
     #   Format: { ok: true/false, result: Hash<Symbol,Numeric|String|Symbol> }
     #
     # @api private
     # @since 1.0.0
-    # @version 1.5.0
+    # @version 1.6.0
+    # rubocop:disable Metrics/MethodLength
     def release_lock(
       redis,
       lock_name,
@@ -50,7 +72,10 @@ module RedisQueuedLocks::Acquier::ReleaseLock
       logger,
       log_sampling_enabled,
       log_sampling_percent,
-      log_sampler
+      log_sampler,
+      instr_sampling_enabled,
+      instr_sampling_percent,
+      instr_sampler
     )
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
@@ -61,6 +86,12 @@ module RedisQueuedLocks::Acquier::ReleaseLock
       rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
       rel_time = ((rel_end_time - rel_start_time) / 1_000).ceil(2)
 
+      instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
+        instr_sampling_enabled,
+        instr_sampling_percent,
+        instr_sampler
+      )
+
       run_non_critical do
         instrumenter.notify('redis_queued_locks.explicit_lock_release', {
           lock_key: lock_key,
@@ -68,7 +99,7 @@ module RedisQueuedLocks::Acquier::ReleaseLock
           rel_time: rel_time,
           at: time_at
         })
-      end
+      end if instr_sampled
 
       RedisQueuedLocks::Data[
         ok: true,
@@ -81,6 +112,7 @@ module RedisQueuedLocks::Acquier::ReleaseLock
         }
       ]
     end
+    # rubocop:enable Metrics/MethodLength
 
     private