rollbar 2.8.3 → 3.6.0

data/lib/rollbar/configuration.rb

@@ -2,74 +2,114 @@ require 'logger'
 
 module Rollbar
   class Configuration
+    SEND_EXTRA_FRAME_DATA_OPTIONS = [:none, :app, :all].freeze
 
-    attr_accessor :access_token
-    attr_accessor :async_handler
-    attr_accessor :branch
-    attr_accessor :before_process
-    attr_accessor :code_version
-    attr_accessor :custom_data_method
-    attr_accessor :delayed_job_enabled
-    attr_accessor :default_logger
-    attr_accessor :disable_monkey_patch
-    attr_accessor :disable_rack_monkey_patch
-    attr_accessor :disable_core_monkey_patch
-    attr_accessor :dj_threshold
-    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 :logger
-    attr_accessor :payload_options
-    attr_accessor :person_method
-    attr_accessor :person_id_method
-    attr_accessor :person_username_method
-    attr_accessor :person_email_method
-    attr_accessor :populate_empty_backtraces
-    attr_accessor :report_dj_data
-    attr_accessor :request_timeout
-    attr_accessor :root
-    attr_accessor :js_options
-    attr_accessor :js_enabled
-    attr_accessor :safely
-    attr_accessor :scrub_fields
-    attr_accessor :scrub_user
-    attr_accessor :scrub_password
-    attr_accessor :user_ip_obfuscator_secret
-    attr_accessor :randomize_scrub_length
-    attr_accessor :uncaught_exception_level
-    attr_accessor :scrub_headers
-    attr_accessor :sidekiq_threshold
-    attr_accessor :transform
-    attr_accessor :verify_ssl_peer
-    attr_accessor :use_async
-    attr_accessor :use_eventmachine
-    attr_accessor :web_base
-    attr_accessor :write_to_file
-
-    attr_reader :project_gem_paths
-
-    alias_method :safely?, :safely
-
-    DEFAULT_ENDPOINT = 'https://api.rollbar.com/api/1/item/'
-    DEFAULT_WEB_BASE = 'https://rollbar.com'
+    attr_accessor :access_token,
+                  :anonymize_user_ip,
+                  :async_handler,
+                  :async_json_payload,
+                  :async_skip_report_handler,
+                  :backtrace_cleaner,
+                  :branch,
+                  :capture_uncaught,
+                  :code_version,
+                  :collect_user_ip,
+                  :configured_options,
+                  :custom_data_method,
+                  :default_logger,
+                  :delayed_job_enabled,
+                  :disable_action_mailer_monkey_patch,
+                  :disable_core_monkey_patch,
+                  :disable_monkey_patch,
+                  :disable_rack_monkey_patch,
+                  :dj_threshold,
+                  :dj_use_scoped_block,
+                  :enable_error_context,
+                  :enabled,
+                  :endpoint,
+                  :environment,
+                  :exception_level_filters,
+                  :failover_handlers,
+                  :filepath,
+                  :files_processed_duration,
+                  :files_processed_enabled,
+                  :files_processed_size,
+                  :files_with_pid_name_enabled,
+                  :framework,
+                  :ignore_internal_errors,
+                  :ignored_person_ids,
+                  :js_enabled,
+                  :js_options,
+                  :host,
+                  :locals,
+                  :log_payload,
+                  :net_retries,
+                  :open_timeout,
+                  :payload_options,
+                  :person_email_method,
+                  :person_id_method,
+                  :person_method,
+                  :person_username_method,
+                  :populate_empty_backtraces,
+                  :proxy,
+                  :raise_on_error,
+                  :randomize_scrub_length,
+                  :report_dj_data,
+                  :request_timeout,
+                  :root,
+                  :safely,
+                  :scrub_fields,
+                  :scrub_password,
+                  :scrub_user,
+                  :scrub_whitelist,
+                  :transmit,
+                  :uncaught_exception_level,
+                  :user_ip_obfuscator_secret,
+                  :user_ip_rack_env_key,
+                  :scrub_headers,
+                  :sidekiq_threshold,
+                  :sidekiq_use_scoped_block,
+                  :use_async,
+                  :use_exception_level_filters_default,
+                  :use_payload_access_token,
+                  :verify_ssl_peer,
+                  :web_base,
+                  :write_to_file
+    attr_reader :before_process,
+                :enable_rails_error_subscriber,
+                :logger_level,
+                :project_gem_paths,
+                :send_extra_frame_data,
+                :transform,
+                :use_eventmachine
+    attr_writer :logger # seconds # bytes
+
+    alias safely? safely
+
+    DEFAULT_ENDPOINT = 'https://api.rollbar.com/api/1/item/'.freeze
+    DEFAULT_WEB_BASE = 'https://rollbar.com'.freeze
 
     def initialize
+      @access_token = nil
       @async_handler = nil
       @before_process = []
+      @branch = nil
+      @capture_uncaught = nil
       @code_version = nil
       @custom_data_method = nil
-      @default_logger = lambda { Logger.new(STDERR) }
+      @default_logger = lambda { ::Logger.new($stderr) }
+      @logger_level = :info
       @delayed_job_enabled = true
       @disable_monkey_patch = false
+      @disable_action_mailer_monkey_patch = false
       @disable_core_monkey_patch = false
       @disable_rack_monkey_patch = false
+      @enable_error_context = true
+      @enable_rails_error_subscriber = false
       @dj_threshold = 0
-      @enabled = nil  # set to true when configure is called
+      @dj_use_scoped_block = false
+      @async_skip_report_handler = nil
+      @enabled = nil # set to true when configure is called
       @endpoint = DEFAULT_ENDPOINT
       @environment = nil
       @exception_level_filters = {
@@ -79,34 +119,72 @@ module Rollbar
       }
       @failover_handlers = []
       @framework = 'Plain'
+      @ignore_internal_errors = [
+        'Net::ReadTimeout',
+        'Net::OpenTimeout',
+        'SocketError'
+      ]
       @ignored_person_ids = []
+      @host = nil
       @payload_options = {}
       @person_method = 'current_user'
       @person_id_method = 'id'
-      @person_username_method = 'username'
-      @person_email_method = 'email'
+      @person_username_method = nil
+      @person_email_method = nil
       @project_gems = []
       @populate_empty_backtraces = false
       @report_dj_data = true
+      @open_timeout = 3
       @request_timeout = 3
+      @net_retries = 3
+      @root = nil
       @js_enabled = false
       @js_options = {}
+      @locals = {}
       @scrub_fields = [:passwd, :password, :password_confirmation, :secret,
                        :confirm_password, :password_confirmation, :secret_token,
-                       :api_key, :access_token ]
+                       :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']
       @sidekiq_threshold = 0
+      @sidekiq_use_scoped_block = false
       @safely = false
       @transform = []
       @use_async = false
+      @async_json_payload = false
       @use_eventmachine = false
       @verify_ssl_peer = true
       @web_base = DEFAULT_WEB_BASE
+      @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
+      @user_ip_obfuscator_secret = nil
+      @user_ip_rack_env_key = nil
+      @backtrace_cleaner = nil
+      @hooks = {
+        :on_error_response => nil, # params: response
+        :on_report_internal_error => nil # params: exception
+      }
+
       @write_to_file = false
+      @filepath = nil
+      @files_with_pid_name_enabled = false
+      @files_processed_enabled = false
+      @files_processed_duration = 60
+      @files_processed_size = 5 * 1000 * 1000
+      @use_payload_access_token = false
+
+      @configured_options = ConfiguredOptions.new(self)
     end
 
     def initialize_copy(orig)
@@ -114,10 +192,56 @@ 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
+      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_active_job(options = {})
+      require 'rollbar/delay/active_job'
+
+      Rollbar::Delay::ActiveJob.queue_as(options[:queue] ||
+      Rollbar::Delay::ActiveJob.default_queue_name)
+
+      @use_async      = true
+      @async_handler  = Rollbar::Delay::ActiveJob
+    end
+
+    def use_delayed_job(options = {})
+      require 'rollbar/delay/delayed_job'
+
+      Rollbar::Delay::DelayedJob.queue = options[:queue] if options[:queue]
+
+      @use_async      = true
+      @async_handler  = Rollbar::Delay::DelayedJob
+    end
+
     def use_sidekiq(options = {})
       require 'rollbar/delay/sidekiq' if defined?(Sidekiq)
       @use_async      = true
@@ -133,16 +257,31 @@ module Rollbar
       @async_handler  = Rollbar::Delay::Resque
     end
 
+    def use_shoryuken(options = {})
+      require 'rollbar/delay/shoryuken' if defined?(Shoryuken)
+
+      Rollbar::Delay::Shoryuken.queue = options[:queue] if options[:queue]
+
+      @use_async      = true
+      @async_handler  = Rollbar::Delay::Shoryuken
+    end
+
     def use_sidekiq=(value)
-      deprecation_message = "#use_sidekiq=(value) has been deprecated in favor of #use_sidekiq(options = {}). Please update your rollbar configuration."
-      defined?(ActiveSupport) ? ActiveSupport::Deprecation.warn(deprecation_message) : puts(deprecation_message)
+      deprecation_message = '#use_sidekiq=(value) has been deprecated in favor ' \
+        'of #use_sidekiq(options = {}). Please update your rollbar configuration.'
+      if defined?(ActiveSupport)
+        ActiveSupport::Deprecation.warn(deprecation_message)
+      else
+        puts(deprecation_message)
+      end
 
       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
 
@@ -152,9 +291,14 @@ module Rollbar
       @async_handler  = Rollbar::Delay::SuckerPunch
     end
 
-    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)
+    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.'
+      if defined?(ActiveSupport)
+        ActiveSupport::Deprecation.warn(deprecation_message)
+      else
+        puts(deprecation_message)
+      end
 
       use_sucker_punch
     end
@@ -167,11 +311,12 @@ module Rollbar
     def project_gems=(gems)
       @project_gem_paths = gems.map do |name|
         found = Gem::Specification.each.select { |spec| name === spec.name }
-        if found.empty?
-          puts "[Rollbar] No gems found matching #{name.inspect}"
-        end
+        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)
@@ -182,13 +327,88 @@ 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 :all is expected"
+        )
+
+        return
+      end
+
+      @send_extra_frame_data = value
+    end
+
+    def enable_rails_error_subscriber=(enable)
+      return if !defined?(::Rails) || ::Rails.gem_version < ::Gem::Version.new('7.1.0')
+
+      if @enable_rails_error_subscriber && !enable
+        ::Rails.error.unsubscribe(Rollbar::ErrorSubscriber)
+      end
+
+      if !@enable_rails_error_subscriber && enable
+        ::Rails.error.subscribe(Rollbar::ErrorSubscriber.new)
+      end
+
+      @enable_rails_error_subscriber = enable
+    end
+
     # allow params to be read like a hash
     def [](option)
       send(option)
     end
 
+    def logger_level=(level)
+      @logger_level = if level
+                        level.to_sym
+                      else
+                        level
+                      end
+    end
+
     def logger
       @logger ||= default_logger.call
     end
+
+    def hook(symbol, &block)
+      unless @hooks.key?(symbol)
+        raise StandardError, "Hook :#{symbol} is not supported by Rollbar SDK."
+      end
+
+      if block_given?
+        @hooks[symbol] = block
+      else
+        @hooks[symbol]
+      end
+    end
+
+    def execute_hook(symbol, *args)
+      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
+      if method_string.end_with?('=')
+        configured[method_string.chomp('=').to_sym] =
+          args.first
+      end
+
+      configuration.send(method, *args, &block)
+    end
+
+    def respond_to_missing?(method)
+      configuration.respond_to?(method) || super
+    end
   end
 end

data/lib/rollbar/delay/active_job.rb

@@ -0,0 +1,17 @@
+module Rollbar
+  module Delay
+    # This class provides the ActiveJob async handler. Users can
+    # use ActiveJob in order to send the reports to the Rollbar API
+    class ActiveJob < ::ActiveJob::Base
+      queue_as :default
+
+      def perform(payload)
+        Rollbar.process_from_async_handler(payload)
+      end
+
+      def self.call(payload)
+        perform_later payload
+      end
+    end
+  end
+end

data/lib/rollbar/delay/delayed_job.rb

@@ -0,0 +1,23 @@
+module Rollbar
+  module Delay
+    # This class provides the DelayedJob async handler. Users can
+    # use DelayedJob in order to send the reports to the Rollbar API
+    class DelayedJob
+      class << self
+        attr_accessor :queue
+
+        def call(payload)
+          if queue
+            new.delay(:queue => queue).call(payload)
+          else
+            new.delay.call(payload)
+          end
+        end
+      end
+
+      def call(payload)
+        Rollbar.process_from_async_handler(payload)
+      end
+    end
+  end
+end

data/lib/rollbar/delay/girl_friday.rb

@@ -1,7 +1,6 @@
 module Rollbar
   module Delay
     class GirlFriday
-
       class << self
         def queue_class
           ::GirlFriday::WorkQueue
@@ -12,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/shoryuken.rb

@@ -0,0 +1,36 @@
+require 'shoryuken'
+
+module Rollbar
+  module Delay
+    # Following class allows to send rollbars using Sho-ryu-ken as a background
+    # jobs processor. See the queue_name method which states that your queues
+    # needs to be names as "rollbar_ENVIRONMENT". Retry intervals will be used
+    # to retry sending the same message again if failed before.
+    class Shoryuken
+      include ::Shoryuken::Worker
+
+      class << self
+        attr_accessor :queue
+      end
+
+      self.queue = "rollbar_#{Rollbar.configuration.environment}"
+
+      def self.call(payload)
+        new.call(payload, :queue => queue)
+      end
+
+      def call(payload, options = {})
+        self.class.perform_async(payload, options)
+      end
+
+      # not allowing bulk, to not double-report rollbars if one of them failed in bunch.
+      shoryuken_options :auto_delete => true,
+                        :body_parser => :json,
+                        :retry_intervals => [60, 180, 360, 120_0, 360_0, 186_00]
+
+      def perform(_sqs_message, payload)
+        Rollbar.process_from_async_handler(payload)
+      end
+    end
+  end
+end

data/lib/rollbar/delay/sidekiq.rb

@@ -10,19 +10,17 @@ module Rollbar
       end
 
       def call(payload)
-        ::Sidekiq::Client.push @options.merge('args' => [payload])
+        return unless ::Sidekiq::Client.push(@options.merge('args' => [payload])).nil?
+
+        raise(StandardError, 'Unable to push the job to Sidekiq')
       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

@@ -4,12 +4,10 @@ require 'sucker_punch/version'
 module Rollbar
   module Delay
     class SuckerPunch
-
       include ::SuckerPunch::Job
 
       class << self
-        attr_accessor :perform_proc
-        attr_accessor :ready
+        attr_accessor :perform_proc, :ready
       end
 
       self.ready = false
@@ -17,11 +15,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
@@ -33,20 +31,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