sidekiq-unique-jobs 8.0.11 → 8.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 752654a036faee8511674b89a3a50ac370f497c29499e3f1fd4dd466b3c5d344
-  data.tar.gz: 40fbc25bd5639f248d6b34817e820d6b7f096a559ed3e0059d28570137b86274
+  metadata.gz: ac54a1a32a5e8e0d11d10907799a1cc495da0439868857db6f7516e2334e8a2e
+  data.tar.gz: '0998be2173de200c826873e1d7e96aceb72f495b3d0b0d3e316196c52e0844e2'
 SHA512:
-  metadata.gz: cfe83dfbe84eaac52440e1178acf19abfe08bcf4e65c7dc8c9013c315f5e19c57a68c104ded980997c8b5f88400e90175a60858eaede00295327917062a26035
-  data.tar.gz: 128852982336a1d363eebf9f597fb30209369e4ce4376bfefe630fdd56c2bd426be724921b4d6493ccb1406ad65ba1fae37c8085efbdb4fb37e2c2cdd660f9a1
+  metadata.gz: e10ce9fe4a23b720f8ecd701bc139ac5f5b3457c53ca6077996abce19d04003b283943fcbb4eeee22284b9df870f477e33c74852e3ec838d50aff28e19440c38
+  data.tar.gz: daeead0b5f5b95dcc22987ad6ec3c2b27118f4166b04c7c478ad790d8a0d10629388866cfcd26b341f2bbfd2e48f7d4b1210583b28ea9287788b23ac3333c659

data/CHANGELOG.md

@@ -1,13 +1,30 @@
 # Changelog
 
-## [Unreleased](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/HEAD)
+## [v8.0.11](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v8.0.11) (2025-05-25)
 
-[Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v8.0.10...HEAD)
+[Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v8.0.10...v8.0.11)
+
+**Implemented enhancements:**
+
+- chore: address recent rubocop changes [\#880](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/880) ([mhenrixon](https://github.com/mhenrixon))
+- feat\(digest\): allow modern algorithm [\#853](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/853) ([mhenrixon](https://github.com/mhenrixon))
+
+**Closed issues:**
+
+- Your paypal link doesn't work [\#876](https://github.com/mhenrixon/sidekiq-unique-jobs/issues/876)
+- Replace MD5 with SHA256+ [\#848](https://github.com/mhenrixon/sidekiq-unique-jobs/issues/848)
+- NoMethodError: undefined method `\[\]' for true:TrueClass [\#643](https://github.com/mhenrixon/sidekiq-unique-jobs/issues/643)
 
 **Merged pull requests:**
 
-- tweak changelog for 8.0.9 [\#836](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/836) ([Earlopain](https://github.com/Earlopain))
-- Add digest scores for faster deletes in sorted sets [\#835](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/835) ([ezekg](https://github.com/ezekg))
+- Add support for lock\_ttl to be a Proc/class method [\#879](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/879) ([brayden-onesignal](https://github.com/brayden-onesignal))
+- Move from Sidekiq 8 beta to released version [\#872](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/872) ([jukra](https://github.com/jukra))
+- update Reject\#kill\_with\_options? for Ruby 3 kwargs [\#868](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/868) ([stathis-alexander](https://github.com/stathis-alexander))
+- Remove redundant include to locales \(for Sidekiq 8\) [\#867](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/867) ([jukra](https://github.com/jukra))
+- Support for Sidekiq 8 [\#866](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/866) ([jukra](https://github.com/jukra))
+- 📝 Improve README.md [\#860](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/860) ([jaredsmithse](https://github.com/jaredsmithse))
+- mention ttl and timeout unit \(seconds\) in README [\#859](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/859) ([fwolfst](https://github.com/fwolfst))
+- Add a note to README on `schedule_in` option for `reschedule` conflict strategy [\#849](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/849) ([vittorius](https://github.com/vittorius))
 
 ## [v8.0.10](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v8.0.10) (2024-02-22)
 
@@ -18,6 +35,11 @@
 - until\_and\_while\_executing and lock\_ttl: jobs silently dropped [\#788](https://github.com/mhenrixon/sidekiq-unique-jobs/issues/788)
 - Slow evalsha causing timeouts [\#668](https://github.com/mhenrixon/sidekiq-unique-jobs/issues/668)
 
+**Merged pull requests:**
+
+- tweak changelog for 8.0.9 [\#836](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/836) ([Earlopain](https://github.com/Earlopain))
+- Add digest scores for faster deletes in sorted sets [\#835](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/835) ([ezekg](https://github.com/ezekg))
+
 ## [v7.1.33](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v7.1.33) (2024-02-12)
 
 [Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v8.0.9...v7.1.33)
@@ -512,7 +534,7 @@
 
 **Merged pull requests:**
 
-- Update docs [\#644](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/644) ([andypple](https://github.com/andypple))
+- Update docs [\#644](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/644) ([ruzig](https://github.com/ruzig))
 
 ## [v7.0.13](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v7.0.13) (2021-09-27)
 
@@ -2166,7 +2188,6 @@
 - Attempt to constantize String `worker_class` arguments passed to client middleware [\#17](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/17) ([disbelief](https://github.com/disbelief))
 - Compatibility with Sidekiq 2.12.1 Scheduled Jobs [\#16](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/16) ([lsimoneau](https://github.com/lsimoneau))
 - Allow worker to specify which arguments to include in uniquing hash [\#12](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/12) ([sax](https://github.com/sax))
-- Add support for unique when using Sidekiq's delay function [\#11](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/11) ([eduardosasso](https://github.com/eduardosasso))
 - Adding the unique prefix option [\#8](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/8) ([KensoDev](https://github.com/KensoDev))
 - Remove unnecessary log messages [\#7](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/7) ([marclennox](https://github.com/marclennox))
 
@@ -2180,7 +2201,6 @@
 
 **Merged pull requests:**
 
-- Fix multiple bugs, cleaned up dependencies, and added a feature [\#4](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/4) ([kemper-blinq](https://github.com/kemper-blinq))
 - Dependency on sidekiq 2.2.0 and up [\#3](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/3) ([philostler](https://github.com/philostler))
 
 ## [v2.2.1](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v2.2.1) (2012-08-19)

data/README.md

@@ -197,7 +197,7 @@ A lock is created when `UntilExecuting.perform_async` is called. Then it is eith
 
 ```ruby
 class UntilExecuting
-  include Sidekiq::Workers
+  include Sidekiq::Worker
 
   sidekiq_options lock: :until_executing
 
@@ -219,7 +219,7 @@ A lock is created when `UntilExecuted.perform_async` is called. Then it is eithe
 
 ```ruby
 class UntilExecuted
-  include Sidekiq::Workers
+  include Sidekiq::Worker
 
   sidekiq_options lock: :until_executed
 
@@ -237,9 +237,9 @@ This lock behaves identically to the [Until Executed](#until-executed) except fo
 
 ```ruby
 class UntilExpired
-  include Sidekiq::Workers
+  include Sidekiq::Worker
 
-  sidekiq_options lock: :until_expired, lock_ttl: 1.day
+  sidekiq_options lock: :until_expired, lock_ttl: 1.day.to_i
 
   def perform
     # Do work
@@ -255,7 +255,7 @@ This lock is a combination of two locks (`:until_executing` and `:while_executin
 
 ```ruby
 class UntilAndWhileExecutingWorker
-  include Sidekiq::Workers
+  include Sidekiq::Worker
 
   sidekiq_options lock: :until_and_while_executing,
                   lock_timeout: 2,
@@ -277,7 +277,7 @@ These locks are put on a queue without any type of locking mechanism, the lockin
 
 ```ruby
 class WhileExecutingWorker
-  include Sidekiq::Workers
+  include Sidekiq::Worker
 
   sidekiq_options lock: :while_executing,
                   lock_timeout: 2,

data/lib/sidekiq_unique_jobs/config.rb

@@ -31,6 +31,10 @@ module SidekiqUniqueJobs
   #
   # @author Mauro Berlanda <mauro.berlanda@gmail.com>
   class Config < ThreadSafeConfig
+    def initialize(*)
+      super
+      @redis_version_mutex = Mutex.new
+    end
     #
     # @return [Hash<Symbol, SidekiqUniqueJobs::Lock::BaseLock] all available queued locks
     LOCKS_WHILE_ENQUEUED = {
@@ -326,11 +330,20 @@ module SidekiqUniqueJobs
     #
     # The current version of redis
     #
+    # Thread-safe: Uses mutex to prevent multiple threads from fetching version simultaneously
     #
     # @return [String] a version string eg. `5.0.1`
     #
     def redis_version
-      self.current_redis_version = SidekiqUniqueJobs.fetch_redis_version if current_redis_version == REDIS_VERSION
+      # Fast path: if already fetched, return immediately without locking
+      return current_redis_version if current_redis_version != REDIS_VERSION
+
+      # Slow path: fetch version with mutex protection
+      @redis_version_mutex.synchronize do
+        # Double-check inside mutex in case another thread just fetched it
+        self.current_redis_version = SidekiqUniqueJobs.fetch_redis_version if current_redis_version == REDIS_VERSION
+      end
+
       current_redis_version
     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)

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_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
@@ -93,6 +95,8 @@ module SidekiqUniqueJobs
         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

data/lib/sidekiq_unique_jobs/locksmith.rb

@@ -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
@@ -259,8 +266,9 @@ module SidekiqUniqueJobs
       # 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/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/orphans/ruby_reaper.rb

@@ -144,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
       #
@@ -152,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
 
       #
@@ -218,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
 
@@ -239,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
       #
@@ -296,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
@@ -304,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/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

data/lib/sidekiq_unique_jobs/script/client.rb

@@ -27,20 +27,26 @@ module SidekiqUniqueJobs
         @scripts = Scripts.fetch(config.scripts_path)
       end
 
+      #
+      # Maximum number of retries for script execution errors
+      #
+      MAX_RETRIES = 3
+
       #
       # Execute a lua script with the provided script_name
       #
       # @note this method is recursive if we need to load a lua script
-      #   that wasn't previously loaded.
+      #   that wasn't previously loaded. Limited to MAX_RETRIES to prevent stack overflow.
       #
       # @param [Symbol] script_name the name of the script to execute
       # @param [Redis] conn the redis connection to use for execution
       # @param [Array<String>] keys script keys
       # @param [Array<Object>] argv script arguments
+      # @param [Integer] retries number of retries remaining (internal use)
       #
       # @return value from script
       #
-      def execute(script_name, conn, keys: [], argv: [])
+      def execute(script_name, conn, keys: [], argv: [], retries: MAX_RETRIES)
         result, elapsed = timed do
           scripts.execute(script_name, conn, keys: keys, argv: argv)
         end
@@ -48,8 +54,10 @@ module SidekiqUniqueJobs
         logger.debug("Executed #{script_name}.lua in #{elapsed}ms")
         result
       rescue ::RedisClient::CommandError => ex
+        raise if retries <= 0
+
         handle_error(script_name, conn, ex) do
-          execute(script_name, conn, keys: keys, argv: argv)
+          execute(script_name, conn, keys: keys, argv: argv, retries: retries - 1)
         end
       end
 

data/lib/sidekiq_unique_jobs/script/lua_error.rb

@@ -88,9 +88,11 @@ module SidekiqUniqueJobs
       end
 
       # :nocov:
+      # rubocop:disable Naming/PredicateMethod
       def line_from_gem(line)
         line.split(":").first.include?(LIB_PATH)
       end
+      # rubocop:enable Naming/PredicateMethod
     end
   end
 end

data/lib/sidekiq_unique_jobs/script/scripts.rb

@@ -11,42 +11,16 @@ module SidekiqUniqueJobs
       SCRIPT_PATHS = Concurrent::Map.new
 
       #
-      # Fetch a scripts configuration for path
+      # Fetch or create a scripts configuration for path
       #
-      # @param [Pathname] root_path the path to scripts
-      #
-      # @return [Scripts] a collection of scripts
-      #
-      def self.fetch(root_path)
-        if (scripts = SCRIPT_PATHS.get(root_path))
-          return scripts
-        end
-
-        create(root_path)
-      end
-
-      #
-      # Create a new scripts collection based on path
+      # Uses Concurrent::Map#fetch_or_store for thread-safe lazy initialization
       #
       # @param [Pathname] root_path the path to scripts
       #
       # @return [Scripts] a collection of scripts
       #
-      def self.create(root_path)
-        scripts = new(root_path)
-        store(scripts)
-      end
-
-      #
-      # Store the scripts collection in memory
-      #
-      # @param [Scripts] scripts the path to scripts
-      #
-      # @return [Scripts] the scripts instance that was stored
-      #
-      def self.store(scripts)
-        SCRIPT_PATHS.put(scripts.root_path, scripts)
-        scripts
+      def self.fetch(root_path)
+        SCRIPT_PATHS.fetch_or_store(root_path) { new(root_path) }
       end
 
       #
@@ -66,35 +40,57 @@ module SidekiqUniqueJobs
         @root_path = path
       end
 
+      #
+      # Fetch or load a script by name
+      #
+      # Uses Concurrent::Map#fetch_or_store for thread-safe lazy loading
+      #
+      # @param [Symbol, String] name the script name
+      # @param [Redis] conn the redis connection
+      #
+      # @return [Script] the loaded script
+      #
       def fetch(name, conn)
-        if (script = scripts.get(name.to_sym))
-          return script
-        end
-
-        load(name, conn)
+        scripts.fetch_or_store(name.to_sym) { load(name, conn) }
       end
 
+      #
+      # Load a script from disk, store in Redis, and cache in memory
+      #
+      # @param [Symbol, String] name the script name
+      # @param [Redis] conn the redis connection
+      #
+      # @return [Script] the loaded script
+      #
       def load(name, conn)
         script = Script.load(name, root_path, conn)
         scripts.put(name.to_sym, script)
-
         script
       end
 
+      #
+      # Delete a script from the collection
+      #
+      # @param [Script, Symbol, String] script the script or script name to delete
+      #
+      # @return [Script, nil] the deleted script
+      #
       def delete(script)
-        if script.is_a?(Script)
-          scripts.delete(script.name)
-        else
-          scripts.delete(script.to_sym)
-        end
+        key = script.is_a?(Script) ? script.name : script.to_sym
+        scripts.delete(key)
       end
 
+      #
+      # Kill a running Redis script
+      #
+      # @param [Redis] conn the redis connection
+      #
+      # @return [String] Redis response
+      #
       def kill(conn)
-        if conn.respond_to?(:namespace)
-          conn.redis.script(:kill)
-        else
-          conn.script(:kill)
-        end
+        # Handle both namespaced and non-namespaced Redis connections
+        redis = conn.respond_to?(:namespace) ? conn.redis : conn
+        redis.script(:kill)
       end
 
       #

data/lib/sidekiq_unique_jobs/version.rb

@@ -3,5 +3,5 @@
 module SidekiqUniqueJobs
   #
   # @return [String] the current SidekiqUniqueJobs version
-  VERSION = "8.0.11"
+  VERSION = "8.0.12"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-unique-jobs
 version: !ruby/object:Gem::Version
-  version: 8.0.11
+  version: 8.0.12
 platform: ruby
 authors:
 - Mikael Henriksson
 bindir: bin
 cert_chain: []
-date: 2025-05-25 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -221,7 +221,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Sidekiq middleware that prevents duplicates jobs
 test_files: []