sidekiq 8.0.7 → 8.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6411cfbee23ece1d53e775bf2726c85d236469d655eedfc8bc808277693fa1b
-  data.tar.gz: eef531b98d9f9e6fd5dc2fe2d2d59ac4a033134417be773b453dbf159f125156
+  metadata.gz: ef51643693879cd574d6edd54ef41443defc4825c855d5eed0e07d42e35aa1cd
+  data.tar.gz: 2d9acb8d89326185356ee9818ca543e8a6992bac0a00262e06aa9394052978c1
 SHA512:
-  metadata.gz: 8cd9e7e77116f9a9d07ac4cf9f805ffd58d6d81fe53fa52cf5c293fb33ae6bdaff6fce351527bf87df056225794016157949c6dcb9f1d3ddc37169c105cc15ce
-  data.tar.gz: f1b0fceebc6a94e2d4ca441fe834f3e82a1d0702da0cd70d14cf8fb0eb2f9490d6b1842e0e5c34e4a5f4e6a13a193806920826bd8b6f816297db471fc7464313
+  metadata.gz: 761f705abeb6b5deb31591d07d9d9ea0d79d5d6f74367f622842994aa0a57866bd3af9add1089ce2b29d8dd4a9cd110d839036504a1ae0830ac59dbca186ff26
+  data.tar.gz: 5df2e3b47cb7ed56a51ff90b1a8d23ea96f74e9fd64a9116d249a266c7a074ef2a4bac09d66202c66a4f631c6f15bcae167df8ae733f43020f0b53886ae3e564

data/Changes.md

@@ -2,6 +2,38 @@
 
 [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.9
+----------
+
+- Implement idle Redis connection reaping, will be activated in 8.1 [#6663]
+- Updated `Sidekiq::Process` API to provide capsule data. The `queues` and `weights` 
+  data will be removed from Redis in Sidekiq 8.1, as this data can now be found in the
+  `capsules` element. [#6295]
+- Restore bulk action buttons on Scheduled, Retry and Dead tabs [#6833, deve1212]
+- Support logging additional job attributes [#6846, bschrag620]
+- Fix display of long job args [#6836]
+- Create development lifecycle (`docs/sdlc.md`) and security (`docs/SECURITY.md`) policy
+  documentation for Sidekiq's current workflows
+
+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
 ----------
 

data/lib/generators/sidekiq/templates/job.rb.erb

@@ -6,4 +6,4 @@ class <%= class_name %>Job
     # Do something
   end
 end
-<% end -%>
+<% end -%>

data/lib/sidekiq/api.rb

@@ -1059,9 +1059,9 @@ module Sidekiq
   #   'started_at' => <process start time>,
   #   'pid' => 12345,
   #   'tag' => 'myapp'
-  #   'concurrency' => 25,
-  #   'queues' => ['default', 'low'],
-  #   'busy' => 10,
+  #   'concurrency' => 5,
+  #   'capsules' => {"default" => {"mode" => "weighted", "concurrency" => 5, "weights" => {"default" => 2, "low" => 1}}},
+  #   'busy' => 3,
   #   'beat' => <last heartbeat>,
   #   'identity' => <unique string identifying the process>,
   #   'embedded' => true,
@@ -1089,12 +1089,25 @@ module Sidekiq
       self["identity"]
     end
 
+    # deprecated, use capsules below
     def queues
-      self["queues"]
+      capsules.values.flat_map { |x| x["weights"].keys }.uniq
     end
 
+    # deprecated, use capsules below
     def weights
-      self["weights"]
+      hash = {}
+      capsules.values.each do |cap|
+        # Note: will lose data if two capsules are processing the same named queue
+        cap["weights"].each_pair do |queue, weight|
+          hash[queue] = weight
+        end
+      end
+      hash
+    end
+
+    def capsules
+      self["capsules"]
     end
 
     def version
@@ -1168,7 +1181,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 +1334,5 @@ module Sidekiq
     end
   end
 end
+
+Sidekiq.loader.run_load_hooks(:api)

data/lib/sidekiq/capsule.rb

@@ -38,6 +38,10 @@ module Sidekiq
       @mode = :strict
     end
 
+    def to_h
+      {concurrency: concurrency, mode: mode, weights: weights}
+    end
+
     def fetcher
       @fetcher ||= begin
         instance = (config[:fetch_class] || Sidekiq::BasicFetch).new(self)

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: {
@@ -36,7 +35,8 @@ module Sidekiq
       dead_max_jobs: 10_000,
       dead_timeout_in_seconds: 180 * 24 * 60 * 60, # 6 months
       reloader: proc { |&block| block.call },
-      backtrace_cleaner: ->(backtrace) { backtrace }
+      backtrace_cleaner: ->(backtrace) { backtrace },
+      logged_job_attributes: ["bid", "tags"]
     }
 
     ERROR_HANDLER = ->(ex, ctx, cfg = Sidekiq.default_configuration) {
@@ -145,11 +145,16 @@ module Sidekiq
       @redis_config = @redis_config.merge(hash)
     end
 
+    def reap_idle_redis_connections(timeout = nil)
+      self[:reap_connections] = timeout
+    end
+    alias_method :reap, :reap_idle_redis_connections
+
     def redis_pool
       Thread.current[:sidekiq_redis_pool] || Thread.current[:sidekiq_capsule]&.redis_pool || local_redis_pool
     end
 
-    private def local_redis_pool
+    def local_redis_pool
       # this is our internal client/housekeeping pool. each capsule has its
       # own pool for executing threads.
       @redis ||= new_redis_pool(10, "internal")

data/lib/sidekiq/fetch.rb

@@ -7,6 +7,7 @@ require "sidekiq/capsule"
 module Sidekiq # :nodoc:
   class BasicFetch
     include Sidekiq::Component
+
     # We want the fetch operation to timeout every few seconds so the thread
     # can check if the process is shutting down.
     TIMEOUT = 2

data/lib/sidekiq/job/iterable.rb

@@ -55,7 +55,7 @@ module Sidekiq
       def cancel!
         return @_cancelled if cancelled?
 
-        key = "it-#{jid}"
+        key = iteration_key
         _, result, _ = Sidekiq.redis do |c|
           c.pipelined do |p|
             p.hsetnx(key, "cancelled", Time.now.to_i)
@@ -143,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
@@ -177,7 +177,7 @@ module Sidekiq
       private
 
       def is_cancelled?
-        @_cancelled = Sidekiq.redis { |c| c.hget("it-#{jid}", "cancelled") }
+        @_cancelled = Sidekiq.redis { |c| c.hget(iteration_key, "cancelled") }
       end
 
       def fetch_previous_iteration_state
@@ -204,17 +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
@@ -223,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
@@ -238,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
 
@@ -273,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 = {
@@ -308,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

@@ -29,8 +29,10 @@ module Sidekiq
         jid: job_hash["jid"],
         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")
+
+      @config[:logged_job_attributes].each do |attr|
+        h[attr.to_sym] = job_hash[attr] if job_hash.has_key?(attr)
+      end
 
       Thread.current[:sidekiq_context] = h
       level = job_hash["log_level"]

data/lib/sidekiq/job_retry.rb

@@ -186,6 +186,8 @@ module Sidekiq
       strategy, delay = delay_for(jobinst, count, exception, msg)
       case strategy
       when :discard
+        msg["discarded_at"] = now_ms
+
         return run_death_handlers(msg, exception)
       when :kill
         return retries_exhausted(jobinst, msg, exception)
@@ -255,8 +257,14 @@ module Sidekiq
         handle_exception(e, {context: "Error calling retries_exhausted", job: msg})
       end
 
-      to_morgue = !(msg["dead"] == false || rv == :discard)
-      send_to_morgue(msg) if to_morgue
+      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
 

data/lib/sidekiq/launcher.rb

@@ -142,6 +142,12 @@ module Sidekiq
       key = identity
       fails = procd = 0
 
+      idle = config[:reap_connections]
+      if idle
+        config.capsules.each_value { |cap| cap.local_redis_pool.reap(idle, &:close) }
+        config.local_redis_pool.reap(idle, &:close)
+      end
+
       begin
         flush_stats
 
@@ -252,8 +258,15 @@ module Sidekiq
         "pid" => ::Process.pid,
         "tag" => @config[:tag] || "",
         "concurrency" => @config.total_concurrency,
+        "capsules" => @config.capsules.each_with_object({}) { |(name, cap), memo|
+          memo[name] = cap.to_h
+        },
+        #####
+        # TODO deprecated, remove in 9.0
+        # This data is now found in the `capsules` element above
         "queues" => @config.capsules.values.flat_map { |cap| cap.queues }.uniq,
-        "weights" => to_weights,
+        "weights" => @config.capsules.values.map(&:weights),
+        #####
         "labels" => @config[:labels].to_a,
         "identity" => identity,
         "version" => Sidekiq::VERSION,
@@ -261,10 +274,6 @@ module Sidekiq
       }
     end
 
-    def to_weights
-      @config.capsules.values.map(&:weights)
-    end
-
     def to_json
       # this data changes infrequently so dump it to a string
       # now so we don't need to dump it every heartbeat.

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/middleware/i18n.rb

@@ -11,6 +11,7 @@ module Sidekiq::Middleware::I18n
   # to be sent to Sidekiq.
   class Client
     include Sidekiq::ClientMiddleware
+
     def call(_jobclass, job, _queue, _redis)
       job["locale"] ||= I18n.locale
       yield
@@ -20,6 +21,7 @@ module Sidekiq::Middleware::I18n
   # Pull the msg locale out and set the current thread to use it.
   class Server
     include Sidekiq::ServerMiddleware
+
     def call(_jobclass, job, _queue, &block)
       I18n.with_locale(job.fetch("locale", I18n.default_locale), &block)
     end

data/lib/sidekiq/monitor.rb

@@ -49,14 +49,10 @@ class Sidekiq::Monitor
       puts "---- Processes (#{process_set.size}) ----"
       process_set.each_with_index do |process, index|
         # Keep compatibility with legacy versions since we don't want to break sidekiqmon during rolling upgrades or downgrades.
-        #
-        # Before:
-        #   ["default", "critical"]
-        #
-        # After:
-        #   {"default" => 1, "critical" => 10}
         queues =
-          if process["weights"]
+          if process["capsules"] # 8.0.6+
+            process["capsules"].values.map { |x| x["weights"].keys.join(", ") }
+          elsif process["weights"]
             process["weights"].sort_by { |queue| queue[0] }.map { |capsule| capsule.map { |name, weight| (weight > 0) ? "#{name}: #{weight}" : name }.join(", ") }
           else
             process["queues"].sort
@@ -105,7 +101,7 @@ class Sidekiq::Monitor
           out << line
           line = " " * pad
         end
-        line << value + ", "
+        line << value + "; "
       end
       out << line[0..-3]
       out.join("\n")

data/lib/sidekiq/profiler.rb

@@ -11,6 +11,7 @@ module Sidekiq
     }
 
     include Sidekiq::Component
+
     def initialize(config)
       @config = config
       @vernier_output_dir = ENV.fetch("VERNIER_OUTPUT_DIR") { Dir.tmpdir }

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

@@ -6,6 +6,7 @@ module Sidekiq
   class RingBuffer
     include Enumerable
     extend Forwardable
+
     def_delegators :@buf, :[], :each, :size
 
     def initialize(size, default = 0)

data/lib/sidekiq/version.rb

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

data/lib/sidekiq/web/action.rb

@@ -102,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/web/application.rb

@@ -318,6 +318,16 @@ module Sidekiq
         redirect_with_query("#{root_path}scheduled")
       end
 
+      post "/scheduled/all/delete" do
+        Sidekiq::ScheduledSet.new.clear
+        redirect "#{root_path}scheduled"
+      end
+
+      post "/scheduled/all/add_to_queue" do
+        Sidekiq::ScheduledSet.new.each(&:add_to_queue)
+        redirect "#{root_path}scheduled"
+      end
+
       get "/dashboard/stats" do
         redirect "#{root_path}stats"
       end

data/lib/sidekiq/web/helpers.rb

@@ -256,14 +256,6 @@ module Sidekiq
       end
     end
 
-    def busy_weights(capsule_weights)
-      # backwards compat with 7.0.0, remove in 7.1
-      cw = [capsule_weights].flatten
-      cw.map { |hash|
-        hash.map { |name, weight| (weight > 0) ? +name << ": " << weight.to_s : name }.join(", ")
-      }.join("; ")
-    end
-
     def stats
       @stats ||= Sidekiq::Stats.new
     end

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?