sidekiq 6.5.12 → 7.2.4

data/bin/multi_queue_bench

@@ -0,0 +1,271 @@
+#!/usr/bin/env ruby
+
+#
+# bin/bench is a helpful script to load test and
+# performance tune Sidekiq's core. It's a configurable script,
+# which accepts the following parameters as ENV variables.
+#
+# QUEUES
+# Number of queues to consume from. Default is 8
+#
+# PROCESSES
+# The number of processes this benchmark will create. Each process, consumes
+# from one of the available queues. When processes are more than the number of
+# queues, they are distributed to processes in round robin. Default is 8
+#
+# ELEMENTS
+# Number of jobs to push to each queue. Default is 1000
+#
+# ITERATIONS
+# Each queue pushes ITERATIONS times ELEMENTS jobs. Default is 1000
+#
+# PORT
+# The port of the Dragonfly instance. Default is 6379
+#
+# IP
+# The ip of the Dragonfly instance. Default is 127.0.0.1
+#
+# Example Usage:
+#
+# > RUBY_YJIT_ENABLE=1 THREADS=10 PROCESSES=8 QUEUES=8 bin/multi_queue_bench
+#
+# None of this script is considered a public API and may change over time.
+#
+
+# Quiet some warnings we see when running in warning mode:
+# RUBYOPT=-w bundle exec sidekiq
+$TESTING = false
+puts RUBY_DESCRIPTION
+
+require "bundler/setup"
+Bundler.require(:default, :load_test)
+
+class LoadWorker
+  include Sidekiq::Job
+  sidekiq_options retry: 1
+  sidekiq_retry_in do |x|
+    1
+  end
+
+  def perform(idx, ts = nil)
+    puts(Time.now.to_f - ts) if !ts.nil?
+    # raise idx.to_s if idx % 100 == 1
+  end
+end
+
+def Process.rss
+  `ps -o rss= -p #{Process.pid}`.chomp.to_i
+end
+
+$iterations = ENV["ITERATIONS"] ? Integer(ENV["ITERATIONS"]) : 1_000
+$elements = ENV["ELEMENTS"] ? Integer(ENV["ELEMENTS"]) : 1_000
+$port = ENV["PORT"] ? Integer(ENV["PORT"]) : 6379
+$ip = ENV["IP"] ? String(ENV["IP"]) : "127.0.0.1"
+
+class Loader
+  def initialize
+    @iter =  $iterations
+    @count = $elements
+  end
+
+  def configure(queue)
+    @x = Sidekiq.configure_embed do |config|
+      config.redis = {db: 0, host: $ip, port: $port}
+      config.concurrency = Integer(ENV.fetch("THREADS", "30"))
+      config.queues = queue
+      config.logger.level = Logger::WARN
+      config.average_scheduled_poll_interval = 2
+      config.reliable! if defined?(Sidekiq::Pro)
+    end
+
+    @self_read, @self_write = IO.pipe
+    %w[INT TERM TSTP TTIN].each do |sig|
+      trap sig do
+        @self_write.puts(sig)
+      end
+    rescue ArgumentError
+      puts "Signal #{sig} not supported"
+    end
+  end
+
+  def handle_signal(sig)
+    launcher = @x
+    Sidekiq.logger.debug "Got #{sig} signal"
+    case sig
+    when "INT"
+      # Handle Ctrl-C in JRuby like MRI
+      # http://jira.codehaus.org/browse/JRUBY-4637
+      raise Interrupt
+    when "TERM"
+      # Heroku sends TERM and then waits 30 seconds for process to exit.
+      raise Interrupt
+    when "TSTP"
+      Sidekiq.logger.info "Received TSTP, no longer accepting new work"
+      launcher.quiet
+    when "TTIN"
+      Thread.list.each do |thread|
+        Sidekiq.logger.warn "Thread TID-#{(thread.object_id ^ ::Process.pid).to_s(36)} #{thread["label"]}"
+        if thread.backtrace
+          Sidekiq.logger.warn thread.backtrace.join("\n")
+        else
+          Sidekiq.logger.warn "<no backtrace available>"
+        end
+      end
+    end
+  end
+
+  def setup(queue)
+    Sidekiq.logger.error("Setup RSS: #{Process.rss}")
+    Sidekiq.logger.error("Pushing work to queue: #{queue}")
+    start = Time.now
+    @iter.times do
+      arr = Array.new(@count) { |idx| [idx] }
+      # Sidekiq always prepends "queue:" to the queue name,
+      # that's why we pass 'q1', 'q2', etc instead of 'queue:q1'
+      Sidekiq::Client.push_bulk("class" => LoadWorker, "args" => arr, "queue" => queue)
+      $stdout.write "."
+    end
+    puts "Done"
+  end
+
+  def monitor_single(queue)
+    q = "queue:#{queue}"
+    @monitor_single = Thread.new do
+      GC.start
+      loop do
+        sleep 0.2
+        total = Sidekiq.redis do |conn|
+          conn.llen q
+        end
+
+        if total == 0
+          sleep 0.1
+          @x.stop
+          Process.kill("INT", $$)
+          break
+        end
+
+      end
+    end
+  end
+
+  def monitor_all(queues)
+    @monitor_all = Thread.new do
+      GC.start
+      loop do
+        sleep 0.2
+        qsize = 0
+        queues.each do |q|
+          tmp = Sidekiq.redis do |conn|
+            conn.llen q
+          end
+          qsize = qsize + tmp
+        end
+        total = qsize
+
+        if total == 0
+          ending = Time.now - @start
+          size = @iter * @count * queues.length()
+          Sidekiq.logger.error("Done, #{size} jobs in #{ending} sec, #{(size / ending).to_i} jobs/sec")
+          Sidekiq.logger.error("Ending RSS: #{Process.rss}")
+
+          sleep 0.1
+          @x.stop
+          Process.kill("INT", $$)
+          break
+        end
+      end
+    end
+  end
+
+  def run(queues, queue, monitor_all_queues)
+    Sidekiq.logger.warn("Consuming from #{queue}")
+    if monitor_all_queues
+      monitor_all(queues)
+    else
+      monitor_single(queue)
+    end
+
+    @start = Time.now
+    @x.run
+
+    while (readable_io = IO.select([@self_read]))
+      signal = readable_io.first[0].gets.strip
+      handle_signal(signal)
+    end
+    # normal
+  rescue Interrupt
+  rescue => e
+    raise e if $DEBUG
+    warn e.message
+    warn e.backtrace.join("\n")
+    exit 1
+  ensure
+    @x.stop
+  end
+end
+
+def setup(queue)
+  ll = Loader.new
+  ll.configure(queue)
+  ll.setup(queue)
+end
+
+def consume(queues, queue, monitor_all_queues)
+  ll = Loader.new
+  ll.configure(queue)
+  ll.run(queues, queue, monitor_all_queues)
+end
+
+# We assign one queue to each sidekiq process
+def run(number_of_processes, total_queues)
+  read_stream, write_stream = IO.pipe
+
+  queues = []
+  (0..total_queues-1).each do |idx|
+    queues.push("queue:q#{idx}")
+  end
+
+  Sidekiq.logger.info("Queues are: #{queues}")
+
+  # Produce
+  start = Time.now
+  (0..total_queues-1).each do |idx|
+    Process.fork do
+      queue_num = "q#{idx}"
+      setup(queue_num)
+    end
+  end
+
+  queue_sz = $iterations * $elements * total_queues
+  Process.waitall
+
+  ending = Time.now - start
+  #Sidekiq.logger.info("Pushed #{queue_sz} in #{ending} secs")
+
+  # Consume
+  (0..number_of_processes-1).each do |idx|
+    Process.fork do
+      # First process only consumes from it's own queue but monitors all queues.
+      # It works as a synchronization point. Once all processes finish
+      # (that is, when all queues are emptied) it prints the the stats.
+      if idx == 0
+        queue = "q#{idx}"
+        consume(queues, queue, true)
+      else
+        queue = "q#{idx % total_queues}"
+        consume(queues, queue, false)
+      end
+    end
+  end
+
+  Process.waitall
+  write_stream.close
+  results = read_stream.read
+  read_stream.close
+end
+
+$total_processes = ENV["PROCESSES"] ? Integer(ENV["PROCESSES"]) : 8;
+$total_queues = ENV["QUEUES"] ? Integer(ENV["QUEUES"]) : 8;
+
+run($total_processes, $total_queues)

data/bin/sidekiq

@@ -10,7 +10,7 @@ def integrate_with_systemd
   return unless ENV["NOTIFY_SOCKET"]
 
   Sidekiq.configure_server do |config|
-    Sidekiq.logger.info "Enabling systemd notification integration"
+    config.logger.info "Enabling systemd notification integration"
     require "sidekiq/sd_notify"
     config.on(:startup) do
       Sidekiq::SdNotify.ready
@@ -31,12 +31,7 @@ begin
   cli.run
 rescue => e
   raise e if $DEBUG
-  if Sidekiq.error_handlers.length == 0
-    warn e.message
-    warn e.backtrace.join("\n")
-  else
-    cli.handle_exception e
-  end
-
+  warn e.message
+  warn e.backtrace.join("\n")
   exit 1
 end

data/bin/sidekiqload

@@ -1,32 +1,63 @@
 #!/usr/bin/env ruby
 
+#
+# bin/sidekiqload is a helpful script to load test and
+# performance tune Sidekiq's core. It creates 500,000 no-op
+# jobs and executes them as fast as possible.
+# Example Usage:
+#
+# > RUBY_YJIT_ENABLE=1 LATENCY=0 THREADS=10 bin/sidekiqload
+# Result: Done, 500000 jobs in 20.264945 sec, 24673 jobs/sec
+#
+# Use LATENCY=1 to get a more real world network setup
+# but you'll need to setup and start toxiproxy as noted below.
+#
+# Use AJ=1 to test ActiveJob instead of plain old Sidekiq::Jobs so
+# you can see the runtime performance difference between the two APIs.
+#
+# None of this script is considered a public API and may change over time.
+#
+
 # Quiet some warnings we see when running in warning mode:
 # RUBYOPT=-w bundle exec sidekiq
 $TESTING = false
+puts RUBY_DESCRIPTION
+puts(%w[THREADS LATENCY AJ PROFILE].map { |x| "#{x}: #{ENV[x] || "nil"}" }.join(", "))
 
-# require "ruby-prof"
+require "ruby-prof" if ENV["PROFILE"]
 require "bundler/setup"
 Bundler.require(:default, :load_test)
 
-require_relative "../lib/sidekiq/cli"
-require_relative "../lib/sidekiq/launcher"
-
-if ENV["SIDEKIQ_REDIS_CLIENT"]
-  Sidekiq::RedisConnection.adapter = :redis_client
+latency = Integer(ENV["LATENCY"] || 1)
+if latency > 0
+  # brew tap shopify/shopify
+  # brew install toxiproxy
+  # run `toxiproxy-server` in a separate terminal window.
+  require "toxiproxy"
+  # simulate a non-localhost network for realer-world conditions.
+  # adding 1ms of network latency has an ENORMOUS impact on benchmarks
+  Toxiproxy.populate([{
+    name: "redis",
+    listen: "127.0.0.1:6380",
+    upstream: "127.0.0.1:6379"
+  }])
 end
 
-Sidekiq.configure_server do |config|
-  config.options[:concurrency] = 10
-  config.redis = {db: 13, port: 6380}
-  # config.redis = { db: 13, port: 6380, driver: :hiredis}
-  config.options[:queues] << "default"
-  config.logger.level = Logger::ERROR
-  config.average_scheduled_poll_interval = 2
-  config.reliable! if defined?(Sidekiq::Pro)
+if ENV["AJ"]
+  require "active_job"
+  puts "Using ActiveJob #{ActiveJob::VERSION::STRING}"
+  ActiveJob::Base.queue_adapter = :sidekiq
+  ActiveJob::Base.logger.level = Logger::WARN
+
+  class LoadJob < ActiveJob::Base
+    def perform(idx, ts = nil)
+      puts(Time.now.to_f - ts) if !ts.nil?
+    end
+  end
 end
 
 class LoadWorker
-  include Sidekiq::Worker
+  include Sidekiq::Job
   sidekiq_options retry: 1
   sidekiq_retry_in do |x|
     1
@@ -38,124 +69,179 @@ class LoadWorker
   end
 end
 
-# brew tap shopify/shopify
-# brew install toxiproxy
-# run `toxiproxy-server` in a separate terminal window.
-require "toxiproxy"
-# simulate a non-localhost network for realer-world conditions.
-# adding 1ms of network latency has an ENORMOUS impact on benchmarks
-Toxiproxy.populate([{
-  name: "redis",
-  listen: "127.0.0.1:6380",
-  upstream: "127.0.0.1:6379"
-}])
-
-self_read, self_write = IO.pipe
-%w[INT TERM TSTP TTIN].each do |sig|
-  trap sig do
-    self_write.puts(sig)
-  end
-rescue ArgumentError
-  puts "Signal #{sig} not supported"
+def Process.rss
+  `ps -o rss= -p #{Process.pid}`.chomp.to_i
 end
 
-Sidekiq.redis { |c| c.flushdb }
-def handle_signal(launcher, sig)
-  Sidekiq.logger.debug "Got #{sig} signal"
-  case sig
-  when "INT"
-    # Handle Ctrl-C in JRuby like MRI
-    # http://jira.codehaus.org/browse/JRUBY-4637
-    raise Interrupt
-  when "TERM"
-    # Heroku sends TERM and then waits 30 seconds for process to exit.
-    raise Interrupt
-  when "TSTP"
-    Sidekiq.logger.info "Received TSTP, no longer accepting new work"
-    launcher.quiet
-  when "TTIN"
-    Thread.list.each do |thread|
-      Sidekiq.logger.warn "Thread TID-#{(thread.object_id ^ ::Process.pid).to_s(36)} #{thread["label"]}"
-      if thread.backtrace
-        Sidekiq.logger.warn thread.backtrace.join("\n")
-      else
-        Sidekiq.logger.warn "<no backtrace available>"
+class Loader
+  def initialize
+    @iter = ENV["GC"] ? 10 : 500
+    @count = Integer(ENV["COUNT"] || 1_000)
+    @latency = Integer(ENV["LATENCY"] || 1)
+  end
+
+  def configure
+    @x = Sidekiq.configure_embed do |config|
+      config.redis = {db: 13, port: ((@latency > 0) ? 6380 : 6379)}
+      config.concurrency = Integer(ENV.fetch("THREADS", "10"))
+      # config.redis = { db: 13, port: 6380, driver: :hiredis}
+      config.queues = %w[default]
+      config.logger.level = Logger::WARN
+      config.average_scheduled_poll_interval = 2
+      config.reliable! if defined?(Sidekiq::Pro)
+    end
+
+    @self_read, @self_write = IO.pipe
+    %w[INT TERM TSTP TTIN].each do |sig|
+      trap sig do
+        @self_write.puts(sig)
       end
+    rescue ArgumentError
+      puts "Signal #{sig} not supported"
     end
   end
-end
 
-def Process.rss
-  `ps -o rss= -p #{Process.pid}`.chomp.to_i
-end
+  def handle_signal(sig)
+    launcher = @x
+    Sidekiq.logger.debug "Got #{sig} signal"
+    case sig
+    when "INT"
+      # Handle Ctrl-C in JRuby like MRI
+      # http://jira.codehaus.org/browse/JRUBY-4637
+      raise Interrupt
+    when "TERM"
+      # Heroku sends TERM and then waits 30 seconds for process to exit.
+      raise Interrupt
+    when "TSTP"
+      Sidekiq.logger.info "Received TSTP, no longer accepting new work"
+      launcher.quiet
+    when "TTIN"
+      Thread.list.each do |thread|
+        Sidekiq.logger.warn "Thread TID-#{(thread.object_id ^ ::Process.pid).to_s(36)} #{thread["label"]}"
+        if thread.backtrace
+          Sidekiq.logger.warn thread.backtrace.join("\n")
+        else
+          Sidekiq.logger.warn "<no backtrace available>"
+        end
+      end
+    end
+  end
 
-iter = 10
-count = 10_000
+  def setup
+    Sidekiq.logger.error("Setup RSS: #{Process.rss}")
+    Sidekiq.redis { |c| c.flushdb }
+    start = Time.now
+    if ENV["AJ"]
+      @iter.times do
+        @count.times do |idx|
+          LoadJob.perform_later(idx)
+        end
+      end
+    else
+      @iter.times do
+        arr = Array.new(@count) { |idx| [idx] }
+        Sidekiq::Client.push_bulk("class" => LoadWorker, "args" => arr)
+      end
+    end
+    Sidekiq.logger.warn "Created #{@count * @iter} jobs in #{Time.now - start} sec"
+  end
 
-iter.times do
-  arr = Array.new(count) { |idx| [idx] }
-  Sidekiq::Client.push_bulk("class" => LoadWorker, "args" => arr)
-end
-Sidekiq.logger.error "Created #{count * iter} jobs"
+  def monitor
+    @monitor = Thread.new do
+      GC.start
+      loop do
+        sleep 0.2
+        qsize = Sidekiq.redis do |conn|
+          conn.llen "queue:default"
+        end
+        total = qsize
+        if total == 0
+          ending = Time.now - @start
+          size = @iter * @count
+          Sidekiq.logger.error("Done, #{size} jobs in #{ending} sec, #{(size / ending).to_i} jobs/sec")
+          Sidekiq.logger.error("Ending RSS: #{Process.rss}")
+          Sidekiq.logger.error("Now here's the latency for three jobs")
+
+          if ENV["AJ"]
+            LoadJob.perform_later(1, Time.now.to_f)
+            LoadJob.perform_later(2, Time.now.to_f)
+            LoadJob.perform_later(3, Time.now.to_f)
+          else
+            LoadWorker.perform_async(1, Time.now.to_f)
+            LoadWorker.perform_async(2, Time.now.to_f)
+            LoadWorker.perform_async(3, Time.now.to_f)
+          end
+
+          sleep 0.1
+          @x.stop
+          Process.kill("INT", $$)
+          break
+        end
+      end
+    end
+  end
 
-start = Time.now
+  def with_latency(latency, &block)
+    Sidekiq.logger.error "Simulating #{latency}ms of latency between Sidekiq and redis"
+    if latency > 0
+      Toxiproxy[:redis].downstream(:latency, latency: latency).apply(&block)
+    else
+      yield
+    end
+  end
 
-Monitoring = Thread.new do
-  while true
-    sleep 0.2
-    qsize = Sidekiq.redis do |conn|
-      conn.llen "queue:default"
+  def run(name)
+    Sidekiq.logger.warn("Starting #{name}")
+    monitor
+
+    if ENV["PROFILE"]
+      RubyProf.exclude_threads = [@monitor]
+      RubyProf.start
+    elsif ENV["GC"]
+      GC.start
+      GC.compact
+      GC.disable
+      Sidekiq.logger.error("GC Start RSS: #{Process.rss}")
     end
-    total = qsize
-    # Sidekiq.logger.error("RSS: #{Process.rss} Pending: #{total}")
-    if total == 0
-      Sidekiq.logger.error("Done, #{iter * count} jobs in #{Time.now - start} sec")
-      Sidekiq.logger.error("Now here's the latency for three jobs")
-
-      LoadWorker.perform_async(1, Time.now.to_f)
-      LoadWorker.perform_async(2, Time.now.to_f)
-      LoadWorker.perform_async(3, Time.now.to_f)
-
-      sleep 0.2
-      exit(0)
+    @start = Time.now
+    with_latency(@latency) do
+      @x.run
+
+      while (readable_io = IO.select([@self_read]))
+        signal = readable_io.first[0].gets.strip
+        handle_signal(signal)
+      end
     end
+    # normal
+  rescue Interrupt
+  rescue => e
+    raise e if $DEBUG
+    warn e.message
+    warn e.backtrace.join("\n")
+    exit 1
+  ensure
+    @x.stop
   end
-end
 
-def with_latency(latency, &block)
-  Sidekiq.logger.error "Simulating #{latency}ms of latency between Sidekiq and redis"
-  if latency > 0
-    Toxiproxy[:redis].downstream(:latency, latency: latency).apply(&block)
-  else
-    yield
+  def done
+    Sidekiq.logger.error("GC End RSS: #{Process.rss}") if ENV["GC"]
+    if ENV["PROFILE"]
+      Sidekiq.logger.error("Profiling...")
+      result = RubyProf.stop
+      printer = RubyProf::GraphHtmlPrinter.new(result)
+      printer.print(File.new("output.html", "w"), min_percent: 1)
+    end
   end
 end
 
-begin
-  # RubyProf::exclude_threads = [ Monitoring ]
-  # RubyProf.start
-  events = Sidekiq.options[:lifecycle_events][:startup]
-  events.each(&:call)
-  events.clear
-  
-  with_latency(Integer(ENV.fetch("LATENCY", "1"))) do
-    launcher = Sidekiq::Launcher.new(Sidekiq)
-    launcher.run
-
-    while readable_io = IO.select([self_read])
-      signal = readable_io.first[0].gets.strip
-      handle_signal(launcher, signal)
-    end
-  end
-rescue SystemExit => e
-  # Sidekiq.logger.error("Profiling...")
-  # result = RubyProf.stop
-  # printer = RubyProf::GraphHtmlPrinter.new(result)
-  # printer.print(File.new("output.html", "w"), :min_percent => 1)
-  # normal
-rescue => e
-  raise e if $DEBUG
-  warn e.message
-  warn e.backtrace.join("\n")
-  exit 1
+ll = Loader.new
+ll.configure
+
+if ENV["WARM"]
+  ll.setup
+  ll.run("warmup")
 end
+
+ll.setup
+ll.run("load")
+ll.done

data/bin/sidekiqmon

@@ -2,6 +2,9 @@
 
 require "sidekiq/monitor"
 
+# disable the Redis connection pool logging
+Sidekiq.default_configuration.logger.level = :warn
+
 section = "all"
 section = ARGV[0] if ARGV.size == 1