rollbar 2.22.1 → 3.4.0

data/lib/rollbar/plugin.rb

@@ -4,12 +4,8 @@ module Rollbar
   # 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_reader :revert_callables
-    attr_accessor :on_demand
-    attr_accessor :loaded
+    attr_reader :name, :dependencies, :callables, :revert_callables
+    attr_accessor :on_demand, :loaded
 
     private :loaded=
 
@@ -116,11 +112,15 @@ module Rollbar
     end
 
     def log_loading_error(error)
-      Rollbar.log_error("Error trying to load plugin '#{name}': #{error.class}, #{error.message}")
+      Rollbar.log_error(
+        "Error trying to load plugin '#{name}': #{error.class}, #{error.message}"
+      )
     end
 
     def log_unloading_error(error)
-      Rollbar.log_error("Error trying to unload plugin '#{name}': #{error.class}, #{error.message}")
+      Rollbar.log_error(
+        "Error trying to unload plugin '#{name}': #{error.class}, #{error.message}"
+      )
     end
   end
 end

data/lib/rollbar/plugins/active_job.rb

@@ -3,16 +3,33 @@ module Rollbar
   module ActiveJob
     def self.included(base)
       base.send :rescue_from, Exception do |exception|
+        args = if self.class.respond_to?(:log_arguments?) && !self.class.log_arguments?
+                 arguments.map(&Rollbar::Scrubbers.method(:scrub_value))
+               else
+                 arguments
+               end
+
         Rollbar.error(exception,
                       :job => self.class.name,
                       :job_id => job_id,
                       :use_exception_level_filters => true,
-                      :arguments => arguments)
+                      :arguments => args)
         raise exception
       end
     end
   end
 end
 
-# Automatically add to ActionMailer::DeliveryJob
-ActionMailer::DeliveryJob.send(:include, Rollbar::ActiveJob) if defined?(ActionMailer::DeliveryJob)
+if defined?(ActiveSupport) && ActiveSupport.respond_to?(:on_load)
+  ActiveSupport.on_load(:action_mailer) do
+    # Automatically add to ActionMailer::DeliveryJob
+    if defined?(ActionMailer::DeliveryJob)
+      ActionMailer::DeliveryJob.send(:include,
+                                     Rollbar::ActiveJob)
+    end
+    # Rails >= 6.0
+    if defined?(ActionMailer::MailDeliveryJob)
+      ActionMailer::MailDeliveryJob.send(:include, Rollbar::ActiveJob)
+    end
+  end
+end

data/lib/rollbar/plugins/delayed_job/plugin.rb

@@ -12,7 +12,19 @@ module Rollbar
         lifecycle.around(:invoke_job, &Delayed.invoke_job_callback)
         lifecycle.after(:failure) do |_, job, _, _|
           data = Rollbar::Delayed.build_job_data(job)
-          ::Rollbar.scope(:request => data).error("Job has failed and won't be retried anymore: " + job.last_error, :use_exception_level_filters => true) if job.last_error
+
+          # DelayedJob < 4.1 doesn't provide job#error
+          if job.class.method_defined? :error
+            if job.error
+              ::Rollbar.scope(:request => data)
+                       .error(job.error, :use_exception_level_filters => true)
+            end
+          elsif job.last_error
+            ::Rollbar.scope(:request => data).error(
+              "Job has failed and won't be retried anymore: #{job.last_error}",
+              :use_exception_level_filters => true
+            )
+          end
         end
       end
     end
@@ -50,10 +62,15 @@ module Rollbar
 
       data = build_job_data(job)
 
-      ::Rollbar.scope(:request => data).error(e, :use_exception_level_filters => true)
+      ::Rollbar.scope(:request => data)
+               .error(e, :use_exception_level_filters => true)
     end
 
     def self.skip_report?(job)
+      handler = ::Rollbar.configuration.async_skip_report_handler
+
+      return handler.call(job) if handler.respond_to?(:call)
+
       job.attempts < ::Rollbar.configuration.dj_threshold
     end
 

data/lib/rollbar/plugins/error_context.rb

@@ -0,0 +1,11 @@
+module RollbarErrorContext
+  attr_accessor :rollbar_context
+end
+
+Rollbar.plugins.define('error_context') do
+  dependency { configuration.enable_error_context }
+
+  execute! do
+    StandardError.send(:include, RollbarErrorContext)
+  end
+end

data/lib/rollbar/plugins/goalie.rb

@@ -11,29 +11,40 @@ Rollbar.plugins.define('goalie') do
           begin
             controller = env['action_controller.instance']
             request_data = begin
-                             controller.rollbar_request_data
-                           rescue StandardError
-                             nil
-                           end
+              controller.rollbar_request_data
+            rescue StandardError
+              nil
+            end
             person_data = begin
-                            controller.rollbar_person_data
-                          rescue StandardError
-                            nil
-                          end
-            exception_data = Rollbar.scope(:request => request_data, :person => person_data).error(exception, :use_exception_level_filters => true)
+              controller.rollbar_person_data
+            rescue StandardError
+              nil
+            end
+            exception_data = Rollbar.scope(
+              :request => request_data,
+              :person => person_data
+            ).error(exception, :use_exception_level_filters => true)
           rescue StandardError => e
-            Rollbar.log_warning "[Rollbar] Exception while reporting exception to Rollbar: #{e}"
+            message = "[Rollbar] Exception while reporting exception to Rollbar: #{e}"
+            Rollbar.log_warning(message)
           end
 
           # if an exception was reported, save uuid in the env
           # so it can be displayed to the user on the error page
-          if exception_data.is_a?(Hash)
+          case exception_data
+          when Hash
             env['rollbar.exception_uuid'] = exception_data[:uuid]
-            Rollbar.log_info "[Rollbar] Exception uuid saved in env: #{exception_data[:uuid]}"
-          elsif exception_data == 'disabled'
-            Rollbar.log_info '[Rollbar] Exception not reported because Rollbar is disabled'
-          elsif exception_data == 'ignored'
-            Rollbar.log_info '[Rollbar] Exception not reported because it was ignored'
+            Rollbar.log_info(
+              "[Rollbar] Exception uuid saved in env: #{exception_data[:uuid]}"
+            )
+          when 'disabled'
+            Rollbar.log_info(
+              '[Rollbar] Exception not reported because Rollbar is disabled'
+            )
+          when 'ignored'
+            Rollbar.log_info(
+              '[Rollbar] Exception not reported because it was ignored'
+            )
           end
 
           # now continue as normal

data/lib/rollbar/plugins/rails/controller_methods.rb

@@ -7,30 +7,34 @@ module Rollbar
       include RequestDataExtractor
 
       def rollbar_person_data
-        (user = send(Rollbar.configuration.person_method)) unless Rollbar::Util.method_in_stack_twice(:rollbar_person_data, __FILE__)
+        user = nil
+        unless Rollbar::Util.method_in_stack_twice(:rollbar_person_data, __FILE__)
+          user = send(Rollbar.configuration.person_method)
+        end
+
         # include id, username, email if non-empty
         if user
           {
             :id => (begin
-                      user.send(Rollbar.configuration.person_id_method)
-                    rescue StandardError
-                      nil
-                    end),
+              user.send(Rollbar.configuration.person_id_method)
+            rescue StandardError
+              nil
+            end),
             :username => (begin
-                            user.send(Rollbar.configuration.person_username_method)
-                          rescue StandardError
-                            nil
-                          end),
+              user.send(Rollbar.configuration.person_username_method)
+            rescue StandardError
+              nil
+            end),
             :email => (begin
-                         user.send(Rollbar.configuration.person_email_method)
-                       rescue StandardError
-                         nil
-                       end)
+              user.send(Rollbar.configuration.person_email_method)
+            rescue StandardError
+              nil
+            end)
           }
         else
           {}
         end
-      rescue NoMethodError, NameError
+      rescue NameError
         {}
       end
 

data/lib/rollbar/plugins/rails/railtie30.rb

@@ -11,7 +11,8 @@ module Rollbar
 
       app.config.middleware.insert_after ActionDispatch::ShowExceptions,
                                          Rollbar::Middleware::Rails::RollbarMiddleware
-      ActionDispatch::ShowExceptions.send(:include, Rollbar::Middleware::Rails::ShowExceptions)
+      ActionDispatch::ShowExceptions.send(:include,
+                                          Rollbar::Middleware::Rails::ShowExceptions)
     end
   end
 end

data/lib/rollbar/plugins/rails/railtie32.rb

@@ -11,7 +11,8 @@ module Rollbar
 
       app.config.middleware.insert_after ActionDispatch::DebugExceptions,
                                          Rollbar::Middleware::Rails::RollbarMiddleware
-      ActionDispatch::DebugExceptions.send(:include, Rollbar::Middleware::Rails::ShowExceptions)
+      ActionDispatch::DebugExceptions.send(:include,
+                                           Rollbar::Middleware::Rails::ShowExceptions)
     end
   end
 end

data/lib/rollbar/plugins/rails/railtie_mixin.rb

@@ -16,9 +16,9 @@ module Rollbar
             config.framework = "Rails: #{::Rails::VERSION::STRING}"
             config.filepath ||= begin
               if ::Rails.application.class.respond_to?(:module_parent_name)
-                ::Rails.application.class.module_parent_name + '.rollbar'
+                "#{::Rails.application.class.module_parent_name}.rollbar"
               else
-                ::Rails.application.class.parent_name + '.rollbar'
+                "#{::Rails.application.class.parent_name}.rollbar"
               end
             end
           end

data/lib/rollbar/plugins/rails.rb

@@ -39,7 +39,8 @@ Rollbar.plugins.define('rails-rollbar.js') do
             end
 
             def after_secure_headers(&block)
-              Rollbar::Railtie.initializer('rollbar.js.frameworks.rails', :after => 'secure_headers.middleware', &block)
+              Rollbar::Railtie.initializer('rollbar.js.frameworks.rails',
+                                           :after => 'secure_headers.middleware', &block)
             end
 
             def plugin_execute_proc_body(plugin)
@@ -52,7 +53,8 @@ Rollbar.plugins.define('rails-rollbar.js') do
                       :options => Rollbar.configuration.js_options,
                       :enabled => Rollbar.configuration.js_enabled
                     }
-                    ::Rails.configuration.middleware.use(::Rollbar::Middleware::Js, config)
+                    ::Rails.configuration.middleware.use(::Rollbar::Middleware::Js,
+                                                         config)
                   end
                 end
               end
@@ -62,6 +64,7 @@ Rollbar.plugins.define('rails-rollbar.js') do
               begin
                 require 'secure_headers'
               rescue LoadError
+                # Skip loading
               end
 
               defined?(::SecureHeaders::Middleware)

data/lib/rollbar/plugins/rake.rb

@@ -40,7 +40,8 @@ Rollbar.plugins.define('rake') do
       end
 
       def self.skip_patch
-        warn('[Rollbar] Rollbar is disabled for Rake tasks since your Rake version is under 0.9.x. Please upgrade to 0.9.x or higher.')
+        warn('[Rollbar] Rollbar is disabled for Rake tasks since your Rake ' \
+          'version is under 0.9.x. Please upgrade to 0.9.x or higher.')
       end
 
       def self.patch?

data/lib/rollbar/plugins/sidekiq/plugin.rb

@@ -4,21 +4,39 @@ module Rollbar
   class Sidekiq
     PARAM_BLACKLIST = %w[backtrace error_backtrace error_message error_class].freeze
 
-    class ClearScope
-      def call(_worker, _msg, _queue)
-        Rollbar.reset_notifier!
+    class ResetScope
+      def call(_worker, msg, _queue, &block)
+        Rollbar.reset_notifier! # clears scope
 
-        yield
+        return yield unless Rollbar.configuration.sidekiq_use_scoped_block
+
+        Rollbar.scoped(Rollbar::Sidekiq.job_scope(msg), &block)
       end
     end
 
-    def self.handle_exception(ctx_hash, e)
-      job_hash = ctx_hash && (ctx_hash[:job] || ctx_hash)
-      return if skip_report?(job_hash, e)
+    def self.handle_exception(msg, e)
+      return if skip_report?(msg, e)
+
+      Rollbar.scope(job_scope(msg)).error(e, :use_exception_level_filters => true)
+    end
+
+    def self.skip_report?(msg, _e)
+      job_hash = job_hash_from_msg(msg)
+
+      return false if job_hash.nil?
+
+      # when rollbar middleware catches, sidekiq's retry_job processor hasn't set
+      # the retry_count for the current job yet, so adding 1 gives the actual retry count
+      actual_retry_count = job_hash.fetch('retry_count', -1) + 1
+      job_hash['retry'] && actual_retry_count < ::Rollbar.configuration.sidekiq_threshold
+    end
 
+    def self.job_scope(msg)
       scope = {
         :framework => "Sidekiq: #{::Sidekiq::VERSION}"
       }
+      job_hash = job_hash_from_msg(msg)
+
       unless job_hash.nil?
         params = job_hash.reject { |k| PARAM_BLACKLIST.include?(k) }
         scope[:request] = { :params => scrub_params(params) }
@@ -26,34 +44,34 @@ module Rollbar
         scope[:queue] = params['queue']
       end
 
-      Rollbar.scope(scope).error(e, :use_exception_level_filters => true)
+      scope
     end
 
     def self.scrub_params(params)
       options = {
         :params => params,
-        :config => Rollbar.configuration.scrub_fields
+        :config => Rollbar.configuration.scrub_fields,
+        :whitelist => Rollbar.configuration.scrub_whitelist
       }
 
       Rollbar::Scrubbers::Params.call(options)
     end
 
-    def self.skip_report?(job_hash, _e)
-      return false if job_hash.nil?
+    # see https://github.com/mperham/sidekiq/wiki/Middleware#server-middleware
+    def call(_worker, msg, _queue, &block)
+      Rollbar.reset_notifier! # clears scope
 
-      # when rollbar middleware catches, sidekiq's retry_job processor hasn't set
-      # the retry_count for the current job yet, so adding 1 gives the actual retry count
-      actual_retry_count = job_hash.fetch('retry_count', -1) + 1
-      job_hash['retry'] && actual_retry_count < ::Rollbar.configuration.sidekiq_threshold
-    end
-
-    def call(_worker, msg, _queue)
-      Rollbar.reset_notifier!
+      return yield unless Rollbar.configuration.sidekiq_use_scoped_block
 
-      yield
-    rescue Exception => e
+      Rollbar.scoped(Rollbar::Sidekiq.job_scope(msg), &block)
+    rescue Exception => e # rubocop:disable Lint/RescueException
       Rollbar::Sidekiq.handle_exception(msg, e)
       raise
     end
+
+    def self.job_hash_from_msg(msg)
+      msg && (msg[:job] || msg)
+    end
+    private_class_method :job_hash_from_msg
   end
 end

data/lib/rollbar/plugins/sidekiq.rb

@@ -9,7 +9,7 @@ Rollbar.plugins.define('sidekiq >= 3') do
 
     Sidekiq.configure_server do |config|
       config.server_middleware do |chain|
-        chain.add Rollbar::Sidekiq::ClearScope
+        chain.add Rollbar::Sidekiq::ResetScope
       end
 
       config.error_handlers << proc do |e, context|

data/lib/rollbar/plugins/thread.rb

@@ -1,13 +1,14 @@
 Rollbar.plugins.define('thread') do
-  execute do
-    Thread.class_eval do
-      def initialize_with_rollbar(*args, &block)
+  module Rollbar
+    module ThreadPlugin
+      def initialize(*args)
         self[:_rollbar_notifier] ||= Rollbar.notifier.scope
-        initialize_without_rollbar(*args, &block)
+        super
       end
-
-      alias_method :initialize_without_rollbar, :initialize
-      alias_method :initialize, :initialize_with_rollbar
     end
   end
+
+  execute do
+    Thread.send(:prepend, Rollbar::ThreadPlugin)
+  end
 end

data/lib/rollbar/plugins/validations.rb

@@ -17,7 +17,9 @@ Rollbar.plugins.define('active_model') do
       module ActiveRecordExtension
         def report_validation_errors_to_rollbar
           errors.full_messages.each do |error|
-            Rollbar.log_info "[Rollbar] Reporting form validation error: #{error} for #{self}"
+            Rollbar.log_info(
+              "[Rollbar] Reporting form validation error: #{error} for #{self}"
+            )
             Rollbar.warning("Form Validation Error: #{error} for #{self}")
           end
         end

data/lib/rollbar/rake_tasks.rb

@@ -1,6 +1,5 @@
-
 namespace :rollbar do
-  desc 'Verify your gem installation by sending a test exception to Rollbar'
+  desc 'Verify your gem installation by sending a test message to Rollbar'
   task :test => [:environment] do
     rollbar_dir = Gem.loaded_specs['rollbar'].full_gem_path
     require "#{rollbar_dir}/lib/rollbar/rollbar_test"

data/lib/rollbar/request_data_extractor.rb

@@ -19,10 +19,10 @@ module Rollbar
       else
         controller = env['action_controller.instance']
         person_data = begin
-                        controller.rollbar_person_data
-                      rescue StandardError
-                        {}
-                      end
+          controller.rollbar_person_data
+        rescue StandardError
+          {}
+        end
       end
 
       person_data
@@ -34,7 +34,8 @@ module Rollbar
 
       get_params = scrub_params(rollbar_get_params(rack_req), sensitive_params)
       post_params = scrub_params(rollbar_post_params(rack_req), sensitive_params)
-      raw_body_params = scrub_params(mergeable_raw_body_params(rack_req), sensitive_params)
+      raw_body_params = scrub_params(mergeable_raw_body_params(rack_req),
+                                     sensitive_params)
       cookies = scrub_params(rollbar_request_cookies(rack_req), sensitive_params)
       session = scrub_params(rollbar_request_session(env), sensitive_params)
       route_params = scrub_params(rollbar_route_params(env), sensitive_params)
@@ -54,7 +55,10 @@ module Rollbar
         :method => rollbar_request_method(env)
       }
 
-      data[:request_id] = env['action_dispatch.request_id'] if env['action_dispatch.request_id']
+      if env['action_dispatch.request_id']
+        data[:request_id] =
+          env['action_dispatch.request_id']
+      end
 
       data
     end
@@ -87,9 +91,10 @@ module Rollbar
     def mergeable_raw_body_params(rack_req)
       raw_body_params = rollbar_raw_body_params(rack_req)
 
-      if raw_body_params.is_a?(Hash)
+      case raw_body_params
+      when Hash
         raw_body_params
-      elsif raw_body_params.is_a?(Array)
+      when Array
         { 'body.multi' => raw_body_params }
       else
         { 'body.value' => raw_body_params }
@@ -109,13 +114,17 @@ module Rollbar
           { name => Rollbar::Scrubbers.scrub_value(env[header]) }
         elsif name == 'X-Forwarded-For' && !Rollbar.configuration.collect_user_ip
           {}
-        elsif name == 'X-Forwarded-For' && Rollbar.configuration.collect_user_ip && Rollbar.configuration.anonymize_user_ip
+        elsif name == 'X-Forwarded-For' &&
+              Rollbar.configuration.collect_user_ip &&
+              Rollbar.configuration.anonymize_user_ip
           ips = env[header].sub(' ', '').split(',')
           ips = ips.map { |ip| Rollbar::Util::IPAnonymizer.anonymize_ip(ip) }
           { name => ips.join(', ') }
         elsif name == 'X-Real-Ip' && !Rollbar.configuration.collect_user_ip
           {}
-        elsif name == 'X-Real-Ip' && Rollbar.configuration.collect_user_ip && Rollbar.configuration.anonymize_user_ip
+        elsif name == 'X-Real-Ip' &&
+              Rollbar.configuration.collect_user_ip &&
+              Rollbar.configuration.anonymize_user_ip
           { name => Rollbar::Util::IPAnonymizer.anonymize_ip(env[header]) }
         else
           { name => env[header] }
@@ -131,15 +140,15 @@ module Rollbar
       host = host.split(',').first.strip unless host.empty?
 
       path = env['ORIGINAL_FULLPATH'] || env['REQUEST_URI']
-      unless path.nil? || path.empty?
-        path = '/' + path.to_s if path.to_s.slice(0, 1) != '/'
-      end
+      query = env['QUERY_STRING'].to_s.empty? ? nil : "?#{env['QUERY_STRING']}"
+      path ||= "#{env['SCRIPT_NAME']}#{env['PATH_INFO']}#{query}"
+      path = "/#{path}" if !(path.nil? || path.empty?) && (path.to_s.slice(0, 1) != '/')
 
       port = env['HTTP_X_FORWARDED_PORT']
       if port && !(!scheme.nil? && scheme.casecmp('http').zero? && port.to_i == 80) && \
          !(!scheme.nil? && scheme.casecmp('https').zero? && port.to_i == 443) && \
          !(host.include? ':')
-        host = host + ':' + port
+        host = "#{host}:#{port}"
       end
 
       [scheme, '://', host, path].join
@@ -148,7 +157,11 @@ module Rollbar
     def rollbar_user_ip(env)
       return nil unless Rollbar.configuration.collect_user_ip
 
-      user_ip_string = (env['action_dispatch.remote_ip'] || env['HTTP_X_REAL_IP'] || x_forwarded_for_client(env['HTTP_X_FORWARDED_FOR']) || env['REMOTE_ADDR']).to_s
+      user_ip_string = (user_ip_at_configured_key(env) ||
+                        env['action_dispatch.remote_ip'] ||
+                        env['HTTP_X_REAL_IP'] ||
+                        x_forwarded_for_client(env['HTTP_X_FORWARDED_FOR']) ||
+                        env['REMOTE_ADDR']).to_s
 
       user_ip_string = Rollbar::Util::IPAnonymizer.anonymize_ip(user_ip_string)
 
@@ -157,6 +170,12 @@ module Rollbar
       nil
     end
 
+    def user_ip_at_configured_key(env)
+      return nil unless Rollbar.configuration.user_ip_rack_env_key
+
+      env[Rollbar.configuration.user_ip_rack_env_key]
+    end
+
     def x_forwarded_for_client(header_value)
       return nil unless header_value
 
@@ -195,7 +214,7 @@ module Rollbar
       return {} unless correct_method
       return {} unless json_request?(rack_req)
 
-      raw_body = rack_req.body.read
+      raw_body = read_raw_body(rack_req.body)
       begin
         Rollbar::JSON.load(raw_body)
       rescue StandardError
@@ -203,8 +222,15 @@ module Rollbar
       end
     rescue StandardError
       {}
-    ensure
-      rack_req.body.rewind
+    end
+
+    def read_raw_body(body)
+      return {} unless body.respond_to?(:rewind)
+
+      body.rewind
+      raw_body = body.read
+      body.rewind
+      raw_body
     end
 
     def json_request?(rack_req)
@@ -247,7 +273,15 @@ module Rollbar
     end
 
     def sensitive_headers_list
-      Rollbar.configuration.scrub_headers || []
+      unless Rollbar.configuration.scrub_headers &&
+             Rollbar.configuration.scrub_headers.is_a?(Array)
+        return []
+      end
+
+      # Normalize into the expected matching format
+      Rollbar.configuration.scrub_headers.map do |header|
+        header.split(/[-_]/).map(&:capitalize).join('-').gsub(/^Http-/, '')
+      end
     end
   end
 end