freekiqs 4.1.0 → 6.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0a7ee677e8d100c7405dc91f9d4c341d7f7a8986
-  data.tar.gz: 0281092a960af50ca75ed3b03370bd7a86b1ae17
+SHA256:
+  metadata.gz: d6b06dcd42bf69b36943cb98073500edaa179251c807284ac1520788f4f9b868
+  data.tar.gz: 7d273e8393c7f4ec61b2bc3488daaa3a8e7c4d2c3c4e323d0787f3217a1ec772
 SHA512:
-  metadata.gz: 35984aad9ab4d0fec1d33f07469ba0f82ff83a5b3cdeaecb39f1bbdb42f56ec9566df45c8735970034f99294919790481983047141a89750118845d46d7a3ad9
-  data.tar.gz: d932c98cefbdcc672d00c2e85ae16a86b6b4b70cb719403a462b8981dacd22fca4f0cbaa7cf90735879cbd8cbc8efe3a5f221eaa9d8cd033962e0efd841dbaf4
+  metadata.gz: beeb49dbe17a46885ab99ff7c2128645fb739496a7636a2a0b8f041c7b1099dfd42e291f23d15bf49b0ff4b1da09d01da8a8f8d2cb9ed482db09982143d64d65
+  data.tar.gz: 1ce3a30d1d569967f3c0b3fe6941baf00cfaa6c99da09436e87481b29e8dfa1412cef2ede6853ae4c9e6099aa547149b01c943ac613891cb7b39d0020c7b44e1

data/.gitignore

@@ -3,3 +3,8 @@ gemfiles/*.lock
 Gemfile.lock
 .ruby-version
 pkg
+/.bundle
+/.vagrant
+/ubuntu-*-console.log
+/vendor
+dump.rdb

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/Procfile

@@ -0,0 +1 @@
+redis: redis-server development/redis/redis.conf --bind $HOST

data/README.md

@@ -3,13 +3,28 @@
 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.
+
+#### 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,
+along with subsequent exceptions from retries, are caught and wrapped
+with the `FreekiqException` exception.
+Cases where Freekiqs does NOT wrap the exception:
+ - The `retry` option is false
+ - The `freekiqs` option is not set on the worker nor globally
+ - The `freekiqs` option is not set on worker and set to `false` globally
+ - The `freekiqs` option is set to `false` on the worker
+ - The job threw an exception that is not a StandardError (nor a subclass)
+ - The number of thrown exceptions is more than specified freekiqs
 
 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 +34,7 @@ Worker example:
   class MyWorker
     include Sidekiq::Worker
     sidekiq_options freekiqs: 3
-      #
+
     def perform(param)
       ...
     end
@@ -35,7 +50,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 +59,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 +83,7 @@ Example:
   class MyWorker
     include Sidekiq::Worker
     sidekiq_options freekiqs: 1, freekiq_for: ['MyError']
-      #
+
     def perform(param)
       ...
     end
@@ -67,8 +93,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 +103,7 @@ Example:
   class MyWorker
     include Sidekiq::Worker
     sidekiq_options freekiqs: 1, freekiq_for: [MyError]
-      #
+
     def perform(param)
       ...
     end
@@ -85,26 +111,9 @@ Example:
 ```
 If MyWorker throws a SubMyError or MyError, it will get freekiq'd.
 
+## Sidekiq Versions
 
-## Overview
+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).
 
-Up to the configured number of "freekiqs", catch exceptions thrown
-from job and wrap them with the `FreekiqException` exception (which is a
-`RuntimeError`). That exception type can be ignored by monitoring
-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:
-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,
-along with subsequent exceptions from retries, are caught and wrapped
-with the `FreekiqException` exception.
-Cases where Freekiqs does NOT wrap the exception:
- - The `retry` option is false
- - The `freekiqs` option is not set on the worker nor globally
- - The `freekiqs` option is not set on worker and set to `false` globally
- - The `freekiqs` option is set to `false` on the worker
- - The job threw an exception that is not a StandardError (nor a subclass)
- - The number of thrown exceptions is more than specified freekiqs
+Version 6.5.0 of this gem works with Sidekiq 6.5 and higher.

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/development/redis/redis.conf

@@ -0,0 +1,49 @@
+protected-mode yes
+port 6379
+tcp-backlog 511
+timeout 0
+tcp-keepalive 300
+daemonize no
+supervised no
+pidfile development/redis/redis_6379.pid
+loglevel warning
+logfile ""
+databases 16
+save 900 1
+save 300 10
+save 60 10000
+stop-writes-on-bgsave-error yes
+rdbcompression yes
+rdbchecksum yes
+dbfilename dump.rdb
+dir development/redis
+slave-serve-stale-data yes
+slave-read-only yes
+repl-diskless-sync no
+repl-diskless-sync-delay 5
+repl-disable-tcp-nodelay no
+slave-priority 100
+appendonly no
+appendfilename "appendonly.aof"
+appendfsync no
+no-appendfsync-on-rewrite no
+auto-aof-rewrite-percentage 100
+auto-aof-rewrite-min-size 64mb
+aof-load-truncated yes
+lua-time-limit 5000
+latency-monitor-threshold 0
+notify-keyspace-events ""
+hash-max-ziplist-entries 512
+hash-max-ziplist-value 64
+list-max-ziplist-size -2
+list-compress-depth 0
+set-max-intset-entries 512
+zset-max-ziplist-entries 128
+zset-max-ziplist-value 64
+hll-sparse-max-bytes 3000
+activerehashing yes
+client-output-buffer-limit normal 0 0 0
+client-output-buffer-limit slave 256mb 64mb 60
+client-output-buffer-limit pubsub 32mb 8mb 60
+hz 10
+aof-rewrite-incremental-fsync yes

data/freekiqs.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |gem|
   gem.name                  = 'freekiqs'
-  gem.version               = '4.1.0'
+  gem.version               = '6.5.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', '>= 6.5.0'
+  gem.add_development_dependency 'rspec', '>= 3.6.0'
 end

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

@@ -1,5 +1,5 @@
 require 'sidekiq'
-require 'sidekiq/util'
+require 'sidekiq/middleware/modules'
 
 module Sidekiq
   class FreekiqException < RuntimeError; end
@@ -7,37 +7,38 @@ module Sidekiq
   module Middleware
     module Server
       class Freekiqs
-        include Sidekiq::Util
+        include Sidekiq::ServerMiddleware
         @@callback = nil
 
         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
                 @@callback.call(worker, msg, queue) if @@callback
               rescue => callback_exception
-                Sidekiq.logger.info { "Freekiq callback failed for #{msg['class']} job #{msg['jid']}" }
+                logger.info { "Freekiq callback failed for #{msg['class']} job #{msg['jid']}" }
               ensure
                 raise FreekiqException, ex.message
               end
             else
-              Sidekiq.logger.info { "Out of free kiqs for #{msg['class']} job #{msg['jid']}" }
+              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/shell.nix

@@ -0,0 +1,42 @@
+{ system ? builtins.currentSystem }:
+
+with (import (fetchTarball {
+  name = "nixpkgs-21.11";
+  url = "https://github.com/nixos/nixpkgs/archive/21.11.tar.gz";
+  sha256 = "162dywda2dvfj1248afxc45kcrg83appjd0nmdb541hl7rnncf02";
+}) { inherit system; });
+
+
+let
+  requiredNixVersion = "2.3";
+
+  pwd = builtins.getEnv "PWD";
+in
+
+if lib.versionOlder builtins.nixVersion requiredNixVersion == true then
+  abort "This project requires Nix >= ${requiredNixVersion}, please run 'nix-channel --update && nix-env -i nix'."
+else
+
+  mkShell {
+    buildInputs = [
+      stdenv
+      git
+      cacert
+
+      # Ruby and Rails dependencies
+      ruby_2_7.devEnv
+      bundler
+
+      # Services
+      overmind
+      redis
+
+    ] ++ lib.optional (!stdenv.isDarwin) [
+      # linux-only packages
+      glibcLocales
+    ];
+
+    HOST = "127.0.0.24";
+    REDIS_URL="redis://127.0.0.24:6379/1";
+    BUNDLE_PATH = "vendor/bundle";
+  }

data/spec/freekiqs_spec.rb

@@ -1,329 +1,249 @@
-require 'spec_helper'
-require 'sidekiq/cli'
-require 'sidekiq/middleware/server/retry_jobs'
+require 'sidekiq'
+require 'sidekiq/api'
+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)
+    processor = Sidekiq::Processor.new(Sidekiq)
+    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.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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: freekiqs
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 6.5.0
 platform: ruby
 authors:
 - Rob Lewis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-24 00:00:00.000000000 Z
+date: 2022-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -16,34 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 6.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 5.0.0
+        version: 6.5.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     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,14 +47,19 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - Gemfile
 - MIT-LICENSE
+- Procfile
 - README.md
 - Rakefile
+- Vagrantfile
 - circle.yml
+- development/redis/redis.conf
 - freekiqs.gemspec
 - lib/freekiqs.rb
 - lib/sidekiq/middleware/server/freekiqs.rb
+- shell.nix
 - spec/freekiqs_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/BookBub/freekiqs
@@ -75,15 +74,14 @@ 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:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
 summary: Sidekiq middleware extending RetryJobs to allow silient errors.