Set blacklisted exceptions

.travis.yml

@@ -1,10 +1,6 @@
 language: ruby
 rvm:
-  - 1.9.3
-  - 2.2
   - 2.3.0
+  - 2.3.3
+  - 2.5.5
 sudo: false
-matrix:
-  include:
-    - rvm: 1.8.7
-      gemfile: Gemfiles/Gemfile.1.8.7

lib/resque/failure/base.rb

@@ -1,10 +1,14 @@
+require 'resque/failure/blacklist_exceptions_registrar'
+
 module Resque
   module Failure
     # All Failure classes are expected to subclass Base.
     #
     # When a job fails, a new instance of your Failure backend is created
     # and #save is called.
     class Base
+      include BlacklistExceptionsRegistrar
+
       # The exception object raised by the failed job
       attr_accessor :exception
 

lib/resque/failure/blacklist_exceptions_registrar.rb

@@ -0,0 +1,50 @@
+module Resque
+  module Failure
+    # A module to access blacklisted exceptions
+    # on a class level
+    module BlacklistExceptionsRegistrar
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      # Class methods for accessing
+      # blacklisted exceptions
+      module ClassMethods
+        # Set a list of blacklisted exceptions
+        #
+        # The method sets a list of exceptions which will
+        # not be pushed to the failed queue when a job fails and it's
+        # exception is included to the blacklisted ones.
+        #
+        # @param [Array<String>] exceptions the list of exceptions to blacklist
+        # @raise [StandardError] if the exceptions argument is not an array
+        # @return [void]
+        def set_blacklisted_exceptions(exceptions)
+          unless exceptions.is_a?(Array)
+            raise StandardError.new("The exceptions argument must be an array")
+          end
+
+          @blacklist = exceptions
+        end
+
+        # Fetch the blacklisted exceptions of a failure backend class
+        #
+        # @return [Array<String>]
+        def get_blacklisted_exceptions
+          return @blacklist if defined?(@blacklist)
+
+          []
+        end
+      end
+
+      # Check if the raised exception belongs
+      # to the backend's blacklisted exceptions.
+      #
+      # @return [true, false] true if raised exception is blacklisted,
+      #   false otherwise
+      def blacklisted_exception_raised?
+        self.class&.get_blacklisted_exceptions&.include?(@exception.class.to_s)
+      end
+    end
+  end
+end

lib/resque/failure/multiple.rb

@@ -25,7 +25,7 @@ def save
         exception = nil
         @backends.each do |b|
           begin
-            b.save
+            b.save unless b.blacklisted_exception_raised?
           rescue => e
             exception = e
             log("Failed saving to #{b.class.name}, error #{e.to_s}")

lib/resque/failure/redis.rb

@@ -16,6 +16,8 @@ def self.data_store
       end
 
       def save
+        return if blacklisted_exception_raised?
+
         data = {
           :failed_at => UTF8Util.clean(Time.now.strftime("%Y/%m/%d %H:%M:%S %Z")),
           :payload   => payload,

lib/resque/failure/redis_multi_queue.rb

@@ -13,6 +13,8 @@ def self.data_store
       end
 
       def save
+        return if blacklisted_exception_raised?
+
         data = {
           :failed_at => Time.now.strftime("%Y/%m/%d %H:%M:%S %Z"),
           :payload   => payload,

lib/resque/version.rb

@@ -1,3 +1,3 @@
 module Resque
-  Version = VERSION = '1.27.4.skroutz.1'
+  Version = VERSION = '1.27.4.skroutz.2'
 end

test/resque_failure_multiple_test.rb

@@ -16,6 +16,8 @@ def save
   end
 end
 
+class CustomException < StandardError; end
+
 describe "Resque::Failure::Multiple" do
 
   it 'requeue_all and does not raise an exception' do
@@ -62,3 +64,22 @@ def save
     end
   end
 end
+
+describe "blacklisted_exceptions" do
+  it "sets blacklisted_exceptions on the multiple backend" do
+    blacklisted_exceptions = ["CustomException"]
+    Resque::Failure::Redis.set_blacklisted_exceptions(blacklisted_exceptions)
+    Resque::Failure::Multiple.classes = [Resque::Failure::Redis]
+
+    exception = CustomException.new("Custom error")
+    worker = Resque::Worker.new(:test)
+    payload = { "class" => Object, "args" => 3 }
+
+    multiple_backend = Resque::Failure::Multiple.new(exception, worker, 'test', payload)
+    backends = multiple_backend.instance_variable_get(:@backends)
+    backends.each do |b|
+      assert_equal blacklisted_exceptions, b.class.get_blacklisted_exceptions
+    end
+  end
+end
+

test/resque_failure_redis_test.rb

@@ -99,3 +99,83 @@
   end
 
 end
+
+class CustomException < StandardError; end
+
+describe "blacklisted exceptions" do
+
+  let(:exception) { CustomException.new("Custom error") }
+  let(:queue) { "test" }
+  let(:worker) { Resque::Worker.new([queue]) }
+  let(:payload) { { "class" => Object, "args" => 3 } }
+  let(:blacklisted_exceptions) { ["CustomException"] }
+  let(:redis_backend) do
+    Resque::Failure::Redis.new(exception, worker, queue, payload)
+  end
+
+  describe "set blacklisted exceptions to empty array" do
+    before do
+      Resque::Failure::Redis.clear
+      Resque::Failure::Redis.set_blacklisted_exceptions([])
+    end
+
+    it "returns blacklisted exceptions" do
+      assert_equal [], redis_backend.class.get_blacklisted_exceptions
+    end
+
+    it "pushes to failed queue" do
+      redis_backend.save
+
+      assert_equal 1, Resque::Failure::Redis.count
+    end
+  end
+
+  describe "exception during set_blacklisted_exceptions" do
+    it "raises exception due to wrong argument type" do
+      assert_raises StandardError do
+        Resque::Failure::Redis.set_blacklisted_exceptions("CustomException")
+      end
+    end
+  end
+
+  describe "setting and using blacklisted exceptions" do
+    before do
+      Resque::Failure::Redis.clear
+      Resque::Failure::Redis.set_blacklisted_exceptions(blacklisted_exceptions)
+    end
+
+    it "returns blacklisted exceptions" do
+      assert_equal blacklisted_exceptions, redis_backend.class.get_blacklisted_exceptions
+    end
+
+    it "does not push to failed queue" do
+      redis_backend.save
+
+      assert_equal 0, Resque::Failure::Redis.count
+    end
+  end
+
+  describe "blacklisted_exception_raised?" do
+    describe "when raised exception is blacklisted" do
+      before do
+        Resque::Failure::Redis.clear
+        Resque::Failure::Redis.set_blacklisted_exceptions(blacklisted_exceptions)
+      end
+
+      it "returns true" do
+        assert_equal true, redis_backend.blacklisted_exception_raised?
+      end
+    end
+
+    describe "when raised exception is not blacklisted" do
+      before do
+        Resque::Failure::Redis.clear
+        Resque::Failure::Redis.set_blacklisted_exceptions(["AnotherException"])
+      end
+
+      it "returns false" do
+        assert_equal false, redis_backend.blacklisted_exception_raised?
+      end
+    end
+  end
+end