freekiqs 4.1.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0a7ee677e8d100c7405dc91f9d4c341d7f7a8986
-  data.tar.gz: 0281092a960af50ca75ed3b03370bd7a86b1ae17
+  metadata.gz: 44594d919a76aa86c249eb5fe88a9af8f95ba253
+  data.tar.gz: b788548a59466399a3e58ed192cd4344b6d37df4
 SHA512:
-  metadata.gz: 35984aad9ab4d0fec1d33f07469ba0f82ff83a5b3cdeaecb39f1bbdb42f56ec9566df45c8735970034f99294919790481983047141a89750118845d46d7a3ad9
-  data.tar.gz: d932c98cefbdcc672d00c2e85ae16a86b6b4b70cb719403a462b8981dacd22fca4f0cbaa7cf90735879cbd8cbc8efe3a5f221eaa9d8cd033962e0efd841dbaf4
+  metadata.gz: fbeab3d19cea8a86adf9e8a47e9cfab8e3739da4d53157fe82418bd838550736c77a414e81b505ccb7dba7663292058bc63b133fabebc2f4048dda0f8ed79f41
+  data.tar.gz: f0e33f9fc4851bfbfb1f4ff1b6f09cdc14dd4ba282e413b8c8e3c69366a4006f63af5edc63eda77b970660d9baa91d17da57468b06f9c5820a625bdb68ebdff0

data/.gitignore

@@ -3,3 +3,6 @@ gemfiles/*.lock
 Gemfile.lock
 .ruby-version
 pkg
+/.bundle
+/.vagrant
+/ubuntu-*-console.log

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/Gemfile

@@ -5,5 +5,5 @@ gemspec
 gem 'rake'
 
 group :test do
-  gem 'rspec', '~> 3.1'
+  gem 'rspec', '~> 3.6'
 end

data/README.md

@@ -3,13 +3,13 @@
 Sidekiq middleware that allows capturing exceptions thrown
 by failed jobs and wrapping them with a `FreekiqException` exception class
 that can be filtered by monitoring tools such as New Relic and
-Honeybadger.
+Rollbar.
 
 Configuration example (in config/initializers/sidekiq.rb):
 ``` ruby
   Sidekiq.configure_server do |config|
     config.server_middleware do |chain|
-      chain.insert_after Sidekiq::Middleware::Server::RetryJobs, Sidekiq::Middleware::Server::Freekiqs
+      chain.add Sidekiq::Middleware::Server::Freekiqs
     end
   end
 ```
@@ -19,7 +19,7 @@ Worker example:
   class MyWorker
     include Sidekiq::Worker
     sidekiq_options freekiqs: 3
-      #
+
     def perform(param)
       ...
     end
@@ -35,7 +35,7 @@ Example:
 ``` ruby
   Sidekiq.configure_server do |config|
     config.server_middleware do |chain|
-      chain.insert_after Sidekiq::Middleware::Server::RetryJobs, Sidekiq::Middleware::Server::Freekiqs, freekiqs: 3
+      chain.add Sidekiq::Middleware::Server::Freekiqs, freekiqs: 3
     end
   end
 ```
@@ -44,6 +44,17 @@ A callback can be fired when a freekiq happens.
 This can be useful for tracking or logging freekiqs separately from the sidekiq logs.
 
 Example:
+``` ruby
+  Sidekiq.configure_server do |config|
+    config.server_middleware do |chain|
+      chain.add Sidekiq::Middleware::Server::Freekiqs, callback: ->(worker, msg, queue) do
+        Librato::Metrics.submit freekiqs: { value: 1, source: worker.class.name }
+      end
+    end
+  end
+```
+
+Or callback can be set outside middleware configuration:
 ``` ruby
   Sidekiq::Middleware::Server::Freekiqs::callback = ->(worker, msg, queue) do
     Librato::Metrics.submit freekiqs: { value: 1, source: worker.class.name }
@@ -57,7 +68,7 @@ Example:
   class MyWorker
     include Sidekiq::Worker
     sidekiq_options freekiqs: 1, freekiq_for: ['MyError']
-      #
+
     def perform(param)
       ...
     end
@@ -67,8 +78,8 @@ 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.
+If a `freekiq_for` contains a class name as a constant, any exception of that class
+type *or a subclass* of that class will get freekiq'd.
 
 Example:
 ``` ruby
@@ -77,7 +88,7 @@ Example:
   class MyWorker
     include Sidekiq::Worker
     sidekiq_options freekiqs: 1, freekiq_for: [MyError]
-      #
+
     def perform(param)
       ...
     end
@@ -85,6 +96,10 @@ Example:
 ```
 If MyWorker throws a SubMyError or MyError, it will get freekiq'd.
 
+## Sidekiq Versions
+
+Version 5 of this gem only works with Sidekiq 5 and higher. If you are using
+an older version of Sidekiq, you'll need to use version [4.1.0](https://github.com/BookBub/freekiqs/tree/v4.1.0).
 
 ## Overview
 
@@ -95,7 +110,8 @@ tools. If job fails more times than configured "freekiqs", thrown
 exception will not be wrapped. That should result in normal operation
 and the exception showing up in monitoring tools.
 
-Implementation Details:
+#### Implementation Details
+
 This relies on Sidekiq's built-in retry handling. Specifically, its
 `retry_count` value. When a job first fails, its `retry_count` value
 is nil (because it hasn't actually been retried yet). That exception,

data/Vagrantfile

@@ -0,0 +1,31 @@
+Vagrant.configure(2) do |config|
+  config.vm.box = 'ubuntu/xenial64'
+
+  config.vm.network :private_network, ip: '192.168.33.69'
+  config.vm.network :forwarded_port, host: 2202, guest: 22, id: 'ssh', auto_correct: true
+
+  config.vm.synced_folder '.', '/vagrant', type: 'nfs'
+
+  config.vm.provider :virtualbox do |vb|
+    vb.name = 'freekiqs'
+    vb.memory = 2048
+    vb.cpus = 2
+  end
+
+  config.vm.provision :shell, inline: <<-SCRIPT
+    apt-get update
+    apt-get upgrade
+    apt-get install -y git gnupg2 redis-server
+  SCRIPT
+
+  config.vm.provision :shell, privileged: false, inline: <<-SCRIPT
+    gpg --keyserver hkp://pool.sks-keyservers.net --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3
+    curl -sSL https://get.rvm.io | bash -s stable --quiet-curl --with-gems=bundler
+    source "$HOME/.rvm/scripts/rvm"
+    rvm --quiet-curl install 2.3.4
+    rvm use 2.3.4 --default
+    cd /vagrant
+    bundle install --full-index -j4
+    echo 'cd /vagrant' >> ~/.bash_profile
+  SCRIPT
+end

data/circle.yml

@@ -1,5 +1,5 @@
 machine:
   ruby:
-    version: 2.3.0
+    version: 2.3.4
   services:
     - redis

data/freekiqs.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |gem|
   gem.name                  = 'freekiqs'
-  gem.version               = '4.1.0'
+  gem.version               = '5.0.0'
   gem.authors               = ['Rob Lewis']
   gem.email                 = ['rob@bookbub.com']
   gem.summary               = 'Sidekiq middleware extending RetryJobs to allow silient errors.'
@@ -14,8 +14,8 @@ Gem::Specification.new do |gem|
   gem.files                 = `git ls-files`.split("\n")
   gem.test_files            = `git ls-files -- spec/*`.split("\n")
   gem.require_paths         = ['lib']
-  gem.required_ruby_version = '>= 1.9.3'
+  gem.required_ruby_version = '>= 2.2.2'
 
-  gem.add_dependency             'sidekiq', '>= 4.0.0', '< 5.0.0'
-  gem.add_development_dependency 'rspec', '>= 2.14.1'
+  gem.add_dependency             'sidekiq', '>= 5.0.0'
+  gem.add_development_dependency 'rspec', '>= 3.6.0'
 end

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

@@ -13,12 +13,13 @@ module Sidekiq
         def initialize(opts={})
           @default_freekiqs = opts[:freekiqs]
           @default_freekiq_for = opts[:freekiq_for]
+          @@callback = opts[:callback]
         end
 
         def call(worker, msg, queue)
           yield
         rescue => ex
-          freekiqs = get_freekiqs_if_enabled(worker, msg, ex)
+          freekiqs = get_freekiqs_if_enabled(worker, ex)
           if freekiqs
             if msg['retry_count'].nil? || msg['retry_count'] < freekiqs-1
               begin
@@ -29,15 +30,15 @@ module Sidekiq
                 raise FreekiqException, ex.message
               end
             else
-              Sidekiq.logger.info { "Out of free kiqs for #{msg['class']} job #{msg['jid']}" }
+              Sidekiq.logger.info { "Out of freekiqs for #{msg['class']} job #{msg['jid']}" }
             end
           end
           raise ex
         end
 
-        def get_freekiqs_if_enabled(worker, msg, ex)
+        def get_freekiqs_if_enabled(worker, ex)
           freekiqs = nil
-          if msg['retry']
+          if worker.class.get_sidekiq_options['retry']
             if worker.class.get_sidekiq_options['freekiqs'] != false
               errors = get_freekiq_errors(worker)
               if worker.class.get_sidekiq_options['freekiqs']

data/spec/freekiqs_spec.rb

@@ -1,329 +1,248 @@
-require 'spec_helper'
-require 'sidekiq/cli'
-require 'sidekiq/middleware/server/retry_jobs'
+require 'sidekiq/processor'
 
-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
+RSpec.describe Sidekiq::Middleware::Server::Freekiqs do
+  class NonArgumentError < StandardError; 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)
+  def build_job_hash(worker_class, args=[])
+    {'class' => worker_class, 'args' => args}
   end
-end
 
-describe Sidekiq::Middleware::Server::Freekiqs do
-  class DummyWorkerPlain
-    include Sidekiq::Worker
+  def fetch_retry_job
+    retry_set = Sidekiq::RetrySet.new
+    retry_job = retry_set.first
+    retry_set.clear
+    retry_job
   end
-  class DummyWorkerWithFreekiqsEnabled
-    include Sidekiq::Worker
-    sidekiq_options freekiqs: 2
+
+  def process_job(job_hash)
+    mgr = instance_double('Manager', options: {:queues => ['default']})
+    processor = ::Sidekiq::Processor.new(mgr)
+    job_msg = Sidekiq.dump_json(job_hash)
+    processor.process(Sidekiq::BasicFetch::UnitOfWork.new('queue:default', job_msg))
   end
 
-  def build_handler_chain(freekiq_options={}, retry_options={})
-    Sidekiq::Middleware::Chain.new do |chain|
-      chain.add Sidekiq::Middleware::Server::RetryJobs, retry_options
-      chain.add Sidekiq::Middleware::Server::Freekiqs, freekiq_options
+  def initialize_middleware(middleware_opts={})
+    Sidekiq.server_middleware do |chain|
+      chain.add Sidekiq::Middleware::Server::Freekiqs, middleware_opts
     end
   end
 
-  def build_job(options={})
-    {'class' => 'FreekiqDummyWorker', 'args' => [], 'retry' => true}.merge(options)
+  def initialize_worker_class(sidekiq_opts=nil)
+    worker_class_name = :TestDummyWorker
+    Object.send(:remove_const, worker_class_name) if Object.const_defined?(worker_class_name)
+    klass = Class.new do
+      include Sidekiq::Worker
+      sidekiq_options sidekiq_opts if sidekiq_opts
+      def perform
+        raise ArgumentError, 'Oops'
+      end
+    end
+    Object.const_set(worker_class_name, klass)
   end
 
   def cleanup_redis
-    Sidekiq::RetrySet.new.select{|job| job.klass == 'FreekiqDummyWorker'}.each(&:delete)
-    Sidekiq::DeadSet.new.clear
+    Sidekiq.redis {|c| c.flushdb }
+  end
+
+  shared_examples_for 'it should have 2 freekiqs for an ArgumentError' do
+    it 'throws Freekiq exception for specified number of freekiqs' do
+      args ||= []
+      expect {
+        process_job(build_job_hash(worker_class, args))
+      }.to raise_error(Sidekiq::FreekiqException, 'Oops')
+      expect(Sidekiq::RetrySet.new.size).to eq(1)
+      retry_job = fetch_retry_job
+      expect(retry_job['retry_count']).to eq(0)
+      expect(retry_job['error_class']).to eq('Sidekiq::FreekiqException')
+      expect(retry_job['error_message']).to eq('Oops')
+
+      expect {
+        process_job(retry_job.item)
+      }.to raise_error(Sidekiq::FreekiqException, 'Oops')
+      expect(Sidekiq::RetrySet.new.size).to eq(1)
+      retry_job = fetch_retry_job
+      expect(retry_job['retry_count']).to eq(1)
+      expect(retry_job['error_class']).to eq('Sidekiq::FreekiqException')
+      expect(retry_job['error_message']).to eq('Oops')
+
+      expect {
+        process_job(retry_job.item)
+      }.to raise_error(ArgumentError, 'Oops')
+      expect(Sidekiq::RetrySet.new.size).to eq(1)
+      retry_job = fetch_retry_job
+      expect(retry_job['retry_count']).to eq(2)
+      expect(retry_job['error_class']).to eq('ArgumentError')
+      expect(retry_job['error_message']).to eq('Oops')
+    end
+  end
+
+  shared_examples_for 'it should have 0 freekiqs for an ArgumentError' do
+    it 'raises the original error' do
+      args ||= []
+      expect {
+        process_job(build_job_hash(worker_class, args))
+      }.to raise_error(ArgumentError, 'Oops')
+      expect(Sidekiq::RetrySet.new.size).to eq(1)
+      retry_job = fetch_retry_job
+      expect(retry_job['retry_count']).to eq(0)
+      expect(retry_job['error_class']).to eq('ArgumentError')
+      expect(retry_job['error_message']).to eq('Oops')
+    end
+  end
+
+  shared_examples_for 'it should only raise exception for an ArgumentError' do
+    it 'raises the original error' do
+      args ||= []
+      expect {
+        process_job(build_job_hash(worker_class, args))
+      }.to raise_error(ArgumentError, 'Oops')
+      expect(Sidekiq::RetrySet.new.size).to eq(0)
+      # Note: Sidekiq doesn't send job to morgue when retries are diabled
+      expect(Sidekiq::DeadSet.new.size).to eq(0)
+    end
   end
 
   before(:each) do
     cleanup_redis
   end
 
-  let(:worker_plain)                  { DummyWorkerPlain.new }
-  let(:worker_with_freekiqs_enabled)  { DummyWorkerWithFreekiqsEnabled.new }
+  context 'with default middleware config' do
+    before(:each) do
+      initialize_middleware
+    end
 
-  it 'requires RetryJobs to update retry_count' do
-    handler = Sidekiq::Middleware::Server::RetryJobs.new
-    worker = worker_plain
-    job = build_job
-    expect {
-      handler.call(worker, job, 'default') do
-        raise 'Oops'
+    describe 'with nothing explicitly enabled' do
+      it_behaves_like 'it should have 0 freekiqs for an ArgumentError' do
+        let!(:worker_class) { initialize_worker_class }
       end
-    }.to raise_error(RuntimeError)
-    expect(job['retry_count']).to eq(0)
-    expect {
-      handler.call(worker, job, 'default') do
-        raise 'Oops'
-      end
-    }.to raise_error(RuntimeError)
-    expect(job['retry_count']).to eq(1)
-  end
-
-  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'
+    describe 'with freekiqs explicitly disabled' do
+      it_behaves_like 'it should have 0 freekiqs for an ArgumentError' do
+        let!(:worker_class) { initialize_worker_class(freekiqs: false) }
       end
-    }.to raise_error(Sidekiq::FreekiqException, 'overlooked')
-  end
-
-  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 {
-      handler.invoke(worker, job, 'default') do
-        raise ArgumentError, 'overlooked'
+    describe 'with 2 freekiqs in the worker' do
+      it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+        let!(:worker_class) { initialize_worker_class(freekiqs: 2) }
       end
-    }.to raise_error(Sidekiq::FreekiqException, 'overlooked')
-  end
+    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
+    describe 'with freekiq_for ArgumentError and 2 freekiqs in worker' do
+      it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+        let!(:worker_class) { initialize_worker_class(freekiqs: 2, freekiq_for: [ArgumentError]) }
       end
     end
-  end
 
-  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
+    describe 'with freekiq_for ArgumentError in worker and no freekiqs' do
+      it_behaves_like 'it should have 0 freekiqs for an ArgumentError' do
+        let!(:worker_class) { initialize_worker_class(freekiqs: false, freekiq_for: [ArgumentError]) }
       end
     end
-  end
 
-  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
+    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!(:worker_class) { initialize_worker_class(freekiqs: 2, freekiq_for: [NonArgumentError]) }
       end
     end
-  end
 
-  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
+    describe 'with freekiq_for ArgumentError as a string' do
+      it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+        let!(:worker_class) { initialize_worker_class(freekiqs: 2, freekiq_for: ['ArgumentError']) }
       end
     end
-  end
 
-  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
+    describe 'with freekiq_for the super class of ArgumentError' do
+      it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+        let!(:worker_class) { initialize_worker_class(freekiqs: 2, freekiq_for: [ArgumentError.superclass]) }
       end
     end
-  end
 
-  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
+    describe 'with 2 freekiqs in the worker and retries disabled' do
+      it_behaves_like 'it should only raise exception for an ArgumentError' do
+        let!(:worker_class) { initialize_worker_class(freekiqs: 2, retry: false) }
       end
     end
   end
 
-  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
+  context 'with middleware configured with 2 freekiqs' do
+    before(:each) do
+      initialize_middleware(freekiqs: 2)
     end
-  end
 
-  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
+      let!(:worker_class) { initialize_worker_class }
     end
-  end
 
-  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
+    describe 'with freekiq_for ArgumentError in worker' do
+      it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+        let!(:worker_class) { initialize_worker_class(freekiq_for: [ArgumentError]) }
       end
     end
   end
 
-  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
+  context 'with middleware configured with freekiq_for ArgumentError' do
+    before(:each) do
+      initialize_middleware(freekiq_for: [ArgumentError])
     end
-  end
 
-  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
+    describe 'with 2 freekiqs in worker' do
+      it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+        let!(:worker_class) { initialize_worker_class(freekiqs: 2) }
       end
     end
-  end
 
-  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
+    describe 'with freekiq_for NonArgumentError in worker' do
+      it_behaves_like 'it should have 0 freekiqs for an ArgumentError' do
+        let!(:worker_class) { initialize_worker_class(freekiqs: 2, freekiq_for: [NonArgumentError]) }
       end
     end
   end
 
-  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
+  context 'with middleware configured with freekiq_for NonArgumentError' do
+    before(:each) do
+      initialize_middleware(freekiq_for: [NonArgumentError])
+    end
+
+    describe 'with 2 freekiqs in worker' do
+      it_behaves_like 'it should have 0 freekiqs for an ArgumentError' do
+        let!(:worker_class) { initialize_worker_class(freekiqs: 2) }
       end
     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
+    describe 'with freekiq_for ArgumentError in worker' do
+      it_behaves_like 'it should have 2 freekiqs for an ArgumentError' do
+        let!(:worker_class) { initialize_worker_class(freekiqs: 2, freekiq_for: [ArgumentError]) }
       end
     end
   end
 
-  describe 'with freekiq_for the super class of ArgumentError' do
+  context 'with middleware configured with 2 freekiqs and freekiq_for ArgumentError' do
+    before(:each) do
+      initialize_middleware(freekiqs: 2, freekiq_for: [ArgumentError])
+    end
+
     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
+      let!(:worker_class) { initialize_worker_class }
     end
   end
+
+  it 'should execute a defined callback' do
+    called = false
+    initialize_middleware(callback: ->(worker, msg, queue){called = true})
+
+    expect {
+      process_job(build_job_hash(initialize_worker_class(freekiqs: 2)))
+    }.to raise_error(Sidekiq::FreekiqException, 'Oops')
+    expect(called).to eq(true)
+  end
+
+  it 'should still raise FreekiqException if the callback fails' do
+    initialize_middleware(callback: ->(worker, msg, queue){raise 'callback error'})
+
+    expect {
+      process_job(build_job_hash(initialize_worker_class(freekiqs: 2)))
+    }.to raise_error(Sidekiq::FreekiqException, 'Oops')
+  end
 end

data/spec/spec_helper.rb

@@ -1,11 +1,102 @@
 require 'freekiqs'
 
+$TESTING = true
+
+Sidekiq::Logging.logger = nil
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
   config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
   end
 
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
   config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
     mocks.verify_partial_doubles = true
   end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  # config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
 end

metadata

@@ -1,23 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: freekiqs
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Rob Lewis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-24 00:00:00.000000000 Z
+date: 2017-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.0.0
-    - - "<"
       - !ruby/object:Gem::Version
         version: 5.0.0
   type: :runtime
@@ -25,9 +22,6 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
-      - !ruby/object:Gem::Version
-        version: 4.0.0
-    - - "<"
       - !ruby/object:Gem::Version
         version: 5.0.0
 - !ruby/object:Gem::Dependency
@@ -36,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: 3.6.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: 3.6.0
 description: Sidekiq middleware extending RetryJobs to allow configuring how many
   exceptions a job can throw and be wrapped by a silenceable exception.
 email:
@@ -53,10 +47,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - Gemfile
 - MIT-LICENSE
 - README.md
 - Rakefile
+- Vagrantfile
 - circle.yml
 - freekiqs.gemspec
 - lib/freekiqs.rb
@@ -75,7 +71,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.2.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -83,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Sidekiq middleware extending RetryJobs to allow silient errors.