sidekiq-unique-jobs 8.0.10 → 8.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cd95f03398a1663b2afbba47f61736cfd3a0ab91fcc0d5b90d353d4f283db07
-  data.tar.gz: ced0a60e5fad52b5f2a66dcc29b10a221c6d39f4c4089d812327922d3b6b4e8b
+  metadata.gz: 752654a036faee8511674b89a3a50ac370f497c29499e3f1fd4dd466b3c5d344
+  data.tar.gz: 40fbc25bd5639f248d6b34817e820d6b7f096a559ed3e0059d28570137b86274
 SHA512:
-  metadata.gz: d72a8b181407ccc09e4f11c9d8f0860df65f80373c2064ec0f7d743d2bde4273cde1e117f2983b8f71b3a2c9f17c8b9ab8808395991030617bb6b380073457be
-  data.tar.gz: 2908759b402bff47b1ace5c9ab666a10779085c89b90c6261b4c935fde97cbf0f8291c8bf2df48e0b46c302eaa66f169785fdf0503ad97fcf0d43a0e0fd1b47d
+  metadata.gz: cfe83dfbe84eaac52440e1178acf19abfe08bcf4e65c7dc8c9013c315f5e19c57a68c104ded980997c8b5f88400e90175a60858eaede00295327917062a26035
+  data.tar.gz: 128852982336a1d363eebf9f597fb30209369e4ce4376bfefe630fdd56c2bd426be724921b4d6493ccb1406ad65ba1fae37c8085efbdb4fb37e2c2cdd660f9a1

data/CHANGELOG.md

@@ -1,12 +1,33 @@
 # 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:**
 
-- 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 +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:**
 
@@ -60,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)
 
@@ -68,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
 

data/lib/sidekiq_unique_jobs/lock_ttl.rb

@@ -66,12 +66,34 @@ 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])
+      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
@@ -243,7 +243,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,10 +251,10 @@ 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

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/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
@@ -197,7 +196,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?
@@ -253,7 +252,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

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/sidekiq_unique_ext.rb

@@ -60,7 +60,7 @@ module Sidekiq
       #
       def delete(score, job_id)
         entry = find_job(job_id)
-        SidekiqUniqueJobs::Unlockable.delete!(entry.item) if super(score, job_id)
+        SidekiqUniqueJobs::Unlockable.delete!(entry.item) if super
         entry
       end
     end
@@ -132,7 +132,7 @@ module Sidekiq
       # @param [String] value a sidekiq job hash
       #
       def delete_by_value(name, value)
-        SidekiqUniqueJobs::Unlockable.delete!(Sidekiq.load_json(value)) if super(name, value)
+        SidekiqUniqueJobs::Unlockable.delete!(Sidekiq.load_json(value)) if super
       end
     end
 

data/lib/sidekiq_unique_jobs/sidekiq_unique_jobs.rb

@@ -4,7 +4,7 @@
 # Contains configuration and utility methods that belongs top level
 #
 # @author Mikael Henriksson <mikael@mhenrixon.com>
-module SidekiqUniqueJobs # rubocop:disable Metrics/ModuleLength
+module SidekiqUniqueJobs
   include SidekiqUniqueJobs::Connection
   extend SidekiqUniqueJobs::JSON
 
@@ -17,7 +17,7 @@ module SidekiqUniqueJobs # rubocop:disable Metrics/ModuleLength
   # @return [SidekiqUniqueJobs::Config] the gem configuration
   #
   def config
-    @config ||= reset! # rubocop:disable ThreadSafety/InstanceVariableInClassMethod
+    @config ||= reset! # rubocop:disable ThreadSafety/ClassInstanceVariable
   end
 
   #
@@ -108,7 +108,7 @@ module SidekiqUniqueJobs # rubocop:disable Metrics/ModuleLength
   # @return [SidekiqUniqueJobs::Config] a default gem configuration
   #
   def reset!
-    @config = SidekiqUniqueJobs::Config.default # rubocop:disable ThreadSafety/InstanceVariableInClassMethod
+    @config = SidekiqUniqueJobs::Config.default # rubocop:disable ThreadSafety/ClassInstanceVariable
   end
 
   #
@@ -288,7 +288,7 @@ module SidekiqUniqueJobs # rubocop:disable Metrics/ModuleLength
   # @return [Reflections]
   #
   def reflections
-    @reflections ||= Reflections.new # rubocop:disable ThreadSafety/InstanceVariableInClassMethod
+    @reflections ||= Reflections.new # rubocop:disable ThreadSafety/ClassInstanceVariable
   end
 
   #

data/lib/sidekiq_unique_jobs/sidekiq_worker_methods.rb

@@ -39,7 +39,7 @@ module SidekiqUniqueJobs
 
     # The hook to call after a successful unlock
     # @return [Proc]
-    def after_unlock_hook # rubocop:disable Metrics/MethodLength
+    def after_unlock_hook
       lambda do
         if @original_job_class.respond_to?(:after_unlock)
           # instance method in sidekiq v6

data/lib/sidekiq_unique_jobs/testing.rb

@@ -21,7 +21,7 @@ module Sidekiq
   #
   # @param [Hash<Symbol, Object>] tmp_config the temporary config to use
   #
-  def self.use_options(tmp_config = {}) # rubocop:disable Metrics/MethodLength
+  def self.use_options(tmp_config = {})
     if respond_to?(:default_job_options)
       default_job_options.clear
       self.default_job_options = tmp_config
@@ -87,7 +87,7 @@ module Sidekiq
       def sidekiq_options(options = {})
         SidekiqUniqueJobs.validate_worker!(options) if SidekiqUniqueJobs.config.raise_on_config_error
 
-        super(options)
+        super
       end
 
       #

data/lib/sidekiq_unique_jobs/version.rb

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

data/lib/sidekiq_unique_jobs/web/helpers.rb

@@ -116,7 +116,7 @@ module SidekiqUniqueJobs
       #
       # @return a redirect to the new subpath
       #
-      def redirect_to(subpath)
+      def safe_redirect_to(subpath)
         if respond_to?(:to)
           # Sinatra-based web UI
           redirect to(subpath)
@@ -170,6 +170,34 @@ module SidekiqUniqueJobs
           Time.parse(time.to_s)
         end
       end
+
+      # Copied from sidekiq for compatibility with older versions
+
+      # stuff after ? or form input
+      # uses String keys, no Symbols!
+      def safe_url_params(key)
+        return url_params(key) if Sidekiq::MAJOR >= 8
+
+        if key.is_a?(Symbol)
+          warn do
+            "URL parameter `#{key}` should be accessed via String, not Symbol (at #{caller(3..3).first})"
+          end
+        end
+        request.params[key.to_s]
+      end
+
+      # variables embedded in path, `/metrics/:name`
+      # uses Symbol keys, no Strings!
+      def safe_route_params(key)
+        return route_params(key) if Sidekiq::MAJOR >= 8
+
+        if key.is_a?(String)
+          warn do
+            "Route parameter `#{key}` should be accessed via Symbol, not String (at #{caller(3..3).first})"
+          end
+        end
+        env["rack.route_params"][key.to_sym]
+      end
     end
   end
 end

data/lib/sidekiq_unique_jobs/web.rb

@@ -7,17 +7,15 @@ module SidekiqUniqueJobs
   # Useful for deleting keys that for whatever reason wasn't deleted
   # @author Mikael Henriksson <mikael@mhenrixon.com>
   module Web
-    def self.registered(app) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      app.helpers do
-        include Web::Helpers
-      end
+    def self.registered(app)
+      app.helpers Web::Helpers
 
       app.get "/changelogs" do
-        @filter         = h(params[:filter] || "*")
+        @filter         = h(safe_url_params("filter") || "*")
         @filter         = "*" if @filter == ""
-        @count          = h(params[:count] || 100).to_i
-        @current_cursor = h(params[:cursor]).to_i
-        @prev_cursor    = h(params[:prev_cursor]).to_i
+        @count          = h(safe_url_params("count") || 100).to_i
+        @current_cursor = h(safe_url_params("cursor")).to_i
+        @prev_cursor    = h(safe_url_params("prev_cursor")).to_i
         @total_size, @next_cursor, @changelogs = changelog.page(
           cursor: @current_cursor,
           pattern: @filter,
@@ -29,15 +27,15 @@ module SidekiqUniqueJobs
 
       app.get "/changelogs/delete_all" do
         changelog.clear
-        redirect_to :changelogs
+        safe_redirect_to :changelogs
       end
 
       app.get "/locks" do
-        @filter         = h(params[:filter]) || "*"
+        @filter         = h(safe_url_params("filter") || "*")
         @filter         = "*" if @filter == ""
-        @count          = h(params[:count] || 100).to_i
-        @current_cursor = h(params[:cursor]).to_i
-        @prev_cursor    = h(params[:prev_cursor]).to_i
+        @count          = h(safe_url_params("count") || 100).to_i
+        @current_cursor = h(safe_url_params("cursor")).to_i
+        @prev_cursor    = h(safe_url_params("prev_cursor")).to_i
 
         @total_size, @next_cursor, @locks = digests.page(
           cursor: @current_cursor,
@@ -49,11 +47,11 @@ module SidekiqUniqueJobs
       end
 
       app.get "/expiring_locks" do
-        @filter         = h(params[:filter]) || "*"
+        @filter         = h(safe_url_params("filter") || "*")
         @filter         = "*" if @filter == ""
-        @count          = h(params[:count] || 100).to_i
-        @current_cursor = h(params[:cursor]).to_i
-        @prev_cursor    = h(params[:prev_cursor]).to_i
+        @count          = h(safe_url_params("count") || 100).to_i
+        @current_cursor = h(safe_url_params("cursor")).to_i
+        @prev_cursor    = h(safe_url_params("prev_cursor")).to_i
 
         @total_size, @next_cursor, @locks = expiring_digests.page(
           cursor: @current_cursor,
@@ -67,29 +65,29 @@ module SidekiqUniqueJobs
       app.get "/locks/delete_all" do
         digests.delete_by_pattern("*", count: digests.count)
         expiring_digests.delete_by_pattern("*", count: digests.count)
-        redirect_to :locks
+        safe_redirect_to :locks
       end
 
       app.get "/locks/:digest" do
-        @digest = h(params[:digest])
+        @digest = h(safe_route_params(:digest))
         @lock   = SidekiqUniqueJobs::Lock.new(@digest)
 
         erb(unique_template(:lock))
       end
 
       app.get "/locks/:digest/delete" do
-        digests.delete_by_digest(h(params[:digest]))
-        expiring_digests.delete_by_digest(h(params[:digest]))
-        redirect_to :locks
+        digests.delete_by_digest(h(safe_route_params(:digest)))
+        expiring_digests.delete_by_digest(h(safe_route_params(:digest)))
+        safe_redirect_to :locks
       end
 
       app.get "/locks/:digest/jobs/:job_id/delete" do
-        @digest = h(params[:digest])
-        @job_id = h(params[:job_id])
+        @digest = h(safe_route_params(:digest))
+        @job_id = h(safe_route_params(:job_id))
         @lock   = SidekiqUniqueJobs::Lock.new(@digest)
         @lock.unlock(@job_id)
 
-        redirect_to "locks/#{@lock.key}"
+        safe_redirect_to "locks/#{@lock.key}"
       end
     end
   end
@@ -99,11 +97,21 @@ begin
   require "delegate" unless defined?(DelegateClass)
   require "sidekiq/web" unless defined?(Sidekiq::Web)
 
-  Sidekiq::Web.register(SidekiqUniqueJobs::Web)
-  Sidekiq::Web.tabs["Locks"]          = "locks"
-  Sidekiq::Web.tabs["Expiring Locks"] = "expiring_locks"
-  Sidekiq::Web.tabs["Changelogs"]     = "changelogs"
-  Sidekiq::Web.settings.locales << File.join(File.dirname(__FILE__), "locales")
+  if Sidekiq::MAJOR >= 8
+    Sidekiq::Web.configure do |config|
+      config.register_extension(
+        SidekiqUniqueJobs::Web,
+        name: "unique_jobs",
+        tab: ["Locks", "Expiring Locks", "Changelogs"],
+        index: %w[locks/ expiring_locks/ changelogs/],
+      )
+    end
+  else
+    Sidekiq::Web.register(SidekiqUniqueJobs::Web)
+    Sidekiq::Web.tabs["Locks"]          = "locks"
+    Sidekiq::Web.tabs["Expiring Locks"] = "expiring_locks"
+    Sidekiq::Web.tabs["Changelogs"]     = "changelogs"
+  end
 rescue NameError, LoadError => ex
   SidekiqUniqueJobs.logger.error(ex)
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-unique-jobs
 version: !ruby/object:Gem::Version
-  version: 8.0.10
+  version: 8.0.11
 platform: ruby
 authors:
 - Mikael Henriksson
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-22 00:00:00.000000000 Z
+date: 2025-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -39,7 +38,7 @@ dependencies:
         version: 7.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 8.0.0
+        version: 9.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -49,7 +48,7 @@ dependencies:
         version: 7.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 8.0.0
+        version: 9.0.0
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -208,7 +207,6 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -223,8 +221,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Sidekiq middleware that prevents duplicates jobs
 test_files: []