rollbar 2.10.0 → 2.11.0

data/lib/rollbar/configuration.rb

@@ -31,7 +31,9 @@ module Rollbar
     attr_accessor :person_email_method
     attr_accessor :populate_empty_backtraces
     attr_accessor :report_dj_data
+    attr_accessor :open_timeout
     attr_accessor :request_timeout
+    attr_accessor :net_retries
     attr_accessor :root
     attr_accessor :js_options
     attr_accessor :js_enabled
@@ -88,7 +90,9 @@ module Rollbar
       @project_gems = []
       @populate_empty_backtraces = false
       @report_dj_data = true
+      @open_timeout = 3
       @request_timeout = 3
+      @net_retries = 3
       @js_enabled = false
       @js_options = {}
       @scrub_fields = [:passwd, :password, :password_confirmation, :secret,

data/lib/rollbar/item.rb

@@ -0,0 +1,225 @@
+require 'socket'
+require 'forwardable'
+
+begin
+  require 'securerandom'
+rescue LoadError
+  nil
+end
+
+require 'rollbar/item/backtrace'
+require 'rollbar/util'
+require 'rollbar/encoding'
+
+module Rollbar
+  # This class represents the payload to be sent to the API.
+  # It contains the logic to build the payload, trucante it
+  # and dump the JSON.
+  class Item
+    extend Forwardable
+
+    attr_writer :payload
+
+    attr_reader :level
+    attr_reader :message
+    attr_reader :exception
+    attr_reader :extra
+
+    attr_reader :configuration
+    attr_reader :scope
+    attr_reader :logger
+    attr_reader :notifier
+
+    def_delegators :payload, :[]
+
+    class << self
+      def build_with(payload, options = {})
+        new(options).tap do |item|
+          item.payload = payload
+        end
+      end
+    end
+
+    def initialize(options)
+      @level = options[:level]
+      @message = options[:message]
+      @exception = options[:exception]
+      @extra = options[:extra]
+      @configuration = options[:configuration]
+      @logger = options[:logger]
+      @scope = options[:scope]
+      @payload = nil
+      @notifier = options[:notifier]
+    end
+
+    def payload
+      @payload ||= build
+    end
+
+    def build
+      data = build_data
+      self.payload = {
+        'access_token' => configuration.access_token,
+        'data' => data
+      }
+
+      enforce_valid_utf8
+      transform
+      payload
+    end
+
+    def build_data
+      data = {
+        :timestamp => Time.now.to_i,
+        :environment => build_environment,
+        :level => level,
+        :language => 'ruby',
+        :framework => configuration.framework,
+        :server => server_data,
+        :notifier => {
+          :name => 'rollbar-gem',
+          :version => VERSION
+        },
+        :body => build_body
+      }
+      data[:project_package_paths] = configuration.project_gem_paths if configuration.project_gem_paths
+      data[:code_version] = configuration.code_version if configuration.code_version
+      data[:uuid] = SecureRandom.uuid if defined?(SecureRandom) && SecureRandom.respond_to?(:uuid)
+
+      Util.deep_merge(data, configuration.payload_options)
+      Util.deep_merge(data, scope)
+
+      # Our API doesn't allow null context values, so just delete
+      # the key if value is nil.
+      data.delete(:context) unless data[:context]
+
+      data
+    end
+
+    def dump
+      # Ensure all keys are strings since we can receive the payload inline or
+      # 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)}")
+
+      nil
+    end
+
+    def ignored?
+      data = payload['data']
+
+      return unless data[:person]
+
+      person_id = data[:person][configuration.person_id_method.to_sym]
+      configuration.ignored_person_ids.include?(person_id)
+    end
+
+    private
+
+    def build_environment
+      env = configuration.environment
+      env = 'unspecified' if env.nil? || env.empty?
+
+      env
+    end
+
+    def build_body
+      exception ? build_backtrace_body : build_message_body
+    end
+
+    def build_backtrace_body
+      backtrace = Backtrace.new(exception,
+                                :message => message,
+                                :extra => build_extra,
+                                :configuration => configuration
+                               )
+
+      backtrace.build
+    end
+
+    def build_extra
+      if custom_data_method?
+        Util.deep_merge(custom_data, extra || {})
+      else
+        extra
+      end
+    end
+
+    def custom_data_method?
+      !!configuration.custom_data_method
+    end
+
+    def custom_data
+      data = configuration.custom_data_method.call
+      Rollbar::Util.deep_copy(data)
+    rescue => e
+      return {} if configuration.safely?
+
+      report_custom_data_error(e)
+    end
+
+    def report_custom_data_error(e)
+      data = notifier.safely.error(e)
+
+      return {} unless data.is_a?(Hash) && data[:uuid]
+
+      uuid_url = Util.uuid_rollbar_url(data, configuration)
+
+      { :_error_in_custom_data_method => uuid_url }
+    end
+
+    def build_message_body
+      extra = build_extra
+      result = { :body => message || 'Empty message' }
+      result[:extra] = extra if extra
+
+      { :message => result }
+    end
+
+    def server_data
+      data = {
+        :host => Socket.gethostname
+      }
+      data[:root] = configuration.root.to_s if configuration.root
+      data[:branch] = configuration.branch if configuration.branch
+      data[:pid] = Process.pid
+
+      data
+    end
+
+    def enforce_valid_utf8
+      Util.enforce_valid_utf8(payload)
+    end
+
+    def transform
+      handlers = configuration.transform
+
+      handlers.each do |handler|
+        begin
+          handler.call(transform_options)
+        rescue => e
+          logger.error("[Rollbar] Error calling the `transform` hook: #{e}")
+
+          break
+        end
+      end
+    end
+
+    def transform_options
+      {
+        :level => level,
+        :scope => scope,
+        :exception => exception,
+        :message => message,
+        :extra => extra,
+        :payload => payload
+      }
+    end
+  end
+end

data/lib/rollbar/item/backtrace.rb

@@ -0,0 +1,97 @@
+module Rollbar
+  class Item
+    class Backtrace
+      attr_reader :exception
+      attr_reader :message
+      attr_reader :extra
+      attr_reader :configuration
+
+      def initialize(exception, options = {})
+        @exception = exception
+        @message = options[:message]
+        @extra = options[:extra]
+        @configuration = options[:configuration]
+      end
+
+      def build
+        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
+
+      private
+
+      def trace_chain
+        exception
+        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 = reduce_frames(current_exception)
+        # reverse so that the order is as rollbar expects
+        frames.reverse!
+
+        {
+          :frames => frames,
+          :exception => {
+            :class => current_exception.class.name,
+            :message => current_exception.message
+          }
+        }
+      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
+        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)
+        return current_exception.backtrace if current_exception.backtrace.respond_to?(:map)
+        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::Specification.find_by_name('rollbar').gem_dir + '/lib'
+      end
+    end
+  end
+end

data/lib/rollbar/js.rb

@@ -1,32 +1,4 @@
-require "rollbar/js/version"
-
 module Rollbar
   module Js
-    extend self
-
-    attr_reader :framework
-    attr_reader :framework_loader
-
-    def prepare
-      @framework ||= detect_framework
-      @framework_loader ||= load_framework_class.new
-
-      @framework_loader.prepare
-    end
-
-    private
-
-    def detect_framework
-      case
-      when defined?(::Rails::VERSION)
-        :rails
-      end
-    end
-
-    def load_framework_class
-      require "rollbar/js/frameworks/#{framework}"
-
-      Rollbar::Js::Frameworks.const_get(framework.to_s.capitalize)
-    end
   end
 end

data/lib/rollbar/language_support.rb

@@ -26,10 +26,20 @@ module Rollbar
       version?('1.8')
     end
 
+    def ruby_19?
+      version?('1.9')
+    end
+
     def version?(version)
       numbers = version.split('.')
 
       numbers == ::RUBY_VERSION.split('.')[0, numbers.size]
     end
+
+    def timeout_exceptions
+      return [] if ruby_18? || ruby_19?
+
+      [Net::ReadTimeout, Net::OpenTimeout]
+    end
   end
 end

data/lib/rollbar/{js/middleware.rb → middleware/js.rb}

@@ -1,10 +1,9 @@
 require 'rack'
 require 'rack/response'
 
-
 module Rollbar
-  module Js
-    class Middleware
+  module Middleware
+    class Js
       attr_reader :app
       attr_reader :config
 
@@ -117,7 +116,7 @@ module Rollbar
       end
 
       def script_tag(content, env)
-        if defined?(::SecureHeaders)
+        if defined?(::SecureHeaders) && ::SecureHeaders.respond_to?(:content_security_policy_script_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

data/lib/rollbar/plugin.rb

@@ -0,0 +1,63 @@
+module Rollbar
+  # Represents a plugin in the gem. Every plugin can have multiple dependencies
+  # and multiple execution blocks.
+  # 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_accessor :loaded
+
+    private :loaded=
+
+    def initialize(name)
+      @name = name
+      @dependencies = []
+      @callables = []
+      @loaded = false
+    end
+
+    def configuration
+      Rollbar.configuration
+    end
+
+    def load!
+      return unless load?
+
+      begin
+        callables.each(&:call)
+      rescue => e
+        log_loading_error(e)
+      ensure
+        self.loaded = true
+      end
+    end
+
+    def execute(&block)
+      callables << block
+    end
+
+    def execute!(&block)
+      block.call if load?
+    end
+
+    private
+
+    def dependency(&block)
+      dependencies << block
+    end
+
+    def load?
+      !loaded && dependencies.all?(&:call)
+    rescue => e
+      log_loading_error(e)
+
+      false
+    end
+
+    def log_loading_error(e)
+      Rollbar.log_error("Error trying to load plugin '#{name}': #{e.class}, #{e.message}")
+    end
+  end
+end