activejob-retry 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9dd35a0525fd3f160a488f90b9471f7058a714de
+  data.tar.gz: 3e423dbca62f4337a765a54f7c212ccd3ef237eb
+SHA512:
+  metadata.gz: ac1daad64696deacbfeab3d8e28e1ffff49b7e219580de47f9f02f0867ae5f0977615c019d88f8f9d2afca3561df7b551fcb56a9b3d4ce2ccdea109e117c907a
+  data.tar.gz: 74b33077ae43b9232eace312851fc9a85165e72c8ae4b1b386f97d109daab75121909fb9a9b7bcec5c7b3e70673ca0d4ab5ed5a16448d7ab7d8769b0b95a7e50

data/.gitignore

@@ -0,0 +1,5 @@
+.bundle
+.gem
+.rbx/
+*.gem
+.ruby-version

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+
+matrix:
+  allow_failures:
+    - rvm: jruby-19mode
+    - rvm: rbx-2
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.1.1
+  - 2.1.2
+  - jruby-19mode
+  - rbx-2

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+gemspec
+
+group :test do
+  gem 'resque', require: false
+  gem 'resque-scheduler', require: false
+  gem 'sidekiq', require: false
+  gem 'sucker_punch', require: false
+  gem 'delayed_job', require: false
+  gem 'queue_classic', "< 3.0.0", require: false, platforms: :ruby
+  gem 'sneakers', '0.1.1.pre', require: false
+  gem 'que', require: false
+  gem 'backburner', require: false
+  gem 'qu-rails', github: "bkeepers/qu", branch: "master", require: false
+  gem 'qu-redis', require: false
+  gem 'sequel', require: false
+end

data/Gemfile.lock

@@ -0,0 +1,197 @@
+GIT
+  remote: git://github.com/bkeepers/qu.git
+  revision: d098e2657c92e89a6413bebd9c033930759c061f
+  branch: master
+  specs:
+    qu (0.2.0)
+    qu-rails (0.2.0)
+      qu (= 0.2.0)
+      railties (>= 3.2, < 5)
+    qu-redis (0.2.0)
+      qu (= 0.2.0)
+      redis-namespace
+
+PATH
+  remote: .
+  specs:
+    activejob-retry (0.0.1)
+      activejob (>= 4.2)
+      activesupport (>= 4.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (4.2.0)
+      actionview (= 4.2.0)
+      activesupport (= 4.2.0)
+      rack (~> 1.6.0)
+      rack-test (~> 0.6.2)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.1)
+    actionview (4.2.0)
+      activesupport (= 4.2.0)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.1)
+    activejob (4.2.0)
+      activesupport (= 4.2.0)
+      globalid (>= 0.3.0)
+    activesupport (4.2.0)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    amq-protocol (1.9.2)
+    backburner (0.4.6)
+      beaneater (~> 0.3.1)
+      dante (~> 0.1.5)
+    beaneater (0.3.3)
+    builder (3.2.2)
+    bunny (1.1.9)
+      amq-protocol (>= 1.9.2)
+    byebug (3.5.1)
+      columnize (~> 0.8)
+      debugger-linecache (~> 1.2)
+      slop (~> 3.6)
+    celluloid (0.16.0)
+      timers (~> 4.0.0)
+    coderay (1.1.0)
+    columnize (0.9.0)
+    connection_pool (2.1.0)
+    dante (0.1.5)
+    debugger-linecache (1.2.0)
+    delayed_job (4.0.6)
+      activesupport (>= 3.0, < 5.0)
+    diff-lcs (1.2.5)
+    erubis (2.7.0)
+    globalid (0.3.0)
+      activesupport (>= 4.1.0)
+    hitimes (1.2.2)
+    i18n (0.7.0)
+    json (1.8.1)
+    loofah (2.0.1)
+      nokogiri (>= 1.5.9)
+    method_source (0.8.2)
+    mini_portile (0.6.2)
+    minitest (5.5.0)
+    mono_logger (1.1.0)
+    multi_json (1.10.1)
+    nokogiri (1.6.5)
+      mini_portile (~> 0.6.0)
+    pg (0.17.1)
+    pry (0.10.1)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-byebug (2.0.0)
+      byebug (~> 3.4)
+      pry (~> 0.10)
+    que (0.9.0)
+    queue_classic (2.2.3)
+      pg (~> 0.17.0)
+    rack (1.6.0)
+    rack-protection (1.5.3)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails-deprecated_sanitizer (1.0.3)
+      activesupport (>= 4.2.0.alpha)
+    rails-dom-testing (1.0.5)
+      activesupport (>= 4.2.0.beta, < 5.0)
+      nokogiri (~> 1.6.0)
+      rails-deprecated_sanitizer (>= 1.0.1)
+    rails-html-sanitizer (1.0.1)
+      loofah (~> 2.0)
+    railties (4.2.0)
+      actionpack (= 4.2.0)
+      activesupport (= 4.2.0)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (10.4.2)
+    redis (3.2.0)
+    redis-namespace (1.5.1)
+      redis (~> 3.0, >= 3.0.4)
+    resque (1.25.2)
+      mono_logger (~> 1.0)
+      multi_json (~> 1.0)
+      redis-namespace (~> 1.3)
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+    resque-scheduler (4.0.0)
+      mono_logger (~> 1.0)
+      redis (~> 3.0)
+      resque (~> 1.25)
+      rufus-scheduler (~> 3.0)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.7)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.1.0)
+    rspec-its (1.1.0)
+      rspec-core (>= 3.0.0)
+      rspec-expectations (>= 3.0.0)
+    rspec-mocks (3.1.3)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.2)
+    rufus-scheduler (3.0.9)
+      tzinfo
+    sequel (4.17.0)
+    serverengine (1.5.10)
+      sigdump (~> 0.2.2)
+    sidekiq (3.3.0)
+      celluloid (>= 0.16.0)
+      connection_pool (>= 2.0.0)
+      json
+      redis (>= 3.0.6)
+      redis-namespace (>= 1.3.1)
+    sigdump (0.2.2)
+    sinatra (1.4.5)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    slop (3.6.0)
+    sneakers (0.1.1.pre)
+      bunny (~> 1.1.3)
+      serverengine
+      thor
+      thread
+    sucker_punch (1.3.2)
+      celluloid (~> 0.16.0)
+    thor (0.19.1)
+    thread (0.1.4)
+    thread_safe (0.3.4)
+    tilt (1.4.1)
+    timers (4.0.1)
+      hitimes
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    vegas (0.1.11)
+      rack (>= 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activejob-retry!
+  backburner
+  delayed_job
+  pry-byebug
+  qu-rails!
+  qu-redis
+  que
+  queue_classic (< 3.0.0)
+  rake (>= 10.3)
+  resque
+  resque-scheduler
+  rspec
+  rspec-its
+  sequel
+  sidekiq
+  sneakers (= 0.1.1.pre)
+  sucker_punch

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Isaac Seymour
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+Software), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+ActiveJob::Retry
+================
+
+A DSL for automatically retrying ActiveJobs, with exponential backoff.
+
+```ruby
+class ProcessWebhook < ActiveJob::Base
+  include ActiveJob::Retry
+
+  queue_as :webhooks
+  retry_with limit: 3,                          # Attempt three times and then raise (default: 1)
+             delay: 5,                          # Wait ~5 seconds between attempts (default: 0)
+             retry_exceptions: [TimeoutError]   # Only retry when these errors are raised (default: all)
+             # Could alternatively use:
+             # fatal_exceptions: [StandardError] # Never catch these errors (default: none)
+
+  def perform(webhook)
+    webhook.process!
+  end
+end
+```
+
+With exponential backoff:
+
+```ruby
+class ProcessWebhook < ActiveJob::Base
+  include ActiveJob::Retry::ExponentialBackoff
+
+  queue_as :webhooks
+  backoff_with strategy: [1, 5, 10, 30, 60] # Delay for 1, 5, ... seconds between subsequent retries
+               min_delay_multiplier: 0.8,   # Multiply each delay by a random number between
+               max_delay_multiplier: 1.2    # 0.8 and 1.2 (rounded to nearest second)
+
+  def perform(webhook)
+    webhook.process!
+  end
+end
+```
+
+Contributing
+------------
+
+  * Fork the project.
+  * Make your feature addition or bug fix.
+  * Add tests for it.
+  * Document it in the CHANGELOG.md.
+  * Open a PR.

data/Rakefile

@@ -0,0 +1,75 @@
+require 'rake/testtask'
+require 'rubygems/package_task'
+
+ACTIVEJOB_ADAPTERS = %w(backburner delayed_job que resque sidekiq)
+
+task default: :test
+task test: 'test:default'
+
+namespace :test do
+  desc 'Run all adapter tests'
+  task :default do
+    run_without_aborting ACTIVEJOB_ADAPTERS.map { |a| "test:#{a}" }
+  end
+
+  desc 'Run all adapter tests in isolation'
+  task :isolated do
+    run_without_aborting ACTIVEJOB_ADAPTERS.map { |a| "test:isolated:#{a}" }
+  end
+
+  desc 'Run integration tests for all adapters'
+  task :integration do
+    run_without_aborting ACTIVEJOB_ADAPTERS.map { |a| "test:integration:#{a}" }
+  end
+
+  task 'env:integration' do
+    ENV['AJ_INTEGRATION_TESTS'] = "1"
+  end
+
+  ACTIVEJOB_ADAPTERS.each do |adapter|
+    task("env:#{adapter}") { ENV['AJADAPTER'] = adapter }
+
+    Rake::TestTask.new(adapter => "test:env:#{adapter}") do |t|
+      t.description = "Run adapter tests for #{adapter}"
+      t.libs << 'test'
+      t.test_files = FileList['test/cases/**/*_test.rb']
+      t.verbose = true
+      t.warning = true
+      t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
+    end
+
+    namespace :isolated do
+      task adapter => "test:env:#{adapter}" do
+        dir = File.dirname(__FILE__)
+        Dir.glob("#{dir}/test/cases/**/*_test.rb").all? do |file|
+          sh(Gem.ruby, '-w', "-I#{dir}/lib", "-I#{dir}/test", file)
+        end or raise 'Failures'
+      end
+    end
+
+    namespace :integration do
+      Rake::TestTask.new(adapter => ["test:env:#{adapter}", 'test:env:integration']) do |t|
+        t.description = "Run integration tests for #{adapter}"
+        t.libs << 'test'
+        t.test_files = FileList['test/integration/**/*_test.rb']
+        t.verbose = true
+        t.warning = true
+        t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
+      end
+    end
+  end
+end
+
+def run_without_aborting(tasks)
+  errors = []
+
+  tasks.each do |task|
+    begin
+      Rake::Task[task].invoke
+    rescue Exception
+      errors << task
+    end
+  end
+
+  abort "Errors running #{errors.join(', ')}" if errors.any?
+end

data/activejob-retry.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_job/retry/version'
+
+Gem::Specification.new do |s|
+  s.name = 'activejob-retry'
+  s.version = ActiveJob::Retry::VERSION
+  s.date = Date.today.strftime('%Y-%m-%d')
+  s.authors = ['Isaac Seymour']
+  s.email = ['isaac@isaacseymour.co.uk']
+  s.summary = 'Automatic retrying DSL for ActiveJob'
+  s.description = <<-EOL
+    activejob-retry provides a simple DSL for automatically retrying ActiveJobs when they
+    fail, with exponential backoff.
+
+    Features:
+
+    * (Should) work with any queue adapter that supports retries.
+    * Whitelist/blacklist exceptions to retry on.
+    * Exponential backoff (varying the delay between retries).
+    * Light and easy to override retry logic.
+  EOL
+  s.homepage = 'http://github.com/isaacseymour/activejob-retry'
+  s.license = 'MIT'
+
+  s.has_rdoc = false
+  s.files = `git ls-files`.split($/)
+  s.require_paths = %w[lib]
+
+  s.add_dependency('activejob', '>= 4.2')
+  s.add_dependency('activesupport', '>= 4.2')
+
+  s.add_development_dependency('rake', ' >= 10.3')
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('rspec-its')
+  s.add_development_dependency('pry-byebug')
+end

data/lib/active_job-retry.rb

@@ -0,0 +1,14 @@
+require 'active_job'
+require 'active_support'
+
+require 'active_job/retry'
+require 'active_job/retry/exponential_backoff'
+require 'active_job/retry/invalid_configuration_error'
+require 'active_job/retry/options_validator'
+require 'active_job/retry/exponential_options_validator'
+
+require 'active_job/retry/version'
+
+unless ActiveJob::Base.method_defined?(:deserialize)
+  require 'active_job/retry/deserialize_monkey_patch'
+end

data/lib/active_job/retry.rb

@@ -0,0 +1,130 @@
+module ActiveJob
+  module Retry
+    class UnsupportedAdapterError < StandardError; end
+    SUPPORTED_ADAPTERS = %i(backburner delayed_job que resque sidekiq).freeze
+
+    # If you want your job to retry on failure, simply include this module in your class,
+    #
+    #   class DeliverWebHook < ActiveJob::Base
+    #     include ActiveJob::Retry
+    #     queue_as :web_hooks
+    #
+    #     retry_with limit: 8,                         # default 1
+    #                delay: 60,                        # default 0
+    #                fatal_exceptions: [RuntimeError], # default [], i.e. none
+    #                retry_exceptions: [TimeoutError]  # default nil, i.e. all
+    #
+    #     def perform(url, web_hook_id, hmac_key)
+    #       work!
+    #     end
+    #   end
+    def self.included(base)
+      # This breaks all specs because the adapter gets set after class eval :(
+      # unless SUPPORTED_ADAPTERS.include?(ActiveJob::Base.queue_adapter)
+      #   raise UnsupportedAdapterError,
+      #         "Only Backburner, DelayedJob, Que, Resque, and Sidekiq support delayed " \
+      #         "retries. #{ActiveJob::Base.queue_adapter} is not supported."
+      # end
+
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Setup DSL
+      def retry_with(options)
+        OptionsValidator.new(options).validate!
+
+        @retry_limit      = options[:limit]            if options[:limit]
+        @retry_delay      = options[:delay]            if options[:delay]
+        @fatal_exceptions = options[:fatal_exceptions] if options[:fatal_exceptions]
+        @retry_exceptions = options[:retry_exceptions] if options[:retry_exceptions]
+      end
+
+      ############
+      # Defaults #
+      ############
+      def retry_limit
+        @retry_limit ||= 1
+      end
+
+      def retry_delay
+        @retry_delay ||= 0
+      end
+
+      def fatal_exceptions
+        @fatal_exceptions ||= []
+      end
+
+      def retry_exceptions
+        @retry_exceptions ||= nil
+      end
+
+      #################
+      # Retry helpers #
+      #################
+      def retry_exception?(exception)
+        return true if retry_exceptions.nil? && fatal_exceptions.empty?
+        return exception_whitelisted?(exception) unless retry_exceptions.nil?
+        !exception_blacklisted?(exception)
+      end
+
+      def exception_whitelisted?(exception)
+        retry_exceptions.any? { |ex| exception.is_a?(ex) }
+      end
+
+      def exception_blacklisted?(exception)
+        fatal_exceptions.any? { |ex| exception.is_a?(ex) }
+      end
+    end
+
+    #############
+    # Overrides #
+    #############
+    def serialize
+      super.merge('retry_attempt' => retry_attempt + 1)
+    end
+
+    def deserialize(job_data)
+      super(job_data)
+      @retry_attempt = job_data['retry_attempt']
+    end
+
+    # Override `rescue_with_handler` to make sure our catch is the last one, and doesn't
+    # happen if the exception has already been caught in a `rescue_from`
+    def rescue_with_handler(exception)
+      super || retry_or_reraise(exception)
+    end
+
+    ##################
+    # Retrying logic #
+    ##################
+    def retry_attempt
+      @retry_attempt ||= 0
+    end
+
+    # Override me if you want more complex behaviour
+    def retry_delay
+      self.class.retry_delay
+    end
+
+    def should_retry?(exception)
+      return false if retry_limit_reached?
+      return false unless self.class.retry_exception?(exception)
+      true
+    end
+
+    def retry_limit_reached?
+      return true if self.class.retry_limit == 0
+      return false if self.class.retry_limit == -1
+      retry_attempt >= self.class.retry_limit
+    end
+
+    def retry_or_reraise(exception)
+      raise exception unless should_retry?(exception)
+
+      this_delay = retry_delay
+      logger.log(Logger::INFO, "Retrying (attempt #{retry_attempt + 1}, waiting #{this_delay}s)")
+      retry_job(wait: this_delay)
+    end
+  end
+end

data/lib/active_job/retry/deserialize_monkey_patch.rb

@@ -0,0 +1,22 @@
+# In Rails 4.2, ActiveJob externally applies deserialized job ID, queue name, arguments to
+# the instantiated job in `ActiveJob::Base.deserialize`, which cannot be overridden in
+# subclasses. https://github.com/rails/rails/pull/18260 changes this to delegate as much
+# of the deserialization as possible to the instance, i.e. `ActiveJob::Base#deserialize`,
+# which can be overridden. This allows us to store extra information in the queue (i.e.
+# retry_attempt), which is essential for ActiveJob::Retry.
+
+raise "Unnecessary monkey patch!" if ActiveJob::Base.method_defined?(:deserialize)
+
+class ActiveJob::Base
+  def self.deserialize(job_data)
+    job = job_data['job_class'].constantize.new
+    job.deserialize(job_data)
+    job
+  end
+
+  def deserialize(job_data)
+    self.job_id               = job_data['job_id']
+    self.queue_name           = job_data['queue_name']
+    self.serialized_arguments = job_data['arguments']
+  end
+end

data/lib/active_job/retry/exponential_backoff.rb

@@ -0,0 +1,92 @@
+module ActiveJob
+  module Retry
+    # If you want your job to retry on failure using a varying delay, simply
+    # extend your class with this module:
+    #
+    #   class DeliverSMS < ActiveJob::Base
+    #     extend ActiveJob::Retry::ExponentialBackoff
+    #     queue_as :messages
+    #
+    #     def perform(mobile_number, message)
+    #       SmsService.deliver!(mobile_number, message)
+    #     end
+    #   end
+    #
+    # Easily do something custom:
+    #
+    #   class DeliverSMS
+    #     extend ActiveJob::Retry::ExponentialBackoff
+    #     queue_as :messages
+    #
+    #     # Options from ActiveJob::Retry can also be used
+    #     retry_with strategy: [0, 60], # retry immediately, then after 60 seconds
+    #                min_delay_multiplier: 0.8, # multiply the delay by a random number
+    #                max_delay_multiplier: 1.5  # between 0.8 and 1.5
+    #
+    #     def perform(mobile_number, message)
+    #       SmsService.deliver!(mobile_number, message)
+    #     end
+    #   end
+    #
+    module ExponentialBackoff
+      include ActiveJob::Retry
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        include ActiveJob::Retry::ClassMethods
+
+        # Setup DSL
+        def backoff_with(options)
+          retry_with(options)
+          ExponentialOptionsValidator.new(options).validate!
+
+          @retry_limit          = options[:limit] || options[:strategy].length if options[:strategy]
+          @backoff_strategy     = options[:strategy]             if options[:strategy]
+          @min_delay_multiplier = options[:min_delay_multiplier] if options[:min_delay_multiplier]
+          @max_delay_multiplier = options[:max_delay_multiplier] if options[:max_delay_multiplier]
+        end
+
+        ############
+        # Defaults #
+        ############
+        def retry_limit
+          @retry_limit ||= (backoff_strategy || []).length
+        end
+
+        def backoff_strategy
+          @backoff_strategy ||= nil
+        end
+
+        def min_delay_multiplier
+          @min_delay_multiplier ||= 1.0
+        end
+
+        def max_delay_multiplier
+          @max_delay_multiplier ||= 1.0
+        end
+      end
+
+      ###############
+      # Retry logic #
+      ###############
+      def retry_delay
+        delay = self.class.backoff_strategy[retry_attempt]
+
+        return (delay * self.class.max_delay_multiplier).to_i unless random_delay?
+
+        (delay * rand(random_delay_range)).to_i
+      end
+
+      def random_delay?
+        self.class.min_delay_multiplier != self.class.max_delay_multiplier
+      end
+
+      def random_delay_range
+        self.class.min_delay_multiplier..self.class.max_delay_multiplier
+      end
+    end
+  end
+end

data/lib/active_job/retry/exponential_options_validator.rb

@@ -0,0 +1,57 @@
+module ActiveJob
+  module Retry
+    class ExponentialOptionsValidator
+      DELAY_MULTIPLIER_KEYS = %i(min_delay_multiplier max_delay_multiplier).freeze
+
+      def initialize(options)
+        @options = options
+        @retry_limit = options[:limit] || options.fetch(:strategy, []).length
+      end
+
+      def validate!
+        validate_strategy!
+        validate_delay_multipliers!
+      end
+
+      private
+
+      attr_reader :options, :retry_limit
+
+      def validate_strategy!
+        unless options[:strategy]
+          raise InvalidConfigurationError, "You must define a backoff strategy"
+        end
+
+        return unless retry_limit
+
+        unless retry_limit > 0
+          raise InvalidConfigurationError,
+                "Exponential backoff cannot be used with infinite or no retries"
+        end
+
+        return if options[:strategy].length == retry_limit
+
+        raise InvalidConfigurationError, "Strategy must have a delay for each retry"
+      end
+
+      def validate_delay_multipliers!
+        unless both_or_neither_multiplier_supplied?
+          raise InvalidConfigurationError,
+                "If one of min/max_delay_multiplier is supplied, both are required"
+        end
+
+        return unless options[:min_delay_multiplier] && options[:max_delay_multiplier]
+
+        return if options[:min_delay_multiplier] <= options[:max_delay_multiplier]
+
+        raise InvalidConfigurationError,
+              "min_delay_multiplier must be less than or equal to max_delay_multiplier"
+      end
+
+      def both_or_neither_multiplier_supplied?
+        supplied = DELAY_MULTIPLIER_KEYS.map { |key| options.key?(key) }
+        supplied.none? || supplied.all?
+      end
+    end
+  end
+end

data/lib/active_job/retry/invalid_configuration_error.rb

@@ -0,0 +1,6 @@
+module ActiveJob
+  module Retry
+    class InvalidConfigurationError < StandardError
+    end
+  end
+end

data/lib/active_job/retry/options_validator.rb

@@ -0,0 +1,84 @@
+module ActiveJob
+  module Retry
+     class OptionsValidator
+      def initialize(options)
+        @options = options
+      end
+
+      def validate!
+        validate_limit!
+        validate_delay!
+        validate_fatal_exceptions!
+        validate_retry_exceptions!
+      end
+
+      private
+
+      attr_reader :options
+
+      # Limit must be an integer >= -1
+      # If it is -1 you *must* set `infinite_job: true` and understand that you're
+      # entering a world of pain and your ops team might hurt you.
+      def validate_limit!
+        return unless options[:limit]
+
+        unless options[:limit].is_a?(Fixnum)
+          raise InvalidConfigurationError, "Limit must be an integer"
+        end
+
+        raise InvalidConfigurationError, "Limit must be >= -1" if options[:limit] < -1
+
+        if options[:limit] == -1 && !options[:infinite_job]
+          raise InvalidConfigurationError,
+                "You must set `infinite_job: true` to use an infinite job"
+        end
+      end
+
+      # Delay must be non-negative
+      def validate_delay!
+        return unless options[:delay]
+
+        unless options[:delay] >= 0
+          raise InvalidConfigurationError, "Delay must be non-negative"
+        end
+      end
+
+      # Fatal exceptions must be an array (cannot be nil, since then all exceptions would
+      # be fatal - for that just set `limit: 0`)
+      def validate_fatal_exceptions!
+        return unless options[:fatal_exceptions]
+
+        unless options[:retry_exceptions].nil?
+          raise InvalidConfigurationError,
+                "fatal_exceptions and retry_exceptions cannot be used together"
+        end
+
+        unless options[:fatal_exceptions].is_a?(Array)
+          raise InvalidConfigurationError, "fatal_exceptions must be an array"
+        end
+
+        unless options[:fatal_exceptions].all? { |ex| ex.is_a?(Class) && ex <= Exception }
+          raise InvalidConfigurationError, "fatal_exceptions must be exceptions!"
+        end
+      end
+
+      # Retry exceptions must be an array of exceptions or `nil` to retry any exception
+      def validate_retry_exceptions!
+        return unless options[:retry_exceptions]
+
+        unless options[:fatal_exceptions].nil?
+          raise InvalidConfigurationError,
+                "retry_exceptions and fatal_exceptions cannot be used together"
+        end
+
+        unless options[:retry_exceptions].is_a?(Array)
+          raise InvalidConfigurationError, "retry_exceptions must be an array or nil"
+        end
+
+        unless options[:retry_exceptions].all? { |ex| ex.is_a?(Class) && ex <= Exception }
+          raise InvalidConfigurationError, "retry_exceptions must be exceptions!"
+        end
+      end
+    end
+  end
+end

data/lib/active_job/retry/version.rb

@@ -0,0 +1,5 @@
+module ActiveJob
+  module Retry
+    VERSION = "0.0.1"
+  end
+end

data/spec/retry_spec.rb

@@ -0,0 +1,228 @@
+require 'spec_helper'
+
+RSpec.describe ActiveJob::Retry do
+  subject(:job) { Class.new(ActiveJob::Base) { include ActiveJob::Retry } }
+
+  describe '.retry_with' do
+    context 'valid options' do
+      before { job.retry_with(options) }
+
+      context 'limit only' do
+        context 'infinite retries' do
+          let(:options) { { limit: -1, infinite_job: true } }
+          its(:retry_limit) { is_expected.to eq(-1) }
+        end
+
+        context 'no retries' do
+          let(:options) { { limit: 0 } }
+          its(:retry_limit) { is_expected.to eq(0) }
+        end
+
+        context 'some retries' do
+          let(:options) { { limit: 3 } }
+          its(:retry_limit) { is_expected.to eq(3) }
+        end
+      end
+
+      context 'delay only' do
+        let(:options) { { delay: 0 } }
+        its(:retry_delay) { is_expected.to eq(0) }
+      end
+
+      context 'fatal exceptions' do
+        let(:options) { { fatal_exceptions: [RuntimeError] } }
+        its(:fatal_exceptions) { is_expected.to eq([RuntimeError]) }
+      end
+
+      context 'retry exceptions' do
+        let(:options) { { retry_exceptions: [StandardError, NoMethodError] } }
+        its(:retry_exceptions) { is_expected.to eq([StandardError, NoMethodError]) }
+      end
+
+      context 'multiple options' do
+        let(:options) { { limit: 3, delay: 10, retry_exceptions: [RuntimeError] } }
+
+        its(:retry_limit) { is_expected.to eq(3) }
+        its(:retry_delay) { is_expected.to eq(10) }
+        its(:retry_exceptions) { is_expected.to eq([RuntimeError]) }
+      end
+    end
+
+    context 'invalid options' do
+      subject { -> { job.retry_with(options) } }
+
+      context 'bad limit' do
+        let(:options) { { limit: -2 } }
+        it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+      end
+
+      context 'accidental infinite limit' do
+        let(:options) { { limit: -1 } }
+        it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+      end
+
+      context 'bad delay' do
+        let(:options) { { delay: -1 } }
+        it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+      end
+
+      context 'bad fatal exceptions' do
+        let(:options) { { fatal_exceptions: ['StandardError'] } }
+        it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+      end
+
+      context 'bad retry exceptions' do
+        let(:options) { { retry_exceptions: [:runtime] } }
+        it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+      end
+
+      context 'retry and fatal exceptions together' do
+        let(:options) { { fatal_exceptions: [StandardError], retry_exceptions: [] } }
+        it { is_expected.to raise_error(ActiveJob::Retry::InvalidConfigurationError) }
+      end
+    end
+  end
+
+  describe '.retry_exception?' do
+    subject { job.retry_exception?(exception) }
+
+    context 'defaults (retry everything)' do
+      context 'Exception' do
+        let(:exception) { Exception.new }
+        it { is_expected.to be_truthy }
+      end
+
+      context 'RuntimeError' do
+        let(:exception) { RuntimeError.new }
+        it { is_expected.to be_truthy }
+      end
+
+      context 'InvalidConfigurationError' do
+        let(:exception) { ActiveJob::Retry::InvalidConfigurationError.new }
+        it { is_expected.to be_truthy }
+      end
+    end
+
+    context 'with whitelist' do
+      before { job.retry_with(retry_exceptions: [RuntimeError]) }
+
+      context 'Exception' do
+        let(:exception) { Exception.new }
+        it { is_expected.to be_falsey }
+      end
+
+      context 'RuntimeError' do
+        let(:exception) { RuntimeError.new }
+        it { is_expected.to be_truthy }
+      end
+
+      context 'subclass of RuntimeError' do
+        let(:exception) { Class.new(RuntimeError).new }
+        it { is_expected.to be_truthy }
+      end
+    end
+
+    context 'with blacklist' do
+      before { job.retry_with(fatal_exceptions: [RuntimeError]) }
+
+      context 'Exception' do
+        let(:exception) { Exception.new }
+        it { is_expected.to be_truthy }
+      end
+
+      context 'RuntimeError' do
+        let(:exception) { RuntimeError.new }
+        it { is_expected.to be_falsey }
+      end
+
+      context 'subclass of RuntimeError' do
+        let(:exception) { Class.new(RuntimeError).new }
+        it { is_expected.to be_falsey }
+      end
+    end
+  end
+
+  describe '#retry_limit_reached?' do
+    let(:instance) { job.tap { |job| job.retry_with(options) }.new }
+    subject { instance.retry_limit_reached? }
+
+    context 'when the limit is infinite' do
+      let(:options) { { limit: -1, infinite_job: true } }
+
+      context 'first attempt' do
+        before { instance.instance_variable_set(:@retry_attempt, 1) }
+        it { is_expected.to be_falsey }
+      end
+
+      context '99999th attempt' do
+        before { instance.instance_variable_set(:@retry_attempt, 99999) }
+        it { is_expected.to be_falsey }
+      end
+    end
+
+    context 'when the limit is 0' do
+      let(:options) { { limit: 0 } }
+
+      context 'first attempt' do
+        before { instance.instance_variable_set(:@retry_attempt, 1) }
+        it { is_expected.to be_truthy }
+      end
+
+      context '99999th attempt' do
+        before { instance.instance_variable_set(:@retry_attempt, 99999) }
+        it { is_expected.to be_truthy }
+      end
+    end
+
+    context 'when the limit is 5' do
+      let(:options) { { limit: 5 } }
+
+      context 'first attempt' do
+        before { instance.instance_variable_set(:@retry_attempt, 1) }
+        it { is_expected.to be_falsey }
+      end
+
+      context '4th attempt' do
+        before { instance.instance_variable_set(:@retry_attempt, 4) }
+        it { is_expected.to be_falsey }
+      end
+
+      context '5th attempt' do
+        before { instance.instance_variable_set(:@retry_attempt, 5) }
+        it { is_expected.to be_truthy }
+      end
+    end
+  end
+
+  describe '#retry_or_reraise' do
+    let(:instance) { job.new }
+    let(:exception) { RuntimeError.new }
+    subject(:retry_or_reraise) { instance.retry_or_reraise(exception) }
+
+    context 'when we should not retry' do
+      before do
+        allow(instance).to receive(:should_retry?).with(exception).and_return(false)
+      end
+
+      specify { expect { retry_or_reraise }.to raise_error(exception) }
+    end
+
+    context 'when we should retry' do
+      before do
+        allow(instance).to receive(:should_retry?).with(exception).and_return(true)
+        allow(instance).to receive(:retry_job).and_return(true)
+      end
+
+      it 'logs the retry' do
+        expect(ActiveJob::Base.logger).to receive(:log).
+          with(Logger::INFO, 'Retrying (attempt 1)')
+        retry_or_reraise
+      end
+
+      it 'retries the job' do
+        expect(instance).to receive(:retry_job).with(wait: 0)
+        retry_or_reraise
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'active_job-retry'
+require 'rspec/its'
+require 'pry'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.disable_monkey_patching!
+
+  config.warnings = true
+
+  # config.profile_examples = 10
+
+  config.order = :random
+
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: activejob-retry
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Isaac Seymour
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+      activejob-retry provides a simple DSL for automatically retrying ActiveJobs when they
+      fail, with exponential backoff.
+
+      Features:
+
+      * (Should) work with any queue adapter that supports retries.
+      * Whitelist/blacklist exceptions to retry on.
+      * Exponential backoff (varying the delay between retries).
+      * Light and easy to override retry logic.
+email:
+- isaac@isaacseymour.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- activejob-retry.gemspec
+- lib/active_job-retry.rb
+- lib/active_job/retry.rb
+- lib/active_job/retry/deserialize_monkey_patch.rb
+- lib/active_job/retry/exponential_backoff.rb
+- lib/active_job/retry/exponential_options_validator.rb
+- lib/active_job/retry/invalid_configuration_error.rb
+- lib/active_job/retry/options_validator.rb
+- lib/active_job/retry/version.rb
+- spec/retry_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/isaacseymour/activejob-retry
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: Automatic retrying DSL for ActiveJob
+test_files: []
+has_rdoc: false