sidekiq 4.2.10 → 7.3.10

data/lib/sidekiq/middleware/current_attributes.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "active_support/current_attributes"
+
+module Sidekiq
+  ##
+  # Automatically save and load any current attributes in the execution context
+  # so context attributes "flow" from Rails actions into any associated jobs.
+  # This can be useful for multi-tenancy, i18n locale, timezone, any implicit
+  # per-request attribute. See +ActiveSupport::CurrentAttributes+.
+  #
+  # For multiple current attributes, pass an array of current attributes.
+  #
+  # @example
+  #
+  #   # in your initializer
+  #   require "sidekiq/middleware/current_attributes"
+  #   Sidekiq::CurrentAttributes.persist("Myapp::Current")
+  #   # or multiple current attributes
+  #   Sidekiq::CurrentAttributes.persist(["Myapp::Current", "Myapp::OtherCurrent"])
+  #
+  module CurrentAttributes
+    class Save
+      include Sidekiq::ClientMiddleware
+
+      def initialize(cattrs)
+        @cattrs = cattrs
+      end
+
+      def call(_, job, _, _)
+        @cattrs.each do |(key, strklass)|
+          if !job.has_key?(key)
+            attrs = strklass.constantize.attributes
+            # Retries can push the job N times, we don't
+            # want retries to reset cattr. #5692, #5090
+            if attrs.any?
+              # Older rails has a bug that `CurrentAttributes#attributes` always returns
+              # the same hash instance. We need to dup it to avoid being accidentally mutated.
+              job[key] = if returns_same_object?
+                attrs.dup
+              else
+                attrs
+              end
+            end
+          end
+        end
+        yield
+      end
+
+      private
+
+      def returns_same_object?
+        ActiveSupport::VERSION::MAJOR < 8 ||
+          (ActiveSupport::VERSION::MAJOR == 8 && ActiveSupport::VERSION::MINOR == 0)
+      end
+    end
+
+    class Load
+      include Sidekiq::ServerMiddleware
+
+      def initialize(cattrs)
+        @cattrs = cattrs
+      end
+
+      def call(_, job, _, &block)
+        klass_attrs = {}
+
+        @cattrs.each do |(key, strklass)|
+          next unless job.has_key?(key)
+
+          klass_attrs[strklass.constantize] = job[key]
+        end
+
+        wrap(klass_attrs.to_a, &block)
+      end
+
+      private
+
+      def wrap(klass_attrs, &block)
+        klass, attrs = klass_attrs.shift
+        return block.call unless klass
+
+        retried = false
+
+        begin
+          klass.set(attrs) do
+            wrap(klass_attrs, &block)
+          end
+        rescue NoMethodError
+          raise if retried
+
+          # It is possible that the `CurrentAttributes` definition
+          # was changed before the job started processing.
+          attrs = attrs.select { |attr| klass.respond_to?(attr) }
+          retried = true
+          retry
+        end
+      end
+    end
+
+    class << self
+      def persist(klass_or_array, config = Sidekiq.default_configuration)
+        cattrs = build_cattrs_hash(klass_or_array)
+
+        config.client_middleware.add Save, cattrs
+        config.server_middleware.prepend Load, cattrs
+      end
+
+      private
+
+      def build_cattrs_hash(klass_or_array)
+        if klass_or_array.is_a?(Array)
+          {}.tap do |hash|
+            klass_or_array.each_with_index do |klass, index|
+              hash[key_at(index)] = klass.to_s
+            end
+          end
+        else
+          {key_at(0) => klass_or_array.to_s}
+        end
+      end
+
+      def key_at(index)
+        (index == 0) ? "cattr" : "cattr_#{index}"
+      end
+    end
+  end
+end

data/lib/sidekiq/middleware/i18n.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 #
 # Simple middleware to save the current locale and restore it when the job executes.
 # Use it by requiring it in your initializer:
@@ -9,19 +10,20 @@ module Sidekiq::Middleware::I18n
   # Get the current locale and store it in the message
   # to be sent to Sidekiq.
   class Client
-    def call(worker_class, msg, queue, redis_pool)
-      msg['locale'] ||= I18n.locale
+    include Sidekiq::ClientMiddleware
+
+    def call(_jobclass, job, _queue, _redis)
+      job["locale"] ||= I18n.locale
       yield
     end
   end
 
   # Pull the msg locale out and set the current thread to use it.
   class Server
-    def call(worker, msg, queue)
-      I18n.locale = msg['locale'] || I18n.default_locale
-      yield
-    ensure
-      I18n.locale = I18n.default_locale
+    include Sidekiq::ServerMiddleware
+
+    def call(_jobclass, job, _queue, &block)
+      I18n.with_locale(job.fetch("locale", I18n.default_locale), &block)
     end
   end
 end

data/lib/sidekiq/middleware/modules.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Sidekiq
+  # Server-side middleware must import this Module in order
+  # to get access to server resources during `call`.
+  module ServerMiddleware
+    attr_accessor :config
+    def redis_pool
+      config.redis_pool
+    end
+
+    def logger
+      config.logger
+    end
+
+    def redis(&block)
+      config.redis(&block)
+    end
+  end
+
+  # no difference for now
+  ClientMiddleware = ServerMiddleware
+end

data/lib/sidekiq/monitor.rb

@@ -0,0 +1,147 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+require "sidekiq/api"
+
+class Sidekiq::Monitor
+  class Status
+    VALID_SECTIONS = %w[all version overview processes queues]
+    COL_PAD = 2
+
+    def display(section = nil)
+      section ||= "all"
+      unless VALID_SECTIONS.include? section
+        puts "I don't know how to check the status of '#{section}'!"
+        puts "Try one of these: #{VALID_SECTIONS.join(", ")}"
+        return
+      end
+      send(section)
+    end
+
+    def all
+      version
+      puts
+      overview
+      puts
+      processes
+      puts
+      queues
+    end
+
+    def version
+      puts "Sidekiq #{Sidekiq::VERSION}"
+      puts Time.now.utc
+    end
+
+    def overview
+      puts "---- Overview ----"
+      puts "  Processed: #{delimit stats.processed}"
+      puts "     Failed: #{delimit stats.failed}"
+      puts "       Busy: #{delimit stats.workers_size}"
+      puts "   Enqueued: #{delimit stats.enqueued}"
+      puts "    Retries: #{delimit stats.retry_size}"
+      puts "  Scheduled: #{delimit stats.scheduled_size}"
+      puts "       Dead: #{delimit stats.dead_size}"
+    end
+
+    def processes
+      puts "---- Processes (#{process_set.size}) ----"
+      process_set.each_with_index do |process, index|
+        # Keep compatibility with legacy versions since we don't want to break sidekiqmon during rolling upgrades or downgrades.
+        #
+        # Before:
+        #   ["default", "critical"]
+        #
+        # After:
+        #   {"default" => 1, "critical" => 10}
+        queues =
+          if process["weights"]
+            process["weights"].sort_by { |queue| queue[0] }.map { |capsule| capsule.map { |name, weight| (weight > 0) ? "#{name}: #{weight}" : name }.join(", ") }
+          else
+            process["queues"].sort
+          end
+
+        puts "#{process["identity"]} #{tags_for(process)}"
+        puts "  Started: #{Time.at(process["started_at"])} (#{time_ago(process["started_at"])})"
+        puts "  Threads: #{process["concurrency"]} (#{process["busy"]} busy)"
+        puts "   Queues: #{split_multiline(queues, pad: 11)}"
+        puts "  Version: #{process["version"] || "Unknown"}" if process["version"] != Sidekiq::VERSION
+        puts "" unless (index + 1) == process_set.size
+      end
+    end
+
+    def queues
+      puts "---- Queues (#{queue_data.size}) ----"
+      columns = {
+        name: [:ljust, (["name"] + queue_data.map(&:name)).map(&:length).max + COL_PAD],
+        size: [:rjust, (["size"] + queue_data.map(&:size)).map(&:length).max + COL_PAD],
+        latency: [:rjust, (["latency"] + queue_data.map(&:latency)).map(&:length).max + COL_PAD]
+      }
+      columns.each { |col, (dir, width)| print col.to_s.upcase.public_send(dir, width) }
+      puts
+      queue_data.each do |q|
+        columns.each do |col, (dir, width)|
+          print q.send(col).public_send(dir, width)
+        end
+        puts
+      end
+    end
+
+    private
+
+    def delimit(number)
+      number.to_s.reverse.scan(/.{1,3}/).join(",").reverse
+    end
+
+    def split_multiline(values, opts = {})
+      return "none" unless values
+      pad = opts[:pad] || 0
+      max_length = opts[:max_length] || (80 - pad)
+      out = []
+      line = +""
+      values.each do |value|
+        if (line.length + value.length) > max_length
+          out << line
+          line = " " * pad
+        end
+        line << value + ", "
+      end
+      out << line[0..-3]
+      out.join("\n")
+    end
+
+    def tags_for(process)
+      tags = [
+        process["tag"],
+        process["labels"],
+        ((process["quiet"] == "true") ? "quiet" : nil)
+      ].flatten.compact
+      tags.any? ? "[#{tags.join("] [")}]" : nil
+    end
+
+    def time_ago(timestamp)
+      seconds = Time.now - Time.at(timestamp)
+      return "just now" if seconds < 60
+      return "a minute ago" if seconds < 120
+      return "#{seconds.floor / 60} minutes ago" if seconds < 3600
+      return "an hour ago" if seconds < 7200
+      "#{seconds.floor / 60 / 60} hours ago"
+    end
+
+    QUEUE_STRUCT = Struct.new(:name, :size, :latency)
+    def queue_data
+      @queue_data ||= Sidekiq::Queue.all.map { |q|
+        QUEUE_STRUCT.new(q.name, q.size.to_s, sprintf("%#.2f", q.latency))
+      }
+    end
+
+    def process_set
+      @process_set ||= Sidekiq::ProcessSet.new
+    end
+
+    def stats
+      @stats ||= Sidekiq::Stats.new
+    end
+  end
+end

data/lib/sidekiq/paginator.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
+
 module Sidekiq
   module Paginator
+    TYPE_CACHE = {
+      "dead" => "zset",
+      "retry" => "zset",
+      "schedule" => "zset"
+    }
 
-    def page(key, pageidx=1, page_size=25, opts=nil)
-      current_page = pageidx.to_i < 1 ? 1 : pageidx.to_i
+    def page(key, pageidx = 1, page_size = 25, opts = nil)
+      current_page = (pageidx.to_i < 1) ? 1 : pageidx.to_i
       pageidx = current_page - 1
       total_size = 0
       items = []
@@ -12,26 +18,31 @@ module Sidekiq
 
       Sidekiq.redis do |conn|
         type = conn.type(key)
+        rev = opts && opts[:reverse]
 
         case type
-        when 'zset'
-          rev = opts && opts[:reverse]
-          total_size, items = conn.multi do
-            conn.zcard(key)
+        when "zset"
+          total_size, items = conn.multi { |transaction|
+            transaction.zcard(key)
             if rev
-              conn.zrevrange(key, starting, ending, :with_scores => true)
+              transaction.zrange(key, starting, ending, "REV", "withscores")
             else
-              conn.zrange(key, starting, ending, :with_scores => true)
+              transaction.zrange(key, starting, ending, "withscores")
             end
-          end
+          }
           [current_page, total_size, items]
-        when 'list'
-          total_size, items = conn.multi do
-            conn.llen(key)
-            conn.lrange(key, starting, ending)
-          end
+        when "list"
+          total_size, items = conn.multi { |transaction|
+            transaction.llen(key)
+            if rev
+              transaction.lrange(key, -ending - 1, -starting - 1)
+            else
+              transaction.lrange(key, starting, ending)
+            end
+          }
+          items.reverse! if rev
           [current_page, total_size, items]
-        when 'none'
+        when "none"
           [1, 0, []]
         else
           raise "can't page a #{type}"
@@ -39,5 +50,12 @@ module Sidekiq
       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