redis_queued_locks 1.20.0 → 1.22.0

data/lib/redis_queued_locks/client.rb

@@ -2,7 +2,7 @@
 
 # @api public
 # @since 1.0.0
-# @version 1.20.0
+# @version 1.22.0
 # rubocop:disable Metrics/ClassLength
 class RedisQueuedLocks::Client
   # @return [RedisClient]
@@ -43,7 +43,7 @@ class RedisQueuedLocks::Client
   # @version 1.13.0
   def initialize(redis_client, &configuration)
     @config = RedisQueuedLocks::Config.new(&configuration)
-    @uniq_identity = config['uniq_identifier'].call #: String
+    @uniq_identity = config['uniq_identifier'].call
     @redis_client = redis_client
     @swarm = RedisQueuedLocks::Swarm.new(self)
     @swarm.swarm! if config['swarm.auto_swarm']
@@ -79,6 +79,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.9.0
+  # @version 1.21.0
   def swarm_info(zombie_ttl: config['swarm.flush_zombies.zombie_ttl'])
     swarm.swarm_info(zombie_ttl:)
   end
@@ -107,6 +108,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.9.0
+  # @version 1.21.0
   def flush_zombies(
     zombie_ttl: config['swarm.flush_zombies.zombie_ttl'],
     lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size'],
@@ -121,6 +123,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.9.0
+  # @version 1.21.0
   def zombie_locks(
     zombie_ttl: config['swarm.flush_zombies.zombie_ttl'],
     lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size']
@@ -132,8 +135,9 @@ class RedisQueuedLocks::Client
   # @option lock_scan_size [Integer]
   # @return [Set<String>]
   #
-  # @api ppublic
+  # @api public
   # @since 1.9.0
+  # @version 1.21.0
   def zombie_acquirers(
     zombie_ttl: config['swarm.flush_zombies.zombie_ttl'],
     lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size']
@@ -146,6 +150,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.9.0
+  # @version 1.21.0
   def zombie_hosts(zombie_ttl: config['swarm.flush_zombies.zombie_ttl'])
     swarm.zombie_hosts(zombie_ttl:)
   end
@@ -159,7 +164,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.9.0
-  # @version 1.17.0
+  # @version 1.21.0
   def zombies_info(
     zombie_ttl: config['swarm.flush_zombies.zombie_ttl'],
     lock_scan_size: config['swarm.flush_zombies.zombie_lock_scan_size']
@@ -171,7 +176,9 @@ class RedisQueuedLocks::Client
   # @param lock_name [String]
   #   Lock name to be obtained.
   # @option ttl [Integer]
-  #   Lock's time to live (in milliseconds).
+  #   - Lock's time to live (in milliseconds);
+  #   - a positive Integer;
+  #   - pre-configured in `config['default_lock_ttl']`;
   # @option queue_ttl [Integer]
   #   Lifetime of the acuier's lock request. In seconds.
   # @option lock_index_grace_period [Integer]
@@ -183,7 +190,8 @@ class RedisQueuedLocks::Client
   #     mode: the lock index is maintained by all lock acquirements of the client);
   #   - pre-configured in `config['lock_index_grace_period']`;
   # @option timeout [Integer,NilClass]
-  #   Time period whe should try to acquire the lock (in seconds). Nil means "without timeout".
+  #   Time period whe should try to acquire the lock (in seconds). Nil means "without timeout"
+  #   (`0` is the same as `nil`).
   # @option timed [Boolean]
   #   Limit the invocation time period of the passed block of code by the lock's TTL.
   # @option retry_count [Integer,NilClass]
@@ -224,8 +232,9 @@ class RedisQueuedLocks::Client
   #   - `:queued` access strategy orders read and write lock requests in FIFO between modes
   #     (read lock request waits for earlier write lock requests, write lock request waits for
   #     earlier read and write lock requests) so writers are not starved by readers;
-  #   - `:random` access strategy ignores lock queues (a continuous flow of readers can starve
-  #     writers);
+  #   - `:random` access strategy: the lock request does not wait for earlier requests (no order
+  #     between modes: a continuous flow of readers can starve writers), but it is queued like any
+  #     lock request (`:queued` lock requests wait for it);
   #   - read lock specifics:
   #     - read lock is released (with a block of code) or expired (by `ttl`) independently
   #       of other read locks; `#unlock` releases all read locks and the write lock;
@@ -247,6 +256,24 @@ class RedisQueuedLocks::Client
   #       (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 priority [Integer,Symbol]
+  #   - The lock request priority: an Integer from `-100` (the lowest) to `100` (the highest),
+  #     `0` by default (`RedisQueuedLocks::Resource::MIN_LOCK_PRIORITY`..`MAX_LOCK_PRIORITY`),
+  #     or a priority name of `config['lock_priorities']` (`:lowest` (-100), `:low` (-50),
+  #     `:normal` (0), `:high` (50), `:highest` (100) by default; the application can define its
+  #     own names, `merge` keeps the default ones:
+  #     `config['lock_priorities'] = config['lock_priorities'].merge(payment: 90, email: -10)`);
+  #   - `:queued` access strategy: the lock request is placed in the lock request queue after all
+  #     requests of the same or higher priority and before all requests of the lower priority
+  #     (strict priority, FIFO inside the same priority; read and write lock requests too);
+  #   - `:random` access strategy: the lock request does not wait for its turn (it ignores the order
+  #     of the lock request queues and the priorities of other requests), but it is queued at the
+  #     position of its priority like a `:queued` one: `:queued` lock requests wait for it;
+  #   - the obtained lock is never taken away: the priority orders the waiting lock requests;
+  #   - positive priorities need all processes that share the lock on RQL versions with priorities
+  #     (older versions drop such lock requests as dead ones: the order is broken, the mutual
+  #     exclusion is not affected); `0` and negative priorities work with older versions too;
+  #   - pre-configured in `config['default_lock_priority']`;
   # @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;
@@ -283,8 +310,8 @@ class RedisQueuedLocks::Client
   #   - Custom instrumenter that will be invoked via #notify method with `event` and `payload` data;
   #   - See RedisQueuedLocks::Instrument::ActiveSupport for examples and implementation details;
   #   - See [Instrumentation](#instrumentation) section of docs;
-  #   - pre-configured in `config['isntrumenter']` with void notifier
-  #     (`RedisQueuedLocks::Instrumenter::VoidNotifier`);
+  #   - pre-configured in `config['instrumenter']` with void notifier
+  #     (`RedisQueuedLocks::Instrument::VoidNotifier`);
   # @option instrument [NilClass,Any]
   #   - Custom instrumentation data wich will be passed to the instrumenter's payload
   #     with :instrument key;
@@ -294,7 +321,7 @@ class RedisQueuedLocks::Client
   #   - works in tandem with <config['log_sampling_percent'] and <config['log_sampler']>;
   # @option log_sampling_percent [Integer]
   #   - the percent of cases that should be logged;
-  #   - take an effect when <config['log_sampling_enalbed']> is true;
+  #   - take an effect when <config['log_sampling_enabled']> 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;
@@ -315,7 +342,7 @@ class RedisQueuedLocks::Client
   #   - works in tandem with <config['instr_sampling_percent']> and <config['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;
+  #   - take an effect when <config['instr_sampling_enabled']> is true;
   #   - works in tandem with <config['instr_sampling_enabled']>
   #     and <config['instr_sampler']> configs;
   # @option instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
@@ -339,7 +366,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.20.0
+  # @version 1.22.0
   # rubocop:disable Metrics/MethodLength
   def lock(
     lock_name,
@@ -356,6 +383,7 @@ class RedisQueuedLocks::Client
     conflict_strategy: config['default_conflict_strategy'],
     read_write_mode: :write,
     access_strategy: config['default_access_strategy'],
+    priority: config['default_lock_priority'],
     identity: uniq_identity,
     meta: nil,
     detailed_acq_timeout_error: config['detailed_acq_timeout_error'],
@@ -396,6 +424,8 @@ class RedisQueuedLocks::Client
       conflict_strategy:,
       read_write_mode:,
       access_strategy:,
+      priority:,
+      lock_priorities: config['lock_priorities'],
       meta:,
       detailed_acq_timeout_error:,
       logger:,
@@ -415,10 +445,10 @@ class RedisQueuedLocks::Client
   # rubocop:enable Metrics/MethodLength
 
   # NOTE: Lock Series PoC
-  # rubocop:disable all
+  # rubocop:disable Metrics/MethodLength
   # @api public
   # @since 1.16.0
-  # @version 1.20.0
+  # @version 1.22.0
   def lock_series( # steep:ignore
     *lock_names,
     detailed_result: false,
@@ -435,6 +465,7 @@ class RedisQueuedLocks::Client
     conflict_strategy: config['default_conflict_strategy'],
     read_write_mode: :write,
     access_strategy: config['default_access_strategy'],
+    priority: config['default_lock_priority'],
     identity: uniq_identity,
     meta: nil,
     detailed_acq_timeout_error: config['detailed_acq_timeout_error'],
@@ -476,6 +507,8 @@ class RedisQueuedLocks::Client
       conflict_strategy:,
       read_write_mode:,
       access_strategy:,
+      priority:,
+      lock_priorities: config['lock_priorities'],
       meta:,
       detailed_acq_timeout_error:,
       logger:,
@@ -492,13 +525,13 @@ class RedisQueuedLocks::Client
       &block
     )
   end
-  # rubocop:enable all
+  # rubocop:enable Metrics/MethodLength
 
   # NOTE: Lock Series PoC
-  # rubocop:disable all
+  # rubocop:disable Metrics/MethodLength
   # @api public
   # @since 1.16.0
-  # @version 1.20.0
+  # @version 1.22.0
   def lock_series!( # steep:ignore
     *lock_names,
     detailed_result: false,
@@ -514,6 +547,7 @@ class RedisQueuedLocks::Client
     conflict_strategy: config['default_conflict_strategy'],
     read_write_mode: :write,
     access_strategy: config['default_access_strategy'],
+    priority: config['default_lock_priority'],
     identity: uniq_identity,
     meta: nil,
     detailed_acq_timeout_error: config['detailed_acq_timeout_error'],
@@ -547,6 +581,7 @@ class RedisQueuedLocks::Client
       conflict_strategy:,
       read_write_mode:,
       access_strategy:,
+      priority:,
       identity:,
       meta:,
       detailed_acq_timeout_error:,
@@ -565,12 +600,14 @@ class RedisQueuedLocks::Client
       &block
     )
   end
+  # rubocop:enable Metrics/MethodLength
 
   # @note See #lock method signature.
   #
+  # rubocop:disable Metrics/MethodLength
   # @api public
   # @since 1.0.0
-  # @version 1.20.0
+  # @version 1.22.0
   def lock!(
     lock_name,
     ttl: config['default_lock_ttl'],
@@ -585,6 +622,7 @@ class RedisQueuedLocks::Client
     conflict_strategy: config['default_conflict_strategy'],
     read_write_mode: :write,
     access_strategy: config['default_access_strategy'],
+    priority: config['default_lock_priority'],
     identity: uniq_identity,
     instrumenter: config['instrumenter'],
     meta: nil,
@@ -624,6 +662,7 @@ class RedisQueuedLocks::Client
       conflict_strategy:,
       read_write_mode:,
       access_strategy:,
+      priority:,
       log_sampling_enabled:,
       log_sampling_percent:,
       log_sampler:,
@@ -665,7 +704,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.20.0
+  # @version 1.21.0
   def unlock(
     lock_name,
     logger: config['logger'],
@@ -684,8 +723,9 @@ class RedisQueuedLocks::Client
       redis_client,
       lock_name,
       config['lock_index_enabled'],
-      instrumenter,
       logger,
+      instrumenter,
+      instrument,
       log_sampling_enabled,
       log_sampling_percent,
       log_sampler,
@@ -705,13 +745,15 @@ class RedisQueuedLocks::Client
   #
   # @param lock_name [String] The lock name whose read lock should be released.
   # @option acquirer_id [String,NilClass]
-  #   - The acquirer whose read lock should be released (`nil` by default);
-  #   - `nil` => the current acquirer is used (calculated from `identity:`, see `#current_acquirer_id`);
-  #   - can be extracted from the lock data (`#lock_info`, `#locks_info`, `#queue_info`, `#queues_info`);
+  #   - the acquirer whose read lock should be released (`nil` by default);
+  #   - `nil` => the current acquirer is used (calculated from `identity:`,
+  #     see `#current_acquirer_id`);
+  #   - can be extracted from the lock data (`#lock_info`, `#locks_info`, `#queue_info`,
+  #     `#queues_info`);
   # @option identity [String]
   #   Unique acquirer identity (the same as for `#lock`) that is used to calculate the current
-  #   acquirer id (see `#current_acquirer_id`). Ignored when `acquirer_id:` is passed: the acquirer id
-  #   already contains its own identity.
+  #   acquirer id (see `#current_acquirer_id`). Ignored when `acquirer_id:` is passed: the
+  #   acquirer id already contains its own identity.
   # @option logger [::Logger,#debug]
   # @option instrumenter [#notify]
   # @option instrument [NilClass,Any]
@@ -742,7 +784,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.18.0
-  # @version 1.19.0
+  # @version 1.21.0
   def unlock_read(
     lock_name,
     acquirer_id: nil,
@@ -763,8 +805,8 @@ class RedisQueuedLocks::Client
       redis_client,
       lock_name,
       acquirer_id || current_acquirer_id(identity:),
-      instrumenter,
       logger,
+      instrumenter,
       instrument,
       log_sampling_enabled,
       log_sampling_percent,
@@ -817,7 +859,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.18.0
+  # @version 1.22.0
   def queue_info(lock_name)
     RedisQueuedLocks::Acquirer::QueueInfo.queue_info(redis_client, lock_name)
   end
@@ -902,19 +944,14 @@ class RedisQueuedLocks::Client
     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
-  #   (2) set new ttl that is calculated as "current pttl + additional milliseconds"
-  # What can happen during these steps
-  # - lock is expired between commands or before the first command;
-  # - lock is expired before the second command;
-  # - lock is expired AND newly acquired by another process (so you will extend the
-  #   totally new lock with fresh PTTL);
+  # The write lock TTL is extended atomically by one Lua script (`PTTL` + `PEXPIRE` with
+  # "current pttl + additional milliseconds") without the lock owner check: when your lock is
+  # expired and newly obtained by another acquirer, the lock of that acquirer is extended.
   # Use it at your own risk and consider async nature when calling this method.
   #
   # @param lock_name [String]
-  # @param milliseconds [Integer] How many milliseconds should be added.
+  # @param milliseconds [Integer]
+  #   How many milliseconds should be added: a positive Integer.
   # @option read_write_mode [Symbol]
   #   - `:write` (default) - extends the write lock (the method description above);
   #   - `:read` - extends the read lock of the current acquirer only (an expired read lock or
@@ -944,7 +981,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.20.0
+  # @version 1.21.0
   def extend_lock_ttl(
     lock_name,
     milliseconds,
@@ -1008,7 +1045,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.20.0
+  # @version 1.21.0
   def clear_locks(
     batch_size: config['lock_release_batch_size'],
     logger: config['logger'],
@@ -1097,12 +1134,12 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.14.0
-  # @version 1.20.0
+  # @version 1.21.0
   def clear_locks_of(
     host_id:,
     acquirer_id:,
     lock_scan_size: config['clear_locks_of__lock_scan_size'],
-    queue_scan_size: config['clear_locks_of__queue_scan_size'], # steep:ingore
+    queue_scan_size: config['clear_locks_of__queue_scan_size'],
     logger: config['logger'],
     instrumenter: config['instrumenter'],
     instrument: nil,
@@ -1140,7 +1177,8 @@ class RedisQueuedLocks::Client
   # Release all locks of the current acquirer/host and
   # remove the current acquirer/host from all queues;
   #
-  # @option batch_size [Integer]
+  # @option lock_scan_size [Integer]
+  # @option queue_scan_size [Integer]
   # @option logger [::Logger,#debug]
   # @option instrumenter [#notify] See `config['instrumenter']` docs for details.
   # @option instrument [NilClass,Any]
@@ -1159,9 +1197,10 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.14.0
+  # @version 1.21.0
   def clear_current_locks(
     lock_scan_size: config['clear_locks_of__lock_scan_size'],
-    queue_scan_size: config['clear_locks_of__queue_scan_size'], # steep:ingore
+    queue_scan_size: config['clear_locks_of__queue_scan_size'],
     logger: config['logger'],
     instrumenter: config['instrumenter'],
     instrument: nil,
@@ -1216,7 +1255,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.20.0
+  # @version 1.21.0
   def locks(scan_size: config['key_extraction_batch_size'], with_info: false)
     RedisQueuedLocks::Acquirer::Locks.locks(
       redis_client, scan_size:, with_info:, lock_index_enabled: config['lock_index_enabled']
@@ -1230,8 +1269,9 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  def locks_info(scan_size: config['key_extraction_batch_size']) # steep:ignore
-    locks(scan_size:, with_info: true)
+  # @version 1.21.0
+  def locks_info(scan_size: config['key_extraction_batch_size'])
+    locks(scan_size:, with_info: true) #: RedisQueuedLocks::Acquirer::Locks::locksInfo
   end
 
   # @option scan_size [Integer]
@@ -1253,7 +1293,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.20.0
+  # @version 1.22.0
   def queues(scan_size: config['key_extraction_batch_size'], with_info: false)
     RedisQueuedLocks::Acquirer::Queues.queues(
       redis_client, scan_size:, with_info:, lock_index_enabled: config['lock_index_enabled']
@@ -1267,8 +1307,9 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
+  # @version 1.22.0
   def queues_info(scan_size: config['key_extraction_batch_size'])
-    queues(scan_size:, with_info: true)
+    queues(scan_size:, with_info: true) #: RedisQueuedLocks::Acquirer::Queues::queuesInfo
   end
 
   # @option scan_size [Integer]
@@ -1279,7 +1320,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.20.0
+  # @version 1.21.0
   def keys(scan_size: config['key_extraction_batch_size'])
     RedisQueuedLocks::Acquirer::Keys.keys(
       redis_client, scan_size:, lock_index_enabled: config['lock_index_enabled']
@@ -1294,6 +1335,13 @@ class RedisQueuedLocks::Client
   #   - the batch of scanned keys for Redis'es SCAN command (or the number of locks in one batch of
   #     the lock index ZSCAN pass: the enabled `config['lock_index_enabled']`);
   #   - `config['lock_release_batch_size']` is used by default;
+  # @option by_priority [Boolean]
+  #   - read only the first lock request of each priority in the lock queues instead of all lock
+  #     requests (the dead requests of a priority are found by its first lock request): the
+  #     transfer does not depend on the length of the lock queues, a batch of lock queues takes
+  #     one round trip per priority of its lock queue with the most priorities + 1 (instead of two
+  #     round trips): for long lock queues with few priorities;
+  #   - `false` by default (all lock requests are read);
   # @option logger [::Logger,#debug]
   # @option instrumenter [#notify]
   # @option instrument [NilClass,Any]
@@ -1310,10 +1358,11 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.20.0
+  # @version 1.22.0
   def clear_dead_requests(
     dead_ttl: config['dead_request_ttl'],
     scan_size: config['lock_release_batch_size'],
+    by_priority: false,
     logger: config['logger'],
     instrumenter: config['instrumenter'],
     instrument: nil,
@@ -1330,6 +1379,7 @@ class RedisQueuedLocks::Client
       redis_client,
       scan_size,
       dead_ttl,
+      by_priority,
       config['lock_index_enabled'],
       logger,
       instrumenter,
@@ -1346,8 +1396,8 @@ class RedisQueuedLocks::Client
   end
 
   # Adds the lock keys without the lock index entry (keys of older RQL versions, keys created while
-  # the lock index was disabled) to the lock index (`rql:index:locks`). Invoke it once after the lock
-  # index is enabled (`config['lock_index_enabled']`) on all your processes: lock-iterating
+  # the lock index was disabled) to the lock index (`rql:index:locks`). Invoke it once after the
+  # lock index is enabled (`config['lock_index_enabled']`) on all your processes: lock-iterating
   # operations (the swarm, `#locks`, `#queues`, `#keys`, `#clear_locks`, ...) find locks via
   # the lock index only.
   #   - works regardless of `config['lock_index_enabled']` (the lock index is not used and not
@@ -1365,21 +1415,55 @@ class RedisQueuedLocks::Client
   # @option lock_index_grace_period [Integer]
   #   - the lock index score margin over the key lifetime (in milliseconds);
   #   - `config['lock_index_grace_period']` is used by default;
+  # @option logger [::Logger,#debug]
+  # @option instrumenter [#notify]
+  # @option instrument [NilClass,Any]
+  # @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,Integer>>]
   #   Format: { ok: true, result: { idx_key_cnt: Integer } } (the number of indexed keys)
   #
   # @api public
   # @since 1.20.0
+  # @version 1.21.0
   def reindex_locks(
     scan_size: config['lock_release_batch_size'],
     queue_ttl: config['default_queue_ttl'],
-    lock_index_grace_period: config['lock_index_grace_period']
+    lock_index_grace_period: config['lock_index_grace_period'],
+    logger: config['logger'],
+    instrumenter: config['instrumenter'],
+    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
   )
     RedisQueuedLocks::Acquirer::ReindexLocks.reindex_locks(
       redis_client,
       scan_size,
       queue_ttl,
-      lock_index_grace_period
+      lock_index_grace_period,
+      logger,
+      instrumenter,
+      instrument,
+      log_sampling_enabled,
+      log_sampling_percent,
+      log_sampler,
+      log_sample_this,
+      instr_sampling_enabled,
+      instr_sampling_percent,
+      instr_sampler,
+      instr_sample_this
     )
   end
 end