sidekiq 5.1.3 → 5.2.8

data/lib/sidekiq/manager.rb

@@ -30,7 +30,7 @@ module Sidekiq
     def initialize(options={})
       logger.debug { options.inspect }
       @options = options
-      @count = options[:concurrency] || 25
+      @count = options[:concurrency] || 10
       raise ArgumentError, "Concurrency of #{@count} is not supported" if @count < 1
 
       @done = false
@@ -70,11 +70,11 @@ module Sidekiq
       return if @workers.empty?
 
       logger.info { "Pausing to allow workers to finish..." }
-      remaining = deadline - Time.now
+      remaining = deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       while remaining > PAUSE_TIME
         return if @workers.empty?
         sleep PAUSE_TIME
-        remaining = deadline - Time.now
+        remaining = deadline - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       end
       return if @workers.empty?
 

data/lib/sidekiq/middleware/server/active_record.rb

@@ -7,7 +7,7 @@ module Sidekiq
         def initialize
           # With Rails 5+ we must use the Reloader **always**.
           # The reloader handles code loading and db connection management.
-          if defined?(::Rails) && ::Rails::VERSION::MAJOR >= 5
+          if defined?(::Rails) && defined?(::Rails::VERSION) && ::Rails::VERSION::MAJOR >= 5
             raise ArgumentError, "Rails 5 no longer needs or uses the ActiveRecord middleware."
           end
         end

data/lib/sidekiq/processor.rb

@@ -4,8 +4,6 @@ require 'sidekiq/fetch'
 require 'sidekiq/job_logger'
 require 'sidekiq/job_retry'
 require 'thread'
-require 'concurrent/map'
-require 'concurrent/atomic/atomic_fixnum'
 
 module Sidekiq
   ##
@@ -89,7 +87,7 @@ module Sidekiq
     def get_one
       begin
         work = @strategy.retrieve_work
-        (logger.info { "Redis is online, #{Time.now - @down} sec downtime" }; @down = nil) if @down
+        (logger.info { "Redis is online, #{::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - @down} sec downtime" }; @down = nil) if @down
         work
       rescue Sidekiq::Shutdown
       rescue => ex
@@ -109,7 +107,7 @@ module Sidekiq
 
     def handle_fetch_exception(ex)
       if !@down
-        @down = Time.now
+        @down = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
         logger.error("Error fetching job: #{ex}")
         handle_exception(ex)
       end
@@ -149,21 +147,19 @@ module Sidekiq
       jobstr = work.job
       queue = work.queue_name
 
-      ack = false
+      # Treat malformed JSON as a special case: job goes straight to the morgue.
+      job_hash = nil
       begin
-        # Treat malformed JSON as a special case: job goes straight to the morgue.
-        job_hash = nil
-        begin
-          job_hash = Sidekiq.load_json(jobstr)
-        rescue => ex
-          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)
-          ack = true
-          raise
-        end
+        job_hash = Sidekiq.load_json(jobstr)
+      rescue => ex
+        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
+      end
 
-        ack = true
+      ack = true
+      begin
         dispatch(job_hash, queue) do |worker|
           Sidekiq.server_middleware.invoke(worker, job_hash, queue) do
             execute_job(worker, cloned(job_hash['args']))
@@ -174,10 +170,19 @@ module Sidekiq
         # within the timeout.  Don't acknowledge the work since
         # we didn't properly finish it.
         ack = false
-      rescue Exception => ex
-        e = ex.is_a?(::Sidekiq::JobRetry::Skip) && ex.cause ? ex.cause : ex
+      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 })
         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 })
+        raise e
       ensure
         work.acknowledge if ack
       end
@@ -187,22 +192,68 @@ module Sidekiq
       worker.perform(*cloned_args)
     end
 
-    WORKER_STATE = Concurrent::Map.new
-    PROCESSED = Concurrent::AtomicFixnum.new
-    FAILURE = Concurrent::AtomicFixnum.new
+    # Ruby doesn't provide atomic counters out of the box so we'll
+    # implement something simple ourselves.
+    # https://bugs.ruby-lang.org/issues/14706
+    class Counter
+      def initialize
+        @value = 0
+        @lock = Mutex.new
+      end
+
+      def incr(amount=1)
+        @lock.synchronize { @value = @value + amount }
+      end
+
+      def reset
+        @lock.synchronize { val = @value; @value = 0; val }
+      end
+    end
+
+    # jruby's Hash implementation is not threadsafe, so we wrap it in a mutex here
+    class SharedWorkerState
+      def initialize
+        @worker_state = {}
+        @lock = Mutex.new
+      end
+
+      def set(tid, hash)
+        @lock.synchronize { @worker_state[tid] = hash }
+      end
+
+      def delete(tid)
+        @lock.synchronize { @worker_state.delete(tid) }
+      end
+
+      def dup
+        @lock.synchronize { @worker_state.dup }
+      end
+
+      def size
+        @lock.synchronize { @worker_state.size }
+      end
+
+      def clear
+        @lock.synchronize { @worker_state.clear }
+      end
+    end
+
+    PROCESSED = Counter.new
+    FAILURE = Counter.new
+    WORKER_STATE = SharedWorkerState.new
 
     def stats(job_hash, queue)
       tid = Sidekiq::Logging.tid
-      WORKER_STATE[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
       rescue Exception
-        FAILURE.increment
+        FAILURE.incr
         raise
       ensure
         WORKER_STATE.delete(tid)
-        PROCESSED.increment
+        PROCESSED.incr
       end
     end
 

data/lib/sidekiq/rails.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Sidekiq
   class Rails < ::Rails::Engine
     # We need to setup this up before any application configuration which might
@@ -54,4 +55,4 @@ 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

@@ -78,7 +78,7 @@ module Sidekiq
           opts.delete(:network_timeout)
         end
 
-        opts[:driver] ||= '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,6 +115,25 @@ 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']
+        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.:
+
+  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
+        end
         ENV[
           ENV['REDIS_PROVIDER'] || 'REDIS_URL'
         ]

data/lib/sidekiq/scheduled.rb

@@ -97,9 +97,34 @@ module Sidekiq
         sleep 5
       end
 
-      # Calculates a random interval that is ±50% the desired average.
       def random_poll_interval
-        poll_interval_average * rand + poll_interval_average.to_f / 2
+        # We want one Sidekiq process to schedule jobs every N seconds.  We have M processes
+        # and **don't** want to coordinate.
+        #
+        # So in N*M second timespan, we want each process to schedule once.  The basic loop is:
+        #
+        # * sleep a random amount within that N*M timespan
+        # * wake up and schedule
+        #
+        # We want to avoid one edge case: imagine a set of 2 processes, scheduling every 5 seconds,
+        # so N*M = 10.  Each process decides to randomly sleep 8 seconds, now we've failed to meet
+        # that 5 second average. Thankfully each schedule cycle will sleep randomly so the next
+        # iteration could see each process sleep for 1 second, undercutting our average.
+        #
+        # So below 10 processes, we special case and ensure the processes sleep closer to the average.
+        # In the example above, each process should schedule every 10 seconds on average. We special
+        # case smaller clusters to add 50% so they would sleep somewhere between 5 and 15 seconds.
+        # As we run more processes, the scheduling interval average will approach an even spread
+        # between 0 and poll interval so we don't need this artifical boost.
+        #
+        if process_count < 10
+          # For small clusters, calculate a random interval that is ±50% the desired average.
+          poll_interval_average * rand + poll_interval_average.to_f / 2
+        else
+          # With 10+ processes, we should have enough randomness to get decent polling
+          # across the entire timespan
+          poll_interval_average * rand
+        end
       end
 
       # We do our best to tune the poll interval to the size of the active Sidekiq
@@ -123,9 +148,13 @@ module Sidekiq
       # This minimizes a single point of failure by dispersing check-ins but without taxing
       # Redis if you run many Sidekiq processes.
       def scaled_poll_interval
+        process_count * Sidekiq.options[:average_scheduled_poll_interval]
+      end
+
+      def process_count
         pcount = Sidekiq::ProcessSet.new.size
         pcount = 1 if pcount == 0
-        pcount * Sidekiq.options[:average_scheduled_poll_interval]
+        pcount
       end
 
       def initial_wait

data/lib/sidekiq/testing.rb

@@ -72,9 +72,7 @@ module Sidekiq
 
   class EmptyQueueError < RuntimeError; end
 
-  class Client
-    alias_method :raw_push_real, :raw_push
-
+  module TestingClient
     def raw_push(payloads)
       if Sidekiq::Testing.fake?
         payloads.each do |job|
@@ -92,11 +90,13 @@ module Sidekiq
         end
         true
       else
-        raw_push_real(payloads)
+        super
       end
     end
   end
 
+  Sidekiq::Client.prepend TestingClient
+
   module Queues
     ##
     # The Queues class is only for testing the fake queue implementation.

data/lib/sidekiq/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Sidekiq
-  VERSION = "5.1.3"
+  VERSION = "5.2.8"
 end

data/lib/sidekiq/web/application.rb

@@ -7,6 +7,21 @@ module Sidekiq
     CONTENT_LENGTH = "Content-Length"
     CONTENT_TYPE = "Content-Type"
     REDIS_KEYS = %w(redis_version uptime_in_days connected_clients used_memory_human used_memory_peak_human)
+    CSP_HEADER = [
+      "default-src 'self' https: http:",
+      "child-src 'self'",
+      "connect-src 'self' https: http: wss: ws:",
+      "font-src 'self' https: http:",
+      "frame-src 'self'",
+      "img-src 'self' https: http: data:",
+      "manifest-src 'self'",
+      "media-src 'self'",
+      "object-src 'none'",
+      "script-src 'self' https: http: 'unsafe-inline'",
+      "style-src 'self' https: http: 'unsafe-inline'",
+      "worker-src 'self'",
+      "base-uri 'self'"
+    ].join('; ').freeze
 
     def initialize(klass)
       @klass = klass
@@ -181,6 +196,12 @@ module Sidekiq
       redirect "#{root_path}retries"
     end
 
+    post "/retries/all/kill" do
+      Sidekiq::RetrySet.new.kill_all
+
+      redirect "#{root_path}retries"
+    end
+
     post "/retries/:key" do
       job = Sidekiq::RetrySet.new.fetch(*parse_params(route_params[:key])).first
 
@@ -279,6 +300,7 @@ module Sidekiq
           "Content-Type" => "text/html",
           "Cache-Control" => "no-cache",
           "Content-Language" => action.locale,
+          "Content-Security-Policy" => CSP_HEADER
         }
 
         [200, headers, [resp]]

data/lib/sidekiq/web/helpers.rb

@@ -121,7 +121,7 @@ module Sidekiq
     end
 
     def t(msg, options={})
-      string = get_locale[msg] || msg
+      string = get_locale[msg] || strings('en')[msg] || msg
       if options.empty?
         string
       else
@@ -155,7 +155,7 @@ module Sidekiq
     end
 
     def namespace
-      @@ns ||= Sidekiq.redis { |conn| conn.respond_to?(:namespace) ? conn.namespace : nil }
+      @ns ||= Sidekiq.redis { |conn| conn.respond_to?(:namespace) ? conn.namespace : nil }
     end
 
     def redis_info
@@ -184,7 +184,7 @@ module Sidekiq
     end
 
     def parse_params(params)
-      score, jid = params.split("-")
+      score, jid = params.split("-", 2)
       [score.to_f, jid]
     end
 
@@ -207,9 +207,16 @@ module Sidekiq
     end
 
     def display_args(args, truncate_after_chars = 2000)
-      args.map do |arg|
-        h(truncate(to_display(arg), truncate_after_chars))
-      end.join(", ")
+      return "Invalid job payload, args is nil" if args == nil
+      return "Invalid job payload, args must be an Array, not #{args.class.name}" if !args.is_a?(Array)
+
+      begin
+        args.map do |arg|
+          h(truncate(to_display(arg), truncate_after_chars))
+        end.join(", ")
+      rescue
+        "Illegal job arguments: #{h args.inspect}"
+      end
     end
 
     def csrf_tag

data/lib/sidekiq/worker.rb

@@ -7,13 +7,13 @@ module Sidekiq
   # Include this module in your worker class and you can easily create
   # asynchronous jobs:
   #
-  # class HardWorker
-  #   include Sidekiq::Worker
+  #   class HardWorker
+  #     include Sidekiq::Worker
   #
-  #   def perform(*args)
-  #     # do some work
+  #     def perform(*args)
+  #       # do some work
+  #     end
   #   end
-  # end
   #
   # Then in your Rails app, you can do this:
   #
@@ -46,6 +46,11 @@ module Sidekiq
         @opts = opts
       end
 
+      def set(options)
+        @opts.merge!(options)
+        self
+      end
+
       def perform_async(*args)
         @klass.client_push(@opts.merge('args' => args, 'class' => @klass))
       end
@@ -66,6 +71,7 @@ module Sidekiq
     end
 
     module ClassMethods
+      ACCESSOR_MUTEX = Mutex.new
 
       def delay(*args)
         raise ArgumentError, "Do not call .delay on a Sidekiq::Worker class, call .perform_async"
@@ -148,10 +154,18 @@ module Sidekiq
         instance_writer = true
 
         attrs.each do |name|
+          synchronized_getter = "__synchronized_#{name}"
+
           singleton_class.instance_eval do
             undef_method(name) if method_defined?(name) || private_method_defined?(name)
           end
-          define_singleton_method(name) { nil }
+
+          define_singleton_method(synchronized_getter) { nil }
+          singleton_class.class_eval do
+            private(synchronized_getter)
+          end
+
+          define_singleton_method(name) { ACCESSOR_MUTEX.synchronize { send synchronized_getter } }
 
           ivar = "@#{name}"
 
@@ -161,8 +175,10 @@ module Sidekiq
           end
           define_singleton_method("#{name}=") do |val|
             singleton_class.class_eval do
-              undef_method(name) if method_defined?(name) || private_method_defined?(name)
-              define_method(name) { val }
+              ACCESSOR_MUTEX.synchronize do
+                undef_method(synchronized_getter) if method_defined?(synchronized_getter) || private_method_defined?(synchronized_getter)
+                define_method(synchronized_getter) { val }
+              end
             end
 
             if singleton_class?

data/lib/sidekiq.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'sidekiq/version'
 fail "Sidekiq #{Sidekiq::VERSION} does not support Ruby versions below 2.2.2." if RUBY_PLATFORM != 'java' && Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.2.2')
 
@@ -17,7 +18,7 @@ module Sidekiq
   DEFAULTS = {
     queues: [],
     labels: [],
-    concurrency: 25,
+    concurrency: 10,
     require: '.',
     environment: nil,
     timeout: 8,
@@ -56,6 +57,7 @@ module Sidekiq
   def self.options
     @options ||= DEFAULTS.dup
   end
+
   def self.options=(opts)
     @options = opts
   end
@@ -94,8 +96,8 @@ module Sidekiq
       begin
         yield conn
       rescue Redis::CommandError => ex
-        #2550 Failover can cause the server to become a slave, need
-        # to disconnect and reopen the socket to get back to the master.
+        #2550 Failover can cause the server to become a replica, need
+        # to disconnect and reopen the socket to get back to the primary.
         (conn.disconnect!; retryable = false; retry) if retryable && ex.message =~ /READONLY/
         raise
       end

data/sidekiq.gemspec

@@ -1,5 +1,4 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/sidekiq/version', __FILE__)
+require_relative 'lib/sidekiq/version'
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Mike Perham"]
@@ -11,18 +10,12 @@ Gem::Specification.new do |gem|
 
   gem.executables   = ['sidekiq', 'sidekiqctl']
   gem.files         = `git ls-files | grep -Ev '^(test|myapp|examples)'`.split("\n")
-  gem.test_files    = []
   gem.name          = "sidekiq"
-  gem.require_paths = ["lib"]
   gem.version       = Sidekiq::VERSION
   gem.required_ruby_version = ">= 2.2.2"
 
-  gem.add_dependency                  'redis', '>= 3.3.5', '< 5'
-  gem.add_dependency                  'connection_pool', '~> 2.2', '>= 2.2.0'
-  gem.add_dependency                  'concurrent-ruby', '~> 1.0'
-  gem.add_dependency                  'rack-protection', '>= 1.5.0'
-  gem.add_development_dependency      'redis-namespace', '~> 1.5', '>= 1.5.2'
-  gem.add_development_dependency      'minitest', '~> 5.10', '>= 5.10.1'
-  gem.add_development_dependency      'rake', '~> 10.0'
-  gem.add_development_dependency      'rails', '>= 3.2.0'
+  gem.add_dependency 'redis', '>= 3.3.5', '< 5'
+  gem.add_dependency 'connection_pool', '~> 2.2', '>= 2.2.2'
+  gem.add_dependency 'rack', '< 2.1.0'
+  gem.add_dependency 'rack-protection', '>= 1.5.0'
 end

data/web/assets/javascripts/dashboard.js

@@ -298,8 +298,18 @@ var debounce = function(fn, timeout)
   }
 };
 
-window.onresize = debounce(function() {
-    clearInterval(poller);
-    resetGraphs();
-    renderGraphs();
-}, 125);
+window.onresize = function() {
+  var prevWidth = window.innerWidth;
+  
+  return debounce(function () {
+    var currWidth = window.innerWidth;
+    
+    if (prevWidth !== currWidth) {
+      prevWidth = currWidth;
+      
+      clearInterval(poller);
+      resetGraphs();
+      renderGraphs();
+    }
+  }, 125);
+}();

data/web/assets/stylesheets/application.css

@@ -126,7 +126,7 @@ header.row .pagination {
   text-align: center;
   width: 14%;
 }
-@media (max-width: 767px) and (min-width: 400px) {
+@media (max-width: 767px) and (min-width: 200px) {
   .summary_bar ul li {
     width: 100%;
   }
@@ -219,6 +219,29 @@ table .table-checkbox label {
   color: #585454;
 }
 
+
+.nav.navbar-nav{
+  display: flex;
+  width: 100%;
+}
+
+.navbar-livereload{
+  margin-left: auto;
+  white-space: nowrap;
+}
+
+.navbar-livereload .poll-wrapper a:last-child{
+	margin-left: 8px;
+}
+
+.navbar-right{
+  margin-right: 0;
+}
+
+.navbar-collapse.collapse{
+  overflow-x: auto !important;
+}
+
 @media (max-width: 768px) {
   .navbar .navbar-header .navbar-livereload {
     border: none;
@@ -234,13 +257,19 @@ table .table-checkbox label {
     display: none;
   }
 
+  .nav.navbar-nav{
+  	display: block;
+  	width: auto;
+  }
+
   .navbar.navbar-fixed-top ul {
     margin-right: -15px!important;
   }
 
   .navbar .nav a {
     text-align: center;
-  }
+  }  
+
 }
 
 @media (width: 768px) {
@@ -645,6 +674,10 @@ div.interval-slider input {
     margin-right: 0;
   }
 
+  .navbar #navbar-menu{
+  	display: none;
+  }
+
   .poll-wrapper {
     width: 100%;
     text-align: center;