rollbar 2.8.3 → 3.6.0

data/lib/rollbar/delay/thread.rb

@@ -1,15 +1,86 @@
+require 'timeout'
+
 module Rollbar
   module Delay
     class Thread
-      def self.call(payload)
-        new.call(payload)
+      EXIT_SIGNAL  = :exit
+      EXIT_TIMEOUT = 6
+
+      Error        = Class.new(StandardError)
+      TimeoutError = Class.new(Error)
+
+      DEFAULT_PRIORITY = 1
+
+      class << self
+        attr_writer :options
+        attr_reader :reaper
+
+        def call(payload)
+          spawn_threads_reaper
+
+          thread = new.call(payload)
+          threads << thread
+          thread
+        end
+
+        def options
+          @options || {}
+        end
+
+        private
+
+        def threads
+          @threads ||= Queue.new
+        end
+
+        def spawn_threads_reaper
+          return if @spawned
+
+          @spawned = true
+
+          @reaper ||= build_reaper_thread
+          configure_exit_handler
+        end
+
+        def build_reaper_thread
+          ::Thread.start do
+            loop do
+              thread = threads.pop
+
+              break if thread == EXIT_SIGNAL
+
+              thread.join
+            end
+          end
+        end
+
+        def configure_exit_handler
+          at_exit do
+            begin
+              Timeout.timeout(EXIT_TIMEOUT) do
+                threads << EXIT_SIGNAL
+                reaper.join
+              end
+            rescue Timeout::Error
+              raise TimeoutError,
+                    "unable to reap all threads within #{EXIT_TIMEOUT} seconds"
+            end
+          end
+        end
+      end
+
+      def priority
+        self.class.options[:priority] || DEFAULT_PRIORITY
       end
 
       def call(payload)
+        priority = self.priority
+
         ::Thread.new do
           begin
+            ::Thread.current.priority = priority
             Rollbar.process_from_async_handler(payload)
-          rescue
+          rescue StandardError
             # Here we swallow the exception:
             # 1. The original report wasn't sent.
             # 2. An internal error was sent and logged

data/lib/rollbar/deploy.rb

@@ -0,0 +1,91 @@
+require 'json'
+
+module Rollbar
+  # Deploy Tracking API wrapper module
+  module Deploy
+    ENDPOINT = 'https://api.rollbar.com/api/1/deploy/'.freeze
+
+    def self.report(opts, access_token, environment, revision)
+      return {} unless access_token && !access_token.empty?
+
+      opts[:status] ||= :started
+
+      uri = ::URI.parse(::Rollbar::Deploy::ENDPOINT)
+
+      request_data = {
+        :access_token => access_token,
+        :environment => environment,
+        :revision => revision
+      }.merge(opts)
+      request_data.delete(:proxy)
+      request_data.delete(:dry_run)
+
+      request = ::Net::HTTP::Post.new(uri.request_uri)
+      request.body = ::JSON.dump(request_data)
+
+      send_request(opts, uri, request)
+    end
+
+    def self.update(opts, access_token, deploy_id, status)
+      return {} unless access_token && !access_token.empty?
+
+      uri = ::URI.parse(
+        "#{::Rollbar::Deploy::ENDPOINT}#{deploy_id}?access_token=#{access_token}"
+      )
+
+      request = ::Net::HTTP::Patch.new(uri.request_uri)
+      request.body = ::JSON.dump(:status => status.to_s, :comment => opts[:comment])
+
+      send_request(opts, uri, request)
+    end
+
+    class << self
+      private
+
+      def send_request(opts, uri, request)
+        ::Net::HTTP.start(uri.host, uri.port, opts[:proxy], :use_ssl => true) do |http|
+          build_result(
+            uri,
+            request,
+            opts[:dry_run] ? nil : http.request(request),
+            opts[:dry_run]
+          )
+        end
+      end
+
+      def build_result(uri, request, response = nil, dry_run = false)
+        result = {}
+        result.merge!(request_result(uri, request))
+        result.merge!(response_result(response)) unless response.nil?
+        result[:success] = success?(result, dry_run)
+        result
+      end
+
+      def success?(result, dry_run = false)
+        return true if dry_run
+
+        result[:response] &&
+          result[:response].is_a?(::Net::HTTPSuccess) &&
+          result[:response].code == '200' &&
+          (result.key?('err') ? result['err'].to_i.zero? : true)
+      end
+
+      def request_result(uri, request)
+        {
+          :request_info => "#{uri.inspect}: #{request.body}",
+          :request => request
+        }
+      end
+
+      def response_result(response)
+        code = response.code
+        message = response.message
+        body = response.body.delete("\n")
+        {
+          :response => response,
+          :response_info => "#{code}; #{message}; #{body}"
+        }.merge(::JSON.parse(response.body, :symbolize_names => true))
+      end
+    end
+  end
+end

data/lib/rollbar/encoding/encoder.rb

@@ -1,9 +1,10 @@
 module Rollbar
   module Encoding
     class Encoder
-      ALL_ENCODINGS = [::Encoding::UTF_8, ::Encoding::ISO_8859_1, ::Encoding::ASCII_8BIT, ::Encoding::US_ASCII]
-      ASCII_ENCODINGS = [::Encoding::US_ASCII, ::Encoding::ASCII_8BIT, ::Encoding::ISO_8859_1]
-      ENCODING_OPTIONS = { :invalid => :replace, :undef => :replace, :replace => '' }
+      ALL_ENCODINGS = [::Encoding::UTF_8, ::Encoding::ISO_8859_1, ::Encoding::ASCII_8BIT,
+                       ::Encoding::US_ASCII].freeze
+      ASCII_ENCODINGS = [::Encoding::US_ASCII, ::Encoding::ASCII_8BIT,
+                         ::Encoding::ISO_8859_1].freeze
       UTF8 = 'UTF-8'.freeze
       BINARY = 'binary'.freeze
 
@@ -18,13 +19,22 @@ module Rollbar
         encoding = value.encoding
 
         # This will be most of cases so avoid force anything for them
-        if encoding == ::Encoding::UTF_8 && value.valid_encoding?
-          encoded_value = value
-        else
-          encoded_value = force_encoding(value).encode(*encoding_args(value))
-        end
+        encoded_value = if encoding == ::Encoding::UTF_8 && value.valid_encoding?
+                          value
+                        else
+                          force_encoding(value).encode(
+                            *encoding_args(value),
+                            # Ruby 2.7 requires this to look like keyword args,
+                            # and Ruby 1.9.3 doesn't understand keyword args, so
+                            # don't use hash rockets here and both will be happy.
+                            invalid: :replace, undef: :replace, replace: '' # rubocop:disable Style/HashSyntax
+                          )
+                        end
 
         object.is_a?(Symbol) ? encoded_value.to_sym : encoded_value
+      rescue StandardError => e
+        # If encoding fails for any reason, replace the string with a diagnostic error.
+        "error encoding string: #{e.class}: #{e.message}"
       end
 
       private
@@ -32,7 +42,9 @@ module Rollbar
       def force_encoding(value)
         return value if value.frozen?
 
-        value.force_encoding(detect_encoding(value)) if value.encoding == ::Encoding::UTF_8
+        if value.encoding == ::Encoding::UTF_8
+          value.force_encoding(detect_encoding(value))
+        end
 
         value
       end
@@ -45,7 +57,7 @@ module Rollbar
             # Seems #codepoints is faster than #valid_encoding?
             value.force_encoding(encoding).encode(::Encoding::UTF_8).codepoints
             true
-          rescue
+          rescue StandardError
             false
           end
         end
@@ -54,7 +66,6 @@ module Rollbar
       def encoding_args(value)
         args = [UTF8]
         args << BINARY if ASCII_ENCODINGS.include?(value.encoding)
-        args << ENCODING_OPTIONS
 
         args
       end

data/lib/rollbar/encoding.rb

@@ -5,13 +5,8 @@ module Rollbar
     end
 
     def self.setup
-      if String.instance_methods.include?(:encode)
-        require 'rollbar/encoding/encoder'
-        self.encoding_class = Rollbar::Encoding::Encoder
-      else
-        require 'rollbar/encoding/legacy_encoder'
-        self.encoding_class = Rollbar::Encoding::LegacyEncoder
-      end
+      require 'rollbar/encoding/encoder'
+      self.encoding_class = Rollbar::Encoding::Encoder
     end
 
     def self.encode(object)

data/lib/rollbar/exception_reporter.rb

@@ -1,21 +1,45 @@
 module Rollbar
-  module ExceptionReporter
+  module ExceptionReporter # :nodoc:
     def report_exception_to_rollbar(env, exception)
-      exception_message = exception.respond_to?(:message) ? exception.message : 'No Exception Message'
-      Rollbar.log_debug "[Rollbar] Reporting exception: #{exception_message}"
+      return unless capture_uncaught?
+
+      log_exception_message(exception)
 
-      exception_data = Rollbar.log(Rollbar.configuration.uncaught_exception_level, exception, :use_exception_level_filters => true)
+      exception_data = exception_data(exception)
 
-      if exception_data.is_a?(Hash)
+      case exception_data
+      when Hash
         env['rollbar.exception_uuid'] = exception_data[:uuid]
-        Rollbar.log_debug "[Rollbar] Exception uuid saved in env: #{exception_data[:uuid]}"
-      elsif exception_data == 'disabled'
-        Rollbar.log_debug "[Rollbar] Exception not reported because Rollbar is disabled"
-      elsif exception_data == 'ignored'
-        Rollbar.log_debug "[Rollbar] Exception not reported because it was ignored"
+        Rollbar.log_debug(
+          "[Rollbar] Exception uuid saved in env: #{exception_data[:uuid]}"
+        )
+      when 'disabled'
+        Rollbar.log_debug(
+          '[Rollbar] Exception not reported because Rollbar is disabled'
+        )
+      when 'ignored'
+        Rollbar.log_debug '[Rollbar] Exception not reported because it was ignored'
       end
-    rescue => e
-      Rollbar.log_warning "[Rollbar] Exception while reporting exception to Rollbar: #{e.message}"
+    rescue StandardError => e
+      Rollbar.log_warning(
+        "[Rollbar] Exception while reporting exception to Rollbar: #{e.message}"
+      )
+    end
+
+    def capture_uncaught?
+      Rollbar.configuration.capture_uncaught != false &&
+        !Rollbar.configuration.enable_rails_error_subscriber
+    end
+
+    def log_exception_message(exception)
+      exception_message = exception.message if exception.respond_to?(:message)
+      exception_message ||= 'No Exception Message'
+      Rollbar.log_debug "[Rollbar] Reporting exception: #{exception_message}"
+    end
+
+    def exception_data(exception)
+      Rollbar.log(Rollbar.configuration.uncaught_exception_level, exception,
+                  :use_exception_level_filters => true)
     end
   end
 end

data/lib/rollbar/item/backtrace.rb

@@ -0,0 +1,118 @@
+require 'rollbar/item/frame'
+
+module Rollbar
+  class Item
+    class Backtrace
+      attr_reader :exception, :message, :extra, :configuration, :files
+
+      private :files
+
+      def initialize(exception, options = {})
+        @exception = exception
+        @message = options[:message]
+        @extra = options[:extra]
+        @configuration = options[:configuration]
+        @files = {}
+      end
+
+      def to_h
+        traces = trace_chain
+
+        traces[0][:exception][:description] = message if message
+        traces[0][:extra] = extra if extra
+
+        if traces.size > 1
+          { :trace_chain => traces }
+        elsif traces.size == 1
+          { :trace => traces[0] }
+        end
+      end
+
+      alias build to_h
+
+      def get_file_lines(filename)
+        files[filename] ||= read_file(filename)
+      end
+
+      private
+
+      def read_file(filename)
+        return unless File.exist?(filename)
+
+        File.read(filename).split("\n")
+      rescue StandardError
+        nil
+      end
+
+      def trace_chain
+        traces = [trace_data(exception)]
+        visited = [exception]
+
+        current_exception = exception
+
+        while current_exception.respond_to?(:cause) &&
+              (cause = current_exception.cause) &&
+              cause.is_a?(Exception) &&
+              !visited.include?(cause)
+          traces << trace_data(cause)
+          visited << cause
+          current_exception = cause
+        end
+
+        traces
+      end
+
+      def trace_data(current_exception)
+        {
+          :frames => map_frames(current_exception),
+          :exception => {
+            :class => current_exception.class.name,
+            :message => current_exception.message
+          }
+        }
+      end
+
+      def map_frames(current_exception)
+        frames = cleaned_backtrace(current_exception).map do |frame|
+          Rollbar::Item::Frame.new(self, frame,
+                                   :configuration => configuration).to_h
+        end
+        frames.reverse!
+      end
+
+      def cleaned_backtrace(current_exception)
+        normalized_backtrace = exception_backtrace(current_exception)
+        if configuration.backtrace_cleaner
+          configuration.backtrace_cleaner.clean(normalized_backtrace)
+        else
+          normalized_backtrace
+        end
+      end
+
+      # Returns the backtrace to be sent to our API. There are 3 options:
+      #
+      # 1. The exception received has a backtrace, then that backtrace is returned.
+      # 2. configuration.populate_empty_backtraces is disabled, we return [] here
+      # 3. The user has configuration.populate_empty_backtraces is enabled, then:
+      #
+      # We want to send the caller as backtrace, but the first lines of that array
+      # are those from the user's Rollbar.error line until this method. We want
+      # to remove those lines.
+      def exception_backtrace(current_exception)
+        if current_exception.backtrace.respond_to?(:map)
+          return current_exception.backtrace
+        end
+        return [] unless configuration.populate_empty_backtraces
+
+        caller_backtrace = caller
+        caller_backtrace.shift while caller_backtrace[0].include?(rollbar_lib_gem_dir)
+        caller_backtrace
+      end
+
+      def rollbar_lib_gem_dir
+        gem_dir = Gem::Specification.find_by_name('rollbar').gem_dir
+        "#{gem_dir}/lib"
+      end
+    end
+  end
+end

data/lib/rollbar/item/frame.rb

@@ -0,0 +1,121 @@
+# We want to use Gem.path
+require 'rubygems'
+require 'rollbar/item/locals'
+
+module Rollbar
+  class Item
+    # Representation of the trace data per frame in the payload
+    class Frame
+      attr_reader :backtrace, :frame, :configuration
+
+      MAX_CONTEXT_LENGTH = 4
+
+      def initialize(backtrace, frame, options = {})
+        @backtrace = backtrace
+        @frame = frame
+        @configuration = options[:configuration]
+      end
+
+      def to_h
+        # parse the line
+        match = frame.match(/(.*):(\d+)(?::in `([^']+)')?/)
+
+        return unknown_frame unless match
+
+        filename = match[1]
+        lineno = match[2].to_i
+        frame_data = {
+          :filename => filename,
+          :lineno => lineno,
+          :method => match[3]
+        }
+
+        frame_data.merge(extra_frame_data(filename, lineno))
+      end
+
+      private
+
+      def unknown_frame
+        { :filename => '<unknown>', :lineno => 0, :method => frame }
+      end
+
+      def extra_frame_data(filename, lineno)
+        file_lines = backtrace.get_file_lines(filename)
+
+        return {} if skip_extra_frame_data?(filename, file_lines)
+
+        {
+          :code => code_data(file_lines, lineno),
+          :context => context_data(file_lines, lineno),
+          :locals => locals_data(filename, lineno)
+        }
+      end
+
+      def skip_extra_frame_data?(filename, file_lines)
+        config = configuration.send_extra_frame_data
+        missing_file_lines = !file_lines || file_lines.empty?
+
+        return false if !missing_file_lines && config == :all
+
+        missing_file_lines ||
+          config == :none ||
+          config == :app && outside_project?(filename)
+      end
+
+      def outside_project?(filename)
+        project_gem_paths = configuration.project_gem_paths
+        inside_project_gem_paths = project_gem_paths.any? do |path|
+          filename.start_with?(path)
+        end
+
+        # The file is inside the configuration.project_gem_paths,
+        return false if inside_project_gem_paths
+
+        root = configuration.root
+        inside_root = root && filename.start_with?(root.to_s)
+
+        # The file is outside the configuration.root
+        return true unless inside_root
+
+        # At this point, the file is inside the configuration.root.
+        # Since it's common to have gems installed in {root}/vendor/bundle,
+        # let's check it's in any of the Gem.path paths
+        Gem.path.any? { |path| filename.start_with?(path) }
+      end
+
+      def code_data(file_lines, lineno)
+        file_lines[lineno - 1]
+      end
+
+      def context_data(file_lines, lineno)
+        {
+          :pre => pre_data(file_lines, lineno),
+          :post => post_data(file_lines, lineno)
+        }
+      end
+
+      def locals_data(filename, lineno)
+        return unless configuration.locals[:enabled]
+
+        ::Rollbar::Item::Locals.locals_for_location(filename, lineno)
+      end
+
+      def post_data(file_lines, lineno)
+        from_line = lineno
+        number_of_lines = [from_line + MAX_CONTEXT_LENGTH,
+                           file_lines.size].min - from_line
+
+        file_lines[from_line, number_of_lines]
+      end
+
+      def pre_data(file_lines, lineno)
+        to_line = lineno - 2
+        from_line = [to_line - MAX_CONTEXT_LENGTH + 1, 0].max
+
+        file_lines[from_line, (to_line - from_line + 1)].select do |line|
+          line && !line.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/item/locals.rb

@@ -0,0 +1,103 @@
+require 'rollbar/scrubbers/params'
+require 'rollbar/util'
+
+module Rollbar
+  class Item
+    class Locals # :nodoc:
+      class << self
+        def exception_frames
+          Rollbar.notifier.exception_bindings
+        end
+
+        def locals_for_location(filename, lineno)
+          if (frame = frame_for_location(filename, lineno))
+            scrub(locals_for(frame[:binding]))
+          else
+            {}
+          end
+        end
+
+        def frame_for_location(filename, lineno)
+          while (frame = exception_frames.pop)
+            return nil unless frame
+            return frame if matching_frame?(frame, filename, lineno)
+          end
+          nil
+        end
+
+        private
+
+        def matching_frame?(frame, filename, lineno)
+          frame[:path] == filename && frame[:lineno].to_i <= lineno.to_i
+        end
+
+        def locals_for(frame)
+          return {} unless frame
+
+          {}.tap do |hash|
+            frame.local_variables.map do |var|
+              hash[var] = prepare_value(frame.local_variable_get(var))
+            end
+          end
+        end
+
+        # Prepare objects to be handled by the payload serializer.
+        #
+        # Hashes and Arrays are traversed. Then all types execpt strings and
+        # immediates are exported using #inspect. Sending the object itself to the
+        # serializer can result in large recursive expansions, especially in Rails
+        # environments with ActiveRecord, ActiveSupport, etc. on the stack.
+        # Other export options could be #to_s, #to_h, and #as_json. Several of these
+        # will omit the class name, or are not implemented for many types.
+        #
+        # #inspect has the advantage that it is specifically intended for debugging
+        # output. If the user wants more or different information in the payload
+        # about a specific type, #inspect is the correct place to implement it.
+        # Likewise the default implementation should be oriented toward usefulness
+        # in debugging.
+        #
+        # Because #inspect outputs a string, it can be handled well by the string
+        # truncation strategy for large payloads.
+        #
+        def prepare_value(value)
+          unless value.is_a?(Hash) || value.is_a?(Array)
+            return simple_value?(value) ? value : value.inspect
+          end
+
+          cloned_value = ::Rollbar::Util.deep_copy(value)
+          ::Rollbar::Util.iterate_and_update_with_block(cloned_value) do |v|
+            simple_value?(v) ? v : v.inspect
+          end
+
+          cloned_value
+        end
+
+        def simple_classes
+          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.4.0')
+            [String, Symbol, Integer, Float, TrueClass, FalseClass, NilClass]
+          else
+            [String, Symbol, Fixnum, Bignum, Float, TrueClass, FalseClass, NilClass] # rubocop:disable Lint/UnifiedInteger
+          end
+        end
+
+        def simple_value?(value)
+          simple_classes.each do |klass|
+            # Use instance_of? so that subclasses and module containers will
+            # be treated like complex object types, not simple values.
+            return true if value.instance_of?(klass)
+          end
+
+          false
+        end
+
+        def scrub(hash)
+          Rollbar::Scrubbers::Params.call(
+            :params => hash,
+            :config => Rollbar.configuration.scrub_fields,
+            :whitelist => Rollbar.configuration.scrub_whitelist
+          )
+        end
+      end
+    end
+  end
+end