freekiqs 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 059f622d989114ee072fabcef7902ca2a6a83e82
-  data.tar.gz: 73388b860f4c623fa692799e8ac0531d2f2c5265
+  metadata.gz: 0a7ee677e8d100c7405dc91f9d4c341d7f7a8986
+  data.tar.gz: 0281092a960af50ca75ed3b03370bd7a86b1ae17
 SHA512:
-  metadata.gz: 12f4de057c24bc156311010179d37ab080f2c23efab81f9ea0743c249e4eaa477d4d4cf328d289bc60325d9b7f7cc59967454038801129c984bc1ae4dfa1d523
-  data.tar.gz: 4d6649df9cbee156a1dbcffd51823d07b0df17ed45ce7f10e76a5a228b5d0fdcf358e90478ac8ce3336c49ef1184d019378e2ae20ca8624539706fb8d6251a58
+  metadata.gz: 35984aad9ab4d0fec1d33f07469ba0f82ff83a5b3cdeaecb39f1bbdb42f56ec9566df45c8735970034f99294919790481983047141a89750118845d46d7a3ad9
+  data.tar.gz: d932c98cefbdcc672d00c2e85ae16a86b6b4b70cb719403a462b8981dacd22fca4f0cbaa7cf90735879cbd8cbc8efe3a5f221eaa9d8cd033962e0efd841dbaf4

data/README.md

@@ -50,6 +50,42 @@ Example:
   end
 ```
 
+An array of specific errors to be freekiq'd can be defined in the `freekiq_for` option.
+
+Example:
+``` ruby
+  class MyWorker
+    include Sidekiq::Worker
+    sidekiq_options freekiqs: 1, freekiq_for: ['MyError']
+      #
+    def perform(param)
+      ...
+    end
+  end
+```
+In this case, if MyWorker fails with a MyError it will get 1 freekiq.
+All other errors thrown by this worker will get no freekiqs.
+
+
+If a `freekiq_for` contains a class name as a constant, any exception is that class
+*or a subclass* of that class will get freekiq'd.
+
+Example:
+``` ruby
+  class SubMyError < MyError; end
+
+  class MyWorker
+    include Sidekiq::Worker
+    sidekiq_options freekiqs: 1, freekiq_for: [MyError]
+      #
+    def perform(param)
+      ...
+    end
+  end
+```
+If MyWorker throws a SubMyError or MyError, it will get freekiq'd.
+
+
 ## Overview
 
 Up to the configured number of "freekiqs", catch exceptions thrown

data/freekiqs.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |gem|
   gem.name                  = 'freekiqs'
-  gem.version               = '4.0.0'
+  gem.version               = '4.1.0'
   gem.authors               = ['Rob Lewis']
   gem.email                 = ['rob@bookbub.com']
   gem.summary               = 'Sidekiq middleware extending RetryJobs to allow silient errors.'

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

@@ -12,12 +12,13 @@ module Sidekiq
 
         def initialize(opts={})
           @default_freekiqs = opts[:freekiqs]
+          @default_freekiq_for = opts[:freekiq_for]
         end
 
         def call(worker, msg, queue)
           yield
         rescue => ex
-          freekiqs = get_freekiqs_if_enabled(worker, msg)
+          freekiqs = get_freekiqs_if_enabled(worker, msg, ex)
           if freekiqs
             if msg['retry_count'].nil? || msg['retry_count'] < freekiqs-1
               begin
@@ -34,20 +35,49 @@ module Sidekiq
           raise ex
         end
 
-        def get_freekiqs_if_enabled(worker, msg)
+        def get_freekiqs_if_enabled(worker, msg, ex)
           freekiqs = nil
           if msg['retry']
             if worker.class.get_sidekiq_options['freekiqs'] != false
+              errors = get_freekiq_errors(worker)
               if worker.class.get_sidekiq_options['freekiqs']
-                freekiqs = worker.class.get_sidekiq_options['freekiqs'].to_i
+                freekiqs = get_freekiqs(worker.class.get_sidekiq_options['freekiqs'], ex, errors)
               elsif @default_freekiqs
-                freekiqs = @default_freekiqs.to_i
+                freekiqs = get_freekiqs(@default_freekiqs, ex, errors)
               end
             end
           end
           freekiqs
         end
 
+        def get_freekiq_errors(worker)
+          if worker.class.get_sidekiq_options['freekiq_for']
+            worker.class.get_sidekiq_options['freekiq_for']
+          elsif @default_freekiq_for
+            @default_freekiq_for
+          end
+        end
+
+        def get_freekiqs(freekiqs, ex, errors)
+          if errors
+            if error_whitelisted?(ex, errors)
+              freekiqs.to_i
+            end
+          else
+            freekiqs.to_i
+          end
+        end
+
+        def error_whitelisted?(ex, errors)
+          errors.any? do |error|
+            if error.respond_to?(:name) && error.is_a?(Class)
+              ex.class == error || ex.class < error
+            else
+              ex.class.name == error
+            end
+          end
+        end
+
         def self.callback
           @@callback
         end

data/spec/freekiqs_spec.rb

@@ -2,6 +2,52 @@ require 'spec_helper'
 require 'sidekiq/cli'
 require 'sidekiq/middleware/server/retry_jobs'
 
+shared_examples_for 'it should have 2 freekiqs for an ArgumentError' do
+  it 'throws Freekiq exception for specified number of free kiqs' do
+    expect {
+      handler.invoke(worker, job, 'default') do
+        raise ArgumentError, 'overlooked'
+      end
+    }.to raise_error(Sidekiq::FreekiqException, 'overlooked')
+    expect(job['retry_count']).to eq(0)
+    expect(job['error_class']).to eq('Sidekiq::FreekiqException')
+    expect(job['error_message']).to eq('overlooked')
+    expect {
+      handler.invoke(worker, job, 'default') do
+        raise ArgumentError, 'overlooked'
+      end
+    }.to raise_error(Sidekiq::FreekiqException, 'overlooked')
+    expect(job['retry_count']).to eq(1)
+    expect(job['error_class']).to eq('Sidekiq::FreekiqException')
+    expect(job['error_message']).to eq('overlooked')
+    expect {
+      handler.invoke(worker, job, 'default') do
+        raise ArgumentError, 'not overlooked'
+      end
+    }.to raise_error(ArgumentError, 'not overlooked')
+    expect(job['retry_count']).to eq(2)
+    expect(job['error_class']).to eq('ArgumentError')
+    expect(job['error_message']).to eq('not overlooked')
+    expect(Sidekiq::RetrySet.new.size).to eq(3)
+    expect(Sidekiq::DeadSet.new.size).to eq(0)
+  end
+end
+
+shared_examples_for 'it should have 0 freekiqs for an ArgumentError' do
+  it 'raises the original error' do
+    expect {
+      handler.invoke(worker, job, 'default') do
+        raise ArgumentError, 'not overlooked'
+      end
+    }.to raise_error(ArgumentError, 'not overlooked')
+    expect(job['retry_count']).to eq(0)
+    expect(job['error_class']).to eq('ArgumentError')
+    expect(job['error_message']).to eq('not overlooked')
+    expect(Sidekiq::RetrySet.new.size).to eq(1)
+    expect(Sidekiq::DeadSet.new.size).to eq(0)
+  end
+end
+
 describe Sidekiq::Middleware::Server::Freekiqs do
   class DummyWorkerPlain
     include Sidekiq::Worker
@@ -10,10 +56,6 @@ describe Sidekiq::Middleware::Server::Freekiqs do
     include Sidekiq::Worker
     sidekiq_options freekiqs: 2
   end
-  class DummyWorkerWithFreekiqsDisabled
-    include Sidekiq::Worker
-    sidekiq_options freekiqs: false
-  end
 
   def build_handler_chain(freekiq_options={}, retry_options={})
     Sidekiq::Middleware::Chain.new do |chain|
@@ -37,7 +79,6 @@ describe Sidekiq::Middleware::Server::Freekiqs do
 
   let(:worker_plain)                  { DummyWorkerPlain.new }
   let(:worker_with_freekiqs_enabled)  { DummyWorkerWithFreekiqsEnabled.new }
-  let(:worker_with_freekiqs_disabled) { DummyWorkerWithFreekiqsDisabled.new }
 
   it 'requires RetryJobs to update retry_count' do
     handler = Sidekiq::Middleware::Server::RetryJobs.new
@@ -57,42 +98,30 @@ describe Sidekiq::Middleware::Server::Freekiqs do
     expect(job['retry_count']).to eq(1)
   end
 
-  it 'throws Freekiq exception for specified number of free kiqs' do
+  it 'should execute a defined callback' do
+    Sidekiq::Middleware::Server::Freekiqs::callback = ->(worker, msg, queue) do
+      return true
+    end
+
     handler = build_handler_chain
     worker = worker_with_freekiqs_enabled
     job = build_job
 
+    expect(Sidekiq::Middleware::Server::Freekiqs::callback).to receive(:call)
     expect {
       handler.invoke(worker, job, 'default') do
         raise ArgumentError, 'overlooked'
       end
     }.to raise_error(Sidekiq::FreekiqException, 'overlooked')
-    expect(job['retry_count']).to eq(0)
-    expect(job['error_class']).to eq('Sidekiq::FreekiqException')
-    expect(job['error_message']).to eq('overlooked')
-    expect {
-      handler.invoke(worker, job, 'default') do
-        raise ArgumentError, 'overlooked'
-      end
-    }.to raise_error(Sidekiq::FreekiqException, 'overlooked')
-    expect(job['retry_count']).to eq(1)
-    expect(job['error_class']).to eq('Sidekiq::FreekiqException')
-    expect(job['error_message']).to eq('overlooked')
-    expect {
-      handler.invoke(worker, job, 'default') do
-        raise ArgumentError, 'not overlooked'
-      end
-    }.to raise_error(ArgumentError, 'not overlooked')
-    expect(job['retry_count']).to eq(2)
-    expect(job['error_class']).to eq('ArgumentError')
-    expect(job['error_message']).to eq('not overlooked')
-    expect(Sidekiq::RetrySet.new.size).to eq(3)
-    expect(Sidekiq::DeadSet.new.size).to eq(0)
   end
 
-  it 'allows a freekiqs option in initializer' do
-    handler = build_handler_chain(freekiqs: 1)
-    worker = worker_plain
+  it 'should still raise FreekiqException if the callback fails' do
+    Sidekiq::Middleware::Server::Freekiqs::callback = ->(worker, msg, queue) do
+      raise 'callback error'
+    end
+
+    handler = build_handler_chain
+    worker = worker_with_freekiqs_enabled
     job = build_job
 
     expect {
@@ -100,101 +129,201 @@ describe Sidekiq::Middleware::Server::Freekiqs do
         raise ArgumentError, 'overlooked'
       end
     }.to raise_error(Sidekiq::FreekiqException, 'overlooked')
-    expect(job['retry_count']).to eq(0)
-    expect(job['error_class']).to eq('Sidekiq::FreekiqException')
-    expect(job['error_message']).to eq('overlooked')
-    expect {
-      handler.invoke(worker, job, 'default') do
-        raise ArgumentError, 'not overlooked'
+  end
+
+  describe 'with nothing explicitly enabled' do
+    it_behaves_like 'it should have 0 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+        end.new
       end
-    }.to raise_error(ArgumentError, 'not overlooked')
-    expect(job['retry_count']).to eq(1)
-    expect(job['error_class']).to eq('ArgumentError')
-    expect(job['error_message']).to eq('not overlooked')
-    expect(Sidekiq::RetrySet.new.size).to eq(2)
-    expect(Sidekiq::DeadSet.new.size).to eq(0)
+    end
   end
 
-  it 'allows explicitly disabling freekiqs' do
-    handler = build_handler_chain(freekiqs: 3)
-    worker = worker_with_freekiqs_disabled
-    job = build_job
+  describe 'with freekiqs explicitly disabled' do
+    it_behaves_like 'it should have 0 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain(freekiqs: 3) }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+          sidekiq_options freekiqs: false
+        end.new
+      end
+    end
+  end
 
-    expect {
-      handler.invoke(worker, job, 'default') do
-        raise ArgumentError, 'not overlooked'
+  describe 'with 2 freekiqs in the initializer' do
+    it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain(freekiqs: 2) }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+        end.new
       end
-    }.to raise_error(ArgumentError, 'not overlooked')
-    expect(job['retry_count']).to eq(0)
-    expect(job['error_class']).to eq('ArgumentError')
-    expect(job['error_message']).to eq('not overlooked')
-    expect(Sidekiq::RetrySet.new.size).to eq(1)
-    expect(Sidekiq::DeadSet.new.size).to eq(0)
+    end
   end
 
-  it 'does nothing if not explicitly enabled' do
-    handler = build_handler_chain
-    worker = worker_plain
-    job = build_job
+  describe 'with 2 freekiqs in the worker' do
+    it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+          sidekiq_options freekiqs: 2
+        end.new
+      end
+    end
+  end
 
-    expect {
-      handler.invoke(worker, job, 'default') do
-        raise ArgumentError, 'not overlooked'
+  describe 'with freekiq_for ArgumentError and 2 freekiqs in worker' do
+    it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+          sidekiq_options freekiqs: 2, freekiq_for: [ArgumentError]
+        end.new
       end
-    }.to raise_error(ArgumentError, 'not overlooked')
-    expect(job['retry_count']).to eq(0)
-    expect(job['error_class']).to eq('ArgumentError')
-    expect(job['error_message']).to eq('not overlooked')
+    end
   end
 
-  it 'does nothing if retries disabled' do
-    handler = build_handler_chain
-    worker = worker_with_freekiqs_enabled
-    job = build_job('retry' => false)
+  describe 'with freekiq_for ArgumentError in worker and no freekiqs' do
+    it_behaves_like 'it should have 0 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+          class NonArgumentError < StandardError; end
+          sidekiq_options freekiqs: 2, freekiq_for: [NonArgumentError]
+        end.new
+      end
+    end
+  end
 
-    expect {
-      handler.invoke(worker, job, 'default') do
-        raise ArgumentError, 'not overlooked'
+  describe 'with freekiq_for ArgumentError in worker and 2 freekiqs in initializer' do
+    it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain(freekiqs: 2) }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+          sidekiq_options freekiq_for: [ArgumentError]
+        end.new
       end
-    }.to raise_error(ArgumentError, 'not overlooked')
-    expect(job['retry_count']).to be_nil
-    expect(job['error_class']).to be_nil
-    expect(job['error_message']).to be_nil
-    expect(job['error_message']).to be_nil
-    expect(Sidekiq::RetrySet.new.size).to eq(0)
-    expect(Sidekiq::DeadSet.new.size).to eq(0)
+    end
   end
 
-  it 'should execute a defined callback' do
-    Sidekiq::Middleware::Server::Freekiqs::callback = ->(worker, msg, queue) do
-      return true
+  describe 'with freekiq_for ArgumentError in initializer and 2 freekiqs in initializer' do
+    it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain(freekiqs: 2, freekiq_for: [ArgumentError]) }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+        end.new
+      end
     end
+  end
 
-    handler = build_handler_chain
-    worker = worker_with_freekiqs_enabled
-    job = build_job
+  describe 'with freekiq_for ArgumentError in initializer and 2 freekiqs in worker' do
+    it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain(freekiq_for: [ArgumentError]) }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+          sidekiq_options freekiqs: 2
+        end.new
+      end
+    end
+  end
 
-    expect(Sidekiq::Middleware::Server::Freekiqs::callback).to receive(:call)
-    expect {
-      handler.invoke(worker, job, 'default') do
-        raise ArgumentError, 'overlooked'
+  describe 'with freekiq_for NonArgumentError in worker and 2 freekiqs in worker' do
+    it_behaves_like 'it should have 0 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+          class NonArgumentError < StandardError; end
+          sidekiq_options freekiqs: 2, freekiq_for: [NonArgumentError]
+        end.new
       end
-    }.to raise_error(Sidekiq::FreekiqException, 'overlooked')
+    end
   end
 
-  it 'should still raise FreekiqException if the callback fails' do
-    Sidekiq::Middleware::Server::Freekiqs::callback = ->(worker, msg, queue) do
-      raise 'callback error'
+  describe 'with freekiq_for NonArgumentError in initializer and 2 freekiqs in worker' do
+    it_behaves_like 'it should have 0 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain(freekiq_for: [NonArgumentError]) }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+          class NonArgumentError < StandardError; end
+          sidekiq_options freekiqs: 2
+        end.new
+      end
     end
+  end
 
-    handler = build_handler_chain
-    worker = worker_with_freekiqs_enabled
-    job = build_job
+  describe 'with freekiq_for NonArgumentError in initializer and freekiq for ArgumentError in worker' do
+    it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain(freekiq_for: [NonArgumentError]) }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+          sidekiq_options freekiqs: 2, freekiq_for: [ArgumentError]
+        end.new
+      end
+    end
+  end
 
-    expect {
-      handler.invoke(worker, job, 'default') do
-        raise ArgumentError, 'overlooked'
+  describe 'with freekiq_for ArgumentError in initializer and freekiq for NonArgumentError in worker' do
+    it_behaves_like 'it should have 0 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain(freekiq_for: [ArgumentError]) }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+          class NonArgumentError < StandardError; end
+          sidekiq_options freekiqs: 2, freekiq_for: [NonArgumentError]
+        end.new
       end
-    }.to raise_error(Sidekiq::FreekiqException, 'overlooked')
+    end
+  end
+
+  describe 'with freekiq_for ArgumentError as a string' do
+    it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+          sidekiq_options freekiqs: 2, freekiq_for: ['ArgumentError']
+        end.new
+      end
+    end
+  end
+
+  describe 'with freekiq_for the super class of ArgumentError' do
+    it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+      let (:handler) { build_handler_chain }
+      let (:job) { build_job }
+      let (:worker) do
+        Class.new do
+          include Sidekiq::Worker
+          sidekiq_options freekiqs: 2, freekiq_for: [ArgumentError.superclass]
+        end.new
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: freekiqs
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.1.0
 platform: ruby
 authors:
 - Rob Lewis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-21 00:00:00.000000000 Z
+date: 2016-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq