redis_queued_locks 1.8.0 → 1.9.0

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

@@ -19,6 +19,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
   # @param logger [::Logger,#debug] Logger object.
   # @param lock_key [String] Obtained lock key that should be expired.
   # @param acquier_id [String] Acquier identifier.
+  # @param host_id [String] Host identifier.
   # @param access_strategy [Symbol] Lock obtaining strategy.
   # @param timed [Boolean] Should the lock be wrapped by Timeout with with lock's ttl
   # @param ttl_shift [Float] Lock's TTL shifting. Should affect block's ttl. In millisecodns.
@@ -36,13 +37,14 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
   #
   # @api private
   # @since 1.3.0
-  # @version 1.8.0
+  # @version 1.9.0
   # rubocop:disable Metrics/MethodLength
   def yield_expire(
     redis,
     logger,
     lock_key,
     acquier_id,
+    host_id,
     access_strategy,
     timed,
     ttl_shift,
@@ -64,7 +66,7 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
       end
 
       if timed && ttl != nil
-        yield_with_timeout(timeout, lock_key, ttl, acquier_id, meta, &block)
+        yield_with_timeout(timeout, lock_key, ttl, acquier_id, host_id, meta, &block)
       else
         yield
       end
@@ -72,8 +74,8 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
   ensure
     if should_expire
       LogVisitor.expire_lock(
-        logger, log_sampled,
-        lock_key, queue_ttl, acquier_id, access_strategy
+        logger, log_sampled, lock_key,
+        queue_ttl, acquier_id, host_id, access_strategy
       )
       redis.call('EXPIRE', lock_key, '0')
     elsif should_decrease
@@ -83,8 +85,8 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
 
       if decreased_ttl > 0
         LogVisitor.decrease_lock(
-          logger, log_sampled,
-          lock_key, decreased_ttl, queue_ttl, acquier_id, access_strategy
+          logger, log_sampled, lock_key,
+          decreased_ttl, queue_ttl, acquier_id, host_id, access_strategy
         )
         # NOTE:# NOTE: EVAL signature -> <lua script>, (number of keys), *(keys), *(arguments)
         redis.call('EVAL', DECREASE_LOCK_PTTL, 1, lock_key, decreased_ttl)
@@ -100,14 +102,15 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
   # @parma lock_key [String]
   # @param lock_ttl [Integer,NilClass]
   # @param acquier_id [String]
+  # @param host_id [String]
   # @param meta [NilClass,Hash<Symbol|String,Any>]
   # @param block [Blcok]
   # @return [Any]
   #
   # @api private
   # @since 1.3.0
-  # @version 1.8.0
-  def yield_with_timeout(timeout, lock_key, lock_ttl, acquier_id, meta, &block)
+  # @version 1.9.0
+  def yield_with_timeout(timeout, lock_key, lock_ttl, acquier_id, host_id, meta, &block)
     ::Timeout.timeout(timeout, &block)
   rescue ::Timeout::Error
     raise(
@@ -116,7 +119,8 @@ module RedisQueuedLocks::Acquier::AcquireLock::YieldExpire
       "(lock: \"#{lock_key}\", " \
       "ttl: #{lock_ttl}, " \
       "meta: #{meta ? meta.inspect : '<no-meta>'}, " \
-      "acq_id: \"#{acquier_id}\")"
+      "acq_id: \"#{acquier_id}\", " \
+      "hst_id: \"#{host_id}\")"
     )
   end
 end

data/lib/redis_queued_locks/acquier/acquire_lock.rb

@@ -121,6 +121,9 @@ module RedisQueuedLocks::Acquier::AcquireLock
     #   - 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;
@@ -139,6 +142,10 @@ module RedisQueuedLocks::Acquier::AcquireLock
     #   - 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]
     #   A block of code that should be executed after the successfully acquired lock.
     # @return [RedisQueuedLocks::Data,Hash<Symbol,Any>,yield]
@@ -147,7 +154,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.8.0
+    # @version 1.9.0
     def acquire_lock(
       redis,
       lock_name,
@@ -176,9 +183,11 @@ module RedisQueuedLocks::Acquier::AcquireLock
       log_sampling_enabled:,
       log_sampling_percent:,
       log_sampler:,
+      log_sample_this:,
       instr_sampling_enabled:,
       instr_sampling_percent:,
       instr_sampler:,
+      instr_sample_this:,
       &block
     )
       # Step 0: Prevent argument type incompatabilities
@@ -195,6 +204,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
       # Step 0.2: prevent :meta incompatabiltiies (structure)
       if meta.is_a?(::Hash) && (meta.any? do |key, _value|
         key == 'acq_id' ||
+        key == 'hst_id' ||
         key == 'ts' ||
         key == 'ini_ttl' ||
         key == 'lock_key' ||
@@ -208,7 +218,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
         raise(
           RedisQueuedLocks::ArgumentError,
           '`:meta` keys can not overlap reserved lock data keys ' \
-          '"acq_id", "ts", "ini_ttl", "lock_key", "rem_ttl", "spc_cnt", ' \
+          '"acq_id", "hst_id", "ts", "ini_ttl", "lock_key", "rem_ttl", "spc_cnt", ' \
           '"spc_ext_ttl", "l_spc_ext_ini_ttl", "l_spc_ext_ts", "l_spc_ts"'
         )
       end
@@ -221,6 +231,12 @@ module RedisQueuedLocks::Acquier::AcquireLock
         ractor_id,
         identity
       )
+      host_id = RedisQueuedLocks::Resource.host_identifier(
+        process_id,
+        thread_id,
+        ractor_id,
+        identity
+      )
       lock_ttl = ttl
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
@@ -228,11 +244,13 @@ module RedisQueuedLocks::Acquier::AcquireLock
 
       log_sampled = RedisQueuedLocks::Logging.should_log?(
         log_sampling_enabled,
+        log_sample_this,
         log_sampling_percent,
         log_sampler
       )
       instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
         instr_sampling_enabled,
+        instr_sample_this,
         instr_sampling_percent,
         instr_sampler
       )
@@ -257,6 +275,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
           lock_key_queue,
           queue_ttl,
           acquier_id,
+          host_id,
           access_strategy,
           log_sampled,
           instr_sampled
@@ -264,8 +283,8 @@ module RedisQueuedLocks::Acquier::AcquireLock
       end
 
       LogVisitor.start_lock_obtaining(
-        logger, log_sampled,
-        lock_key, queue_ttl, acquier_id, access_strategy
+        logger, log_sampled, lock_key,
+        queue_ttl, acquier_id, host_id, access_strategy
       )
 
       # Step 2: try to lock with timeout
@@ -284,8 +303,8 @@ module RedisQueuedLocks::Acquier::AcquireLock
         while acq_process[:should_try]
 
           LogVisitor.start_try_to_lock_cycle(
-            logger, log_sampled,
-            lock_key, queue_ttl, acquier_id, access_strategy
+            logger, log_sampled, lock_key,
+            queue_ttl, acquier_id, host_id, access_strategy
           )
 
           # Step 2.X: check the actual score: is it in queue ttl limit or not?
@@ -294,8 +313,8 @@ module RedisQueuedLocks::Acquier::AcquireLock
             acquier_position = RedisQueuedLocks::Resource.calc_initial_acquier_position
 
             LogVisitor.dead_score_reached__reset_acquier_position(
-              logger, log_sampled,
-              lock_key, queue_ttl, acquier_id, access_strategy
+              logger, log_sampled, lock_key,
+              queue_ttl, acquier_id, host_id, access_strategy
             )
           end
 
@@ -306,6 +325,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
             lock_key,
             lock_key_queue,
             acquier_id,
+            host_id,
             acquier_position,
             lock_ttl,
             queue_ttl,
@@ -330,35 +350,35 @@ module RedisQueuedLocks::Acquier::AcquireLock
             if acq_process[:result][:process] == :extendable_conflict_work_through
               # instrumetnation: (reentrant lock with ttl extension)
               LogVisitor.extendable_reentrant_lock_obtained(
-                logger, log_sampled,
-                result[:lock_key], queue_ttl, acquier_id, acq_time, access_strategy
+                logger, log_sampled, result[:lock_key],
+                queue_ttl, acquier_id, host_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,
+                instrumenter, instr_sampled, result[:lock_key],
+                result[:ttl], result[:acq_id], result[:hst_id], result[:ts], acq_time,
                 instrument
               )
             elsif acq_process[:result][:process] == :conflict_work_through
               # instrumetnation: (reentrant lock without ttl extension)
               LogVisitor.reentrant_lock_obtained(
-                logger, log_sampled,
-                result[:lock_key], queue_ttl, acquier_id, acq_time, access_strategy
+                logger, log_sampled, result[:lock_key],
+                queue_ttl, acquier_id, host_id, acq_time, access_strategy
               )
               InstrVisitor.reentrant_lock_obtained(
-                instrumenter, instr_sampled,
-                result[:lock_key], result[:ttl], result[:acq_id], result[:ts], acq_time,
+                instrumenter, instr_sampled, result[:lock_key],
+                result[:ttl], result[:acq_id], result[:hst_id], result[:ts], acq_time,
                 instrument
               )
             else
               # instrumentation: (classic lock obtain)
               # NOTE: classic is: acq_process[:result][:process] == :lock_obtaining
               LogVisitor.lock_obtained(
-                logger, log_sampled,
-                result[:lock_key], queue_ttl, acquier_id, acq_time, access_strategy
+                logger, log_sampled, result[:lock_key],
+                queue_ttl, acquier_id, host_id, acq_time, access_strategy
               )
               InstrVisitor.lock_obtained(
-                instrumenter, instr_sampled,
-                result[:lock_key], result[:ttl], result[:acq_id], result[:ts], acq_time,
+                instrumenter, instr_sampled, result[:lock_key],
+                result[:ttl], result[:acq_id], result[:hst_id], result[:ts], acq_time,
                 instrument
               )
             end
@@ -367,6 +387,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
             acq_process[:lock_info] = {
               lock_key: result[:lock_key],
               acq_id: result[:acq_id],
+              hst_id: result[:hst_id],
               ts: result[:ts],
               ttl: result[:ttl],
               process: result[:process]
@@ -464,6 +485,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
               logger,
               lock_key,
               acquier_id,
+              host_id,
               access_strategy,
               timed,
               ttl_shift,
@@ -493,6 +515,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
                 acq_process[:lock_info][:lock_key],
                 acq_process[:lock_info][:ttl],
                 acq_process[:lock_info][:acq_id],
+                acq_process[:lock_info][:hst_id],
                 acq_process[:lock_info][:ts],
                 acq_process[:acq_time],
                 acq_process[:hold_time],
@@ -506,6 +529,7 @@ module RedisQueuedLocks::Acquier::AcquireLock
                 acq_process[:lock_info][:lock_key],
                 acq_process[:lock_info][:ttl],
                 acq_process[:lock_info][:acq_id],
+                acq_process[:lock_info][:hst_id],
                 acq_process[:lock_info][:ts],
                 acq_process[:lock_info][:lock_key],
                 acq_process[:acq_time],

data/lib/redis_queued_locks/acquier/clear_dead_requests.rb

@@ -13,9 +13,11 @@ module RedisQueuedLocks::Acquier::ClearDeadRequests
     # @param log_sampling_enabled [Boolean]
     # @param log_sampling_percent [Integer]
     # @param log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
+    # @param log_sample_this [Boolean]
     # @param instr_sampling_enabled [Boolean]
     # @param instr_sampling_percent [Integer]
     # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
+    # @param instr_sample_this [Boolean]
     # @return [Hash<Symbol,Boolean|Hash<Symbol,Set<String>>>]
     #
     # @api private
@@ -31,9 +33,11 @@ module RedisQueuedLocks::Acquier::ClearDeadRequests
       log_sampling_enabled,
       log_sampling_percent,
       log_sampler,
+      log_sample_this,
       instr_sampling_enabled,
       instr_sampling_percent,
-      instr_sampler
+      instr_sampler,
+      instr_sample_this
     )
       dead_score = RedisQueuedLocks::Resource.acquier_dead_score(dead_ttl / 1_000.0)
 

data/lib/redis_queued_locks/acquier/extend_lock_ttl.rb

@@ -22,9 +22,11 @@ module RedisQueuedLocks::Acquier::ExtendLockTTL
     # @param log_sampling_enabled [Boolean]
     # @param log_sampling_percent [Integer]
     # @param log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
+    # @param log_sample_this [Boolean]
     # @param instr_sampling_enabled [Boolean]
     # @param instr_sampling_percent [Integer]
     # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
+    # @param instr_sample_this [Boolean]
     # @return [Hash<Symbol,Boolean|Symbol>]
     #
     # @api private
@@ -40,9 +42,11 @@ module RedisQueuedLocks::Acquier::ExtendLockTTL
       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)
 

data/lib/redis_queued_locks/acquier/lock_info.rb

@@ -10,7 +10,8 @@ module RedisQueuedLocks::Acquier::LockInfo
     #   - `nil` is returned when lock key does not exist or expired;
     #   - result format: {
     #     'lock_key' => "rql:lock:your_lockname", # acquired lock key
-    #     'acq_id' => "rql:acq:process_id/thread_id", # lock acquier identifier
+    #     'acq_id' => "rql:acq:123/456/789/987/uniqstring", # lock acquier identifier
+    #     'hst_id' => "rql:hst:123/456/987/uniqstring", # lock host identifier
     #     'ts' => 123456789.2649841, # <locked at> time stamp (epoch, seconds.microseconds)
     #     'ini_ttl' => 123456789, # initial lock key ttl (milliseconds)
     #     'rem_ttl' => 123456789, # remaining lock key ttl (milliseconds)
@@ -24,7 +25,7 @@ module RedisQueuedLocks::Acquier::LockInfo
     #
     # @api private
     # @since 1.0.0
-    # @version 1.3.0
+    # @version 1.9.0
     # rubocop:disable Metrics/MethodLength
     def lock_info(redis_client, lock_name)
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
@@ -55,7 +56,7 @@ module RedisQueuedLocks::Acquier::LockInfo
             lock_data['lock_key'] = lock_key
             lock_data['ts'] = Float(lock_data['ts'])
             lock_data['ini_ttl'] = Integer(lock_data['ini_ttl'])
-            lock_data['rem_ttl'] = ((pttl_cmd_res == -1) ? Infinity : pttl_cmd_res)
+            lock_data['rem_ttl'] = ((pttl_cmd_res == -1) ? Float::INFINITY : pttl_cmd_res)
             lock_data['spc_cnt'] = Integer(lock_data['spc_cnt']) if lock_data['spc_cnt']
             lock_data['l_spc_ts'] = Float(lock_data['l_spc_ts']) if lock_data['l_spc_ts']
             lock_data['spc_ext_ttl'] = Integer(lock_data['spc_ext_ttl']) if lock_data['spc_ext_ttl']

data/lib/redis_queued_locks/acquier/locks.rb

@@ -45,7 +45,7 @@ module RedisQueuedLocks::Acquier::Locks
     #
     # @api private
     # @since 1.0.0
-    # @version 1.3.0
+    # @version 1.9.0
     # rubocop:disable Metrics/MethodLength
     def extract_locks_info(redis_client, lock_keys)
       # TODO: refactor with RedisQueuedLocks::Acquier::LockInfo
@@ -72,7 +72,7 @@ module RedisQueuedLocks::Acquier::Locks
                 hget_cmd_res.tap do |lock_data|
                   lock_data['ts'] = Float(lock_data['ts'])
                   lock_data['ini_ttl'] = Integer(lock_data['ini_ttl'])
-                  lock_data['rem_ttl'] = ((pttl_cmd_res == -1) ? Infinity : pttl_cmd_res)
+                  lock_data['rem_ttl'] = ((pttl_cmd_res == -1) ? Float::INFINITY : pttl_cmd_res)
                   lock_data['spc_cnt'] = Integer(lock_data['spc_cnt']) if lock_data['spc_cnt']
                   lock_data['l_spc_ts'] = Float(lock_data['l_spc_ts']) if lock_data['l_spc_ts']
                   lock_data['spc_ext_ttl'] =

data/lib/redis_queued_locks/acquier/queue_info.rb

@@ -17,8 +17,8 @@ module RedisQueuedLocks::Acquier::QueueInfo
     #   - result format: {
     #     "lock_queue" => "rql:lock_queue:your_lock_name", # lock queue key in redis,
     #     queue: [
-    #       { "acq_id" => "rql:acq:process_id/thread_id", "score" => 123 },
-    #       { "acq_id" => "rql:acq:process_id/thread_id", "score" => 456 },
+    #       { "acq_id" => "rql:acq:123/456/789/987/identity", "score" => 123 },
+    #       { "acq_id" => "rql:acq:123/686/789/987/identity", "score" => 456 },
     #     ] # ordered set (by score) with information about an acquier and their position in queue
     #   }
     #

data/lib/redis_queued_locks/acquier/release_all_locks.rb

@@ -40,6 +40,9 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
     #   - 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::ReleaseAllLocks
     #   - 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,Any>]
     #   Format: { ok: true, result: Hash<Symbol,Numeric> }
     #
@@ -73,18 +80,21 @@ module RedisQueuedLocks::Acquier::ReleaseAllLocks
       log_sampling_enabled,
       log_sampling_percent,
       log_sampler,
+      log_sample_this,
       instr_sampling_enabled,
       instr_sampling_percent,
-      instr_sampler
+      instr_sampler,
+      instr_sample_this
     )
       rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
       fully_release_all_locks(redis, batch_size) => { 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/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
       )