sidekiq 6.5.12 → 7.3.4

data/lib/sidekiq/capsule.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "sidekiq/component"
+
+module Sidekiq
+  # A Sidekiq::Capsule is the set of resources necessary to
+  # process one or more queues with a given concurrency.
+  # One "default" Capsule is started but the user may declare additional
+  # Capsules in their initializer.
+  #
+  # This capsule will pull jobs from the "single" queue and process
+  # the jobs with one thread, meaning the jobs will be processed serially.
+  #
+  # Sidekiq.configure_server do |config|
+  #   config.capsule("single-threaded") do |cap|
+  #     cap.concurrency = 1
+  #     cap.queues = %w(single)
+  #   end
+  # end
+  class Capsule
+    include Sidekiq::Component
+    extend Forwardable
+
+    attr_reader :name
+    attr_reader :queues
+    attr_accessor :concurrency
+    attr_reader :mode
+    attr_reader :weights
+
+    def_delegators :@config, :[], :[]=, :fetch, :key?, :has_key?, :merge!, :dig
+
+    def initialize(name, config)
+      @name = name
+      @config = config
+      @queues = ["default"]
+      @weights = {"default" => 0}
+      @concurrency = config[:concurrency]
+      @mode = :strict
+    end
+
+    def fetcher
+      @fetcher ||= begin
+        instance = (config[:fetch_class] || Sidekiq::BasicFetch).new(self)
+        instance.setup(config[:fetch_setup]) if instance.respond_to?(:setup)
+        instance
+      end
+    end
+
+    def stop
+      fetcher&.bulk_requeue([])
+    end
+
+    # Sidekiq checks queues in three modes:
+    # - :strict - all queues have 0 weight and are checked strictly in order
+    # - :weighted - queues have arbitrary weight between 1 and N
+    # - :random - all queues have weight of 1
+    def queues=(val)
+      @weights = {}
+      @queues = Array(val).each_with_object([]) do |qstr, memo|
+        arr = qstr
+        arr = qstr.split(",") if qstr.is_a?(String)
+        name, weight = arr
+        @weights[name] = weight.to_i
+        [weight.to_i, 1].max.times do
+          memo << name
+        end
+      end
+      @mode = if @weights.values.all?(&:zero?)
+        :strict
+      elsif @weights.values.all? { |x| x == 1 }
+        :random
+      else
+        :weighted
+      end
+    end
+
+    # Allow the middleware to be different per-capsule.
+    # Avoid if possible and add middleware globally so all
+    # capsules share the same chains. Easier to debug that way.
+    def client_middleware
+      @client_chain ||= config.client_middleware.copy_for(self)
+      yield @client_chain if block_given?
+      @client_chain
+    end
+
+    def server_middleware
+      @server_chain ||= config.server_middleware.copy_for(self)
+      yield @server_chain if block_given?
+      @server_chain
+    end
+
+    def redis_pool
+      Thread.current[:sidekiq_redis_pool] || local_redis_pool
+    end
+
+    def local_redis_pool
+      # connection pool is lazy, it will not create connections unless you actually need them
+      # so don't be skimpy!
+      @redis ||= config.new_redis_pool(@concurrency, name)
+    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
+
+    def lookup(name)
+      config.lookup(name)
+    end
+
+    def logger
+      config.logger
+    end
+  end
+end

data/lib/sidekiq/cli.rb

@@ -9,20 +9,11 @@ require "erb"
 require "fileutils"
 
 require "sidekiq"
+require "sidekiq/config"
 require "sidekiq/component"
+require "sidekiq/capsule"
 require "sidekiq/launcher"
 
-# module ScoutApm
-# VERSION = "5.3.1"
-# end
-fail <<~EOM if defined?(ScoutApm::VERSION) && ScoutApm::VERSION < "5.2.0"
-  
-  
-  scout_apm v#{ScoutApm::VERSION} is unsafe with Sidekiq 6.5. Please run `bundle up scout_apm` to upgrade to 5.2.0 or greater.
-  
-  
-EOM
-
 module Sidekiq # :nodoc:
   class CLI
     include Sidekiq::Component
@@ -33,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
@@ -49,10 +38,10 @@ module Sidekiq # :nodoc:
     # Code within this method is not tested because it alters
     # global process state irreversibly.  PRs which improve the
     # test coverage of Sidekiq::CLI are welcomed.
-    def run(boot_app: true)
+    def run(boot_app: true, warmup: 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?
@@ -84,26 +73,27 @@ 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"
+      if maxmemory_policy != "noeviction" && maxmemory_policy != ""
+        # Redis Enterprise Cloud returns "" for their policy 😳
         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
+          See: https://github.com/sidekiq/sidekiq/wiki/Using-Redis#memory
 
         EOM
       end
 
       # 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
@@ -111,12 +101,14 @@ module Sidekiq # :nodoc:
       # Touch middleware so it isn't lazy loaded by multiple threads, #3043
       @config.server_middleware
 
+      ::Process.warmup if warmup && ::Process.respond_to?(:warmup)
+
       # Before this point, the process is initializing with just the main thread.
       # 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
@@ -149,19 +141,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
 
@@ -174,7 +181,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}|____/|_|\\__,_|\\___|_|\\_\\_|\\__, |
@@ -272,6 +279,18 @@ 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
+
+      opts[:capsules]&.each do |name, cap_config|
+        @config.capsule(name.to_s) do |cap|
+          cap.queues = cap_config[:queues]
+          cap.concurrency = cap_config[:concurrency]
+        end
+      end
     end
 
     def boot_application
@@ -279,12 +298,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]
@@ -332,10 +350,6 @@ module Sidekiq # :nodoc:
           opts[:concurrency] = Integer(arg)
         end
 
-        o.on "-d", "--daemon", "Daemonize process" do |arg|
-          puts "ERROR: Daemonization mode was removed in Sidekiq 6.0, please use a proper process supervisor to start and manage your services"
-        end
-
         o.on "-e", "--environment ENV", "Application environment" do |arg|
           opts[:environment] = arg
         end
@@ -345,8 +359,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|
@@ -365,15 +379,7 @@ module Sidekiq # :nodoc:
           opts[:config_file] = arg
         end
 
-        o.on "-L", "--logfile PATH", "path to writable logfile" do |arg|
-          puts "ERROR: Logfile redirection was removed in Sidekiq 6.0, Sidekiq will only log to STDOUT"
-        end
-
-        o.on "-P", "--pidfile PATH", "path to pidfile" do |arg|
-          puts "ERROR: PID file creation was removed in Sidekiq 6.0, please use a proper process supervisor to start and manage your services"
-        end
-
-        o.on "-V", "--version", "Print version and exit" do |arg|
+        o.on "-V", "--version", "Print version and exit" do
           puts "Sidekiq #{Sidekiq::VERSION}"
           die(0)
         end
@@ -393,9 +399,9 @@ module Sidekiq # :nodoc:
     end
 
     def parse_config(path)
-      erb = ERB.new(File.read(path))
+      erb = ERB.new(File.read(path), trim_mode: "-")
       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!
@@ -406,31 +412,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
@@ -438,4 +422,5 @@ module Sidekiq # :nodoc:
 end
 
 require "sidekiq/systemd"
-require "sidekiq/metrics/tracking" if ENV["SIDEKIQ_METRICS_BETA"]
+require "sidekiq/metrics/tracking"
+require "sidekiq/job/interrupt_handler"

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,49 @@ 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
+
+    # Cancel the IterableJob with the given JID.
+    # **NB: Cancellation is asynchronous.** Iteration checks every
+    # five seconds so this will not immediately stop the given job.
+    def cancel!(jid)
+      key = "it-#{jid}"
+      _, result, _ = Sidekiq.redis do |c|
+        c.pipelined do |p|
+          p.hsetnx(key, "cancelled", Time.now.to_i)
+          p.hget(key, "cancelled")
+          p.expire(key, Sidekiq::Job::Iterable::STATE_TTL)
+          # TODO When Redis 7.2 is required
+          # p.expire(key, Sidekiq::Job::Iterable::STATE_TTL, "nx")
+        end
+      end
+      result.to_i
     end
 
     ##
@@ -53,6 +83,7 @@ module Sidekiq
     #   args - an array of simple arguments to the perform method, must be JSON-serializable
     #   at - timestamp to schedule the job (optional), must be Numeric (e.g. Time.now.to_f)
     #   retry - whether to retry this job if it fails, default true or an integer number of retries
+    #   retry_for - relative amount of time to retry this job if it fails, default nil
     #   backtrace - whether to save any error backtrace, default false
     #
     # If class is set to the class name, the jobs' options will be based on Sidekiq's default
@@ -60,7 +91,7 @@ module Sidekiq
     #
     # Any options valid for a job class's sidekiq_options are also available here.
     #
-    # All options must be strings, not symbols.  NB: because we are serializing to JSON, all
+    # All keys must be strings, not symbols.  NB: because we are serializing to JSON, all
     # symbols in 'args' will be converted to strings.  Note that +backtrace: true+ can take quite a bit of
     # space in Redis; a large volume of failing jobs can start Redis swapping if you aren't careful.
     #
@@ -83,8 +114,9 @@ module Sidekiq
 
     ##
     # Push a large number of jobs to Redis. This method cuts out the redis
-    # network round trip latency.  I wouldn't recommend pushing more than
-    # 1000 per call but YMMV based on network quality, size of job args, etc.
+    # network round trip latency. It pushes jobs in batches if more than
+    # `:batch_size` (1000 by default) of jobs are passed. I wouldn't recommend making `:batch_size`
+    # larger than 1000 but YMMV based on network quality, size of job args, etc.
     # A large number of jobs can cause a bit of Redis command processing latency.
     #
     # Takes the same arguments as #push except that args is expected to be
@@ -92,13 +124,15 @@ module Sidekiq
     # is run through the client middleware pipeline and each job gets its own Job ID
     # as normal.
     #
-    # Returns an array of the of pushed jobs' jids.  The number of jobs pushed can be less
-    # than the number given if the middleware stopped processing for one or more jobs.
+    # Returns an array of the of pushed jobs' jids, may contain nils if any client middleware
+    # prevented a job push.
+    #
+    # Example (pushing jobs in batches):
+    #   push_bulk('class' => MyJob, 'args' => (1..100_000).to_a, batch_size: 1_000)
+    #
     def push_bulk(items)
+      batch_size = items.delete(:batch_size) || items.delete("batch_size") || 1_000
       args = items["args"]
-      raise ArgumentError, "Bulk arguments must be an Array of Arrays: [[1], [2]]" unless args.is_a?(Array) && args.all?(Array)
-      return [] if args.empty? # no jobs to push
-
       at = items.delete("at")
       raise ArgumentError, "Job 'at' must be a Numeric or an Array of Numeric timestamps" if at && (Array(at).empty? || !Array(at).all? { |entry| entry.is_a?(Numeric) })
       raise ArgumentError, "Job 'at' Array must have same size as 'args' Array" if at.is_a?(Array) && at.size != args.size
@@ -107,18 +141,28 @@ module Sidekiq
       raise ArgumentError, "Explicitly passing 'jid' when pushing more than one job is not supported" if jid && args.size > 1
 
       normed = normalize_item(items)
-      payloads = args.map.with_index { |job_args, index|
-        copy = normed.merge("args" => job_args, "jid" => SecureRandom.hex(12))
-        copy["at"] = (at.is_a?(Array) ? at[index] : at) if at
-        result = middleware.invoke(items["class"], copy, copy["queue"], @redis_pool) do
-          verify_json(copy)
-          copy
-        end
-        result || nil
-      }.compact
+      slice_index = 0
+      result = args.each_slice(batch_size).flat_map do |slice|
+        raise ArgumentError, "Bulk arguments must be an Array of Arrays: [[1], [2]]" unless slice.is_a?(Array) && slice.all?(Array)
+        break [] if slice.empty? # no jobs to push
+
+        payloads = slice.map.with_index { |job_args, index|
+          copy = normed.merge("args" => job_args, "jid" => SecureRandom.hex(12))
+          copy["at"] = (at.is_a?(Array) ? at[slice_index + index] : at) if at
+          result = middleware.invoke(items["class"], copy, copy["queue"], @redis_pool) do
+            verify_json(copy)
+            copy
+          end
+          result || nil
+        }
+        slice_index += batch_size
+
+        to_push = payloads.compact
+        raw_push(to_push) unless to_push.empty?
+        payloads.map { |payload| payload&.[]("jid") }
+      end
 
-      raw_push(payloads) unless payloads.empty?
-      payloads.collect { |payload| payload["jid"] }
+      result.is_a?(Enumerator::Lazy) ? result.force : result
     end
 
     # Allows sharding of jobs across any number of Redis instances.  All jobs
@@ -135,11 +179,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
@@ -147,8 +191,8 @@ module Sidekiq
         new.push(item)
       end
 
-      def push_bulk(items)
-        new.push_bulk(items)
+      def push_bulk(...)
+        new.push_bulk(...)
       end
 
       # Resque compatibility helpers.  Note all helpers
@@ -201,14 +245,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
@@ -221,7 +265,12 @@ module Sidekiq
     def atomic_push(conn, payloads)
       if payloads.first.key?("at")
         conn.zadd("schedule", payloads.flat_map { |hash|
-          at = hash.delete("at").to_s
+          at = hash["at"].to_s
+          # ActiveJob sets this but the job has not been enqueued yet
+          hash.delete("enqueued_at")
+          # TODO: Use hash.except("at") when support for Ruby 2.7 is dropped
+          hash = hash.dup
+          hash.delete("at")
           [at, Sidekiq.dump_json(hash)]
         })
       else

data/lib/sidekiq/component.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sidekiq
   ##
   # Sidekiq::Component assumes a config instance is available at @config
@@ -13,7 +15,7 @@ module Sidekiq
 
     def safe_thread(name, &block)
       Thread.new do
-        Thread.current.name = name
+        Thread.current.name = "sidekiq.#{name}"
         watchdog(name, &block)
       end
     end
@@ -50,6 +52,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