sidekiq 7.2.4 → 7.3.1

data/lib/sidekiq/job/iterable.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require_relative "iterable/enumerators"
+
+module Sidekiq
+  module Job
+    class Interrupted < ::RuntimeError; end
+
+    module Iterable
+      include Enumerators
+
+      # @api private
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # @api private
+      module ClassMethods
+        def method_added(method_name)
+          raise "#{self} is an iterable job and must not define #perform" if method_name == :perform
+          super
+        end
+      end
+
+      # @api private
+      def initialize
+        super
+
+        @_executions = 0
+        @_cursor = nil
+        @_start_time = nil
+        @_runtime = 0
+      end
+
+      # A hook to override that will be called when the job starts iterating.
+      #
+      # It is called only once, for the first time.
+      #
+      def on_start
+      end
+
+      # A hook to override that will be called around each iteration.
+      #
+      # Can be useful for some metrics collection, performance tracking etc.
+      #
+      def around_iteration
+        yield
+      end
+
+      # A hook to override that will be called when the job resumes iterating.
+      #
+      def on_resume
+      end
+
+      # A hook to override that will be called each time the job is interrupted.
+      #
+      # This can be due to interruption or sidekiq stopping.
+      #
+      def on_stop
+      end
+
+      # A hook to override that will be called when the job finished iterating.
+      #
+      def on_complete
+      end
+
+      # The enumerator to be iterated over.
+      #
+      # @return [Enumerator]
+      #
+      # @raise [NotImplementedError] with a message advising subclasses to
+      #     implement an override for this method.
+      #
+      def build_enumerator(*)
+        raise NotImplementedError, "#{self.class.name} must implement a '#build_enumerator' method"
+      end
+
+      # The action to be performed on each item from the enumerator.
+      #
+      # @return [void]
+      #
+      # @raise [NotImplementedError] with a message advising subclasses to
+      #     implement an override for this method.
+      #
+      def each_iteration(*)
+        raise NotImplementedError, "#{self.class.name} must implement an '#each_iteration' method"
+      end
+
+      def iteration_key
+        "it-#{jid}"
+      end
+
+      # @api private
+      def perform(*arguments)
+        fetch_previous_iteration_state
+
+        @_executions += 1
+        @_start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+
+        enumerator = build_enumerator(*arguments, cursor: @_cursor)
+        unless enumerator
+          logger.info("'#build_enumerator' returned nil, skipping the job.")
+          return
+        end
+
+        assert_enumerator!(enumerator)
+
+        if @_executions == 1
+          on_start
+        else
+          on_resume
+        end
+
+        completed = catch(:abort) do
+          iterate_with_enumerator(enumerator, arguments)
+        end
+
+        on_stop
+        completed = handle_completed(completed)
+
+        if completed
+          on_complete
+          cleanup
+        else
+          reenqueue_iteration_job
+        end
+      end
+
+      private
+
+      def fetch_previous_iteration_state
+        state = Sidekiq.redis { |conn| conn.hgetall(iteration_key) }
+
+        unless state.empty?
+          @_executions = state["ex"].to_i
+          @_cursor = Sidekiq.load_json(state["c"])
+          @_runtime = state["rt"].to_f
+        end
+      end
+
+      STATE_FLUSH_INTERVAL = 5 # seconds
+      # we need to keep the state around as long as the job
+      # might be retrying
+      STATE_TTL = 30 * 24 * 60 * 60 # one month
+
+      def iterate_with_enumerator(enumerator, arguments)
+        found_record = false
+        state_flushed_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+
+        enumerator.each do |object, cursor|
+          found_record = true
+          @_cursor = cursor
+
+          is_interrupted = interrupted?
+          if ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - state_flushed_at >= STATE_FLUSH_INTERVAL || is_interrupted
+            flush_state
+            state_flushed_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+          end
+
+          return false if is_interrupted
+
+          around_iteration do
+            each_iteration(object, *arguments)
+          end
+        end
+
+        logger.debug("Enumerator found nothing to iterate!") unless found_record
+        true
+      ensure
+        @_runtime += (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @_start_time)
+      end
+
+      def reenqueue_iteration_job
+        flush_state
+        logger.debug { "Interrupting job (cursor=#{@_cursor.inspect})" }
+
+        raise Interrupted
+      end
+
+      def assert_enumerator!(enum)
+        unless enum.is_a?(Enumerator)
+          raise ArgumentError, <<~MSG
+            #build_enumerator must return an Enumerator, but returned #{enum.class}.
+            Example:
+              def build_enumerator(params, cursor:)
+                active_record_records_enumerator(
+                  Shop.find(params["shop_id"]).products,
+                  cursor: cursor
+                )
+              end
+          MSG
+        end
+      end
+
+      def flush_state
+        key = iteration_key
+        state = {
+          "ex" => @_executions,
+          "c" => Sidekiq.dump_json(@_cursor),
+          "rt" => @_runtime
+        }
+
+        Sidekiq.redis do |conn|
+          conn.multi do |pipe|
+            pipe.hset(key, state)
+            pipe.expire(key, STATE_TTL)
+          end
+        end
+      end
+
+      def cleanup
+        logger.debug {
+          format("Completed iteration. executions=%d runtime=%.3f", @_executions, @_runtime)
+        }
+        Sidekiq.redis { |conn| conn.unlink(iteration_key) }
+      end
+
+      def handle_completed(completed)
+        case completed
+        when nil, # someone aborted the job but wants to call the on_complete callback
+             true
+          true
+        when false
+          false
+        else
+          raise "Unexpected thrown value: #{completed.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq/job.rb

@@ -69,7 +69,11 @@ module Sidekiq
         # In practice, any option is allowed.  This is the main mechanism to configure the
         # options for a specific job.
         def sidekiq_options(opts = {})
-          opts = opts.transform_keys(&:to_s) # stringify
+          # stringify 2 levels of keys
+          opts = opts.to_h do |k, v|
+            [k.to_s, (Hash === v) ? v.transform_keys(&:to_s) : v]
+          end
+
           self.sidekiq_options_hash = get_sidekiq_options.merge(opts)
         end
 
@@ -155,6 +159,9 @@ module Sidekiq
 
     attr_accessor :jid
 
+    # This attribute is implementation-specific and not a public API
+    attr_accessor :_context
+
     def self.included(base)
       raise ArgumentError, "Sidekiq::Job cannot be included in an ActiveJob: #{base.name}" if base.ancestors.any? { |c| c.name == "ActiveJob::Base" }
 
@@ -166,6 +173,10 @@ module Sidekiq
       Sidekiq.logger
     end
 
+    def interrupted?
+      @_context&.stopping?
+    end
+
     # This helper class encapsulates the set options for `set`, e.g.
     #
     #     SomeJob.set(queue: 'foo').perform_async(....)
@@ -366,7 +377,7 @@ module Sidekiq
 
       def build_client # :nodoc:
         pool = Thread.current[:sidekiq_redis_pool] || get_sidekiq_options["pool"] || Sidekiq.default_configuration.redis_pool
-        client_class = get_sidekiq_options["client_class"] || Sidekiq::Client
+        client_class = Thread.current[:sidekiq_client_class] || get_sidekiq_options["client_class"] || Sidekiq::Client
         client_class.new(pool: pool)
       end
     end

data/lib/sidekiq/job_logger.rb

@@ -2,23 +2,34 @@
 
 module Sidekiq
   class JobLogger
-    def initialize(logger)
-      @logger = logger
+    def initialize(config)
+      @config = config
+      @logger = @config.logger
+    end
+
+    # If true we won't do any job logging out of the box.
+    # The user is responsible for any logging.
+    def skip_default_logging?
+      @config[:skip_default_job_logging]
     end
 
     def call(item, queue)
-      start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-      @logger.info("start")
+      return yield if skip_default_logging?
 
-      yield
+      begin
+        start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        @logger.info("start")
 
-      Sidekiq::Context.add(:elapsed, elapsed(start))
-      @logger.info("done")
-    rescue Exception
-      Sidekiq::Context.add(:elapsed, elapsed(start))
-      @logger.info("fail")
+        yield
 
-      raise
+        Sidekiq::Context.add(:elapsed, elapsed(start))
+        @logger.info("done")
+      rescue Exception
+        Sidekiq::Context.add(:elapsed, elapsed(start))
+        @logger.info("fail")
+
+        raise
+      end
     end
 
     def prepare(job_hash, &block)

data/lib/sidekiq/job_retry.rb

@@ -59,8 +59,13 @@ module Sidekiq
   #    end
   #
   class JobRetry
+    # Handled means the job failed but has been dealt with
+    # (by creating a retry, rescheduling it, etc). It still
+    # needs to be logged and dispatched to error_handlers.
     class Handled < ::RuntimeError; end
 
+    # Skip means the job failed but Sidekiq does not need to
+    # create a retry, log it or send to error_handlers.
     class Skip < Handled; end
 
     include Sidekiq::Component
@@ -129,7 +134,7 @@ module Sidekiq
       process_retry(jobinst, msg, queue, e)
       # We've handled this error associated with this job, don't
       # need to handle it at the global level
-      raise Skip
+      raise Handled
     end
 
     private

data/lib/sidekiq/job_util.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "securerandom"
 require "time"
 

data/lib/sidekiq/metrics/query.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "sidekiq"
 require "date"
 require "set"

data/lib/sidekiq/metrics/shared.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "concurrent"
 
 module Sidekiq

data/lib/sidekiq/metrics/tracking.rb

@@ -31,11 +31,11 @@ module Sidekiq
           # We don't track time for failed jobs as they can have very unpredictable
           # execution times. more important to know average time for successful jobs so we
           # can better recognize when a perf regression is introduced.
-          @lock.synchronize {
-            @grams[klass].record_time(time_ms)
-            @jobs["#{klass}|ms"] += time_ms
-            @totals["ms"] += time_ms
-          }
+          track_time(klass, time_ms)
+        rescue JobRetry::Skip
+          # This is raised when iterable job is interrupted.
+          track_time(klass, time_ms)
+          raise
         rescue Exception
           @lock.synchronize {
             @jobs["#{klass}|f"] += 1
@@ -100,6 +100,14 @@ module Sidekiq
 
       private
 
+      def track_time(klass, time_ms)
+        @lock.synchronize {
+          @grams[klass].record_time(time_ms)
+          @jobs["#{klass}|ms"] += time_ms
+          @totals["ms"] += time_ms
+        }
+      end
+
       def reset
         @lock.synchronize {
           array = [@totals, @jobs, @grams]

data/lib/sidekiq/middleware/current_attributes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/current_attributes"
 
 module Sidekiq
@@ -46,22 +48,38 @@ module Sidekiq
       end
 
       def call(_, job, _, &block)
-        cattrs_to_reset = []
+        klass_attrs = {}
 
         @cattrs.each do |(key, strklass)|
-          if job.has_key?(key)
-            constklass = strklass.constantize
-            cattrs_to_reset << constklass
+          next unless job.has_key?(key)
 
-            job[key].each do |(attribute, value)|
-              constklass.public_send(:"#{attribute}=", value)
-            end
-          end
+          klass_attrs[strklass.constantize] = job[key]
         end
 
-        yield
-      ensure
-        cattrs_to_reset.each(&:reset)
+        wrap(klass_attrs.to_a, &block)
+      end
+
+      private
+
+      def wrap(klass_attrs, &block)
+        klass, attrs = klass_attrs.shift
+        return block.call unless klass
+
+        retried = false
+
+        begin
+          klass.set(attrs) do
+            wrap(klass_attrs, &block)
+          end
+        rescue NoMethodError
+          raise if retried
+
+          # It is possible that the `CurrentAttributes` definition
+          # was changed before the job started processing.
+          attrs = attrs.select { |attr| klass.respond_to?(attr) }
+          retried = true
+          retry
+        end
       end
     end
 

data/lib/sidekiq/middleware/modules.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sidekiq
   # Server-side middleware must import this Module in order
   # to get access to server resources during `call`.

data/lib/sidekiq/monitor.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require "fileutils"
 require "sidekiq/api"
@@ -98,7 +99,7 @@ class Sidekiq::Monitor
       pad = opts[:pad] || 0
       max_length = opts[:max_length] || (80 - pad)
       out = []
-      line = ""
+      line = +""
       values.each do |value|
         if (line.length + value.length) > max_length
           out << line

data/lib/sidekiq/processor.rb

@@ -36,7 +36,7 @@ module Sidekiq
       @job = nil
       @thread = nil
       @reloader = Sidekiq.default_configuration[:reloader]
-      @job_logger = (capsule.config[:job_logger] || Sidekiq::JobLogger).new(logger)
+      @job_logger = (capsule.config[:job_logger] || Sidekiq::JobLogger).new(capsule.config)
       @retrier = Sidekiq::JobRetry.new(capsule)
     end
 
@@ -58,6 +58,10 @@ module Sidekiq
       @thread.value if wait
     end
 
+    def stopping?
+      @done
+    end
+
     def start
       @thread ||= safe_thread("#{config.name}/processor", &method(:run))
     end
@@ -136,6 +140,7 @@ module Sidekiq
                 klass = Object.const_get(job_hash["class"])
                 inst = klass.new
                 inst.jid = job_hash["jid"]
+                inst._context = self
                 @retrier.local(inst, jobstr, queue) do
                   yield inst
                 end
@@ -185,6 +190,11 @@ module Sidekiq
           # Had to force kill this job because it didn't finish
           # within the timeout.  Don't acknowledge the work since
           # we didn't properly finish it.
+        rescue Sidekiq::JobRetry::Skip => s
+          # Skip means we handled this error elsewhere. We don't
+          # need to log or report the error.
+          ack = true
+          raise s
         rescue Sidekiq::JobRetry::Handled => h
           # this is the common case: job raised error and Sidekiq::JobRetry::Handled
           # signals that we created a retry successfully.  We can acknowledge the job.

data/lib/sidekiq/redis_client_adapter.rb

@@ -64,6 +64,13 @@ module Sidekiq
       opts = client_opts(options)
       @config = if opts.key?(:sentinels)
         RedisClient.sentinel(**opts)
+      elsif opts.key?(:nodes)
+        # Sidekiq does not support Redis clustering but Sidekiq Enterprise's
+        # rate limiters are cluster-safe so we can scale to millions
+        # of rate limiters using a Redis cluster. This requires the
+        # `redis-cluster-client` gem.
+        # Sidekiq::Limiter.redis = { nodes: [...] }
+        RedisClient.cluster(**opts)
       else
         RedisClient.config(**opts)
       end
@@ -90,13 +97,9 @@ module Sidekiq
         opts.delete(:network_timeout)
       end
 
-      if opts[:driver]
-        opts[:driver] = opts[:driver].to_sym
-      end
-
       opts[:name] = opts.delete(:master_name) if opts.key?(:master_name)
       opts[:role] = opts[:role].to_sym if opts.key?(:role)
-      opts.delete(:url) if opts.key?(:sentinels)
+      opts[:driver] = opts[:driver].to_sym if opts.key?(:driver)
 
       # Issue #3303, redis-rb will silently retry an operation.
       # This can lead to duplicate jobs if Sidekiq::Client's LPUSH

data/lib/sidekiq/redis_connection.rb

@@ -8,17 +8,28 @@ module Sidekiq
   module RedisConnection
     class << self
       def create(options = {})
-        symbolized_options = options.transform_keys(&:to_sym)
+        symbolized_options = deep_symbolize_keys(options)
         symbolized_options[:url] ||= determine_redis_provider
 
         logger = symbolized_options.delete(:logger)
         logger&.info { "Sidekiq #{Sidekiq::VERSION} connecting to Redis with options #{scrub(symbolized_options)}" }
 
         raise "Sidekiq 7+ does not support Redis protocol 2" if symbolized_options[:protocol] == 2
+
+        safe = !!symbolized_options.delete(:cluster_safe)
+        raise ":nodes not allowed, Sidekiq is not safe to run on Redis Cluster" if !safe && symbolized_options.key?(:nodes)
+
         size = symbolized_options.delete(:size) || 5
         pool_timeout = symbolized_options.delete(:pool_timeout) || 1
         pool_name = symbolized_options.delete(:pool_name)
 
+        # Default timeout in redis-client is 1 second, which can be too aggressive
+        # if the Sidekiq process is CPU-bound. With 10-15 threads and a thread quantum of 100ms,
+        # it can be easy to get the occasional ReadTimeoutError. You can still provide
+        # a smaller timeout explicitly:
+        #     config.redis = { url: "...", timeout: 1 }
+        symbolized_options[:timeout] ||= 3
+
         redis_config = Sidekiq::RedisClientAdapter.new(symbolized_options)
         ConnectionPool.new(timeout: pool_timeout, size: size, name: pool_name) do
           redis_config.new_client
@@ -27,6 +38,19 @@ module Sidekiq
 
       private
 
+      def deep_symbolize_keys(object)
+        case object
+        when Hash
+          object.each_with_object({}) do |(key, value), result|
+            result[key.to_sym] = deep_symbolize_keys(value)
+          end
+        when Array
+          object.map { |e| deep_symbolize_keys(e) }
+        else
+          object
+        end
+      end
+
       def scrub(options)
         redacted = "REDACTED"
 
@@ -42,7 +66,14 @@ module Sidekiq
         scrubbed_options[:password] = redacted if scrubbed_options[:password]
         scrubbed_options[:sentinel_password] = redacted if scrubbed_options[:sentinel_password]
         scrubbed_options[:sentinels]&.each do |sentinel|
-          sentinel[:password] = redacted if sentinel[:password]
+          if sentinel.is_a?(String)
+            if (uri = URI(sentinel)) && uri.password
+              uri.password = redacted
+              sentinel.replace(uri.to_s)
+            end
+          elsif sentinel[:password]
+            sentinel[:password] = redacted
+          end
         end
         scrubbed_options
       end

data/lib/sidekiq/ring_buffer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "forwardable"
 
 module Sidekiq

data/lib/sidekiq/systemd.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 #
 # Sidekiq's systemd integration allows Sidekiq to inform systemd:
 #  1. when it has successfully started

data/lib/sidekiq/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Sidekiq
-  VERSION = "7.2.4"
+  VERSION = "7.3.1"
   MAJOR = 7
 end

data/lib/sidekiq/web/action.rb

@@ -47,7 +47,8 @@ module Sidekiq
     def erb(content, options = {})
       if content.is_a? Symbol
         unless respond_to?(:"_erb_#{content}")
-          src = ERB.new(File.read("#{Web.settings.views}/#{content}.erb")).src
+          views = options[:views] || Web.settings.views
+          src = ERB.new(File.read("#{views}/#{content}.erb")).src
           WebAction.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def _erb_#{content}
               #{src}

data/lib/sidekiq/web/application.rb

@@ -5,7 +5,7 @@ module Sidekiq
     extend WebRouter
 
     REDIS_KEYS = %w[redis_version uptime_in_days connected_clients used_memory_human used_memory_peak_human]
-    CSP_HEADER = [
+    CSP_HEADER_TEMPLATE = [
       "default-src 'self' https: http:",
       "child-src 'self'",
       "connect-src 'self' https: http: wss: ws:",
@@ -15,8 +15,8 @@ module Sidekiq
       "manifest-src 'self'",
       "media-src 'self'",
       "object-src 'none'",
-      "script-src 'self' https: http:",
-      "style-src 'self' https: http: 'unsafe-inline'",
+      "script-src 'self' 'nonce-!placeholder!'",
+      "style-src 'self' https: http: 'unsafe-inline'", # TODO Nonce in 8.0
       "worker-src 'self'",
       "base-uri 'self'"
     ].join("; ").freeze
@@ -428,13 +428,18 @@ module Sidekiq
           Rack::CONTENT_TYPE => "text/html",
           Rack::CACHE_CONTROL => "private, no-store",
           Web::CONTENT_LANGUAGE => action.locale,
-          Web::CONTENT_SECURITY_POLICY => CSP_HEADER
+          Web::CONTENT_SECURITY_POLICY => process_csp(env, CSP_HEADER_TEMPLATE),
+          Web::X_CONTENT_TYPE_OPTIONS => "nosniff"
         }
         # we'll let Rack calculate Content-Length for us.
         [200, headers, [resp]]
       end
     end
 
+    def process_csp(env, input)
+      input.gsub("!placeholder!", env[:csp_nonce])
+    end
+
     def self.helpers(mod = nil, &block)
       if block
         WebAction.class_eval(&block)