sidekiq-unique-jobs 8.0.10 → 8.0.12

data/lib/sidekiq_unique_jobs/digests.rb

@@ -18,7 +18,7 @@ module SidekiqUniqueJobs
     EMPTY_KEYS_SEGMENT = ["", "", "", ""].freeze
 
     def initialize(digests_key = DIGESTS)
-      super(digests_key)
+      super
     end
 
     #

data/lib/sidekiq_unique_jobs/exceptions.rb

@@ -80,8 +80,8 @@ module SidekiqUniqueJobs
 
       super(
         "#{job_class}##{lock_args_method} takes #{num_args} arguments, received #{given.inspect}" \
-        "\n\n" \
-        "   #{source_location.join(':')}"
+        "\n\n   " \
+        "#{source_location.join(':')}"
       )
     end
   end

data/lib/sidekiq_unique_jobs/job.rb

@@ -53,7 +53,7 @@ module SidekiqUniqueJobs
     end
 
     def add_lock_prefix(item)
-      item[LOCK_PREFIX] = SidekiqUniqueJobs.config.lock_prefix
+      item[LOCK_PREFIX] ||= SidekiqUniqueJobs.config.lock_prefix
     end
 
     def add_lock_type(item)

data/lib/sidekiq_unique_jobs/lock/base_lock.rb

@@ -134,9 +134,13 @@ module SidekiqUniqueJobs
       def callback_safely
         callback&.call
         item[JID]
-      rescue StandardError
-        reflect(:after_unlock_callback_failed, item)
-        raise
+      rescue StandardError => ex
+        reflect(:after_unlock_callback_failed, item, ex)
+        # Don't re-raise: lock is already unlocked, can't rollback
+        # Re-raising would cause job retry with lock already released
+        # leading to potential double execution
+        log_warn("After unlock callback failed: #{ex.class} - #{ex.message}")
+        item[JID]
       end
 
       def strategy_for(origin)
@@ -147,7 +151,7 @@ module SidekiqUniqueJobs
           server_strategy
         else
           raise SidekiqUniqueJobs::InvalidArgument,
-                "#origin needs to be either `:server` or `:client`"
+            "#origin needs to be either `:server` or `:client`"
         end
       end
 

data/lib/sidekiq_unique_jobs/lock/until_and_while_executing.rb

@@ -45,9 +45,11 @@ module SidekiqUniqueJobs
         else
           reflect(:unlock_failed, item)
         end
-      rescue Exception # rubocop:disable Lint/RescueException
+      rescue StandardError
         reflect(:execution_failed, item)
-        locksmith.lock(wait: 2)
+        # Re-acquire the "until" lock to prevent duplicates while job is in retry
+        # Use non-blocking lock attempt to avoid hanging on shutdown
+        locksmith.lock(wait: 0)
 
         raise
       end
@@ -56,9 +58,10 @@ module SidekiqUniqueJobs
 
       def ensure_relocked
         yield
-      rescue Exception # rubocop:disable Lint/RescueException
+      rescue StandardError
         reflect(:execution_failed, item)
-        locksmith.lock
+        # Re-acquire the "until" lock to prevent duplicates while job is in retry
+        locksmith.lock(wait: 0)
 
         raise
       end

data/lib/sidekiq_unique_jobs/lock/until_executing.rb

@@ -35,7 +35,7 @@ module SidekiqUniqueJobs
         yield
       rescue StandardError => ex
         reflect(:execution_failed, item, ex)
-        locksmith.lock(wait: 1)
+        locksmith.lock(wait: 0)
         raise
       end
     end

data/lib/sidekiq_unique_jobs/lock/while_executing.rb

@@ -23,7 +23,7 @@ module SidekiqUniqueJobs
       # @param [Sidekiq::RedisConnection, ConnectionPool] redis_pool the redis connection
       #
       def initialize(item, callback, redis_pool = nil)
-        super(item, callback, redis_pool)
+        super
         append_unique_key_suffix
       end
 

data/lib/sidekiq_unique_jobs/lock.rb

@@ -6,7 +6,7 @@ module SidekiqUniqueJobs
   #
   # @author Mikael Henriksson <mikael@mhenrixon.com>
   #
-  class Lock # rubocop:disable Metrics/ClassLength
+  class Lock
     # includes "SidekiqUniqueJobs::Connection"
     # @!parse include SidekiqUniqueJobs::Connection
     include SidekiqUniqueJobs::Connection

data/lib/sidekiq_unique_jobs/lock_args.rb

@@ -91,9 +91,9 @@ module SidekiqUniqueJobs
       job_class.send(lock_args_method, args)
     rescue ArgumentError
       raise SidekiqUniqueJobs::InvalidUniqueArguments,
-            given: args,
-            job_class: job_class,
-            lock_args_method: lock_args_method
+        given: args,
+        job_class: job_class,
+        lock_args_method: lock_args_method
     end
 
     # The method to use for filtering unique arguments

data/lib/sidekiq_unique_jobs/lock_digest.rb

@@ -51,7 +51,12 @@ module SidekiqUniqueJobs
     # Creates a namespaced unique digest based on the {#digestable_hash} and the {#lock_prefix}
     # @return [String] a unique digest
     def create_digest
-      digest = OpenSSL::Digest::MD5.hexdigest(dump_json(digestable_hash.sort))
+      digest = if SidekiqUniqueJobs.config.digest_algorithm == :legacy
+        OpenSSL::Digest::MD5.hexdigest(dump_json(digestable_hash.sort))
+      else
+        OpenSSL::Digest.new("SHA3-256", dump_json(digestable_hash.sort)).hexdigest
+      end
+
       "#{lock_prefix}:#{digest}"
     end
 

data/lib/sidekiq_unique_jobs/lock_ttl.rb

@@ -40,13 +40,15 @@ module SidekiqUniqueJobs
     #
     # Calculates the time until the job is scheduled starting from now
     #
+    # @note Ensures result is never negative to prevent TTL calculation issues
     #
-    # @return [Integer] the number of seconds until job is scheduled
+    # @return [Integer] the number of seconds until job is scheduled (>= 0)
     #
     def time_until_scheduled
       return 0 unless scheduled_at
 
-      scheduled_at.to_i - Time.now.utc.to_i
+      # Clamp to 0 to prevent negative values if job is already overdue
+      [0, scheduled_at.to_i - Time.now.utc.to_i].max
     end
 
     # The time a job is scheduled
@@ -66,12 +68,36 @@ module SidekiqUniqueJobs
     # @return [Integer] the number of seconds to live
     #
     def calculate
-      ttl = item[LOCK_TTL]
-      ttl ||= job_options[LOCK_TTL]
-      ttl ||= item[LOCK_EXPIRATION] # TODO: Deprecate at some point
-      ttl ||= job_options[LOCK_EXPIRATION] # TODO: Deprecate at some point
-      ttl ||= SidekiqUniqueJobs.config.lock_ttl
-      ttl && (ttl.to_i + time_until_scheduled)
+      ttl = fetch_ttl
+      return unless ttl
+
+      timing = calculate_timing(ttl)
+      return unless timing
+
+      timing.to_i + time_until_scheduled
+    end
+
+    private
+
+    def fetch_ttl
+      item[LOCK_TTL] ||
+        job_options[LOCK_TTL] ||
+        item[LOCK_EXPIRATION] || # TODO: Deprecate at some point
+        job_options[LOCK_EXPIRATION] || # TODO: Deprecate at some point
+        SidekiqUniqueJobs.config.lock_ttl
+    end
+
+    def calculate_timing(ttl)
+      case ttl
+      when String, Numeric
+        ttl
+      when Proc
+        ttl.call(item[ARGS])
+      when Symbol
+        job_class.send(ttl, item[ARGS])
+      else
+        raise ArgumentError, "#{ttl.class} is not supported for lock_ttl"
+      end
     end
   end
 end

data/lib/sidekiq_unique_jobs/locksmith.rb

@@ -4,7 +4,7 @@ module SidekiqUniqueJobs
   # Lock manager class that handles all the various locks
   #
   # @author Mikael Henriksson <mikael@mhenrixon.com>
-  class Locksmith # rubocop:disable Metrics/ClassLength
+  class Locksmith
     # includes "SidekiqUniqueJobs::Connection"
     # @!parse include SidekiqUniqueJobs::Connection
     include SidekiqUniqueJobs::Connection
@@ -34,6 +34,11 @@ module SidekiqUniqueJobs
     CLOCK_DRIFT_FACTOR = 0.01
     NETWORK_FACTOR = 0.04
 
+    #
+    # @return [Integer] Maximum wait time for blocking Redis operations (in seconds)
+    #   Prevents blocking web requests indefinitely when used in client middleware
+    MAX_BLOCKING_WAIT = 5
+
     #
     # @!attribute [r] key
     #   @return [Key] the key used for locking
@@ -81,9 +86,11 @@ module SidekiqUniqueJobs
     #
     # Deletes the lock regardless of if it has a pttl set
     #
+    # rubocop:disable Naming/PredicateMethod
     def delete!
       call_script(:delete, key.to_a, argv).to_i.positive?
     end
+    # rubocop:enable Naming/PredicateMethod
 
     #
     # Create a lock for the Sidekiq job
@@ -243,7 +250,7 @@ module SidekiqUniqueJobs
     # @return [nil] when lock was not possible
     # @return [Object] whatever the block returns when lock was acquired
     #
-    def primed_async(conn, wait = nil, &block) # rubocop:disable Metrics/MethodLength
+    def primed_async(conn, wait = nil, &block)
       timeout = (wait || config.timeout).to_i
       timeout = 1 if timeout.zero?
 
@@ -251,16 +258,17 @@ module SidekiqUniqueJobs
       concurrent_timeout = add_drift(timeout)
 
       reflect(:debug, :timeouts, item,
-              timeouts: {
-                brpoplpush_timeout: brpoplpush_timeout,
-                concurrent_timeout: concurrent_timeout,
-              })
+        timeouts: {
+          brpoplpush_timeout: brpoplpush_timeout,
+          concurrent_timeout: concurrent_timeout,
+        })
 
       # NOTE: When debugging, change .value to .value!
       primed_jid = Concurrent::Promises
         .future(conn) { |red_con| pop_queued(red_con, timeout) }
-        .value
+        .value(concurrent_timeout) # Timeout to prevent indefinite blocking
 
+      # If promise times out, primed_jid will be nil
       handle_primed(primed_jid, &block)
     end
 
@@ -307,6 +315,16 @@ module SidekiqUniqueJobs
     def brpoplpush(conn, wait)
       # passing timeout 0 to brpoplpush causes it to block indefinitely
       raise InvalidArgument, "wait must be an integer" unless wait.is_a?(Integer)
+      raise InvalidArgument, "wait must be positive" if wait.negative?
+
+      # Cap the wait time to prevent blocking requests too long
+      # This is especially important when called from client middleware
+      if wait > MAX_BLOCKING_WAIT
+        log_debug(
+          "Capping blocking wait from #{wait}s to #{MAX_BLOCKING_WAIT}s to prevent long request blocks",
+        )
+        wait = MAX_BLOCKING_WAIT
+      end
 
       conn.blmove(key.queued, key.primed, "RIGHT", "LEFT", wait)
     end

data/lib/sidekiq_unique_jobs/logging.rb

@@ -223,8 +223,8 @@ module SidekiqUniqueJobs
     end
 
     def fake_logger_context(_context)
-      logger.warn "Don't know how to setup the logging context. Please open a feature request:" \
-                  " https://github.com/mhenrixon/sidekiq-unique-jobs/issues/new?template=feature_request.md"
+      logger.warn "Don't know how to setup the logging context. Please open a feature request: " \
+                  "https://github.com/mhenrixon/sidekiq-unique-jobs/issues/new?template=feature_request.md"
 
       yield
     end

data/lib/sidekiq_unique_jobs/lua/shared/_find_digest_in_process_set.lua

@@ -1,9 +1,11 @@
 local function find_digest_in_process_set(digest, threshold)
   local process_cursor = 0
   local job_cursor     = 0
-  local pattern        = "*" .. digest .. "*"
   local found          = false
 
+  -- Cache digest transformation outside the loop - major performance win!
+  local digest_without_run = string.gsub(digest, ':RUN', '')
+
   log_debug("Searching in process list",
             "for digest:", digest,
             "cursor:", process_cursor)
@@ -26,8 +28,11 @@ local function find_digest_in_process_set(digest, threshold)
         log_debug("No entries in:", workers_key)
       else
         for i = 1, #jobs, 2 do
-          local jobstr = jobs[i +1]
-          if string.find(string.gsub(jobstr, ':RUN', ''), string.gsub(digest, ':RUN', '')) then
+          local jobstr = jobs[i + 1]
+          -- Use cached digest transformation - avoid repeated string.gsub on digest
+          local jobstr_without_run = string.gsub(jobstr, ':RUN', '')
+
+          if string.find(jobstr_without_run, digest_without_run) then
             log_debug("Found digest", digest, "in:", workers_key)
             found = true
             break

data/lib/sidekiq_unique_jobs/lua/shared/_find_digest_in_queues.lua

@@ -32,8 +32,19 @@ local function find_digest_in_queues(digest)
             break
           end
         end
+
+        -- Short-circuit: Stop scanning this queue's batches after finding match
+        if found then
+          break
+        end
+
         index = index + per
       end
+
+      -- Short-circuit: Stop scanning remaining queues after finding match
+      if found then
+        break
+      end
     end
 
     cursor = next_cursor

data/lib/sidekiq_unique_jobs/lua/shared/_find_digest_in_sorted_set.lua

@@ -1,12 +1,16 @@
 local function find_digest_in_sorted_set(name, digest)
   local cursor  = 0
-  local count   = 5
+  local count   = 50
   local pattern = "*" .. digest .. "*"
   local found   = false
 
   log_debug("searching in:", name,
             "for digest:", digest,
             "cursor:", cursor)
+
+  -- Note: We must use pattern matching because sorted sets contain job JSON strings,
+  -- not just digests. The digest is embedded in the JSON as the "lock_digest" field.
+  -- ZSCORE won't work here as we need to search within the member content.
   repeat
     local pagination  = redis.call("ZSCAN", name, cursor, "MATCH", pattern, "COUNT", count)
     local next_cursor = pagination[1]

data/lib/sidekiq_unique_jobs/lua/unlock.lua

@@ -42,12 +42,25 @@ local locked_count = redis.call("HLEN", locked)
 ---------  Begin unlock.lua ---------
 log_debug("BEGIN unlock digest:", digest, "(job_id: " .. job_id ..")")
 
-log_debug("HEXISTS", locked, job_id)
-if redis.call("HEXISTS", locked, job_id) == 0 then
-  -- TODO: Improve orphaned lock detection
+-- Always clean up this job's queued/primed entries first
+-- This prevents orphaned entries even if job doesn't hold the lock
+log_debug("LREM", queued, -1, job_id)
+redis.call("LREM", queued, -1, job_id)
+
+log_debug("LREM", primed, -1, job_id)
+redis.call("LREM", primed, -1, job_id)
+
+-- Check if this job actually holds the lock
+local holds_lock = redis.call("HEXISTS", locked, job_id) == 1
+log_debug("HEXISTS", locked, job_id, "=>", holds_lock)
+
+if not holds_lock then
+  -- Job doesn't hold the lock - check if this is an orphaned lock scenario
   if queued_count == 0 and primed_count == 0 and locked_count == 0 then
-    log_debug("Orphaned lock")
+    log_debug("Orphaned lock - cleaning up")
+    -- Continue with cleanup below
   else
+    -- Other jobs still hold locks for this digest
     local result = ""
     for i,v in ipairs(redis.call("HKEYS", locked)) do
       result = result .. v .. ","
@@ -55,17 +68,12 @@ if redis.call("HEXISTS", locked, job_id) == 0 then
     result = locked .. " (" .. result .. ")"
     log("Yielding to: " .. result)
     log_debug("Yielding to", result, locked, "by job", job_id)
-    return nil
+    -- Still return job_id to indicate cleanup completed
+    -- Caller already removed from queued/primed
+    return job_id
   end
 end
 
--- Just in case something went wrong
-log_debug("LREM", queued, -1, job_id)
-redis.call("LREM", queued, -1, job_id)
-
-log_debug("LREM", primed, -1, job_id)
-redis.call("LREM", primed, -1, job_id)
-
 local redis_version = toversion(redisversion)
 
 if lock_type ~= "until_expired" then

data/lib/sidekiq_unique_jobs/on_conflict/reject.rb

@@ -28,7 +28,16 @@ module SidekiqUniqueJobs
       # @return [false] when Sidekiq::Deadset#kill does not take multiple arguments
       #
       def kill_with_options?
-        Sidekiq::DeadSet.instance_method(:kill).arity > 1
+        kill_arity = Sidekiq::DeadSet.instance_method(:kill).arity
+        # Method#arity returns:
+        #   1. a nonnegative number for methods that take a fixed number of arguments.
+        #   2. A negative number if it takes a variable number of arguments.
+        # Keyword arguments are considered a single argument, and are considered optional unless one of the kwargs is
+        # required.
+        # Therefore, to determine if `Sidekiq::DeadSet#kill` accepts options beyond the single positional payload
+        # argument, we need to check whether the absolute value of the arity is greater than 1.
+        # See: https://apidock.com/ruby/Method/arity
+        kill_arity > 1 || kill_arity < -1
       end
 
       #

data/lib/sidekiq_unique_jobs/on_conflict/replace.rb

@@ -21,7 +21,7 @@ module SidekiqUniqueJobs
       # @param [Hash] item sidekiq job hash
       #
       def initialize(item, redis_pool = nil)
-        super(item, redis_pool)
+        super
         @queue       = item[QUEUE]
         @lock_digest = item[LOCK_DIGEST]
       end
@@ -54,8 +54,8 @@ module SidekiqUniqueJobs
       #
       def delete_job_by_digest
         call_script(:delete_job_by_digest,
-                    keys: ["#{QUEUE}:#{queue}", SCHEDULE, RETRY],
-                    argv: [lock_digest])
+          keys: ["#{QUEUE}:#{queue}", SCHEDULE, RETRY],
+          argv: [lock_digest])
       end
 
       #

data/lib/sidekiq_unique_jobs/on_conflict/reschedule.rb

@@ -13,7 +13,7 @@ module SidekiqUniqueJobs
 
       # @param [Hash] item sidekiq job hash
       def initialize(item, redis_pool = nil)
-        super(item, redis_pool)
+        super
         self.job_class = item[CLASS]
       end
 

data/lib/sidekiq_unique_jobs/on_conflict.rb

@@ -33,8 +33,8 @@ module SidekiqUniqueJobs
 
       strategies.fetch(strategy.to_sym) do
         SidekiqUniqueJobs.logger.warn(
-          "No matching implementation for strategy: #{strategy}, returning OnConflict::NullStrategy." \
-          " Available strategies are (#{strategies.inspect})",
+          "No matching implementation for strategy: #{strategy}, returning OnConflict::NullStrategy. " \
+          "Available strategies are (#{strategies.inspect})",
         )
 
         OnConflict::NullStrategy

data/lib/sidekiq_unique_jobs/orphans/manager.rb

@@ -32,7 +32,7 @@ module SidekiqUniqueJobs
       #
       # @return [SidekiqUniqueJobs::TimerTask] the task that was started
       #
-      def start(test_task = nil) # rubocop:disable
+      def start(test_task = nil)
         return if disabled?
         return if registered?
 
@@ -73,7 +73,7 @@ module SidekiqUniqueJobs
       # @return [<type>] <description>
       #
       def task
-        @task ||= default_task # rubocop:disable ThreadSafety/InstanceVariableInClassMethod
+        @task ||= default_task # rubocop:disable ThreadSafety/ClassInstanceVariable
       end
 
       #
@@ -101,7 +101,7 @@ module SidekiqUniqueJobs
       # @return [void]
       #
       def task=(task)
-        @task = task # rubocop:disable ThreadSafety/InstanceVariableInClassMethod
+        @task = task # rubocop:disable ThreadSafety/ClassInstanceVariable
       end
 
       #

data/lib/sidekiq_unique_jobs/orphans/ruby_reaper.rb

@@ -9,7 +9,6 @@ module SidekiqUniqueJobs
     #
     # @author Mikael Henriksson <mikael@mhenrixon.com>
     #
-    # rubocop:disable Metrics/ClassLength
     class RubyReaper < Reaper
       include SidekiqUniqueJobs::Timing
 
@@ -57,7 +56,7 @@ module SidekiqUniqueJobs
       # @param [Redis] conn a connection to redis
       #
       def initialize(conn)
-        super(conn)
+        super
         @digests      = SidekiqUniqueJobs::Digests.new
         @scheduled    = Redis::SortedSet.new(SCHEDULE)
         @retried      = Redis::SortedSet.new(RETRY)
@@ -107,7 +106,7 @@ module SidekiqUniqueJobs
       #
       # @return [Array<String>] an array of orphaned digests
       #
-      def orphans # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      def orphans
         orphans = []
         page    = 0
         per     = reaper_count * 2
@@ -145,7 +144,10 @@ module SidekiqUniqueJobs
       #   1. It checks the scheduled set
       #   2. It checks the retry set
       #   3. It goes through all queues
+      #   4. It checks active processes
       #
+      # Note: Uses early returns for short-circuit evaluation.
+      # We can't pipeline ZSCAN operations as they're iterative.
       #
       # @param [String] digest the digest to search for
       #
@@ -153,7 +155,17 @@ module SidekiqUniqueJobs
       # @return [false] when no job was found for this digest
       #
       def belongs_to_job?(digest)
-        scheduled?(digest) || retried?(digest) || enqueued?(digest) || active?(digest)
+        # Short-circuit: Return immediately if found in scheduled set
+        return true if scheduled?(digest)
+
+        # Short-circuit: Return immediately if found in retry set
+        return true if retried?(digest)
+
+        # Short-circuit: Return immediately if found in any queue
+        return true if enqueued?(digest)
+
+        # Last check: active processes
+        active?(digest)
       end
 
       #
@@ -197,7 +209,7 @@ module SidekiqUniqueJobs
         end
       end
 
-      def active?(digest) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def active?(digest)
         Sidekiq.redis do |conn|
           procs = conn.sscan("processes").to_a
           return false if procs.empty?
@@ -219,10 +231,12 @@ module SidekiqUniqueJobs
             workers.each_pair do |_tid, job|
               next unless (item = safe_load_json(job))
 
-              payload = safe_load_json(item[PAYLOAD])
+              next unless (raw_payload = item[PAYLOAD])
+
+              payload = safe_load_json(raw_payload)
 
               return true if match?(digest, payload[LOCK_DIGEST])
-              return true if considered_active?(payload[CREATED_AT])
+              return true if considered_active?(time_from_payload_timestamp(payload[CREATED_AT]).to_f)
             end
           end
 
@@ -240,6 +254,15 @@ module SidekiqUniqueJobs
         max_score < time_f
       end
 
+      def time_from_payload_timestamp(timestamp)
+        if timestamp.is_a?(Float)
+          # < Sidekiq 8, timestamps were stored as fractional seconds since the epoch
+          Time.at(timestamp).utc
+        else
+          Time.at(timestamp / 1000, timestamp % 1000, :millisecond)
+        end
+      end
+
       #
       # Loops through all the redis queues and yields them one by one
       #
@@ -253,7 +276,7 @@ module SidekiqUniqueJobs
         conn.sscan("queues").each(&block)
       end
 
-      def entries(conn, queue, &block) # rubocop:disable Metrics/MethodLength
+      def entries(conn, queue, &block)
         queue_key    = "queue:#{queue}"
         initial_size = conn.llen(queue_key)
         deleted_size = 0
@@ -297,6 +320,9 @@ module SidekiqUniqueJobs
       #
       # Checks a sorted set for the existance of this digest
       #
+      # Note: Must use pattern matching because sorted sets contain job JSON strings,
+      # not just digests. The digest is embedded in the JSON as the "lock_digest" field.
+      # ZSCORE won't work here as we need to search within the member content.
       #
       # @param [String] key the key for the sorted set
       # @param [String] digest the digest to scan for
@@ -305,7 +331,8 @@ module SidekiqUniqueJobs
       # @return [false] when missing
       #
       def in_sorted_set?(key, digest)
-        conn.zscan(key, match: "*#{digest}*", count: 1).to_a.any?
+        # Increased count from 1 to 50 for better throughput
+        conn.zscan(key, match: "*#{digest}*", count: 50).to_a.any?
       end
     end
     # rubocop:enable Metrics/ClassLength

data/lib/sidekiq_unique_jobs/reflections.rb

@@ -50,15 +50,15 @@ module SidekiqUniqueJobs
     #
     # @return [void] <description>
     #
-    def dispatch(reflection, *args) # rubocop:disable Metrics/MethodLength
+    def dispatch(reflection, *args)
       if (block = @reflections[reflection])
         block.call(*args)
 
         if DEPRECATIONS.key?(reflection)
           replacement, removal_version = DEPRECATIONS[reflection]
           SidekiqUniqueJobs::Deprecation.warn(
-            "#{reflection} is deprecated and will be removed in version #{removal_version}." \
-            " Use #{replacement} instead.",
+            "#{reflection} is deprecated and will be removed in version #{removal_version}. " \
+            "Use #{replacement} instead.",
           )
         end
       elsif misconfigured?(reflection)

data/lib/sidekiq_unique_jobs/rspec/matchers/have_valid_sidekiq_options.rb

@@ -43,9 +43,11 @@ module SidekiqUniqueJobs
       #
       # @return [HaveValidSidekiqOptions] an RSpec matcher
       #
-      def have_valid_sidekiq_options(*args) # rubocop:disable Naming/PredicateName
+      # rubocop:disable Naming/PredicatePrefix
+      def have_valid_sidekiq_options(*args)
         HaveValidSidekiqOptions.new(*args)
       end
+      # rubocop:enable Naming/PredicatePrefix
     end
   end
 end