raygun4ruby 4.0.0 → 4.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b7c357c986e52b60665b3ee8af64d7a2c421747825e16b928fc91b76ae58f2a
-  data.tar.gz: 671db6dc795dfe165f531b16443b483865ca659c83b25df617c09ce706f4ca48
+  metadata.gz: f1f1acdc84e42b8f39dd817b3e3b74e39dd18b07c675f46afa1cb57bf42bb435
+  data.tar.gz: 6ca0a6036d1d56d23e66105c5535ccc8687973b55b32e461d7643543693e475a
 SHA512:
-  metadata.gz: 7287d1190a0fa828a3cd9acc0ac4935249e080f1749730ad2dc2c6b9ef868f42f0e0293ba6c9c1eb5a9828d8b52ba6cfd832783512938614cf1e6921d7365a73
-  data.tar.gz: 9a35eeba3f42c226c98f077a27870096853e8a1e06073736e0b02bc1114725f1feeed66f2434adc35dc41f5c2b5c3181f7ab04da29886a18b638899e25460dee
+  metadata.gz: 318c63ba10cb3645f7c75b81f1f4da06de5f361650f3ae7b3a32cc229fa9670589b742952e3cbb1929cfb02d581bdac3fd45c120b957645bea5c9339096021ff
+  data.tar.gz: 396e058ef6bb5fe5a802a6430c548d3133e2b50000af67bdca300cb280c211d2f5464fb12afe4c3c694e658c5887c1983f1d7af08e4cbc2b535c88be75917558

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 4.0.1 (29/07/2024):
+
+- Adds the ability to unwrap `Sidekiq::JobRetry::Handled` exceptions (or ignore them entirely) ([#185](https://github.com/MindscapeHQ/raygun4ruby/pull/185))
+
 ## 4.0.0 (20/05/2024):
 
 - BREAKING CHANGE: Remove support for end-of-life Ruby verisons and Rails versions prior to 6.0.0

data/README.md

@@ -402,6 +402,10 @@ class FailingWorker
   end
 ```
 
+##### Sidekiq Retries
+
+By default, Raygun4Ruby will unwrap `Sidekiq::JobRetry::Handled` exceptions and report the original error via `Exception#cause`. If you would prefer not to hear about retries, you can set `config.track_retried_sidekiq_jobs` to `false` in your Raygun configuration.
+
 ### Other Configuration options
 
 For a complete list of configuration options see the [configuration.rb](https://github.com/MindscapeHQ/raygun4ruby/blob/master/lib/raygun/configuration.rb) file

data/lib/raygun/configuration.rb

@@ -86,9 +86,18 @@ module Raygun
     # How long to wait for the POST request to the API server before timing out
     config_option :error_report_send_timeout
 
+    # How many times to try sending to Raygun before giving up
+    config_option :error_report_max_attempts
+
+    # Whether or not we should raise an exception if the error reporting fails
+    config_option :raise_on_failed_error_report
+
     # Should we register an error handler with [Rails' built in API](https://edgeguides.rubyonrails.org/error_reporting.html)
     config_option :register_rails_error_handler
 
+    # Should we track jobs that are retried in Sidekiq (ones that raise Sidekiq::JobRetry::Handled). Set to "false" to ignore.
+    config_option :track_retried_sidekiq_jobs
+
     # Exception classes to ignore by default
     IGNORE_DEFAULT = ['ActiveRecord::RecordNotFound',
                       'ActionController::RoutingError',
@@ -143,7 +152,10 @@ module Raygun
         breadcrumb_level:              :info,
         record_raw_data:               false,
         send_in_background:            false,
-        error_report_send_timeout:     10
+        error_report_send_timeout:     10,
+        error_report_max_attempts:     1,
+        raise_on_failed_error_report:  false,
+        track_retried_sidekiq_jobs:    true
       )
     end
 

data/lib/raygun/error_subscriber.rb

@@ -16,6 +16,10 @@ class Raygun::ErrorSubscriber
       tags: ["rails_error_reporter", *tags].compact
     }
 
-    Raygun.track_exception(error, data)
+    if source == "job.sidekiq" && defined?(Sidekiq)
+      Raygun::SidekiqReporter.call(error, data)
+    else
+      Raygun.track_exception(error, data)
+    end
   end
 end

data/lib/raygun/sidekiq.rb

@@ -6,7 +6,7 @@
 module Raygun
 
   class SidekiqReporter
-    def self.call(exception, context_hash, config)
+    def self.call(exception, context_hash = {}, config = nil)
       user = affected_user(context_hash)
       data =  {
         custom_data: {
@@ -14,6 +14,16 @@ module Raygun
         },
         tags: ['sidekiq']
       }
+
+      if exception.is_a?(Sidekiq::JobRetry::Handled) && exception.cause
+        if Raygun.configuration.track_retried_sidekiq_jobs
+          data.merge!(sidekiq_retried: true)
+          exception = exception.cause
+        else
+          return false
+        end
+      end
+
       if exception.instance_variable_defined?(:@__raygun_correlation_id) && correlation_id = exception.instance_variable_get(:@__raygun_correlation_id)
         data.merge!(correlation_id: correlation_id)
       end

data/lib/raygun/version.rb

@@ -1,3 +1,3 @@
 module Raygun
-  VERSION = "4.0.0"
+  VERSION = "4.0.2"
 end

data/lib/raygun.rb

@@ -60,15 +60,15 @@ module Raygun
       !!configuration.api_key
     end
 
-    def track_exception(exception_instance, env = {}, user = nil, retry_count = 1)
+    def track_exception(exception_instance, env = {}, user = nil, retries_remaining = configuration.error_report_max_attempts - 1)
       log('tracking exception')
       
       exception_instance.set_backtrace(caller) if exception_instance.is_a?(Exception) && exception_instance.backtrace.nil?
 
       result = if configuration.send_in_background
-        track_exception_async(exception_instance, env, user, retry_count)
+        track_exception_async(exception_instance, env, user, retries_remaining)
       else
-        track_exception_sync(exception_instance, env, user, retry_count)
+        track_exception_sync(exception_instance, env, user, retries_remaining)
       end
 
       result
@@ -128,10 +128,10 @@ module Raygun
 
     private
 
-    def track_exception_async(exception_instance, env, user, retry_count)
+    def track_exception_async(exception_instance, env, user, retries_remaining)
       env[:rg_breadcrumb_store] = Raygun::Breadcrumbs::Store.take_until_size(Client::MAX_BREADCRUMBS_SIZE) if Raygun::Breadcrumbs::Store.any?
 
-      future = Concurrent::Future.execute { track_exception_sync(exception_instance, env, user, retry_count) }
+      future = Concurrent::Future.execute { track_exception_sync(exception_instance, env, user, retries_remaining) }
       future.add_observer(lambda do |_, value, reason|
         if value == nil || !value.responds_to?(:response) || value.response.code != "202"
           log("unexpected response from Raygun, could indicate error: #{value.inspect}")
@@ -143,7 +143,7 @@ module Raygun
       future
     end
 
-    def track_exception_sync(exception_instance, env, user, retry_count)
+    def track_exception_sync(exception_instance, env, user, retries_remaining)
       if should_report?(exception_instance)
         log('attempting to send exception')
         resp = Client.new.track_exception(exception_instance, env, user)
@@ -158,18 +158,25 @@ module Raygun
         failsafe_log("Problem reporting exception to Raygun: #{e.class}: #{e.message}\n\n#{e.backtrace.join("\n")}")
       end
 
-      if retry_count > 0
+      if retries_remaining > 0
         new_exception = e.exception("raygun4ruby encountered an exception processing your exception")
         new_exception.set_backtrace(e.backtrace)
 
         env[:custom_data] ||= {}
-        env[:custom_data].merge!(original_stacktrace: exception_instance.backtrace)
+        env[:custom_data].merge!(original_stacktrace: exception_instance.backtrace, retries_remaining: retries_remaining)
 
         ::Raygun::Breadcrumbs::Store.clear
 
-        track_exception(new_exception, env, user, retry_count - 1)
+        track_exception(new_exception, env, user, retries_remaining - 1)
       else
-        raise e
+        if configuration.raise_on_failed_error_report
+          raise e
+        else
+          retries = configuration.error_report_max_attempts - retries_remaining
+          if configuration.failsafe_logger
+            failsafe_log("Gave up reporting exception to Raygun after #{retries} #{retries == 1 ? "retry" : "retries"}: #{e.class}: #{e.message}\n\n#{e.backtrace.join("\n")}")
+          end
+        end
       end
     end
 

data/raygun4ruby.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "json"
   spec.add_runtime_dependency "rack"
   spec.add_runtime_dependency "concurrent-ruby"
+  spec.add_runtime_dependency "ostruct"
 
   spec.add_development_dependency "bundler", ">= 2.3"
   spec.add_development_dependency "rake", ">= 12.3.3"

data/test/unit/raygun_test.rb

@@ -103,4 +103,43 @@ class RaygunTest < Raygun::UnitTest
     assert_equal Raygun.default_configuration.api_url, Raygun.configuration.api_url
     refute_equal original_api_url, Raygun.configuration.api_url
   end
+
+  def test_retries 
+    failsafe_logger = FakeLogger.new
+    Raygun.setup do |c|
+      c.error_report_max_attempts = 3
+      c.failsafe_logger = failsafe_logger
+    end  
+
+    WebMock.reset!
+    report_request = stub_request(:post, "https://api.raygun.com/entries").to_timeout
+
+    error = StandardError.new
+    Raygun.track_exception(error)
+
+    assert_requested report_request, times: 3
+
+    assert_match(/Gave up reporting exception to Raygun after 3 retries/, failsafe_logger.get)
+  ensure
+    Raygun.reset_configuration
+  end
+
+  def test_raising_on_retry_failure
+    Raygun.setup do |c|
+      c.error_report_max_attempts = 1
+      c.raise_on_failed_error_report = true
+    end  
+
+    report_request = stub_request(:post, "https://api.raygun.com/entries").to_timeout
+
+    error = StandardError.new
+
+    assert_raises(StandardError) do
+      Raygun.track_exception(error)
+      assert_requested report_request
+    end
+
+  ensure
+    Raygun.reset_configuration
+  end
 end

data/test/unit/sidekiq_failure_test.rb

@@ -1,6 +1,7 @@
 require_relative "../test_helper.rb"
 
 require "sidekiq"
+
 # Convince Sidekiq it's on a server :)
 module Sidekiq
   class << self
@@ -15,6 +16,8 @@ require "raygun/sidekiq"
 class SidekiqFailureTest < Raygun::UnitTest
 
   def setup
+    require "sidekiq/job_retry"
+
     super
     Raygun.configuration.send_in_background = false
 
@@ -32,6 +35,61 @@ class SidekiqFailureTest < Raygun::UnitTest
     assert response && response.success?, "Expected success, got #{response.class}: #{response.inspect}"
   end
 
+  def test_failure_backend_unwraps_retries
+    WebMock.reset!
+
+    unwrapped_stub = stub_request(:post, 'https://api.raygun.com/entries').
+      with(body: /StandardError/).
+      to_return(status: 202)
+
+    begin
+      raise StandardError.new("Some job in Sidekiq failed, oh dear!")
+    rescue
+      raise Sidekiq::JobRetry::Handled
+    end
+
+  rescue Sidekiq::JobRetry::Handled => e
+
+    response = Raygun::SidekiqReporter.call(
+      e,
+      { sidekick_name: "robin" }, 
+      {} # config
+    )
+
+    assert_requested unwrapped_stub
+    assert response && response.success?, "Expected success, got #{response.class}: #{response.inspect}"
+  end
+
+  def test_failured_backend_ignores_retries_if_configured
+    Raygun.configuration.track_retried_sidekiq_jobs = false
+    
+    begin
+      raise StandardError.new("Some job in Sidekiq failed, oh dear!")
+    rescue
+      raise Sidekiq::JobRetry::Handled
+    end
+
+  rescue Sidekiq::JobRetry::Handled => e
+
+    refute Raygun::SidekiqReporter.call(e,
+      { sidekick_name: "robin" }, 
+      {} # config
+    )
+  ensure
+    Raygun.configuration.track_retried_sidekiq_jobs = true
+  end
+
+  # See https://github.com/MindscapeHQ/raygun4ruby/issues/183
+  # (This is how Sidekiq pre 7.1.5 calls error handlers: https://github.com/sidekiq/sidekiq/blob/1ba89bbb22d2fd574b11702d8b6ed63ae59e2256/lib/sidekiq/config.rb#L269)
+  def test_failure_backend_appears_to_work_without_config_argument
+    response = Raygun::SidekiqReporter.call(
+      StandardError.new("Oh no! Your Sidekiq has failed!"),
+      { sidekick_name: "robin" }
+    )
+
+    assert response && response.success?, "Expected success, got #{response.class}: #{response.inspect}"
+  end
+
   def test_we_are_in_sidekiqs_list_of_error_handlers
     # Sidekiq 7.x stores error handlers inside a configuration object, while 6.x and below stores them directly against the Sidekiq module
     error_handlers = Sidekiq.respond_to?(:error_handlers) ? Sidekiq.error_handlers : Sidekiq.default_configuration.error_handlers
@@ -39,4 +97,26 @@ class SidekiqFailureTest < Raygun::UnitTest
     assert error_handlers.include?(Raygun::SidekiqReporter)
   end
 
+  def test_rails_error_reporter_uses_sidekiq_reporter
+    WebMock.reset!
+
+    tagged_request = stub_request(:post, 'https://api.raygun.com/entries').
+      with(body: /"sidekiq"/). # should have a sidekiq tag!
+      to_return(status: 202)
+
+    error = StandardError.new("Oh no! Your Sidekiq has failed!")
+
+    response = Raygun::ErrorSubscriber.new.report(
+      error,
+      handled: true,
+      severity: "error",
+      context: { sidekick_name: "robin" },
+      source: "job.sidekiq"
+    )
+
+    assert response && response.success?, "Expected success, got #{response.class}: #{response.inspect}"
+
+    assert_requested tagged_request
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raygun4ruby
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.0.2
 platform: ruby
 authors:
 - Mindscape
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-19 00:00:00.000000000 Z
+date: 2024-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -67,6 +67,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement