sidekiq 2.6.4 → 2.6.5

data/.rvmrc

@@ -1,3 +1,3 @@
 export RUBYOPT="-Ilib:test"
-rvm use 1.9.3@sidekiq --create
+rvm use 1.9.3-p327@sidekiq --create
 #rvm use jruby@sidekiq --create

data/Changes.md

@@ -1,3 +1,14 @@
+2.6.5
+-----------
+
+- Several reliability fixes for job requeueing upon termination [apinstein, #622, #624]
+- Fix typo in capistrano recipe
+- Add `retry_queue` option so retries can be given lower priority [ryanlower, #620]
+
+```ruby
+sidekiq_options queue: 'high', retry_queue: 'low'
+```
+
 2.6.4
 -----------
 

data/examples/sidekiq

@@ -0,0 +1,92 @@
+#!/bin/bash
+# sidekiq    Init script for Sidekiq
+# chkconfig: 345 100 75
+#
+# Description: Starts and Stops Sidekiq message processor for Stratus application.
+#
+# User-specified exit parameters used in this script:
+#
+# Exit Code 5 - Incorrect User ID
+# Exit Code 6 - Directory not found
+
+
+#Variable Set
+APP="stratus"
+APP_DIR="/opt/railsapps/${APP}"
+APP_CONFIG="${APP_DIR}/config"
+LOG_FILE="$APP_DIR/log/sidekiq.log"
+LOCK_FILE="$APP_DIR/${APP}-lock"
+PID_FILE="$APP_DIR/${APP}.pid"
+GEMFILE="$APP_DIR/Gemfile"
+SIDEKIQ="sidekiq"
+APP_ENV="production"
+BUNDLE="bundle"
+
+START_CMD="$BUNDLE exec $SIDEKIQ -e $APP_ENV -P $PID_FILE"
+RETVAL=0
+
+
+start() {
+
+  status
+  if [ $? -eq 1 ]; then
+
+    [ `id -u` == '0' ] || (echo "$SIDEKIQ runs as root only .."; exit 5)
+    [ -d $APP_DIR ] || (echo "$APP_DIR not found!.. Exiting"; exit 6)
+    cd $APP_DIR
+    echo "Starting $SIDEKIQ message processor .. "
+    $START_CMD >> $LOG_FILE 2>&1 &
+    RETVAL=$?
+    #Sleeping for 8 seconds for process to be precisely visible in process table - See status ()
+    sleep 8
+    [ $RETVAL -eq 0 ] && touch $LOCK_FILE
+    return $RETVAL
+  else
+    echo "$SIDEKIQ message processor is already running .. "
+  fi
+
+
+}
+
+stop() {
+
+    echo "Stopping $SIDEKIQ message processor .."
+    SIG="INT"
+    kill -$SIG `cat  $PID_FILE`
+    RETVAL=$?
+    [ $RETVAL -eq 0 ] && rm -f $LOCK_FILE
+    return $RETVAL
+}
+
+
+status() {
+
+  ps -ef | grep 'sidekiq [0-9].[0-9].[0-9]' | grep -v grep
+  return $?
+}
+
+
+case "$1" in
+    start)
+        start
+        ;;
+    stop)
+        stop
+        ;;
+    status)
+        status
+
+        if [ $? -eq 0 ]; then
+             echo "$SIDEKIQ message processor is running .."
+             RETVAL=0
+         else
+             echo "$SIDEKIQ message processor is stopped .."
+             RETVAL=1
+         fi
+        ;;
+    *)
+        echo "Usage: $0 {start|stop|status}"
+        exit 0
+        ;;
+esac
+exit $RETVAL

data/lib/sidekiq/capistrano.rb

@@ -13,21 +13,21 @@ Capistrano::Configuration.instance.load do
 
   namespace :sidekiq do
     def for_each_process(&block)
-      0.upto(fetch(:sidekiq_processes) - 1) do |process|
-        yield process == 0 ? "#{fetch(:sidekiq_pid)}" : "#{fetch(:sidekiq_pid)}-#{process}"
+      fetch(:sidekiq_processes).times do |idx|
+        yield((idx == 0 ? "#{fetch(:sidekiq_pid)}" : "#{fetch(:sidekiq_pid)}-#{idx}"), idx)
       end
     end
 
     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|
+      for_each_process do |pid_file, idx|
         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|
+      for_each_process do |pid_file, idx|
         run "if [ -d #{current_path} ] && [ -f #{pid_file} ]; then cd #{current_path} && #{fetch(:sidekiqctl_cmd)} stop #{pid_file} #{fetch :sidekiq_timeout} ; fi"
       end
     end
@@ -35,8 +35,8 @@ Capistrano::Configuration.instance.load do
     desc "Start sidekiq"
     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(:sidekiq_cmd)} -e #{rails_env} -C #{current_path}/config/sidekiq.yml -P #{pid_file} >> #{current_path}/log/sidekiq.log 2>&1 &", :pty => false
+      for_each_process do |pid_file, idx|
+        run "cd #{current_path} ; nohup #{fetch(:sidekiq_cmd)} -e #{rails_env} -C #{current_path}/config/sidekiq.yml -i #{idx} -P #{pid_file} >> #{current_path}/log/sidekiq.log 2>&1 &", :pty => false
       end
     end
 

data/lib/sidekiq/fetch.rb

@@ -71,6 +71,22 @@ module Sidekiq
       UnitOfWork.new(*work) if work
     end
 
+    def self.bulk_requeue(inprogress)
+      Sidekiq.logger.debug { "Re-queueing terminated jobs" }
+      jobs_to_requeue = {}
+      inprogress.each do |unit_of_work|
+        jobs_to_requeue[unit_of_work.queue] ||= []
+        jobs_to_requeue[unit_of_work.queue] << unit_of_work.message
+      end
+
+      Sidekiq.redis do |conn|
+        jobs_to_requeue.each do |queue, jobs|
+          conn.rpush(queue, jobs)
+        end
+      end
+      Sidekiq.logger.info("Pushed #{inprogress.size} messages back to Redis")
+    end
+
     UnitOfWork = Struct.new(:queue, :message) do
       def acknowledge
         # nothing to do
@@ -93,9 +109,7 @@ module Sidekiq
     # recreate the queue command each time we invoke Redis#blpop
     # to honor weights and avoid queue starvation.
     def queues_cmd
-      return @unique_queues.dup << Sidekiq::Fetcher::TIMEOUT if @strictly_ordered_queues
-      queues = @queues.sample(@unique_queues.size).uniq
-      queues.concat(@unique_queues - queues)
+      queues = @strictly_ordered_queues ? @unique_queues.dup : @queues.shuffle.uniq
       queues << Sidekiq::Fetcher::TIMEOUT
     end
   end

data/lib/sidekiq/manager.rb

@@ -112,23 +112,31 @@ module Sidekiq
           # They must die but their messages shall live on.
           logger.info("Still waiting for #{@busy.size} busy workers")
 
+          # Re-enqueue terminated jobs
+          # NOTE: You may notice that we may push a job back to redis before
+          # the worker thread is terminated. This is ok because Sidekiq's
+          # contract says that jobs are run AT LEAST once. Process termination
+          # is delayed until we're certain the jobs are back in Redis because
+          # it is worse to lose a job than to run it twice.
+          Sidekiq.options[:fetch].bulk_requeue(@in_progress.values)
+
+          # Clearing workers in Redis
+          # NOTE: we do this before terminating worker threads because the
+          # process will likely receive a hard shutdown soon anyway, which
+          # means the threads will killed.
+          logger.debug { "Clearing workers in redis" }
           Sidekiq.redis do |conn|
-            logger.debug { "Clearing workers in redis" }
             workers = conn.smembers('workers')
-            workers.each do |name|
-              conn.srem('workers', name) if name =~ /:#{process_id}-/
+            workers_to_remove = workers.select do |worker_name|
+              worker_name =~ /:#{process_id}-/
             end
+            conn.srem('workers', workers_to_remove)
+          end
 
-            @busy.each do |processor|
-              # processor is an actor proxy and we can't call any methods
-              # that would go to the actor (since it's busy).  Instead
-              # we'll use the object_id to track the worker's data here.
-              processor.terminate if processor.alive?
-              msg, queue = @in_progress[processor.object_id]
-              conn.lpush("queue:#{queue}", msg)
-            end
+          logger.debug { "Terminating worker threads" }
+          @busy.each do |processor|
+            processor.terminate if processor.alive?
           end
-          logger.info("Pushed #{@busy.size} messages back to Redis")
 
           after(0) { signal(:shutdown) }
         end

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

@@ -51,7 +51,11 @@ module Sidekiq
           raise e unless msg['retry']
           max_retry_attempts = retry_attempts_from(msg['retry'], DEFAULT_MAX_RETRY_ATTEMPTS)
 
-          msg['queue'] = queue
+          msg['queue'] = if msg['retry_queue']
+            msg['retry_queue']
+          else
+            queue
+          end
           msg['error_message'] = e.message
           msg['error_class'] = e.class.name
           count = if msg['retry_count']

data/lib/sidekiq/version.rb

@@ -1,3 +1,3 @@
 module Sidekiq
-  VERSION = "2.6.4"
+  VERSION = "2.6.5"
 end

data/test/test_fetch.rb

@@ -5,7 +5,7 @@ class TestFetcher < MiniTest::Unit::TestCase
 
   def setup
     Sidekiq.redis do |conn|
-      conn.del('queue:basic')
+      conn.flushdb
       conn.rpush('queue:basic', 'msg')
     end
   end
@@ -28,4 +28,15 @@ class TestFetcher < MiniTest::Unit::TestCase
     cmd = fetch.queues_cmd
     assert_equal cmd, ['queue:basic', 'queue:bar', 1]
   end
+
+  def test_basic_fetch_bulk_requeue
+    q1 = Sidekiq::Queue.new('foo')
+    q2 = Sidekiq::Queue.new('bar')
+    assert_equal 0, q1.size
+    assert_equal 0, q2.size
+    uow = Sidekiq::BasicFetch::UnitOfWork
+    Sidekiq::BasicFetch.bulk_requeue([uow.new('queue:foo', 'bob'), uow.new('queue:foo', 'bar'), uow.new('queue:bar', 'widget')])
+    assert_equal 2, q1.size
+    assert_equal 1, q2.size
+  end
 end

data/test/test_retry.rb

@@ -86,6 +86,24 @@ class TestRetry < MiniTest::Unit::TestCase
       @redis.verify
     end
 
+    it 'allows a retry queue' do
+      @redis.expect :zadd, 1, ['retry', String, String]
+      msg = { 'class' => 'Bob', 'args' => [1,2,'foo'], 'retry' => true, 'retry_queue' => 'retry' }
+      handler = Sidekiq::Middleware::Server::RetryJobs.new
+      assert_raises RuntimeError do
+        handler.call('', msg, 'default') do
+          raise "kerblammo!"
+        end
+      end
+      assert_equal 'retry', msg["queue"]
+      assert_equal 'kerblammo!', msg["error_message"]
+      assert_equal 'RuntimeError', msg["error_class"]
+      assert_equal 0, msg["retry_count"]
+      refute msg["error_backtrace"]
+      assert msg["failed_at"]
+      @redis.verify
+    end
+
     it 'handles a recurring failed message' do
       @redis.expect :zadd, 1, ['retry', String, String]
       now = Time.now.utc

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq
 version: !ruby/object:Gem::Version
-  version: 2.6.4
+  version: 2.6.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-08 00:00:00.000000000 Z
+date: 2013-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -219,6 +219,7 @@ files:
 - examples/monitrc.conf
 - examples/por.rb
 - examples/scheduling.rb
+- examples/sidekiq
 - examples/sinkiq.rb
 - examples/web-ui.png
 - lib/sidekiq.rb