resque-retry 1.7.3 → 1.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 215fb485738158bbc70e52dc3cfb8ffe0f506cea4eea5000c63bfd0112e1e1ad
-  data.tar.gz: d3de2dc53f2d491ef38327723c72fe0fe393caeb611887037128345f1a782a36
+  metadata.gz: ab175830aa9de0d24e514a8bd054b1ebe8a2924ba134fd975013685e84828b9d
+  data.tar.gz: a6cb49fb45375e4a82a8811e126f428de4acda1248d7b6cc6de5df6d9b6340bf
 SHA512:
-  metadata.gz: d3e70d04e8248d787febc0fa2abbf1b2d61b29daca52eb43348beafda614acd0498bd93fd52a3b53f10d9010e1d2f180a7689ca0a36a4b2aada5478105140774
-  data.tar.gz: 1756af428ee66d0538fc8c428929408098add0f820506881fe295022069465ae624d96263dbaf6dff154c15711e1dd57a54363c927a3f2a240ff7e118f6f356b
+  metadata.gz: f4176df779bbc212e25d64190ae7680ee410beebb663d6b502f45fd73532b14fa4ed9f86dc76e74474dd757247b45b0a8503037a6154c814ffad159dec22413a
+  data.tar.gz: 2109a5558025ff2d7b5b8e1cd952242aad11641b11b1036332d2f68111c1d6ca5f9de402ec92376aedff37d6dff534bed0e017196e85f451b976e405168a71da

data/HISTORY.md

@@ -1,3 +1,8 @@
+# 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

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/version.rb

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

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

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/test_jobs.rb

@@ -254,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
@@ -576,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.7.3
+  version: 1.7.4
 platform: ruby
 authors:
 - Luke Antins
 - Ryan Carver
 - Jonathan W. Zaleski
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-11-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.6
-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.