sidekiq 6.5.9 → 7.0.0.beta1

data/lib/sidekiq/launcher.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 require "sidekiq/manager"
-require "sidekiq/fetch"
+require "sidekiq/capsule"
 require "sidekiq/scheduled"
 require "sidekiq/ring_buffer"
 
 module Sidekiq
-  # The Launcher starts the Manager and Poller threads and provides the process heartbeat.
+  # The Launcher starts the Capsule Managers, the Poller thread and provides the process heartbeat.
   class Launcher
     include Sidekiq::Component
 
@@ -16,48 +16,53 @@ module Sidekiq
       proc { "sidekiq" },
       proc { Sidekiq::VERSION },
       proc { |me, data| data["tag"] },
-      proc { |me, data| "[#{Processor::WORK_STATE.size} of #{data["concurrency"]} busy]" },
+      proc { |me, data| "[#{Processor::WORK_STATE.size} of #{me.config.total_concurrency} busy]" },
       proc { |me, data| "stopping" if me.stopping? }
     ]
 
-    attr_accessor :manager, :poller, :fetcher
+    attr_accessor :managers, :poller
 
-    def initialize(options)
-      @config = options
-      options[:fetch] ||= BasicFetch.new(options)
-      @manager = Sidekiq::Manager.new(options)
-      @poller = Sidekiq::Scheduled::Poller.new(options)
+    def initialize(config, embedded: false)
+      @config = config
+      @embedded = embedded
+      @managers = config.capsules.values.map do |cap|
+        Sidekiq::Manager.new(cap)
+      end
+      @poller = Sidekiq::Scheduled::Poller.new(@config)
       @done = false
     end
 
     def run
+      Sidekiq.freeze!
       @thread = safe_thread("heartbeat", &method(:start_heartbeat))
       @poller.start
-      @manager.start
+      @managers.each(&:start)
     end
 
     # Stops this instance from processing any more jobs,
     #
     def quiet
+      return if @done
+
       @done = true
-      @manager.quiet
+      @managers.each(&:quiet)
       @poller.terminate
+      fire_event(:quiet, reverse: true)
     end
 
     # Shuts down this Sidekiq instance. Waits up to the deadline for all jobs to complete.
     def stop
       deadline = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + @config[:timeout]
 
-      @done = true
-      @manager.quiet
-      @poller.terminate
-
-      @manager.stop(deadline)
+      quiet
+      stoppers = @managers.map do |mgr|
+        Thread.new do
+          mgr.stop(deadline)
+        end
+      end
 
-      # Requeue everything in case there was a thread which fetched a job while the process was stopped.
-      # This call is a no-op in Sidekiq but necessary for Sidekiq Pro.
-      strategy = @config[:fetch]
-      strategy.bulk_requeue([], @config)
+      fire_event(:shutdown, reverse: true)
+      stoppers.each(&:join)
 
       clear_heartbeat
     end
@@ -68,7 +73,7 @@ module Sidekiq
 
     private unless $TESTING
 
-    BEAT_PAUSE = 5
+    BEAT_PAUSE = 10
 
     def start_heartbeat
       loop do
@@ -95,7 +100,7 @@ module Sidekiq
     end
 
     def heartbeat
-      $0 = PROCTITLES.map { |proc| proc.call(self, to_data) }.compact.join(" ")
+      $0 = PROCTITLES.map { |proc| proc.call(self, to_data) }.compact.join(" ") unless @embedded
 
       ❤
     end
@@ -107,7 +112,7 @@ module Sidekiq
 
       nowdate = Time.now.utc.strftime("%Y-%m-%d")
       begin
-        Sidekiq.redis do |conn|
+        redis do |conn|
           conn.pipelined do |pipeline|
             pipeline.incrby("stat:processed", procd)
             pipeline.incrby("stat:processed:#{nowdate}", procd)
@@ -119,9 +124,7 @@ module Sidekiq
           end
         end
       rescue => ex
-        # we're exiting the process, things might be shut down so don't
-        # try to handle the exception
-        Sidekiq.logger.warn("Unable to flush stats: #{ex}")
+        logger.warn("Unable to flush stats: #{ex}")
       end
     end
 
@@ -130,23 +133,10 @@ module Sidekiq
       fails = procd = 0
 
       begin
-        fails = Processor::FAILURE.reset
-        procd = Processor::PROCESSED.reset
-        curstate = Processor::WORK_STATE.dup
-
-        nowdate = Time.now.utc.strftime("%Y-%m-%d")
+        flush_stats
 
+        curstate = Processor::WORK_STATE.dup
         redis do |conn|
-          conn.multi do |transaction|
-            transaction.incrby("stat:processed", procd)
-            transaction.incrby("stat:processed:#{nowdate}", procd)
-            transaction.expire("stat:processed:#{nowdate}", STATS_TTL)
-
-            transaction.incrby("stat:failed", fails)
-            transaction.incrby("stat:failed:#{nowdate}", fails)
-            transaction.expire("stat:failed:#{nowdate}", STATS_TTL)
-          end
-
           # work is the current set of executing jobs
           work_key = "#{key}:work"
           conn.pipelined do |transaction|
@@ -166,7 +156,7 @@ module Sidekiq
         _, exists, _, _, msg = redis { |conn|
           conn.multi { |transaction|
             transaction.sadd("processes", [key])
-            transaction.exists?(key)
+            transaction.exists(key)
             transaction.hmset(key, "info", to_json,
               "busy", curstate.size,
               "beat", Time.now.to_f,
@@ -179,7 +169,7 @@ module Sidekiq
         }
 
         # first heartbeat or recovering from an outage and need to reestablish our heartbeat
-        fire_event(:heartbeat) unless exists
+        fire_event(:heartbeat) unless exists > 0
         fire_event(:beat, oneshot: false)
 
         return unless msg
@@ -251,9 +241,9 @@ module Sidekiq
         "started_at" => Time.now.to_f,
         "pid" => ::Process.pid,
         "tag" => @config[:tag] || "",
-        "concurrency" => @config[:concurrency],
-        "queues" => @config[:queues].uniq,
-        "labels" => @config[:labels],
+        "concurrency" => @config.total_concurrency,
+        "queues" => @config.capsules.values.map { |cap| cap.queues }.flatten.uniq,
+        "labels" => @config[:labels].to_a,
         "identity" => identity
       }
     end

data/lib/sidekiq/logger.rb

@@ -31,7 +31,7 @@ module Sidekiq
       "fatal" => 4
     }
     LEVELS.default_proc = proc do |_, level|
-      Sidekiq.logger.warn("Invalid log level: #{level.inspect}")
+      puts("Invalid log level: #{level.inspect}")
       nil
     end
 
@@ -70,36 +70,11 @@ module Sidekiq
     ensure
       self.local_level = old_local_level
     end
-
-    # Redefined to check severity against #level, and thus the thread-local level, rather than +@level+.
-    # FIXME: Remove when the minimum Ruby version supports overriding Logger#level.
-    def add(severity, message = nil, progname = nil, &block)
-      severity ||= ::Logger::UNKNOWN
-      progname ||= @progname
-
-      return true if @logdev.nil? || severity < level
-
-      if message.nil?
-        if block
-          message = yield
-        else
-          message = progname
-          progname = @progname
-        end
-      end
-
-      @logdev.write format_message(format_severity(severity), Time.now, progname, message)
-    end
   end
 
   class Logger < ::Logger
     include LoggingUtils
 
-    def initialize(*args, **kwargs)
-      super
-      self.formatter = Sidekiq.log_formatter
-    end
-
     module Formatters
       class Base < ::Logger::Formatter
         def tid

data/lib/sidekiq/manager.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "sidekiq/processor"
-require "sidekiq/fetch"
 require "set"
 
 module Sidekiq
@@ -23,19 +22,19 @@ module Sidekiq
     include Sidekiq::Component
 
     attr_reader :workers
+    attr_reader :capsule
 
-    def initialize(options = {})
-      @config = options
-      logger.debug { options.inspect }
-      @count = options[:concurrency] || 10
+    def initialize(capsule)
+      @config = @capsule = capsule
+      @count = capsule.concurrency
       raise ArgumentError, "Concurrency of #{@count} is not supported" if @count < 1
 
       @done = false
       @workers = Set.new
+      @plock = Mutex.new
       @count.times do
         @workers << Processor.new(@config, &method(:processor_result))
       end
-      @plock = Mutex.new
     end
 
     def start
@@ -46,14 +45,12 @@ module Sidekiq
       return if @done
       @done = true
 
-      logger.info { "Terminating quiet threads" }
+      logger.info { "Terminating quiet threads for #{capsule.name} capsule" }
       @workers.each(&:terminate)
-      fire_event(:quiet, reverse: true)
     end
 
     def stop(deadline)
       quiet
-      fire_event(:shutdown, reverse: true)
 
       # some of the shutdown events can be async,
       # we don't have any way to know when they're done but
@@ -66,6 +63,8 @@ module Sidekiq
       return if @workers.empty?
 
       hard_shutdown
+    ensure
+      capsule.stop
     end
 
     def processor_result(processor, reason = nil)
@@ -105,8 +104,7 @@ module Sidekiq
         # contract says that jobs are run AT LEAST once. Process termination
         # is delayed until we're certain the jobs are back in Redis because
         # it is worse to lose a job than to run it twice.
-        strategy = @config[:fetch]
-        strategy.bulk_requeue(jobs, @config)
+        capsule.fetcher.bulk_requeue(jobs, nil)
       end
 
       cleanup.each do |processor|

data/lib/sidekiq/metrics/query.rb

@@ -13,9 +13,9 @@ module Sidekiq
     # NB: all metrics and times/dates are UTC only. We specifically do not
     # support timezones.
     class Query
-      def initialize(pool: Sidekiq.redis_pool, now: Time.now)
+      def initialize(pool: nil, now: Time.now)
         @time = now.utc
-        @pool = pool
+        @pool = pool || Sidekiq.default_configuration.redis_pool
         @klass = nil
       end
 
@@ -123,7 +123,7 @@ module Sidekiq
         def series_avg(metric = "ms")
           series[metric].each_with_object(Hash.new(0)) do |(bucket, value), result|
             completed = series.dig("p", bucket) - series.dig("f", bucket)
-            result[bucket] = (completed == 0) ? 0 : value.to_f / completed
+            result[bucket] = completed == 0 ? 0 : value.to_f / completed
           end
         end
       end

data/lib/sidekiq/metrics/shared.rb

@@ -2,7 +2,8 @@ require "concurrent"
 
 module Sidekiq
   module Metrics
-    # TODO Support apps without concurrent-ruby
+    # This is the only dependency on concurrent-ruby in Sidekiq but it's
+    # mandatory for thread-safety until MRI supports atomic operations on values.
     Counter = ::Concurrent::AtomicFixnum
 
     # Implements space-efficient but statistically useful histogram storage.
@@ -38,7 +39,6 @@ module Sidekiq
         "65s", "100s", "150s", "225s", "335s",
         "Slow"
       ]
-
       FETCH = "GET u16 #0 GET u16 #1 GET u16 #2 GET u16 #3 \
         GET u16 #4 GET u16 #5 GET u16 #6 GET u16 #7 \
         GET u16 #8 GET u16 #9 GET u16 #10 GET u16 #11 \
@@ -46,6 +46,7 @@ module Sidekiq
         GET u16 #16 GET u16 #17 GET u16 #18 GET u16 #19 \
         GET u16 #20 GET u16 #21 GET u16 #22 GET u16 #23 \
         GET u16 #24 GET u16 #25".split
+      HISTOGRAM_TTL = 8 * 60 * 60
 
       def each
         buckets.each { |counter| yield counter.value }
@@ -86,7 +87,7 @@ module Sidekiq
         end
 
         conn.bitfield(*cmd) if cmd.size > 3
-        conn.expire(key, 86400)
+        conn.expire(key, HISTOGRAM_TTL)
         key
       end
     end

data/lib/sidekiq/metrics/tracking.rb

@@ -48,8 +48,8 @@ module Sidekiq
         end
       end
 
-      LONG_TERM = 90 * 24 * 60 * 60
-      MID_TERM = 7 * 24 * 60 * 60
+      # LONG_TERM = 90 * 24 * 60 * 60
+      # MID_TERM = 7 * 24 * 60 * 60
       SHORT_TERM = 8 * 60 * 60
 
       def flush(time = Time.now)
@@ -59,12 +59,13 @@ module Sidekiq
         return if procd == 0 && fails == 0
 
         now = time.utc
-        nowdate = now.strftime("%Y%m%d")
-        nowhour = now.strftime("%Y%m%d|%-H")
+        # nowdate = now.strftime("%Y%m%d")
+        # nowhour = now.strftime("%Y%m%d|%-H")
         nowmin = now.strftime("%Y%m%d|%-H:%-M")
         count = 0
 
         redis do |conn|
+          # persist fine-grained histogram data
           if grams.size > 0
             conn.pipelined do |pipe|
               grams.each do |_, gram|
@@ -73,15 +74,16 @@ module Sidekiq
             end
           end
 
+          # persist coarse grained execution count + execution millis.
+          # note as of today we don't use or do anything with the
+          # daily or hourly rollups.
           [
-            ["j", jobs, nowdate, LONG_TERM],
-            ["j", jobs, nowhour, MID_TERM],
+            # ["j", jobs, nowdate, LONG_TERM],
+            # ["j", jobs, nowhour, MID_TERM],
             ["j", jobs, nowmin, SHORT_TERM]
           ].each do |prefix, data, bucket, ttl|
-            # Quietly seed the new 7.0 stats format so migration is painless.
             conn.pipelined do |xa|
               stats = "#{prefix}|#{bucket}"
-              # logger.debug "Flushing metrics #{stats}"
               data.each_pair do |key, value|
                 xa.hincrby stats, key, value
                 count += 1
@@ -89,7 +91,7 @@ module Sidekiq
               xa.expire(stats, ttl)
             end
           end
-          logger.info "Flushed #{count} metrics"
+          logger.debug "Flushed #{count} metrics"
           count
         end
       end
@@ -121,14 +123,12 @@ module Sidekiq
   end
 end
 
-if ENV["SIDEKIQ_METRICS_BETA"] == "1"
-  Sidekiq.configure_server do |config|
-    exec = Sidekiq::Metrics::ExecutionTracker.new(config)
-    config.server_middleware do |chain|
-      chain.add Sidekiq::Metrics::Middleware, exec
-    end
-    config.on(:beat) do
-      exec.flush
-    end
+Sidekiq.configure_server do |config|
+  exec = Sidekiq::Metrics::ExecutionTracker.new(config)
+  config.server_middleware do |chain|
+    chain.add Sidekiq::Metrics::Middleware, exec
+  end
+  config.on(:beat) do
+    exec.flush
   end
 end

data/lib/sidekiq/middleware/chain.rb

@@ -80,15 +80,6 @@ module Sidekiq
     class Chain
       include Enumerable
 
-      # A unique instance of the middleware chain is created for
-      # each job executed in order to be thread-safe.
-      # @param copy [Sidekiq::Middleware::Chain] New instance of Chain
-      # @returns nil
-      def initialize_copy(copy)
-        copy.instance_variable_set(:@entries, entries.dup)
-        nil
-      end
-
       # Iterate through each middleware in the chain
       def each(&block)
         entries.each(&block)
@@ -105,6 +96,12 @@ module Sidekiq
         @entries ||= []
       end
 
+      def copy_for(capsule)
+        chain = Sidekiq::Middleware::Chain.new(capsule)
+        chain.instance_variable_set(:@entries, entries.dup)
+        chain
+      end
+
       # Remove all middleware matching the given Class
       # @param klass [Class]
       def remove(klass)
@@ -152,6 +149,7 @@ module Sidekiq
       def exists?(klass)
         any? { |entry| entry.klass == klass }
       end
+      alias_method :include?, :exists?
 
       # @return [Boolean] if the chain contains no middleware
       def empty?

data/lib/sidekiq/middleware/current_attributes.rb

@@ -50,14 +50,9 @@ module Sidekiq
       end
     end
 
-    def self.persist(klass)
-      Sidekiq.configure_client do |config|
-        config.client_middleware.add Save, klass.to_s
-      end
-      Sidekiq.configure_server do |config|
-        config.client_middleware.add Save, klass.to_s
-        config.server_middleware.add Load, klass.to_s
-      end
+    def self.persist(klass, config = Sidekiq.default_configuration)
+      config.client_middleware.add Save, klass.to_s
+      config.server_middleware.add Load, klass.to_s
     end
   end
 end

data/lib/sidekiq/monitor.rb

@@ -101,7 +101,7 @@ class Sidekiq::Monitor
       tags = [
         process["tag"],
         process["labels"],
-        ((process["quiet"] == "true") ? "quiet" : nil)
+        (process["quiet"] == "true" ? "quiet" : nil)
       ].flatten.compact
       tags.any? ? "[#{tags.join("] [")}]" : nil
     end

data/lib/sidekiq/paginator.rb

@@ -3,7 +3,7 @@
 module Sidekiq
   module Paginator
     def page(key, pageidx = 1, page_size = 25, opts = nil)
-      current_page = (pageidx.to_i < 1) ? 1 : pageidx.to_i
+      current_page = pageidx.to_i < 1 ? 1 : pageidx.to_i
       pageidx = current_page - 1
       total_size = 0
       items = []
@@ -43,13 +43,5 @@ module Sidekiq
         end
       end
     end
-
-    def page_items(items, pageidx = 1, page_size = 25)
-      current_page = (pageidx.to_i < 1) ? 1 : pageidx.to_i
-      pageidx = current_page - 1
-      starting = pageidx * page_size
-      items = items.to_a
-      [current_page, items.size, items[starting, page_size]]
-    end
   end
 end

data/lib/sidekiq/pool.rb

@@ -0,0 +1,7 @@
+module Sidekiq
+  module PoolAccess
+    def redis_pool
+      Thread.current[:sidekiq_redis_pool] || (@redis ||= Sidekiq::RedisConnection.create)
+    end
+  end
+end

data/lib/sidekiq/processor.rb

@@ -26,18 +26,18 @@ module Sidekiq
 
     attr_reader :thread
     attr_reader :job
+    attr_reader :capsule
 
-    def initialize(options, &block)
+    def initialize(capsule, &block)
+      @config = @capsule = capsule
       @callback = block
       @down = false
       @done = false
       @job = nil
       @thread = nil
-      @config = options
-      @strategy = options[:fetch]
-      @reloader = options[:reloader] || proc { |&block| block.call }
-      @job_logger = (options[:job_logger] || Sidekiq::JobLogger).new
-      @retrier = Sidekiq::JobRetry.new(options)
+      @reloader = Sidekiq.default_configuration[:reloader]
+      @job_logger = (capsule.config[:job_logger] || Sidekiq::JobLogger).new(logger)
+      @retrier = Sidekiq::JobRetry.new(capsule)
     end
 
     def terminate(wait = false)
@@ -59,12 +59,16 @@ module Sidekiq
     end
 
     def start
-      @thread ||= safe_thread("processor", &method(:run))
+      @thread ||= safe_thread("#{config.name}/processor", &method(:run))
     end
 
     private unless $TESTING
 
     def run
+      # By setting this thread-local, Sidekiq.redis will access +Sidekiq::Capsule#redis_pool+
+      # instead of the global pool in +Sidekiq::Config#redis_pool+.
+      Thread.current[:sidekiq_capsule] = @capsule
+
       process_one until @done
       @callback.call(self)
     rescue Sidekiq::Shutdown
@@ -80,7 +84,7 @@ module Sidekiq
     end
 
     def get_one
-      uow = @strategy.retrieve_work
+      uow = capsule.fetcher.retrieve_work
       if @down
         logger.info { "Redis is online, #{::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @down} sec downtime" }
         @down = nil
@@ -129,7 +133,7 @@ module Sidekiq
               # 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 = Object.const_get(job_hash["class"])
                 inst = klass.new
                 inst.jid = job_hash["jid"]
                 @retrier.local(inst, jobstr, queue) do
@@ -153,11 +157,11 @@ module Sidekiq
       rescue => ex
         handle_exception(ex, {context: "Invalid JSON for job", jobstr: jobstr})
         now = Time.now.to_f
-        config.redis do |conn|
+        redis do |conn|
           conn.multi do |xa|
             xa.zadd("dead", now.to_s, jobstr)
-            xa.zremrangebyscore("dead", "-inf", now - config[:dead_timeout_in_seconds])
-            xa.zremrangebyrank("dead", 0, - config[:dead_max_jobs])
+            xa.zremrangebyscore("dead", "-inf", now - @capsule.config[:dead_timeout_in_seconds])
+            xa.zremrangebyrank("dead", 0, - @capsule.config[:dead_max_jobs])
           end
         end
         return uow.acknowledge
@@ -166,7 +170,7 @@ module Sidekiq
       ack = false
       begin
         dispatch(job_hash, queue, jobstr) do |inst|
-          @config.server_middleware.invoke(inst, job_hash, queue) do
+          config.server_middleware.invoke(inst, job_hash, queue) do
             execute_job(inst, job_hash["args"])
           end
         end
@@ -269,18 +273,5 @@ module Sidekiq
         PROCESSED.incr
       end
     end
-
-    def constantize(str)
-      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_get(name, false)
-      end
-    end
   end
 end