sidekiq 5.2.10 → 6.5.12

data/lib/sidekiq/cli.rb

@@ -1,33 +1,42 @@
 # frozen_string_literal: true
-$stdout.sync = true
-
-require 'yaml'
-require 'singleton'
-require 'optparse'
-require 'erb'
-require 'fileutils'
 
-require 'sidekiq'
-require 'sidekiq/util'
-require 'sidekiq/launcher'
+$stdout.sync = true
 
-module Sidekiq
+require "yaml"
+require "singleton"
+require "optparse"
+require "erb"
+require "fileutils"
+
+require "sidekiq"
+require "sidekiq/component"
+require "sidekiq/launcher"
+
+# module ScoutApm
+# VERSION = "5.3.1"
+# end
+fail <<~EOM if defined?(ScoutApm::VERSION) && ScoutApm::VERSION < "5.2.0"
+  
+  
+  scout_apm v#{ScoutApm::VERSION} is unsafe with Sidekiq 6.5. Please run `bundle up scout_apm` to upgrade to 5.2.0 or greater.
+  
+  
+EOM
+
+module Sidekiq # :nodoc:
   class CLI
-    include Util
+    include Sidekiq::Component
     include Singleton unless $TESTING
 
-    PROCTITLES = [
-      proc { 'sidekiq' },
-      proc { Sidekiq::VERSION },
-      proc { |me, data| data['tag'] },
-      proc { |me, data| "[#{Processor::WORKER_STATE.size} of #{data['concurrency']} busy]" },
-      proc { |me, data| "stopping" if me.stopping? },
-    ]
-
     attr_accessor :launcher
     attr_accessor :environment
+    attr_accessor :config
+
+    def parse(args = ARGV.dup)
+      @config = Sidekiq
+      @config[:error_handlers].clear
+      @config[:error_handlers] << @config.method(:default_error_handler)
 
-    def parse(args = ARGV)
       setup_options(args)
       initialize_logger
       validate!
@@ -40,187 +49,190 @@ module Sidekiq
     # Code within this method is not tested because it alters
     # global process state irreversibly.  PRs which improve the
     # test coverage of Sidekiq::CLI are welcomed.
-    def run
-      daemonize if options[:daemon]
-      write_pid
-      boot_system
-      print_banner if environment == 'development' && $stdout.tty?
+    def run(boot_app: true)
+      boot_application if boot_app
 
-      self_read, self_write = IO.pipe
-      sigs = %w(INT TERM TTIN TSTP)
-      # USR1 and USR2 don't work on the JVM
-      if !jruby?
-        sigs << 'USR1'
-        sigs << 'USR2'
+      if environment == "development" && $stdout.tty? && @config.log_formatter.is_a?(Sidekiq::Logger::Formatters::Pretty)
+        print_banner
       end
+      logger.info "Booted Rails #{::Rails.version} application in #{environment} environment" if rails_app?
 
+      self_read, self_write = IO.pipe
+      sigs = %w[INT TERM TTIN TSTP]
+      # USR1 and USR2 don't work on the JVM
+      sigs << "USR2" if Sidekiq.pro? && !jruby?
       sigs.each do |sig|
-        begin
-          trap sig do
-            self_write.write("#{sig}\n")
+        old_handler = Signal.trap(sig) do
+          if old_handler.respond_to?(:call)
+            begin
+              old_handler.call
+            rescue Exception => exc
+              # signal handlers can't use Logger so puts only
+              puts ["Error in #{sig} handler", exc].inspect
+            end
           end
-        rescue ArgumentError
-          puts "Signal #{sig} not supported"
+          self_write.puts(sig)
         end
+      rescue ArgumentError
+        puts "Signal #{sig} not supported"
       end
 
       logger.info "Running in #{RUBY_DESCRIPTION}"
       logger.info Sidekiq::LICENSE
-      logger.info "Upgrade to Sidekiq Pro for more features and support: http://sidekiq.org" unless defined?(::Sidekiq::Pro)
+      logger.info "Upgrade to Sidekiq Pro for more features and support: https://sidekiq.org" unless defined?(::Sidekiq::Pro)
 
       # touch the connection pool so it is created before we
       # fire startup and start multithreading.
-      ver = Sidekiq.redis_info['redis_version']
-      raise "You are using Redis v#{ver}, Sidekiq requires Redis v2.8.0 or greater" if ver < '2.8'
-      logger.warn "Sidekiq 6.0 will require Redis 4.0+, you are using Redis v#{ver}" if ver < '4'
+      info = @config.redis_info
+      ver = info["redis_version"]
+      raise "You are connecting to Redis v#{ver}, Sidekiq requires Redis v4.0.0 or greater" if ver < "4"
+
+      maxmemory_policy = info["maxmemory_policy"]
+      if maxmemory_policy != "noeviction"
+        logger.warn <<~EOM
+
+
+          WARNING: Your Redis instance will evict Sidekiq data under heavy load.
+          The 'noeviction' maxmemory policy is recommended (current policy: '#{maxmemory_policy}').
+          See: https://github.com/mperham/sidekiq/wiki/Using-Redis#memory
+
+        EOM
+      end
 
       # Since the user can pass us a connection pool explicitly in the initializer, we
       # need to verify the size is large enough or else Sidekiq's performance is dramatically slowed.
-      cursize = Sidekiq.redis_pool.size
-      needed = Sidekiq.options[:concurrency] + 2
+      cursize = @config.redis_pool.size
+      needed = @config[:concurrency] + 2
       raise "Your pool of #{cursize} Redis connections is too small, please increase the size to at least #{needed}" if cursize < needed
 
       # cache process identity
-      Sidekiq.options[:identity] = identity
+      @config[:identity] = identity
 
       # Touch middleware so it isn't lazy loaded by multiple threads, #3043
-      Sidekiq.server_middleware
+      @config.server_middleware
 
       # Before this point, the process is initializing with just the main thread.
       # Starting here the process will now have multiple threads running.
       fire_event(:startup, reverse: false, reraise: true)
 
-      logger.debug { "Client Middleware: #{Sidekiq.client_middleware.map(&:klass).join(', ')}" }
-      logger.debug { "Server Middleware: #{Sidekiq.server_middleware.map(&:klass).join(', ')}" }
+      logger.debug { "Client Middleware: #{@config.client_middleware.map(&:klass).join(", ")}" }
+      logger.debug { "Server Middleware: #{@config.server_middleware.map(&:klass).join(", ")}" }
 
       launch(self_read)
     end
 
     def launch(self_read)
-      if !options[:daemon]
-        logger.info 'Starting processing, hit Ctrl-C to stop'
+      if environment == "development" && $stdout.tty?
+        logger.info "Starting processing, hit Ctrl-C to stop"
       end
 
-      @launcher = Sidekiq::Launcher.new(options)
+      @launcher = Sidekiq::Launcher.new(@config)
 
       begin
         launcher.run
 
-        while readable_io = IO.select([self_read])
-          signal = readable_io.first[0].gets.strip
+        while self_read.wait_readable
+          signal = self_read.gets.strip
           handle_signal(signal)
         end
       rescue Interrupt
-        logger.info 'Shutting down'
+        logger.info "Shutting down"
         launcher.stop
-        # Explicitly exit so busy Processor threads can't block
-        # process shutdown.
         logger.info "Bye!"
+
+        # Explicitly exit so busy Processor threads won't block process shutdown.
+        #
+        # NB: slow at_exit handlers will prevent a timely exit if they take
+        # a while to run. If Sidekiq is getting here but the process isn't exiting,
+        # use the TTIN signal to determine where things are stuck.
         exit(0)
       end
     end
 
+    def self.w
+      "\e[37m"
+    end
+
+    def self.r
+      "\e[31m"
+    end
+
+    def self.b
+      "\e[30m"
+    end
+
+    def self.reset
+      "\e[0m"
+    end
+
     def self.banner
-%q{
-         m,
-         `$b
-    .ss,  $$:         .,d$
-    `$$P,d$P'    .,md$P"'
-     ,$$$$$bmmd$$$P^'
-   .d$$$$$$$$$$P'
-   $$^' `"^$$$'       ____  _     _      _    _
-   $:     ,$$:       / ___|(_) __| | ___| | _(_) __ _
-   `b     :$$        \___ \| |/ _` |/ _ \ |/ / |/ _` |
-          $$:         ___) | | (_| |  __/   <| | (_| |
-          $$         |____/|_|\__,_|\___|_|\_\_|\__, |
-        .d$$                                       |_|
-}
+      %{
+      #{w}         m,
+      #{w}         `$b
+      #{w}    .ss,  $$:         .,d$
+      #{w}    `$$P,d$P'    .,md$P"'
+      #{w}     ,$$$$$b#{b}/#{w}md$$$P^'
+      #{w}   .d$$$$$$#{b}/#{w}$$$P'
+      #{w}   $$^' `"#{b}/#{w}$$$'       #{r}____  _     _      _    _
+      #{w}   $:     ,$$:      #{r} / ___|(_) __| | ___| | _(_) __ _
+      #{w}   `b     :$$       #{r} \\___ \\| |/ _` |/ _ \\ |/ / |/ _` |
+      #{w}          $$:        #{r} ___) | | (_| |  __/   <| | (_| |
+      #{w}          $$         #{r}|____/|_|\\__,_|\\___|_|\\_\\_|\\__, |
+      #{w}        .d$$          #{r}                             |_|
+      #{reset}}
     end
 
     SIGNAL_HANDLERS = {
       # Ctrl-C in terminal
-      'INT' => ->(cli) { raise Interrupt },
+      "INT" => ->(cli) { raise Interrupt },
       # TERM is the signal that Sidekiq must exit.
       # Heroku sends TERM and then waits 30 seconds for process to exit.
-      'TERM' => ->(cli) { raise Interrupt },
-      'USR1' => ->(cli) {
-        Sidekiq.logger.info "Received USR1, no longer accepting new work"
+      "TERM" => ->(cli) { raise Interrupt },
+      "TSTP" => ->(cli) {
+        cli.logger.info "Received TSTP, no longer accepting new work"
         cli.launcher.quiet
       },
-      'TSTP' => ->(cli) {
-        Sidekiq.logger.info "Received TSTP, no longer accepting new work"
-        cli.launcher.quiet
-      },
-      'USR2' => ->(cli) {
-        if Sidekiq.options[:logfile]
-          Sidekiq.logger.info "Received USR2, reopening log file"
-          Sidekiq::Logging.reopen_logs
-        end
-      },
-      'TTIN' => ->(cli) {
+      "TTIN" => ->(cli) {
         Thread.list.each do |thread|
-          Sidekiq.logger.warn "Thread TID-#{(thread.object_id ^ ::Process.pid).to_s(36)} #{thread['sidekiq_label']}"
+          cli.logger.warn "Thread TID-#{(thread.object_id ^ ::Process.pid).to_s(36)} #{thread.name}"
           if thread.backtrace
-            Sidekiq.logger.warn thread.backtrace.join("\n")
+            cli.logger.warn thread.backtrace.join("\n")
           else
-            Sidekiq.logger.warn "<no backtrace available>"
+            cli.logger.warn "<no backtrace available>"
           end
         end
-      },
+      }
     }
+    UNHANDLED_SIGNAL_HANDLER = ->(cli) { cli.logger.info "No signal handler registered, ignoring" }
+    SIGNAL_HANDLERS.default = UNHANDLED_SIGNAL_HANDLER
 
     def handle_signal(sig)
-      Sidekiq.logger.debug "Got #{sig} signal"
-      handy = SIGNAL_HANDLERS[sig]
-      if handy
-        handy.call(self)
-      else
-        Sidekiq.logger.info { "No signal handler for #{sig}" }
-      end
+      logger.debug "Got #{sig} signal"
+      SIGNAL_HANDLERS[sig].call(self)
     end
 
     private
 
     def print_banner
-      puts "\e[#{31}m"
+      puts "\e[31m"
       puts Sidekiq::CLI.banner
       puts "\e[0m"
     end
 
-    def daemonize
-      raise ArgumentError, "You really should set a logfile if you're going to daemonize" unless options[:logfile]
-
-      files_to_reopen = ObjectSpace.each_object(File).reject { |f| f.closed? }
-      ::Process.daemon(true, true)
-
-      files_to_reopen.each do |file|
-        begin
-          file.reopen file.path, "a+"
-          file.sync = true
-        rescue ::Exception
-        end
-      end
-
-      [$stdout, $stderr].each do |io|
-        File.open(options[:logfile], 'ab') do |f|
-          io.reopen(f)
-        end
-        io.sync = true
-      end
-      $stdin.reopen('/dev/null')
-
-      initialize_logger
-    end
-
     def set_environment(cli_env)
-      @environment = cli_env || ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      # See #984 for discussion.
+      # APP_ENV is now the preferred ENV term since it is not tech-specific.
+      # Both Sinatra 2.0+ and Sidekiq support this term.
+      # RAILS_ENV and RACK_ENV are there for legacy support.
+      @environment = cli_env || ENV["APP_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+      config[:environment] = @environment
     end
 
     def symbolize_keys_deep!(hash)
       hash.keys.each do |k|
         symkey = k.respond_to?(:to_sym) ? k.to_sym : k
         hash[symkey] = hash.delete k
-        symbolize_keys_deep! hash[symkey] if hash[symkey].kind_of? Hash
+        symbolize_keys_deep! hash[symkey] if hash[symkey].is_a? Hash
       end
     end
 
@@ -235,14 +247,14 @@ module Sidekiq
 
       # check config file presence
       if opts[:config_file]
-        if opts[:config_file] && !File.exist?(opts[:config_file])
+        unless File.exist?(opts[:config_file])
           raise ArgumentError, "No such file #{opts[:config_file]}"
         end
       else
         config_dir = if File.directory?(opts[:require].to_s)
-          File.join(opts[:require], 'config')
+          File.join(opts[:require], "config")
         else
-          File.join(options[:require], 'config')
+          File.join(@config[:require], "config")
         end
 
         %w[sidekiq.yml sidekiq.yml.erb].each do |config_file|
@@ -255,49 +267,36 @@ module Sidekiq
       opts = parse_config(opts[:config_file]).merge(opts) if opts[:config_file]
 
       # set defaults
-      opts[:queues] = Array(opts[:queues]) << 'default' if opts[:queues].nil? || opts[:queues].empty?
-      opts[:strict] = true if opts[:strict].nil?
+      opts[:queues] = ["default"] if opts[:queues].nil?
       opts[:concurrency] = Integer(ENV["RAILS_MAX_THREADS"]) if opts[:concurrency].nil? && ENV["RAILS_MAX_THREADS"]
 
       # merge with defaults
-      options.merge!(opts)
-    end
-
-    def options
-      Sidekiq.options
+      @config.merge!(opts)
     end
 
-    def boot_system
-      ENV['RACK_ENV'] = ENV['RAILS_ENV'] = environment
+    def boot_application
+      ENV["RACK_ENV"] = ENV["RAILS_ENV"] = environment
 
-      if File.directory?(options[:require])
-        require 'rails'
-        if ::Rails::VERSION::MAJOR < 4
+      if File.directory?(@config[:require])
+        require "rails"
+        if ::Rails::VERSION::MAJOR < 5
           raise "Sidekiq no longer supports this version of Rails"
-        elsif ::Rails::VERSION::MAJOR == 4
-          # Painful contortions, see 1791 for discussion
-          # No autoloading, we want to force eager load for everything.
-          require File.expand_path("#{options[:require]}/config/application.rb")
-          ::Rails::Application.initializer "sidekiq.eager_load" do
-            ::Rails.application.config.eager_load = true
-          end
-          require 'sidekiq/rails'
-          require File.expand_path("#{options[:require]}/config/environment.rb")
         else
-          require 'sidekiq/rails'
-          require File.expand_path("#{options[:require]}/config/environment.rb")
+          require "sidekiq/rails"
+          require File.expand_path("#{@config[:require]}/config/environment.rb")
         end
-        options[:tag] ||= default_tag
+        @config[:tag] ||= default_tag
       else
-        require options[:require]
+        require @config[:require]
       end
     end
 
     def default_tag
       dir = ::Rails.root
       name = File.basename(dir)
-      if name.to_i != 0 && prevdir = File.dirname(dir) # Capistrano release directory?
-        if File.basename(prevdir) == 'releases'
+      prevdir = File.dirname(dir) # Capistrano release directory?
+      if name.to_i != 0 && prevdir
+        if File.basename(prevdir) == "releases"
           return File.basename(File.dirname(prevdir))
         end
       end
@@ -305,58 +304,56 @@ module Sidekiq
     end
 
     def validate!
-      if !File.exist?(options[:require]) ||
-         (File.directory?(options[:require]) && !File.exist?("#{options[:require]}/config/application.rb"))
+      if !File.exist?(@config[:require]) ||
+          (File.directory?(@config[:require]) && !File.exist?("#{@config[:require]}/config/application.rb"))
         logger.info "=================================================================="
-        logger.info "  Please point sidekiq to a Rails 4/5 application or a Ruby file  "
-        logger.info "  to load your worker classes with -r [DIR|FILE]."
+        logger.info "  Please point Sidekiq to a Rails application or a Ruby file  "
+        logger.info "  to load your job classes with -r [DIR|FILE]."
         logger.info "=================================================================="
         logger.info @parser
         die(1)
       end
 
       [:concurrency, :timeout].each do |opt|
-        raise ArgumentError, "#{opt}: #{options[opt]} is not a valid value" if options.has_key?(opt) && options[opt].to_i <= 0
+        raise ArgumentError, "#{opt}: #{@config[opt]} is not a valid value" if @config[opt].to_i <= 0
       end
     end
 
     def parse_options(argv)
       opts = {}
+      @parser = option_parser(opts)
+      @parser.parse!(argv)
+      opts
+    end
 
-      @parser = OptionParser.new do |o|
-        o.on '-c', '--concurrency INT', "processor threads to use" do |arg|
+    def option_parser(opts)
+      parser = OptionParser.new { |o|
+        o.on "-c", "--concurrency INT", "processor threads to use" do |arg|
           opts[:concurrency] = Integer(arg)
         end
 
-        o.on '-d', '--daemon', "Daemonize process" do |arg|
-          opts[:daemon] = arg
-          puts "WARNING: Daemonization mode will be removed in Sidekiq 6.0, see #4045. Please use a proper process supervisor to start and manage your services"
+        o.on "-d", "--daemon", "Daemonize process" do |arg|
+          puts "ERROR: Daemonization mode was removed in Sidekiq 6.0, please use a proper process supervisor to start and manage your services"
         end
 
-        o.on '-e', '--environment ENV', "Application environment" do |arg|
+        o.on "-e", "--environment ENV", "Application environment" do |arg|
           opts[:environment] = arg
         end
 
-        o.on '-g', '--tag TAG', "Process tag for procline" do |arg|
+        o.on "-g", "--tag TAG", "Process tag for procline" do |arg|
           opts[:tag] = arg
         end
 
-        # this index remains here for backwards compatibility but none of the Sidekiq
-        # family use this value anymore.  it was used by Pro's original reliable_fetch.
-        o.on '-i', '--index INT', "unique process index on this machine" do |arg|
-          opts[:index] = Integer(arg.match(/\d+/)[0])
-        end
-
         o.on "-q", "--queue QUEUE[,WEIGHT]", "Queues to process with optional weights" do |arg|
           queue, weight = arg.split(",")
           parse_queue opts, queue, weight
         end
 
-        o.on '-r', '--require [PATH|DIR]', "Location of Rails application with workers or file to require" do |arg|
+        o.on "-r", "--require [PATH|DIR]", "Location of Rails application with jobs or file to require" do |arg|
           opts[:require] = arg
         end
 
-        o.on '-t', '--timeout NUM', "Shutdown timeout" do |arg|
+        o.on "-t", "--timeout NUM", "Shutdown timeout" do |arg|
           opts[:timeout] = Integer(arg)
         end
 
@@ -364,54 +361,41 @@ module Sidekiq
           opts[:verbose] = arg
         end
 
-        o.on '-C', '--config PATH', "path to YAML config file" do |arg|
+        o.on "-C", "--config PATH", "path to YAML config file" do |arg|
           opts[:config_file] = arg
         end
 
-        o.on '-L', '--logfile PATH', "path to writable logfile" do |arg|
-          opts[:logfile] = arg
-          puts "WARNING: Logfile redirection will be removed in Sidekiq 6.0, see #4045. Sidekiq will only log to STDOUT"
+        o.on "-L", "--logfile PATH", "path to writable logfile" do |arg|
+          puts "ERROR: Logfile redirection was removed in Sidekiq 6.0, Sidekiq will only log to STDOUT"
         end
 
-        o.on '-P', '--pidfile PATH', "path to pidfile" do |arg|
-          opts[:pidfile] = arg
-          puts "WARNING: PID file creation will be removed in Sidekiq 6.0, see #4045. Please use a proper process supervisor to start and manage your services"
+        o.on "-P", "--pidfile PATH", "path to pidfile" do |arg|
+          puts "ERROR: PID file creation was removed in Sidekiq 6.0, please use a proper process supervisor to start and manage your services"
         end
 
-        o.on '-V', '--version', "Print version and exit" do |arg|
+        o.on "-V", "--version", "Print version and exit" do |arg|
           puts "Sidekiq #{Sidekiq::VERSION}"
           die(0)
         end
-      end
+      }
 
-      @parser.banner = "sidekiq [options]"
-      @parser.on_tail "-h", "--help", "Show help" do
-        logger.info @parser
+      parser.banner = "sidekiq [options]"
+      parser.on_tail "-h", "--help", "Show help" do
+        logger.info parser
         die 1
       end
 
-      @parser.parse!(argv)
-
-      opts
+      parser
     end
 
     def initialize_logger
-      Sidekiq::Logging.initialize_logger(options[:logfile]) if options[:logfile]
-
-      Sidekiq.logger.level = ::Logger::DEBUG if options[:verbose]
-    end
-
-    def write_pid
-      if path = options[:pidfile]
-        pidfile = File.expand_path(path)
-        File.open(pidfile, 'w') do |f|
-          f.puts ::Process.pid
-        end
-      end
+      @config.logger.level = ::Logger::DEBUG if @config[:verbose]
     end
 
     def parse_config(path)
-      opts = YAML.load(ERB.new(File.read(path)).result) || {}
+      erb = ERB.new(File.read(path))
+      erb.filename = File.expand_path(path)
+      opts = load_yaml(erb.result) || {}
 
       if opts.respond_to? :deep_symbolize_keys!
         opts.deep_symbolize_keys!
@@ -420,26 +404,38 @@ module Sidekiq
       end
 
       opts = opts.merge(opts.delete(environment.to_sym) || {})
+      opts.delete(:strict)
+
       parse_queues(opts, opts.delete(:queues) || [])
 
-      ns = opts.delete(:namespace)
-      if ns
-        # logger hasn't been initialized yet, puts is all we have.
-        puts("namespace should be set in your ruby initializer, is ignored in config file")
-        puts("config.redis = { :url => ..., :namespace => '#{ns}' }")
-      end
       opts
     end
 
+    def load_yaml(src)
+      if Psych::VERSION > "4.0"
+        YAML.safe_load(src, permitted_classes: [Symbol], aliases: true)
+      else
+        YAML.load(src)
+      end
+    end
+
     def parse_queues(opts, queues_and_weights)
       queues_and_weights.each { |queue_and_weight| parse_queue(opts, *queue_and_weight) }
     end
 
     def parse_queue(opts, queue, weight = nil)
       opts[:queues] ||= []
+      opts[:strict] = true if opts[:strict].nil?
       raise ArgumentError, "queues: #{queue} cannot be defined twice" if opts[:queues].include?(queue)
-      [weight.to_i, 1].max.times { opts[:queues] << queue }
+      [weight.to_i, 1].max.times { opts[:queues] << queue.to_s }
       opts[:strict] = false if weight.to_i > 0
     end
+
+    def rails_app?
+      defined?(::Rails) && ::Rails.respond_to?(:application)
+    end
   end
 end
+
+require "sidekiq/systemd"
+require "sidekiq/metrics/tracking" if ENV["SIDEKIQ_METRICS_BETA"]