sidekiq 6.0.7 → 6.5.0

data/lib/sidekiq/middleware/modules.rb

@@ -0,0 +1,19 @@
+module Sidekiq
+  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

@@ -17,7 +17,7 @@ class Sidekiq::Monitor
       end
       send(section)
     rescue => e
-      puts "Couldn't get status: #{e}"
+      abort "Couldn't get status: #{e}"
     end
 
     def all

data/lib/sidekiq/paginator.rb

@@ -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

data/lib/sidekiq/processor.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "sidekiq/util"
 require "sidekiq/fetch"
 require "sidekiq/job_logger"
 require "sidekiq/job_retry"
@@ -11,33 +10,34 @@ module Sidekiq
   #
   # 1. fetches a job from Redis
   # 2. executes the job
-  #   a. instantiate the Worker
+  #   a. instantiate the job class
   #   b. run the middleware chain
   #   c. call #perform
   #
-  # A Processor can exit due to shutdown (processor_stopped)
-  # or due to an error during job execution (processor_died)
+  # A Processor can exit due to shutdown or due to
+  # an error during job execution.
   #
   # If an error occurs in the job execution, the
   # Processor calls the Manager to create a new one
   # to replace itself and exits.
   #
   class Processor
-    include Util
+    include Sidekiq::Component
 
     attr_reader :thread
     attr_reader :job
 
-    def initialize(mgr)
-      @mgr = mgr
+    def initialize(options, &block)
+      @callback = block
       @down = false
       @done = false
       @job = nil
       @thread = nil
-      @strategy = (mgr.options[:fetch] || Sidekiq::BasicFetch).new(mgr.options)
-      @reloader = Sidekiq.options[:reloader]
-      @job_logger = (mgr.options[:job_logger] || Sidekiq::JobLogger).new
-      @retrier = Sidekiq::JobRetry.new
+      @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)
     end
 
     def terminate(wait = false)
@@ -66,26 +66,26 @@ module Sidekiq
 
     def run
       process_one until @done
-      @mgr.processor_stopped(self)
+      @callback.call(self)
     rescue Sidekiq::Shutdown
-      @mgr.processor_stopped(self)
+      @callback.call(self)
     rescue Exception => ex
-      @mgr.processor_died(self, ex)
+      @callback.call(self, ex)
     end
 
-    def process_one
+    def process_one(&block)
       @job = fetch
       process(@job) if @job
       @job = nil
     end
 
     def get_one
-      work = @strategy.retrieve_work
+      uow = @strategy.retrieve_work
       if @down
         logger.info { "Redis is online, #{::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @down} sec downtime" }
         @down = nil
       end
-      work
+      uow
     rescue Sidekiq::Shutdown
     rescue => ex
       handle_fetch_exception(ex)
@@ -130,10 +130,10 @@ module Sidekiq
               # Effectively this block denotes a "unit of work" to Rails.
               @reloader.call do
                 klass = constantize(job_hash["class"])
-                worker = klass.new
-                worker.jid = job_hash["jid"]
-                @retrier.local(worker, jobstr, queue) do
-                  yield worker
+                inst = klass.new
+                inst.jid = job_hash["jid"]
+                @retrier.local(inst, jobstr, queue) do
+                  yield inst
                 end
               end
             end
@@ -142,9 +142,9 @@ module Sidekiq
       end
     end
 
-    def process(work)
-      jobstr = work.job
-      queue = work.queue_name
+    def process(uow)
+      jobstr = uow.job
+      queue = uow.queue_name
 
       # Treat malformed JSON as a special case: job goes straight to the morgue.
       job_hash = nil
@@ -154,14 +154,14 @@ module Sidekiq
         handle_exception(ex, {context: "Invalid JSON for job", jobstr: jobstr})
         # we can't notify because the job isn't a valid hash payload.
         DeadSet.new.kill(jobstr, notify_failure: false)
-        return work.acknowledge
+        return uow.acknowledge
       end
 
       ack = false
       begin
-        dispatch(job_hash, queue, jobstr) do |worker|
-          Sidekiq.server_middleware.invoke(worker, job_hash, queue) do
-            execute_job(worker, job_hash["args"])
+        dispatch(job_hash, queue, jobstr) do |inst|
+          @config.server_middleware.invoke(inst, job_hash, queue) do
+            execute_job(inst, job_hash["args"])
           end
         end
         ack = true
@@ -186,14 +186,14 @@ module Sidekiq
         if ack
           # We don't want a shutdown signal to interrupt job acknowledgment.
           Thread.handle_interrupt(Sidekiq::Shutdown => :never) do
-            work.acknowledge
+            uow.acknowledge
           end
         end
       end
     end
 
-    def execute_job(worker, cloned_args)
-      worker.perform(*cloned_args)
+    def execute_job(inst, cloned_args)
+      inst.perform(*cloned_args)
     end
 
     # Ruby doesn't provide atomic counters out of the box so we'll
@@ -219,39 +219,39 @@ module Sidekiq
     end
 
     # jruby's Hash implementation is not threadsafe, so we wrap it in a mutex here
-    class SharedWorkerState
+    class SharedWorkState
       def initialize
-        @worker_state = {}
+        @work_state = {}
         @lock = Mutex.new
       end
 
       def set(tid, hash)
-        @lock.synchronize { @worker_state[tid] = hash }
+        @lock.synchronize { @work_state[tid] = hash }
       end
 
       def delete(tid)
-        @lock.synchronize { @worker_state.delete(tid) }
+        @lock.synchronize { @work_state.delete(tid) }
       end
 
       def dup
-        @lock.synchronize { @worker_state.dup }
+        @lock.synchronize { @work_state.dup }
       end
 
       def size
-        @lock.synchronize { @worker_state.size }
+        @lock.synchronize { @work_state.size }
       end
 
       def clear
-        @lock.synchronize { @worker_state.clear }
+        @lock.synchronize { @work_state.clear }
       end
     end
 
     PROCESSED = Counter.new
     FAILURE = Counter.new
-    WORKER_STATE = SharedWorkerState.new
+    WORK_STATE = SharedWorkState.new
 
     def stats(jobstr, queue)
-      WORKER_STATE.set(tid, {queue: queue, payload: jobstr, run_at: Time.now.to_i})
+      WORK_STATE.set(tid, {queue: queue, payload: jobstr, run_at: Time.now.to_i})
 
       begin
         yield
@@ -259,7 +259,7 @@ module Sidekiq
         FAILURE.incr
         raise
       ensure
-        WORKER_STATE.delete(tid)
+        WORK_STATE.delete(tid)
         PROCESSED.incr
       end
     end

data/lib/sidekiq/rails.rb

@@ -1,9 +1,25 @@
 # frozen_string_literal: true
 
-require "sidekiq/worker"
+require "sidekiq/job"
 
 module Sidekiq
   class Rails < ::Rails::Engine
+    class Reloader
+      def initialize(app = ::Rails.application)
+        @app = app
+      end
+
+      def call
+        @app.reloader.wrap do
+          yield
+        end
+      end
+
+      def inspect
+        "#<Sidekiq::Rails::Reloader @app=#{@app.class.name}>"
+      end
+    end
+
     # By including the Options module, we allow AJs to directly control sidekiq features
     # via the *sidekiq_options* class method and, for instance, not use AJ's retry system.
     # AJ retries don't show up in the Sidekiq UI Retries tab, save any error data, can't be
@@ -17,35 +33,35 @@ module Sidekiq
     #   end
     initializer "sidekiq.active_job_integration" do
       ActiveSupport.on_load(:active_job) do
-        include ::Sidekiq::Worker::Options unless respond_to?(:sidekiq_options)
+        include ::Sidekiq::Job::Options unless respond_to?(:sidekiq_options)
+      end
+    end
+
+    initializer "sidekiq.rails_logger" do
+      Sidekiq.configure_server do |config|
+        # This is the integration code necessary so that if a job uses `Rails.logger.info "Hello"`,
+        # it will appear in the Sidekiq console with all of the job context. See #5021 and
+        # https://github.com/rails/rails/blob/b5f2b550f69a99336482739000c58e4e04e033aa/railties/lib/rails/commands/server/server_command.rb#L82-L84
+        unless ::Rails.logger == config.logger || ::ActiveSupport::Logger.logger_outputs_to?(::Rails.logger, $stdout)
+          ::Rails.logger.extend(::ActiveSupport::Logger.broadcast(config.logger))
+        end
       end
     end
 
+    config.before_configuration do
+      dep = ActiveSupport::Deprecation.new("7.0", "Sidekiq")
+      dep.deprecate_methods(Sidekiq.singleton_class,
+        default_worker_options: :default_job_options,
+        "default_worker_options=": :default_job_options=)
+    end
+
     # This hook happens after all initializers are run, just before returning
     # from config/environment.rb back to sidekiq/cli.rb.
-    # We have to add the reloader after initialize to see if cache_classes has
-    # been turned on.
     #
     # None of this matters on the client-side, only within the Sidekiq process itself.
     config.after_initialize do
-      Sidekiq.configure_server do |_|
-        Sidekiq.options[:reloader] = Sidekiq::Rails::Reloader.new
-      end
-    end
-
-    class Reloader
-      def initialize(app = ::Rails.application)
-        @app = app
-      end
-
-      def call
-        @app.reloader.wrap do
-          yield
-        end
-      end
-
-      def inspect
-        "#<Sidekiq::Rails::Reloader @app=#{@app.class.name}>"
+      Sidekiq.configure_server do |config|
+        config[:reloader] = Sidekiq::Rails::Reloader.new
       end
     end
   end

data/lib/sidekiq/redis_client_adapter.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "connection_pool"
+require "redis_client"
+require "redis_client/decorator"
+require "uri"
+
+module Sidekiq
+  class RedisClientAdapter
+    BaseError = RedisClient::Error
+    CommandError = RedisClient::CommandError
+
+    module CompatMethods
+      def info
+        @client.call("INFO") { |i| i.lines(chomp: true).map { |l| l.split(":", 2) }.select { |l| l.size == 2 }.to_h }
+      end
+
+      def evalsha(sha, keys, argv)
+        @client.call("EVALSHA", sha, keys.size, *keys, *argv)
+      end
+
+      def brpoplpush(*args)
+        @client.blocking_call(false, "BRPOPLPUSH", *args)
+      end
+
+      def brpop(*args)
+        @client.blocking_call(false, "BRPOP", *args)
+      end
+
+      def set(*args)
+        @client.call("SET", *args) { |r| r == "OK" }
+      end
+      ruby2_keywords :set if respond_to?(:ruby2_keywords, true)
+
+      def sismember(*args)
+        @client.call("SISMEMBER", *args) { |c| c > 0 }
+      end
+
+      def exists?(key)
+        @client.call("EXISTS", key) { |c| c > 0 }
+      end
+
+      private
+
+      def method_missing(*args, &block)
+        @client.call(*args, *block)
+      end
+      ruby2_keywords :method_missing if respond_to?(:ruby2_keywords, true)
+
+      def respond_to_missing?(name, include_private = false)
+        super # Appease the linter. We can't tell what is a valid command.
+      end
+    end
+
+    CompatClient = RedisClient::Decorator.create(CompatMethods)
+
+    class CompatClient
+      %i[scan sscan zscan hscan].each do |method|
+        alias_method :"#{method}_each", method
+        undef_method method
+      end
+
+      def disconnect!
+        @client.close
+      end
+
+      def connection
+        {id: @client.id}
+      end
+
+      def redis
+        self
+      end
+
+      def _client
+        @client
+      end
+
+      def message
+        yield nil, @queue.pop
+      end
+
+      # NB: this method does not return
+      def subscribe(chan)
+        @queue = ::Queue.new
+
+        pubsub = @client.pubsub
+        pubsub.call("subscribe", chan)
+
+        loop do
+          evt = pubsub.next_event
+          next if evt.nil?
+          next unless evt[0] == "message" && evt[1] == chan
+
+          (_, _, msg) = evt
+          @queue << msg
+          yield self
+        end
+      end
+    end
+
+    def initialize(options)
+      opts = client_opts(options)
+      @config = if opts.key?(:sentinels)
+        RedisClient.sentinel(**opts)
+      else
+        RedisClient.config(**opts)
+      end
+    end
+
+    def new_client
+      CompatClient.new(@config.new_client)
+    end
+
+    private
+
+    def client_opts(options)
+      opts = options.dup
+
+      if opts[:namespace]
+        Sidekiq.logger.error("Your Redis configuration uses the namespace '#{opts[:namespace]}' but this feature isn't supported by redis-client. " \
+          "Either use the redis adapter or remove the namespace.")
+        Kernel.exit(-127)
+      end
+
+      opts.delete(:size)
+      opts.delete(:pool_timeout)
+
+      if opts[:network_timeout]
+        opts[:timeout] = opts[:network_timeout]
+        opts.delete(:network_timeout)
+      end
+
+      if opts[:driver]
+        opts[:driver] = opts[:driver].to_sym
+      end
+
+      opts[:name] = opts.delete(:master_name) if opts.key?(:master_name)
+      opts[:role] = opts[:role].to_sym if opts.key?(:role)
+      opts.delete(:url) if opts.key?(:sentinels)
+
+      # Issue #3303, redis-rb will silently retry an operation.
+      # This can lead to duplicate jobs if Sidekiq::Client's LPUSH
+      # is performed twice but I believe this is much, much rarer
+      # than the reconnect silently fixing a problem; we keep it
+      # on by default.
+      opts[:reconnect_attempts] ||= 1
+
+      opts
+    end
+  end
+end
+
+Sidekiq::RedisConnection.adapter = Sidekiq::RedisClientAdapter

data/lib/sidekiq/redis_connection.rb

@@ -5,57 +5,20 @@ require "redis"
 require "uri"
 
 module Sidekiq
-  class RedisConnection
-    class << self
-      def create(options = {})
-        options.keys.each do |key|
-          options[key.to_sym] = options.delete(key)
-        end
-
-        if !options[:url] && (u = determine_redis_provider)
-          options[:url] = u
-        end
-
-        size = if options[:size]
-          options[:size]
-        elsif Sidekiq.server?
-          # Give ourselves plenty of connections.  pool is lazy
-          # so we won't create them until we need them.
-          Sidekiq.options[:concurrency] + 5
-        elsif ENV["RAILS_MAX_THREADS"]
-          Integer(ENV["RAILS_MAX_THREADS"])
-        else
-          5
-        end
-
-        verify_sizing(size, Sidekiq.options[:concurrency]) if Sidekiq.server?
-
-        pool_timeout = options[:pool_timeout] || 1
-        log_info(options)
-
-        ConnectionPool.new(timeout: pool_timeout, size: size) do
-          build_client(options)
-        end
-      end
-
-      private
-
-      # Sidekiq needs a lot of concurrent Redis connections.
-      #
-      # We need a connection for each Processor.
-      # We need a connection for Pro's real-time change listener
-      # We need a connection to various features to call Redis every few seconds:
-      #   - the process heartbeat.
-      #   - enterprise's leader election
-      #   - enterprise's cron support
-      def verify_sizing(size, concurrency)
-        raise ArgumentError, "Your Redis connection pool is too small for Sidekiq to work. Your pool has #{size} connections but must have at least #{concurrency + 2}" if size < (concurrency + 2)
+  module RedisConnection
+    class RedisAdapter
+      BaseError = Redis::BaseError
+      CommandError = Redis::CommandError
+
+      def initialize(options)
+        warn("Usage of the 'redis' gem within Sidekiq itself is deprecated, Sidekiq 7.0 will only use the new, simpler 'redis-client' gem", caller) if ENV["SIDEKIQ_REDIS_CLIENT"] == "1"
+        @options = options
       end
 
-      def build_client(options)
-        namespace = options[:namespace]
+      def new_client
+        namespace = @options[:namespace]
 
-        client = Redis.new client_opts(options)
+        client = Redis.new client_opts(@options)
         if namespace
           begin
             require "redis/namespace"
@@ -70,6 +33,8 @@ module Sidekiq
         end
       end
 
+      private
+
       def client_opts(options)
         opts = options.dup
         if opts[:namespace]
@@ -92,12 +57,81 @@ module Sidekiq
 
         opts
       end
+    end
+
+    @adapter = RedisAdapter
+
+    class << self
+      attr_reader :adapter
+
+      # RedisConnection.adapter = :redis
+      # RedisConnection.adapter = :redis_client
+      def adapter=(adapter)
+        raise "no" if adapter == self
+        result = case adapter
+        when :redis
+          RedisAdapter
+        when Class
+          adapter
+        else
+          require "sidekiq/#{adapter}_adapter"
+          nil
+        end
+        @adapter = result if result
+      end
+
+      def create(options = {})
+        symbolized_options = options.transform_keys(&:to_sym)
+
+        if !symbolized_options[:url] && (u = determine_redis_provider)
+          symbolized_options[:url] = u
+        end
+
+        size = if symbolized_options[:size]
+          symbolized_options[:size]
+        elsif Sidekiq.server?
+          # Give ourselves plenty of connections.  pool is lazy
+          # so we won't create them until we need them.
+          Sidekiq[:concurrency] + 5
+        elsif ENV["RAILS_MAX_THREADS"]
+          Integer(ENV["RAILS_MAX_THREADS"])
+        else
+          5
+        end
+
+        verify_sizing(size, Sidekiq[:concurrency]) if Sidekiq.server?
+
+        pool_timeout = symbolized_options[:pool_timeout] || 1
+        log_info(symbolized_options)
+
+        redis_config = adapter.new(symbolized_options)
+        ConnectionPool.new(timeout: pool_timeout, size: size) do
+          redis_config.new_client
+        end
+      end
+
+      private
+
+      # Sidekiq needs many concurrent Redis connections.
+      #
+      # We need a connection for each Processor.
+      # We need a connection for Pro's real-time change listener
+      # We need a connection to various features to call Redis every few seconds:
+      #   - the process heartbeat.
+      #   - enterprise's leader election
+      #   - enterprise's cron support
+      def verify_sizing(size, concurrency)
+        raise ArgumentError, "Your Redis connection pool is too small for Sidekiq. Your pool has #{size} connections but must have at least #{concurrency + 2}" if size < (concurrency + 2)
+      end
 
       def log_info(options)
         redacted = "REDACTED"
 
-        # deep clone so we can muck with these options all we want
-        scrubbed_options = Marshal.load(Marshal.dump(options))
+        # Deep clone so we can muck with these options all we want and exclude
+        # params from dump-and-load that may contain objects that Marshal is
+        # unable to safely dump.
+        keys = options.keys - [:logger, :ssl_params]
+        scrubbed_options = Marshal.load(Marshal.dump(options.slice(*keys)))
         if scrubbed_options[:url] && (uri = URI.parse(scrubbed_options[:url])) && uri.password
           uri.password = redacted
           scrubbed_options[:url] = uri.to_s
@@ -109,9 +143,9 @@ module Sidekiq
           sentinel[:password] = redacted if sentinel[:password]
         end
         if Sidekiq.server?
-          Sidekiq.logger.info("Booting Sidekiq #{Sidekiq::VERSION} with redis options #{scrubbed_options}")
+          Sidekiq.logger.info("Booting Sidekiq #{Sidekiq::VERSION} with #{adapter.name} options #{scrubbed_options}")
         else
-          Sidekiq.logger.debug("#{Sidekiq::NAME} client with redis options #{scrubbed_options}")
+          Sidekiq.logger.debug("#{Sidekiq::NAME} client with #{adapter.name} options #{scrubbed_options}")
         end
       end
 
@@ -124,7 +158,7 @@ module Sidekiq
         # initialization code at all.
         #
         p = ENV["REDIS_PROVIDER"]
-        if p && p =~ /\:/
+        if p && p =~ /:/
           raise <<~EOM
             REDIS_PROVIDER should be set to the name of the variable which contains the Redis URL, not a URL itself.
             Platforms like Heroku will sell addons that publish a *_URL variable.  You need to tell Sidekiq with REDIS_PROVIDER, e.g.: