rollbar 2.26.0 → 3.4.0

data/lib/rollbar/notifier.rb

@@ -15,9 +15,7 @@ module Rollbar
   # The notifier class. It has the core functionality
   # for sending reports to the API.
   class Notifier
-    attr_accessor :configuration
-    attr_accessor :last_report
-    attr_accessor :scope_object
+    attr_accessor :configuration, :last_report, :scope_object
 
     MUTEX = Mutex.new
     EXTENSION_REGEXP = /.rollbar\z/.freeze
@@ -34,7 +32,9 @@ module Rollbar
         self.scope_object = ::Rollbar::LazyStore.new(scope)
       end
 
-      Rollbar::Util.deep_merge(configuration.payload_options, payload_options) if payload_options
+      return unless payload_options
+
+      Rollbar::Util.deep_merge(configuration.payload_options, payload_options)
     end
 
     def reset!
@@ -134,17 +134,8 @@ module Rollbar
       message, exception, extra, context = extract_arguments(args)
       use_exception_level_filters = use_exception_level_filters?(extra)
 
-      return 'ignored' if ignored?(exception, use_exception_level_filters)
-
-      begin
-        status = call_before_process(:level => level,
-                                     :exception => exception,
-                                     :message => message,
-                                     :extra => extra)
-        return 'ignored' if status == 'ignored'
-      rescue Rollbar::Ignore
-        return 'ignored'
-      end
+      return 'ignored' if ignored?(exception, use_exception_level_filters) ||
+                          ignore_before_process?(level, exception, message, extra)
 
       level = lookup_exception_level(level, exception,
                                      use_exception_level_filters)
@@ -156,6 +147,17 @@ module Rollbar
       ret
     end
 
+    def ignore_before_process?(level, exception, message, extra)
+      status = call_before_process(:level => level,
+                                   :exception => exception,
+                                   :message => message,
+                                   :extra => extra)
+
+      status == 'ignored'
+    rescue Rollbar::Ignore
+      true
+    end
+
     def report_with_rescue(level, message, exception, extra, context)
       report(level, message, exception, extra, context)
     rescue StandardError, SystemStackError => e
@@ -202,23 +204,20 @@ module Rollbar
 
     def enabled?
       # Require access_token so we don't try to send events when unconfigured.
-      configuration.enabled && configuration.access_token && !configuration.access_token.empty?
+      configuration.enabled &&
+        configuration.access_token &&
+        !configuration.access_token.empty?
     end
 
     def process_item(item)
-      if configuration.write_to_file
-        if configuration.use_async
-          MUTEX.synchronize do
-            do_write_item(item)
-          end
-        else
-          do_write_item(item)
-        end
-      else
-        send_item(item)
-      end
+      return send_item(item) unless configuration.write_to_file
+
+      return do_write_item(item) unless configuration.use_async
+
+      MUTEX.synchronize { do_write_item(item) }
     rescue StandardError => e
-      log_error("[Rollbar] Error processing the item: #{e.class}, #{e.message}. Item: #{item.payload.inspect}")
+      log_error '[Rollbar] Error processing the item: ' \
+        "#{e.class}, #{e.message}. Item: #{item.payload.inspect}"
       raise e unless via_failsafe?(item)
 
       log_error('[Rollbar] Item has already failed. Not re-raising')
@@ -254,10 +253,7 @@ module Rollbar
             # The final payload has already been built.
             send_body(payload)
           else
-            item = Item.build_with(payload,
-                                   :notifier => self,
-                                   :configuration => configuration,
-                                   :logger => logger)
+            item = build_item_with_payload(payload)
 
             process_item(item)
           end
@@ -269,6 +265,12 @@ module Rollbar
       end
     end
 
+    def build_item_with_payload(payload)
+      Item.build_with(payload, :notifier => self,
+                               :configuration => configuration,
+                               :logger => logger)
+    end
+
     def failsafe_initial_data(exception_reason)
       {
         :level => 'error',
@@ -300,21 +302,19 @@ module Rollbar
         'data' => failsafe_data
       }
 
-      begin
-        item = Item.build_with(failsafe_payload,
-                               :notifier => self,
-                               :configuration => configuration,
-                               :logger => logger)
-
-        process_item(item)
-        log_and_return_item_data(item)
-      rescue StandardError => e
-        log_error "[Rollbar] Error sending failsafe : #{e}"
-      end
+      process_failsafe_item(failsafe_payload)
 
       failsafe_payload
     end
 
+    def process_failsafe_item(failsafe_payload)
+      item = build_item_with_payload(failsafe_payload)
+      process_item(item)
+      log_and_return_item_data(item)
+    rescue StandardError => e
+      log_error "[Rollbar] Error sending failsafe : #{e}"
+    end
+
     def failsafe_add_original_error_data(payload_notifier, original_error)
       return unless original_error
 
@@ -328,8 +328,10 @@ module Rollbar
     end
 
     def add_original_message(diagnostic, original_error)
-        diagnostic[:original_message] = original_error[:message].truncate(FAILSAFE_STRING_LENGTH) if original_error[:message]
-
+      if original_error[:message]
+        diagnostic[:original_message] =
+          original_error[:message].truncate(FAILSAFE_STRING_LENGTH)
+      end
     rescue StandardError => e
       diagnostic[:original_message] = "Failed: #{e.message}"
     end
@@ -343,7 +345,6 @@ module Rollbar
           :stack => backtrace && backtrace.join(', ').truncate(FAILSAFE_STRING_LENGTH)
         }
       end
-
     rescue StandardError => e
       diagnostic[:original_error] = "Failed: #{e.message}"
     end
@@ -351,9 +352,9 @@ module Rollbar
     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)
+        payload_notifier[:configured_options] =
+          ::JSON.generate(configured).truncate(FAILSAFE_STRING_LENGTH)
       end
-
     rescue StandardError => e
       payload_notifier[:configured_options] = "Failed: #{e.message}"
     end
@@ -390,7 +391,8 @@ module Rollbar
     end
 
     def enable_locals?
-      configuration.locals[:enabled] && [:app, :all].include?(configuration.send_extra_frame_data)
+      configuration.locals[:enabled] &&
+        [:app, :all].include?(configuration.send_extra_frame_data)
     end
 
     def enable_locals
@@ -412,13 +414,7 @@ module Rollbar
     end
 
     def call_before_process(options)
-      options = {
-        :level => options[:level],
-        :scope => scope_object,
-        :exception => options[:exception],
-        :message => options[:message],
-        :extra => options[:extra]
-      }
+      options = options_for_handler(options)
       handlers = configuration.before_process
 
       handlers.each do |handler|
@@ -435,24 +431,30 @@ module Rollbar
       end
     end
 
+    def options_for_handler(options)
+      {
+        :level => options[:level],
+        :scope => scope_object,
+        :exception => options[:exception],
+        :message => options[:message],
+        :extra => options[:extra]
+      }
+    end
+
     def extract_arguments(args)
-      message = nil
-      exception = nil
-      extra = nil
-      context = nil
+      message = exception = extra = context = nil
 
       args.each do |arg|
         if arg.is_a?(String)
           message = arg
         elsif arg.is_a?(Exception)
           exception = arg
-        elsif RUBY_PLATFORM == 'java' && arg.is_a?(java.lang.Throwable)
+        elsif java_exception?(arg)
           exception = arg
         elsif arg.is_a?(Hash)
           extra = arg
 
-          context = extra[:custom_data_method_context]
-          extra.delete :custom_data_method_context
+          context = extra.delete :custom_data_method_context
 
           extra = nil if extra.empty?
         end
@@ -461,6 +463,10 @@ module Rollbar
       [message, exception, extra, context]
     end
 
+    def java_exception?(obj)
+      RUBY_PLATFORM == 'java' && obj.is_a?(java.lang.Throwable)
+    end
+
     def lookup_exception_level(orig_level, exception, use_exception_level_filters)
       return orig_level unless use_exception_level_filters
 
@@ -491,7 +497,9 @@ module Rollbar
 
     def report(level, message, exception, extra, context)
       unless message || exception || extra
-        log_error '[Rollbar] Tried to send a report with no message, exception or extra data.'
+        log_error(
+          '[Rollbar] Tried to send a report with no message, exception or extra data.'
+        )
 
         return 'error'
       end
@@ -518,37 +526,48 @@ module Rollbar
       log_info "[Rollbar] Data: #{data}"
     end
 
-    # 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.
+    # 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, original_error = nil)
-      log_error '[Rollbar] Reporting internal error encountered while sending data to Rollbar.'
+      return if skip_reporting_internal_error(exception)
+
+      failsafe_message = ''
+      log_error(
+        '[Rollbar] Reporting internal error encountered while sending data to Rollbar.'
+      )
 
       configuration.execute_hook(:on_report_internal_error, exception)
 
-      begin
-        item = build_item('error', nil, exception, { :internal => true }, nil)
-      rescue StandardError => e
-        send_failsafe('build_item in exception_data', e, original_error)
-        log_error "[Rollbar] Exception: #{exception}"
-        return
-      end
+      failsafe_message = 'build_item in exception_data'
+      item = build_item('error', nil, exception, { :internal => true }, nil)
 
-      begin
-        process_item(item)
-      rescue StandardError => e
-        send_failsafe('error in process_item', e, original_error)
-        log_error "[Rollbar] Item: #{item}"
-        return
-      end
+      failsafe_message = 'error in process_item'
+      process_item(item)
 
-      begin
-        log_instance_link(item['data'])
-      rescue StandardError => e
-        send_failsafe('error logging instance link', e, original_error)
-        log_error "[Rollbar] Item: #{item}"
-        return
+      failsafe_message = 'error logging instance link'
+      log_instance_link(item['data'])
+    rescue StandardError => e
+      send_failsafe(failsafe_message, e, original_error)
+      log_error(item ? "[Rollbar] Item: #{item}" : "[Rollbar] Exception: #{exception}")
+    end
+
+    def skip_reporting_internal_error(exception)
+      return true if configuration.ignore_internal_errors == true
+
+      configuration.ignore_internal_errors.each do |error_name|
+        begin
+          error_cls = error_name.split('::').reduce(Module, :const_get)
+          return true if exception.class <= error_cls
+        rescue NameError
+          # Ignore errors and continue matching.
+          # It's possible for a class name in the list to not be resolvable,
+          # and this is ok.
+        end
       end
+
+      false
     end
 
     ## Payload building functions
@@ -579,7 +598,8 @@ module Rollbar
 
       headers = { 'X-Rollbar-Access-Token' => configuration.access_token }
       options = http_proxy_for_em(uri)
-      req = EventMachine::HttpRequest.new(uri.to_s, options).post(:body => body, :head => headers)
+      req = EventMachine::HttpRequest.new(uri.to_s, options).post(:body => body,
+                                                                  :head => headers)
 
       eventmachine_callback(req)
       eventmachine_errback(req)
@@ -590,7 +610,8 @@ module Rollbar
         if req.response_header.status == 200
           log_info '[Rollbar] Success'
         else
-          log_warning "[Rollbar] Got unexpected status code from Rollbar.io api: #{req.response_header.status}"
+          log_warning '[Rollbar] Got unexpected status code from Rollbar.io api: ' \
+            "#{req.response_header.status}"
           log_info "[Rollbar] Response: #{req.response}"
         end
       end
@@ -598,7 +619,9 @@ module Rollbar
 
     def eventmachine_errback(req)
       req.errback do
-        log_warning "[Rollbar] Call to API failed, status code: #{req.response_header.status}"
+        log_warning(
+          "[Rollbar] Call to API failed, status code: #{req.response_header.status}"
+        )
         log_info "[Rollbar] Error's response: #{req.response}"
       end
     end
@@ -626,29 +649,44 @@ module Rollbar
     end
 
     def do_post(uri, body, access_token)
+      http = init_http(uri)
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+
+      request.body = pack_ruby260_bytes(body)
+
+      # Ensure the payload token will be used if the option is set.
+      unless configuration.use_payload_access_token
+        request.add_field('X-Rollbar-Access-Token', access_token)
+      end
+
+      handle_net_retries { http.request(request) }
+    end
+
+    def init_http(uri)
       proxy = http_proxy(uri)
-      http  = Net::HTTP.new(uri.host, uri.port, proxy.host, proxy.port, proxy.user, proxy.password)
+      http  = Net::HTTP.new(uri.host, uri.port, proxy.host, proxy.port, proxy.user,
+                            proxy.password)
 
-      http.open_timeout = configuration.open_timeout
-      http.read_timeout = configuration.request_timeout
+      init_http_timeouts(http)
 
       if uri.scheme == 'https'
         http.use_ssl = true
         http.verify_mode = ssl_verify_mode
       end
 
-      request = Net::HTTP::Post.new(uri.request_uri)
-
-      request.body = pack_ruby260_bytes(body)
-      request.add_field('X-Rollbar-Access-Token', access_token)
+      http
+    end
 
-      handle_net_retries { http.request(request) }
+    def init_http_timeouts(http)
+      http.open_timeout = configuration.open_timeout
+      http.read_timeout = configuration.request_timeout
     end
 
     def pack_ruby260_bytes(body)
       # Ruby 2.6.0 shipped with a bug affecting multi-byte body for Net::HTTP.
       # Fix (committed one day after 2.6.0p0 shipped) is here:
-      # https://github.com/ruby/ruby/commit/1680a13a926b17661329beec1ded6b32aad16c1b#diff-00a99d8c71daaf5fc60a050da41f7261
+      # ruby/ruby/commit/1680a13a926b17661329beec1ded6b32aad16c1b
       #
       # We work around this by repacking the body as single byte chars if needed.
       if RUBY_VERSION == '2.6.0' && multibyte?(body)
@@ -698,8 +736,6 @@ module Rollbar
     end
 
     def handle_net_retries
-      return yield if skip_retries?
-
       retries = configuration.net_retries - 1
 
       begin
@@ -713,15 +749,13 @@ module Rollbar
       end
     end
 
-    def skip_retries?
-      Rollbar::LanguageSupport.ruby_19?
-    end
-
     def handle_response(response)
       if response.code == '200'
         log_info '[Rollbar] Success'
       else
-        log_warning "[Rollbar] Got unexpected status code from Rollbar api: #{response.code}"
+        log_warning(
+          "[Rollbar] Got unexpected status code from Rollbar api: #{response.code}"
+        )
         log_info "[Rollbar] Response: #{response.body}"
         configuration.execute_hook(:on_error_response, response)
       end
@@ -741,11 +775,7 @@ module Rollbar
       body = item.dump
       return unless body
 
-      file_name = if configuration.files_with_pid_name_enabled
-                    configuration.filepath.gsub(EXTENSION_REGEXP, "_#{Process.pid}\\0")
-                  else
-                    configuration.filepath
-                  end
+      file_name = file_name_with_pid(configuration)
 
       begin
         @file ||= File.open(file_name, 'a')
@@ -760,11 +790,22 @@ module Rollbar
       end
     end
 
+    def file_name_with_pid(configuration)
+      if configuration.files_with_pid_name_enabled
+        configuration.filepath.gsub(EXTENSION_REGEXP, "_#{Process.pid}\\0")
+      else
+        configuration.filepath
+      end
+    end
+
     def update_file(file, file_name)
       return unless configuration.files_processed_enabled
 
       time_now = Time.now
-      return if configuration.files_processed_duration > time_now - file.birthtime && file.size < configuration.files_processed_size
+      if configuration.files_processed_duration > time_now - file.birthtime &&
+         file.size < configuration.files_processed_size
+        return
+      end
 
       new_file_name = file_name.gsub(EXTENSION_REGEXP, "_processed_#{time_now.to_i}\\0")
       File.rename(file, new_file_name)
@@ -773,31 +814,30 @@ module Rollbar
     end
 
     def failsafe_reason(message, exception)
-      body = ''
+      return failsafe_exception_reason(message, exception) if exception
 
-      if exception
-        begin
-          backtrace = exception.backtrace || []
-          nearest_frame = backtrace[0]
+      message.to_s
+    rescue StandardError
+      log_error('[Rollbar] Error building failsafe message')
+      ''
+    end
 
-          exception_info = exception.class.name
-          # #to_s and #message defaults to class.to_s. Add message only if add valuable info.
-          exception_info += %[: "#{exception.message}"] if exception.message != exception.class.to_s
-          exception_info += " in #{nearest_frame}" if nearest_frame
+    def failsafe_exception_reason(message, exception)
+      backtrace = exception.backtrace || []
+      nearest_frame = backtrace[0]
 
-          body += "#{exception_info}: #{message}"
-        rescue StandardError
-          log_error('[Rollbar] Error building failsafe exception message')
-        end
-      else
-        begin
-          body += message.to_s
-        rescue StandardError
-          log_error('[Rollbar] Error building failsafe message')
-        end
+      exception_info = exception.class.name
+      # #to_s and #message defaults to class.to_s.
+      # Add message only if add valuable info.
+      if exception.message != exception.class.to_s
+        exception_info += %[: "#{exception.message}"]
       end
+      exception_info += " in #{nearest_frame}" if nearest_frame
 
-      body
+      "#{exception_info}: #{message}"
+    rescue StandardError
+      log_error('[Rollbar] Error building failsafe exception message')
+      ''
     end
 
     def failsafe_body(reason)
@@ -830,7 +870,8 @@ module Rollbar
       configuration.async_handler.call(payload)
     rescue StandardError
       if configuration.failover_handlers.empty?
-        log_error '[Rollbar] Async handler failed, and there are no failover handlers configured. See the docs for "failover_handlers"'
+        log_error '[Rollbar] Async handler failed, and there are no failover ' \
+          'handlers configured. See the docs for "failover_handlers"'
         return
       end
 
@@ -848,7 +889,8 @@ module Rollbar
         rescue StandardError
           next unless handler == failover_handlers.last
 
-          log_error "[Rollbar] All failover handlers failed while processing item: #{Rollbar::JSON.dump(item.payload)}"
+          log_error '[Rollbar] All failover handlers failed while processing ' \
+            "item: #{Rollbar::JSON.dump(item.payload)}"
         end
       end
     end
@@ -859,7 +901,9 @@ module Rollbar
       return unless data[:uuid]
 
       uuid_url = Util.uuid_rollbar_url(data, configuration)
-      log_info "[Rollbar] Details: #{uuid_url} (only available if report was successful)"
+      log_info(
+        "[Rollbar] Details: #{uuid_url} (only available if report was successful)"
+      )
     end
 
     def via_failsafe?(item)

data/lib/rollbar/plugin.rb

@@ -4,12 +4,8 @@ module Rollbar
   # On Rollbar initialization, all plugins will be saved in memory and those that
   # satisfy the dependencies will be loaded
   class Plugin
-    attr_reader :name
-    attr_reader :dependencies
-    attr_reader :callables
-    attr_reader :revert_callables
-    attr_accessor :on_demand
-    attr_accessor :loaded
+    attr_reader :name, :dependencies, :callables, :revert_callables
+    attr_accessor :on_demand, :loaded
 
     private :loaded=
 
@@ -116,11 +112,15 @@ module Rollbar
     end
 
     def log_loading_error(error)
-      Rollbar.log_error("Error trying to load plugin '#{name}': #{error.class}, #{error.message}")
+      Rollbar.log_error(
+        "Error trying to load plugin '#{name}': #{error.class}, #{error.message}"
+      )
     end
 
     def log_unloading_error(error)
-      Rollbar.log_error("Error trying to unload plugin '#{name}': #{error.class}, #{error.message}")
+      Rollbar.log_error(
+        "Error trying to unload plugin '#{name}': #{error.class}, #{error.message}"
+      )
     end
   end
 end

data/lib/rollbar/plugins/active_job.rb

@@ -3,11 +3,17 @@ module Rollbar
   module ActiveJob
     def self.included(base)
       base.send :rescue_from, Exception do |exception|
+        args = if self.class.respond_to?(:log_arguments?) && !self.class.log_arguments?
+                 arguments.map(&Rollbar::Scrubbers.method(:scrub_value))
+               else
+                 arguments
+               end
+
         Rollbar.error(exception,
                       :job => self.class.name,
                       :job_id => job_id,
                       :use_exception_level_filters => true,
-                      :arguments => arguments)
+                      :arguments => args)
         raise exception
       end
     end
@@ -17,6 +23,13 @@ end
 if defined?(ActiveSupport) && ActiveSupport.respond_to?(:on_load)
   ActiveSupport.on_load(:action_mailer) do
     # Automatically add to ActionMailer::DeliveryJob
-    ActionMailer::DeliveryJob.send(:include, Rollbar::ActiveJob) if defined?(ActionMailer::DeliveryJob)
+    if defined?(ActionMailer::DeliveryJob)
+      ActionMailer::DeliveryJob.send(:include,
+                                     Rollbar::ActiveJob)
+    end
+    # Rails >= 6.0
+    if defined?(ActionMailer::MailDeliveryJob)
+      ActionMailer::MailDeliveryJob.send(:include, Rollbar::ActiveJob)
+    end
   end
 end

data/lib/rollbar/plugins/delayed_job/plugin.rb

@@ -15,9 +15,15 @@ module Rollbar
 
           # DelayedJob < 4.1 doesn't provide job#error
           if job.class.method_defined? :error
-            ::Rollbar.scope(:request => data).error(job.error, :use_exception_level_filters => true) if job.error
+            if job.error
+              ::Rollbar.scope(:request => data)
+                       .error(job.error, :use_exception_level_filters => true)
+            end
           elsif job.last_error
-            ::Rollbar.scope(:request => data).error("Job has failed and won't be retried anymore: " + job.last_error, :use_exception_level_filters => true)
+            ::Rollbar.scope(:request => data).error(
+              "Job has failed and won't be retried anymore: #{job.last_error}",
+              :use_exception_level_filters => true
+            )
           end
         end
       end
@@ -56,10 +62,15 @@ module Rollbar
 
       data = build_job_data(job)
 
-      ::Rollbar.scope(:request => data).error(e, :use_exception_level_filters => true)
+      ::Rollbar.scope(:request => data)
+               .error(e, :use_exception_level_filters => true)
     end
 
     def self.skip_report?(job)
+      handler = ::Rollbar.configuration.async_skip_report_handler
+
+      return handler.call(job) if handler.respond_to?(:call)
+
       job.attempts < ::Rollbar.configuration.dj_threshold
     end