sidekiq-rescue 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01671c36411fb052587442c08db979d740c563e6d74311ed1c4d17293b266745
-  data.tar.gz: 90de1649e943e5a422dc6d601d7b7425ee74958418ed9f89ef635c27aac1b0b7
+  metadata.gz: dd1cc37dddad565e32a86226f22111be381fffb62f80253e36dbd563598531be
+  data.tar.gz: 050f58d316e722f243b7eb49a5396cb56aa0ba368d827099aa4ca2dafafe43a0
 SHA512:
-  metadata.gz: c60d5673e1c25f7634820a760e4e4f0463ab618187147f96a412527db866944f7a37b44327d50053066c83b2e2694c09570befba78902053969b27a116968df7
-  data.tar.gz: 291b24d3f090b425702bd9ec2f644f8bb92e374deb7cb20d9553574b30b3502d7091544de81a2769238fbb3f4ea3851b9939299a2630dd54d2b416285db3c587
+  metadata.gz: 34d0325a6547e9ff4087114fb20c424383a62a144bafe72ede1ed53badecdba38affa32f6b695a5e68ab02c100c96629dfce30bc766f656f5dc319659e8e9489
+  data.tar.gz: a6d66d595d8e75e18cadb0f4e7360e49604c36a86c2587b249cb3e98fb4d90b30564ecf1e88d574c97ec34e5673e7a6df12b4d36d45eede6f6529cab9c1423c5

data/CHANGELOG.md

@@ -1,9 +1,17 @@
 ## [Unreleased]
 
+## [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
+
 ## [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
@@ -26,7 +34,10 @@
 - Add documentation
 - Add CI
 
-[Unreleased]: https://github.com/moofkit/sidekiq-rescue/compare/v0.2.1...HEAD
+[Unreleased]: https://github.com/moofkit/sidekiq-rescue/compare/v0.4.0...HEAD
+[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
 [0.2.0]: https://github.com/moofkit/sidekiq-rescue/releases/tag/v0.2.0
 [0.1.0]: https://github.com/moofkit/sidekiq-rescue/releases/tag/v0.1.0

data/README.md

@@ -81,7 +81,7 @@ 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 +89,20 @@ 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.
+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 `jitter` represents the upper bound of possible wait time (expressed as a percentage) and defaults to 0.15 (15%).
 
 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,17 +22,25 @@ 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
         # @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)
           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)
+          assign_sidekiq_rescue_options(errors: unpacked_errors, delay: delay, limit: limit, jitter: jitter)
         end
 
-        def sidekiq_rescue_options_for(error)
-          sidekiq_rescue_options&.find { |k, _v| k.include?(error) }&.last
+        # Find the error group and options for the given exception.
+        # @param exception [StandardError] The exception to find the error group for.
+        # @return [Array<StandardError>, Hash] The error group and options.
+        def sidekiq_rescue_error_group_with_options_by(exception)
+          sidekiq_rescue_options.reverse_each.find do |error_group, _options|
+            Array(error_group).any? { |error_klass| exception.is_a?(error_klass) }
+          end
         end
 
         private
@@ -46,7 +54,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)
@@ -63,9 +70,17 @@ 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 assign_sidekiq_rescue_options(errors:, delay:, limit:, jitter:)
           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 })
         end
       end
     end

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

@@ -35,7 +35,7 @@ module Sidekiq
 
             return false unless matched
 
-            options = actual.sidekiq_rescue_options_for(expected)
+            _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)

data/lib/sidekiq/rescue/server_middleware.rb

@@ -23,22 +23,20 @@ module Sidekiq
       def sidekiq_rescue(job_payload, job_class)
         yield
       rescue StandardError => e
-        error_group, options = job_class.sidekiq_rescue_options.reverse_each.find do |error_group, _options|
-          Array(error_group).any? { |error| e.is_a?(error) }
-        end
+        error_group, options = job_class.sidekiq_rescue_error_group_with_options_by(e)
         raise e unless error_group
 
         rescue_error(e, error_group, options, job_payload)
       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)
         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,
+        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)
       end
 
@@ -48,23 +46,27 @@ 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:)
+        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 }
         Sidekiq::Client.push(payload)
       end
     end

data/lib/sidekiq/rescue/version.rb

@@ -2,6 +2,6 @@
 
 module Sidekiq
   module Rescue
-    VERSION = "0.3.0"
+    VERSION = "0.4.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-rescue
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Dmitrii Ivliev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-30 00:00:00.000000000 Z
+date: 2024-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -50,7 +50,7 @@ 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.0
+  documentation_uri: https://rubydoc.info/gems/sidekiq-rescue/0.4.0
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []