sidekiq 6.3.1 → 7.0.7

data/lib/sidekiq/middleware/chain.rb

@@ -1,82 +1,93 @@
 # frozen_string_literal: true
 
+require "sidekiq/middleware/modules"
+
 module Sidekiq
   # Middleware is code configured to run before/after
-  # a message is processed.  It is patterned after Rack
+  # a job is processed.  It is patterned after Rack
   # middleware. Middleware exists for the client side
   # (pushing jobs onto the queue) as well as the server
   # side (when jobs are actually processed).
   #
+  # Callers will register middleware Classes and Sidekiq will
+  # create new instances of the middleware for every job. This
+  # is important so that instance state is not shared accidentally
+  # between job executions.
+  #
   # To add middleware for the client:
   #
-  # Sidekiq.configure_client do |config|
-  #   config.client_middleware do |chain|
-  #     chain.add MyClientHook
+  #   Sidekiq.configure_client do |config|
+  #     config.client_middleware do |chain|
+  #       chain.add MyClientHook
+  #     end
   #   end
-  # end
   #
   # To modify middleware for the server, just call
   # with another block:
   #
-  # Sidekiq.configure_server do |config|
-  #   config.server_middleware do |chain|
-  #     chain.add MyServerHook
-  #     chain.remove ActiveRecord
+  #   Sidekiq.configure_server do |config|
+  #     config.server_middleware do |chain|
+  #       chain.add MyServerHook
+  #       chain.remove ActiveRecord
+  #     end
   #   end
-  # end
   #
   # To insert immediately preceding another entry:
   #
-  # Sidekiq.configure_client do |config|
-  #   config.client_middleware do |chain|
-  #     chain.insert_before ActiveRecord, MyClientHook
+  #   Sidekiq.configure_client do |config|
+  #     config.client_middleware do |chain|
+  #       chain.insert_before ActiveRecord, MyClientHook
+  #     end
   #   end
-  # end
   #
   # To insert immediately after another entry:
   #
-  # Sidekiq.configure_client do |config|
-  #   config.client_middleware do |chain|
-  #     chain.insert_after ActiveRecord, MyClientHook
+  #   Sidekiq.configure_client do |config|
+  #     config.client_middleware do |chain|
+  #       chain.insert_after ActiveRecord, MyClientHook
+  #     end
   #   end
-  # end
   #
   # This is an example of a minimal server middleware:
   #
-  # class MyServerHook
-  #   def call(worker_instance, msg, queue)
-  #     puts "Before work"
-  #     yield
-  #     puts "After work"
+  #   class MyServerHook
+  #     include Sidekiq::ServerMiddleware
+  #
+  #     def call(job_instance, msg, queue)
+  #       logger.info "Before job"
+  #       redis {|conn| conn.get("foo") } # do something in Redis
+  #       yield
+  #       logger.info "After job"
+  #     end
   #   end
-  # end
   #
   # This is an example of a minimal client middleware, note
   # the method must return the result or the job will not push
   # to Redis:
   #
-  # class MyClientHook
-  #   def call(worker_class, msg, queue, redis_pool)
-  #     puts "Before push"
-  #     result = yield
-  #     puts "After push"
-  #     result
+  #   class MyClientHook
+  #     include Sidekiq::ClientMiddleware
+  #
+  #     def call(job_class, msg, queue, redis_pool)
+  #       logger.info "Before push"
+  #       result = yield
+  #       logger.info "After push"
+  #       result
+  #     end
   #   end
-  # end
   #
   module Middleware
     class Chain
       include Enumerable
 
-      def initialize_copy(copy)
-        copy.instance_variable_set(:@entries, entries.dup)
-      end
-
+      # Iterate through each middleware in the chain
       def each(&block)
         entries.each(&block)
       end
 
-      def initialize
+      # @api private
+      def initialize(config = nil) # :nodoc:
+        @config = config
         @entries = nil
         yield self if block_given?
       end
@@ -85,38 +96,62 @@ 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)
         entries.delete_if { |entry| entry.klass == klass }
       end
 
+      # Add the given middleware to the end of the chain.
+      # Sidekiq will call `klass.new(*args)` to create a clean
+      # copy of your middleware for every job executed.
+      #
+      #   chain.add(Statsd::Metrics, { collector: "localhost:8125" })
+      #
+      # @param klass [Class] Your middleware class
+      # @param *args [Array<Object>] Set of arguments to pass to every instance of your middleware
       def add(klass, *args)
         remove(klass)
-        entries << Entry.new(klass, *args)
+        entries << Entry.new(@config, klass, *args)
       end
 
+      # Identical to {#add} except the middleware is added to the front of the chain.
       def prepend(klass, *args)
         remove(klass)
-        entries.insert(0, Entry.new(klass, *args))
+        entries.insert(0, Entry.new(@config, klass, *args))
       end
 
+      # Inserts +newklass+ before +oldklass+ in the chain.
+      # Useful if one middleware must run before another middleware.
       def insert_before(oldklass, newklass, *args)
         i = entries.index { |entry| entry.klass == newklass }
-        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        new_entry = i.nil? ? Entry.new(@config, newklass, *args) : entries.delete_at(i)
         i = entries.index { |entry| entry.klass == oldklass } || 0
         entries.insert(i, new_entry)
       end
 
+      # Inserts +newklass+ after +oldklass+ in the chain.
+      # Useful if one middleware must run after another middleware.
       def insert_after(oldklass, newklass, *args)
         i = entries.index { |entry| entry.klass == newklass }
-        new_entry = i.nil? ? Entry.new(newklass, *args) : entries.delete_at(i)
+        new_entry = i.nil? ? Entry.new(@config, newklass, *args) : entries.delete_at(i)
         i = entries.index { |entry| entry.klass == oldklass } || entries.count - 1
         entries.insert(i + 1, new_entry)
       end
 
+      # @return [Boolean] if the given class is already in the chain
       def exists?(klass)
         any? { |entry| entry.klass == klass }
       end
+      alias_method :include?, :exists?
 
+      # @return [Boolean] if the chain contains no middleware
       def empty?
         @entries.nil? || @entries.empty?
       end
@@ -129,33 +164,43 @@ module Sidekiq
         entries.clear
       end
 
-      def invoke(*args)
+      # Used by Sidekiq to execute the middleware at runtime
+      # @api private
+      def invoke(*args, &block)
         return yield if empty?
 
         chain = retrieve
-        traverse_chain = proc do
-          if chain.empty?
-            yield
-          else
-            chain.shift.call(*args, &traverse_chain)
+        traverse(chain, 0, args, &block)
+      end
+
+      private
+
+      def traverse(chain, index, args, &block)
+        if index >= chain.size
+          yield
+        else
+          chain[index].call(*args) do
+            traverse(chain, index + 1, args, &block)
           end
         end
-        traverse_chain.call
       end
     end
 
-    private
-
+    # Represents each link in the middleware chain
+    # @api private
     class Entry
       attr_reader :klass
 
-      def initialize(klass, *args)
+      def initialize(config, klass, *args)
+        @config = config
         @klass = klass
         @args = args
       end
 
       def make_new
-        @klass.new(*@args)
+        x = @klass.new(*@args)
+        x.config = @config if @config && x.respond_to?(:config=)
+        x
       end
     end
   end

data/lib/sidekiq/middleware/current_attributes.rb

@@ -11,42 +11,46 @@ module Sidekiq
   #
   #   # in your initializer
   #   require "sidekiq/middleware/current_attributes"
-  #   Sidekiq::CurrentAttributes.persist(Myapp::Current)
+  #   Sidekiq::CurrentAttributes.persist("Myapp::Current")
   #
   module CurrentAttributes
     class Save
+      include Sidekiq::ClientMiddleware
+
       def initialize(cattr)
-        @klass = cattr
+        @strklass = cattr
       end
 
       def call(_, job, _, _)
-        job["cattr"] = @klass.attributes
+        if !job.has_key?("cattr")
+          attrs = @strklass.constantize.attributes
+          # Retries can push the job N times, we don't
+          # want retries to reset cattr. #5692, #5090
+          job["cattr"] = attrs if attrs.any?
+        end
         yield
       end
     end
 
     class Load
+      include Sidekiq::ServerMiddleware
+
       def initialize(cattr)
-        @klass = cattr
+        @strklass = cattr
       end
 
       def call(_, job, _, &block)
         if job.has_key?("cattr")
-          @klass.set(job["cattr"], &block)
+          @strklass.constantize.set(job["cattr"], &block)
         else
           yield
         end
       end
     end
 
-    def self.persist(klass)
-      Sidekiq.configure_client do |config|
-        config.client_middleware.add Save, klass
-      end
-      Sidekiq.configure_server do |config|
-        config.client_middleware.add Save, klass
-        config.server_middleware.add Load, klass
-      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/middleware/i18n.rb

@@ -10,16 +10,18 @@ module Sidekiq::Middleware::I18n
   # Get the current locale and store it in the message
   # to be sent to Sidekiq.
   class Client
-    def call(_worker, msg, _queue, _redis)
-      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, &block)
-      I18n.with_locale(msg.fetch("locale", I18n.default_locale), &block)
+    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,21 @@
+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

@@ -16,8 +16,6 @@ class Sidekiq::Monitor
         return
       end
       send(section)
-    rescue => e
-      puts "Couldn't get status: #{e}"
     end
 
     def all
@@ -49,10 +47,25 @@ class Sidekiq::Monitor
     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(process["queues"].sort, pad: 11)}"
+        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
@@ -101,7 +114,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 = []
@@ -16,22 +16,22 @@ module Sidekiq
 
         case type
         when "zset"
-          total_size, items = conn.multi {
-            conn.zcard(key)
+          total_size, items = conn.multi { |transaction|
+            transaction.zcard(key)
             if rev
-              conn.zrevrange(key, starting, ending, with_scores: true)
+              transaction.zrevrange(key, starting, ending, withscores: true)
             else
-              conn.zrange(key, starting, ending, with_scores: true)
+              transaction.zrange(key, starting, ending, withscores: true)
             end
           }
           [current_page, total_size, items]
         when "list"
-          total_size, items = conn.multi {
-            conn.llen(key)
+          total_size, items = conn.multi { |transaction|
+            transaction.llen(key)
             if rev
-              conn.lrange(key, -ending - 1, -starting - 1)
+              transaction.lrange(key, -ending - 1, -starting - 1)
             else
-              conn.lrange(key, starting, ending)
+              transaction.lrange(key, starting, ending)
             end
           }
           items.reverse! if rev
@@ -43,5 +43,13 @@ 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