sidekiq-rescue 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f373ccbd6c038182766f55cd0d2091eb3052c2a008827b223aa9293728d41268
-  data.tar.gz: d6b8c96d73cb0690446be1b8330eda3f805a63f386d1778d5a1682d70e379037
+  metadata.gz: 237d80187eecb22c8b7ef0d4f15ff93e2c728b024ea01119dae161ac7d75385d
+  data.tar.gz: 8861871097ab632c21ee355dc9ce4ef56700ea1088a19be504295374e6a9636b
 SHA512:
-  metadata.gz: 967dd0e178742e6dd1df06f0e5382d2a07d889a18007db15c7202f2725954c29916a866b182b1823e35fe24ad5252df791201e26045c456272ac74b36f1c82c8
-  data.tar.gz: 6ce5d97588e78c3cf1bd49e462a9af742bd7afa2fc25a5b6e798adc67a182e0d2236b8c24471d729de757a7cbb25d8544d7baac3e69d5fb01dec164fb72c34a8
+  metadata.gz: 543e8549fb9c61be288bd7cabe436d4e26d80db094a78661996f053861d474aef955efa8ea0448d06122cf78e7350ef2edb2f1fb5a322d37cd05673a3ab02acd
+  data.tar.gz: '09d8d2bb966fcb827376c88dc11e1c1c11bf9773d207ed064df9bd69b2e35bc6a02a3847aabf920ad08f4f4ae4f59254b7621332956c170289a1d580a809159f'

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 ## [Unreleased]
 
+## [0.5.0] - 2024-10-17
+- Add support for queue configuration [#5](https://github.com/moofkit/sidekiq-rescue/pull/5)
+
+## [0.4.0] - 2024-06-03
+- Add support for jitter configuration [#4](https://github.com/moofkit/sidekiq-rescue/pull/4)
+- Changes the strategy for retry delay. Now it's calculated using the formula `delay + delay * jitter * rand`
+
 ## [0.3.1] - 2024-05-30
 
 - Fix bug with inheritance of DSL options
@@ -7,7 +14,7 @@
 ## [0.3.0] - 2024-05-30
 
 - Fix issue with RSpec matcher when job is not rescueable
-- Add support for multiple invocations of the DSL #3
+- Add support for multiple invocations of the DSL
 - Update documentation with new features
 
 ## [0.2.1] - 2024-02-27
@@ -30,7 +37,9 @@
 - Add documentation
 - Add CI
 
-[Unreleased]: https://github.com/moofkit/sidekiq-rescue/compare/v0.3.1...HEAD
+[Unreleased]: https://github.com/moofkit/sidekiq-rescue/compare/v0.5.0...HEAD
+[0.5.0]: https://github.com/moofkit/sidekiq-rescue/releases/tag/v0.5.0
+[0.4.0]: https://github.com/moofkit/sidekiq-rescue/releases/tag/v0.4.0
 [0.3.1]: https://github.com/moofkit/sidekiq-rescue/releases/tag/v0.3.1
 [0.3.0]: https://github.com/moofkit/sidekiq-rescue/releases/tag/v0.3.0
 [0.2.1]: https://github.com/moofkit/sidekiq-rescue/releases/tag/v0.2.1

data/README.md

@@ -16,14 +16,16 @@ class MyJob
 
   sidekiq_rescue CustomAppException # defaults to 60 seconds delay and 10 retries
   sidekiq_rescue AnotherCustomAppException, delay: ->(counter) { counter * 2 }
-  sidekiq_rescue CustomInfrastructureException, delay: 5.minutes
-  sidekiq_rescue ActiveRecord::Deadlocked, delay: 5.seconds, limit: 3
+  sidekiq_rescue CustomInfrastructureException, delay: 5.minutes.to_i
+  sidekiq_rescue ActiveRecord::Deadlocked, delay: 5.seconds.to_i, limit: 3
+  sidekiq_rescue TooManyRequestsError, queue: "slow"
   sidekiq_rescue Net::OpenTimeout, Timeout::Error, limit: 10 # retries at most 10 times for Net::OpenTimeout and Timeout::Error combined
 
   def perform(*args)
     # Might raise CustomAppException, AnotherCustomAppException, or YetAnotherCustomAppException for something domain specific
     # Might raise ActiveRecord::Deadlocked when a local db deadlock is detected
     # Might raise Net::OpenTimeout or Timeout::Error when the remote service is down
+    # Might raise TooManyRequestsError when the rate limit is exceeded
   end
 end
 ```
@@ -74,14 +76,14 @@ end
 
 ## Configuration
 
-You can configure the number of retries and the delay (in seconds) between retries:
+You can configure the number of retries and the delay *in seconds* between retries:
 
 ```ruby
 class MyJob
   include Sidekiq::Job
   include Sidekiq::Rescue::Dsl
 
-  sidekiq_rescue ExpectedError, delay: 60, limit: 5
+  sidekiq_rescue ExpectedError, delay: 60, limit: 5, jitter: 0.15
 
   def perform(*)
     # ...
@@ -89,18 +91,25 @@ class MyJob
 end
 ```
 
-The `delay` is not the exact time between retries, but a minimum delay. The actual delay calculates based on retries counter and `delay` value. The formula is `delay + retries * rand(10)` seconds. Randomization is used to avoid retry storms.
+* `delay` - the delay between retries in seconds
+* `limit` - the number of retries. The number of attempts includes the original job execution.
+* `jitter` - represents the upper bound of possible wait time (expressed as a percentage) and defaults to 0.15 (15%)
+* `queue` - the queue to which the job will be enqueued if it fails
+
+The `delay` is not the exact time between retries, but a minimum delay. The actual delay calculates based on jitter and `delay` value. The formula is `delay + delay * jitter * rand` seconds. Randomization is used to avoid retry storms.
 
 The default values are:
 - `delay`: 60 seconds
 - `limit`: 5 retries
+- `jitter`: 0.15
 
-Delay and limit can be configured globally:
+Delay, limit and jitter can be configured globally:
 
 ```ruby
 Sidekiq::Rescue.configure do |config|
   config.delay = 65
   config.limit = 10
+  config.jitter = 0.2
 end
 ```
 

data/lib/sidekiq/rescue/config.rb

@@ -7,12 +7,14 @@ module Sidekiq
     class Config
       DEFAULTS = {
         delay: 60,
-        limit: 10
+        limit: 10,
+        jitter: 0.15
       }.freeze
 
       def initialize
         @delay = DEFAULTS[:delay]
         @limit = DEFAULTS[:limit]
+        @jitter = DEFAULTS[:jitter]
         @logger = Sidekiq.logger
       end
 
@@ -45,6 +47,22 @@ module Sidekiq
         @limit = limit
       end
 
+      # The jitter for the delay.
+      # @return [Integer, Float]
+      attr_reader :jitter
+
+      # @param jitter [Integer, Float] The jitter for the delay.
+      # @return [void]
+      # @raise [ArgumentError] if jitter is not an Integer or Float
+      def jitter=(jitter)
+        case jitter
+        when Integer, Float
+          @jitter = jitter
+        else
+          raise ArgumentError, "jitter must be Integer or Float"
+        end
+      end
+
       # The logger instance.
       # @return [Logger]
       # @note The default logger is Sidekiq's logger.

data/lib/sidekiq/rescue/dsl.rb

@@ -22,13 +22,20 @@ module Sidekiq
         # @raise [ArgumentError] if error is not an array of StandardError
         # @raise [ArgumentError] if delay is not an Integer or Float
         # @raise [ArgumentError] if limit is not an Integer
+        # @raise [ArgumentError] if jitter is not an Integer or Float
+        # @raise [ArgumentError] if queue is not a String
         # @example
         #  sidekiq_rescue NetworkError, delay: 60, limit: 10
-        def sidekiq_rescue(*errors, delay: Sidekiq::Rescue.config.delay, limit: Sidekiq::Rescue.config.limit)
+        def sidekiq_rescue(*errors, delay: Sidekiq::Rescue.config.delay, limit: Sidekiq::Rescue.config.limit,
+                           jitter: Sidekiq::Rescue.config.jitter, queue: nil)
           unpacked_errors = validate_and_unpack_error_argument(errors)
           validate_delay_argument(delay)
           validate_limit_argument(limit)
-          assign_sidekiq_rescue_options(unpacked_errors, delay, limit)
+          validate_jitter_argument(jitter)
+          validate_queue_argument(queue)
+          assign_sidekiq_rescue_options(
+            errors: unpacked_errors, delay: delay, limit: limit, jitter: jitter, queue: queue
+          )
         end
 
         # Find the error group and options for the given exception.
@@ -51,7 +58,6 @@ module Sidekiq
         end
 
         def validate_delay_argument(delay)
-          return if delay.nil?
           return if delay.is_a?(Integer) || delay.is_a?(Float)
 
           if delay.is_a?(Proc)
@@ -68,9 +74,25 @@ module Sidekiq
           raise ArgumentError, "limit must be integer" if limit && !limit.is_a?(Integer)
         end
 
-        def assign_sidekiq_rescue_options(errors, delay, limit)
+        def validate_jitter_argument(jitter)
+          return if jitter.is_a?(Integer) || jitter.is_a?(Float)
+
+          raise ArgumentError,
+                "jitter must be integer or float"
+        end
+
+        def validate_queue_argument(queue)
+          return if queue.nil? || queue.is_a?(String)
+
+          raise ArgumentError,
+                "queue must be a string"
+        end
+
+        def assign_sidekiq_rescue_options(errors:, delay:, limit:, jitter:, queue:)
           self.sidekiq_rescue_options ||= {}
-          self.sidekiq_rescue_options = self.sidekiq_rescue_options.merge(errors => { delay: delay, limit: limit })
+          self.sidekiq_rescue_options = self.sidekiq_rescue_options.merge(errors => {
+            delay: delay, limit: limit, jitter: jitter, queue: queue
+          }.compact)
         end
       end
     end

data/lib/sidekiq/rescue/rspec/matchers.rb

@@ -15,6 +15,8 @@ module Sidekiq
             str = "expected #{actual} to be rescueable with #{expected}"
             str += " and delay #{@delay}" if @delay
             str += " and limit #{@limit}" if @limit
+            str += " and jitter #{@jitter}" if @jitter
+            str += " and queue #{@queue}" if @queue
             str
           end
           failure_message_when_negated { |actual| "expected #{actual} not to be rescueable with #{expected}" }
@@ -27,6 +29,14 @@ module Sidekiq
             @limit = limit
           end
 
+          chain :with_jitter do |jitter|
+            @jitter = jitter
+          end
+
+          chain :with_queue do |queue|
+            @queue = queue
+          end
+
           match do |actual|
             matched = actual.is_a?(Class) &&
                       actual.include?(Sidekiq::Rescue::Dsl) &&
@@ -38,12 +48,16 @@ module Sidekiq
             _error_group, options = actual.sidekiq_rescue_error_group_with_options_by(expected.new)
 
             (@delay.nil? || options.fetch(:delay) == @delay) &&
-              (@limit.nil? || options.fetch(:limit) == @limit)
+              (@limit.nil? || options.fetch(:limit) == @limit) &&
+              (@jitter.nil? || options.fetch(:jitter) == @jitter) &&
+              (@queue.nil? || options.fetch(:queue) == @queue)
           end
 
           match_when_negated do |actual|
             raise NotImplementedError, "it's confusing to use `not_to be_rescueable` with `with_delay`" if @delay
             raise NotImplementedError, "it's confusing to use `not_to be_rescueable` with `with_limit`" if @limit
+            raise NotImplementedError, "it's confusing to use `not_to be_rescueable` with `with_jitter`" if @jitter
+            raise NotImplementedError, "it's confusing to use `not_to be_rescueable` with `with_queue`" if @queue
 
             actual.is_a?(Class) &&
               actual.include?(Sidekiq::Rescue::Dsl) &&

data/lib/sidekiq/rescue/server_middleware.rb

@@ -30,14 +30,16 @@ module Sidekiq
       end
 
       def rescue_error(error, error_group, options, job_payload)
-        delay, limit = options.fetch_values(:delay, :limit)
+        delay, limit, jitter = options.fetch_values(:delay, :limit, :jitter)
+        queue = options.fetch(:queue, job_payload["queue"])
+
         rescue_counter = increment_rescue_counter_for(error_group, job_payload)
         raise error if rescue_counter > limit
 
-        reschedule_at = calculate_reschedule_time(delay, rescue_counter)
-        log_reschedule_info(rescue_counter, error, reschedule_at)
-        reschedule_job(job_payload: job_payload, reschedule_at: reschedule_at, rescue_counter: rescue_counter,
-                       error_group: error_group)
+        calculated_delay = calculate_delay(delay, rescue_counter, jitter)
+        log_reschedule_info(rescue_counter, error, calculated_delay)
+        reschedule_job(job_payload: job_payload, delay: calculated_delay, rescue_counter: rescue_counter,
+                       error_group: error_group, queue: queue)
       end
 
       def increment_rescue_counter_for(error_group, job_payload)
@@ -46,23 +48,28 @@ module Sidekiq
         rescue_counter
       end
 
-      def calculate_reschedule_time(delay, rescue_counter)
-        # NOTE: we use the retry counter to increase the jitter
-        # so that the jobs don't retry at the same time
-        # inspired by sidekiq https://github.com/sidekiq/sidekiq/blob/73c150d0430a8394cadb5cd49218895b113613a0/lib/sidekiq/job_retry.rb#L188
-        jitter = rand(10) * rescue_counter
+      def calculate_delay(delay, rescue_counter, jitter)
         delay = delay.call(rescue_counter) if delay.is_a?(Proc)
-        Time.now.to_f + delay + jitter
+        jitter_delay = calculate_delay_jitter(jitter, delay)
+        delay + jitter_delay
+      end
+
+      def calculate_delay_jitter(jitter, delay)
+        return 0.0 if jitter.zero?
+
+        jitter * Kernel.rand * delay
       end
 
-      def log_reschedule_info(rescue_counter, error, reschedule_at)
+      def log_reschedule_info(rescue_counter, error, delay)
         Sidekiq::Rescue.logger.info("[sidekiq_rescue] Job failed #{rescue_counter} times with error: " \
-                                    "#{error.message}; rescheduling at #{reschedule_at}")
+                                    "#{error.message}; rescheduling in #{delay} seconds")
       end
 
-      def reschedule_job(job_payload:, reschedule_at:, rescue_counter:, error_group:)
-        payload = job_payload.merge("at" => reschedule_at,
-                                    "sidekiq_rescue_exceptions_counter" => { error_group.to_s => rescue_counter })
+      def reschedule_job(job_payload:, delay:, rescue_counter:, error_group:, queue:)
+        payload = job_payload.dup
+        payload["at"] = Time.now.to_f + delay if delay.positive?
+        payload["sidekiq_rescue_exceptions_counter"] = { error_group.to_s => rescue_counter }
+        payload["queue"] = queue
         Sidekiq::Client.push(payload)
       end
     end

data/lib/sidekiq/rescue/version.rb

@@ -2,6 +2,6 @@
 
 module Sidekiq
   module Rescue
-    VERSION = "0.3.1"
+    VERSION = "0.5.0"
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-rescue
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Dmitrii Ivliev
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-30 00:00:00.000000000 Z
+date: 2024-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -24,7 +23,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '6.5'
-description:
 email:
 - mail@ivda.dev
 executables: []
@@ -50,9 +48,8 @@ metadata:
   homepage_uri: https://github.com/moofkit/sidekiq-rescue
   source_code_uri: https://github.com/moofkit/sidekiq-rescue
   changelog_uri: https://github.com/moofkit/sidekiq-rescue/blob/master/CHANGELOG.md
-  documentation_uri: https://rubydoc.info/gems/sidekiq-rescue/0.3.1
+  documentation_uri: https://rubydoc.info/gems/sidekiq-rescue/0.5.0
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -67,8 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 3.6.0.dev
 specification_version: 4
 summary: Rescue Sidekiq jobs on expected error and reschedule them
 test_files: []