rollbar 2.25.0 → 2.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9b5cc0a79feb740c661bce79fb76f17a75d38b83172783cf61c8adf955805ec
-  data.tar.gz: a6c59d9d8d1a228f8b06779a53a07f106f85afcdece4172cdf2f59bbe8d7e330
+  metadata.gz: 69307fc6496e1b12a3ebbe3e40b7341f725a7f4efadd6a1a5e76d7246bc86928
+  data.tar.gz: 117fb5d03ab1f140f9469558c6560963180806935d3d56eeeb35da9cf450edc6
 SHA512:
-  metadata.gz: 639efd714acef67a62998009fbcd527a0cd28262a6cf683efc941533779bef9b51086b5469fa41971d74bf2bf29693044a0cd89634c8abfdf0021d21990524b4
-  data.tar.gz: 5ad38e447c67a08e4da7e76fb7df303a4c9e0c11d8f469e0f6645c34283b06c35db0e6f74165d3995b0bfe95588ec94cf834f6452e7100dd7d02eddabfe828c0
+  metadata.gz: 61587004c5ba54fffb2bd34d9f4abdfd182a82002ebcbe688c8c500975797f43f2caac63ce3ca510276828e1b2132cda95027b42ea02533221a18a008d8d654b
+  data.tar.gz: 9b62efc68f689811910cb92ae3262447c41732eaa6ebdc14019b7fd96114fcfebddf921e29699480e1fa7a21d54281e9130e99a3c85f8104f2d4440fd22f840d

data/README.md

@@ -1,5 +1,5 @@
 # Rollbar-gem
-[![Build Status](https://api.travis-ci.org/rollbar/rollbar-gem.svg?branch=master)](https://travis-ci.org/rollbar/rollbar-gem/branches)
+[![Build Status](https://travis-ci.org/rollbar/rollbar-gem.svg?branch=master)](https://travis-ci.org/rollbar/rollbar-gem/branches)
 [![Gem Version](https://badge.fury.io/rb/rollbar.svg)](http://badge.fury.io/rb/rollbar)
 [![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=rollbar&package-manager=bundler&version-scheme=semver&target-version=latest)](https://dependabot.com/compatibility-score.html?dependency-name=rollbar&package-manager=bundler&version-scheme=semver&new-version=latest)
 

data/lib/rollbar/item.rb

@@ -65,7 +65,6 @@ module Rollbar
     def build
       data = build_data
       self.payload = {
-        'access_token' => configuration.access_token,
         'data' => data
       }
 
@@ -137,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
@@ -104,10 +105,10 @@ module Rollbar
 
     # Sends a report to Rollbar.
     #
-    # Accepts any number of arguments. The last String argument will become
-    # the message or description of the report. The last Exception argument
-    # will become the associated exception for the report. The last hash
-    # argument will be used as the extra data for the report.
+    # Accepts a level string plus any number of arguments. The last String
+    # argument will become the message or description of the report. The last
+    # Exception argument will become the associated exception for the report.
+    # The last hash argument will be used as the extra data for the report.
     #
     # If the extra hash contains a symbol key :custom_data_method_context
     # the value of the key will be used as the context for
@@ -118,14 +119,14 @@ module Rollbar
     #   begin
     #     foo = bar
     #   rescue => e
-    #     Rollbar.log(e)
+    #     Rollbar.log('error', e)
     #   end
     #
     # @example
-    #   Rollbar.log('This is a simple log message')
+    #   Rollbar.log('info', 'This is a simple log message')
     #
     # @example
-    #   Rollbar.log(e, 'This is a description of the exception')
+    #   Rollbar.log('error', e, 'This is a description of the exception')
     #
     def log(level, *args)
       return 'disabled' unless enabled?
@@ -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,35 +269,34 @@ 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 = {
-        'access_token' => configuration.access_token,
         'data' => failsafe_data
       }
 
@@ -299,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
@@ -307,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|
@@ -462,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)
@@ -470,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
@@ -478,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
@@ -486,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.0'.freeze
+  VERSION = '2.26.0'.freeze
 end

data/spec/support/rollbar_api.rb

@@ -16,8 +16,8 @@ class RollbarAPI
 
   protected
 
-  def authorized?(json, _request)
-    json['access_token'] != UNAUTHORIZED_ACCESS_TOKEN
+  def authorized?(_json, request)
+    request.env['HTTP_X_ROLLBAR_ACCESS_TOKEN'] != UNAUTHORIZED_ACCESS_TOKEN
   end
 
   def response_headers
@@ -26,8 +26,8 @@ class RollbarAPI
     }
   end
 
-  def valid_data?(json, _request)
-    !!json['access_token']
+  def valid_data?(_json, request)
+    !!request.env['HTTP_X_ROLLBAR_ACCESS_TOKEN']
   end
 
   def unauthorized

metadata

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