sidekiq 2.15.1 → 4.2.10

data/lib/sidekiq/rails.rb

@@ -1,19 +1,123 @@
+# frozen_string_literal: true
 module Sidekiq
   def self.hook_rails!
-    if defined?(::ActiveRecord)
-      ::ActiveRecord::Base.send(:include, Sidekiq::Extensions::ActiveRecord)
+    return if defined?(@delay_removed)
+
+    ActiveSupport.on_load(:active_record) do
+      include Sidekiq::Extensions::ActiveRecord
+    end
+
+    ActiveSupport.on_load(:action_mailer) do
+      extend Sidekiq::Extensions::ActionMailer
     end
 
-    if defined?(::ActionMailer)
-      ::ActionMailer::Base.extend(Sidekiq::Extensions::ActionMailer)
+    Module.__send__(:include, Sidekiq::Extensions::Klass)
+  end
+
+  # Removes the generic aliases which MAY clash with names of already
+  #  created methods by other applications. The methods `sidekiq_delay`,
+  #  `sidekiq_delay_for` and `sidekiq_delay_until` can be used instead.
+  def self.remove_delay!
+    @delay_removed = true
+
+    [Extensions::ActiveRecord,
+     Extensions::ActionMailer,
+     Extensions::Klass].each do |mod|
+      mod.module_eval do
+        remove_method :delay if respond_to?(:delay)
+        remove_method :delay_for if respond_to?(:delay_for)
+        remove_method :delay_until if respond_to?(:delay_until)
+      end
     end
   end
 
   class Rails < ::Rails::Engine
-    config.autoload_paths << File.expand_path("#{config.root}/app/workers") if File.exist?("#{config.root}/app/workers")
+    # We need to setup this up before any application configuration which might
+    # change Sidekiq middleware.
+    #
+    # 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
+      end
+    end
 
     initializer 'sidekiq' do
       Sidekiq.hook_rails!
     end
+
+    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
+          # The reloader also takes care of ActiveRecord but is incompatible with
+          # the ActiveRecord middleware so make sure it's not in the chain already.
+          if defined?(Sidekiq::Middleware::Server::ActiveRecord) && Sidekiq.server_middleware.exists?(Sidekiq::Middleware::Server::ActiveRecord)
+            raise ArgumentError, "You are using the Sidekiq ActiveRecord middleware and the new Rails 5 reloader which are incompatible. Please remove the ActiveRecord middleware from your Sidekiq middleware configuration."
+          elsif ::Rails.application.config.cache_classes
+            # The reloader API has proven to be troublesome under load in production.
+            # We won't use it at all when classes are cached, see #3154
+            Sidekiq.logger.debug { "Autoload disabled in #{::Rails.env}, Sidekiq will not reload changed classes" }
+            Sidekiq.options[:executor] = Sidekiq::Rails::Executor.new
+          else
+            Sidekiq.logger.debug { "Enabling Rails 5+ live code reloading, so hot!" }
+            Sidekiq.options[:reloader] = Sidekiq::Rails::Reloader.new
+            Psych::Visitors::ToRuby.prepend(Sidekiq::Rails::PsychAutoload)
+          end
+        end
+      end
+    end
+
+    class Executor
+      def initialize(app = ::Rails.application)
+        @app = app
+      end
+
+      def call
+        @app.executor.wrap do
+          yield
+        end
+      end
+
+      def inspect
+        "#<Sidekiq::Rails::Executor @app=#{@app.class.name}>"
+      end
+    end
+
+    class Reloader
+      def initialize(app = ::Rails.application)
+        @app = app
+      end
+
+      def call
+        @app.reloader.wrap do
+          yield
+        end
+      end
+
+      def inspect
+        "#<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

data/lib/sidekiq/redis_connection.rb

@@ -1,58 +1,104 @@
+# frozen_string_literal: true
 require 'connection_pool'
 require 'redis'
+require 'uri'
 
 module Sidekiq
   class RedisConnection
     class << self
 
       def create(options={})
-        url = options[:url] || determine_redis_provider || 'redis://localhost:6379/0'
-        # need a connection for Fetcher and Retry
-        size = options[:size] || (Sidekiq.server? ? (Sidekiq.options[:concurrency] + 2) : 5)
-        pool_timeout = options[:pool_timeout] || 1
+        options = options.symbolize_keys
+
+        options[:url] ||= determine_redis_provider
+
+        size = options[:size] || (Sidekiq.server? ? (Sidekiq.options[:concurrency] + 5) : 5)
 
-        log_info(url, options)
+        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
-          build_client(url, options[:namespace], options[:driver] || 'ruby', options[:network_timeout])
+          build_client(options)
         end
       end
 
       private
 
-      def build_client(url, namespace, driver, network_timeout)
-        client = Redis.new client_opts(url, driver, network_timeout)
+      # Sidekiq needs a lot of concurrent Redis connections.
+      #
+      # We need a connection for each Processor.
+      # We need a connection for Pro's real-time change listener
+      # We need a connection to various features to call Redis every few seconds:
+      #   - the process heartbeat.
+      #   - 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
+      end
+
+      def build_client(options)
+        namespace = options[:namespace]
+
+        client = Redis.new client_opts(options)
         if namespace
-          require 'redis/namespace'
-          Redis::Namespace.new(namespace, :redis => client)
+          begin
+            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.")
+            exit(-127)
+          end
         else
           client
         end
       end
 
-      def client_opts(url, driver, timeout)
-        if timeout
-          { :url => url, :driver => driver, :timeout => timeout }
-        else
-          { :url => url, :driver => driver }
+      def client_opts(options)
+        opts = options.dup
+        if opts[:namespace]
+          opts.delete(:namespace)
+        end
+
+        if opts[:network_timeout]
+          opts[:timeout] = opts[:network_timeout]
+          opts.delete(:network_timeout)
         end
+
+        opts[:driver] ||= 'ruby'
+
+        # Issue #3303, redis-rb will silently retry an operation.
+        # This can lead to duplicate jobs if Sidekiq::Client's LPUSH
+        # is performed twice but I believe this is much, much rarer
+        # than the reconnect silently fixing a problem; we keep it
+        # on by default.
+        opts[:reconnect_attempts] ||= 1
+
+        opts
       end
 
-      def log_info(url, options)
-        opts = options.dup
-        opts.delete(:url)
+      def log_info(options)
+        # Don't log Redis AUTH password
+        redacted = "REDACTED"
+        scrubbed_options = options.dup
+        if scrubbed_options[:url] && (uri = URI.parse(scrubbed_options[:url])) && uri.password
+          uri.password = redacted
+          scrubbed_options[:url] = uri.to_s
+        end
+        if scrubbed_options[:password]
+          scrubbed_options[:password] = redacted
+        end
         if Sidekiq.server?
-          Sidekiq.logger.info("Booting Sidekiq #{Sidekiq::VERSION} using #{url} with options #{opts}")
+          Sidekiq.logger.info("Booting Sidekiq #{Sidekiq::VERSION} with redis options #{scrubbed_options}")
         else
-          Sidekiq.logger.info("#{Sidekiq::NAME} client using #{url} with options #{opts}")
+          Sidekiq.logger.debug("#{Sidekiq::NAME} client with redis options #{scrubbed_options}")
         end
       end
 
       def determine_redis_provider
-        # REDISTOGO_URL is only support for legacy reasons
-        return ENV['REDISTOGO_URL'] if ENV['REDISTOGO_URL']
-        provider = ENV['REDIS_PROVIDER'] || 'REDIS_URL'
-        ENV[provider]
+        ENV[ENV['REDIS_PROVIDER'] || 'REDIS_URL']
       end
 
     end

data/lib/sidekiq/scheduled.rb

@@ -1,75 +1,147 @@
+# frozen_string_literal: true
 require 'sidekiq'
 require 'sidekiq/util'
-require 'sidekiq/actor'
+require 'sidekiq/api'
 
 module Sidekiq
   module Scheduled
+    SETS = %w(retry schedule)
 
-    POLL_INTERVAL = 15
+    class Enq
+      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|
+          sorted_sets.each do |sorted_set|
+            # Get the next item in the queue if it's score (time to execute) is <= now.
+            # 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
+
+              # 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}" }
+              end
+            end
+          end
+        end
+      end
+    end
 
     ##
-    # The Poller checks Redis every N seconds for messages in the retry or scheduled
+    # The Poller checks Redis every N seconds for jobs in the retry or scheduled
     # set have passed their timestamp and should be enqueued.  If so, it
-    # just pops the message back onto its original queue so the
-    # workers can pick it up like any other message.
+    # just pops the job back onto its original queue so the
+    # workers can pick it up like any other job.
     class Poller
       include Util
-      include Actor
-
-      SETS = %w(retry schedule)
-
-      def poll(first_time=false)
-        watchdog('scheduling poller thread died!') do
-          add_jitter if first_time
-
-          begin
-            # A message's "score" in Redis is the time at which it should be processed.
-            # Just check Redis for the set of messages with a timestamp before now.
-            now = Time.now.to_f.to_s
-            Sidekiq.redis do |conn|
-              SETS.each do |sorted_set|
-                # Get the next item in the queue if it's score (time to execute) is <= now.
-                # 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 message = conn.zrangebyscore(sorted_set, '-inf', now, :limit => [0, 1]).first do
-
-                  # 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, message)
-                    Sidekiq::Client.push(Sidekiq.load_json(message))
-                    logger.debug { "enqueued #{sorted_set}: #{message}" }
-                  end
-                end
-              end
-            end
-          rescue => ex
-            # Most likely a problem with redis networking.
-            # Punt and try again at the next interval
-            logger.error ex.message
-            logger.error ex.backtrace.first
-          end
 
-          after(poll_interval) { poll }
+      INITIAL_WAIT = 10
+
+      def initialize
+        @enq = (Sidekiq.options[:scheduled_enq] || Sidekiq::Scheduled::Enq).new
+        @sleeper = ConnectionPool::TimedStack.new
+        @done = false
+        @thread = nil
+      end
+
+      # Shut down this instance, will pause until the thread is dead.
+      def terminate
+        @done = true
+        if @thread
+          t = @thread
+          @thread = nil
+          @sleeper << 0
+          t.value
         end
       end
 
-      private
+      def start
+        @thread ||= safe_thread("scheduler") do
+          initial_wait
 
-      def poll_interval
-        Sidekiq.options[:poll_interval] || POLL_INTERVAL
+          while !@done
+            enqueue
+            wait
+          end
+          Sidekiq.logger.info("Scheduler exiting...")
+        end
       end
 
-      def add_jitter
+      def enqueue
         begin
-          sleep(poll_interval * rand)
-        rescue Celluloid::Task::TerminatedError
-          # Hit Ctrl-C when Sidekiq is finished booting and we have a chance
-          # to get here.
+          @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
       end
 
+      private
+
+      def wait
+        @sleeper.pop(random_poll_interval)
+      rescue Timeout::Error
+        # expected
+      rescue => ex
+        # 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
+        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
+      end
+
+      # We do our best to tune the poll interval to the size of the active Sidekiq
+      # cluster.  If you have 30 processes and poll every 15 seconds, that means one
+      # Sidekiq is checking Redis every 0.5 seconds - way too often for most people
+      # and really bad if the retry or scheduled sets are large.
+      #
+      # Instead try to avoid polling more than once every 15 seconds.  If you have
+      # 30 Sidekiq processes, we'll poll every 30 * 15 or 450 seconds.
+      # To keep things statistically random, we'll sleep a random amount between
+      # 225 and 675 seconds for each poll or 450 seconds on average.  Otherwise restarting
+      # all your Sidekiq processes at the same time will lead to them all polling at
+      # the same time: the thundering herd problem.
+      #
+      # We only do this if poll_interval_average is unset (the default).
+      def poll_interval_average
+        Sidekiq.options[:poll_interval_average] ||= scaled_poll_interval
+      end
+
+      # Calculates an average poll interval based on the number of known Sidekiq processes.
+      # 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
+        pcount = Sidekiq::ProcessSet.new.size
+        pcount = 1 if pcount == 0
+        pcount * Sidekiq.options[:average_scheduled_poll_interval]
+      end
+
+      def initial_wait
+        # Have all processes sleep between 5-15 seconds.  10 seconds
+        # to give time for the heartbeat to register (if the poll interval is going to be calculated by the number
+        # of workers), and 5 random seconds to ensure they don't all hit Redis at the same time.
+        total = 0
+        total += INITIAL_WAIT unless Sidekiq.options[:poll_interval_average]
+        total += (5 * rand)
+
+        @sleeper.pop(total)
+      rescue Timeout::Error
+      end
+
     end
   end
 end