rollbar 2.16.2 → 2.22.1

data/lib/rollbar/delay/sidekiq.rb

@@ -10,19 +10,17 @@ module Rollbar
       end
 
       def call(payload)
-        ::Sidekiq::Client.push @options.merge('args' => [payload])
+        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)
+      rescue StandardError
+        # Raise the exception so Sidekiq can track the errored job
+        # and retry it
+        raise
       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,18 @@ 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)
+      rescue StandardError
+        # 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
     end
   end

data/lib/rollbar/delay/thread.rb

@@ -1,11 +1,10 @@
-require 'thread'
 require 'timeout'
 
 module Rollbar
   module Delay
     class Thread
       EXIT_SIGNAL  = :exit
-      EXIT_TIMEOUT = 3
+      EXIT_TIMEOUT = 6
 
       Error        = Class.new(StandardError)
       TimeoutError = Class.new(Error)
@@ -29,6 +28,7 @@ module Rollbar
 
         def spawn_threads_reaper
           return if @spawned
+
           @spawned = true
 
           @reaper ||= build_reaper_thread
@@ -65,7 +65,7 @@ module Rollbar
         ::Thread.new do
           begin
             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,90 @@
+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.to_s +
+        '?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)
+        {
+          :response => response,
+          :response_info => response.code + '; ' +
+            response.message + '; ' +
+            response.body.delete("\n")
+        }.merge(::JSON.parse(response.body, :symbolize_names => true))
+      end
+    end
+  end
+end

data/lib/rollbar/encoding/encoder.rb

@@ -1,9 +1,9 @@
 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
+      ENCODING_OPTIONS = { :invalid => :replace, :undef => :replace, :replace => '' }.freeze
       UTF8 = 'UTF-8'.freeze
       BINARY = 'binary'.freeze
 
@@ -18,11 +18,11 @@ 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))
+                        end
 
         object.is_a?(Symbol) ? encoded_value.to_sym : encoded_value
       end
@@ -45,7 +45,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

data/lib/rollbar/exception_reporter.rb

@@ -1,10 +1,11 @@
 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)
         env['rollbar.exception_uuid'] = exception_data[:uuid]
@@ -14,8 +15,21 @@ module Rollbar
       elsif exception_data == 'ignored'
         Rollbar.log_debug '[Rollbar] Exception not reported because it was ignored'
       end
-    rescue => e
+    rescue StandardError => e
       Rollbar.log_warning "[Rollbar] Exception while reporting exception to Rollbar: #{e.message}"
     end
+
+    def capture_uncaught?
+      Rollbar.configuration.capture_uncaught != false
+    end
+
+    def log_exception_message(exception)
+      exception_message = 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.rb

@@ -12,6 +12,7 @@ require 'rollbar/util'
 require 'rollbar/encoding'
 require 'rollbar/truncation'
 require 'rollbar/json'
+require 'rollbar/scrubbers/params'
 
 module Rollbar
   # This class represents the payload to be sent to the API.
@@ -26,12 +27,12 @@ module Rollbar
     attr_reader :message
     attr_reader :exception
     attr_reader :extra
-    
+
     attr_reader :configuration
     attr_reader :scope
     attr_reader :logger
     attr_reader :notifier
-    
+
     attr_reader :context
 
     def_delegators :payload, :[]
@@ -83,7 +84,8 @@ module Rollbar
         :server => server_data,
         :notifier => {
           :name => 'rollbar-gem',
-          :version => VERSION
+          :version => VERSION,
+          :configured_options => configured_options
         },
         :body => build_body
       }
@@ -101,29 +103,58 @@ module Rollbar
       data
     end
 
+    def configured_options
+      if Gem.loaded_specs['activesupport'] && Gem.loaded_specs['activesupport'].version < Gem::Version.new('4.1')
+        # There are too many types that crash ActiveSupport JSON serialization, and not worth
+        # the risk just to send this diagnostic object. In versions < 4.1, ActiveSupport hooks
+        # Ruby's JSON.generate so deeply there's no workaround.
+        'not serialized in ActiveSupport < 4.1'
+      elsif configuration.use_async
+        # Currently serialization is performed by each handler, and this invariably
+        # means it is actually performed by ActiveSupport.
+        #
+        # TODO: Since serialization must be done prior to scheduling the job,
+        # it should at least be done by rollbar-gem itself. Much work has been done
+        # to avoid the bugs in ActiveSupport JSON. The async handlers are currently
+        # still subject to all those knnown issues.
+        'not serialized for async/delayed handlers'
+      else
+        scrub(configuration.configured_options.configured)
+      end
+    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)
+      attempts = []
+      result = Truncation.truncate(stringified_payload, attempts)
 
       return result unless Truncation.truncate?(result)
 
-      handle_too_large_payload(stringified_payload, result)
+      handle_too_large_payload(stringified_payload, result, attempts)
 
       nil
     end
 
-    def handle_too_large_payload(stringified_payload, final_payload)
-      original_size = Rollbar::JSON.dump(stringified_payload).bytesize
-      final_size = final_payload.bytesize
+    def handle_too_large_payload(stringified_payload, final_payload, attempts)
       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)
+      notifier.send_failsafe(
+        too_large_payload_string(attempts),
+        nil,
+        uuid,
+        host
+      )
       logger.error("[Rollbar] Payload too large to be sent for UUID #{uuid}: #{Rollbar::JSON.dump(payload)}")
     end
 
+    def too_large_payload_string(attempts)
+      'Could not send payload due to it being too large after truncating attempts. ' \
+        "Original size: #{attempts.first} Attempts: #{attempts.join(', ')} Final size: #{attempts.last}"
+    end
+
     def ignored?
       data = payload['data']
 
@@ -156,26 +187,37 @@ module Rollbar
     end
 
     def build_extra
-      if custom_data_method?
-        Util.deep_merge(custom_data, extra || {})
+      if custom_data_method? && !Rollbar::Util.method_in_stack(:custom_data, __FILE__)
+        Util.deep_merge(scrub(custom_data), scrub(extra) || {})
       else
-        extra
+        scrub(extra)
       end
     end
 
+    def scrub(data)
+      return data unless data.is_a? Hash
+
+      options = {
+        :params => data,
+        :config => Rollbar.configuration.scrub_fields,
+        :whitelist => Rollbar.configuration.scrub_whitelist
+      }
+      Rollbar::Scrubbers::Params.call(options)
+    end
+
     def custom_data_method?
       !!configuration.custom_data_method
     end
 
     def custom_data
-      if configuration.custom_data_method.arity == 3
-        data = configuration.custom_data_method.call(message, exception, context)
-      else
-        data = configuration.custom_data_method.call
-      end
-      
+      data = if configuration.custom_data_method.arity == 3
+               configuration.custom_data_method.call(message, exception, context)
+             else
+               configuration.custom_data_method.call
+             end
+
       Rollbar::Util.deep_copy(data)
-    rescue => e
+    rescue StandardError => e
       return {} if configuration.safely?
 
       report_custom_data_error(e)
@@ -220,7 +262,7 @@ module Rollbar
       handlers.each do |handler|
         begin
           handler.call(transform_options)
-        rescue => e
+        rescue StandardError => e
           logger.error("[Rollbar] Error calling the `transform` hook: #{e}")
 
           break

data/lib/rollbar/item/backtrace.rb

@@ -32,7 +32,7 @@ module Rollbar
         end
       end
 
-      alias_method :build, :to_h
+      alias build to_h
 
       def get_file_lines(filename)
         files[filename] ||= read_file(filename)
@@ -44,7 +44,7 @@ module Rollbar
         return unless File.exist?(filename)
 
         File.read(filename).split("\n")
-      rescue
+      rescue StandardError
         nil
       end
 
@@ -74,10 +74,10 @@ module Rollbar
       end
 
       def map_frames(current_exception)
-        exception_backtrace(current_exception).reverse.map do |frame|
+        exception_backtrace(current_exception).map do |frame|
           Rollbar::Item::Frame.new(self, frame,
                                    :configuration => configuration).to_h
-        end
+        end.reverse
       end
 
       # Returns the backtrace to be sent to our API. There are 3 options: