rollbar 2.25.1 → 2.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bffe91029b00ca56f007756a93e94cdfb22ae068983b7d81c8f5b8dd168de41
-  data.tar.gz: 5f75d00b9b6f8910fb0d7c8de71f30efde6b00132927b01746811d101b5a4dc2
+  metadata.gz: 69307fc6496e1b12a3ebbe3e40b7341f725a7f4efadd6a1a5e76d7246bc86928
+  data.tar.gz: 117fb5d03ab1f140f9469558c6560963180806935d3d56eeeb35da9cf450edc6
 SHA512:
-  metadata.gz: ff7f880b5749d41a349ffa441198d495f13b450712c79a407b9569f091161ca06fdd5c3db08068d05a970745d629e99ed258de770cb8a973e3c3834a66d0592c
-  data.tar.gz: 740de4df537388a5a52280c2aebb5f2286849dc70589baa20dd587518a49334e8a10f28c2caa6540b1c45dbcf24c1c46652f90c35395c51bba7ae9d154bb3c64
+  metadata.gz: 61587004c5ba54fffb2bd34d9f4abdfd182a82002ebcbe688c8c500975797f43f2caac63ce3ca510276828e1b2132cda95027b42ea02533221a18a008d8d654b
+  data.tar.gz: 9b62efc68f689811910cb92ae3262447c41732eaa6ebdc14019b7fd96114fcfebddf921e29699480e1fa7a21d54281e9130e99a3c85f8104f2d4440fd22f840d

data/lib/rollbar/item.rb

@@ -136,11 +136,18 @@ module Rollbar
       uuid = stringified_payload['data']['uuid']
       host = stringified_payload['data'].fetch('server', {})['host']
 
+      original_error = {
+        :message => message,
+        :exception => exception,
+        :configuration => configuration,
+        :uuid => uuid,
+        :host => host
+      }
+
       notifier.send_failsafe(
         too_large_payload_string(attempts),
         nil,
-        uuid,
-        host
+        original_error
       )
       logger.error("[Rollbar] Payload too large to be sent for UUID #{uuid}: #{Rollbar::JSON.dump(payload)}")
     end

data/lib/rollbar/item/backtrace.rb

@@ -55,7 +55,7 @@ module Rollbar
         current_exception = exception
 
         while current_exception.respond_to?(:cause) && (cause = current_exception.cause) && cause.is_a?(Exception) && !visited.include?(cause)
-          traces.unshift(trace_data(cause))
+          traces << trace_data(cause)
           visited << cause
           current_exception = cause
         end

data/lib/rollbar/middleware/js.rb

@@ -80,8 +80,11 @@ module Rollbar
         return app_result unless response_string
 
         env[JS_IS_INJECTED_KEY] = true
-        response = ::Rack::Response.new(response_string, app_result[0],
-                                        app_result[1])
+
+        status, headers, = app_result
+        headers['Content-Length'] = response_string.bytesize.to_s if headers.key?('Content-Length')
+
+        response = ::Rack::Response.new(response_string, status, headers)
 
         finished = response.finish
 

data/lib/rollbar/notifier.rb

@@ -21,6 +21,7 @@ module Rollbar
 
     MUTEX = Mutex.new
     EXTENSION_REGEXP = /.rollbar\z/.freeze
+    FAILSAFE_STRING_LENGTH = 10_000
 
     def initialize(parent_notifier = nil, payload_options = nil, scope = nil)
       if parent_notifier
@@ -158,7 +159,13 @@ module Rollbar
     def report_with_rescue(level, message, exception, extra, context)
       report(level, message, exception, extra, context)
     rescue StandardError, SystemStackError => e
-      report_internal_error(e)
+      original_error = {
+        :message => message,
+        :exception => exception,
+        :configuration => configuration
+      }
+
+      report_internal_error(e, original_error)
 
       'error'
     end
@@ -262,32 +269,32 @@ module Rollbar
       end
     end
 
-    def send_failsafe(message, exception, uuid = nil, host = nil)
-      exception_reason = failsafe_reason(message, exception)
-
-      log_error "[Rollbar] Sending failsafe response due to #{exception_reason}"
-
-      body = failsafe_body(exception_reason)
-
-      failsafe_data = {
+    def failsafe_initial_data(exception_reason)
+      {
         :level => 'error',
         :environment => configuration.environment.to_s,
         :body => {
           :message => {
-            :body => body
+            :body => failsafe_body(exception_reason)
           }
         },
         :notifier => {
           :name => 'rollbar-gem',
           :version => VERSION
         },
-        :custom => {
-          :orig_uuid => uuid,
-          :orig_host => host
-        },
         :internal => true,
         'failsafe' => true
       }
+    end
+
+    def send_failsafe(message, exception, original_error = nil)
+      exception_reason = failsafe_reason(message, exception)
+
+      log_error "[Rollbar] Sending failsafe response due to #{exception_reason}"
+
+      failsafe_data = failsafe_initial_data(exception_reason)
+
+      failsafe_add_original_error_data(failsafe_data[:notifier], original_error)
 
       failsafe_payload = {
         'data' => failsafe_data
@@ -298,7 +305,9 @@ module Rollbar
                                :notifier => self,
                                :configuration => configuration,
                                :logger => logger)
-        schedule_item(item)
+
+        process_item(item)
+        log_and_return_item_data(item)
       rescue StandardError => e
         log_error "[Rollbar] Error sending failsafe : #{e}"
       end
@@ -306,6 +315,57 @@ module Rollbar
       failsafe_payload
     end
 
+    def failsafe_add_original_error_data(payload_notifier, original_error)
+      return unless original_error
+
+      payload_notifier[:diagnostic] ||= {}
+
+      add_original_host(payload_notifier[:diagnostic], original_error)
+      add_original_uuid(payload_notifier[:diagnostic], original_error)
+      add_original_message(payload_notifier[:diagnostic], original_error)
+      add_original_error(payload_notifier[:diagnostic], original_error)
+      add_configured_options(payload_notifier, original_error)
+    end
+
+    def add_original_message(diagnostic, original_error)
+        diagnostic[:original_message] = original_error[:message].truncate(FAILSAFE_STRING_LENGTH) if original_error[:message]
+
+    rescue StandardError => e
+      diagnostic[:original_message] = "Failed: #{e.message}"
+    end
+
+    def add_original_error(diagnostic, original_error)
+      if original_error[:exception]
+        backtrace = original_error[:exception].backtrace
+        message = original_error[:exception].message
+        diagnostic[:original_error] = {
+          :message => message && message.truncate(FAILSAFE_STRING_LENGTH),
+          :stack => backtrace && backtrace.join(', ').truncate(FAILSAFE_STRING_LENGTH)
+        }
+      end
+
+    rescue StandardError => e
+      diagnostic[:original_error] = "Failed: #{e.message}"
+    end
+
+    def add_configured_options(payload_notifier, original_error)
+      if original_error[:configuration]
+        configured = original_error[:configuration].configured_options.configured
+        payload_notifier[:configured_options] = ::JSON.generate(configured).truncate(FAILSAFE_STRING_LENGTH)
+      end
+
+    rescue StandardError => e
+      payload_notifier[:configured_options] = "Failed: #{e.message}"
+    end
+
+    def add_original_host(diagnostic, original_error)
+      diagnostic[:original_host] = original_error[:host] if original_error[:host]
+    end
+
+    def add_original_uuid(diagnostic, original_error)
+      diagnostic[:original_uuid] = original_error[:uuid] if original_error[:uuid]
+    end
+
     ## Logging
     %w[debug info warn error].each do |level|
       define_method(:"log_#{level}") do |message|
@@ -461,7 +521,7 @@ module Rollbar
     # Reports an internal error in the Rollbar library. This will be reported within the configured
     # Rollbar project. We'll first attempt to provide a report including the exception traceback.
     # If that fails, we'll fall back to a more static failsafe response.
-    def report_internal_error(exception)
+    def report_internal_error(exception, original_error = nil)
       log_error '[Rollbar] Reporting internal error encountered while sending data to Rollbar.'
 
       configuration.execute_hook(:on_report_internal_error, exception)
@@ -469,7 +529,7 @@ module Rollbar
       begin
         item = build_item('error', nil, exception, { :internal => true }, nil)
       rescue StandardError => e
-        send_failsafe('build_item in exception_data', e)
+        send_failsafe('build_item in exception_data', e, original_error)
         log_error "[Rollbar] Exception: #{exception}"
         return
       end
@@ -477,7 +537,7 @@ module Rollbar
       begin
         process_item(item)
       rescue StandardError => e
-        send_failsafe('error in process_item', e)
+        send_failsafe('error in process_item', e, original_error)
         log_error "[Rollbar] Item: #{item}"
         return
       end
@@ -485,7 +545,7 @@ module Rollbar
       begin
         log_instance_link(item['data'])
       rescue StandardError => e
-        send_failsafe('error logging instance link', e)
+        send_failsafe('error logging instance link', e, original_error)
         log_error "[Rollbar] Item: #{item}"
         return
       end

data/lib/rollbar/version.rb

@@ -1,3 +1,3 @@
 module Rollbar
-  VERSION = '2.25.1'.freeze
+  VERSION = '2.26.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rollbar
 version: !ruby/object:Gem::Version
-  version: 2.25.1
+  version: 2.26.0
 platform: ruby
 authors:
 - Rollbar, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-10 00:00:00.000000000 Z
+date: 2020-06-22 00:00:00.000000000 Z
 dependencies: []
 description: Easy and powerful exception tracking for Ruby
 email: