rollbar 2.19.1 → 2.27.1

data/lib/rollbar/plugins/active_job.rb

@@ -14,5 +14,9 @@ module Rollbar
   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
+    ActionMailer::DeliveryJob.send(:include, Rollbar::ActiveJob) if defined?(ActionMailer::DeliveryJob)
+  end
+end

data/lib/rollbar/plugins/basic_socket.rb

@@ -1,16 +1,31 @@
 Rollbar.plugins.define('basic_socket') do
+  load_on_demand
+
   dependency { !configuration.disable_core_monkey_patch }
 
   # Needed to avoid active_support (< 4.1.0) bug serializing JSONs
-  dependency { defined?(ActiveSupport::VERSION::STRING) }
+  dependency do
+    defined?(ActiveSupport::VERSION::STRING) &&
+      Gem::Version.new(ActiveSupport::VERSION::STRING) < Gem::Version.new('4.1.0')
+  end
 
   execute do
-    require 'socket'
-
-    class BasicSocket
-      def as_json(*)
-        to_s
+    class BasicSocket # :nodoc:
+      def new_as_json(_options = nil)
+        {
+          :value => inspect
+        }
       end
+      # alias_method is recommended over alias when aliasing at runtime.
+      # https://github.com/rubocop-hq/ruby-style-guide#alias-method
+      alias_method :original_as_json, :as_json # rubocop:disable Style/Alias
+      alias_method :as_json, :new_as_json # rubocop:disable Style/Alias
+    end
+  end
+
+  revert do
+    class BasicSocket # :nodoc:
+      alias_method :as_json, :original_as_json # rubocop:disable Style/Alias
     end
   end
 end

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

@@ -10,7 +10,7 @@ module Rollbar
       def to_hash
         job_data = extract_job_data
 
-        handler_parent = job_data['job'] ? job_data['job'] : job_data
+        handler_parent = job_data['job'] || job_data
         handler_parent['handler'] = handler_data
 
         job_data
@@ -32,7 +32,7 @@ module Rollbar
         return payload_object unless payload_object.respond_to?(:object)
 
         object_data(payload_object.object)
-      rescue
+      rescue StandardError
         {}
       end
 
@@ -42,7 +42,7 @@ module Rollbar
           :args => job.payload_object.args,
           :object => object.is_a?(Class) ? object.name : object.to_s
         }
-      rescue
+      rescue StandardError
         {}
       end
     end

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

@@ -9,10 +9,16 @@ module Rollbar
 
     class RollbarPlugin < ::Delayed::Plugin
       callbacks do |lifecycle|
-        lifecycle.around(:invoke_job, &Delayed::invoke_job_callback)
+        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
+            ::Rollbar.scope(:request => data).error(job.error, :use_exception_level_filters => true) if job.error
+          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
@@ -37,7 +43,7 @@ module Rollbar
       proc do |job, *args, &block|
         begin
           block.call(job, *args)
-        rescue => e
+        rescue StandardError => e
           report(e, job)
 
           raise e
@@ -54,6 +60,10 @@ module Rollbar
     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

@@ -10,10 +10,18 @@ Rollbar.plugins.define('goalie') do
 
           begin
             controller = env['action_controller.instance']
-            request_data = controller.rollbar_request_data rescue nil
-            person_data = controller.rollbar_person_data rescue nil
+            request_data = begin
+                             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)
-          rescue => e
+          rescue StandardError => e
             Rollbar.log_warning "[Rollbar] Exception while reporting exception to Rollbar: #{e}"
           end
 

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

@@ -11,9 +11,21 @@ module Rollbar
         # include id, username, email if non-empty
         if user
           {
-            :id => (user.send(Rollbar.configuration.person_id_method) rescue nil),
-            :username => (user.send(Rollbar.configuration.person_username_method) rescue nil),
-            :email => (user.send(Rollbar.configuration.person_email_method) rescue nil)
+            :id => (begin
+                      user.send(Rollbar.configuration.person_id_method)
+                    rescue StandardError
+                      nil
+                    end),
+            :username => (begin
+                            user.send(Rollbar.configuration.person_username_method)
+                          rescue StandardError
+                            nil
+                          end),
+            :email => (begin
+                         user.send(Rollbar.configuration.person_email_method)
+                       rescue StandardError
+                         nil
+                       end)
           }
         else
           {}

data/lib/rollbar/plugins/rake.rb

@@ -58,9 +58,9 @@ Rollbar.plugins.define('rake') do
 
       def self.rake_version
         if Object.const_defined?('RAKEVERSION')
-          return RAKEVERSION
+          RAKEVERSION
         elsif ::Rake.const_defined?('VERSION')
-          return ::Rake::VERSION
+          ::Rake::VERSION
         end
       end
     end

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

@@ -2,10 +2,10 @@ require 'rollbar/scrubbers/params'
 
 module Rollbar
   class Sidekiq
-    PARAM_BLACKLIST = %w[backtrace error_backtrace error_message error_class]
+    PARAM_BLACKLIST = %w[backtrace error_backtrace error_message error_class].freeze
 
     class ClearScope
-      def call(worker, msg, queue)
+      def call(_worker, _msg, _queue)
         Rollbar.reset_notifier!
 
         yield
@@ -38,15 +38,16 @@ module Rollbar
       Rollbar::Scrubbers::Params.call(options)
     end
 
-    def self.skip_report?(job_hash, e)
+    def self.skip_report?(job_hash, _e)
       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 call(worker, msg, queue)
+    def call(_worker, msg, _queue)
       Rollbar.reset_notifier!
 
       yield

data/lib/rollbar/plugins.rb

@@ -29,7 +29,13 @@ module Rollbar
     end
 
     def load!
-      collection.each(&:load!)
+      collection.each do |plugin|
+        plugin.load! unless plugin.on_demand
+      end
+    end
+
+    def get(name)
+      collection.find { |plugin| plugin.name == name }
     end
 
     private

data/lib/rollbar/rake_tasks.rb

@@ -1,154 +1,10 @@
-require 'rollbar'
-begin
-  require 'rack/mock'
-rescue LoadError
-  puts 'Cannot load rack/mock'
-end
-require 'logger'
 
 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
-    RollbarTest.run
-  end
-end
-
-# 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
-
-    Rails.logger.level = Logger::DEBUG
-    Rollbar.preconfigure do |config|
-      config.logger = Rails.logger
-    end
-  end
-
-  def self.confirmed_token?
-    return true if Rollbar.configuration.access_token
-
-    puts token_error_message
-
-    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.'
+    rollbar_dir = Gem.loaded_specs['rollbar'].full_gem_path
+    require "#{rollbar_dir}/lib/rollbar/rollbar_test"
 
-    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.'
-  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
+    RollbarTest.run
   end
 end

data/lib/rollbar/request_data_extractor.rb

@@ -10,15 +10,19 @@ require 'rollbar/json'
 
 module Rollbar
   module RequestDataExtractor
-    ALLOWED_HEADERS_REGEX = /^HTTP_|^CONTENT_TYPE$|^CONTENT_LENGTH$/
-    ALLOWED_BODY_PARSEABLE_METHODS = %w(POST PUT PATCH DELETE).freeze
+    ALLOWED_HEADERS_REGEX = /^HTTP_|^CONTENT_TYPE$|^CONTENT_LENGTH$/.freeze
+    ALLOWED_BODY_PARSEABLE_METHODS = %w[POST PUT PATCH DELETE].freeze
 
     def extract_person_data_from_controller(env)
-      if env.has_key?('rollbar.person_data')
+      if env.key?('rollbar.person_data')
         person_data = env['rollbar.person_data'] || {}
       else
         controller = env['action_controller.instance']
-        person_data = controller.rollbar_person_data rescue {}
+        person_data = begin
+                        controller.rollbar_person_data
+                      rescue StandardError
+                        {}
+                      end
       end
 
       person_data
@@ -50,9 +54,7 @@ module Rollbar
         :method => rollbar_request_method(env)
       }
 
-      if env['action_dispatch.request_id']
-        data[:request_id] = env['action_dispatch.request_id']
-      end
+      data[:request_id] = env['action_dispatch.request_id'] if env['action_dispatch.request_id']
 
       data
     end
@@ -108,7 +110,7 @@ module Rollbar
         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
-          ips = env[header].sub(" ", "").split(',')
+          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
@@ -129,13 +131,14 @@ module Rollbar
       host = host.split(',').first.strip unless host.empty?
 
       path = env['ORIGINAL_FULLPATH'] || env['REQUEST_URI']
+      path ||= "#{env['SCRIPT_NAME']}#{env['PATH_INFO']}#{"?#{env['QUERY_STRING']}" unless env['QUERY_STRING'].to_s.empty?}"
       unless path.nil? || path.empty?
         path = '/' + path.to_s if path.to_s.slice(0, 1) != '/'
       end
 
       port = env['HTTP_X_FORWARDED_PORT']
-      if port && !(!scheme.nil? && scheme.downcase == 'http' && port.to_i == 80) && \
-         !(!scheme.nil? && scheme.downcase == 'https' && port.to_i == 443) && \
+      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
       end
@@ -145,12 +148,13 @@ 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 = Rollbar::Util::IPAnonymizer.anonymize_ip(user_ip_string)
 
       Rollbar::Util::IPObfuscator.obfuscate_ip(user_ip_string)
-    rescue
+    rescue StandardError
       nil
     end
 
@@ -176,13 +180,13 @@ module Rollbar
 
     def rollbar_get_params(rack_req)
       rack_req.GET
-    rescue
+    rescue StandardError
       {}
     end
 
     def rollbar_post_params(rack_req)
       rack_req.POST
-    rescue
+    rescue StandardError
       {}
     end
 
@@ -195,18 +199,19 @@ module Rollbar
       raw_body = rack_req.body.read
       begin
         Rollbar::JSON.load(raw_body)
-      rescue
+      rescue StandardError
         raw_body
       end
-    rescue
+    rescue StandardError
       {}
     ensure
       rack_req.body.rewind
     end
 
     def json_request?(rack_req)
-      !!(rack_req.env['CONTENT_TYPE'] =~ %r{application/json} ||
-         rack_req.env['ACCEPT'] =~ /\bjson\b/)
+      json_regex = /\bjson\b/
+
+      !!(rack_req.env['CONTENT_TYPE'] =~ json_regex)
     end
 
     def rollbar_route_params(env)
@@ -219,7 +224,7 @@ module Rollbar
         # route params (if any)and format (if defined)
         ::Rails.application.routes.recognize_path(env['PATH_INFO'],
                                                   environment)
-      rescue
+      rescue StandardError
         {}
       end
     end
@@ -228,13 +233,13 @@ module Rollbar
       session = env.fetch('rack.session', {})
 
       session.to_hash
-    rescue
+    rescue StandardError
       {}
     end
 
     def rollbar_request_cookies(rack_req)
       rack_req.cookies
-    rescue
+    rescue StandardError
       {}
     end
 
@@ -243,7 +248,12 @@ module Rollbar
     end
 
     def sensitive_headers_list
-      Rollbar.configuration.scrub_headers || []
+      return [] unless Rollbar.configuration.scrub_headers && Rollbar.configuration.scrub_headers.is_a?(Array)
+
+      # Normalize into the expected matching format
+      Rollbar.configuration.scrub_headers.map do |header|
+        header.split(/[-_]/).map(&:capitalize).join('-').gsub(/^Http-/, '')
+      end
     end
   end
 end

data/lib/rollbar/rollbar_test.rb

@@ -0,0 +1,36 @@
+require 'rollbar'
+
+module RollbarTest # :nodoc:
+  def self.run
+    return unless confirmed_token?
+
+    puts 'Test sending to Rollbar...'
+    result = Rollbar.info('Test message from rollbar:test')
+
+    if result == 'error'
+      puts error_message
+    else
+      puts success_message
+    end
+  end
+
+  def self.confirmed_token?
+    return true if Rollbar.configuration.access_token
+
+    puts token_error_message
+
+    false
+  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.'
+  end
+
+  def self.success_message
+    'Testing rollbar with "rake rollbar:test". If you can see this, it works.'
+  end
+end

data/lib/rollbar/scrubbers/params.rb

@@ -9,8 +9,8 @@ module Rollbar
     # received parameters. It will not scrub anything that is in the scrub_whitelist
     # configuration array even if :scrub_all is true.
     class Params
-      SKIPPED_CLASSES = [::Tempfile]
-      ATTACHMENT_CLASSES = %w(ActionDispatch::Http::UploadedFile Rack::Multipart::UploadedFile).freeze
+      SKIPPED_CLASSES = [::Tempfile].freeze
+      ATTACHMENT_CLASSES = %w[ActionDispatch::Http::UploadedFile Rack::Multipart::UploadedFile].freeze
       SCRUB_ALL = :scrub_all
 
       def self.call(*args)
@@ -52,9 +52,10 @@ module Rollbar
       end
 
       def build_whitelist_regex(whitelist)
-        fields = whitelist.find_all { |f| f.is_a?(String) || f.is_a?(Symbol) }
+        fields = whitelist.find_all { |f| f.is_a?(String) || f.is_a?(Symbol) || f.is_a?(Regexp) }
         return unless fields.any?
-        Regexp.new(fields.map { |val| /\A#{Regexp.escape(val.to_s)}\z/ }.join('|'))
+
+        Regexp.new(fields.map { |val| val.is_a?(Regexp) ? val : /\A#{Regexp.escape(val.to_s)}\z/ }.join('|'))
       end
 
       def scrub(params, options)
@@ -70,19 +71,19 @@ module Rollbar
 
         params.to_hash.inject({}) do |result, (key, value)|
           encoded_key = Rollbar::Encoding.encode(key).to_s
-          if (fields_regex === encoded_key) && !(whitelist_regex === encoded_key)
-            result[key] = scrub_value(value)
-          elsif value.is_a?(Hash)
-            result[key] = scrub(value, options)
-          elsif scrub_all && !(whitelist_regex === encoded_key)
-            result[key] = scrub_value(value)
-          elsif value.is_a?(Array)
-            result[key] = scrub_array(value, options)
-          elsif skip_value?(value)
-            result[key] = "Skipped value of class '#{value.class.name}'"
-          else
-            result[key] = rollbar_filtered_param_value(value)
-          end
+          result[key] = if (fields_regex === encoded_key) && !(whitelist_regex === encoded_key)
+                          scrub_value(value)
+                        elsif value.is_a?(Hash)
+                          scrub(value, options)
+                        elsif scrub_all && !(whitelist_regex === encoded_key)
+                          scrub_value(value)
+                        elsif value.is_a?(Array)
+                          scrub_array(value, options)
+                        elsif skip_value?(value)
+                          "Skipped value of class '#{value.class.name}'"
+                        else
+                          rollbar_filtered_param_value(value)
+                        end
 
           result
         end
@@ -102,7 +103,7 @@ module Rollbar
         if ATTACHMENT_CLASSES.include?(value.class.name)
           begin
             attachment_value(value)
-          rescue
+          rescue StandardError
             'Uploaded file'
           end
         else