rollbar 2.12.0 → 2.13.0

data/lib/rollbar/configuration.rb

@@ -2,6 +2,7 @@ require 'logger'
 
 module Rollbar
   class Configuration
+    SEND_EXTRA_FRAME_DATA_OPTIONS = [:none, :app, :all].freeze
 
     attr_accessor :access_token
     attr_accessor :async_handler
@@ -52,6 +53,7 @@ module Rollbar
     attr_accessor :use_eventmachine
     attr_accessor :web_base
     attr_accessor :write_to_file
+    attr_reader :send_extra_frame_data
 
     attr_reader :project_gem_paths
 
@@ -111,6 +113,8 @@ module Rollbar
       @verify_ssl_peer = true
       @web_base = DEFAULT_WEB_BASE
       @write_to_file = false
+      @send_extra_frame_data = :none
+      @project_gem_paths = []
     end
 
     def initialize_copy(orig)
@@ -122,6 +126,24 @@ module Rollbar
       end
     end
 
+    def merge(options)
+      new_configuration = clone
+      new_configuration.merge!(options)
+
+      new_configuration
+    end
+
+    def merge!(options)
+      options.each do |name, value|
+        variable_name = "@#{name}"
+        next unless instance_variable_defined?(variable_name)
+
+        instance_variable_set(variable_name, value)
+      end
+
+      self
+    end
+
     def use_delayed_job
       require 'rollbar/delay/delayed_job'
       @use_async      = true
@@ -192,6 +214,16 @@ module Rollbar
       @transform = Array(handler)
     end
 
+    def send_extra_frame_data=(value)
+      unless SEND_EXTRA_FRAME_DATA_OPTIONS.include?(value)
+        logger.warning("Wrong 'send_extra_frame_data' value, :none, :app or :full is expected")
+
+        return
+      end
+
+      @send_extra_frame_data = value
+    end
+
     # allow params to be read like a hash
     def [](option)
       send(option)

data/lib/rollbar/item.rb

@@ -10,6 +10,8 @@ end
 require 'rollbar/item/backtrace'
 require 'rollbar/util'
 require 'rollbar/encoding'
+require 'rollbar/truncation'
+require 'rollbar/json'
 
 module Rollbar
   # This class represents the payload to be sent to the API.
@@ -82,7 +84,7 @@ module Rollbar
         },
         :body => build_body
       }
-      data[:project_package_paths] = configuration.project_gem_paths if configuration.project_gem_paths
+      data[:project_package_paths] = configuration.project_gem_paths if configuration.project_gem_paths.any?
       data[:code_version] = configuration.code_version if configuration.code_version
       data[:uuid] = SecureRandom.uuid if defined?(SecureRandom) && SecureRandom.respond_to?(:uuid)
 
@@ -101,16 +103,24 @@ module Rollbar
       # from an async handler job, which can be serialized.
       stringified_payload = Util::Hash.deep_stringify_keys(payload)
       result = Truncation.truncate(stringified_payload)
+
       return result unless Truncation.truncate?(result)
 
-      original_size = Rollbar::JSON.dump(payload).bytesize
-      final_size = result.bytesize
-      notifier.send_failsafe("Could not send payload due to it being too large after truncating attempts. Original size: #{original_size} Final size: #{final_size}", nil)
-      logger.error("[Rollbar] Payload too large to be sent: #{Rollbar::JSON.dump(payload)}")
+      handle_too_large_payload(stringified_payload, result)
 
       nil
     end
 
+    def handle_too_large_payload(stringified_payload, final_payload)
+      original_size = Rollbar::JSON.dump(stringified_payload).bytesize
+      final_size = final_payload.bytesize
+      uuid = stringified_payload['data']['uuid']
+      host = stringified_payload['data'].fetch('server', {})['host']
+
+      notifier.send_failsafe("Could not send payload due to it being too large after truncating attempts. Original size: #{original_size} Final size: #{final_size}", nil, uuid, host)
+      logger.error("[Rollbar] Payload too large to be sent for UUID #{uuid}: #{Rollbar::JSON.dump(payload)}")
+    end
+
     def ignored?
       data = payload['data']
 
@@ -140,7 +150,7 @@ module Rollbar
                                 :configuration => configuration
                                )
 
-      backtrace.build
+      backtrace.to_h
     end
 
     def build_extra

data/lib/rollbar/item/backtrace.rb

@@ -1,3 +1,5 @@
+require 'rollbar/item/frame'
+
 module Rollbar
   class Item
     class Backtrace
@@ -5,15 +7,19 @@ module Rollbar
       attr_reader :message
       attr_reader :extra
       attr_reader :configuration
+      attr_reader :files
+
+      private :files
 
       def initialize(exception, options = {})
         @exception = exception
         @message = options[:message]
         @extra = options[:extra]
         @configuration = options[:configuration]
+        @files = {}
       end
 
-      def build
+      def to_h
         traces = trace_chain
 
         traces[0][:exception][:description] = message if message
@@ -26,10 +32,23 @@ module Rollbar
         end
       end
 
+      alias_method :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
+        nil
+      end
+
       def trace_chain
-        exception
         traces = [trace_data(exception)]
         visited = [exception]
 
@@ -45,12 +64,8 @@ module Rollbar
       end
 
       def trace_data(current_exception)
-        frames = reduce_frames(current_exception)
-        # reverse so that the order is as rollbar expects
-        frames.reverse!
-
         {
-          :frames => frames,
+          :frames => map_frames(current_exception),
           :exception => {
             :class => current_exception.class.name,
             :message => current_exception.message
@@ -58,16 +73,10 @@ module Rollbar
         }
       end
 
-      def reduce_frames(current_exception)
-        exception_backtrace(current_exception).map do |frame|
-          # parse the line
-          match = frame.match(/(.*):(\d+)(?::in `([^']+)')?/)
-
-          if match
-            { :filename => match[1], :lineno => match[2].to_i, :method => match[3] }
-          else
-            { :filename => '<unknown>', :lineno => 0, :method => frame }
-          end
+      def map_frames(current_exception)
+        exception_backtrace(current_exception).reverse.map do |frame|
+          Rollbar::Item::Frame.new(self, frame,
+                                   :configuration => configuration).to_h
         end
       end
 

data/lib/rollbar/item/frame.rb

@@ -0,0 +1,112 @@
+# We want to use Gem.path
+require 'rubygems'
+
+module Rollbar
+  class Item
+    # Representation of the trace data per frame in the payload
+    class Frame
+      attr_reader :backtrace
+      attr_reader :frame
+      attr_reader :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)
+        }
+      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 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(&:present?)
+      end
+    end
+  end
+end

data/lib/rollbar/middleware/js.rb

@@ -3,6 +3,7 @@ require 'rack/response'
 
 module Rollbar
   module Middleware
+    # Middleware to inject the rollbar.js snippet into a 200 html response
     class Js
       attr_reader :app
       attr_reader :config
@@ -18,38 +19,24 @@ module Rollbar
       def call(env)
         result = app.call(env)
 
-        _call(env, result)
-      end
-
-      private
-
-      def _call(env, result)
-        return result unless should_add_js?(env, result[0], result[1])
+        begin
+          return result unless add_js?(env, result[0], result[1])
 
-        if response_string = add_js(env, result[2])
-          env[JS_IS_INJECTED_KEY] = true
-          response = ::Rack::Response.new(response_string, result[0], result[1])
-
-          response.finish
-        else
+          response_string = add_js(env, result[2])
+          build_response(env, result, response_string)
+        rescue => e
+          Rollbar.log_error("[Rollbar] Rollbar.js could not be added because #{e} exception")
           result
         end
-      rescue => e
-        Rollbar.log_error("[Rollbar] Rollbar.js could not be added because #{e} exception")
-        result
       end
 
       def enabled?
         !!config[:enabled]
       end
 
-      def should_add_js?(env, status, headers)
-        enabled? &&
-          status == 200 &&
-          !env[JS_IS_INJECTED_KEY] &&
-          html?(headers) &&
-          !attachment?(headers) &&
-          !streaming?(env)
+      def add_js?(env, status, headers)
+        enabled? && status == 200 && !env[JS_IS_INJECTED_KEY] &&
+          html?(headers) && !attachment?(headers) && !streaming?(env)
       end
 
       def html?(headers)
@@ -75,28 +62,39 @@ module Rollbar
         head_open_end = find_end_of_head_open(body)
         return nil unless head_open_end
 
-        if head_open_end
-          body = body[0..head_open_end] <<
-                 config_js_tag(env) <<
-                 snippet_js_tag(env) <<
-                 body[head_open_end + 1..-1]
-        end
-
-        body
+        build_body_with_js(env, body, head_open_end)
       rescue => e
         Rollbar.log_error("[Rollbar] Rollbar.js could not be added because #{e} exception")
         nil
       end
 
+      def build_response(env, app_result, response_string)
+        return result unless response_string
+
+        env[JS_IS_INJECTED_KEY] = true
+        response = ::Rack::Response.new(response_string, app_result[0],
+                                        app_result[1])
+
+        response.finish
+      end
+
+      def build_body_with_js(env, body, head_open_end)
+        return body unless head_open_end
+
+        body[0..head_open_end] << config_js_tag(env) << snippet_js_tag(env) <<
+          body[head_open_end + 1..-1]
+      end
+
       def find_end_of_head_open(body)
         head_open = body.index(/<head\W/)
         body.index('>', head_open) if head_open
       end
 
       def join_body(response)
-        source = nil
-        response.each { |fragment| source ? (source << fragment.to_s) : (source = fragment.to_s)}
-        source
+        response.to_enum.reduce('') do |acc, fragment|
+          acc << fragment.to_s
+          acc
+        end
       end
 
       def close_old_response(response)
@@ -116,7 +114,7 @@ module Rollbar
       end
 
       def script_tag(content, env)
-        if defined?(::SecureHeaders) && ::SecureHeaders.respond_to?(:content_security_policy_script_nonce)
+        if append_nonce?
           nonce = ::SecureHeaders.content_security_policy_script_nonce(::Rack::Request.new(env))
           script_tag_content = "\n<script type=\"text/javascript\" nonce=\"#{nonce}\">#{content}</script>"
         else
@@ -130,6 +128,12 @@ module Rollbar
         string = string.html_safe if string.respond_to?(:html_safe)
         string
       end
+
+      def append_nonce?
+        defined?(::SecureHeaders) && ::SecureHeaders.respond_to?(:content_security_policy_script_nonce) &&
+          defined?(::SecureHeaders::Configuration) &&
+          !::SecureHeaders::Configuration.get.current_csp[:script_src].to_a.include?("'unsafe-inline'")
+      end
     end
   end
 end

data/lib/rollbar/middleware/rails/rollbar.rb

@@ -66,11 +66,11 @@ module Rollbar
         end
 
         def context(request_data)
-          return unless request_data[:route]
+          return unless request_data[:params]
 
-          route = request_data[:route]
+          route_params = request_data[:params]
           # make sure route is a hash built by RequestDataExtractor
-          return "#{route[:controller]}" + '#' + "#{route[:action]}" if route.is_a?(Hash) && !route.empty?
+          return route_params[:controller].to_s + '#' + route_params[:action].to_s if route_params.is_a?(Hash) && !route_params.empty?
         end
       end
     end