sidekiq 8.0.5 → 8.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6b95635fb1084ed28d8b6dd5f7d273873e24ffab09aeb5057de74d4bebeae07
-  data.tar.gz: bba44aed090637fb4991ae3935112b84b33df8b7281c9d0f273f0146ea11415a
+  metadata.gz: 3a1e8c90888b4135f21e4dfef66fd9ad9ac8c72ab267599a8452f4bd172234a2
+  data.tar.gz: fa83e70c818fc3b25441e946c1a093a2d9a5f4515ee2bd88522cbafcb8097973
 SHA512:
-  metadata.gz: 657b2d2f1e1c850779d29990c88227d7776f8e5a4b3333fd7b2e5f249fb360a1f69de40a773dc5b608ae37ff249713af5aa5b38cd04da2ceffe64f79578861a3
-  data.tar.gz: a8d8d6f32921b00341dc8910155b8a85d6c036bc31a69437dde3f5107d02bed5ffb2b0754f014eaf69f577570e91455a7ead03367cf43fe0b24ef2650e9f57be
+  metadata.gz: 0ea8ac9585538723d941af6ce9150933669705cf1e3459dcea8989d073d234c4e233e74314a5a682e3111e1290a69671051e847b5ee97970c1edd08293e14bbc
+  data.tar.gz: 0b253cd035132f786613fbb97440f5d16f48717aedaa7f50865e0e261ce0fc17b64885bea3cdeb5aabe72258c06ed013891d83655bdcf842fc1a261d1b0aa985

data/Changes.md

@@ -2,6 +2,45 @@
 
 [Sidekiq Changes](https://github.com/sidekiq/sidekiq/blob/main/Changes.md) | [Sidekiq Pro Changes](https://github.com/sidekiq/sidekiq/blob/main/Pro-Changes.md) | [Sidekiq Enterprise Changes](https://github.com/sidekiq/sidekiq/blob/main/Ent-Changes.md)
 
+8.0.8
+----------
+
+- Allow an optional global iteration max runtime. After executing for this length of time,
+  Sidekiq will re-queue the job to continue execution at a later time [#6819, fatkodima]
+```ruby
+Sidekiq.configure_server do |cfg|
+  cfg[:max_iteration_runtime] = 600 # ten minutes
+end
+```
+- Add `discarded_at` attribute when discarding a job so death handlers can distinguish between
+  a job which was killed and one that was discarded. [#6820, gstokkink]
+- `perform_bulk` now accepts an `:at` array of times to schedule each job at the corresponding time.
+  `perform_bulk(args: [[1], [2]], at: [Time.now, Time.now + 1])` [#6790, fatkodima]
+- `perform_bulk` now accepts a `:spread_interval` value to schedule jobs over
+  the next N seconds. `perform_bulk(..., spread_interval: 60)` [#6792, fatkodima]
+- Fix unintended display of flash messages in the Web UI due to session key collision
+- Add support for lazy load hooks [#6825]
+
+8.0.7
+----------
+
+- The `:discard` option for `sidekiq_retries_exhausted` and `sidekiq_retry_in`
+  now calls death handlers, otherwise it could break other Sidekiq
+  functionality. [#6741]
+- Provide a Plain log formatter which does not colorize output [#6778]
+- Job iteration now exposes `current_object` for easy access within the `around_iteration` callback [#6774]
+- Fix JS race condition which could skip confirmation dialogs when Live Polling [#6768]
+- Fix edge case which could lose CurrentAttributes [#6767]
+- Update UK locale [#6776]
+
+8.0.6
+----------
+
+- Adjust transactional client to use ActiveRecord 7.2's support for
+  `after_all_transactions_commit` when available. [#6765, rewritten]
+- Fix Rails 7.0 and 7.1 compatibility [#6746, mlarraz]
+- Flush metrics at `:exit` [#6764]
+
 8.0.5
 ----------
 

data/lib/active_job/queue_adapters/sidekiq_adapter.rb

@@ -43,7 +43,8 @@ begin
       # To use Sidekiq set the queue_adapter config to +:sidekiq+.
       #
       #   Rails.application.config.active_job.queue_adapter = :sidekiq
-      class SidekiqAdapter < AbstractAdapter
+      parent = const_defined?(:AbstractAdapter) ? AbstractAdapter : Object
+      class SidekiqAdapter < parent
         @@stopping = false
 
         callback = -> { @@stopping = true }

data/lib/sidekiq/api.rb

@@ -1168,7 +1168,6 @@ module Sidekiq
   #      # thread_id is a unique identifier per thread
   #      # work is a `Sidekiq::Work` instance that has the following accessor methods.
   #      # [work.queue, work.run_at, work.payload]
-  #      # run_at is an epoch Integer.
   #    end
   #
   class WorkSet
@@ -1322,3 +1321,5 @@ module Sidekiq
     end
   end
 end
+
+Sidekiq.loader.run_load_hooks(:api)

data/lib/sidekiq/client.rb

@@ -117,6 +117,9 @@ module Sidekiq
     # larger than 1000 but YMMV based on network quality, size of job args, etc.
     # A large number of jobs can cause a bit of Redis command processing latency.
     #
+    # Accepts an additional `:spread_interval` option (in seconds) to randomly spread
+    # the jobs schedule times over the specified interval.
+    #
     # Takes the same arguments as #push except that args is expected to be
     # an Array of Arrays.  All other keys are duplicated for each job.  Each job
     # is run through the client middleware pipeline and each job gets its own Job ID
@@ -131,13 +134,24 @@ module Sidekiq
     def push_bulk(items)
       batch_size = items.delete(:batch_size) || items.delete("batch_size") || 1_000
       args = items["args"]
-      at = items.delete("at")
+      at = items.delete("at") || items.delete(:at)
       raise ArgumentError, "Job 'at' must be a Numeric or an Array of Numeric timestamps" if at && (Array(at).empty? || !Array(at).all? { |entry| entry.is_a?(Numeric) })
       raise ArgumentError, "Job 'at' Array must have same size as 'args' Array" if at.is_a?(Array) && at.size != args.size
 
       jid = items.delete("jid")
       raise ArgumentError, "Explicitly passing 'jid' when pushing more than one job is not supported" if jid && args.size > 1
 
+      spread_interval = items.delete(:spread_interval) || items.delete("spread_interval")
+      raise ArgumentError, "Jobs 'spread_interval' must be a positive Numeric" if spread_interval && (!spread_interval.is_a?(Numeric) || spread_interval <= 0)
+      raise ArgumentError, "Only one of 'at' or 'spread_interval' can be provided" if at && spread_interval
+
+      if !at && spread_interval
+        # Do not use spread interval smaller than pooling interval.
+        spread_interval = [spread_interval, 5].max
+        now = Time.now.to_f
+        at = args.map { now + rand * spread_interval }
+      end
+
       normed = normalize_item(items)
       slice_index = 0
       result = args.each_slice(batch_size).flat_map do |slice|

data/lib/sidekiq/component.rb

@@ -19,7 +19,8 @@ module Sidekiq
   DEFAULT_THREAD_PRIORITY = -1
 
   ##
-  # Sidekiq::Component assumes a config instance is available at @config
+  # Sidekiq::Component provides a set of utility methods depending only
+  # on Sidekiq::Config. It assumes a config instance is available at @config.
   module Component # :nodoc:
     attr_reader :config
 

data/lib/sidekiq/config.rb

@@ -17,10 +17,9 @@ module Sidekiq
       poll_interval_average: nil,
       average_scheduled_poll_interval: 5,
       on_complex_arguments: :raise,
-      iteration: {
-        max_job_runtime: nil,
-        retry_backoff: 0
-      },
+      # if the Iterable job runs longer than this value (in seconds), then the job
+      # will be interrupted after the current iteration and re-enqueued at the back of the queue
+      max_iteration_runtime: nil,
       error_handlers: [],
       death_handlers: [],
       lifecycle_events: {

data/lib/sidekiq/job/iterable.rb

@@ -32,8 +32,14 @@ module Sidekiq
         @_runtime = 0
         @_args = nil
         @_cancelled = nil
+        @current_object = nil
       end
 
+      # Access to the current object while iterating.
+      # This value is not reset so the latest element is
+      # explicitly available to cleanup/complete callbacks.
+      attr_reader :current_object
+
       def arguments
         @_args
       end
@@ -137,7 +143,7 @@ module Sidekiq
         fetch_previous_iteration_state
 
         @_executions += 1
-        @_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        @_start_time = mono_now
 
         enumerator = build_enumerator(*args, cursor: @_cursor)
         unless enumerator
@@ -198,16 +204,17 @@ module Sidekiq
 
         time_limit = Sidekiq.default_configuration[:timeout]
         found_record = false
-        state_flushed_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        state_flushed_at = mono_now
 
         enumerator.each do |object, cursor|
           found_record = true
           @_cursor = cursor
+          @current_object = object
 
-          is_interrupted = interrupted?
-          if ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - state_flushed_at >= STATE_FLUSH_INTERVAL || is_interrupted
+          interrupt_job = interrupted? || should_interrupt?
+          if mono_now - state_flushed_at >= STATE_FLUSH_INTERVAL || interrupt_job
             _, _, cancelled = flush_state
-            state_flushed_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+            state_flushed_at = mono_now
             if cancelled
               @_cancelled = true
               on_cancel
@@ -216,9 +223,9 @@ module Sidekiq
             end
           end
 
-          return false if is_interrupted
+          return false if interrupt_job
 
-          verify_iteration_time(time_limit, object) do
+          verify_iteration_time(time_limit) do
             around_iteration do
               each_iteration(object, *arguments)
             rescue Exception
@@ -231,16 +238,16 @@ module Sidekiq
         logger.debug("Enumerator found nothing to iterate!") unless found_record
         true
       ensure
-        @_runtime += (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @_start_time)
+        @_runtime += (mono_now - @_start_time)
       end
 
-      def verify_iteration_time(time_limit, object)
-        start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      def verify_iteration_time(time_limit)
+        start = mono_now
         yield
-        finish = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        finish = mono_now
         total = finish - start
         if total > time_limit
-          logger.warn { "Iteration took longer (%.2f) than Sidekiq's shutdown timeout (%d) when processing `%s`. This can lead to job processing problems during deploys" % [total, time_limit, object] }
+          logger.warn { "Iteration took longer (%.2f) than Sidekiq's shutdown timeout (%d). This can lead to job processing problems during deploys" % [total, time_limit] }
         end
       end
 
@@ -266,6 +273,11 @@ module Sidekiq
         end
       end
 
+      def should_interrupt?
+        max_iteration_runtime = Sidekiq.default_configuration[:max_iteration_runtime]
+        max_iteration_runtime && (mono_now - @_start_time > max_iteration_runtime)
+      end
+
       def flush_state
         key = iteration_key
         state = {
@@ -301,6 +313,10 @@ module Sidekiq
           raise "Unexpected thrown value: #{completed.inspect}"
         end
       end
+
+      def mono_now
+        ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      end
     end
   end
 end

data/lib/sidekiq/job.rb

@@ -248,9 +248,9 @@ module Sidekiq
       end
       alias_method :perform_sync, :perform_inline
 
-      def perform_bulk(args, batch_size: 1_000)
+      def perform_bulk(args, **options)
         client = @klass.build_client
-        client.push_bulk(@opts.merge("class" => @klass, "args" => args, :batch_size => batch_size))
+        client.push_bulk(@opts.merge({"class" => @klass, "args" => args}, options))
       end
 
       # +interval+ must be a timestamp, numeric or something that acts

data/lib/sidekiq/job_logger.rb

@@ -27,7 +27,7 @@ module Sidekiq
       # attribute to expose the underlying thing.
       h = {
         jid: job_hash["jid"],
-        class: job_hash["display_class"] || job_hash["wrapped"] || job_hash["class"]
+        class: job_hash["wrapped"] || job_hash["class"]
       }
       h[:bid] = job_hash["bid"] if job_hash.has_key?("bid")
       h[:tags] = job_hash["tags"] if job_hash.has_key?("tags")

data/lib/sidekiq/job_retry.rb

@@ -186,7 +186,9 @@ module Sidekiq
       strategy, delay = delay_for(jobinst, count, exception, msg)
       case strategy
       when :discard
-        return # poof!
+        msg["discarded_at"] = now_ms
+
+        return run_death_handlers(msg, exception)
       when :kill
         return retries_exhausted(jobinst, msg, exception)
       end
@@ -255,13 +257,22 @@ module Sidekiq
         handle_exception(e, {context: "Error calling retries_exhausted", job: msg})
       end
 
-      return if rv == :discard # poof!
-      send_to_morgue(msg) unless msg["dead"] == false
+      discarded = msg["dead"] == false || rv == :discard
+
+      if discarded
+        msg["discarded_at"] = now_ms
+      else
+        send_to_morgue(msg)
+      end
+
+      run_death_handlers(msg, exception)
+    end
 
+    def run_death_handlers(job, exception)
       @capsule.config.death_handlers.each do |handler|
-        handler.call(msg, exception)
+        handler.call(job, exception)
       rescue => e
-        handle_exception(e, {context: "Error calling death handler", job: msg})
+        handle_exception(e, {context: "Error calling death handler", job: job})
       end
     end
 

data/lib/sidekiq/loader.rb

@@ -0,0 +1,57 @@
+module Sidekiq
+  require "sidekiq/component"
+
+  class Loader
+    include Sidekiq::Component
+
+    def initialize(cfg = Sidekiq.default_configuration)
+      @config = cfg
+      @load_hooks = Hash.new { |h, k| h[k] = [] }
+      @loaded = Set.new
+      @lock = Mutex.new
+    end
+
+    # Declares a block that will be executed when a Sidekiq component is fully
+    # loaded. If the component has already loaded, the block is executed
+    # immediately.
+    #
+    #   Sidekiq.loader.on_load(:api) do
+    #     # extend the sidekiq API
+    #   end
+    #
+    def on_load(name, &block)
+      # we don't want to hold the lock while calling the block
+      to_run = nil
+
+      @lock.synchronize do
+        if @loaded.include?(name)
+          to_run = block
+        else
+          @load_hooks[name] << block
+        end
+      end
+
+      to_run&.call
+      nil
+    end
+
+    # Executes all blocks registered to +name+ via on_load.
+    #
+    #   Sidekiq.loader.run_load_hooks(:api)
+    #
+    # In the case of the above example, it will execute all hooks registered for +:api+.
+    #
+    def run_load_hooks(name)
+      hks = @lock.synchronize do
+        @loaded << name
+        @load_hooks.delete(name)
+      end
+
+      hks&.each do |blk|
+        blk.call
+      rescue => ex
+        handle_exception(ex, hook: name)
+      end
+    end
+  end
+end

data/lib/sidekiq/logger.rb

@@ -24,14 +24,15 @@ module Sidekiq
 
   class Logger < ::Logger
     module Formatters
-      COLORS = {
-        "DEBUG" => "\e[1;32mDEBUG\e[0m", # green
-        "INFO" => "\e[1;34mINFO \e[0m", # blue
-        "WARN" => "\e[1;33mWARN \e[0m", # yellow
-        "ERROR" => "\e[1;31mERROR\e[0m", # red
-        "FATAL" => "\e[1;35mFATAL\e[0m" # pink
-      }
       class Base < ::Logger::Formatter
+        COLORS = {
+          "DEBUG" => "\e[1;32mDEBUG\e[0m", # green
+          "INFO" => "\e[1;34mINFO \e[0m", # blue
+          "WARN" => "\e[1;33mWARN \e[0m", # yellow
+          "ERROR" => "\e[1;31mERROR\e[0m", # red
+          "FATAL" => "\e[1;35mFATAL\e[0m" # pink
+        }
+
         def tid
           Thread.current["sidekiq_tid"] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
         end
@@ -50,13 +51,19 @@ module Sidekiq
 
       class Pretty < Base
         def call(severity, time, program_name, message)
-          "#{Formatters::COLORS[severity]} #{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
+          "#{COLORS[severity]} #{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
+        end
+      end
+
+      class Plain < Base
+        def call(severity, time, program_name, message)
+          "#{severity} #{time.utc.iso8601(3)} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
         end
       end
 
       class WithoutTimestamp < Pretty
         def call(severity, time, program_name, message)
-          "#{Formatters::COLORS[severity]} pid=#{::Process.pid} tid=#{tid} #{format_context}: #{message}\n"
+          "#{COLORS[severity]} pid=#{::Process.pid} tid=#{tid}#{format_context}: #{message}\n"
         end
       end
 

data/lib/sidekiq/metrics/tracking.rb

@@ -147,4 +147,7 @@ Sidekiq.configure_server do |config|
   config.on(:beat) do
     exec.flush
   end
+  config.on(:exit) do
+    exec.flush
+  end
 end

data/lib/sidekiq/middleware/current_attributes.rb

@@ -50,7 +50,7 @@ module Sidekiq
         @cattrs = cattrs
       end
 
-      def call(_, job, _, &block)
+      def call(_, job, *, &block)
         klass_attrs = {}
 
         @cattrs.each do |(key, strklass)|
@@ -93,6 +93,7 @@ module Sidekiq
       def persist(klass_or_array, config = Sidekiq.default_configuration)
         cattrs = build_cattrs_hash(klass_or_array)
 
+        config.client_middleware.prepend Load, cattrs
         config.client_middleware.add Save, cattrs
         config.server_middleware.prepend Load, cattrs
       end

data/lib/sidekiq/rails.rb

@@ -48,8 +48,10 @@ module Sidekiq
           unless ::Rails.logger == config.logger || ::ActiveSupport::Logger.logger_outputs_to?(::Rails.logger, $stdout)
             if ::Rails.logger.respond_to?(:broadcast_to)
               ::Rails.logger.broadcast_to(config.logger)
-            else
+            elsif ::ActiveSupport::Logger.respond_to?(:broadcast)
               ::Rails.logger.extend(::ActiveSupport::Logger.broadcast(config.logger))
+            else
+              ::Rails.logger = ::ActiveSupport::BroadcastLogger.new(::Rails.logger, config.logger)
             end
           end
         end

data/lib/sidekiq/testing.rb

@@ -83,7 +83,7 @@ module Sidekiq
   class EmptyQueueError < RuntimeError; end
 
   module TestingClient
-    def atomic_push(conn, payloads)
+    private def atomic_push(conn, payloads)
       if Sidekiq::Testing.fake?
         payloads.each do |job|
           job = Sidekiq.load_json(Sidekiq.dump_json(job))

data/lib/sidekiq/transaction_aware_client.rb

@@ -7,6 +7,12 @@ module Sidekiq
   class TransactionAwareClient
     def initialize(pool: nil, config: nil)
       @redis_client = Client.new(pool: pool, config: config)
+      @transaction_backend =
+        if ActiveRecord.version >= Gem::Version.new("7.2")
+          ActiveRecord.method(:after_all_transactions_commit)
+        else
+          AfterCommitEverywhere.method(:after_commit)
+        end
     end
 
     def batching?
@@ -20,7 +26,7 @@ module Sidekiq
       # pre-allocate the JID so we can return it immediately and
       # save it to the database as part of the transaction.
       item["jid"] ||= SecureRandom.hex(12)
-      AfterCommitEverywhere.after_commit { @redis_client.push(item) }
+      @transaction_backend.call { @redis_client.push(item) }
       item["jid"]
     end
 
@@ -38,10 +44,12 @@ end
 # Use `Sidekiq.transactional_push!` in your sidekiq.rb initializer
 module Sidekiq
   def self.transactional_push!
-    begin
-      require "after_commit_everywhere"
-    rescue LoadError
-      raise %q(You need to add `gem "after_commit_everywhere"` to your Gemfile to use Sidekiq's transactional client)
+    if ActiveRecord.version < Gem::Version.new("7.2")
+      begin
+        require "after_commit_everywhere"
+      rescue LoadError
+        raise %q(You need ActiveRecord >= 7.2 or to add `gem "after_commit_everywhere"` to your Gemfile to use Sidekiq's transactional client)
+      end
     end
 
     Sidekiq.default_job_options["client_class"] = Sidekiq::TransactionAwareClient

data/lib/sidekiq/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Sidekiq
-  VERSION = "8.0.5"
+  VERSION = "8.0.8"
   MAJOR = 8
 
   def self.gem_version

data/lib/sidekiq/web/action.rb

@@ -67,7 +67,31 @@ module Sidekiq
       end
 
       def session
-        env["rack.session"]
+        env["rack.session"] || fail(<<~EOM)
+          Sidekiq::Web needs a valid Rack session. If this is a Rails app, make
+          sure you mount Sidekiq::Web *inside* your application routes:
+
+
+          Rails.application.routes.draw do
+            mount Sidekiq::Web => "/sidekiq"
+            ....
+          end
+
+
+          If this is a Rails app in API mode, you need to enable sessions.
+
+            https://guides.rubyonrails.org/api_app.html#using-session-middlewares
+
+          If this is a bare Rack app, use a session middleware before Sidekiq::Web:
+
+            # first, use IRB to create a shared secret key for sessions and commit it
+            require 'securerandom'; File.open(".session.key", "w") {|f| f.write(SecureRandom.hex(32)) }
+
+            # now use the secret with a session cookie middleware
+            use Rack::Session::Cookie, secret: File.read(".session.key"), same_site: true, max_age: 86400
+            run Sidekiq::Web
+
+        EOM
       end
 
       def logger
@@ -78,15 +102,15 @@ module Sidekiq
       def flash
         msg = yield
         logger.info msg
-        session[:flash] = msg
+        session[:skq_flash] = msg
       end
 
       def flash?
-        session&.[](:flash)
+        session&.[](:skq_flash)
       end
 
       def get_flash
-        @flash ||= session.delete(:flash)
+        @flash ||= session.delete(:skq_flash)
       end
 
       def erb(content, options = {})

data/lib/sidekiq.rb

@@ -29,6 +29,7 @@ end
 
 require "sidekiq/config"
 require "sidekiq/logger"
+require "sidekiq/loader"
 require "sidekiq/client"
 require "sidekiq/transaction_aware_client"
 require "sidekiq/job"
@@ -94,6 +95,10 @@ module Sidekiq
     default_configuration.logger
   end
 
+  def self.loader
+    @loader ||= Loader.new
+  end
+
   def self.configure_server(&block)
     (@config_blocks ||= []) << block
     yield default_configuration if server?

data/web/assets/javascripts/application.js

@@ -18,15 +18,6 @@ function addListeners() {
     })
   });
 
-  document.querySelectorAll("input[data-confirm]").forEach(node => {
-    node.addEventListener("click", event => {
-      if (!window.confirm(node.getAttribute("data-confirm"))) {
-        event.preventDefault();
-        event.stopPropagation();
-      }
-    })
-  })
-
   document.querySelectorAll("[data-toggle]").forEach(node => {
     node.addEventListener("click", addDataToggleListeners)
   })
@@ -67,7 +58,7 @@ function addPollingListeners(_event)  {
 
 function addDataToggleListeners(event) {
   var source = event.target || event.srcElement;
-  var targName = source.getAttribute("data-toggle");
+  var targName = source.dataset.toggle;
   var full = document.getElementById(targName);
   full.classList.toggle("is-open");
 }
@@ -90,7 +81,7 @@ function addShiftClickListeners() {
 }
 
 function updateFuzzyTimes() {
-  var locale = document.body.getAttribute("data-locale");
+  var locale = document.body.dataset.locale;
   var parts = locale.split('-');
   if (typeof parts[1] !== 'undefined') {
     parts[1] = parts[1].toUpperCase();
@@ -105,7 +96,7 @@ function updateFuzzyTimes() {
 function updateNumbers() {
   document.querySelectorAll("[data-nwp]").forEach(node => {
     let number = parseFloat(node.textContent);
-    let precision = parseInt(node.dataset["nwp"] || 0);
+    let precision = parseInt(node.dataset.nwp || 0);
     if (typeof number === "number") {
       let formatted = number.toLocaleString(undefined, {
         minimumFractionDigits: precision,
@@ -178,4 +169,20 @@ function updateLocale(event) {
 
 function updateProgressBars() {
   document.querySelectorAll('.progress-bar').forEach(bar => { bar.style.width = bar.dataset.width + "%"})
-}
+}
+
+function handleConfirmDialog (event) {
+  const target = event.target
+
+  if (target.localName !== "input") { return }
+  const confirmMessage = target.dataset.confirm
+
+  if (confirmMessage === undefined) { return }
+
+  if (!window.confirm(confirmMessage)) {
+    event.preventDefault()
+    event.stopPropagation()
+  }
+}
+
+document.addEventListener("click", handleConfirmDialog)

data/web/assets/stylesheets/style.css

@@ -29,8 +29,6 @@
 
 *, *::before, *::after { box-sizing: border-box; }
 
-::selection { background: var(--color-selected); }
-
 :focus-visible {
   outline: 1px solid oklch(from var(--color-primary) l c h / 50%);
 }
@@ -567,7 +565,6 @@ body > footer .nav {
     --color-border: oklch(25% 0.01 256);
     --color-input-border: oklch(31% 0.01 256);
     --color-selected: oklch(27% 0.01 256);
-    --color-selected-text: oklch(55% 0.11 45);
     --color-table-bg-alt: oklch(24% 0.01 256);
     --color-shadow: oklch(9% 0.01 256 / 10%);
     --color-text: oklch(75% 0.01 256);
@@ -616,10 +613,6 @@ body > footer .nav {
   .label-info { background: var(--color-info); }
   .label-danger { background: var(--color-danger); }
   .label-warning { background: var(--color-warning); }
-
-  td.box::selection {
-    background-color: var(--color-selected-text);
-  }
 }
 
 @media (max-width: 800px) { :root { --font-size: 14px; } }

data/web/locales/uk.yml

@@ -14,8 +14,8 @@ uk:
   CreatedAt: Створено
   CurrentMessagesInQueue: Поточні задачі у черзі <span class='title'>%{queue}</span>
   Dashboard: Панель керування
-  Dead: Вбитих
-  DeadJobs: Вбиті задачі
+  Dead: Зупинених
+  DeadJobs: Зупинені задачі
   Delete: Видалити
   DeleteAll: Видалити усі
   Deploy: Деплой
@@ -33,8 +33,8 @@ uk:
   History: Історія
   Job: Задача
   Jobs: Задачі
-  Kill: Вбити
-  KillAll: Вбити все
+  Kill: Зупинити
+  KillAll: Зупинити все
   LastRetry: Остання спроба
   Latency: Затримка
   LivePoll: Постійне опитування
@@ -42,7 +42,7 @@ uk:
   Name: Назва
   Namespace: Простір імен
   NextRetry: Наступна спроба
-  NoDeadJobsFound: Вбитих задач не знайдено
+  NoDeadJobsFound: Зупинених задач не знайдено
   NoRetriesFound: Спроб не знайдено
   NoScheduledFound: Запланованих задач не знайдено
   NotYetEnqueued: Ще не в черзі

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq
 version: !ruby/object:Gem::Version
-  version: 8.0.5
+  version: 8.0.8
 platform: ruby
 authors:
 - Mike Perham
 bindir: bin
 cert_chain: []
-date: 2025-06-30 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis-client
@@ -122,6 +122,7 @@ files:
 - lib/sidekiq/job_retry.rb
 - lib/sidekiq/job_util.rb
 - lib/sidekiq/launcher.rb
+- lib/sidekiq/loader.rb
 - lib/sidekiq/logger.rb
 - lib/sidekiq/manager.rb
 - lib/sidekiq/metrics/query.rb
@@ -244,7 +245,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Simple, efficient background processing for Ruby
 test_files: []