sidekiq 2.5.4 → 2.6.0

data/.travis.yml

@@ -3,6 +3,7 @@ rvm:
   - 1.9.3
   - jruby-19mode
   - rbx-19mode
+  - 2.0.0
 branches:
   only:
     - master
@@ -15,3 +16,4 @@ matrix:
   allow_failures:
     - rvm: jruby-19mode
     - rvm: rbx-19mode
+    - rvm: 2.0.0

data/Changes.md

@@ -1,3 +1,13 @@
+2.6.0
+-----------
+
+- Web UI much more mobile friendly now [brandonhilkert, #573]
+- Enable live polling for every section in Web UI [brandonhilkert, #567]
+- Add Stats API [brandonhilkert, #565]
+- Add Stats::History API [brandonhilkert, #570]
+- Add Dashboard to Web UI with live and historical stat graphs [brandonhilkert, #580]
+- Add option to log output to a file, reopen log file on USR2 signal [mrnugget, #581]
+
 2.5.4
 -----------
 

data/examples/sinkiq.rb

@@ -19,8 +19,9 @@ class SinatraWorker
 end
 
 get '/' do
-  @failed = Sidekiq.info[:failed]
-  @processed = Sidekiq.info[:processed]
+  stats = Sidekiq::Stats.new
+  @failed = stats.failed
+  @processed = stats.processed
   @messages = $redis.lrange('sinkiq-example-messages', 0, -1)
   erb :index
 end

data/lib/sidekiq/api.rb

@@ -1,6 +1,91 @@
 require 'sidekiq'
 
 module Sidekiq
+  class Stats
+    def processed
+      count = Sidekiq.redis do |conn|
+                conn.get("stat:processed")
+              end
+      count.nil? ? 0 : count.to_i
+    end
+
+    def failed
+      count = Sidekiq.redis do |conn|
+                conn.get("stat:failed")
+              end
+      count.nil? ? 0 : count.to_i
+    end
+
+    def queues
+      Sidekiq.redis do |conn|
+        queues = conn.smembers('queues')
+
+        array_of_arrays = queues.inject({}) do |memo, queue|
+          memo[queue] = conn.llen("queue:#{queue}")
+          memo
+        end.sort_by { |_, size| size }
+
+        Hash[array_of_arrays.reverse]
+      end
+    end
+
+    def enqueued
+      queues.values.inject(&:+) || 0
+    end
+
+    class History
+      def initialize(days_previous, start_date = nil)
+        @days_previous = days_previous
+        @start_date = start_date || Time.now.utc.to_date
+      end
+
+      def processed
+        date_stat_hash("processed")
+      end
+
+      def failed
+        date_stat_hash("failed")
+      end
+
+      def self.cleanup
+        days_of_stats_to_keep = 180
+        today = Time.now.utc.to_date
+        delete_before_date = Time.now.utc.to_date - days_of_stats_to_keep
+
+        Sidekiq.redis do |conn|
+          processed_keys = conn.keys("stat:processed:*")
+          earliest = "stat:processed:#{delete_before_date.to_s}"
+          pkeys = processed_keys.select { |key| key < earliest }
+          conn.del(pkeys) if pkeys.size > 0
+
+          failed_keys = conn.keys("stat:failed:*")
+          earliest = "stat:failed:#{delete_before_date.to_s}"
+          fkeys = failed_keys.select { |key| key < earliest }
+          conn.del(fkeys) if fkeys.size > 0
+        end
+      end
+
+      private
+
+      def date_stat_hash(stat)
+        i = 0
+        stat_hash = {}
+
+        Sidekiq.redis do |conn|
+          while i < @days_previous
+            date = @start_date - i
+            value = conn.get("stat:#{stat}:#{date}")
+
+            stat_hash[date.to_s] = value ? value.to_i : 0
+
+            i += 1
+          end
+        end
+
+        stat_hash
+      end
+    end
+  end
 
   ##
   # Encapsulates a queue within Sidekiq.
@@ -110,11 +195,24 @@ module Sidekiq
     end
 
     def at
-      Time.at(@score)
+      Time.at(score)
     end
 
     def delete
-      @parent.delete(@score)
+      @parent.delete(score, jid)
+    end
+
+    def retry
+      raise "Retry not available on jobs not in the Retry queue." unless item["failed_at"]
+      Sidekiq.redis do |conn|
+        results = conn.zrangebyscore('retry', score, score)
+        conn.zremrangebyscore('retry', score, score)
+        results.map do |message|
+          msg = Sidekiq.load_json(message)
+          msg['retry_count'] = msg['retry_count'] - 1
+          conn.rpush("queue:#{msg['queue']}", Sidekiq.dump_json(msg))
+        end
+      end
     end
   end
 
@@ -146,11 +244,42 @@ module Sidekiq
       end
     end
 
-    def delete(score)
-      count = Sidekiq.redis do |conn|
-        conn.zremrangebyscore(@zset, score, score)
+    def fetch(score, jid = nil)
+      elements = Sidekiq.redis do |conn|
+        conn.zrangebyscore(@zset, score, score)
+      end
+
+      elements.inject([]) do |result, element|
+        entry = SortedEntry.new(self, score, element)
+        if jid
+          result << entry if entry.jid == jid
+        else
+          result << entry
+        end
+        result
+      end
+    end
+
+    def delete(score, jid = nil)
+      if jid
+        elements = Sidekiq.redis do |conn|
+          conn.zrangebyscore(@zset, score, score)
+        end
+
+        elements_with_jid = elements.map do |element|
+          message = Sidekiq.load_json(element)
+
+          if message["jid"] == jid
+            Sidekiq.redis { |conn| conn.zrem(@zset, element) }
+          end
+        end
+        elements_with_jid.count != 0
+      else
+        count = Sidekiq.redis do |conn|
+          conn.zremrangebyscore(@zset, score, score)
+        end
+        count != 0
       end
-      count != 0
     end
 
     def clear

data/lib/sidekiq/capistrano.rb

@@ -4,6 +4,8 @@ Capistrano::Configuration.instance.load do
   after "deploy:start",   "sidekiq:start"
   after "deploy:restart", "sidekiq:restart"
 
+  _cset(:sidekiq_cmd) { "#{fetch(:bundle_cmd, "bundle")} exec sidekiq" }
+  _cset(:sidekiqctl_cmd) { "#{fetch(:bundle_cmd, "bundle")} exec sidekiqctl" }
   _cset(:sidekiq_timeout)   { 10 }
   _cset(:sidekiq_role)      { :app }
   _cset(:sidekiq_pid)       { "#{current_path}/tmp/pids/sidekiq.pid" }
@@ -19,14 +21,14 @@ Capistrano::Configuration.instance.load do
     desc "Quiet sidekiq (stop accepting new work)"
     task :quiet, :roles => lambda { fetch(:sidekiq_role) }, :on_no_matching_servers => :continue do
       for_each_process do |pid_file|
-        run "if [ -d #{current_path} ] && [ -f #{pid_file} ]; then cd #{current_path} && #{fetch(:bundle_cmd, "bundle")} exec sidekiqctl quiet #{pid_file} ; fi"
+        run "if [ -d #{current_path} ] && [ -f #{pid_file} ]; then cd #{current_path} && #{fetch(:sidekiqctl_cmd)} quiet #{pid_file} ; fi"
       end
     end
 
     desc "Stop sidekiq"
     task :stop, :roles => lambda { fetch(:sidekiq_role) }, :on_no_matching_servers => :continue do
       for_each_process do |pid_file|
-        run "if [ -d #{current_path} ] && [ -f #{pid_file} ]; then cd #{current_path} && #{fetch(:bundle_cmd, "bundle")} exec sidekiqctl stop #{pid_file} #{fetch :sidekiq_timeout} ; fi"
+        run "if [ -d #{current_path} ] && [ -f #{pid_file} ]; then cd #{current_path} && #{fetch(:sidekiqctl_cmd)} stop #{pid_file} #{fetch :sidekiq_timeout} ; fi"
       end
     end
 
@@ -34,7 +36,7 @@ Capistrano::Configuration.instance.load do
     task :start, :roles => lambda { fetch(:sidekiq_role) }, :on_no_matching_servers => :continue do
       rails_env = fetch(:rails_env, "production")
       for_each_process do |pid_file|
-        run "cd #{current_path} ; nohup #{fetch(:bundle_cmd, "bundle")} exec sidekiq -e #{rails_env} -C #{current_path}/config/sidekiq.yml -P #{pid_file} >> #{current_path}/log/sidekiq.log 2>&1 &", :pty => false
+        run "cd #{current_path} ; nohup #{fetch(:sidekiq_cmd)} -e #{rails_env} -C #{current_path}/config/sidekiq.yml -P #{pid_file} >> #{current_path}/log/sidekiq.log 2>&1 &", :pty => false
       end
     end
 

data/lib/sidekiq/cli.rb

@@ -15,6 +15,13 @@ trap 'USR1' do
   mgr.async.stop if mgr
 end
 
+trap 'USR2' do
+  if Sidekiq.options[:logfile]
+    Sidekiq.logger.info "Received USR2, reopening log file"
+    Sidekiq::Logging.initialize_logger(Sidekiq.options[:logfile])
+  end
+end
+
 trap 'TTIN' do
   Thread.list.each do |thread|
     Sidekiq.logger.info "Thread TID-#{thread.object_id.to_s(36)} #{thread['label']}"
@@ -56,15 +63,12 @@ module Sidekiq
 
     def parse(args=ARGV)
       @code = nil
-      Sidekiq.logger
 
       cli = parse_options(args)
       config = parse_config(cli)
       options.merge!(config.merge(cli))
 
-      Sidekiq.logger.level = Logger::DEBUG if options[:verbose]
-      Celluloid.logger = nil unless options[:verbose]
-
+      initialize_logger
       validate!
       write_pid
       boot_system
@@ -75,6 +79,8 @@ module Sidekiq
       logger.info "Running in #{RUBY_DESCRIPTION}"
       logger.info Sidekiq::LICENSE
 
+      Sidekiq::Stats::History.cleanup
+
       @manager = Sidekiq::Manager.new(options)
       poller = Sidekiq::Scheduled::Poller.new
       begin
@@ -166,8 +172,8 @@ module Sidekiq
           parse_queues opts, queues_and_weights
         end
 
-        o.on "-v", "--verbose", "Print more verbose output" do
-          Sidekiq.logger.level = ::Logger::DEBUG
+        o.on "-v", "--verbose", "Print more verbose output" do |arg|
+          opts[:verbose] = arg
         end
 
         o.on '-e', '--environment ENV', "Application environment" do |arg|
@@ -198,6 +204,10 @@ module Sidekiq
           opts[:config_file] = arg
         end
 
+        o.on '-L', '--logfile PATH', "path to writable logfile" do |arg|
+          opts[:logfile] = arg
+        end
+
         o.on '-V', '--version', "Print version and exit" do |arg|
           puts "Sidekiq #{Sidekiq::VERSION}"
           die(0)
@@ -213,6 +223,13 @@ module Sidekiq
       opts
     end
 
+    def initialize_logger
+      Sidekiq::Logging.initialize_logger(options[:logfile]) if options[:logfile]
+
+      Sidekiq.logger.level = Logger::DEBUG if options[:verbose]
+      Celluloid.logger = nil unless options[:verbose]
+    end
+
     def write_pid
       if path = options[:pidfile]
         File.open(path, 'w') do |f|

data/lib/sidekiq/logging.rb

@@ -25,13 +25,15 @@ module Sidekiq
       end
     end
 
+    def self.initialize_logger(log_target = STDOUT)
+      @logger = Logger.new(log_target)
+      @logger.level = Logger::INFO
+      @logger.formatter = Pretty.new
+      @logger
+    end
+
     def self.logger
-      @logger ||= begin
-        log = Logger.new(STDOUT)
-        log.level = Logger::INFO
-        log.formatter = Pretty.new
-        log
-      end
+      @logger || initialize_logger
     end
 
     def self.logger=(log)
@@ -41,6 +43,5 @@ module Sidekiq
     def logger
       Sidekiq::Logging.logger
     end
-
   end
 end

data/lib/sidekiq/processor.rb

@@ -80,6 +80,7 @@ module Sidekiq
         redis do |conn|
           conn.multi do
             conn.incrby("stat:failed", 1)
+            conn.incrby("stat:failed:#{Time.now.utc.to_date}", 1)
           end
         end
         raise
@@ -90,6 +91,7 @@ module Sidekiq
             conn.del("worker:#{self}")
             conn.del("worker:#{self}:started")
             conn.incrby("stat:processed", 1)
+            conn.incrby("stat:processed:#{Time.now.utc.to_date}", 1)
           end
         end
       end

data/lib/sidekiq/stats.rb

@@ -1,31 +1,8 @@
 module Sidekiq
   module_function
 
-  def info
-    results = {}
-    processed, failed, queues = Sidekiq.redis { |conn|
-      conn.multi do
-        conn.get('stat:processed')
-        conn.get('stat:failed')
-        conn.smembers('queues')
-      end
-    }
-    results[:queues_with_sizes] = Sidekiq.redis do |conn|
-      queues.inject({}) { |memo, q|
-        memo[q] = conn.llen("queue:#{q}")
-        memo
-      }.sort_by { |_, size| size }
-    end
-    results[:processed] = (processed || 0).to_i
-    results[:failed] = (failed || 0).to_i
-    results[:backlog] = results[:queues_with_sizes].
-                          map {|_, size| size }.
-                          inject(0) {|memo, val| memo + val }
-    results
-  end
-
   def size(*queues)
-    return info[:backlog] if queues.empty?
+    return Sidekiq::Stats.new.enqueued if queues.empty?
 
     Sidekiq.redis { |conn|
       conn.multi {

data/lib/sidekiq/version.rb

@@ -1,3 +1,3 @@
 module Sidekiq
-  VERSION = "2.5.4"
+  VERSION = "2.6.0"
 end

data/lib/sidekiq/web.rb

@@ -34,28 +34,16 @@ module Sidekiq
         end
       end
 
-      def info
-        @info ||= Sidekiq.info
+      def stats
+        @stats ||= Sidekiq::Stats.new
       end
 
-      def processed
-        info[:processed]
+      def scheduled_job_count
+        Sidekiq::ScheduledSet.new.size
       end
 
-      def failed
-        info[:failed]
-      end
-
-      def zcard(name)
-        Sidekiq.redis { |conn| conn.zcard(name) }
-      end
-
-      def queues
-        @queues ||= Sidekiq.info[:queues_with_sizes]
-      end
-
-      def backlog
-        info[:backlog]
+      def retry_job_count
+        Sidekiq::RetrySet.new.size
       end
 
       def retries_with_score(score)
@@ -86,6 +74,15 @@ module Sidekiq
         %{<time datetime="#{time.getutc.iso8601}">#{time}</time>}
       end
 
+      def job_params(job, score)
+        "#{score}-#{job['jid']}"
+      end
+
+      def parse_params(params)
+        score, jid = params.split("-")
+        [score.to_f, jid]
+      end
+
       def display_args(args, count=100)
         args.map { |arg| a = arg.inspect; a.size > count ? "#{a[0..count]}..." : a }.join(", ")
       end
@@ -112,12 +109,8 @@ module Sidekiq
       slim :index
     end
 
-    get "/poll" do
-      slim :poll, layout: false
-    end
-
     get "/queues" do
-      @queues = queues
+      @queues = Sidekiq::Stats.new.queues
       slim :queues
     end
 
@@ -141,20 +134,10 @@ module Sidekiq
     end
 
     post "/queues/:name/delete" do
-      Sidekiq.redis do |conn|
-        conn.lrem("queue:#{params[:name]}", 0, params[:key_val])
-      end
+      Sidekiq::Job.new(params[:key_val], params[:name]).delete
       redirect "#{root_path}queues/#{params[:name]}"
     end
 
-    get "/retries/:score" do
-      halt 404 unless params[:score]
-      @score = params[:score].to_f
-      @retries = retries_with_score(@score)
-      redirect "#{root_path}retries" if @retries.empty?
-      slim :retry
-    end
-
     get '/retries' do
       @count = (params[:count] || 25).to_i
       (@current_page, @total_size, @retries) = page("retry", params[:page], @count)
@@ -162,31 +145,22 @@ module Sidekiq
       slim :retries
     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.load_json(msg), score] }
-      slim :scheduled
-    end
-
-    post '/scheduled' do
-      halt 404 unless params[:score]
-      halt 404 unless params['delete']
-      params[:score].each do |score|
-        s = score.to_f
-        process_score('schedule', s, :delete)
-      end
-      redirect "#{root_path}scheduled"
+    get "/retries/:key" do
+      halt 404 unless params['key']
+      @retry = Sidekiq::RetrySet.new.fetch(*parse_params(params['key'])).first
+      redirect "#{root_path}retries" if @retry.nil?
+      slim :retry
     end
 
     post '/retries' do
-      halt 404 unless params[:score]
-      params[:score].each do |score|
-        s = score.to_f
+      halt 404 unless params['key']
+
+      params['key'].each do |key|
+        job = Sidekiq::RetrySet.new.fetch(*parse_params(key)).first
         if params['retry']
-          process_score('retry', s, :retry)
+          job.retry
         elsif params['delete']
-          process_score('retry', s, :delete)
+          job.delete
         end
       end
       redirect "#{root_path}retries"
@@ -198,40 +172,49 @@ module Sidekiq
     end
 
     post "/retries/all/retry" do
-      Sidekiq::RetrySet.new.each do |job|
-        process_score('retry', job.score, :retry)
-      end
+      Sidekiq::RetrySet.new.each { |job| job.retry }
       redirect "#{root_path}retries"
     end
 
-    post "/retries/:score" do
-      halt 404 unless params[:score]
-      score = params[:score].to_f
+    post "/retries/:key" do
+      halt 404 unless params['key']
+      job = Sidekiq::RetrySet.new.fetch(*parse_params(params['key'])).first
       if params['retry']
-        process_score('retry', score, :retry)
+        job.retry
       elsif params['delete']
-        process_score('retry', score, :delete)
+        job.delete
       end
       redirect "#{root_path}retries"
     end
 
-    def process_score(set, score, operation)
-      case operation
-      when :retry
-        Sidekiq.redis do |conn|
-          results = conn.zrangebyscore(set, score, score)
-          conn.zremrangebyscore(set, score, score)
-          results.map do |message|
-            msg = Sidekiq.load_json(message)
-            msg['retry_count'] = msg['retry_count'] - 1
-            conn.rpush("queue:#{msg['queue']}", Sidekiq.dump_json(msg))
-          end
-        end
-      when :delete
-        Sidekiq.redis do |conn|
-          conn.zremrangebyscore(set, score, score)
-        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.load_json(msg), score] }
+      slim :scheduled
+    end
+
+    post '/scheduled' do
+      halt 404 unless params['key']
+      halt 404 unless params['delete']
+      params['key'].each do |key|
+        Sidekiq::ScheduledSet.new.fetch(*parse_params(key)).first.delete
       end
+      redirect "#{root_path}scheduled"
+    end
+
+    get '/dashboard' do
+      @redis_info = Sidekiq.redis{ |conn| conn.info }
+      stats_history = Sidekiq::Stats::History.new((params[:days] || 30).to_i)
+      @processed_history = stats_history.processed
+      @failed_history = stats_history.failed
+      slim :dashboard
+    end
+
+    get '/dashboard/stats' do
+      stats = Sidekiq::Stats.new
+      content_type :json
+      Sidekiq.dump_json({ processed: stats.processed, failed: stats.failed })
     end
 
     def self.tabs
@@ -239,7 +222,8 @@ module Sidekiq
         "Workers"   =>'',
         "Queues"    =>'queues',
         "Retries"   =>'retries',
-        "Scheduled" =>'scheduled'
+        "Scheduled" =>'scheduled',
+        "Dashboard" =>'dashboard'
       }
     end