sidekiq 5.2.5 → 6.0.2

data/lib/sidekiq/processor.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
-require 'sidekiq/util'
-require 'sidekiq/fetch'
-require 'sidekiq/job_logger'
-require 'sidekiq/job_retry'
-require 'thread'
+
+require "sidekiq/util"
+require "sidekiq/fetch"
+require "sidekiq/job_logger"
+require "sidekiq/job_retry"
 
 module Sidekiq
   ##
@@ -23,7 +23,6 @@ module Sidekiq
   # to replace itself and exits.
   #
   class Processor
-
     include Util
 
     attr_reader :thread
@@ -37,19 +36,19 @@ module Sidekiq
       @thread = nil
       @strategy = (mgr.options[:fetch] || Sidekiq::BasicFetch).new(mgr.options)
       @reloader = Sidekiq.options[:reloader]
-      @logging = (mgr.options[:job_logger] || Sidekiq::JobLogger).new
+      @job_logger = (mgr.options[:job_logger] || Sidekiq::JobLogger).new
       @retrier = Sidekiq::JobRetry.new
     end
 
-    def terminate(wait=false)
+    def terminate(wait = false)
       @done = true
-      return if !@thread
+      return unless @thread
       @thread.value if wait
     end
 
-    def kill(wait=false)
+    def kill(wait = false)
       @done = true
-      return if !@thread
+      return unless @thread
       # unlike the other actors, terminate does not wait
       # for the thread to finish because we don't know how
       # long the job will take to finish.  Instead we
@@ -66,16 +65,12 @@ module Sidekiq
     private unless $TESTING
 
     def run
-      begin
-        while !@done
-          process_one
-        end
-        @mgr.processor_stopped(self)
-      rescue Sidekiq::Shutdown
-        @mgr.processor_stopped(self)
-      rescue Exception => ex
-        @mgr.processor_died(self, ex)
-      end
+      process_one until @done
+      @mgr.processor_stopped(self)
+    rescue Sidekiq::Shutdown
+      @mgr.processor_stopped(self)
+    rescue Exception => ex
+      @mgr.processor_died(self, ex)
     end
 
     def process_one
@@ -85,14 +80,15 @@ module Sidekiq
     end
 
     def get_one
-      begin
-        work = @strategy.retrieve_work
-        (logger.info { "Redis is online, #{::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @down} sec downtime" }; @down = nil) if @down
-        work
-      rescue Sidekiq::Shutdown
-      rescue => ex
-        handle_fetch_exception(ex)
+      work = @strategy.retrieve_work
+      if @down
+        logger.info { "Redis is online, #{::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @down} sec downtime" }
+        @down = nil
       end
+      work
+    rescue Sidekiq::Shutdown
+    rescue => ex
+      handle_fetch_exception(ex)
     end
 
     def fetch
@@ -106,7 +102,7 @@ module Sidekiq
     end
 
     def handle_fetch_exception(ex)
-      if !@down
+      unless @down
         @down = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
         logger.error("Error fetching job: #{ex}")
         handle_exception(ex)
@@ -115,25 +111,28 @@ module Sidekiq
       nil
     end
 
-    def dispatch(job_hash, queue)
+    def dispatch(job_hash, queue, jobstr)
       # since middleware can mutate the job hash
-      # we clone here so we report the original
+      # we need to clone it to report the original
       # job structure to the Web UI
-      pristine = cloned(job_hash)
-
-      Sidekiq::Logging.with_job_hash_context(job_hash) do
-        @retrier.global(pristine, queue) do
-          @logging.call(job_hash, queue) do
-            stats(pristine, queue) do
+      # or to push back to redis when retrying.
+      # To avoid costly and, most of the time, useless cloning here,
+      # we pass original String of JSON to respected methods
+      # to re-parse it there if we need access to the original, untouched job
+
+      @job_logger.prepare(job_hash) do
+        @retrier.global(jobstr, queue) do
+          @job_logger.call(job_hash, queue) do
+            stats(jobstr, queue) do
               # Rails 5 requires a Reloader to wrap code execution.  In order to
               # constantize the worker and instantiate an instance, we have to call
               # the Reloader.  It handles code loading, db connection management, etc.
               # Effectively this block denotes a "unit of work" to Rails.
               @reloader.call do
-                klass  = constantize(job_hash['class'])
+                klass = constantize(job_hash["class"])
                 worker = klass.new
-                worker.jid = job_hash['jid']
-                @retrier.local(worker, pristine, queue) do
+                worker.jid = job_hash["jid"]
+                @retrier.local(worker, jobstr, queue) do
                   yield worker
                 end
               end
@@ -147,37 +146,49 @@ module Sidekiq
       jobstr = work.job
       queue = work.queue_name
 
-      ack = false
+      # Treat malformed JSON as a special case: job goes straight to the morgue.
+      job_hash = nil
       begin
-        # Treat malformed JSON as a special case: job goes straight to the morgue.
-        job_hash = nil
-        begin
-          job_hash = Sidekiq.load_json(jobstr)
-        rescue => ex
-          handle_exception(ex, { :context => "Invalid JSON for job", :jobstr => jobstr })
-          # we can't notify because the job isn't a valid hash payload.
-          DeadSet.new.kill(jobstr, notify_failure: false)
-          ack = true
-          raise
-        end
+        job_hash = Sidekiq.load_json(jobstr)
+      rescue => ex
+        handle_exception(ex, {context: "Invalid JSON for job", jobstr: jobstr})
+        # we can't notify because the job isn't a valid hash payload.
+        DeadSet.new.kill(jobstr, notify_failure: false)
+        return work.acknowledge
+      end
 
-        ack = true
-        dispatch(job_hash, queue) do |worker|
+      ack = false
+      begin
+        dispatch(job_hash, queue, jobstr) do |worker|
           Sidekiq.server_middleware.invoke(worker, job_hash, queue) do
-            execute_job(worker, cloned(job_hash['args']))
+            execute_job(worker, job_hash["args"])
           end
         end
+        ack = true
       rescue Sidekiq::Shutdown
         # 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.
-        ack = false
+      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 acknowlege the job.
+        ack = true
+        e = h.cause || h
+        handle_exception(e, {context: "Job raised exception", job: job_hash, jobstr: jobstr})
+        raise e
       rescue Exception => ex
-        e = ex.is_a?(::Sidekiq::JobRetry::Skip) && ex.cause ? ex.cause : ex
-        handle_exception(e, { :context => "Job raised exception", :job => job_hash, :jobstr => jobstr })
+        # Unexpected error!  This is very bad and indicates an exception that got past
+        # the retry subsystem (e.g. network partition).  We won't acknowledge the job
+        # so it can be rescued when using Sidekiq Pro.
+        handle_exception(ex, {context: "Internal exception!", job: job_hash, jobstr: jobstr})
         raise e
       ensure
-        work.acknowledge if ack
+        if ack
+          # We don't want a shutdown signal to interrupt job acknowledgment.
+          Thread.handle_interrupt(Sidekiq::Shutdown => :never) do
+            work.acknowledge
+          end
+        end
       end
     end
 
@@ -194,12 +205,16 @@ module Sidekiq
         @lock = Mutex.new
       end
 
-      def incr(amount=1)
-        @lock.synchronize { @value = @value + amount }
+      def incr(amount = 1)
+        @lock.synchronize { @value += amount }
       end
 
       def reset
-        @lock.synchronize { val = @value; @value = 0; val }
+        @lock.synchronize {
+          val = @value
+          @value = 0
+          val
+        }
       end
     end
 
@@ -235,9 +250,8 @@ module Sidekiq
     FAILURE = Counter.new
     WORKER_STATE = SharedWorkerState.new
 
-    def stats(job_hash, queue)
-      tid = Sidekiq::Logging.tid
-      WORKER_STATE.set(tid, {:queue => queue, :payload => job_hash, :run_at => Time.now.to_i })
+    def stats(jobstr, queue)
+      WORKER_STATE.set(tid, {queue: queue, payload: jobstr, run_at: Time.now.to_i})
 
       begin
         yield
@@ -250,23 +264,17 @@ module Sidekiq
       end
     end
 
-    # Deep clone the arguments passed to the worker so that if
-    # the job fails, what is pushed back onto Redis hasn't
-    # been mutated by the worker.
-    def cloned(thing)
-      Marshal.load(Marshal.dump(thing))
-    end
-
     def constantize(str)
-      names = str.split('::')
+      return Object.const_get(str) unless str.include?("::")
+
+      names = str.split("::")
       names.shift if names.empty? || names.first.empty?
 
       names.inject(Object) do |constant, name|
         # the false flag limits search for name to under the constant namespace
         #   which mimics Rails' behaviour
-        constant.const_defined?(name, false) ? constant.const_get(name, false) : constant.const_missing(name)
+        constant.const_get(name, false)
       end
     end
-
   end
 end

data/lib/sidekiq/rails.rb

@@ -1,35 +1,35 @@
 # frozen_string_literal: true
 
+require "sidekiq/worker"
+
 module Sidekiq
   class Rails < ::Rails::Engine
-    # We need to setup this up before any application configuration which might
-    # change Sidekiq middleware.
+    # By including the Options module, we allow AJs to directly control sidekiq features
+    # via the *sidekiq_options* class method and, for instance, not use AJ's retry system.
+    # AJ retries don't show up in the Sidekiq UI Retries tab, save any error data, can't be
+    # manually retried, don't automatically die, etc.
     #
-    # This hook happens after `Rails::Application` is inherited within
-    # config/application.rb and before config is touched, usually within the
-    # class block. Definitely before config/environments/*.rb and
-    # config/initializers/*.rb.
-    config.before_configuration do
-      if ::Rails::VERSION::MAJOR < 5 && defined?(::ActiveRecord)
-        Sidekiq.server_middleware do |chain|
-          require 'sidekiq/middleware/server/active_record'
-          chain.add Sidekiq::Middleware::Server::ActiveRecord
-        end
+    #   class SomeJob < ActiveJob::Base
+    #     queue_as :default
+    #     sidekiq_options retry: 3, backtrace: 10
+    #     def perform
+    #     end
+    #   end
+    initializer "sidekiq.active_job_integration" do
+      ActiveSupport.on_load(:active_job) do
+        include ::Sidekiq::Worker::Options unless respond_to?(:sidekiq_options)
       end
     end
 
+    # This hook happens after all initializers are run, just before returning
+    # from config/environment.rb back to sidekiq/cli.rb.
+    # We have to add the reloader after initialize to see if cache_classes has
+    # been turned on.
+    #
+    # None of this matters on the client-side, only within the Sidekiq process itself.
     config.after_initialize do
-      # This hook happens after all initializers are run, just before returning
-      # from config/environment.rb back to sidekiq/cli.rb.
-      # We have to add the reloader after initialize to see if cache_classes has
-      # been turned on.
-      #
-      # None of this matters on the client-side, only within the Sidekiq process itself.
-      #
       Sidekiq.configure_server do |_|
-        if ::Rails::VERSION::MAJOR >= 5
-          Sidekiq.options[:reloader] = Sidekiq::Rails::Reloader.new
-        end
+        Sidekiq.options[:reloader] = Sidekiq::Rails::Reloader.new
       end
     end
 
@@ -48,11 +48,5 @@ module Sidekiq
         "#<Sidekiq::Rails::Reloader @app=#{@app.class.name}>"
       end
     end
-  end if defined?(::Rails)
-end
-
-if defined?(::Rails) && ::Rails::VERSION::MAJOR < 4
-  $stderr.puts("**************************************************")
-  $stderr.puts("⛔️ WARNING: Sidekiq server is no longer supported by Rails 3.2 - please ensure your server/workers are updated")
-  $stderr.puts("**************************************************")
+  end
 end

data/lib/sidekiq/redis_connection.rb

@@ -1,36 +1,38 @@
 # frozen_string_literal: true
-require 'connection_pool'
-require 'redis'
-require 'uri'
+
+require "connection_pool"
+require "redis"
+require "uri"
 
 module Sidekiq
   class RedisConnection
     class << self
-
-      def create(options={})
+      def create(options = {})
         options.keys.each do |key|
           options[key.to_sym] = options.delete(key)
         end
 
-        options[:id] = "Sidekiq-#{Sidekiq.server? ? "server" : "client"}-PID-#{$$}" if !options.has_key?(:id)
+        options[:id] = "Sidekiq-#{Sidekiq.server? ? "server" : "client"}-PID-#{::Process.pid}" unless options.key?(:id)
         options[:url] ||= determine_redis_provider
 
         size = if options[:size]
-                 options[:size]
-               elsif Sidekiq.server?
-                 Sidekiq.options[:concurrency] + 5
-               elsif ENV['RAILS_MAX_THREADS']
-                 Integer(ENV['RAILS_MAX_THREADS'])
-               else
-                 5
-               end
+          options[:size]
+        elsif Sidekiq.server?
+          # Give ourselves plenty of connections.  pool is lazy
+          # so we won't create them until we need them.
+          Sidekiq.options[:concurrency] + 5
+        elsif ENV["RAILS_MAX_THREADS"]
+          Integer(ENV["RAILS_MAX_THREADS"])
+        else
+          5
+        end
 
         verify_sizing(size, Sidekiq.options[:concurrency]) if Sidekiq.server?
 
         pool_timeout = options[:pool_timeout] || 1
         log_info(options)
 
-        ConnectionPool.new(:timeout => pool_timeout, :size => size) do
+        ConnectionPool.new(timeout: pool_timeout, size: size) do
           build_client(options)
         end
       end
@@ -46,7 +48,7 @@ module Sidekiq
       #   - enterprise's leader election
       #   - enterprise's cron support
       def verify_sizing(size, concurrency)
-        raise ArgumentError, "Your Redis connection pool is too small for Sidekiq to work. Your pool has #{size} connections but must have at least #{concurrency + 2}" if size <= concurrency
+        raise ArgumentError, "Your Redis connection pool is too small for Sidekiq to work. Your pool has #{size} connections but must have at least #{concurrency + 2}" if size < (concurrency + 2)
       end
 
       def build_client(options)
@@ -55,8 +57,8 @@ module Sidekiq
         client = Redis.new client_opts(options)
         if namespace
           begin
-            require 'redis/namespace'
-            Redis::Namespace.new(namespace, :redis => client)
+            require "redis/namespace"
+            Redis::Namespace.new(namespace, redis: client)
           rescue LoadError
             Sidekiq.logger.error("Your Redis configuration uses the namespace '#{namespace}' but the redis-namespace gem is not included in the Gemfile." \
                                  "Add the gem to your Gemfile to continue using a namespace. Otherwise, remove the namespace parameter.")
@@ -78,7 +80,7 @@ module Sidekiq
           opts.delete(:network_timeout)
         end
 
-        opts[:driver] ||= Redis::Connection.drivers.last || 'ruby'
+        opts[:driver] ||= Redis::Connection.drivers.last || "ruby"
 
         # Issue #3303, redis-rb will silently retry an operation.
         # This can lead to duplicate jobs if Sidekiq::Client's LPUSH
@@ -115,30 +117,22 @@ module Sidekiq
         # REDIS_PROVIDER=MY_REDIS_URL
         # and Sidekiq will find your custom URL variable with no custom
         # initialization code at all.
-        p = ENV['REDIS_PROVIDER']
+        #
+        p = ENV["REDIS_PROVIDER"]
         if p && p =~ /\:/
-          Sidekiq.logger.error <<-EOM
-
-#################################################################################
-
-REDIS_PROVIDER should be set to the **name** of the variable which contains the Redis URL, not a URL itself.
-Platforms like Heroku sell addons that publish a *_URL variable.  You tell Sidekiq with REDIS_PROVIDER, e.g.:
+          raise <<~EOM
+            REDIS_PROVIDER should be set to the name of the variable which contains the Redis URL, not a URL itself.
+            Platforms like Heroku will sell addons that publish a *_URL variable.  You need to tell Sidekiq with REDIS_PROVIDER, e.g.:
 
-  REDIS_PROVIDER=REDISTOGO_URL
-  REDISTOGO_URL=redis://somehost.example.com:6379/4
-
-Use REDIS_URL if you wish to point Sidekiq to a URL directly.
-
-This configuration error will crash starting in Sidekiq 5.3.
-
-#################################################################################
-EOM
+            REDISTOGO_URL=redis://somehost.example.com:6379/4
+            REDIS_PROVIDER=REDISTOGO_URL
+          EOM
         end
+
         ENV[
-          ENV['REDIS_PROVIDER'] || 'REDIS_URL'
+          p || "REDIS_URL"
         ]
       end
-
     end
   end
 end