rollbar 2.26.0 → 3.4.0

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,10 @@ module Rollbar
     end
 
     def sensitive_headers_list
-      return [] unless Rollbar.configuration.scrub_headers && Rollbar.configuration.scrub_headers.is_a?(Array)
+      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|

data/lib/rollbar/rollbar_test.rb

@@ -1,48 +1,16 @@
 require 'rollbar'
-begin
-  require 'rack/mock'
-rescue LoadError
-  puts 'Cannot load rack/mock'
-end
-require 'logger'
 
-# Module to inject into the Rails controllers or rack apps
 module RollbarTest # :nodoc:
-  def test_rollbar
-    puts 'Raising RollbarTestingException to simulate app failure.'
-
-    raise RollbarTestingException.new, ::RollbarTest.success_message
-  end
-
   def self.run
     return unless confirmed_token?
 
-    configure_rails if defined?(Rails)
-
-    puts 'Testing manual report...'
-    Rollbar.error('Test error from rollbar:test')
-
-    return unless defined?(Rack::MockRequest)
-
-    protocol, app = setup_app
-
-    puts 'Processing...'
-    env = Rack::MockRequest.env_for("#{protocol}://www.example.com/verify", 'REMOTE_ADDR' => '127.0.0.1')
-    status, = app.call(env)
-
-    puts error_message unless status.to_i == 500
-  end
-
-  def self.configure_rails
-    Rails.logger = if defined?(ActiveSupport::TaggedLogging)
-                     ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
-                   else
-                     Logger.new(STDOUT)
-                   end
+    puts 'Test sending to Rollbar...'
+    result = Rollbar.info('Test message from rollbar:test')
 
-    Rails.logger.level = Logger::DEBUG
-    Rollbar.preconfigure do |config|
-      config.logger = Rails.logger
+    if result == 'error'
+      puts error_message
+    else
+      puts success_message
     end
   end
 
@@ -54,94 +22,17 @@ module RollbarTest # :nodoc:
     false
   end
 
-  def self.authlogic_config
-    # from http://stackoverflow.com/questions/5270835/authlogic-activation-problems
-    return unless defined?(Authlogic)
-
-    Authlogic::Session::Base.controller = Authlogic::ControllerAdapters::RailsAdapter.new(self)
-  end
-
-  def self.setup_app
-    puts 'Setting up the test app.'
-
-    if defined?(Rails)
-      app = rails_app
-
-      draw_rails_route(app)
-
-      authlogic_config
-
-      [rails_protocol(app), app]
-    else
-      ['http', rack_app]
-    end
-  end
-
-  def self.rails_app
-    # The setup below is needed for Rails 5.x, but not for Rails 4.x and below.
-    # (And fails on Rails 4.x in various ways depending on the exact version.)
-    return Rails.application if Rails.version < '5.0.0'
-
-    # Spring now runs by default in development on all new Rails installs. This causes
-    # the new `/verify` route to not get picked up if `config.cache_classes == false`
-    # which is also a default in development env.
-    #
-    # `config.cache_classes` needs to be set, but the only possible time is at app load,
-    # so here we clone the default app with an updated config.
-    #
-    config = Rails.application.config
-    config.cache_classes = true
-
-    # Make a copy of the app, so the config can be updated.
-    Rails.application.class.name.constantize.new(:config => config)
-  end
-
-  def self.draw_rails_route(app)
-    app.routes_reloader.execute_if_updated
-    app.routes.draw do
-      get 'verify' => 'rollbar_test#verify', :as => 'verify'
-    end
-  end
-
-  def self.rails_protocol(app)
-    defined?(app.config.force_ssl && app.config.force_ssl) ? 'https' : 'http'
-  end
-
-  def self.rack_app
-    Class.new do
-      include RollbarTest
-
-      def self.call(_env)
-        new.test_rollbar
-      end
-    end
-  end
-
   def self.token_error_message
     'Rollbar needs an access token configured. Check the README for instructions.'
   end
 
   def self.error_message
-    'Test failed! You may have a configuration issue, or you could be using a gem that\'s blocking the test. Contact support@rollbar.com if you need help troubleshooting.'
+    'Test failed! You may have a configuration issue, or you could be using a ' \
+    'gem that\'s blocking the test. Contact support@rollbar.com if you need ' \
+    'help troubleshooting.'
   end
 
   def self.success_message
     'Testing rollbar with "rake rollbar:test". If you can see this, it works.'
   end
 end
-
-class RollbarTestingException < RuntimeError; end
-
-if defined?(Rails)
-  class RollbarTestController < ActionController::Base # :nodoc:
-    include RollbarTest
-
-    def verify
-      test_rollbar
-    end
-
-    def logger
-      nil
-    end
-  end
-end