sidekiq 3.5.4 → 5.2.7

data/lib/sidekiq/testing/inline.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'sidekiq/testing'
 
 ##

data/lib/sidekiq/util.rb

@@ -1,7 +1,7 @@
+# frozen_string_literal: true
 require 'socket'
 require 'securerandom'
 require 'sidekiq/exception_handler'
-require 'sidekiq/core_ext'
 
 module Sidekiq
   ##
@@ -19,6 +19,13 @@ module Sidekiq
       raise ex
     end
 
+    def safe_thread(name, &block)
+      Thread.new do
+        Thread.current['sidekiq_label'] = name
+        watchdog(name, &block)
+      end
+    end
+
     def logger
       Sidekiq.logger
     end
@@ -39,30 +46,21 @@ module Sidekiq
       @@identity ||= "#{hostname}:#{$$}:#{process_nonce}"
     end
 
-    def fire_event(event, reverse=false)
+    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, { event: event })
+          handle_exception(ex, { context: "Exception during Sidekiq lifecycle event.", event: event })
+          raise ex if reraise
         end
       end
+      arr.clear
     end
-
-    def want_a_hertz_donut?
-      # what's a hertz donut?
-      # punch!  Hurts, don't it?
-      info = Sidekiq.redis {|c| c.info }
-      if info['connected_clients'].to_i > 1000 && info['hz'].to_i >= 10
-        Sidekiq.logger.warn { "Your Redis `hz` setting is too high at #{info['hz']}.  See mperham/sidekiq#2431.  Set it to 3 in #{info[:config_file]}" }
-        true
-      else
-        Sidekiq.logger.debug { "Redis hz: #{info['hz']}.  Client count: #{info['connected_clients']}" }
-        false
-      end
-    end
-
   end
 end

data/lib/sidekiq/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Sidekiq
-  VERSION = "3.5.4"
+  VERSION = "5.2.7"
 end

data/lib/sidekiq/web.rb

@@ -1,25 +1,28 @@
+# frozen_string_literal: true
 require 'erb'
-require 'yaml'
-require 'sinatra/base'
 
 require 'sidekiq'
 require 'sidekiq/api'
 require 'sidekiq/paginator'
-require 'sidekiq/web_helpers'
+require 'sidekiq/web/helpers'
 
-module Sidekiq
-  class Web < Sinatra::Base
-    include Sidekiq::Paginator
+require 'sidekiq/web/router'
+require 'sidekiq/web/action'
+require 'sidekiq/web/application'
 
-    enable :sessions
-    use Rack::Protection, :use => :authenticity_token unless ENV['RACK_ENV'] == 'test'
+require 'rack/protection'
 
-    set :root, File.expand_path(File.dirname(__FILE__) + "/../../web")
-    set :public_folder, proc { "#{root}/assets" }
-    set :views, proc { "#{root}/views" }
-    set :locales, ["#{root}/locales"]
+require 'rack/builder'
+require 'rack/file'
+require 'rack/session/cookie'
 
-    helpers WebHelpers
+module Sidekiq
+  class Web
+    ROOT = File.expand_path("#{File.dirname(__FILE__)}/../../web")
+    VIEWS = "#{ROOT}/views"
+    LOCALES = ["#{ROOT}/locales"]
+    LAYOUT = "#{VIEWS}/layout.erb"
+    ASSETS = "#{ROOT}/assets"
 
     DEFAULT_TABS = {
       "Dashboard" => '',
@@ -31,6 +34,18 @@ module Sidekiq
     }
 
     class << self
+      def settings
+        self
+      end
+
+      def middlewares
+        @middlewares ||= []
+      end
+
+      def use(*middleware_args, &block)
+        middlewares << [middleware_args, block]
+      end
+
       def default_tabs
         DEFAULT_TABS
       end
@@ -40,234 +55,155 @@ module Sidekiq
       end
       alias_method :tabs, :custom_tabs
 
-      attr_accessor :app_url
-    end
+      def locales
+        @locales ||= LOCALES
+      end
 
-    get "/busy" do
-      erb :busy
-    end
+      def views
+        @views ||= VIEWS
+      end
 
-    post "/busy" do
-      if params['identity']
-        p = Sidekiq::Process.new('identity' => params['identity'])
-        p.quiet! if params[:quiet]
-        p.stop! if params[:stop]
-      else
-        processes.each do |pro|
-          pro.quiet! if params[:quiet]
-          pro.stop! if params[:stop]
-        end
+      def enable(*opts)
+        opts.each {|key| set(key, true) }
       end
-      redirect "#{root_path}busy"
-    end
 
-    get "/queues" do
-      @queues = Sidekiq::Queue.all
-      erb :queues
-    end
+      def disable(*opts)
+        opts.each {|key| set(key, false) }
+      end
 
-    get "/queues/:name" do
-      halt 404 unless params[:name]
-      @count = (params[:count] || 25).to_i
-      @name = params[:name]
-      @queue = Sidekiq::Queue.new(@name)
-      (@current_page, @total_size, @messages) = page("queue:#{@name}", params[:page], @count)
-      @messages = @messages.map { |msg| Sidekiq::Job.new(msg, @name) }
-      erb :queue
-    end
+      # Helper for the Sinatra syntax: Sidekiq::Web.set(:session_secret, Rails.application.secrets...)
+      def set(attribute, value)
+        send(:"#{attribute}=", value)
+      end
 
-    post "/queues/:name" do
-      Sidekiq::Queue.new(params[:name]).clear
-      redirect "#{root_path}queues"
+      attr_accessor :app_url, :session_secret, :redis_pool, :sessions
+      attr_writer :locales, :views
     end
 
-    post "/queues/:name/delete" do
-      Sidekiq::Job.new(params[:key_val], params[:name]).delete
-      redirect_with_query("#{root_path}queues/#{params[:name]}")
+    def self.inherited(child)
+      child.app_url = self.app_url
+      child.session_secret = self.session_secret
+      child.redis_pool = self.redis_pool
+      child.sessions = self.sessions
     end
 
-    get '/morgue' do
-      @count = (params[:count] || 25).to_i
-      (@current_page, @total_size, @dead) = page("dead", params[:page], @count, reverse: true)
-      @dead = @dead.map { |msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
-      erb :morgue
+    def settings
+      self.class.settings
     end
 
-    get "/morgue/:key" do
-      halt 404 unless params['key']
-      @dead = Sidekiq::DeadSet.new.fetch(*parse_params(params['key'])).first
-      redirect "#{root_path}morgue" if @dead.nil?
-      erb :dead
+    def use(*middleware_args, &block)
+      middlewares << [middleware_args, block]
     end
 
-    post '/morgue' do
-      redirect request.path unless params['key']
-
-      params['key'].each do |key|
-        job = Sidekiq::DeadSet.new.fetch(*parse_params(key)).first
-        retry_or_delete_or_kill job, params if job
-      end
-      redirect_with_query("#{root_path}morgue")
+    def middlewares
+      @middlewares ||= Web.middlewares.dup
     end
 
-    post "/morgue/all/delete" do
-      Sidekiq::DeadSet.new.clear
-      redirect "#{root_path}morgue"
+    def call(env)
+      app.call(env)
     end
 
-    post "/morgue/all/retry" do
-      Sidekiq::DeadSet.new.retry_all
-      redirect "#{root_path}morgue"
+    def self.call(env)
+      @app ||= new
+      @app.call(env)
     end
 
-    post "/morgue/:key" do
-      halt 404 unless params['key']
-      job = Sidekiq::DeadSet.new.fetch(*parse_params(params['key'])).first
-      retry_or_delete_or_kill job, params if job
-      redirect_with_query("#{root_path}morgue")
+    def app
+      @app ||= build
     end
 
-
-    get '/retries' do
-      @count = (params[:count] || 25).to_i
-      (@current_page, @total_size, @retries) = page("retry", params[:page], @count)
-      @retries = @retries.map { |msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
-      erb :retries
+    def enable(*opts)
+      opts.each {|key| set(key, true) }
     end
 
-    get "/retries/:key" do
-      @retry = Sidekiq::RetrySet.new.fetch(*parse_params(params['key'])).first
-      redirect "#{root_path}retries" if @retry.nil?
-      erb :retry
+    def disable(*opts)
+      opts.each {|key| set(key, false) }
     end
 
-    post '/retries' do
-      redirect request.path unless params['key']
-
-      params['key'].each do |key|
-        job = Sidekiq::RetrySet.new.fetch(*parse_params(key)).first
-        retry_or_delete_or_kill job, params if job
-      end
-      redirect_with_query("#{root_path}retries")
+    def set(attribute, value)
+      send(:"#{attribute}=", value)
     end
 
-    post "/retries/all/delete" do
-      Sidekiq::RetrySet.new.clear
-      redirect "#{root_path}retries"
-    end
+    # Default values
+    set :sessions, true
 
-    post "/retries/all/retry" do
-      Sidekiq::RetrySet.new.retry_all
-      redirect "#{root_path}retries"
-    end
+    attr_writer :sessions
 
-    post "/retries/:key" do
-      job = Sidekiq::RetrySet.new.fetch(*parse_params(params['key'])).first
-      retry_or_delete_or_kill job, params if job
-      redirect_with_query("#{root_path}retries")
-    end
+    def sessions
+      unless instance_variable_defined?("@sessions")
+        @sessions = self.class.sessions
+        @sessions = @sessions.to_hash.dup if @sessions.respond_to?(:to_hash)
+      end
 
-    get '/scheduled' do
-      @count = (params[:count] || 25).to_i
-      (@current_page, @total_size, @scheduled) = page("schedule", params[:page], @count)
-      @scheduled = @scheduled.map { |msg, score| Sidekiq::SortedEntry.new(nil, score, msg) }
-      erb :scheduled
+      @sessions
     end
 
-    get "/scheduled/:key" do
-      @job = Sidekiq::ScheduledSet.new.fetch(*parse_params(params['key'])).first
-      redirect "#{root_path}scheduled" if @job.nil?
-      erb :scheduled_job_info
+    def self.register(extension)
+      extension.registered(WebApplication)
     end
 
-    post '/scheduled' do
-      redirect request.path unless params['key']
+    private
 
-      params['key'].each do |key|
-        job = Sidekiq::ScheduledSet.new.fetch(*parse_params(key)).first
-        delete_or_add_queue job, params if job
+    def using?(middleware)
+      middlewares.any? do |(m,_)|
+        m.kind_of?(Array) && (m[0] == middleware || m[0].kind_of?(middleware))
       end
-      redirect_with_query("#{root_path}scheduled")
     end
 
-    post "/scheduled/:key" do
-      halt 404 unless params['key']
-      job = Sidekiq::ScheduledSet.new.fetch(*parse_params(params['key'])).first
-      delete_or_add_queue job, params if job
-      redirect_with_query("#{root_path}scheduled")
-    end
+    def build_sessions
+      middlewares = self.middlewares
 
-    get '/' do
-      @redis_info = redis_info.select{ |k, v| REDIS_KEYS.include? k }
-      stats_history = Sidekiq::Stats::History.new((params[:days] || 30).to_i)
-      @processed_history = stats_history.processed
-      @failed_history = stats_history.failed
-      erb :dashboard
-    end
+      unless using?(::Rack::Protection) || ENV['RACK_ENV'] == 'test'
+        middlewares.unshift [[::Rack::Protection, { use: :authenticity_token }], nil]
+      end
 
-    REDIS_KEYS = %w(redis_version uptime_in_days connected_clients used_memory_human used_memory_peak_human)
+      s = sessions
+      return unless s
 
-    get '/dashboard/stats' do
-      redirect "#{root_path}stats"
-    end
+      unless using? ::Rack::Session::Cookie
+        unless secret = Web.session_secret
+          require 'securerandom'
+          secret = SecureRandom.hex(64)
+        end
+
+        options = { secret: secret }
+        options = options.merge(s.to_hash) if s.respond_to? :to_hash
 
-    get '/stats' do
-      sidekiq_stats = Sidekiq::Stats.new
-      redis_stats   = redis_info.select { |k, v| REDIS_KEYS.include? k }
-
-      content_type :json
-      Sidekiq.dump_json(
-        sidekiq: {
-          processed:       sidekiq_stats.processed,
-          failed:          sidekiq_stats.failed,
-          busy:            sidekiq_stats.workers_size,
-          processes:       sidekiq_stats.processes_size,
-          enqueued:        sidekiq_stats.enqueued,
-          scheduled:       sidekiq_stats.scheduled_size,
-          retries:         sidekiq_stats.retry_size,
-          dead:            sidekiq_stats.dead_size,
-          default_latency: sidekiq_stats.default_queue_latency
-        },
-        redis: redis_stats
-      )
+        middlewares.unshift [[::Rack::Session::Cookie, options], nil]
+      end
     end
 
-    get '/stats/queues' do
-      queue_stats = Sidekiq::Stats::Queues.new
+    def build
+      build_sessions
 
-      content_type :json
-      Sidekiq.dump_json(
-        queue_stats.lengths
-      )
-    end
+      middlewares = self.middlewares
+      klass = self.class
 
-    private
+      ::Rack::Builder.new do
+        %w(stylesheets javascripts images).each do |asset_dir|
+          map "/#{asset_dir}" do
+            run ::Rack::File.new("#{ASSETS}/#{asset_dir}", { 'Cache-Control' => 'public, max-age=86400' })
+          end
+        end
 
-    def retry_or_delete_or_kill job, params
-      if params['retry']
-        job.retry
-      elsif params['delete']
-        job.delete
-      elsif params['kill']
-        job.kill
-      end
-    end
+        middlewares.each {|middleware, block| use(*middleware, &block) }
 
-    def delete_or_add_queue job, params
-      if params['delete']
-        job.delete
-      elsif params['add_to_queue']
-        job.add_to_queue
+        run WebApplication.new(klass)
       end
     end
   end
+
+  Sidekiq::WebApplication.helpers WebHelpers
+  Sidekiq::WebApplication.helpers Sidekiq::Paginator
+
+  Sidekiq::WebAction.class_eval "def _render\n#{ERB.new(File.read(Web::LAYOUT)).src}\nend"
 end
 
 if defined?(::ActionDispatch::Request::Session) &&
-    !::ActionDispatch::Request::Session.respond_to?(:each)
+    !::ActionDispatch::Request::Session.method_defined?(:each)
   # mperham/sidekiq#2460
   # Rack apps can't reuse the Rails session store without
-  # this monkeypatch
+  # this monkeypatch, fixed in Rails 5.
   class ActionDispatch::Request::Session
     def each(&block)
       hash = self.to_hash