rollbar 2.16.2 → 2.22.1

data/lib/rollbar/capistrano3.rb

@@ -1 +1,56 @@
-load File.expand_path('../tasks/rollbar.cap', __FILE__)
+# This is a tasks file to use with Capistrano 3
+
+require 'net/http'
+require 'rubygems'
+require 'json'
+require 'rollbar/deploy'
+require 'rollbar/capistrano_tasks'
+
+namespace :rollbar do
+  # dry_run? wasn't introduced till Capistrano 3.5.0; use the old fetch(:sshkit_backed)
+  set :dry_run, (proc { ::Capistrano::Configuration.env.fetch(:sshkit_backend) == ::SSHKit::Backend::Printer })
+
+  desc 'Send deployment started notification to Rollbar.'
+  task :deploy_started do
+    on primary fetch(:rollbar_role) do
+      ::Rollbar::CapistranoTasks.deploy_started(self, self, fetch(:dry_run))
+    end
+  end
+
+  desc 'Send deployment succeeded notification to Rollbar.'
+  task :deploy_succeeded do
+    on primary fetch(:rollbar_role) do
+      ::Rollbar::CapistranoTasks.deploy_succeeded(self, self, fetch(:dry_run))
+    end
+  end
+
+  desc 'Send deployment failed notification to Rollbar.'
+  task :deploy_failed do
+    on primary fetch(:rollbar_role) do
+      ::Rollbar::CapistranoTasks.deploy_failed(self, self, fetch(:dry_run))
+    end
+  end
+
+  task :fail do
+    raise StandardError
+  end
+end
+
+namespace :deploy do
+  after 'deploy:set_current_revision', 'rollbar:deploy_started'
+  after 'deploy:finished', 'rollbar:deploy_succeeded'
+  after 'deploy:failed', 'rollbar:deploy_failed'
+
+  # Used for testing :deploy_failed task
+  # after 'rollbar:deploy_started', 'rollbar:fail'
+end
+
+namespace :load do
+  task :defaults do
+    set :rollbar_user,      (proc { fetch :local_user, ENV['USER'] || ENV['USERNAME'] })
+    set :rollbar_env,       (proc { fetch :rails_env, 'production' })
+    set :rollbar_token,     (proc { abort "Please specify the Rollbar access token, set :rollbar_token, 'your token'" })
+    set :rollbar_role,      (proc { :app })
+    set :rollbar_revision,  (proc { fetch :current_revision })
+  end
+end

data/lib/rollbar/capistrano_tasks.rb

@@ -0,0 +1,130 @@
+require 'rollbar/deploy'
+
+module Rollbar
+  # Module containing the logic of Capistrano tasks for deploy tracking
+  module CapistranoTasks
+    class << self
+      def deploy_started(capistrano, logger, dry_run)
+        deploy_task(logger, :desc => 'Notifying Rollbar of deployment start') do
+          result = report_deploy_started(capistrano, dry_run)
+
+          debug_request_response(logger, result)
+
+          capistrano.set(:rollbar_deploy_id, 123) if dry_run
+
+          skip_in_dry_run(logger, dry_run) do
+            if result[:success] && (deploy_id = result[:data] && result[:data][:deploy_id])
+              capistrano.set :rollbar_deploy_id, deploy_id
+            else
+              logger.error 'Unable to report deploy to Rollbar' + (result[:message] ? ': ' + result[:message] : '')
+            end
+          end
+        end
+      end
+
+      def deploy_succeeded(capistrano, logger, dry_run)
+        deploy_update(capistrano, logger, dry_run, :desc => 'Setting deployment status to `succeeded` in Rollbar') do
+          report_deploy_succeeded(capistrano, dry_run)
+        end
+      end
+
+      def deploy_failed(capistrano, logger, dry_run)
+        deploy_update(capistrano, logger, dry_run, :desc => 'Setting deployment status to `failed` in Rollbar') do
+          report_deploy_failed(capistrano, dry_run)
+        end
+      end
+
+      private
+
+      def deploy_task(logger, opts = {})
+        capistrano_300_warning(logger)
+        logger.info opts[:desc] if opts[:desc]
+        yield
+      end
+
+      def deploy_update(capistrano, logger, dry_run, opts = {})
+        deploy_task(logger, opts) do
+          depend_on_deploy_id(capistrano, logger) do
+            result = yield
+
+            debug_request_response(logger, result)
+
+            skip_in_dry_run(logger, dry_run) do
+              if result[:success]
+                logger.info 'Updated deploy status in Rollbar'
+              else
+                logger.error 'Unable to update deploy status in Rollbar' + (result[:message] ? ': ' + result[:message] : '')
+              end
+            end
+          end
+        end
+      end
+
+      def capistrano_300_warning(logger)
+        logger.warn("You need to upgrade capistrano to '>= 3.1' version in order to correctly report deploys to Rollbar. (On 3.0, the reported revision will be incorrect.)") if ::Capistrano::VERSION =~ /^3\.0/
+      end
+
+      def report_deploy_started(capistrano, dry_run)
+        ::Rollbar::Deploy.report(
+          {
+            :rollbar_username => capistrano.fetch(:rollbar_user),
+            :local_username => capistrano.fetch(:rollbar_user),
+            :comment => capistrano.fetch(:rollbar_comment),
+            :status => :started,
+            :proxy => :ENV,
+            :dry_run => dry_run
+          },
+          capistrano.fetch(:rollbar_token),
+          capistrano.fetch(:rollbar_env),
+          capistrano.fetch(:rollbar_revision)
+        )
+      end
+
+      def report_deploy_succeeded(capistrano, dry_run)
+        ::Rollbar::Deploy.update(
+          {
+            :proxy => :ENV,
+            :dry_run => dry_run
+          },
+          capistrano.fetch(:rollbar_token),
+          capistrano.fetch(:rollbar_deploy_id),
+          :succeeded
+        )
+      end
+
+      def report_deploy_failed(capistrano, dry_run)
+        ::Rollbar::Deploy.update(
+          {
+            :proxy => :ENV,
+            :dry_run => dry_run
+          },
+          capistrano.fetch(:rollbar_token),
+          capistrano.fetch(:rollbar_deploy_id),
+          :failed
+        )
+      end
+
+      def depend_on_deploy_id(capistrano, logger)
+        if capistrano.fetch(:rollbar_deploy_id)
+          yield
+        else
+          logger.error 'Failed to update the deploy in Rollbar. No deploy id available.'
+        end
+      end
+
+      def skip_in_dry_run(logger, dry_run)
+        if dry_run
+          logger.info 'Skipping sending HTTP requests to Rollbar in dry run.'
+        else
+          yield
+        end
+      end
+
+      def debug_request_response(logger, result)
+        # NOTE: in Capistrano debug messages go to log/capistrano.log but not to stdout even if log_level == :debug
+        logger.debug result[:request_info]
+        logger.debug result[:response_info] if result[:response_info]
+      end
+    end
+  end
+end

data/lib/rollbar/configuration.rb

@@ -8,10 +8,12 @@ module Rollbar
     attr_accessor :async_handler
     attr_accessor :branch
     attr_reader :before_process
+    attr_accessor :capture_uncaught
     attr_accessor :code_version
     attr_accessor :custom_data_method
     attr_accessor :delayed_job_enabled
     attr_accessor :default_logger
+    attr_reader :logger_level
     attr_accessor :disable_monkey_patch
     attr_accessor :disable_rack_monkey_patch
     attr_accessor :disable_core_monkey_patch
@@ -25,6 +27,7 @@ module Rollbar
     attr_accessor :framework
     attr_accessor :ignored_person_ids
     attr_accessor :host
+    attr_accessor :locals
     attr_writer :logger
     attr_accessor :payload_options
     attr_accessor :person_method
@@ -43,6 +46,7 @@ module Rollbar
     attr_accessor :scrub_fields
     attr_accessor :scrub_user
     attr_accessor :scrub_password
+    attr_accessor :scrub_whitelist
     attr_accessor :collect_user_ip
     attr_accessor :anonymize_user_ip
     attr_accessor :user_ip_obfuscator_secret
@@ -59,20 +63,26 @@ module Rollbar
     attr_reader :send_extra_frame_data
     attr_accessor :use_exception_level_filters_default
     attr_accessor :proxy
+    attr_accessor :raise_on_error
+    attr_accessor :transmit
+    attr_accessor :log_payload
 
     attr_reader :project_gem_paths
+    attr_accessor :configured_options
 
-    alias_method :safely?, :safely
+    alias safely? safely
 
-    DEFAULT_ENDPOINT = 'https://api.rollbar.com/api/1/item/'
-    DEFAULT_WEB_BASE = 'https://rollbar.com'
+    DEFAULT_ENDPOINT = 'https://api.rollbar.com/api/1/item/'.freeze
+    DEFAULT_WEB_BASE = 'https://rollbar.com'.freeze
 
     def initialize
       @async_handler = nil
       @before_process = []
+      @capture_uncaught = nil
       @code_version = nil
       @custom_data_method = nil
       @default_logger = lambda { ::Logger.new(STDERR) }
+      @logger_level = :info
       @delayed_job_enabled = true
       @disable_monkey_patch = false
       @disable_core_monkey_patch = false
@@ -102,12 +112,14 @@ module Rollbar
       @net_retries = 3
       @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
+      @scrub_whitelist = []
       @uncaught_exception_level = 'error'
       @scrub_headers = ['Authorization']
       @sidekiq_threshold = 0
@@ -122,8 +134,17 @@ module Rollbar
       @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
+      @hooks = {
+        :on_error_response => nil, # params: response
+        :on_report_internal_error => nil # params: exception
+      }
+
+      @configured_options = ConfiguredOptions.new(self)
     end
 
     def initialize_copy(orig)
@@ -131,9 +152,18 @@ 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
@@ -153,6 +183,15 @@ module Rollbar
       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'
 
@@ -177,8 +216,11 @@ module Rollbar
       @async_handler  = Rollbar::Delay::Resque
     end
 
-    def use_shoryuken
+    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
@@ -202,7 +244,7 @@ module Rollbar
       @async_handler  = Rollbar::Delay::SuckerPunch
     end
 
-    def use_sucker_punch=(value)
+    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)
 
@@ -245,8 +287,54 @@ module Rollbar
       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)
+      if @hooks.key?(symbol)
+        if block_given?
+          @hooks[symbol] = block
+        else
+          @hooks[symbol]
+        end
+      else
+        raise StandardError, 'Hook :' + symbol.to_s + ' is not supported by Rollbar SDK.'
+      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
+      configured[method_string.chomp('=').to_sym] = args.first if method_string.end_with?('=')
+
+      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/girl_friday.rb

@@ -11,10 +11,10 @@ module Rollbar
         end
 
         def queue
-          @queue ||= self.queue_class.new(nil, :size => 5) do |payload|
+          @queue ||= queue_class.new(nil, :size => 5) do |payload|
             begin
               Rollbar.process_from_async_handler(payload)
-            rescue
+            rescue StandardError
               # According to https://github.com/mperham/girl_friday/wiki#error-handling
               # we reraise the exception so it can be handled some way
               raise

data/lib/rollbar/delay/resque.rb

@@ -23,12 +23,10 @@ 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)
+        rescue StandardError
+          # Raise the exception so Resque can track the errored job
+          raise
         end
       end
     end

data/lib/rollbar/delay/shoryuken.rb

@@ -8,22 +8,28 @@ module Rollbar
     class Shoryuken
       include ::Shoryuken::Worker
 
-      def self.queue_name
-        "rollbar_#{Rollbar.configuration.environment}"
+      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 :queue => queue_name, :auto_delete => true, :body_parser => :json, :retry_intervals => [60, 180, 360, 120_0, 360_0, 186_00]
+      shoryuken_options :auto_delete => true,
+                        :body_parser => :json,
+                        :retry_intervals => [60, 180, 360, 120_0, 360_0, 186_00]
 
-      ## responsible for performing job. - payload is a json parsed body of the message.
       def perform(_sqs_message, payload)
         Rollbar.process_from_async_handler(payload)
       end
-
-      ## to push the job !
-      def call(payload)
-        self.class.perform_async(payload)
-      end
     end
   end
 end