rollbar 2.19.1 → 2.27.1

data/lib/rollbar/capistrano_tasks.rb

@@ -1,5 +1,3 @@
-require 'capistrano'
-require 'capistrano/version'
 require 'rollbar/deploy'
 
 module Rollbar
@@ -10,15 +8,15 @@ module Rollbar
         deploy_task(logger, :desc => 'Notifying Rollbar of deployment start') do
           result = report_deploy_started(capistrano, dry_run)
 
-          info_request_response(logger, result)
+          debug_request_response(logger, result)
 
           capistrano.set(:rollbar_deploy_id, 123) if dry_run
 
           skip_in_dry_run(logger, dry_run) do
-            if (deploy_id = result[:data][:deploy_id])
+            if result[:success] && (deploy_id = result[:data] && result[:data][:deploy_id])
               capistrano.set :rollbar_deploy_id, deploy_id
             else
-              logger.error 'Unable to report deploy to Rollbar'
+              logger.error 'Unable to report deploy to Rollbar' + (result[:message] ? ': ' + result[:message] : '')
             end
           end
         end
@@ -42,6 +40,9 @@ module Rollbar
         capistrano_300_warning(logger)
         logger.info opts[:desc] if opts[:desc]
         yield
+
+      rescue StandardError => e
+        logger.error "Error reporting to Rollbar: #{e.inspect}"
       end
 
       def deploy_update(capistrano, logger, dry_run, opts = {})
@@ -49,13 +50,13 @@ module Rollbar
           depend_on_deploy_id(capistrano, logger) do
             result = yield
 
-            info_request_response(logger, result)
+            debug_request_response(logger, result)
 
             skip_in_dry_run(logger, dry_run) do
-              if result[:response].is_a?(Net::HTTPSuccess)
+              if result[:success]
                 logger.info 'Updated deploy status in Rollbar'
               else
-                logger.error 'Unable to update deploy status in Rollbar'
+                logger.error 'Unable to update deploy status in Rollbar' + (result[:message] ? ': ' + result[:message] : '')
               end
             end
           end
@@ -63,7 +64,11 @@ module Rollbar
       end
 
       def capistrano_300_warning(logger)
-        logger.warn("You need to upgrade capistrano to '>= 3.1' version in order to correctly report deploys to Rollbar. (On 3.0, the reported revision will be incorrect.)") if ::Capistrano::VERSION =~ /^3\.0/
+        return unless ::Capistrano.const_defined?('VERSION') && ::Capistrano::VERSION =~ /^3\.0/
+
+        logger.warn('You need to upgrade capistrano to >= 3.1 version in order'\
+          'to correctly report deploys to Rollbar. (On 3.0, the reported revision'\
+          'will be incorrect.)')
       end
 
       def report_deploy_started(capistrano, dry_run)
@@ -76,33 +81,35 @@ module Rollbar
             :proxy => :ENV,
             :dry_run => dry_run
           },
-          :access_token => capistrano.fetch(:rollbar_token),
-          :environment => capistrano.fetch(:rollbar_env),
-          :revision => capistrano.fetch(:rollbar_revision)
+          capistrano.fetch(:rollbar_token),
+          capistrano.fetch(:rollbar_env),
+          capistrano.fetch(:rollbar_revision)
         )
       end
 
       def report_deploy_succeeded(capistrano, dry_run)
         ::Rollbar::Deploy.update(
           {
+            :comment => capistrano.fetch(:rollbar_comment),
             :proxy => :ENV,
             :dry_run => dry_run
           },
-          :access_token => capistrano.fetch(:rollbar_token),
-          :deploy_id => capistrano.fetch(:rollbar_deploy_id),
-          :status => :succeeded
+          capistrano.fetch(:rollbar_token),
+          capistrano.fetch(:rollbar_deploy_id),
+          :succeeded
         )
       end
 
       def report_deploy_failed(capistrano, dry_run)
         ::Rollbar::Deploy.update(
           {
+            :comment => capistrano.fetch(:rollbar_comment),
             :proxy => :ENV,
             :dry_run => dry_run
           },
-          :access_token => capistrano.fetch(:rollbar_token),
-          :deploy_id => capistrano.fetch(:rollbar_deploy_id),
-          :status => :failed
+          capistrano.fetch(:rollbar_token),
+          capistrano.fetch(:rollbar_deploy_id),
+          :failed
         )
       end
 
@@ -122,9 +129,10 @@ module Rollbar
         end
       end
 
-      def info_request_response(logger, result)
-        logger.info result[:request_info]
-        logger.info result[:response_info] if result[:response_info]
+      def debug_request_response(logger, result)
+        # NOTE: in Capistrano debug messages go to log/capistrano.log but not to stdout even if log_level == :debug
+        logger.debug result[:request_info]
+        logger.debug result[:response_info] if result[:response_info]
       end
     end
   end

data/lib/rollbar/configuration.rb

@@ -8,6 +8,7 @@ module Rollbar
     attr_accessor :async_handler
     attr_accessor :branch
     attr_reader :before_process
+    attr_accessor :capture_uncaught
     attr_accessor :code_version
     attr_accessor :custom_data_method
     attr_accessor :delayed_job_enabled
@@ -16,16 +17,18 @@ module Rollbar
     attr_accessor :disable_monkey_patch
     attr_accessor :disable_rack_monkey_patch
     attr_accessor :disable_core_monkey_patch
+    attr_accessor :enable_error_context
     attr_accessor :dj_threshold
+    attr_accessor :async_skip_report_handler
     attr_accessor :enabled
     attr_accessor :endpoint
     attr_accessor :environment
     attr_accessor :exception_level_filters
     attr_accessor :failover_handlers
-    attr_accessor :filepath
     attr_accessor :framework
     attr_accessor :ignored_person_ids
     attr_accessor :host
+    attr_accessor :locals
     attr_writer :logger
     attr_accessor :payload_options
     attr_accessor :person_method
@@ -55,23 +58,36 @@ module Rollbar
     attr_reader :transform
     attr_accessor :verify_ssl_peer
     attr_accessor :use_async
+    attr_accessor :async_json_payload
     attr_reader :use_eventmachine
     attr_accessor :web_base
-    attr_accessor :write_to_file
     attr_reader :send_extra_frame_data
     attr_accessor :use_exception_level_filters_default
     attr_accessor :proxy
+    attr_accessor :raise_on_error
+    attr_accessor :transmit
+    attr_accessor :log_payload
+    attr_accessor :backtrace_cleaner
+
+    attr_accessor :write_to_file
+    attr_accessor :filepath
+    attr_accessor :files_with_pid_name_enabled
+    attr_accessor :files_processed_enabled
+    attr_accessor :files_processed_duration # seconds
+    attr_accessor :files_processed_size # bytes
 
     attr_reader :project_gem_paths
+    attr_accessor :configured_options
 
-    alias_method :safely?, :safely
+    alias safely? safely
 
-    DEFAULT_ENDPOINT = 'https://api.rollbar.com/api/1/item/'
-    DEFAULT_WEB_BASE = 'https://rollbar.com'
+    DEFAULT_ENDPOINT = 'https://api.rollbar.com/api/1/item/'.freeze
+    DEFAULT_WEB_BASE = 'https://rollbar.com'.freeze
 
     def initialize
       @async_handler = nil
       @before_process = []
+      @capture_uncaught = nil
       @code_version = nil
       @custom_data_method = nil
       @default_logger = lambda { ::Logger.new(STDERR) }
@@ -80,7 +96,9 @@ module Rollbar
       @disable_monkey_patch = false
       @disable_core_monkey_patch = false
       @disable_rack_monkey_patch = false
+      @enable_error_context = true
       @dj_threshold = 0
+      @async_skip_report_handler = nil
       @enabled = nil # set to true when configure is called
       @endpoint = DEFAULT_ENDPOINT
       @environment = nil
@@ -105,12 +123,13 @@ module Rollbar
       @net_retries = 3
       @js_enabled = false
       @js_options = {}
+      @locals = {}
       @scrub_fields = [:passwd, :password, :password_confirmation, :secret,
                        :confirm_password, :password_confirmation, :secret_token,
-                       :api_key, :access_token, :session_id]
+                       :api_key, :access_token, :accessToken, :session_id]
       @scrub_user = true
       @scrub_password = true
-      @randomize_scrub_length = true
+      @randomize_scrub_length = false
       @scrub_whitelist = []
       @uncaught_exception_level = 'error'
       @scrub_headers = ['Authorization']
@@ -118,20 +137,32 @@ module Rollbar
       @safely = false
       @transform = []
       @use_async = false
+      @async_json_payload = false
       @use_eventmachine = false
       @verify_ssl_peer = true
       @web_base = DEFAULT_WEB_BASE
-      @write_to_file = false
       @send_extra_frame_data = :none
       @project_gem_paths = []
       @use_exception_level_filters_default = false
       @proxy = nil
+      @raise_on_error = false
+      @transmit = true
+      @log_payload = false
       @collect_user_ip = true
       @anonymize_user_ip = false
+      @backtrace_cleaner = nil
       @hooks = {
         :on_error_response => nil, # params: response
-        :on_report_internal_error => nil, # params: exception
+        :on_report_internal_error => nil # params: exception
       }
+
+      @write_to_file = false
+      @files_with_pid_name_enabled = false
+      @files_processed_enabled = false
+      @files_processed_duration = 60
+      @files_processed_size = 5 * 1000 * 1000
+
+      @configured_options = ConfiguredOptions.new(self)
     end
 
     def initialize_copy(orig)
@@ -139,9 +170,18 @@ module Rollbar
 
       instance_variables.each do |var|
         instance_var = instance_variable_get(var)
-        instance_variable_set(var, Rollbar::Util::deep_copy(instance_var))
+        instance_variable_set(var, Rollbar::Util.deep_copy(instance_var))
+      end
+    end
+
+    def wrapped_clone
+      original_clone.tap do |new_config|
+        new_config.configured_options = ConfiguredOptions.new(new_config)
+        new_config.configured_options.configured = configured_options.configured
       end
     end
+    alias original_clone clone
+    alias clone wrapped_clone
 
     def merge(options)
       new_configuration = clone
@@ -210,9 +250,10 @@ module Rollbar
       value.is_a?(Hash) ? use_sidekiq(value) : use_sidekiq
     end
 
-    def use_thread
+    def use_thread(options = {})
       require 'rollbar/delay/thread'
       @use_async = true
+      Rollbar::Delay::Thread.options = options
       @async_handler = Rollbar::Delay::Thread
     end
 
@@ -222,7 +263,7 @@ module Rollbar
       @async_handler  = Rollbar::Delay::SuckerPunch
     end
 
-    def use_sucker_punch=(value)
+    def use_sucker_punch=(_value)
       deprecation_message = '#use_sucker_punch=(value) has been deprecated in favor of #use_sucker_punch. Please update your rollbar configuration.'
       defined?(ActiveSupport) ? ActiveSupport::Deprecation.warn(deprecation_message) : puts(deprecation_message)
 
@@ -239,7 +280,10 @@ module Rollbar
         found = Gem::Specification.each.select { |spec| name === spec.name }
         puts "[Rollbar] No gems found matching #{name.inspect}" if found.empty?
         found
-      end.flatten.uniq.map(&:gem_dir)
+      end
+      @project_gem_paths.flatten!
+      @project_gem_paths.uniq!
+      @project_gem_paths.map!(&:gem_dir)
     end
 
     def before_process=(*handler)
@@ -266,7 +310,11 @@ module Rollbar
     end
 
     def logger_level=(level)
-      @logger_level = level.to_sym
+      @logger_level = if level
+                        level.to_sym
+                      else
+                        level
+                      end
     end
 
     def logger
@@ -274,14 +322,14 @@ module Rollbar
     end
 
     def hook(symbol, &block)
-      if @hooks.has_key?(symbol)
+      if @hooks.key?(symbol)
         if block_given?
           @hooks[symbol] = block
         else
           @hooks[symbol]
         end
       else
-        raise StandardError.new "Hook :" + symbol.to_s + " is not supported by Rollbar SDK."
+        raise StandardError, 'Hook :' + symbol.to_s + ' is not supported by Rollbar SDK.'
       end
     end
 
@@ -289,4 +337,26 @@ module Rollbar
       hook(symbol).call(*args) if hook(symbol).is_a?(Proc)
     end
   end
+
+  class ConfiguredOptions
+    attr_accessor :configuration, :configured
+
+    def initialize(configuration)
+      @configuration = configuration
+      @configured = {}
+    end
+
+    def method_missing(method, *args, &block)
+      return super unless configuration.respond_to?(method)
+
+      method_string = method.to_s
+      configured[method_string.chomp('=').to_sym] = args.first if method_string.end_with?('=')
+
+      configuration.send(method, *args, &block)
+    end
+
+    def respond_to_missing?(method)
+      configuration.respond_to?(method) || super
+    end
+  end
 end

data/lib/rollbar/delay/girl_friday.rb

@@ -11,14 +11,10 @@ module Rollbar
         end
 
         def queue
-          @queue ||= self.queue_class.new(nil, :size => 5) do |payload|
-            begin
-              Rollbar.process_from_async_handler(payload)
-            rescue
-              # According to https://github.com/mperham/girl_friday/wiki#error-handling
-              # we reraise the exception so it can be handled some way
-              raise
-            end
+          @queue ||= queue_class.new(nil, :size => 5) do |payload|
+            Rollbar.process_from_async_handler(payload)
+
+            # Do not rescue. GirlFriday will call the error handler.
           end
         end
       end

data/lib/rollbar/delay/resque.rb

@@ -23,12 +23,9 @@ module Rollbar
         end
 
         def perform(payload)
-          begin
-            Rollbar.process_from_async_handler(payload)
-          rescue
-            # Raise the exception so Resque can track the errored job
-            raise
-          end
+          Rollbar.process_from_async_handler(payload)
+
+          # Do not rescue. Resque will call the error handler.
         end
       end
     end

data/lib/rollbar/delay/sidekiq.rb

@@ -10,21 +10,15 @@ module Rollbar
       end
 
       def call(payload)
-        if ::Sidekiq::Client.push(@options.merge('args' => [payload])) == nil
-          raise StandardError.new "Unable to push the job to Sidekiq"
-        end
+        raise StandardError, 'Unable to push the job to Sidekiq' if ::Sidekiq::Client.push(@options.merge('args' => [payload])).nil?
       end
 
       include ::Sidekiq::Worker
 
       def perform(*args)
-        begin
-          Rollbar.process_from_async_handler(*args)
-        rescue
-          # Raise the exception so Sidekiq can track the errored job
-          # and retry it
-          raise
-        end
+        Rollbar.process_from_async_handler(*args)
+
+        # Do not rescue. Sidekiq will call the error handler.
       end
     end
   end

data/lib/rollbar/delay/sucker_punch.rb

@@ -16,11 +16,11 @@ module Rollbar
       def self.setup
         major_version = ::SuckerPunch::VERSION.split.first.to_i
 
-        if major_version > 1
-          self.perform_proc = proc { |payload| perform_async(payload) }
-        else
-          self.perform_proc = proc { |payload| new.async.perform(payload) }
-        end
+        self.perform_proc = if major_version > 1
+                              proc { |payload| perform_async(payload) }
+                            else
+                              proc { |payload| new.async.perform(payload) }
+                            end
 
         self.ready = true
       end
@@ -32,20 +32,17 @@ module Rollbar
       end
 
       def perform(*args)
-        begin
-          Rollbar.process_from_async_handler(*args)
-        rescue
-          # SuckerPunch can configure an exception handler with:
-          #
-          # SuckerPunch.exception_handler { # do something here }
-          #
-          # This is just passed to Celluloid.exception_handler which will
-          # push the reiceved block to an array of handlers, by default empty, [].
-          #
-          # We reraise the exception here casue it's safe and users could have defined
-          # their own exception handler for SuckerPunch
-          raise
-        end
+        Rollbar.process_from_async_handler(*args)
+
+        # SuckerPunch can configure an exception handler with:
+        #
+        # SuckerPunch.exception_handler { # do something here }
+        #
+        # This is just passed to Celluloid.exception_handler which will
+        # push the reiceved block to an array of handlers, by default empty, [].
+        #
+
+        # Do not rescue. SuckerPunch will call the error handler.
       end
     end
   end

data/lib/rollbar/delay/thread.rb

@@ -1,4 +1,3 @@
-require 'thread'
 require 'timeout'
 
 module Rollbar
@@ -10,7 +9,10 @@ module Rollbar
       Error        = Class.new(StandardError)
       TimeoutError = Class.new(Error)
 
+      DEFAULT_PRIORITY = 1
+
       class << self
+        attr_writer :options
         attr_reader :reaper
 
         def call(payload)
@@ -21,6 +23,10 @@ module Rollbar
           thread
         end
 
+        def options
+          @options || {}
+        end
+
         private
 
         def threads
@@ -29,6 +35,7 @@ module Rollbar
 
         def spawn_threads_reaper
           return if @spawned
+
           @spawned = true
 
           @reaper ||= build_reaper_thread
@@ -61,11 +68,18 @@ module Rollbar
         end
       end # class << self
 
+      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

@@ -1,68 +1,91 @@
-require 'capistrano'
+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:)
+    def self.report(opts, access_token, environment, revision)
+      return {} unless access_token && !access_token.empty?
+
       opts[:status] ||= :started
 
-      uri = URI.parse(::Rollbar::Deploy::ENDPOINT)
+      uri = ::URI.parse(::Rollbar::Deploy::ENDPOINT)
 
-      request = Net::HTTP::Post.new(uri.request_uri)
-      request.body = ::JSON.dump({
+      request_data = {
         :access_token => access_token,
         :environment => environment,
         :revision => revision
-      }.merge(opts))
+      }.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 => uri, :request => request)
+      send_request(opts, uri, request)
     end
 
-    def self.update(opts = {}, deploy_id:, access_token:, status:)
-      uri = URI.parse(
+    def self.update(opts, access_token, deploy_id, status)
+      return {} unless access_token && !access_token.empty?
+
+      uri = ::URI.parse(
         ::Rollbar::Deploy::ENDPOINT +
         deploy_id.to_s +
         '?access_token=' + access_token
       )
 
-      request = Net::HTTP::Patch.new(uri.request_uri)
+      request = ::Net::HTTP::Patch.new(uri.request_uri)
       request.body = ::JSON.dump(:status => status.to_s, :comment => opts[:comment])
 
-      send_request(opts, :uri => uri, :request => request)
+      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|
+      def send_request(opts, uri, request)
+        ::Net::HTTP.start(uri.host, uri.port, opts[:proxy], :use_ssl => true) do |http|
           build_result(
-            :uri => uri,
-            :request => request,
-            :response => opts[:dry_run] ? nil : http.request(request)
+            uri,
+            request,
+            opts[:dry_run] ? nil : http.request(request),
+            opts[:dry_run]
           )
         end
       end
 
-      def build_result(uri:, request:, response: nil)
-        result = {
-          :request_info => uri.inspect + ': ' + request.body,
-          :request => request,
-          :response => response
-        }
+      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
 
-        unless result[:response].nil?
-          result.merge!(JSON.parse(result[:response].body, :symbolize_names => true))
-          result[:response_info] = build_response_info(result[:response])
-        end
+      def success?(result, dry_run = false)
+        return true if dry_run
 
-        result
+        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 build_response_info(response)
-        response.code + '; ' + response.message + '; ' + response.body.delete!("\n")
+      def response_result(response)
+        {
+          :response => response,
+          :response_info => response.code + '; ' +
+            response.message + '; ' +
+            response.body.delete("\n")
+        }.merge(::JSON.parse(response.body, :symbolize_names => true))
       end
     end
   end