sidekiq-rescue 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd1cc37dddad565e32a86226f22111be381fffb62f80253e36dbd563598531be
-  data.tar.gz: 050f58d316e722f243b7eb49a5396cb56aa0ba368d827099aa4ca2dafafe43a0
+  metadata.gz: f7e9209b0b3fcb19ae0068540e6a83aedf56928457fd53584e6ebf7397ef541a
+  data.tar.gz: debef2495e57e1452f19982777fb2238f75c811ab48a161f36858beff7f7a7e1
 SHA512:
-  metadata.gz: 34d0325a6547e9ff4087114fb20c424383a62a144bafe72ede1ed53badecdba38affa32f6b695a5e68ab02c100c96629dfce30bc766f656f5dc319659e8e9489
-  data.tar.gz: a6d66d595d8e75e18cadb0f4e7360e49604c36a86c2587b249cb3e98fb4d90b30564ecf1e88d574c97ec34e5673e7a6df12b4d36d45eede6f6529cab9c1423c5
+  metadata.gz: 96620e97aeabdfb9bc0ed8df29216e5017409c28e126e0e41d3941b3dde8548b5a4ecf0c1e54253f6280a8046291f21e2110ab3c514673f26cb1a557b895f754
+  data.tar.gz: a01212d26bdfb69c4dd3377a89fdeae379f8a016d8e98087b5c916528e0a54191bdff9b99d5e41330e81b7d971aea0da18fcde7058d1f727d525ac57e29d72b6

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.6.0] - 2025-03-15
+- Add support for Sidekiq 8.0, Ruby 3.4 [#6](https://github.com/moofkit/sidekiq-rescue/pull/6)
+
+## [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`
@@ -34,7 +40,9 @@
 - Add documentation
 - Add CI
 
-[Unreleased]: https://github.com/moofkit/sidekiq-rescue/compare/v0.4.0...HEAD
+[Unreleased]: https://github.com/moofkit/sidekiq-rescue/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/moofkit/sidekiq-rescue/releases/tag/v0.6.0
+[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

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,7 +76,7 @@ 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
@@ -89,7 +91,12 @@ class MyJob
 end
 ```
 
-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%).
+* `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
@@ -261,7 +268,7 @@ If something doesn't work on one of these versions, it's a bug
 
 ## Supported Sidekiq versions
 
-This gem supports Sidekiq 6.5+. It may work with older versions, but it's not tested.
+This gem supports Sidekiq 7.0+. It may work with older versions, but it's not tested.
 
 If you need support for older versions, please open an issue
 

data/lib/sidekiq/rescue/dsl.rb

@@ -23,15 +23,19 @@ module Sidekiq
         # @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,
-                           jitter: Sidekiq::Rescue.config.jitter)
+                           jitter: Sidekiq::Rescue.config.jitter, queue: nil)
           unpacked_errors = validate_and_unpack_error_argument(errors)
           validate_delay_argument(delay)
           validate_limit_argument(limit)
           validate_jitter_argument(jitter)
-          assign_sidekiq_rescue_options(errors: unpacked_errors, delay: delay, limit: limit, jitter: jitter)
+          validate_queue_argument(queue)
+          assign_sidekiq_rescue_options(
+            errors: unpacked_errors, delay:, limit:, jitter:, queue:
+          )
         end
 
         # Find the error group and options for the given exception.
@@ -77,10 +81,18 @@ module Sidekiq
                 "jitter must be integer or float"
         end
 
-        def assign_sidekiq_rescue_options(errors:, delay:, limit:, jitter:)
+        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,
-                                                                                      jitter: jitter })
+          self.sidekiq_rescue_options = self.sidekiq_rescue_options.merge(errors => {
+            delay:, limit:, jitter:, 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,23 +29,36 @@ 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) &&
                       actual.respond_to?(:sidekiq_rescue_options) &&
-                      actual&.sidekiq_rescue_options&.keys&.flatten&.include?(expected)
+                      actual.sidekiq_rescue_options.is_a?(Hash) &&
+                      actual.sidekiq_rescue_options.keys.flatten.include?(expected)
 
             return false unless matched
 
             _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

@@ -9,10 +9,10 @@ module Sidekiq
     class ServerMiddleware
       include Sidekiq::ServerMiddleware
 
-      def call(job_instance, job_payload, _queue, &block)
+      def call(job_instance, job_payload, _queue, &)
         job_class = job_instance.class
         if job_class.respond_to?(:sidekiq_rescue_options) && !job_class.sidekiq_rescue_options.nil?
-          sidekiq_rescue(job_payload, job_class, &block)
+          sidekiq_rescue(job_payload, job_class, &)
         else
           yield
         end
@@ -31,13 +31,15 @@ module Sidekiq
 
       def rescue_error(error, error_group, options, job_payload)
         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
 
         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)
+        reschedule_job(job_payload:, delay: calculated_delay, rescue_counter:,
+                       error_group:, queue:)
       end
 
       def increment_rescue_counter_for(error_group, job_payload)
@@ -63,10 +65,11 @@ module Sidekiq
                                     "#{error.message}; rescheduling in #{delay} seconds")
       end
 
-      def reschedule_job(job_payload:, delay:, rescue_counter:, error_group:)
+      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.4.0"
+    VERSION = "0.6.0"
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq-rescue
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Dmitrii Ivliev
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-03 00:00:00.000000000 Z
+date: 2025-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -16,15 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.5'
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.5'
-description:
+        version: '7.0'
 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.4.0
+  documentation_uri: https://rubydoc.info/gems/sidekiq-rescue/0.6.0
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -60,15 +57,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Rescue Sidekiq jobs on expected error and reschedule them
 test_files: []