sidekiq-unique-jobs 8.0.10 → 8.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cd95f03398a1663b2afbba47f61736cfd3a0ab91fcc0d5b90d353d4f283db07
-  data.tar.gz: ced0a60e5fad52b5f2a66dcc29b10a221c6d39f4c4089d812327922d3b6b4e8b
+  metadata.gz: ac54a1a32a5e8e0d11d10907799a1cc495da0439868857db6f7516e2334e8a2e
+  data.tar.gz: '0998be2173de200c826873e1d7e96aceb72f495b3d0b0d3e316196c52e0844e2'
 SHA512:
-  metadata.gz: d72a8b181407ccc09e4f11c9d8f0860df65f80373c2064ec0f7d743d2bde4273cde1e117f2983b8f71b3a2c9f17c8b9ab8808395991030617bb6b380073457be
-  data.tar.gz: 2908759b402bff47b1ace5c9ab666a10779085c89b90c6261b4c935fde97cbf0f8291c8bf2df48e0b46c302eaa66f169785fdf0503ad97fcf0d43a0e0fd1b47d
+  metadata.gz: e10ce9fe4a23b720f8ecd701bc139ac5f5b3457c53ca6077996abce19d04003b283943fcbb4eeee22284b9df870f477e33c74852e3ec838d50aff28e19440c38
+  data.tar.gz: daeead0b5f5b95dcc22987ad6ec3c2b27118f4166b04c7c478ad790d8a0d10629388866cfcd26b341f2bbfd2e48f7d4b1210583b28ea9287788b23ac3333c659

data/CHANGELOG.md

@@ -1,12 +1,55 @@
 # Changelog
 
+## [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...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:**
+
+- 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)
+
+[Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v7.1.33...v8.0.10)
+
+**Closed issues:**
+
+- 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)
+
 ## [v8.0.9](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v8.0.9) (2024-02-12)
 
 [Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v8.0.8...v8.0.9)
 
 **Fixed bugs:**
 
-- note: The RCE vulnerability was a false alarm, `sidekiq-unique-jobs` was not vulnerable to RCE. You can find additional information in the PR linked below.
 - fix\(rce\): prevent remot code execution [\#833](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/833) ([mhenrixon](https://github.com/mhenrixon))
 
 ## [v8.0.8](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v8.0.8) (2024-02-12)
@@ -50,7 +93,7 @@
 
 ## [v8.0.6](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v8.0.6) (2024-01-24)
 
-[Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v8.0.5...v8.0.6)
+[Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v7.1.32...v8.0.6)
 
 **Implemented enhancements:**
 
@@ -60,7 +103,6 @@
 **Closed issues:**
 
 - should respond to `has_valid_sidekiq_options?` [\#822](https://github.com/mhenrixon/sidekiq-unique-jobs/issues/822)
-- Reaper manager registration is subject to race conditions [\#801](https://github.com/mhenrixon/sidekiq-unique-jobs/issues/801)
 - `while_executing` with `on_conflict: :reschedule` Reschedule job after job execution  [\#800](https://github.com/mhenrixon/sidekiq-unique-jobs/issues/800)
 - Large retry queue causes reaper to run too slow [\#759](https://github.com/mhenrixon/sidekiq-unique-jobs/issues/759)
 
@@ -68,6 +110,14 @@
 
 - fix: skip unless reaper was registered [\#820](https://github.com/mhenrixon/sidekiq-unique-jobs/pull/820) ([mhenrixon](https://github.com/mhenrixon))
 
+## [v7.1.32](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v7.1.32) (2023-11-11)
+
+[Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v8.0.5...v7.1.32)
+
+**Closed issues:**
+
+- Reaper manager registration is subject to race conditions [\#801](https://github.com/mhenrixon/sidekiq-unique-jobs/issues/801)
+
 ## [v8.0.5](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/v8.0.5) (2023-11-11)
 
 [Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v8.0.4...v8.0.5)
@@ -484,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)
 
@@ -2138,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))
 
@@ -2152,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

@@ -4,7 +4,7 @@
 
 ## Support Me
 
-Want to show me some ❤️ for the hard work I do on this gem? You can use the following PayPal link: [https://paypal.me/mhenrixon1](https://paypal.me/mhenrixon1). Any amount is welcome and let me tell you it feels good to be appreciated. Even a dollar makes me super excited about all of this.
+Want to show me some ❤️ for the hard work I do on this gem? You can use the following PayPal link: [https://paypal.me/mhenrixon2](https://paypal.me/mhenrixon2). Any amount is welcome and let me tell you it feels good to be appreciated. Even a dollar makes me super excited about all of this.
 
 <!-- MarkdownTOC -->
 
@@ -59,6 +59,7 @@ Want to show me some ❤️ for the hard work I do on this gem? You can use the
     - [sidekiq-global_id](#sidekiq-global_id)
     - [sidekiq-status](#sidekiq-status)
   - [Global Configuration](#global-configuration)
+    - [digest_algorithm](#digest_algorithm)
     - [debug_lua](#debug_lua)
     - [lock_timeout](#lock_timeout)
     - [lock_ttl](#lock_ttl)
@@ -88,7 +89,7 @@ Want to show me some ❤️ for the hard work I do on this gem? You can use the
 
 ## Introduction
 
-This gem adds unique constraints to sidekiq jobs. The uniqueness is achieved by creating a set of keys in redis based off of `queue`, `class`, `args` (in the sidekiq job hash).
+This gem adds unique constraints to Sidekiq jobs. The uniqueness is achieved by creating a set of keys in redis based off of `queue`, `class`, `args` (in the Sidekiq job hash).
 
 By default, only one lock for a given hash can be acquired. What happens when a lock can't be acquired is governed by a chosen [Conflict Strategy](#conflict-strategy) strategy. Unless a conflict strategy is chosen (?)
 
@@ -108,7 +109,7 @@ Here are links to some of the old versions
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'sidekiq-unique-jobs'
+gem "sidekiq-unique-jobs"
 ```
 
 And then execute:
@@ -153,7 +154,7 @@ end
 
 ### Your first worker
 
-The lock type most likely to be is `:until_executed`. This type of lock creates a lock from when `UntilExecutedWorker.perform_async` is called until right after `UntilExecutedWorker.new.perform` has been called.
+The lock type most likely to be used is `:until_executed`. This type of lock creates a lock from when `UntilExecutedWorker.perform_async` is called until right after `UntilExecutedWorker.new.perform` has been called.
 
 ```ruby
 # frozen_string_literal: true
@@ -184,7 +185,7 @@ You can read more about the worker configuration in [Worker Configuration](#work
 - [ActiveJob officially not supported][48]
 - [redis-namespace officially not supported][49]
 
-See [Sidekiq requirements][24] for detailed requirements of Sidekiq itself (be sure to check the right sidekiq version).
+See [Sidekiq requirements][24] for detailed requirements of Sidekiq itself (be sure to check the right `sidekiq` version).
 
 ## Locks
 
@@ -196,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
 
@@ -218,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
 
@@ -236,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
@@ -254,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,
@@ -276,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,
@@ -347,7 +348,7 @@ Please not that if you try to override a default lock, an `ArgumentError` will b
 
 ## Conflict Strategy
 
-Decides how we handle conflict. We can either `reject` the job to the dead queue or `reschedule` it. Both are useful for jobs that absolutely need to run and have been configured to use the lock `WhileExecuting` that is used only by the sidekiq server process.
+Decides how we handle conflict. We can either `reject` the job to the dead queue or `reschedule` it. Both are useful for jobs that absolutely need to run and have been configured to use the lock `WhileExecuting` that is used only by the Sidekiq server process.
 
 Furthermore, `log` can be be used with the lock `UntilExecuted` and `UntilExpired`. Now we write a log entry saying the job could not be pushed because it is a duplicate of another job with the same arguments.
 
@@ -401,7 +402,7 @@ always scheduled in the future. Currently only attempting to retry one time.
 sidekiq_options on_conflict: :reschedule
 ```
 
-This strategy is intended to be used with `WhileExecuting` and will delay the job to be tried again in 5 seconds. This will mess up the sidekiq stats but will prevent exceptions from being logged and confuse your sysadmins.
+This strategy is intended to be used with `WhileExecuting` and will delay the job to be tried again in 5 seconds (this delay can be configured via `sidekiq_options schedule_in: {seconds}`). This will mess up the Sidekiq stats but will prevent exceptions from being logged and confuse your sysadmins.
 
 ### Custom Strategies
 
@@ -440,12 +441,12 @@ Please not that if you try to override a default lock, an `ArgumentError` will b
 
 ### 3 Cleanup Dead Locks
 
-For sidekiq versions < 5.1 a `sidekiq_retries_exhausted` block is required per worker class. This is deprecated in Sidekiq 6.0
+For `sidekiq` versions < 5.1 a `sidekiq_retries_exhausted` block is required per worker class. This is deprecated in Sidekiq 6.0
 
 ```ruby
 class MyWorker
   sidekiq_retries_exhausted do |msg, _ex|
-    digest = msg['lock_digest']
+    digest = msg["lock_digest"]
     SidekiqUniqueJobs::Digests.new.delete_by_digest(digest) if digest
   end
 end
@@ -456,7 +457,7 @@ Starting in v5.1, Sidekiq can also fire a global callback when a job dies: In ve
 ```ruby
 Sidekiq.configure_server do |config|
   config.death_handlers << ->(job, _ex) do
-    digest = job['lock_digest']
+    digest = job["lock_digest"]
     SidekiqUniqueJobs::Digests.new.delete_by_digest(digest) if digest
   end
 end
@@ -472,11 +473,11 @@ To use the web extension you need to require it in your routes.
 
 ```ruby
 #app/config/routes.rb
-require 'sidekiq_unique_jobs/web'
-mount Sidekiq::Web, at: '/sidekiq'
+require "sidekiq_unique_jobs/web"
+mount Sidekiq::Web, at: "/sidekiq"
 ```
 
-There is no need to `require 'sidekiq/web'` since `sidekiq_unique_jobs/web`
+There is no need to `require "sidekiq/web"` since `sidekiq_unique_jobs/web`
 already does this.
 
 To filter/search for keys we can use the wildcard `*`. If we have a unique digest `'uniquejobs:9e9b5ce5d423d3ea470977004b50ff84` we can search for it by enter `*ff84` and it should return all digests that end with `ff84`.
@@ -490,10 +491,10 @@ To setup reflections for logging or metrics, use the following API:
 ```ruby
 
 def extract_log_from_job(message, job_hash)
-  worker    = job_hash['class']
-  args      = job_hash['args']
-  lock_args = job_hash['lock_args']
-  queue     = job_hash['queue']
+  worker    = job_hash["class"]
+  args      = job_hash["args"]
+  lock_args = job_hash["lock_args"]
+  queue     = job_hash["queue"]
   {
     message: message,
     worker: worker,
@@ -505,7 +506,7 @@ end
 
 SidekiqUniqueJobs.reflect do |on|
   on.lock_failed do |job_hash|
-    message = extract_log_from_job('Lock Failed', job_hash)
+    message = extract_log_from_job("Lock Failed", job_hash)
     Sidekiq.logger.warn(message)
   end
 end
@@ -555,7 +556,7 @@ Also mostly useful for reporting purposes. The job was successfully unlocked.
 
 #### unknown_sidekiq_worker
 
-The reason this happens is that the server couldn't find a valid sidekiq worker class. Most likely, that worker isn't intended to be processed by this sidekiq server instance.
+The reason this happens is that the server couldn't find a valid Sidekiq worker class. Most likely, that worker isn't intended to be processed by this Sidekiq server instance.
 
 ### Show Locks
 
@@ -603,7 +604,7 @@ assert_raise(InvalidWorker){ SidekiqUniqueJobs.validate_worker!(BadWorker.get_si
 
 ### Uniqueness
 
-This has been probably the most confusing part of this gem. People get really confused with how unreliable the unique jobs have been. I there for decided to do what Mike is doing for sidekiq enterprise. Read the section about unique jobs: [Enterprise unique jobs][](?)
+This has been probably the most confusing part of this gem. People get really confused with how unreliable the unique jobs have been. I therefore decided to do what Mike is doing for Sidekiq Enterprise. Read the section about unique jobs: [Enterprise unique jobs][](?)
 
 ```ruby
 SidekiqUniqueJobs.configure do |config|
@@ -612,7 +613,7 @@ SidekiqUniqueJobs.configure do |config|
 end
 ```
 
-If you truly wanted to test the sidekiq client push you could do something like below. Note that it will only work for the jobs that lock when the client pushes the job to redis (UntilExecuted, UntilAndWhileExecuting and UntilExpired).
+If you truly wanted to test the `sidekiq` client push you could do something like below. Note that it will only work for the jobs that lock when the client pushes the job to redis (UntilExecuted, UntilAndWhileExecuting and UntilExpired).
 
 ```ruby
 require "sidekiq_unique_jobs/testing"
@@ -624,7 +625,7 @@ RSpec.describe Workers::CoolOne do
 
   # ... your tests that don't test uniqueness
 
-  context 'when Sidekiq::Testing.disabled?' do
+  context "when Sidekiq::Testing.disabled?" do
     before do
       Sidekiq::Testing.disable!
       Sidekiq.redis(&:flushdb)
@@ -634,7 +635,7 @@ RSpec.describe Workers::CoolOne do
       Sidekiq.redis(&:flushdb)
     end
 
-    it 'prevents duplicate jobs from being scheduled' do
+    it "prevents duplicate jobs from being scheduled" do
       SidekiqUniqueJobs.use_config(enabled: true) do
         expect(described_class.perform_in(3600, 1)).not_to eq(nil)
         expect(described_class.perform_async(1)).to eq(nil)
@@ -734,17 +735,29 @@ Configure SidekiqUniqueJobs in an initializer or the sidekiq initializer on appl
 
 ```ruby
 SidekiqUniqueJobs.configure do |config|
-  config.logger = Sidekiq.logger # default, change at your own discretion
-  config.logger_enabled  = true # default, disable for test environments
-  config.debug_lua       = false # Turn on when debugging
-  config.lock_info       = false # Turn on when debugging
-  config.lock_ttl        = 600   # Expire locks after 10 minutes
-  config.lock_timeout    = nil   # turn off lock timeout
-  config.max_history     = 0     # Turn on when debugging
-  config.reaper          = :ruby # :ruby, :lua or :none/nil
-  config.reaper_count    = 1000  # Stop reaping after this many keys
-  config.reaper_interval = 600   # Reap orphans every 10 minutes
-  config.reaper_timeout  = 150   # Timeout reaper after 2.5 minutes
+  config.logger = Sidekiq.logger    # default, change at your own discretion
+  config.logger_enabled   = true    # default, disable for test environments
+  config.debug_lua        = false   # Turn on when debugging
+  config.lock_info        = false   # Turn on when debugging
+  config.lock_ttl         = 600     # Expire locks after 10 minutes
+  config.lock_timeout     = nil     # turn off lock timeout
+  config.max_history      = 0       # Turn on when debugging
+  config.reaper           = :ruby   # :ruby, :lua or :none/nil
+  config.reaper_count     = 1000    # Stop reaping after this many keys
+  config.reaper_interval  = 600     # Reap orphans every 10 minutes
+  config.reaper_timeout   = 150     # Timeout reaper after 2.5 minutes
+  config.digest_algorithm = :modern # Timeout reaper after 2.5 minutes
+end
+```
+#### digest_algorithm
+
+For backwards compatibility this one is set to `:legacy` by the default. If you happen to run into issues with FIPS being enabled on your redis server you might want to set this to `:modern`.
+
+See: https://github.com/mhenrixon/sidekiq-unique-jobs/issues/848 for explanation
+
+```ruby
+SidekiqUniqueJobs.configure do |config|
+  config.digest_algorithm = :modern # Timeout reaper after 2.5 minutes
 end
 ```
 
@@ -762,7 +775,7 @@ Turning on debug_lua will allow the lua scripts to output debug information abou
 SidekiqUniqueJobs.config.lock_timeout #=> 0
 ```
 
-Set a global lock_timeout to use for all jobs that don't otherwise specify a lock_timeout.
+Set a global lock_timeout (in seconds) to use for all jobs that don't otherwise specify a lock_timeout.
 
 Lock timeout decides how long to wait for acquiring the lock. A value of nil means to wait indefinitely for a lock resource to become available.
 
@@ -772,7 +785,7 @@ Lock timeout decides how long to wait for acquiring the lock. A value of nil mea
 SidekiqUniqueJobs.config.lock_ttl #=> nil
 ```
 
-Set a global lock_ttl to use for all jobs that don't otherwise specify a lock_ttl.
+Set a global lock_ttl (in seconds) to use for all jobs that don't otherwise specify a lock_ttl.
 
 Lock TTL decides how long to wait at most before considering a lock to be expired and making it possible to reuse that lock.
 
@@ -808,7 +821,7 @@ This is a log that can be accessed by a lock to see what happened for that lock.
 SidekiqUniqueJobs.config.reaper #=> :ruby
 ```
 
-If using the orphans cleanup process it is critical to be aware of the following. The `:ruby` job is much slower but the `:lua` job locks redis while executing. While doing intense processing it is best to avoid locking redis with a lua script. There for the batch size (controlled by the `reaper_count` setting) needs to be reduced.
+If using the orphans cleanup process it is critical to be aware of the following. The `:ruby` job is much slower but the `:lua` job locks redis while executing. While doing intense processing it is best to avoid locking redis with a lua script. Therefore the batch size (controlled by the `reaper_count` setting) needs to be reduced.
 
 In my benchmarks deleting 1000 orphaned locks with lua performs around 65% faster than deleting 1000 keys in ruby.
 
@@ -913,13 +926,13 @@ This is mainly intended for `Worker.set(queue: :another).perform_async`.
 class Worker
   include Sidekiq::Worker
 
-  sidekiq_options unique_across_queues: true, queue: 'default'
+  sidekiq_options unique_across_queues: true, queue: "default"
 
   def perform(args); end
 end
 ```
 
-Now if you push override the queue with `Worker.set(queue: 'another').perform_async(1)` it will still be considered unique when compared to `Worker.perform_async(1)` (that was actually pushed to the queue `default`).
+Now if you push override the queue with `Worker.set(queue: "another").perform_async(1)` it will still be considered unique when compared to `Worker.perform_async(1)` (that was actually pushed to the queue `default`).
 
 #### unique_across_workers
 
@@ -929,7 +942,7 @@ This configuration option is slightly misleading. It doesn't disregard the worke
 class WorkerOne
   include Sidekiq::Worker
 
-  sidekiq_options unique_across_workers: true, queue: 'default'
+  sidekiq_options unique_across_workers: true, queue: "default"
 
   def perform(args); end
 end
@@ -937,14 +950,14 @@ end
 class WorkerTwo
   include Sidekiq::Worker
 
-  sidekiq_options unique_across_workers: true, queue: 'default'
+  sidekiq_options unique_across_workers: true, queue: "default"
 
   def perform(args); end
 end
 
 
 WorkerOne.perform_async(1)
-# => 'the jobs unique id'
+# => "the jobs unique id"
 
 WorkerTwo.perform_async(1)
 # => nil because WorkerOne just stole the lock
@@ -1036,7 +1049,7 @@ There is a [![Join the chat at https://gitter.im/mhenrixon/sidekiq-unique-jobs](
 
 1. Fork it
 1. Create your feature branch (`git checkout -b my-new-feature`)
-1. Commit your changes (`git commit -am 'Add some feature'`)
+1. Commit your changes (`git commit -am "Add some feature"`)
 1. Push to the branch (`git push origin my-new-feature`)
 1. Create new Pull Request
 

data/lib/sidekiq_unique_jobs/cli.rb

@@ -12,7 +12,7 @@ module SidekiqUniqueJobs
     # :nodoc:
     # rubocop:disable Style/OptionalBooleanParameter
     def self.banner(command, _namespace = nil, _subcommand = false) # rubocop:disable Style/OptionalBooleanParameter
-      "jobs #{@package_name} #{command.usage}" # rubocop:disable ThreadSafety/InstanceVariableInClassMethod
+      "jobs #{@package_name} #{command.usage}" # rubocop:disable ThreadSafety/ClassInstanceVariable
     end
     # rubocop:enable Style/OptionalBooleanParameter
 
@@ -51,7 +51,7 @@ module SidekiqUniqueJobs
       console_class.start
     end
 
-    no_commands do # rubocop:disable Metrics/BlockLength
+    no_commands do
       # :nodoc:
       def digests
         @digests ||= SidekiqUniqueJobs::Digests.new

data/lib/sidekiq_unique_jobs/config.rb

@@ -2,33 +2,39 @@
 
 module SidekiqUniqueJobs
   # ThreadSafe config exists to be able to document the config class without errors
-  ThreadSafeConfig = Concurrent::MutableStruct.new("ThreadSafeConfig",
-                                                   :lock_timeout,
-                                                   :lock_ttl,
-                                                   :enabled,
-                                                   :lock_prefix,
-                                                   :logger,
-                                                   :logger_enabled,
-                                                   :locks,
-                                                   :strategies,
-                                                   :debug_lua,
-                                                   :max_history,
-                                                   :reaper,
-                                                   :reaper_count,
-                                                   :reaper_interval,
-                                                   :reaper_timeout,
-                                                   :reaper_resurrector_interval,
-                                                   :reaper_resurrector_enabled,
-                                                   :lock_info,
-                                                   :raise_on_config_error,
-                                                   :current_redis_version)
+  ThreadSafeConfig = Concurrent::MutableStruct.new(
+    "ThreadSafeConfig",
+    :lock_timeout,
+    :lock_ttl,
+    :enabled,
+    :lock_prefix,
+    :logger,
+    :logger_enabled,
+    :locks,
+    :strategies,
+    :debug_lua,
+    :max_history,
+    :reaper,
+    :reaper_count,
+    :reaper_interval,
+    :reaper_timeout,
+    :reaper_resurrector_interval,
+    :reaper_resurrector_enabled,
+    :lock_info,
+    :raise_on_config_error,
+    :current_redis_version,
+    :digest_algorithm,
+  )
 
   #
   # Shared class for dealing with gem configuration
   #
   # @author Mauro Berlanda <mauro.berlanda@gmail.com>
-  # rubocop:disable Metrics/ClassLength
   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 = {
@@ -118,11 +124,9 @@ module SidekiqUniqueJobs
     #
     # @return [3600] check if reaper is dead each 3600 seconds
     REAPER_RESURRECTOR_INTERVAL = 3600
-
     #
     # @return [false] enable reaper resurrector
     REAPER_RESURRECTOR_ENABLED = false
-
     #
     # @return [false] while useful it also adds overhead so disable lock_info by default
     USE_LOCK_INFO         = false
@@ -132,6 +136,9 @@ module SidekiqUniqueJobs
     #
     # @return [0.0.0] default redis version is only to avoid NoMethodError on nil
     REDIS_VERSION         = "0.0.0"
+    #
+    # @return [:legacy] default digest algorithm :modern or :legacy
+    DIGEST_ALGORITHM      = :legacy
 
     #
     # Returns a default configuration
@@ -177,7 +184,7 @@ module SidekiqUniqueJobs
     #
     # @return [SidekiqUniqueJobs::Config] a default configuration
     #
-    def self.default # rubocop:disable Metrics/MethodLength
+    def self.default
       new(
         LOCK_TIMEOUT,
         LOCK_TTL,
@@ -198,6 +205,7 @@ module SidekiqUniqueJobs
         USE_LOCK_INFO,
         RAISE_ON_CONFIG_ERROR,
         REDIS_VERSION,
+        DIGEST_ALGORITHM,
       )
     end
 
@@ -210,8 +218,8 @@ module SidekiqUniqueJobs
     # @return [<type>] <description>
     #
     def default_lock_ttl=(obj)
-      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated." \
-           " Please use `#{class_name}#lock_ttl=` instead."
+      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated. " \
+           "Please use `#{class_name}#lock_ttl=` instead."
       self.lock_ttl = obj
     end
 
@@ -224,8 +232,8 @@ module SidekiqUniqueJobs
     # @return [Integer]
     #
     def default_lock_timeout=(obj)
-      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated." \
-           " Please use `#{class_name}#lock_timeout=` instead."
+      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated. " \
+           "Please use `#{class_name}#lock_timeout=` instead."
       self.lock_timeout = obj
     end
 
@@ -236,8 +244,8 @@ module SidekiqUniqueJobs
     # @return [nil, Integer] configured value or nil
     #
     def default_lock_ttl
-      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated." \
-           " Please use `#{class_name}#lock_ttl` instead."
+      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated. " \
+           "Please use `#{class_name}#lock_ttl` instead."
       lock_ttl
     end
 
@@ -249,8 +257,8 @@ module SidekiqUniqueJobs
     # @return [nil, Integer] configured value or nil
     #
     def default_lock_timeout
-      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated." \
-           " Please use `#{class_name}#lock_timeout` instead."
+      warn "[DEPRECATION] `#{class_name}##{__method__}` is deprecated. " \
+           "Please use `#{class_name}#lock_timeout` instead."
       lock_timeout
     end
 
@@ -304,14 +312,38 @@ module SidekiqUniqueJobs
       self.strategies = new_strategies
     end
 
+    #
+    # Sets digest_algorithm to either :modern or :legacy
+    #
+    # @param [Symbol] value
+    #
+    # @return [Symbol] the new value
+    #
+    def digest_algorithm=(value)
+      unless [:modern, :legacy].include?(value)
+        raise ArgumentError, "Invalid digest algorithm: #{value} (should be :modern or :legacy)"
+      end
+
+      super
+    end
+
     #
     # 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