sidekiq 6.5.6 → 7.0.0.beta1

data/lib/sidekiq/cli.rb

@@ -9,7 +9,9 @@ require "erb"
 require "fileutils"
 
 require "sidekiq"
+require "sidekiq/config"
 require "sidekiq/component"
+require "sidekiq/capsule"
 require "sidekiq/launcher"
 
 module Sidekiq # :nodoc:
@@ -22,9 +24,7 @@ module Sidekiq # :nodoc:
     attr_accessor :config
 
     def parse(args = ARGV.dup)
-      @config = Sidekiq
-      @config[:error_handlers].clear
-      @config[:error_handlers] << @config.method(:default_error_handler)
+      @config ||= Sidekiq.default_configuration
 
       setup_options(args)
       initialize_logger
@@ -41,7 +41,7 @@ module Sidekiq # :nodoc:
     def run(boot_app: true)
       boot_application if boot_app
 
-      if environment == "development" && $stdout.tty? && @config.log_formatter.is_a?(Sidekiq::Logger::Formatters::Pretty)
+      if environment == "development" && $stdout.tty? && @config.logger.formatter.is_a?(Sidekiq::Logger::Formatters::Pretty)
         print_banner
       end
       logger.info "Booted Rails #{::Rails.version} application in #{environment} environment" if rails_app?
@@ -73,8 +73,8 @@ module Sidekiq # :nodoc:
       # touch the connection pool so it is created before we
       # fire startup and start multithreading.
       info = @config.redis_info
-      ver = info["redis_version"]
-      raise "You are connecting to Redis v#{ver}, Sidekiq requires Redis v4.0.0 or greater" if ver < "4"
+      ver = Gem::Version.new(info["redis_version"])
+      raise "You are connecting to Redis #{ver}, Sidekiq requires Redis 6.2.0 or greater" if ver < Gem::Version.new("6.2.0")
 
       maxmemory_policy = info["maxmemory_policy"]
       if maxmemory_policy != "noeviction"
@@ -90,9 +90,9 @@ module Sidekiq # :nodoc:
 
       # Since the user can pass us a connection pool explicitly in the initializer, we
       # need to verify the size is large enough or else Sidekiq's performance is dramatically slowed.
-      cursize = @config.redis_pool.size
-      needed = @config[:concurrency] + 2
-      raise "Your pool of #{cursize} Redis connections is too small, please increase the size to at least #{needed}" if cursize < needed
+      @config.capsules.each_pair do |name, cap|
+        raise ArgumentError, "Pool size too small for #{name}" if cap.redis_pool.size < cap.concurrency
+      end
 
       # cache process identity
       @config[:identity] = identity
@@ -104,8 +104,8 @@ module Sidekiq # :nodoc:
       # Starting here the process will now have multiple threads running.
       fire_event(:startup, reverse: false, reraise: true)
 
-      logger.debug { "Client Middleware: #{@config.client_middleware.map(&:klass).join(", ")}" }
-      logger.debug { "Server Middleware: #{@config.server_middleware.map(&:klass).join(", ")}" }
+      logger.debug { "Client Middleware: #{@config.default_capsule.client_middleware.map(&:klass).join(", ")}" }
+      logger.debug { "Server Middleware: #{@config.default_capsule.server_middleware.map(&:klass).join(", ")}" }
 
       launch(self_read)
     end
@@ -138,19 +138,34 @@ module Sidekiq # :nodoc:
       end
     end
 
-    def self.w
-      "\e[37m"
+    HOLIDAY_COLORS = {
+      # got other color-specific holidays from around the world?
+      # https://developer-book.com/post/definitive-guide-for-colored-text-in-terminal/#256-color-escape-codes
+      "3-17" => "\e[1;32m", # St. Patrick's Day green
+      "10-31" => "\e[38;5;208m" # Halloween orange
+    }
+
+    def self.day
+      @@day ||= begin
+        t = Date.today
+        "#{t.month}-#{t.day}"
+      end
     end
 
     def self.r
-      "\e[31m"
+      @@r ||= HOLIDAY_COLORS[day] || "\e[1;31m"
     end
 
     def self.b
-      "\e[30m"
+      @@b ||= HOLIDAY_COLORS[day] || "\e[30m"
+    end
+
+    def self.w
+      "\e[1;37m"
     end
 
     def self.reset
+      @@b = @@r = @@day = nil
       "\e[0m"
     end
 
@@ -163,7 +178,7 @@ module Sidekiq # :nodoc:
       #{w}     ,$$$$$b#{b}/#{w}md$$$P^'
       #{w}   .d$$$$$$#{b}/#{w}$$$P'
       #{w}   $$^' `"#{b}/#{w}$$$'       #{r}____  _     _      _    _
-      #{w}   $:     ,$$:      #{r} / ___|(_) __| | ___| | _(_) __ _
+      #{w}   $:    #{b}'#{w},$$:      #{r} / ___|(_) __| | ___| | _(_) __ _
       #{w}   `b     :$$       #{r} \\___ \\| |/ _` |/ _ \\ |/ / |/ _` |
       #{w}          $$:        #{r} ___) | | (_| |  __/   <| | (_| |
       #{w}          $$         #{r}|____/|_|\\__,_|\\___|_|\\_\\_|\\__, |
@@ -260,6 +275,11 @@ module Sidekiq # :nodoc:
 
       # merge with defaults
       @config.merge!(opts)
+
+      @config.default_capsule.tap do |cap|
+        cap.queues = opts[:queues]
+        cap.concurrency = opts[:concurrency] || @config[:concurrency]
+      end
     end
 
     def boot_application
@@ -267,12 +287,11 @@ module Sidekiq # :nodoc:
 
       if File.directory?(@config[:require])
         require "rails"
-        if ::Rails::VERSION::MAJOR < 5
-          raise "Sidekiq no longer supports this version of Rails"
-        else
-          require "sidekiq/rails"
-          require File.expand_path("#{@config[:require]}/config/environment.rb")
+        if ::Rails::VERSION::MAJOR < 6
+          warn "Sidekiq #{Sidekiq::VERSION} only supports Rails 6+"
         end
+        require "sidekiq/rails"
+        require File.expand_path("#{@config[:require]}/config/environment.rb")
         @config[:tag] ||= default_tag
       else
         require @config[:require]
@@ -333,8 +352,8 @@ module Sidekiq # :nodoc:
         end
 
         o.on "-q", "--queue QUEUE[,WEIGHT]", "Queues to process with optional weights" do |arg|
-          queue, weight = arg.split(",")
-          parse_queue opts, queue, weight
+          opts[:queues] ||= []
+          opts[:queues] << arg
         end
 
         o.on "-r", "--require [PATH|DIR]", "Location of Rails application with jobs or file to require" do |arg|
@@ -383,7 +402,7 @@ module Sidekiq # :nodoc:
     def parse_config(path)
       erb = ERB.new(File.read(path))
       erb.filename = File.expand_path(path)
-      opts = load_yaml(erb.result) || {}
+      opts = YAML.safe_load(erb.result, permitted_classes: [Symbol], aliases: true) || {}
 
       if opts.respond_to? :deep_symbolize_keys!
         opts.deep_symbolize_keys!
@@ -394,31 +413,9 @@ module Sidekiq # :nodoc:
       opts = opts.merge(opts.delete(environment.to_sym) || {})
       opts.delete(:strict)
 
-      parse_queues(opts, opts.delete(:queues) || [])
-
       opts
     end
 
-    def load_yaml(src)
-      if Psych::VERSION > "4.0"
-        YAML.safe_load(src, permitted_classes: [Symbol], aliases: true)
-      else
-        YAML.load(src)
-      end
-    end
-
-    def parse_queues(opts, queues_and_weights)
-      queues_and_weights.each { |queue_and_weight| parse_queue(opts, *queue_and_weight) }
-    end
-
-    def parse_queue(opts, queue, weight = nil)
-      opts[:queues] ||= []
-      opts[:strict] = true if opts[:strict].nil?
-      raise ArgumentError, "queues: #{queue} cannot be defined twice" if opts[:queues].include?(queue)
-      [weight.to_i, 1].max.times { opts[:queues] << queue.to_s }
-      opts[:strict] = false if weight.to_i > 0
-    end
-
     def rails_app?
       defined?(::Rails) && ::Rails.respond_to?(:application)
     end
@@ -426,4 +423,4 @@ module Sidekiq # :nodoc:
 end
 
 require "sidekiq/systemd"
-require "sidekiq/metrics/tracking" if ENV["SIDEKIQ_METRICS_BETA"]
+require "sidekiq/metrics/tracking"

data/lib/sidekiq/client.rb

@@ -21,7 +21,6 @@ module Sidekiq
     # Sidekiq.client_middleware but you can change as necessary.
     #
     def middleware(&block)
-      @chain ||= Sidekiq.client_middleware
       if block
         @chain = @chain.dup
         yield @chain
@@ -31,18 +30,32 @@ module Sidekiq
 
     attr_accessor :redis_pool
 
-    # Sidekiq::Client normally uses the default Redis pool but you may
-    # pass a custom ConnectionPool if you want to shard your
-    # Sidekiq jobs across several Redis instances (for scalability
-    # reasons, e.g.)
+    # Sidekiq::Client is responsible for pushing job payloads to Redis.
+    # Requires the :pool or :config keyword argument.
     #
-    #   Sidekiq::Client.new(ConnectionPool.new { Redis.new })
+    #   Sidekiq::Client.new(pool: Sidekiq::RedisConnection.create)
     #
-    # Generally this is only needed for very large Sidekiq installs processing
-    # thousands of jobs per second.  I don't recommend sharding unless you
-    # cannot scale any other way (e.g. splitting your app into smaller apps).
-    def initialize(redis_pool = nil)
-      @redis_pool = redis_pool || Thread.current[:sidekiq_via_pool] || Sidekiq.redis_pool
+    # Inside the Sidekiq process, you can reuse the configured resources:
+    #
+    #   Sidekiq::Client.new(config: config)
+    #
+    # @param pool [ConnectionPool] explicit Redis pool to use
+    # @param config [Sidekiq::Config] use the pool and middleware from the given Sidekiq container
+    # @param chain [Sidekiq::Middleware::Chain] use the given middleware chain
+    def initialize(*args, **kwargs)
+      if args.size == 1 && kwargs.size == 0
+        warn "Sidekiq::Client.new(pool) is deprecated, please use Sidekiq::Client.new(pool: pool), #{caller(0..3)}"
+        # old calling method, accept 1 pool argument
+        @redis_pool = args[0]
+        @chain = Sidekiq.default_configuration.client_middleware
+        @config = Sidekiq.default_configuration
+      else
+        # new calling method: keyword arguments
+        @config = kwargs[:config] || Sidekiq.default_configuration
+        @redis_pool = kwargs[:pool] || Thread.current[:sidekiq_redis_pool] || @config&.redis_pool
+        @chain = kwargs[:chain] || @config&.client_middleware
+        raise ArgumentError, "No Redis pool available for Sidekiq::Client" unless @redis_pool
+      end
     end
 
     ##
@@ -135,11 +148,11 @@ module Sidekiq
     # you cannot scale any other way (e.g. splitting your app into smaller apps).
     def self.via(pool)
       raise ArgumentError, "No pool given" if pool.nil?
-      current_sidekiq_pool = Thread.current[:sidekiq_via_pool]
-      Thread.current[:sidekiq_via_pool] = pool
+      current_sidekiq_pool = Thread.current[:sidekiq_redis_pool]
+      Thread.current[:sidekiq_redis_pool] = pool
       yield
     ensure
-      Thread.current[:sidekiq_via_pool] = current_sidekiq_pool
+      Thread.current[:sidekiq_redis_pool] = current_sidekiq_pool
     end
 
     class << self
@@ -201,14 +214,14 @@ module Sidekiq
           conn.pipelined do |pipeline|
             atomic_push(pipeline, payloads)
           end
-        rescue RedisConnection.adapter::BaseError => ex
+        rescue RedisClient::Error => ex
           # 2550 Failover can cause the server to become a replica, need
           # to disconnect and reopen the socket to get back to the primary.
           # 4495 Use the same logic if we have a "Not enough replicas" error from the primary
           # 4985 Use the same logic when a blocking command is force-unblocked
           # The retry logic is copied from sidekiq.rb
           if retryable && ex.message =~ /READONLY|NOREPLICAS|UNBLOCKED/
-            conn.disconnect!
+            conn.close
             retryable = false
             retry
           end

data/lib/sidekiq/component.rb

@@ -50,6 +50,7 @@ module Sidekiq
       oneshot = options.fetch(:oneshot, true)
       reverse = options[:reverse]
       reraise = options[:reraise]
+      logger.debug("Firing #{event} event") if oneshot
 
       arr = config[:lifecycle_events][event]
       arr.reverse! if reverse

data/lib/sidekiq/config.rb

@@ -0,0 +1,270 @@
+require "forwardable"
+
+require "set"
+require "sidekiq/redis_connection"
+
+module Sidekiq
+  # Sidekiq::Config represents the global configuration for an instance of Sidekiq.
+  class Config
+    extend Forwardable
+
+    DEFAULTS = {
+      labels: Set.new,
+      require: ".",
+      environment: nil,
+      concurrency: 5,
+      timeout: 25,
+      poll_interval_average: nil,
+      average_scheduled_poll_interval: 5,
+      on_complex_arguments: :raise,
+      error_handlers: [],
+      death_handlers: [],
+      lifecycle_events: {
+        startup: [],
+        quiet: [],
+        shutdown: [],
+        # triggers when we fire the first heartbeat on startup OR repairing a network partition
+        heartbeat: [],
+        # triggers on EVERY heartbeat call, every 10 seconds
+        beat: []
+      },
+      dead_max_jobs: 10_000,
+      dead_timeout_in_seconds: 180 * 24 * 60 * 60, # 6 months
+      reloader: proc { |&block| block.call }
+    }
+
+    ERROR_HANDLER = ->(ex, ctx, cfg = Sidekiq.default_configuration) {
+      l = cfg.logger
+      l.warn(Sidekiq.dump_json(ctx)) unless ctx.empty?
+      l.warn("#{ex.class.name}: #{ex.message}")
+      l.warn(ex.backtrace.join("\n")) unless ex.backtrace.nil?
+    }
+
+    def initialize(options = {})
+      @options = DEFAULTS.merge(options)
+      @options[:error_handlers] << ERROR_HANDLER if @options[:error_handlers].empty?
+      @directory = {}
+      @redis_config = {}
+      @capsules = {}
+    end
+
+    def_delegators :@options, :[], :[]=, :fetch, :key?, :has_key?, :merge!
+    attr_reader :options
+    attr_reader :capsules
+
+    # LEGACY: edits the default capsule
+    # config.concurrency = 5
+    def concurrency=(val)
+      default_capsule.concurrency = Integer(val)
+    end
+
+    def concurrency
+      default_capsule.concurrency
+    end
+
+    def total_concurrency
+      capsules.each_value.sum(&:concurrency)
+    end
+
+    # Edit the default capsule.
+    # config.queues = %w( high default low )                 # strict
+    # config.queues = %w( high,3 default,2 low,1 )           # weighted
+    # config.queues = %w( feature1,1 feature2,1 feature3,1 ) # random
+    #
+    # With weighted priority, queue will be checked first (weight / total) of the time.
+    # high will be checked first (3/6) or 50% of the time.
+    # I'd recommend setting weights between 1-10. Weights in the hundreds or thousands
+    # are ridiculous and unnecessarily expensive. You can get random queue ordering
+    # by explicitly setting all weights to 1.
+    def queues=(val)
+      default_capsule.queues = val
+    end
+
+    def queues
+      default_capsule.queues
+    end
+
+    def client_middleware
+      @client_chain ||= Sidekiq::Middleware::Chain.new(self)
+      yield @client_chain if block_given?
+      @client_chain
+    end
+
+    def server_middleware
+      @server_chain ||= Sidekiq::Middleware::Chain.new(self)
+      yield @server_chain if block_given?
+      @server_chain
+    end
+
+    def default_capsule(&block)
+      capsule("default", &block)
+    end
+
+    # register a new queue processing subsystem
+    def capsule(name)
+      nm = name.to_s
+      cap = @capsules.fetch(nm) do
+        cap = Sidekiq::Capsule.new(nm, self)
+        @capsules[nm] = cap
+      end
+      yield cap if block_given?
+      cap
+    end
+
+    # All capsules must use the same Redis configuration
+    def redis=(hash)
+      @redis_config = @redis_config.merge(hash)
+    end
+
+    def redis_pool
+      Thread.current[:sidekiq_redis_pool] || Thread.current[:sidekiq_capsule]&.redis_pool || local_redis_pool
+    end
+
+    private def local_redis_pool
+      # this is our internal client/housekeeping pool. each capsule has its
+      # own pool for executing threads.
+      @redis ||= new_redis_pool(5, "internal")
+    end
+
+    def new_redis_pool(size, name = "unset")
+      # connection pool is lazy, it will not create connections unless you actually need them
+      # so don't be skimpy!
+      RedisConnection.create(@redis_config.merge(size: size, logger: logger, pool_name: name))
+    end
+
+    def redis_info
+      redis do |conn|
+        conn.info
+      rescue RedisClientAdapter::CommandError => ex
+        # 2850 return fake version when INFO command has (probably) been renamed
+        raise unless /unknown command/.match?(ex.message)
+        {
+          "redis_version" => "9.9.9",
+          "uptime_in_days" => "9999",
+          "connected_clients" => "9999",
+          "used_memory_human" => "9P",
+          "used_memory_peak_human" => "9P"
+        }.freeze
+      end
+    end
+
+    def redis
+      raise ArgumentError, "requires a block" unless block_given?
+      redis_pool.with do |conn|
+        retryable = true
+        begin
+          yield conn
+        rescue RedisClientAdapter::BaseError => ex
+          # 2550 Failover can cause the server to become a replica, need
+          # to disconnect and reopen the socket to get back to the primary.
+          # 4495 Use the same logic if we have a "Not enough replicas" error from the primary
+          # 4985 Use the same logic when a blocking command is force-unblocked
+          # The same retry logic is also used in client.rb
+          if retryable && ex.message =~ /READONLY|NOREPLICAS|UNBLOCKED/
+            conn.close
+            retryable = false
+            retry
+          end
+          raise
+        end
+      end
+    end
+
+    # register global singletons which can be accessed elsewhere
+    def register(name, instance)
+      @directory[name] = instance
+    end
+
+    # find a singleton
+    def lookup(name, default_class = nil)
+      # JNDI is just a fancy name for a hash lookup
+      @directory.fetch(name) do |key|
+        return nil unless default_class
+        @directory[key] = default_class.new(self)
+      end
+    end
+
+    ##
+    # Death handlers are called when all retries for a job have been exhausted and
+    # the job dies.  It's the notification to your application
+    # that this job will not succeed without manual intervention.
+    #
+    # Sidekiq.configure_server do |config|
+    #   config.death_handlers << ->(job, ex) do
+    #   end
+    # end
+    def death_handlers
+      @options[:death_handlers]
+    end
+
+    # How frequently Redis should be checked by a random Sidekiq process for
+    # scheduled and retriable jobs. Each individual process will take turns by
+    # waiting some multiple of this value.
+    #
+    # See sidekiq/scheduled.rb for an in-depth explanation of this value
+    def average_scheduled_poll_interval=(interval)
+      @options[:average_scheduled_poll_interval] = interval
+    end
+
+    # Register a proc to handle any error which occurs within the Sidekiq process.
+    #
+    #   Sidekiq.configure_server do |config|
+    #     config.error_handlers << proc {|ex,ctx_hash| MyErrorService.notify(ex, ctx_hash) }
+    #   end
+    #
+    # The default error handler logs errors to @logger.
+    def error_handlers
+      @options[:error_handlers]
+    end
+
+    # Register a block to run at a point in the Sidekiq lifecycle.
+    # :startup, :quiet or :shutdown are valid events.
+    #
+    #   Sidekiq.configure_server do |config|
+    #     config.on(:shutdown) do
+    #       puts "Goodbye cruel world!"
+    #     end
+    #   end
+    def on(event, &block)
+      raise ArgumentError, "Symbols only please: #{event}" unless event.is_a?(Symbol)
+      raise ArgumentError, "Invalid event name: #{event}" unless @options[:lifecycle_events].key?(event)
+      @options[:lifecycle_events][event] << block
+    end
+
+    def logger
+      @logger ||= Sidekiq::Logger.new($stdout, level: :info).tap do |log|
+        log.level = Logger::INFO
+        log.formatter = if ENV["DYNO"]
+          Sidekiq::Logger::Formatters::WithoutTimestamp.new
+        else
+          Sidekiq::Logger::Formatters::Pretty.new
+        end
+      end
+    end
+
+    def logger=(logger)
+      if logger.nil?
+        self.logger.level = Logger::FATAL
+        return
+      end
+
+      logger.extend(Sidekiq::LoggingUtils)
+      @logger = logger
+    end
+
+    # INTERNAL USE ONLY
+    def handle_exception(ex, ctx = {})
+      if @options[:error_handlers].size == 0
+        p ["!!!!!", ex]
+      end
+      @options[:error_handlers].each do |handler|
+        handler.call(ex, ctx, self)
+      rescue => e
+        l = logger
+        l.error "!!! ERROR HANDLER THREW AN ERROR !!!"
+        l.error e
+        l.error e.backtrace.join("\n") unless e.backtrace.nil?
+      end
+    end
+  end
+end

data/lib/sidekiq/deploy.rb

@@ -0,0 +1,62 @@
+require "sidekiq/redis_connection"
+require "time"
+
+# This file is designed to be required within the user's
+# deployment script; it should need a bare minimum of dependencies.
+# Usage:
+#
+#   require "sidekiq/deploy"
+#   Sidekiq::Deploy.mark!("Some change")
+#
+# If you do not pass a label, Sidekiq will try to use the latest
+# git commit info.
+#
+
+module Sidekiq
+  class Deploy
+    MARK_TTL = 90 * 24 * 60 * 60 # 90 days
+
+    LABEL_MAKER = -> {
+      `git log -1 --format="%h %s"`.strip
+    }
+
+    def self.mark!(label = nil)
+      label ||= LABEL_MAKER.call
+      Sidekiq::Deploy.new.mark(label: label)
+    end
+
+    def initialize(pool = Sidekiq::RedisConnection.create)
+      @pool = pool
+    end
+
+    def mark(at: Time.now, label: "")
+      # we need to round the timestamp so that we gracefully
+      # handle an very common error in marking deploys:
+      # having every process mark its deploy, leading
+      # to N marks for each deploy. Instead we round the time
+      # to the minute so that multple marks within that minute
+      # will all naturally rollup into one mark per minute.
+      whence = at.utc
+      floor = Time.utc(whence.year, whence.month, whence.mday, whence.hour, whence.min, 0)
+      datecode = floor.strftime("%Y%m%d")
+      key = "#{datecode}-marks"
+      stamp = floor.iso8601
+
+      @pool.with do |c|
+        # only allow one deploy mark for a given label for the next minute
+        lock = c.set("deploylock-#{label}", stamp, nx: true, ex: 60)
+        if lock
+          c.multi do |pipe|
+            pipe.hsetnx(key, stamp, label)
+            pipe.expire(key, MARK_TTL)
+          end
+        end
+      end
+    end
+
+    def fetch(date = Time.now.utc.to_date)
+      datecode = date.strftime("%Y%m%d")
+      @pool.with { |c| c.hgetall("#{datecode}-marks") }
+    end
+  end
+end

data/lib/sidekiq/embedded.rb

@@ -0,0 +1,61 @@
+require "sidekiq/component"
+require "sidekiq/launcher"
+require "sidekiq/metrics/tracking"
+
+module Sidekiq
+  class Embedded
+    include Sidekiq::Component
+
+    def initialize(config)
+      @config = config
+    end
+
+    def run
+      housekeeping
+      fire_event(:startup, reverse: false, reraise: true)
+      @launcher = Sidekiq::Launcher.new(@config, embedded: true)
+      @launcher.run
+      sleep 0.1 # pause to give threads time to spin up
+
+      logger.info "Embedded mode running with #{Thread.list.size} threads"
+      logger.debug { Thread.list.map(&:name) }
+    end
+
+    def quiet
+      @launcher&.quiet
+    end
+
+    def stop
+      @launcher&.stop
+    end
+
+    private
+
+    def housekeeping
+      logger.info "Running in #{RUBY_DESCRIPTION}"
+      logger.info Sidekiq::LICENSE
+      logger.info "Upgrade to Sidekiq Pro for more features and support: https://sidekiq.org" unless defined?(::Sidekiq::Pro)
+
+      # touch the connection pool so it is created before we
+      # fire startup and start multithreading.
+      info = config.redis_info
+      ver = Gem::Version.new(info["redis_version"])
+      raise "You are connecting to Redis #{ver}, Sidekiq requires Redis 6.2.0 or greater" if ver < Gem::Version.new("6.2.0")
+
+      maxmemory_policy = info["maxmemory_policy"]
+      if maxmemory_policy != "noeviction"
+        logger.warn <<~EOM
+
+
+          WARNING: Your Redis instance will evict Sidekiq data under heavy load.
+          The 'noeviction' maxmemory policy is recommended (current policy: '#{maxmemory_policy}').
+          See: https://github.com/mperham/sidekiq/wiki/Using-Redis#memory
+
+        EOM
+      end
+
+      logger.debug { "Client Middleware: #{@config.default_capsule.client_middleware.map(&:klass).join(", ")}" }
+      logger.debug { "Server Middleware: #{@config.default_capsule.server_middleware.map(&:klass).join(", ")}" }
+    end
+  end
+end