resque-retry 1.6.0 → 1.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18f7b00c3922adebe816efc0357bfba5925dddc5ae85bea9d4b69e0a05e9fb46
-  data.tar.gz: dd4d14d570a628aa667445cd4f64929ecc0bcab22bc536b164bc9e9437574a59
+  metadata.gz: ab175830aa9de0d24e514a8bd054b1ebe8a2924ba134fd975013685e84828b9d
+  data.tar.gz: a6cb49fb45375e4a82a8811e126f428de4acda1248d7b6cc6de5df6d9b6340bf
 SHA512:
-  metadata.gz: ffab51ba83437149d5bc39400983e436a38cd4e2d200b7562fa892f16f6facf1310a0dcf666030d8181aec5424dbcd80c146983ce25b3579f7e9a4088692dc8f
-  data.tar.gz: dcef4495dfc111270f16bb02dafa72d1fb66caebe4302dbb0359aad2dcaf72f29c887cc7e0caa22c3ef012aba5813933fb19c1c210b597bea17b6ab4ab561ff6
+  metadata.gz: f4176df779bbc212e25d64190ae7680ee410beebb663d6b502f45fd73532b14fa4ed9f86dc76e74474dd757247b45b0a8503037a6154c814ffad159dec22413a
+  data.tar.gz: 2109a5558025ff2d7b5b8e1cd952242aad11641b11b1036332d2f68111c1d6ca5f9de402ec92376aedff37d6dff534bed0e017196e85f451b976e405168a71da

data/HISTORY.md

@@ -1,11 +1,41 @@
+# 1.7.4 (2020-10-09)
+
+* Rework how the default `retry_limit` is calculated
+* Numerous documentation updates
+
+# 1.7.3 (2019-11-21)
+
+* Do not crash if job class is not found on the resque-web server
+
+# 1.7.2 (2019-11-21)
+
+* Address part 2 of issue #158
+
+# 1.7.1 (2019-07-10)
+
+* Prevent `NoMethodError` when calculating `retry_delay`
+
+# 1.7.0 (2019-06-15)
+
+!!! [Potential] breaking changes -- details below !!!
+
+* Remove support for `args_for_retry` -- it has been deprecated for almost 5
+  years
+* Work w/ shallow-clone(s) of `args` in `MultipleWithRetrySuppression#save` and
+  `Retry.retry_args`
+* Remove deprecated options from `Gem::Specification`
+* Clean-up formatting in HISTORY.md
+
 # 1.6.0 (2019-04-21)
 
-* Clean-up / refactoring in preparation for a release (`ruby` deprecations, etc.)
+* Clean-up / refactoring in preparation for a release (`ruby` deprecations,
+  etc.)
 * Loosen version requirement to allow resque v2.0 and up (@peret)
 
 # 1.5.3 (2018-11-26)
 
-* Monkey patch in the `requeue_queue` method onto the `Resque::Failure` backend (this _should_ be a temporary fix)
+* Monkey patch in the `requeue_queue` method onto the `Resque::Failure` backend
+  (this _should_ be a temporary fix)
 
 # 1.5.2 (2018-07-16)
 
@@ -14,11 +44,15 @@
 
 # 1.5.1 (2018-01-07)
 
-* Added build support for `ruby-2.2.x`, `ruby-2.3.x`, `ruby-2.4.x` and `ruby-2.5.x`
-* Dropped build support for `ruby-1.9.3` and `ruby-2.0.0` (these versions are no unsupported)
+* Added build support for `ruby-2.2.x`, `ruby-2.3.x`, `ruby-2.4.x` and
+  `ruby-2.5.x`
+* Dropped build support for `ruby-1.9.3` and `ruby-2.0.0` (these versions are
+  no unsupported)
 * Fix some deprecation warnings in tests
-* Feature: If no exact exception class is present in `@retry_exceptions` hash, try to find closest superclass (@fanfilmu)
-* Feature: When running Resque inline, explicitly don't try to retry, don't touch Redis (@michaelglass)
+* Feature: If no exact exception class is present in `@retry_exceptions` hash,
+  try to find closest superclass (@fanfilmu)
+* Feature: When running Resque inline, explicitly don't try to retry, don't
+  touch Redis (@michaelglass)
 
 # 1.5.0 (2015-10-24)
 
@@ -40,25 +74,35 @@
 ## 1.3.0 (2014-07-25)
 
 * Adjust gem dependency on `resque-scheduler` to ~> 3.0
-* Deprecated: `args_for_retry` in favor of `retry_args` (will output deprecation warnings if your using the older method).
-* Feature: Allow changing the args for a given exception using `retry_args_for_exception` (@jonp)
+* Deprecated: `args_for_retry` in favor of `retry_args` (will output deprecation
+  warnings if your using the older method).
+* Feature: Allow changing the args for a given exception using
+  `retry_args_for_exception` (@jonp)
 * Feature: Allow setting `@expire_retry_key_after` on the fly (@orenmazor)
 
 ## 1.2.1 (2014-06-09)
 
-* Fixed Kernel.rand: "invalid argument - 0.0 (ArgumentError)" error with "ExponentialBackoff" (on "Rubinius") when `retry_delay_multiplicand_min` and `retry_delay_multiplicand_max` were the same value (@saizai)
+* Fixed Kernel.rand: "invalid argument - 0.0 (ArgumentError)" error with
+  "ExponentialBackoff" (on "Rubinius") when `retry_delay_multiplicand_min` and
+  `retry_delay_multiplicand_max` were the same value (@saizai)
 
 ## 1.2.0 (2014-05-19)
 
-* Fixed scenario where job does not get retried correctly when `perform` is not called as expected.
-* Feature: Optional `@expire_retry_key_after` settings; expires retry counters from redis to save you cleaning up stale state.
-* Feature: Expose inner-workings of plugin through debug messages using `Resque.logger` (when logging level is Logger:DEBUG).
+* Fixed scenario where job does not get retried correctly when `perform` is not
+  called as expected.
+* Feature: Optional `@expire_retry_key_after` settings; expires retry counters
+  from redis to save you cleaning up stale state.
+* Feature: Expose inner-workings of plugin through debug messages using
+  `Resque.logger` (when logging level is Logger:DEBUG).
 
 ## 1.1.4 (2014-03-17)
 
-* Fixed displaying retry information in resque web interface, caused by `Resque::Helpers` being deprecated.
-* Feature: Allow `@fatal_exceptions` as inverse of `@retry_exceptions`, when fatal exception is raised the job will be immediately fail.
-* Feature: Allow a random retry delay (within a range) when using exponential backoff strategy.
+* Fixed displaying retry information in resque web interface, caused by
+  `Resque::Helpers` being deprecated.
+* Feature: Allow `@fatal_exceptions` as inverse of `@retry_exceptions`, when
+  a fatal exception is raised the job will be immediately fail.
+* Feature: Allow a random retry delay (within a range) when using exponential
+  backoff strategy.
 
 ## 1.1.1 (2014-03-12)
 
@@ -67,7 +111,8 @@
 ## 1.1.0 (2014-03-12)
 
 * Remove dependence on `Resque::Helpers`, will be removed in Resque 2.0
-* Use SHA1 for default `#retry_identifier` to prevents issues with long args gobbling space.
+* Use SHA1 for default `#retry_identifier` to prevents issues with long args
+  gobbling space.
 * Minimum version of Resque is now ~> 1.25
 
 ## 1.0.0 (2012-09-07)
@@ -75,12 +120,16 @@
 ** !!! WARNING !!! INCLUDES NON-BACKWARDS COMPATIBLE CHANGES **
 
 * Fixed issues related to infinite job retries and v1.20.0 of resque.
-* Minimum gem dependency versions changed: resque >= 1.10.0, resque-scheduler >= 1.9.9
-* Feature: Setting `@retry_job_delegate` allows you to separate the original job from a the retry job. (@tanob/@jniesen)
-* Web interface will work without needing to `require` your job code. (n.b. less details available via web).
+* Minimum gem dependency versions changed: resque >= 1.10.0, resque-scheduler
+  >= 1.9.9
+* Feature: Setting `@retry_job_delegate` allows you to separate the original job
+  from a the retry job. (@tanob/@jniesen)
+* Web interface will work without needing to `require` your job code. (n.b.
+  less details available via web).
 * IMPORTANT: `#identifier` method has been namespaced to `#retry_identifier`.
 * Bugfix: `Remove` button on retry web interface was not working.
-* Feature: Allow `tagging` exceptions with a module instead of an exception class. (@tils - Tilmann Singer)
+* Feature: Allow `tagging` exceptions with a module instead of an exception
+  class. (@tils - Tilmann Singer)
 
 ## 0.2.2 (2011-12-08)
 
@@ -88,7 +137,8 @@
 
 ## 0.2.1 (2011-11-23)
 
-* Bugfix: Fixed error when we tried to parse a number/string as JSON on the reque-retry web interface.
+* Bugfix: Fixed error when we tried to parse a number/string as JSON on the
+  reque-retry web interface.
 
 ## 0.2.0 (2011-11-22)
 
@@ -98,9 +148,10 @@
     PREVIOUSLY: 0 == infinite retries.
            NOW: -1 == infinite retries; 0 == means never retry.
 
-* Bugfix: `#redis_retry_key` incorrectly built key when custom identifier was used. (Bogdan Gusiev)
+* Bugfix: `#redis_retry_key` incorrectly built key when custom identifier was
+  used. (Bogdan Gusiev)
 * Feature: Ability to sleep worker after re-queuing a job, may be used to bias
-           against the same worker from picking up the job again. (Michael Keirnan)
+  against the same worker from picking up the job again. (Michael Keirnan)
 * Feature: Ability to remove retry jobs using resque-web. (Thiago Morello)
 * Added example demo application.
 * Added Bundler `Gemfile`.
@@ -130,7 +181,8 @@
 ## 0.0.2 (2010-05-06)
 
 * Bugfix: Were calling non-existent method to delete redis key.
-* Delay no-longer falls back to `sleep`. resque-scheduler is a required dependancy.
+* Delay no-longer falls back to `sleep`. resque-scheduler is a required
+  dependancy.
 * Redis key doesn't include ending colon `:` if no args were passed to the job.
 
 ## 0.0.1 (2010-04-27)

data/README.md

@@ -231,8 +231,8 @@ class ExampleJob
   extend Resque::Plugins::Retry
   @queue = :testing
 
-  def self.retry_delay(exception)
-    if exception == SocketError
+  def self.retry_delay(exception_class)
+    if exception_class == SocketError
       10
     else
       1
@@ -359,7 +359,12 @@ You may also want to specify different retry delays for different exception
 types. You may optionally set `@retry_exceptions` to a hash where the keys are
 your specific exception classes to retry on, and the values are your retry
 delays in seconds or an array of retry delays to be used similar to exponential
-backoff.
+backoff.  `resque-retry` will attempt to determine your retry strategy's
+`@retry_limit` based on your specified `@retry_exceptions`.  If, however, you
+define `@retry_limit` explicitly, you should define `@retry_limit` such that it
+allows for your retry strategies to complete.  If your `@retry_limit` is less
+than the number of desired retry attempts defined in `@retry_exceptions`, your
+job will only retry `@retry_limit` times.
 ```ruby
 class DeliverSMS
   extend Resque::Plugins::Retry
@@ -374,9 +379,15 @@ end
 ```
 
 In the above example, Resque would retry any `DeliverSMS` jobs which throw a
-`NetworkError` or `SystemCallError`. If the job throws a `NetworkError` it
-will be retried 30 seconds later, if it throws `SystemCallError` it will first
-retry 120 seconds later then subsequent retry attempts 240 seconds later.
+`NetworkError` or `SystemCallError`. The `@retry_limit` would be inferred to be
+2 based on the longest retry strategy defined in `@retry_exceptions`. If the job
+throws a `NetworkError` it will be retried 30 seconds later with a subsequent
+retry 30 seconds after that. If it throws a `SystemCallError` it will first
+retry 120 seconds later then a subsequent retry attempt 240 seconds later.  If
+the job fails due to a `NetworkError`, Resque would retry the job in 30 seconds.
+If the job fails a second time, this time due to a `SystemCallError`, the next
+retry would occur 240 seconds later as specified in the `SystemCallError`
+array defined in `@retry_exceptions`.
 
 ### <a name="fail_fast"></a> Fail Fast For Specific Exceptions
 
@@ -511,7 +522,7 @@ class ExampleJob
 
   def self.work(*args)
     user_id, user_mode, record_id = *args
-    
+
     Resque.enqueue_to(
       target_queue_for_args(user_id, user_mode, record_id),
       self,
@@ -531,7 +542,7 @@ class ExampleJob
     user_id, user_mode, record_id = *args
 
     if user_mode
-      'high
+      'high'
     else
       'low'
     end
@@ -585,7 +596,7 @@ end
 
 This saves you from having to run a "house cleaning" or "errand" job.
 
-The expiary timeout is "pushed forward" or "touched" after each failure to
+The expiry timeout is "pushed forward" or "touched" after each failure to
 ensure it's not expired too soon.
 
 ### <a name="callbacks"></a> Try Again and Give Up Callbacks

data/lib/resque-retry/server.rb

@@ -66,15 +66,23 @@ module ResqueRetry
       # cancels job retry
       def cancel_retry(job)
         klass = get_class(job)
-        retry_key = retry_key_for_job(job)
-        Resque.remove_delayed(klass, *job['args'])
-        Resque.redis.del("failure-#{retry_key}")
-        Resque.redis.del(retry_key)
+        if klass
+          retry_key = retry_key_for_job(job)
+          Resque.remove_delayed(klass, *job['args'])
+          Resque.redis.del("failure-#{retry_key}")
+          Resque.redis.del(retry_key)
+        else
+          raise 'cannot cancel, job not found'
+        end
       end
 
       private
       def get_class(job)
-        Resque::Job.new(nil, nil).constantize(job['class'])
+        begin
+          Resque::Job.new(nil, nil).constantize(job['class'])
+        rescue
+          nil
+        end
       end
     end
 

data/lib/resque-retry/version.rb

@@ -1,3 +1,3 @@
 module ResqueRetry
-  VERSION = '1.6.0'
+  VERSION = '1.7.4'
 end

data/lib/resque/failure/multiple_with_retry_suppression.rb

@@ -27,7 +27,9 @@ module Resque
       #
       # @api private
       def save
-        log_message 'failure backend save', args_from(payload), exception
+        args = args_from(payload)
+
+        log_message 'failure backend save', args, exception
 
         retryable = retryable?
         job_being_retried = retryable && retrying?
@@ -35,7 +37,7 @@ module Resque
         if !job_being_retried
           log_message(
             "#{retryable ? '' : 'non-'}retryable job is not being retried - sending failure to superclass",
-            args_from(payload),
+            args,
             exception
           )
 
@@ -44,7 +46,7 @@ module Resque
         elsif retry_delay > 0
           log_message(
             "retry_delay: #{retry_delay} > 0 - saving details in Redis",
-            args_from(payload),
+            args,
             exception
           )
 
@@ -67,7 +69,7 @@ module Resque
         else
           log_message(
             "retry_delay: #{retry_delay} <= 0 - ignoring",
-            args_from(payload),
+            args,
             exception
           )
         end
@@ -100,7 +102,7 @@ module Resque
       protected
 
       def args_from(payload)
-        (payload || {})['args']
+        (payload || {})['args'].dup
       end
 
       def cleanup_retry_failure_log!

data/lib/resque/plugins/exponential_backoff.rb

@@ -80,10 +80,11 @@ module Resque
 
       # Selects the delay from the backoff strategy
       #
+      # @param _ [Exception] unused exception argument for signature parity
       # @return [Number] seconds to delay until the next retry.
       #
       # @api private
-      def retry_delay
+      def retry_delay(_ = nil)
         delay = backoff_strategy[retry_attempt] || backoff_strategy.last
         # if the values are the same don't bother generating a random number, if
         # the delta is zero, some platforms will raise an error

data/lib/resque/plugins/retry.rb

@@ -107,11 +107,27 @@ module Resque
       # A retry limit of 0 will *never* retry.
       # A retry limit of -1 or below will retry forever.
       #
+      # The default value is: `1` or in the case of where `@retry_exceptions` is
+      # specified, and it contains one or more `Array` values, the maximum
+      # length will be used (e.g. `@retry_exceptions = { NetworkError => 30, SystemCallError => [120, 240] }`
+      # would return `2` because `SystemCallError` _should_ be attempted at
+      # least twice to respect the specified configuration).
+      #
       # @return [Fixnum]
       #
       # @api public
       def retry_limit
-        @retry_limit ||= 1
+        @retry_limit ||= begin
+          default_retry_limit = 1
+          if instance_variable_defined?(:@retry_exceptions) && @retry_exceptions.is_a?(Hash)
+            @retry_exceptions.values.each do |value|
+              if value.is_a?(Array) && value.length > default_retry_limit
+                default_retry_limit = value.length
+              end
+            end
+          end
+          default_retry_limit
+        end
       end
 
       # Number of retry attempts used to try and perform the job
@@ -135,9 +151,13 @@ module Resque
       #
       # @api public
       def retry_delay(exception_class = nil)
-        if instance_variable_defined?(:@retry_exceptions) && @retry_exceptions.is_a?(Hash)
+        if \
+          !exception_class.nil? && \
+          instance_variable_defined?(:@retry_exceptions) && \
+          @retry_exceptions.is_a?(Hash)
           delay = @retry_exceptions[exception_class] ||= begin
-            relevant_definitions = @retry_exceptions.select { |ex| exception_class <= ex }
+            relevant_definitions = \
+              @retry_exceptions.select { |ex| exception_class <= ex }
             relevant_definitions.any? ? relevant_definitions.sort.first[1] : 0
           end
           # allow an array of delays.
@@ -186,15 +206,7 @@ module Resque
       #
       # @api public
       def retry_args(*args)
-        # Here for backwards compatibility. If an "args_for_retry" method exists
-        # invoke it, but warn that it is deprecated (and will be removed in a
-        # future revision)
-        if respond_to?(:args_for_retry)
-          warn "`Resque::Plugins::Retry#args_for_retry` is deprecated, please use `Resque::Plugins::Retry#retry_args` instead."
-          args_for_retry(*args)
-        else
-          args
-        end
+        args.dup
       end
 
       # @abstract
@@ -460,7 +472,8 @@ module Resque
         # set/update the "retry_key" expiration
         if expire_retry_key_after
           log_message "updating expiration for retry key: #{retry_key}", args
-          Resque.redis.expire(retry_key, retry_delay + expire_retry_key_after)
+          exception_class = Object.const_get(args[0]) rescue nil
+          Resque.redis.expire(retry_key, retry_delay(exception_class) + expire_retry_key_after)
         end
       end
 

data/resque-retry.gemspec

@@ -25,7 +25,6 @@ Gem::Specification.new do |s|
   s.homepage = 'http://github.com/lantins/resque-retry'
   s.license = 'MIT'
 
-  s.has_rdoc = false
   s.files = `git ls-files`.split($/)
   s.require_paths = %w[lib]
 

data/test/exponential_backoff_test.rb

@@ -128,4 +128,11 @@ class ExponentialBackoffTest < Minitest::Test
     assert_equal 4, Resque.info[:failed],     'failed jobs'
     assert_equal 0, Resque.info[:pending],    'pending jobs'
   end
+
+  def test_backoff_with_expiration
+    Resque.redis.expects(:expire)
+
+    Resque.enqueue(ExponentialBackoffWithExpiryJob)
+    perform_next_job(@worker)
+  end
 end

data/test/retry_exception_delay_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class RetryExeptionDelayTest < Minitest::Test
+class RetryExceptionDelayTest < Minitest::Test
   def setup
     Resque.redis.flushall
     @worker = Resque::Worker.new(:testing)
@@ -43,4 +43,12 @@ class RetryExeptionDelayTest < Minitest::Test
     assert_in_delta (start_time + 10), delayed[1], 1.00, '2nd retry delay timestamp'
     assert_in_delta (start_time + 15), delayed[2], 1.00, '3rd retry delay timestamp'
   end
+
+  def test_retry_delay_per_exception_multiple_delay_no_retry_limit_specified
+    # For this job-type there are 3 `Exception` types defined: `Exception`,
+    # `StandardError` and `Timeout::Error` -- their array-lengths are are 1, 3
+    # and 5 (respectively). We expect the `retry_limit` to default to the
+    # maximum length of the `Array` of delays or 1 (in this case: 5)
+    assert_equal 5, PerExceptionClassRetryCountArrayNoRetryLimitSpecifiedJob.retry_limit
+  end
 end

data/test/retry_test.rb

@@ -55,13 +55,6 @@ class RetryTest < Minitest::Test
     assert_equal test_args, job['args']
   end
 
-  def test_job_args_can_be_modified_by_overriding_args_for_retry
-    Resque.enqueue(DeprecatedRetryWithModifiedArgsJob)
-    DeprecatedRetryWithModifiedArgsJob.expects(:warn)
-    DeprecatedRetryWithModifiedArgsJob.expects(:args_for_retry)
-    perform_next_job(@worker)
-  end
-
   def test_job_args_can_be_modified_by_overriding_retry_args
     Resque.enqueue(RetryWithModifiedArgsJob)
     RetryWithModifiedArgsJob.expects(:retry_args)
@@ -278,6 +271,7 @@ class RetryTest < Minitest::Test
   end
 
   def test_retry_delay
+    assert_equal 0, NoRetryDelayJob.retry_delay
     assert_equal 3, NormalRetryCountJob.retry_delay
     assert_equal 7, PerExceptionClassRetryCountJob.retry_delay(StandardError)
     assert_equal 7, PerExceptionClassRetryCountJob.retry_delay(CustomException)
@@ -293,6 +287,12 @@ class RetryTest < Minitest::Test
     perform_next_job(@worker)
   end
 
+  def test_expire_key_set_with_retry_exceptions
+    Resque.redis.expects(:expire).once.with(ExpiringJobWithRetryExceptions.redis_retry_key(StandardError), 17)
+    Resque.enqueue(ExpiringJobWithRetryExceptions, StandardError)
+    perform_next_job(@worker)
+  end
+
   def test_expire_key_setting_on_the_fly
     retry_key = 'resque-retry:FailFiveTimesWithCustomExpiryJob'
 

data/test/test_jobs.rb

@@ -7,7 +7,7 @@ class NoRetryJob
   @queue = :testing
 
   def self.perform(*args)
-    raise "error"
+    raise 'error'
   end
 end
 
@@ -28,6 +28,17 @@ class ExpiringJob
   end
 end
 
+class ExpiringJobWithRetryExceptions
+  extend Resque::Plugins::Retry
+
+  @queue = :testing
+  @expire_retry_key_after = 10
+  @retry_exceptions = { StandardError => 7 }
+
+  def self.perform(*args)
+  end
+end
+
 class RetryDefaultSettingsJob
   extend Resque::Plugins::Retry
   @queue = :testing
@@ -146,14 +157,6 @@ class InheritTestWithMoreExtraJob < InheritTestWithExtraJob
   end
 end
 
-class DeprecatedRetryWithModifiedArgsJob < RetryDefaultsJob
-  @queue = :testing
-
-  def self.args_for_retry(*args)
-    # NOTE: implementation is irrelevant we only care that it's invoked
-  end
-end
-
 class RetryWithModifiedArgsJob < RetryDefaultsJob
   @queue = :testing
 
@@ -251,6 +254,12 @@ class ExponentialBackoffWithRetryDelayMultiplicandMinAndMaxJob < RetryDefaultsJo
   @retry_delay_multiplicand_max = 3.0
 end
 
+class ExponentialBackoffWithExpiryJob < RetryDefaultsJob
+  extend Resque::Plugins::ExponentialBackoff
+  @queue = :testing
+  @expire_retry_key_after = 60 * 60
+end
+
 class InvalidRetryDelayMaxConfigurationJob
   @queue = :testing
   @retry_delay_multiplicand_max = 0.9
@@ -534,6 +543,13 @@ class CustomRetryIdentifierFailingJob
   end
 end
 
+class NoRetryDelayJob
+  extend Resque::Plugins::Retry
+
+  @queue = :testing
+  @retry_exceptions = {}
+end
+
 class NormalRetryCountJob
   extend Resque::Plugins::Retry
 
@@ -566,6 +582,17 @@ class PerExceptionClassRetryCountArrayJob
   end
 end
 
+class PerExceptionClassRetryCountArrayNoRetryLimitSpecifiedJob
+  extend Resque::Plugins::Retry
+
+  @queue = :testing
+  @retry_exceptions = { Exception => 11, RuntimeError => [5, 10, 15],  Timeout::Error => [2, 4, 6, 8, 10] }
+
+  def self.perform
+    raise RuntimeError, 'I always fail with a RuntimeError'
+  end
+end
+
 # We can't design a job to fail during connect, see perform_next_job_fail_on_reconnect
 class FailsDuringConnectJob < RetryDefaultsJob
   @queue = :testing

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: resque-retry
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.4
 platform: ruby
 authors:
 - Luke Antins
 - Ryan Carver
 - Jonathan W. Zaleski
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-04-21 00:00:00.000000000 Z
+date: 2020-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
@@ -208,7 +208,7 @@ homepage: http://github.com/lantins/resque-retry
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -223,8 +223,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: A resque plugin; provides retry, delay and exponential backoff support for
   resque jobs.