redis_queued_locks 1.13.0 → 1.14.0

data/Rakefile

@@ -2,7 +2,7 @@
 
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
-require "steep/rake_task"
+require 'steep/rake_task'
 require 'rubocop'
 require 'rubocop/rake_task'
 require 'rubocop-performance'

data/Steepfile

@@ -9,7 +9,6 @@ target :lib do
   library 'timeout'
   library 'securerandom'
   library 'logger'
-  library 'objspace'
   library 'monitor'
 
   configure_code_diagnostics(Steep::Diagnostic::Ruby.strict)

data/lib/redis_queued_locks/acquirer/acquire_lock.rb

@@ -17,6 +17,8 @@ module RedisQueuedLocks::Acquirer::AcquireLock
   require_relative 'acquire_lock/try_to_lock'
   require_relative 'acquire_lock/dequeue_from_lock_queue'
 
+  # @since 1.14.0
+  extend RedisQueuedLocks::Utilities
   # @since 1.0.0
   extend TryToLock
   # @since 1.0.0
@@ -157,7 +159,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.13.0
+    # @version 1.14.0
     def acquire_lock(
       redis,
       lock_name,
@@ -309,7 +311,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
         detailed_acq_timeout_error,
         on_timeout: acq_dequeue
       ) do
-        acq_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+        acq_start_time = clock_gettime
 
         # Step 2.1: cyclically try to obtain the lock
         while acq_process[:should_try]
@@ -358,7 +360,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
           # @type var ok: bool
           # @type var result: Symbol|Hash[Symbol,untyped]
 
-          acq_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+          acq_end_time = clock_gettime
           acq_time = ((acq_end_time - acq_start_time) / 1_000.0).ceil(2)
 
           # Step X: save the intermediate results to the result observer
@@ -491,7 +493,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
         # Step 3.a: acquired successfully => run logic or return the result of acquirement
         if block_given?
           begin
-            yield_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+            yield_time = clock_gettime
 
             ttl_shift = (
               (yield_time - acq_process[:acq_end_time]) / 1_000.0 -
@@ -524,9 +526,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
               &block
             )
           ensure
-            acq_process[:rel_time] = ::Process.clock_gettime(
-              ::Process::CLOCK_MONOTONIC, :microsecond
-            )
+            acq_process[:rel_time] = clock_gettime
             acq_process[:hold_time] = (
               (acq_process[:rel_time] - acq_process[:acq_end_time]) / 1_000.0
             ).ceil(2)

data/lib/redis_queued_locks/acquirer/release_all_locks.rb

@@ -71,7 +71,7 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
     #
     # @api private
     # @since 1.0.0
-    # @version 1.6.0
+    # @version 1.14.0
     def release_all_locks(
       redis,
       batch_size,
@@ -87,14 +87,14 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
       instr_sampler,
       instr_sample_this
     )
-      rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+      rel_start_time = clock_gettime
       fully_release_all_locks(redis, batch_size) => { ok:, result: } # steep:ignore
 
       # @type var ok: bool
       # @type var result: Hash[Symbol,Integer]
 
       time_at = Time.now.to_f
-      rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+      rel_end_time = clock_gettime
       rel_time = ((rel_end_time - rel_start_time) / 1_000.0).ceil(2)
 
       instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(

data/lib/redis_queued_locks/acquirer/release_lock.rb

@@ -71,7 +71,7 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.6.0
+    # @version 1.14.0
     # rubocop:disable Metrics/MethodLength
     def release_lock(
       redis,
@@ -90,14 +90,14 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
 
-      rel_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+      rel_start_time = clock_gettime
       fully_release_lock(redis, lock_key, lock_key_queue) => { ok:, result: } # steep:ignore
 
       # @type var ok: bool
       # @type var result: Hash[Symbol,Symbol]
 
       time_at = Time.now.to_f
-      rel_end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :microsecond)
+      rel_end_time = clock_gettime
       rel_time = ((rel_end_time - rel_start_time) / 1_000.0).ceil(2)
 
       instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(

data/lib/redis_queued_locks/acquirer/release_locks_of.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 1.14.0
+module RedisQueuedLocks::Acquirer::ReleaseLocksOf
+  # @since 1.14.0
+  extend RedisQueuedLocks::Utilities
+
+  class << self
+    # Release all queues and locks that belong to the given host and its associated acquirer.
+    #
+    # @param refused_host_id [String]
+    #   A host whose locks and queues should be released.
+    # @param refused_acquirer_id [String]
+    #   An acquirer (of the passed host) whose locks and queues should be released.
+    # @param redis [RedisClient]
+    #   Redis connection client.
+    # @param lock_scan_size [Integer]
+    #   The number of lock keys that should be released in a time.
+    #   Affects the RubyVM memmory (cuz each found lock will be temporary stored in memory for
+    #   subsequent removal from redis in one query at a time).
+    # @param queue_scan_size [Integer]
+    #   The number of lock queues that should be scanned removing an acquirer from them (at a time).
+    # @param logger [::Logger,#debug]
+    #   - Logger object used from `configuration` layer (see config['logger']);
+    #   - See RedisQueuedLocks::Logging::VoidLogger for example;
+    # @param isntrumenter [#notify]
+    #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
+    # @param instrument [NilClass,Any]
+    #    - 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 RQL cases will be logged;
+    #   - disabled by default;
+    #   - works in tandem with <config['log_sampling_percent']> and <config['log_sampler']>;
+    # @param log_sampling_percent [Integer]
+    #   - 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 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;
+    #   - disabled by default;
+    #   - works in tandem with <config['instr_sampling_percent']> and <config['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);
+    # @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 [Hash<Symbol,Any>]
+    #   Format: { ok: true, result: Hash<Symbol,Numeric> }
+    #
+    # @api private
+    # @since 1.14.0
+    # rubocop:disable Metrics/MethodLength
+    def release_locks_of(
+      refused_host_id,
+      refused_acquirer_id,
+      redis,
+      lock_scan_size,
+      queue_scan_size,
+      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
+    ) # TODO: move from SCAN to indexes :thinking:
+      rel_start_time = clock_gettime
+
+      # steep:ignore:start
+      fully_release_locks_of(
+        refused_host_id,
+        refused_acquirer_id,
+        redis,
+        lock_scan_size,
+        queue_scan_size
+      ) => { ok:, result: }
+      # steep:ignore:end
+
+      # @type var ok: bool
+      # @type var result: Hash[Symbol,Integer]
+
+      time_at = Time.now.to_f
+      rel_end_time = clock_gettime
+      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
+      )
+
+      run_non_critical do
+        instrumenter.notify('redis_queued_locks.release_locks_of', {
+          at: time_at,
+          rel_time: rel_time,
+          rel_key_cnt: result[:rel_key_cnt],
+          tch_queue_cnt: result[:tch_queue_cnt]
+        })
+      end if instr_sampled
+
+      {
+        ok: true,
+        result: {
+          rel_key_cnt: result[:rel_key_cnt],
+          tch_queue_cnt: result[:tch_queue_cnt],
+          rel_time: rel_time
+        }
+      }
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    private
+
+    # @param refused_host_id [String]
+    # @param refused_acquirer_id [String]
+    # @param redis [RedisClient]
+    # @param lock_scan_size [Integer]
+    # @param queue_scan_size [Integer]
+    # @return [Hash<Symbol,Boolean|Hash<Symbol,Integer>>]
+    #   - Example: { ok: true, result: { rel_key_cnt: 12345, tch_queue_cnt: 321 } }
+    #
+    # @api private
+    # @since 1.14.0
+    # rubocop:disable Metrics/MethodLength
+    def fully_release_locks_of(
+      refused_host_id,
+      refused_acquirer_id,
+      redis,
+      lock_scan_size,
+      queue_scan_size
+    )
+      # TODO: some indexing approach isntead of <scan>
+      rel_key_cnt = 0
+      tch_queue_cnt = 0
+
+      redis.with do |rconn|
+        # Step A: drop locks of the passed host/acquirer
+        refused_locks = Set.new #: Set[String]
+        rconn.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::LOCK_PATTERN,
+          count: lock_scan_size
+        ) do |lock_key|
+          acquirer_id, host_id = rconn.call('HMGET', lock_key, 'acq_id', 'hst_id')
+          if refused_host_id == host_id && refused_acquirer_id == acquirer_id
+            refused_locks << lock_key
+          end
+
+          if refused_locks.size >= lock_scan_size
+            # NOTE: steep can not recognize the `*`-splat operator on Set objects
+            rconn.call('DEL', *refused_locks) # steep:ignore
+            rel_key_cnt += refused_locks.size
+            refused_locks.clear
+          end
+        end
+
+        if refused_locks.any?
+          # NOTE: steep can not recognize the `*`-splat operator on Set objects
+          rconn.call('DEL', *refused_locks) # steep:ignore
+          rel_key_cnt += refused_locks.size
+        end
+
+        # Step B: drop passed host/acquirer from lock queues
+        rconn.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::LOCK_QUEUE_PATTERN,
+          count: queue_scan_size
+        ) do |lock_queue|
+          res = rconn.call('ZREM', lock_queue, refused_acquirer_id)
+          tch_queue_cnt += 1 if res != 0
+        end
+      end
+
+      { ok: true, result: { rel_key_cnt:, tch_queue_cnt: } }
+    end
+  end
+  # rubocop:enable Metrics/MethodLength
+end

data/lib/redis_queued_locks/acquirer.rb

@@ -6,6 +6,7 @@ module RedisQueuedLocks::Acquirer
   require_relative 'acquirer/acquire_lock'
   require_relative 'acquirer/release_lock'
   require_relative 'acquirer/release_all_locks'
+  require_relative 'acquirer/release_locks_of'
   require_relative 'acquirer/is_locked'
   require_relative 'acquirer/is_queued'
   require_relative 'acquirer/lock_info'

data/lib/redis_queued_locks/client.rb

@@ -2,6 +2,7 @@
 
 # @api public
 # @since 1.0.0
+# @version 1.14.0
 # rubocop:disable Metrics/ClassLength
 class RedisQueuedLocks::Client
   # @return [RedisClient]
@@ -27,7 +28,7 @@ class RedisQueuedLocks::Client
   # @return [RedisQueuedLocks::Config]
   #
   # @api public
-  # @since [1.13.0]
+  # @since 1.13.0
   attr_reader :config
 
   # @param redis_client [RedisClient]
@@ -52,7 +53,7 @@ class RedisQueuedLocks::Client
   # @return [void]
   #
   # @api public
-  # @since [1.13.0]
+  # @since 1.13.0
   def configure(&configuration)
     config.configure(&configuration)
   end
@@ -577,6 +578,8 @@ class RedisQueuedLocks::Client
       identity
     )
   end
+  alias_method :current_acq_id, :current_acquirer_id
+  alias_method :acq_id, :current_acquirer_id
 
   # Retrun the current host identifier.
   #
@@ -608,6 +611,8 @@ class RedisQueuedLocks::Client
       identity
     )
   end
+  alias_method :current_hst_id, :current_host_id
+  alias_method :hst_id, :current_host_id
 
   # Return the list of possible host identifiers that can be reached from the current ractor.
   #
@@ -739,6 +744,154 @@ class RedisQueuedLocks::Client
   end
   alias_method :release_locks, :clear_locks
 
+  # Release all locks of the passed acquirer/host and remove this acquirer/host from all queues;
+  #
+  # This is a cleanup helper intended for operational and debugging scenarios (for example: your
+  # current puma request thread is killed by Rack::Timeout and you need to cleanup all zombie RQL
+  # locks and lock reuqests obtained during the request processing).
+  #
+  # Identifiers can be extracted via:
+  #   - `#current_host_id`
+  #   - `#current_acquirer_id`
+  #   - `#possible_host_ids`
+  #   - lock data (extracted from Redis via #lock_info, #locks_info, #queue_info, #queues_info)
+  #
+  # @option host_id [String] Host identifier whose locks/queues should be released.
+  # @option acquirer_id [String] Acquirer identifier, associated with the `host_id`.
+  # @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]
+  # @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,Numeric>>]
+  #   Example: { ok: true, result: { rel_key_cnt: 100, tch_queue_cnt: 2, rel_time: 0.01 } }
+  #
+  # @example Release locks of the current process:
+  #   client.clear_locks_of(
+  #     host_id: client.current_host_id,
+  #     acquirer_id: client.current_acquirer_id
+  #   )
+  #
+  # @example Release locks of a different host/acquirer:
+  #   client.clear_locks_of(
+  #     host_id: "rql:hst:62681/2016/2032/b30ec5e4bea10512",
+  #     acquirer_id: "ral:acq:62681/2016/2024/2032/b30ec5e4bea10512"
+  #   )
+  #
+  # @see #clear_current_locks
+  # @see #current_host_id
+  # @see #current_acquirer_id
+  # @see #possible_host_ids
+  # @see #lock_info
+  # @see #locks_info
+  # @see #queue_info
+  # @see #queues_info
+  #
+  # @api public
+  # @since 1.14.0
+  def clear_locks_of(
+    host_id:,
+    acquirer_id:,
+    lock_scan_size: config['clear_locks_of__lock_scan_size'], # steep:ignore
+    queue_scan_size: config['clear_locks_of__queue_scan_size'], # steep:ingore
+    logger: config['logger'], # steep:ignore
+    instrumenter: config['instrumenter'], # steep:ignore
+    instrument: nil,
+    log_sampling_enabled: config['log_sampling_enabled'], # steep:ignore
+    log_sampling_percent: config['log_sampling_percent'], # steep:ignore
+    log_sampler: config['log_sampler'], # steep:ignore
+    log_sample_this: false,
+    instr_sampling_enabled: config['instr_sampling_enabled'], # steep:ignore
+    instr_sampling_percent: config['instr_sampling_percent'], # steep:ignore
+    instr_sampler: config['instr_sampler'], # steep:ignore
+    instr_sample_this: false
+  )
+    RedisQueuedLocks::Acquirer::ReleaseLocksOf.release_locks_of(
+      host_id,
+      acquirer_id,
+      redis_client,
+      lock_scan_size,
+      queue_scan_size,
+      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
+  alias_method :release_locks_of, :clear_locks_of
+
+  # Release all locks of the current acquirer/host and
+  # remove the current acquirer/host from all queues;
+  #
+  # @option batch_size [Integer]
+  # @option logger [::Logger,#debug]
+  # @option instrumenter [#notify] See `config['instrumenter']` docs for details.
+  # @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,Numeric>>]
+  #   Example: { ok: true, result: { rel_key_cnt: 100, tch_queue_cnt: 2, rel_time: 0.01 } }
+  #
+  # @see #clear_locks_of
+  #
+  # @api public
+  # @since 1.14.0
+  def clear_current_locks(
+    lock_scan_size: config['clear_locks_of__lock_scan_size'], # steep:ignore
+    queue_scan_size: config['clear_locks_of__queue_scan_size'], # steep:ingore
+    logger: config['logger'], # steep:ignore
+    instrumenter: config['instrumenter'], # steep:ignore
+    instrument: nil,
+    log_sampling_enabled: config['log_sampling_enabled'], # steep:ignore
+    log_sampling_percent: config['log_sampling_percent'], # steep:ignore
+    log_sampler: config['log_sampler'], # steep:ignore
+    log_sample_this: false,
+    instr_sampling_enabled: config['instr_sampling_enabled'], # steep:ignore
+    instr_sampling_percent: config['instr_sampling_percent'], # steep:ignore
+    instr_sampler: config['instr_sampler'], # steep:ignore
+    instr_sample_this: false
+  )
+    clear_locks_of(
+      host_id: current_host_id,
+      acquirer_id: current_acquirer_id,
+      lock_scan_size:,
+      queue_scan_size:,
+      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
+  alias_method :release_current_locks, :clear_current_locks
+
   # @option scan_size [Integer]
   #   The batch of scanned keys for Redis'es SCAN command.
   # @option with_info [Boolean]

data/lib/redis_queued_locks/config/dsl.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 # @api private
-# @since [1.13.0]
+# @since 1.13.0
 module RedisQueuedLocks::Config::DSL
   # @api private
-  # @since [1.13.0]
+  # @since 1.13.0
   module ClassMethods
     # NOTE:
     #   1. Style/DefWithParentheses rubocop's cop incorrectly drops `()` from method definition
@@ -15,7 +15,7 @@ module RedisQueuedLocks::Config::DSL
     # @return [Hash<String,Block>]
     #
     # @api private
-    # @since [1.13.0]
+    # @since 1.13.0
     def config_setters()= @config_setters # rubocop:disable Style/DefWithParentheses
 
     # NOTE:
@@ -27,7 +27,7 @@ module RedisQueuedLocks::Config::DSL
     # @return [Hash<String,Block>]
     #
     # @api private
-    # @since [1.13.0]
+    # @since 1.13.0
     def config_validators()= @config_validators # rubocop:disable Style/DefWithParentheses
 
     # @param config_key [String]
@@ -35,7 +35,7 @@ module RedisQueuedLocks::Config::DSL
     # @return [Bool]
     #
     # @api private
-    # @since [1.13.0]
+    # @since 1.13.0
     def validate(config_key, &validator)
       config_validators[config_key] = validator
     end
@@ -45,7 +45,7 @@ module RedisQueuedLocks::Config::DSL
     # @return [void]
     #
     # @api private
-    # @since [1.13.0]
+    # @since 1.13.0
     def setting(config_key, config_value)
       config_setters[config_key] = proc do |config|
         config[config_key] = config_value
@@ -57,7 +57,7 @@ module RedisQueuedLocks::Config::DSL
     # @return [Hash<String,Blcok>]
     #
     # @api private
-    # @since [1.13.0]
+    # @since 1.13.0
     def config_setters
       self.class.config_setters # steep:ignore
     end
@@ -65,7 +65,7 @@ module RedisQueuedLocks::Config::DSL
     # @return [Hash<String,Blcok>]
     #
     # @api private
-    # @since [1.13.0]
+    # @since 1.13.0
     def config_validators
       self.class.config_validators # steep:ignore
     end
@@ -76,7 +76,7 @@ module RedisQueuedLocks::Config::DSL
     # @return [void]
     #
     # @api private
-    # @since [1.13.0]
+    # @since 1.13.0
     def included(child_klass)
       child_klass.instance_variable_set(
         :@config_setters,