sidekiq-unique-jobs 8.0.9 → 8.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de442ce815fcfc00992295bd4160cfcf122815282e652cccca8c73ce1e62b351
-  data.tar.gz: f01d32c217f81f41abf34666c43acdddcb8148e6f7ca0df8146d408f9ed14f8e
+  metadata.gz: 752654a036faee8511674b89a3a50ac370f497c29499e3f1fd4dd466b3c5d344
+  data.tar.gz: 40fbc25bd5639f248d6b34817e820d6b7f096a559ed3e0059d28570137b86274
 SHA512:
-  metadata.gz: aec1ab15a3a3c1959bc137aaad674fa9e0854ca354b2226c352901f4d7d7c9cc6c8ef8d805b3b1ad680672eebca52a332de916a5e10d5f4d8b7b439bb677c7c0
-  data.tar.gz: 9af5d9ce6dda38757fb33aa33d86c337cd40751fc55bad37ad5c3f98cb04225209953843b7ec137e9295b8da2c2a40a640c7735f1d623c17851621b577b7a03e
+  metadata.gz: cfe83dfbe84eaac52440e1178acf19abfe08bcf4e65c7dc8c9013c315f5e19c57a68c104ded980997c8b5f88400e90175a60858eaede00295327917062a26035
+  data.tar.gz: 128852982336a1d363eebf9f597fb30209369e4ce4376bfefe630fdd56c2bd426be724921b4d6493ccb1406ad65ba1fae37c8085efbdb4fb37e2c2cdd660f9a1

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [Unreleased](https://github.com/mhenrixon/sidekiq-unique-jobs/tree/HEAD)
+
+[Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v8.0.10...HEAD)
+
+**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))
+
+## [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)
+
+## [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:**
+
+- 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)
 
 [Full Changelog](https://github.com/mhenrixon/sidekiq-unique-jobs/compare/v8.0.7...v8.0.8)
@@ -41,7 +71,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:**
 
@@ -51,7 +81,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)
 
@@ -59,6 +88,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)

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
 
@@ -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,32 +2,34 @@
 
 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
     #
     # @return [Hash<Symbol, SidekiqUniqueJobs::Lock::BaseLock] all available queued locks
@@ -118,11 +120,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 +132,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 +180,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 +201,7 @@ module SidekiqUniqueJobs
         USE_LOCK_INFO,
         RAISE_ON_CONFIG_ERROR,
         REDIS_VERSION,
+        DIGEST_ALGORITHM,
       )
     end
 
@@ -210,8 +214,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 +228,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 +240,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 +253,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,6 +308,21 @@ 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
     #

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/lock/base_lock.rb

@@ -147,7 +147,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/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