sidekiq 5.2.10 → 6.0.0.pre1

data/lib/sidekiq/processor.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
-require 'sidekiq/util'
-require 'sidekiq/fetch'
-require 'sidekiq/job_logger'
-require 'sidekiq/job_retry'
-require 'thread'
 
+require "sidekiq/util"
+require "sidekiq/fetch"
+require "sidekiq/job_logger"
+require "sidekiq/job_retry"
 module Sidekiq
   ##
   # The Processor is a standalone thread which:
@@ -23,7 +22,6 @@ module Sidekiq
   # to replace itself and exits.
   #
   class Processor
-
     include Util
 
     attr_reader :thread
@@ -37,19 +35,19 @@ module Sidekiq
       @thread = nil
       @strategy = (mgr.options[:fetch] || Sidekiq::BasicFetch).new(mgr.options)
       @reloader = Sidekiq.options[:reloader]
-      @logging = (mgr.options[:job_logger] || Sidekiq::JobLogger).new
+      @job_logger = (mgr.options[:job_logger] || Sidekiq::JobLogger).new
       @retrier = Sidekiq::JobRetry.new
     end
 
-    def terminate(wait=false)
+    def terminate(wait = false)
       @done = true
-      return if !@thread
+      return unless @thread
       @thread.value if wait
     end
 
-    def kill(wait=false)
+    def kill(wait = false)
       @done = true
-      return if !@thread
+      return unless @thread
       # unlike the other actors, terminate does not wait
       # for the thread to finish because we don't know how
       # long the job will take to finish.  Instead we
@@ -66,16 +64,12 @@ module Sidekiq
     private unless $TESTING
 
     def run
-      begin
-        while !@done
-          process_one
-        end
-        @mgr.processor_stopped(self)
-      rescue Sidekiq::Shutdown
-        @mgr.processor_stopped(self)
-      rescue Exception => ex
-        @mgr.processor_died(self, ex)
-      end
+      process_one until @done
+      @mgr.processor_stopped(self)
+    rescue Sidekiq::Shutdown
+      @mgr.processor_stopped(self)
+    rescue Exception => ex
+      @mgr.processor_died(self, ex)
     end
 
     def process_one
@@ -85,14 +79,15 @@ module Sidekiq
     end
 
     def get_one
-      begin
-        work = @strategy.retrieve_work
-        (logger.info { "Redis is online, #{::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @down} sec downtime" }; @down = nil) if @down
-        work
-      rescue Sidekiq::Shutdown
-      rescue => ex
-        handle_fetch_exception(ex)
+      work = @strategy.retrieve_work
+      if @down
+        logger.info { "Redis is online, #{::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @down} sec downtime" }
+        @down = nil
       end
+      work
+    rescue Sidekiq::Shutdown
+    rescue => ex
+      handle_fetch_exception(ex)
     end
 
     def fetch
@@ -106,7 +101,7 @@ module Sidekiq
     end
 
     def handle_fetch_exception(ex)
-      if !@down
+      unless @down
         @down = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
         logger.error("Error fetching job: #{ex}")
         handle_exception(ex)
@@ -121,18 +116,18 @@ module Sidekiq
       # job structure to the Web UI
       pristine = cloned(job_hash)
 
-      Sidekiq::Logging.with_job_hash_context(job_hash) do
+      @job_logger.with_job_hash_context(job_hash) do
         @retrier.global(pristine, queue) do
-          @logging.call(job_hash, queue) do
+          @job_logger.call(job_hash, queue) do
             stats(pristine, queue) do
               # Rails 5 requires a Reloader to wrap code execution.  In order to
               # constantize the worker and instantiate an instance, we have to call
               # the Reloader.  It handles code loading, db connection management, etc.
               # Effectively this block denotes a "unit of work" to Rails.
               @reloader.call do
-                klass  = constantize(job_hash['class'])
+                klass  = constantize(job_hash["class"])
                 worker = klass.new
-                worker.jid = job_hash['jid']
+                worker.jid = job_hash["jid"]
                 @retrier.local(worker, pristine, queue) do
                   yield worker
                 end
@@ -152,7 +147,7 @@ module Sidekiq
       begin
         job_hash = Sidekiq.load_json(jobstr)
       rescue => ex
-        handle_exception(ex, { :context => "Invalid JSON for job", :jobstr => jobstr })
+        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
@@ -162,7 +157,7 @@ module Sidekiq
       begin
         dispatch(job_hash, queue) do |worker|
           Sidekiq.server_middleware.invoke(worker, job_hash, queue) do
-            execute_job(worker, cloned(job_hash['args']))
+            execute_job(worker, cloned(job_hash["args"]))
           end
         end
       rescue Sidekiq::Shutdown
@@ -173,15 +168,15 @@ module Sidekiq
       rescue Sidekiq::JobRetry::Handled => h
         # this is the common case: job raised error and Sidekiq::JobRetry::Handled
         # signals that we created a retry successfully.  We can acknowlege the job.
-        e = h.cause ? h.cause : h
-        handle_exception(e, { :context => "Job raised exception", :job => job_hash, :jobstr => jobstr })
+        e = h.cause || h
+        handle_exception(e, {context: "Job raised exception", job: job_hash, jobstr: jobstr})
         raise e
       rescue Exception => ex
         # Unexpected error!  This is very bad and indicates an exception that got past
         # the retry subsystem (e.g. network partition).  We won't acknowledge the job
         # so it can be rescued when using Sidekiq Pro.
         ack = false
-        handle_exception(ex, { :context => "Internal exception!", :job => job_hash, :jobstr => jobstr })
+        handle_exception(ex, {context: "Internal exception!", job: job_hash, jobstr: jobstr})
         raise e
       ensure
         work.acknowledge if ack
@@ -201,12 +196,16 @@ module Sidekiq
         @lock = Mutex.new
       end
 
-      def incr(amount=1)
-        @lock.synchronize { @value = @value + amount }
+      def incr(amount = 1)
+        @lock.synchronize { @value += amount }
       end
 
       def reset
-        @lock.synchronize { val = @value; @value = 0; val }
+        @lock.synchronize {
+          val = @value
+          @value = 0
+          val
+        }
       end
     end
 
@@ -243,8 +242,7 @@ module Sidekiq
     WORKER_STATE = SharedWorkerState.new
 
     def stats(job_hash, queue)
-      tid = Sidekiq::Logging.tid
-      WORKER_STATE.set(tid, {:queue => queue, :payload => job_hash, :run_at => Time.now.to_i })
+      WORKER_STATE.set(tid, {queue: queue, payload: job_hash, run_at: Time.now.to_i})
 
       begin
         yield
@@ -265,7 +263,7 @@ module Sidekiq
     end
 
     def constantize(str)
-      names = str.split('::')
+      names = str.split("::")
       names.shift if names.empty? || names.first.empty?
 
       names.inject(Object) do |constant, name|
@@ -274,6 +272,5 @@ module Sidekiq
         constant.const_defined?(name, false) ? constant.const_get(name, false) : constant.const_missing(name)
       end
     end
-
   end
 end

data/lib/sidekiq/rails.rb

@@ -2,22 +2,6 @@
 
 module Sidekiq
   class Rails < ::Rails::Engine
-    # We need to setup this up before any application configuration which might
-    # change Sidekiq middleware.
-    #
-    # This hook happens after `Rails::Application` is inherited within
-    # config/application.rb and before config is touched, usually within the
-    # class block. Definitely before config/environments/*.rb and
-    # config/initializers/*.rb.
-    config.before_configuration do
-      if ::Rails::VERSION::MAJOR < 5 && defined?(::ActiveRecord)
-        Sidekiq.server_middleware do |chain|
-          require 'sidekiq/middleware/server/active_record'
-          chain.add Sidekiq::Middleware::Server::ActiveRecord
-        end
-      end
-    end
-
     config.after_initialize do
       # This hook happens after all initializers are run, just before returning
       # from config/environment.rb back to sidekiq/cli.rb.
@@ -27,9 +11,7 @@ module Sidekiq
       # None of this matters on the client-side, only within the Sidekiq process itself.
       #
       Sidekiq.configure_server do |_|
-        if ::Rails::VERSION::MAJOR >= 5
-          Sidekiq.options[:reloader] = Sidekiq::Rails::Reloader.new
-        end
+        Sidekiq.options[:reloader] = Sidekiq::Rails::Reloader.new
       end
     end
 
@@ -48,11 +30,5 @@ module Sidekiq
         "#<Sidekiq::Rails::Reloader @app=#{@app.class.name}>"
       end
     end
-  end if defined?(::Rails)
-end
-
-if defined?(::Rails) && ::Rails::VERSION::MAJOR < 4
-  $stderr.puts("**************************************************")
-  $stderr.puts("⛔️ WARNING: Sidekiq server is no longer supported by Rails 3.2 - please ensure your server/workers are updated")
-  $stderr.puts("**************************************************")
+  end
 end

data/lib/sidekiq/redis_connection.rb

@@ -1,36 +1,38 @@
 # frozen_string_literal: true
-require 'connection_pool'
-require 'redis'
-require 'uri'
+
+require "connection_pool"
+require "redis"
+require "uri"
 
 module Sidekiq
   class RedisConnection
     class << self
-
-      def create(options={})
+      def create(options = {})
         options.keys.each do |key|
           options[key.to_sym] = options.delete(key)
         end
 
-        options[:id] = "Sidekiq-#{Sidekiq.server? ? "server" : "client"}-PID-#{$$}" if !options.has_key?(:id)
+        options[:id] = "Sidekiq-#{Sidekiq.server? ? "server" : "client"}-PID-#{$PID}" unless options.key?(:id)
         options[:url] ||= determine_redis_provider
 
         size = if options[:size]
-                 options[:size]
-               elsif Sidekiq.server?
-                 Sidekiq.options[:concurrency] + 5
-               elsif ENV['RAILS_MAX_THREADS']
-                 Integer(ENV['RAILS_MAX_THREADS'])
-               else
-                 5
-               end
+          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
+        ConnectionPool.new(timeout: pool_timeout, size: size) do
           build_client(options)
         end
       end
@@ -46,7 +48,7 @@ module Sidekiq
       #   - 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
+        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)
       end
 
       def build_client(options)
@@ -55,8 +57,8 @@ module Sidekiq
         client = Redis.new client_opts(options)
         if namespace
           begin
-            require 'redis/namespace'
-            Redis::Namespace.new(namespace, :redis => client)
+            require "redis/namespace"
+            Redis::Namespace.new(namespace, redis: client)
           rescue LoadError
             Sidekiq.logger.error("Your Redis configuration uses the namespace '#{namespace}' but the redis-namespace gem is not included in the Gemfile." \
                                  "Add the gem to your Gemfile to continue using a namespace. Otherwise, remove the namespace parameter.")
@@ -78,7 +80,7 @@ module Sidekiq
           opts.delete(:network_timeout)
         end
 
-        opts[:driver] ||= Redis::Connection.drivers.last || 'ruby'
+        opts[:driver] ||= Redis::Connection.drivers.last || "ruby"
 
         # Issue #3303, redis-rb will silently retry an operation.
         # This can lead to duplicate jobs if Sidekiq::Client's LPUSH
@@ -115,30 +117,22 @@ module Sidekiq
         # REDIS_PROVIDER=MY_REDIS_URL
         # and Sidekiq will find your custom URL variable with no custom
         # initialization code at all.
-        p = ENV['REDIS_PROVIDER']
+        #
+        p = ENV["REDIS_PROVIDER"]
         if p && p =~ /\:/
-          Sidekiq.logger.error <<-EOM
-
-#################################################################################
-
-REDIS_PROVIDER should be set to the **name** of the variable which contains the Redis URL, not a URL itself.
-Platforms like Heroku sell addons that publish a *_URL variable.  You tell Sidekiq with REDIS_PROVIDER, e.g.:
+          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.:
 
-  REDIS_PROVIDER=REDISTOGO_URL
-  REDISTOGO_URL=redis://somehost.example.com:6379/4
-
-Use REDIS_URL if you wish to point Sidekiq to a URL directly.
-
-This configuration error will crash starting in Sidekiq 5.3.
-
-#################################################################################
-EOM
+            REDIS_PROVIDER=REDISTOGO_URL
+            REDISTOGO_URL=redis://somehost.example.com:6379/4
+          EOM
         end
+
         ENV[
-          ENV['REDIS_PROVIDER'] || 'REDIS_URL'
+          p || "REDIS_URL"
         ]
       end
-
     end
   end
 end

data/lib/sidekiq/scheduled.rb

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
-require 'sidekiq'
-require 'sidekiq/util'
-require 'sidekiq/api'
+
+require "sidekiq"
+require "sidekiq/util"
+require "sidekiq/api"
 
 module Sidekiq
   module Scheduled
-    SETS = %w(retry schedule)
+    SETS = %w[retry schedule]
 
     class Enq
-      def enqueue_jobs(now=Time.now.to_f.to_s, sorted_sets=SETS)
+      def enqueue_jobs(now = Time.now.to_f.to_s, sorted_sets = SETS)
         # A job's "score" in Redis is the time at which it should be processed.
         # Just check Redis for the set of jobs with a timestamp before now.
         Sidekiq.redis do |conn|
@@ -17,14 +18,14 @@ module Sidekiq
             # We need to go through the list one at a time to reduce the risk of something
             # going wrong between the time jobs are popped from the scheduled queue and when
             # they are pushed onto a work queue and losing the jobs.
-            while job = conn.zrangebyscore(sorted_set, '-inf', now, :limit => [0, 1]).first do
+            while (job = conn.zrangebyscore(sorted_set, "-inf", now, limit: [0, 1]).first)
 
               # Pop item off the queue and add it to the work queue. If the job can't be popped from
               # the queue, it's because another process already popped it so we can move on to the
               # next one.
               if conn.zrem(sorted_set, job)
                 Sidekiq::Client.push(Sidekiq.load_json(job))
-                Sidekiq::Logging.logger.debug { "enqueued #{sorted_set}: #{job}" }
+                Sidekiq.logger.debug { "enqueued #{sorted_set}: #{job}" }
               end
             end
           end
@@ -61,26 +62,24 @@ module Sidekiq
       end
 
       def start
-        @thread ||= safe_thread("scheduler") do
+        @thread ||= safe_thread("scheduler") {
           initial_wait
 
-          while !@done
+          until @done
             enqueue
             wait
           end
           Sidekiq.logger.info("Scheduler exiting...")
-        end
+        }
       end
 
       def enqueue
-        begin
-          @enq.enqueue_jobs
-        rescue => ex
-          # Most likely a problem with redis networking.
-          # Punt and try again at the next interval
-          logger.error ex.message
-          handle_exception(ex)
-        end
+        @enq.enqueue_jobs
+      rescue => ex
+        # Most likely a problem with redis networking.
+        # Punt and try again at the next interval
+        logger.error ex.message
+        handle_exception(ex)
       end
 
       private
@@ -168,7 +167,6 @@ module Sidekiq
         @sleeper.pop(total)
       rescue Timeout::Error
       end
-
     end
   end
 end

data/lib/sidekiq/testing/inline.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'sidekiq/testing'
+
+require "sidekiq/testing"
 
 ##
 # The Sidekiq inline infrastructure overrides perform_async so that it

data/lib/sidekiq/testing.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
-require 'securerandom'
-require 'sidekiq'
 
-module Sidekiq
+require "securerandom"
+require "sidekiq"
 
+module Sidekiq
   class Testing
     class << self
       attr_accessor :__test_mode
 
       def __set_test_mode(mode)
         if block_given?
-          current_mode = self.__test_mode
+          current_mode = __test_mode
           begin
             self.__test_mode = mode
             yield
@@ -35,19 +35,19 @@ module Sidekiq
       end
 
       def enabled?
-        self.__test_mode != :disable
+        __test_mode != :disable
       end
 
       def disabled?
-        self.__test_mode == :disable
+        __test_mode == :disable
       end
 
       def fake?
-        self.__test_mode == :fake
+        __test_mode == :fake
       end
 
       def inline?
-        self.__test_mode == :inline
+        __test_mode == :inline
       end
 
       def server_middleware
@@ -57,7 +57,7 @@ module Sidekiq
       end
 
       def constantize(str)
-        names = str.split('::')
+        names = str.split("::")
         names.shift if names.empty? || names.first.empty?
 
         names.inject(Object) do |constant, name|
@@ -77,14 +77,14 @@ module Sidekiq
       if Sidekiq::Testing.fake?
         payloads.each do |job|
           job = Sidekiq.load_json(Sidekiq.dump_json(job))
-          job.merge!('enqueued_at' => Time.now.to_f) unless job['at']
-          Queues.push(job['queue'], job['class'], job)
+          job["enqueued_at"] = Time.now.to_f unless job["at"]
+          Queues.push(job["queue"], job["class"], job)
         end
         true
       elsif Sidekiq::Testing.inline?
         payloads.each do |job|
-          klass = Sidekiq::Testing.constantize(job['class'])
-          job['id'] ||= SecureRandom.hex(12)
+          klass = Sidekiq::Testing.constantize(job["class"])
+          job["id"] ||= SecureRandom.hex(12)
           job_hash = Sidekiq.load_json(Sidekiq.dump_json(job))
           klass.process_job(job_hash)
         end
@@ -255,27 +255,26 @@ module Sidekiq
     #   Then I should receive a welcome email to "foo@example.com"
     #
     module ClassMethods
-
       # Queue for this worker
       def queue
-        self.sidekiq_options["queue"]
+        sidekiq_options["queue"]
       end
 
       # Jobs queued for this worker
       def jobs
-        Queues.jobs_by_worker[self.to_s]
+        Queues.jobs_by_worker[to_s]
       end
 
       # Clear all jobs for this worker
       def clear
-        Queues.clear_for(queue, self.to_s)
+        Queues.clear_for(queue, to_s)
       end
 
       # Drain and run all jobs for this worker
       def drain
         while jobs.any?
           next_job = jobs.first
-          Queues.delete_for(next_job["jid"], next_job["queue"], self.to_s)
+          Queues.delete_for(next_job["jid"], next_job["queue"], to_s)
           process_job(next_job)
         end
       end
@@ -284,16 +283,16 @@ module Sidekiq
       def perform_one
         raise(EmptyQueueError, "perform_one called with empty job queue") if jobs.empty?
         next_job = jobs.first
-        Queues.delete_for(next_job["jid"], queue, self.to_s)
+        Queues.delete_for(next_job["jid"], queue, to_s)
         process_job(next_job)
       end
 
       def process_job(job)
         worker = new
-        worker.jid = job['jid']
-        worker.bid = job['bid'] if worker.respond_to?(:bid=)
-        Sidekiq::Testing.server_middleware.invoke(worker, job, job['queue']) do
-          execute_job(worker, job['args'])
+        worker.jid = job["jid"]
+        worker.bid = job["bid"] if worker.respond_to?(:bid=)
+        Sidekiq::Testing.server_middleware.invoke(worker, job, job["queue"]) do
+          execute_job(worker, job["args"])
         end
       end
 

data/lib/sidekiq/util.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
-require 'socket'
-require 'securerandom'
-require 'sidekiq/exception_handler'
+
+require "socket"
+require "securerandom"
+require "sidekiq/exception_handler"
 
 module Sidekiq
   ##
@@ -15,13 +16,13 @@ module Sidekiq
     def watchdog(last_words)
       yield
     rescue Exception => ex
-      handle_exception(ex, { context: last_words })
+      handle_exception(ex, {context: last_words})
       raise ex
     end
 
     def safe_thread(name, &block)
       Thread.new do
-        Thread.current['sidekiq_label'] = name
+        Thread.current["sidekiq_label"] = name
         watchdog(name, &block)
       end
     end
@@ -34,31 +35,33 @@ module Sidekiq
       Sidekiq.redis(&block)
     end
 
+    def tid
+      Thread.current["sidekiq_tid"] ||= (Thread.current.object_id ^ ::Process.pid).to_s(36)
+    end
+
     def hostname
-      ENV['DYNO'] || Socket.gethostname
+      ENV["DYNO"] || Socket.gethostname
     end
 
     def process_nonce
-      @@process_nonce ||= SecureRandom.hex(6)
+      @process_nonce ||= SecureRandom.hex(6)
     end
 
     def identity
-      @@identity ||= "#{hostname}:#{$$}:#{process_nonce}"
+      @identity ||= "#{hostname}:#{$PID}:#{process_nonce}"
     end
 
-    def fire_event(event, options={})
+    def fire_event(event, options = {})
       reverse = options[:reverse]
       reraise = options[:reraise]
 
       arr = Sidekiq.options[:lifecycle_events][event]
       arr.reverse! if reverse
       arr.each do |block|
-        begin
-          block.call
-        rescue => ex
-          handle_exception(ex, { context: "Exception during Sidekiq lifecycle event.", event: event })
-          raise ex if reraise
-        end
+        block.call
+      rescue => ex
+        handle_exception(ex, {context: "Exception during Sidekiq lifecycle event.", event: event})
+        raise ex if reraise
       end
       arr.clear
     end

data/lib/sidekiq/version.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Sidekiq
-  VERSION = "5.2.10"
+  VERSION = "6.0.0.pre1"
 end