rollbar 2.25.1 → 2.26.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bffe91029b00ca56f007756a93e94cdfb22ae068983b7d81c8f5b8dd168de41
-  data.tar.gz: 5f75d00b9b6f8910fb0d7c8de71f30efde6b00132927b01746811d101b5a4dc2
+  metadata.gz: cd45e6b870eee21793378f297cf881406be39872d66be7cf69327aa7bc06a027
+  data.tar.gz: d575825e0dc9715370e04b4a667d94eec34a089dedbbd4c0ef92df991ac9ecbf
 SHA512:
-  metadata.gz: ff7f880b5749d41a349ffa441198d495f13b450712c79a407b9569f091161ca06fdd5c3db08068d05a970745d629e99ed258de770cb8a973e3c3834a66d0592c
-  data.tar.gz: 740de4df537388a5a52280c2aebb5f2286849dc70589baa20dd587518a49334e8a10f28c2caa6540b1c45dbcf24c1c46652f90c35395c51bba7ae9d154bb3c64
+  metadata.gz: 51ebdecd60cef3c8cb540ed24179b00840f296a137fad69f68c19b7ddff65e987129b4e7ef6fa138bd5e6b5e823f4a9e9a3aef471524797efe8a6ff9b41efd34
+  data.tar.gz: 17de152e3dadb969fae494fae14d00903bc7e31781d1d0bbe3d6410b8623e96b7f58b52b9cb9bcab03d517ad894acd1d908a23ffe722b4bd748f93450a7b0abf

data/lib/rollbar/capistrano.rb

@@ -35,7 +35,7 @@ module Rollbar
           _cset(:rollbar_user)  { ENV['USER'] || ENV['USERNAME'] }
           _cset(:rollbar_env)   { fetch(:rails_env, 'production') }
           _cset(:rollbar_token) { abort("Please specify the Rollbar access token, set :rollbar_token, 'your token'") }
-          _cset(:rollbar_revision) { current_revision }
+          _cset(:rollbar_revision) { real_revision }
           _cset(:rollbar_comment) { nil }
         end
       end

data/lib/rollbar/capistrano_tasks.rb

@@ -40,6 +40,9 @@ module Rollbar
         capistrano_300_warning(logger)
         logger.info opts[:desc] if opts[:desc]
         yield
+
+      rescue StandardError => e
+        logger.error "Error reporting to Rollbar: #{e.inspect}"
       end
 
       def deploy_update(capistrano, logger, dry_run, opts = {})
@@ -61,7 +64,11 @@ module Rollbar
       end
 
       def capistrano_300_warning(logger)
-        logger.warn("You need to upgrade capistrano to '>= 3.1' version in order to correctly report deploys to Rollbar. (On 3.0, the reported revision will be incorrect.)") if ::Capistrano::VERSION =~ /^3\.0/
+        return unless ::Capistrano.const_defined?('VERSION') && ::Capistrano::VERSION =~ /^3\.0/
+
+        logger.warn('You need to upgrade capistrano to >= 3.1 version in order'\
+          'to correctly report deploys to Rollbar. (On 3.0, the reported revision'\
+          'will be incorrect.)')
       end
 
       def report_deploy_started(capistrano, dry_run)
@@ -83,6 +90,7 @@ module Rollbar
       def report_deploy_succeeded(capistrano, dry_run)
         ::Rollbar::Deploy.update(
           {
+            :comment => capistrano.fetch(:rollbar_comment),
             :proxy => :ENV,
             :dry_run => dry_run
           },
@@ -95,6 +103,7 @@ module Rollbar
       def report_deploy_failed(capistrano, dry_run)
         ::Rollbar::Deploy.update(
           {
+            :comment => capistrano.fetch(:rollbar_comment),
             :proxy => :ENV,
             :dry_run => dry_run
           },

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/rake_tasks.rb

@@ -1,6 +1,6 @@
 
 namespace :rollbar do
-  desc 'Verify your gem installation by sending a test exception to Rollbar'
+  desc 'Verify your gem installation by sending a test message to Rollbar'
   task :test => [:environment] do
     rollbar_dir = Gem.loaded_specs['rollbar'].full_gem_path
     require "#{rollbar_dir}/lib/rollbar/rollbar_test"

data/lib/rollbar/request_data_extractor.rb

@@ -131,6 +131,7 @@ module Rollbar
       host = host.split(',').first.strip unless host.empty?
 
       path = env['ORIGINAL_FULLPATH'] || env['REQUEST_URI']
+      path ||= "#{env['SCRIPT_NAME']}#{env['PATH_INFO']}#{"?#{env['QUERY_STRING']}" unless env['QUERY_STRING'].to_s.empty?}"
       unless path.nil? || path.empty?
         path = '/' + path.to_s if path.to_s.slice(0, 1) != '/'
       end

data/lib/rollbar/rollbar_test.rb

@@ -1,48 +1,16 @@
 require 'rollbar'
-begin
-  require 'rack/mock'
-rescue LoadError
-  puts 'Cannot load rack/mock'
-end
-require 'logger'
 
-# Module to inject into the Rails controllers or rack apps
 module RollbarTest # :nodoc:
-  def test_rollbar
-    puts 'Raising RollbarTestingException to simulate app failure.'
-
-    raise RollbarTestingException.new, ::RollbarTest.success_message
-  end
-
   def self.run
     return unless confirmed_token?
 
-    configure_rails if defined?(Rails)
-
-    puts 'Testing manual report...'
-    Rollbar.error('Test error from rollbar:test')
-
-    return unless defined?(Rack::MockRequest)
-
-    protocol, app = setup_app
-
-    puts 'Processing...'
-    env = Rack::MockRequest.env_for("#{protocol}://www.example.com/verify", 'REMOTE_ADDR' => '127.0.0.1')
-    status, = app.call(env)
-
-    puts error_message unless status.to_i == 500
-  end
-
-  def self.configure_rails
-    Rails.logger = if defined?(ActiveSupport::TaggedLogging)
-                     ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
-                   else
-                     Logger.new(STDOUT)
-                   end
+    puts 'Test sending to Rollbar...'
+    result = Rollbar.info('Test message from rollbar:test')
 
-    Rails.logger.level = Logger::DEBUG
-    Rollbar.preconfigure do |config|
-      config.logger = Rails.logger
+    if result == 'error'
+      puts error_message
+    else
+      puts success_message
     end
   end
 
@@ -54,69 +22,6 @@ module RollbarTest # :nodoc:
     false
   end
 
-  def self.authlogic_config
-    # from http://stackoverflow.com/questions/5270835/authlogic-activation-problems
-    return unless defined?(Authlogic)
-
-    Authlogic::Session::Base.controller = Authlogic::ControllerAdapters::RailsAdapter.new(self)
-  end
-
-  def self.setup_app
-    puts 'Setting up the test app.'
-
-    if defined?(Rails)
-      app = rails_app
-
-      draw_rails_route(app)
-
-      authlogic_config
-
-      [rails_protocol(app), app]
-    else
-      ['http', rack_app]
-    end
-  end
-
-  def self.rails_app
-    # The setup below is needed for Rails 5.x, but not for Rails 4.x and below.
-    # (And fails on Rails 4.x in various ways depending on the exact version.)
-    return Rails.application if Rails.version < '5.0.0'
-
-    # Spring now runs by default in development on all new Rails installs. This causes
-    # the new `/verify` route to not get picked up if `config.cache_classes == false`
-    # which is also a default in development env.
-    #
-    # `config.cache_classes` needs to be set, but the only possible time is at app load,
-    # so here we clone the default app with an updated config.
-    #
-    config = Rails.application.config
-    config.cache_classes = true
-
-    # Make a copy of the app, so the config can be updated.
-    Rails.application.class.name.constantize.new(:config => config)
-  end
-
-  def self.draw_rails_route(app)
-    app.routes_reloader.execute_if_updated
-    app.routes.draw do
-      get 'verify' => 'rollbar_test#verify', :as => 'verify'
-    end
-  end
-
-  def self.rails_protocol(app)
-    defined?(app.config.force_ssl && app.config.force_ssl) ? 'https' : 'http'
-  end
-
-  def self.rack_app
-    Class.new do
-      include RollbarTest
-
-      def self.call(_env)
-        new.test_rollbar
-      end
-    end
-  end
-
   def self.token_error_message
     'Rollbar needs an access token configured. Check the README for instructions.'
   end
@@ -129,19 +34,3 @@ module RollbarTest # :nodoc:
     'Testing rollbar with "rake rollbar:test". If you can see this, it works.'
   end
 end
-
-class RollbarTestingException < RuntimeError; end
-
-if defined?(Rails)
-  class RollbarTestController < ActionController::Base # :nodoc:
-    include RollbarTest
-
-    def verify
-      test_rollbar
-    end
-
-    def logger
-      nil
-    end
-  end
-end

data/lib/rollbar/version.rb

@@ -1,3 +1,3 @@
 module Rollbar
-  VERSION = '2.25.1'.freeze
+  VERSION = '2.26.1'.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.1
 platform: ruby
 authors:
 - Rollbar, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-10 00:00:00.000000000 Z
+date: 2020-07-22 00:00:00.000000000 Z
 dependencies: []
 description: Easy and powerful exception tracking for Ruby
 email: