sidekiq 5.0.0 → 6.0.0

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
-          Psych::Visitors::ToRuby.prepend(Sidekiq::Rails::PsychAutoload)
-        end
+        Sidekiq.options[:reloader] = Sidekiq::Rails::Reloader.new
       end
     end
 
@@ -48,13 +48,5 @@ module Sidekiq
         "#<Sidekiq::Rails::Reloader @app=#{@app.class.name}>"
       end
     end
-
-    module PsychAutoload
-      def resolve_class(klass_name)
-        klass_name && klass_name.constantize
-      rescue NameError
-        super
-      end
-    end
-  end if defined?(::Rails)
+  end
 end

data/lib/sidekiq/redis_connection.rb

@@ -1,25 +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 = {})
+        options.keys.each do |key|
+          options[key.to_sym] = options.delete(key)
+        end
 
-      def create(options={})
-        options = options.symbolize_keys
-
+        options[:id] = "Sidekiq-#{Sidekiq.server? ? "server" : "client"}-PID-#{::Process.pid}" unless options.key?(:id)
         options[:url] ||= determine_redis_provider
 
-        size = options[:size] || (Sidekiq.server? ? (Sidekiq.options[:concurrency] + 5) : 5)
+        size = if options[:size]
+          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
@@ -35,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 really needs to 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)
@@ -44,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.")
@@ -67,7 +80,7 @@ module Sidekiq
           opts.delete(:network_timeout)
         end
 
-        opts[:driver] ||= 'ruby'.freeze
+        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
@@ -98,9 +111,28 @@ module Sidekiq
       end
 
       def determine_redis_provider
-        ENV[ENV['REDIS_PROVIDER'] || 'REDIS_URL']
-      end
+        # If you have this in your environment:
+        # MY_REDIS_URL=redis://hostname.example.com:1238/4
+        # then set:
+        # REDIS_PROVIDER=MY_REDIS_URL
+        # and Sidekiq will find your custom URL variable with no custom
+        # initialization code at all.
+        #
+        p = ENV["REDIS_PROVIDER"]
+        if p && p =~ /\:/
+          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.:
+
+            REDISTOGO_URL=redis://somehost.example.com:6379/4
+            REDIS_PROVIDER=REDISTOGO_URL
+          EOM
+        end
 
+        ENV[
+          p || "REDIS_URL"
+        ]
+      end
     end
   end
 end

data/lib/sidekiq/scheduled.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
-require 'sidekiq'
-require 'sidekiq/util'
-require 'sidekiq/api'
+
+require "sidekiq"
+require "sidekiq/util"
+require "sidekiq/api"
 
 module Sidekiq
   module Scheduled
-    SETS = %w(retry schedule)
+    SETS = %w[retry schedule]
 
     class Enq
-      def enqueue_jobs(now=Time.now.to_f.to_s, sorted_sets=SETS)
+      def enqueue_jobs(now = Time.now.to_f.to_s, sorted_sets = SETS)
         # A job's "score" in Redis is the time at which it should be processed.
         # Just check Redis for the set of jobs with a timestamp before now.
         Sidekiq.redis do |conn|
@@ -17,14 +18,14 @@ module Sidekiq
             # We need to go through the list one at a time to reduce the risk of something
             # going wrong between the time jobs are popped from the scheduled queue and when
             # they are pushed onto a work queue and losing the jobs.
-            while job = conn.zrangebyscore(sorted_set, '-inf'.freeze, now, :limit => [0, 1]).first do
+            while (job = conn.zrangebyscore(sorted_set, "-inf", now, limit: [0, 1]).first)
 
               # Pop item off the queue and add it to the work queue. If the job can't be popped from
               # the queue, it's because another process already popped it so we can move on to the
               # next one.
               if conn.zrem(sorted_set, job)
                 Sidekiq::Client.push(Sidekiq.load_json(job))
-                Sidekiq::Logging.logger.debug { "enqueued #{sorted_set}: #{job}" }
+                Sidekiq.logger.debug { "enqueued #{sorted_set}: #{job}" }
               end
             end
           end
@@ -61,28 +62,24 @@ module Sidekiq
       end
 
       def start
-        @thread ||= safe_thread("scheduler") do
+        @thread ||= safe_thread("scheduler") {
           initial_wait
 
-          while !@done
+          until @done
             enqueue
             wait
           end
           Sidekiq.logger.info("Scheduler exiting...")
-        end
+        }
       end
 
       def enqueue
-        begin
-          @enq.enqueue_jobs
-        rescue => ex
-          # Most likely a problem with redis networking.
-          # Punt and try again at the next interval
-          logger.error ex.message
-          ex.backtrace.each do |bt|
-            logger.error(bt)
-          end
-        end
+        @enq.enqueue_jobs
+      rescue => ex
+        # Most likely a problem with redis networking.
+        # Punt and try again at the next interval
+        logger.error ex.message
+        handle_exception(ex)
       end
 
       private
@@ -95,13 +92,38 @@ module Sidekiq
         # if poll_interval_average hasn't been calculated yet, we can
         # raise an error trying to reach Redis.
         logger.error ex.message
-        logger.error ex.backtrace.first
+        handle_exception(ex)
         sleep 5
       end
 
-      # Calculates a random interval that is ±50% the desired average.
       def random_poll_interval
-        poll_interval_average * rand + poll_interval_average.to_f / 2
+        # We want one Sidekiq process to schedule jobs every N seconds.  We have M processes
+        # and **don't** want to coordinate.
+        #
+        # So in N*M second timespan, we want each process to schedule once.  The basic loop is:
+        #
+        # * sleep a random amount within that N*M timespan
+        # * wake up and schedule
+        #
+        # We want to avoid one edge case: imagine a set of 2 processes, scheduling every 5 seconds,
+        # so N*M = 10.  Each process decides to randomly sleep 8 seconds, now we've failed to meet
+        # that 5 second average. Thankfully each schedule cycle will sleep randomly so the next
+        # iteration could see each process sleep for 1 second, undercutting our average.
+        #
+        # So below 10 processes, we special case and ensure the processes sleep closer to the average.
+        # In the example above, each process should schedule every 10 seconds on average. We special
+        # case smaller clusters to add 50% so they would sleep somewhere between 5 and 15 seconds.
+        # As we run more processes, the scheduling interval average will approach an even spread
+        # between 0 and poll interval so we don't need this artifical boost.
+        #
+        if process_count < 10
+          # For small clusters, calculate a random interval that is ±50% the desired average.
+          poll_interval_average * rand + poll_interval_average.to_f / 2
+        else
+          # With 10+ processes, we should have enough randomness to get decent polling
+          # across the entire timespan
+          poll_interval_average * rand
+        end
       end
 
       # We do our best to tune the poll interval to the size of the active Sidekiq
@@ -125,9 +147,13 @@ module Sidekiq
       # This minimizes a single point of failure by dispersing check-ins but without taxing
       # Redis if you run many Sidekiq processes.
       def scaled_poll_interval
+        process_count * Sidekiq.options[:average_scheduled_poll_interval]
+      end
+
+      def process_count
         pcount = Sidekiq::ProcessSet.new.size
         pcount = 1 if pcount == 0
-        pcount * Sidekiq.options[:average_scheduled_poll_interval]
+        pcount
       end
 
       def initial_wait
@@ -141,7 +167,6 @@ module Sidekiq
         @sleeper.pop(total)
       rescue Timeout::Error
       end
-
     end
   end
 end

data/lib/sidekiq/testing.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
-require 'securerandom'
-require 'sidekiq'
 
-module Sidekiq
+require "securerandom"
+require "sidekiq"
 
+module Sidekiq
   class Testing
     class << self
       attr_accessor :__test_mode
 
       def __set_test_mode(mode)
         if block_given?
-          current_mode = self.__test_mode
+          current_mode = __test_mode
           begin
             self.__test_mode = mode
             yield
@@ -35,19 +35,19 @@ module Sidekiq
       end
 
       def enabled?
-        self.__test_mode != :disable
+        __test_mode != :disable
       end
 
       def disabled?
-        self.__test_mode == :disable
+        __test_mode == :disable
       end
 
       def fake?
-        self.__test_mode == :fake
+        __test_mode == :fake
       end
 
       def inline?
-        self.__test_mode == :inline
+        __test_mode == :inline
       end
 
       def server_middleware
@@ -55,6 +55,15 @@ module Sidekiq
         yield @server_chain if block_given?
         @server_chain
       end
+
+      def constantize(str)
+        names = str.split("::")
+        names.shift if names.empty? || names.first.empty?
+
+        names.inject(Object) do |constant, name|
+          constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+      end
     end
   end
 
@@ -63,31 +72,31 @@ module Sidekiq
 
   class EmptyQueueError < RuntimeError; end
 
-  class Client
-    alias_method :raw_push_real, :raw_push
-
+  module TestingClient
     def raw_push(payloads)
       if Sidekiq::Testing.fake?
         payloads.each do |job|
           job = Sidekiq.load_json(Sidekiq.dump_json(job))
-          job.merge!('enqueued_at' => Time.now.to_f) unless job['at']
-          Queues.push(job['queue'], job['class'], job)
+          job["enqueued_at"] = Time.now.to_f unless job["at"]
+          Queues.push(job["queue"], job["class"], job)
         end
         true
       elsif Sidekiq::Testing.inline?
         payloads.each do |job|
-          klass = job['class'].constantize
-          job['id'] ||= SecureRandom.hex(12)
+          klass = Sidekiq::Testing.constantize(job["class"])
+          job["id"] ||= SecureRandom.hex(12)
           job_hash = Sidekiq.load_json(Sidekiq.dump_json(job))
           klass.process_job(job_hash)
         end
         true
       else
-        raw_push_real(payloads)
+        super
       end
     end
   end
 
+  Sidekiq::Client.prepend TestingClient
+
   module Queues
     ##
     # The Queues class is only for testing the fake queue implementation.
@@ -246,27 +255,26 @@ module Sidekiq
     #   Then I should receive a welcome email to "foo@example.com"
     #
     module ClassMethods
-
       # Queue for this worker
       def queue
-        self.sidekiq_options["queue"]
+        get_sidekiq_options["queue"]
       end
 
       # Jobs queued for this worker
       def jobs
-        Queues.jobs_by_worker[self.to_s]
+        Queues.jobs_by_worker[to_s]
       end
 
       # Clear all jobs for this worker
       def clear
-        Queues.clear_for(queue, self.to_s)
+        Queues.clear_for(queue, to_s)
       end
 
       # Drain and run all jobs for this worker
       def drain
         while jobs.any?
           next_job = jobs.first
-          Queues.delete_for(next_job["jid"], next_job["queue"], self.to_s)
+          Queues.delete_for(next_job["jid"], next_job["queue"], to_s)
           process_job(next_job)
         end
       end
@@ -275,16 +283,16 @@ module Sidekiq
       def perform_one
         raise(EmptyQueueError, "perform_one called with empty job queue") if jobs.empty?
         next_job = jobs.first
-        Queues.delete_for(next_job["jid"], queue, self.to_s)
+        Queues.delete_for(next_job["jid"], queue, to_s)
         process_job(next_job)
       end
 
       def process_job(job)
         worker = new
-        worker.jid = job['jid']
-        worker.bid = job['bid'] if worker.respond_to?(:bid=)
-        Sidekiq::Testing.server_middleware.invoke(worker, job, job['queue']) do
-          execute_job(worker, job['args'])
+        worker.jid = job["jid"]
+        worker.bid = job["bid"] if worker.respond_to?(:bid=)
+        Sidekiq::Testing.server_middleware.invoke(worker, job, job["queue"]) do
+          execute_job(worker, job["args"])
         end
       end
 
@@ -309,7 +317,7 @@ module Sidekiq
           worker_classes = jobs.map { |job| job["class"] }.uniq
 
           worker_classes.each do |worker_class|
-            worker_class.constantize.drain
+            Sidekiq::Testing.constantize(worker_class).drain
           end
         end
       end