rollbar 2.22.1 → 3.4.0

data/lib/rollbar/notifier.rb

@@ -15,11 +15,11 @@ 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
 
-    @file_semaphore = Mutex.new
+    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
@@ -32,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!
@@ -103,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
@@ -117,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?
@@ -132,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)
@@ -154,10 +147,27 @@ 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
-      report_internal_error(e)
+      original_error = {
+        :message => message,
+        :exception => exception,
+        :configuration => configuration
+      }
+
+      report_internal_error(e, original_error)
 
       'error'
     end
@@ -194,24 +204,23 @@ 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
-          @file_semaphore.synchronize do
-            write_item(item)
-          end
-        else
-          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}")
-      raise e
+      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')
     end
 
     # We will reraise exceptions in this method so async queues
@@ -238,16 +247,16 @@ module Rollbar
     # Using Rollbar.silenced we avoid the above behavior but Sidekiq
     # will have a chance to retry the original job.
     def process_from_async_handler(payload)
-      payload = Rollbar::JSON.load(payload) if payload.is_a?(String)
-
-      item = Item.build_with(payload,
-                             :notifier => self,
-                             :configuration => configuration,
-                             :logger => logger)
-
       Rollbar.silenced do
         begin
-          process_item(item)
+          if payload.is_a?(String)
+            # The final payload has already been built.
+            send_body(payload)
+          else
+            item = build_item_with_payload(payload)
+
+            process_item(item)
+          end
         rescue StandardError => e
           report_internal_error(e)
 
@@ -256,51 +265,108 @@ 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)
+    def build_item_with_payload(payload)
+      Item.build_with(payload, :notifier => self,
+                               :configuration => configuration,
+                               :logger => logger)
+    end
 
-      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
+        '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
       }
 
-      begin
-        item = Item.build_with(failsafe_payload,
-                               :notifier => self,
-                               :configuration => configuration,
-                               :logger => logger)
-        schedule_item(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
+
+      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)
+      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
+
+    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|
@@ -325,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
@@ -347,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|
@@ -370,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
@@ -396,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
 
@@ -426,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
@@ -453,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.
-    def report_internal_error(exception)
-      log_error '[Rollbar] Reporting internal error encountered while sending data to 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, original_error = nil)
+      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)
-        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)
-        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)
-        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
@@ -509,25 +593,35 @@ module Rollbar
 
     ## Delivery functions
 
-    def send_item_using_eventmachine(item, uri)
-      body = item.dump
-      return unless body
+    def send_using_eventmachine(body)
+      uri = URI.parse(configuration.endpoint)
 
-      headers = { 'X-Rollbar-Access-Token' => item['access_token'] }
+      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)
+    end
 
+    def eventmachine_callback(req)
       req.callback do
         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
+    end
 
+    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
@@ -538,40 +632,61 @@ module Rollbar
       body = item.dump
       return unless body
 
-      uri = URI.parse(configuration.endpoint)
-
       if configuration.use_eventmachine
-        send_item_using_eventmachine(item, uri)
+        send_using_eventmachine(body)
         return
       end
 
-      handle_response(do_post(uri, body, item['access_token']))
+      send_body(body)
+    end
+
+    def send_body(body)
+      log_info '[Rollbar] Sending json'
+
+      uri = URI.parse(configuration.endpoint)
+
+      handle_response(do_post(uri, body, configuration.access_token))
     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)
@@ -621,8 +736,6 @@ module Rollbar
     end
 
     def handle_net_retries
-      return yield if skip_retries?
-
       retries = configuration.net_retries - 1
 
       begin
@@ -636,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
@@ -658,27 +769,20 @@ module Rollbar
       end
     end
 
-    def write_item(item)
-      if configuration.use_async
-        @file_semaphore.synchronize do
-          do_write_item(item)
-        end
-      else
-        do_write_item(item)
-      end
-    end
-
     def do_write_item(item)
       log_info '[Rollbar] Writing item to file'
 
       body = item.dump
       return unless body
 
+      file_name = file_name_with_pid(configuration)
+
       begin
-        @file ||= File.open(configuration.filepath, 'a')
+        @file ||= File.open(file_name, 'a')
 
         @file.puts(body)
         @file.flush
+        update_file(@file, file_name)
 
         log_info '[Rollbar] Success'
       rescue IOError => e
@@ -686,32 +790,54 @@ 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
+      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)
+      file.close
+      @file = File.open(file_name, 'a')
+    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)
@@ -737,11 +863,15 @@ module Rollbar
     end
 
     def process_async_item(item)
+      # Send async payloads as JSON string when async_json_payload is set.
+      payload = configuration.async_json_payload ? item.dump : item.payload
+
       configuration.async_handler ||= default_async_handler
-      configuration.async_handler.call(item.payload)
+      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
 
@@ -759,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
@@ -770,7 +901,13 @@ 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)
+      item.payload.fetch('data', {}).fetch('failsafe', false)
     end
   end
 end