rollbar 2.8.3 → 3.6.0

data/lib/rollbar/plugin.rb

@@ -0,0 +1,126 @@
+module Rollbar
+  # Represents a plugin in the gem. Every plugin can have multiple dependencies
+  # and multiple execution blocks.
+  # On Rollbar initialization, all plugins will be saved in memory and those that
+  # satisfy the dependencies will be loaded
+  class Plugin
+    attr_reader :name, :dependencies, :callables, :revert_callables
+    attr_accessor :on_demand, :loaded
+
+    private :loaded=
+
+    def initialize(name)
+      @name = name
+      @dependencies = []
+      @callables = []
+      @revert_callables = []
+      @loaded = false
+      @on_demand = false
+    end
+
+    def load_on_demand
+      @on_demand = true
+    end
+
+    def configuration
+      Rollbar.configuration
+    end
+
+    def load_scoped!(transparent = false)
+      if transparent
+        load! if load?
+
+        result = yield
+
+        unload! if loaded
+      else
+        return unless load?
+
+        load!
+
+        result = yield
+
+        unload!
+      end
+
+      result
+    end
+
+    def load!
+      return unless load?
+
+      begin
+        callables.each(&:call)
+      rescue StandardError => e
+        log_loading_error(e)
+      ensure
+        self.loaded = true
+      end
+    end
+
+    def unload!
+      return unless loaded
+
+      begin
+        revert_callables.each(&:call)
+      rescue StandardError => e
+        log_unloading_error(e)
+      ensure
+        self.loaded = false
+      end
+    end
+
+    def execute(&block)
+      callables << block
+    end
+
+    def execute!
+      yield if load?
+    end
+
+    def revert(&block)
+      revert_callables << block
+    end
+
+    private
+
+    def dependency(&block)
+      dependencies << block
+    end
+
+    def require_dependency(file)
+      dependency do
+        begin
+          require file
+          true
+        rescue LoadError
+          false
+        end
+      end
+    end
+
+    def load?
+      !loaded && dependencies_satisfy?
+    rescue StandardError => e
+      log_loading_error(e)
+
+      false
+    end
+
+    def dependencies_satisfy?
+      dependencies.all?(&:call)
+    end
+
+    def log_loading_error(error)
+      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}"
+      )
+    end
+  end
+end

data/lib/rollbar/plugins/active_job.rb

@@ -0,0 +1,54 @@
+module Rollbar
+  # Report any uncaught errors in a job to Rollbar and reraise
+  module ActiveJob
+    def self.included(base)
+      base.send :rescue_from, Exception do |exception|
+        job_data = {
+          :job => self.class.name,
+          :use_exception_level_filters => true
+        }
+
+        # When included in ActionMailer, the handler is called twice.
+        # This detects the execution that has the expected state.
+        if defined?(ActionMailer::Base) && self.class.ancestors.include?(ActionMailer::Base)
+          job_data[:action] = action_name
+          job_data[:params] = @params
+
+          Rollbar.error(exception, job_data)
+
+        # This detects other supported integrations.
+        elsif defined?(arguments)
+          job_data[:arguments] = \
+            if self.class.respond_to?(:log_arguments?) && !self.class.log_arguments?
+              arguments.map(&Rollbar::Scrubbers.method(:scrub_value))
+            else
+              arguments
+            end
+          job_data[:job_id] = job_id if defined?(job_id)
+
+          Rollbar.error(exception, job_data)
+        end
+
+        raise exception
+      end
+    end
+  end
+end
+
+Rollbar.plugins.define('active_job') do
+  dependency { !configuration.disable_monkey_patch }
+  dependency { !configuration.disable_action_mailer_monkey_patch }
+
+  execute do
+    if defined?(ActiveSupport) && ActiveSupport.respond_to?(:on_load)
+      ActiveSupport.on_load(:action_mailer) do
+        if defined?(ActionMailer::MailDeliveryJob) # Rails >= 6.0
+          ActionMailer::Base.send(:include, Rollbar::ActiveJob)
+        elsif defined?(ActionMailer::DeliveryJob) # Rails < 6.0
+          ActionMailer::DeliveryJob.send(:include,
+                                         Rollbar::ActiveJob)
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/plugins/basic_socket.rb

@@ -0,0 +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 do
+    defined?(ActiveSupport::VERSION::STRING) &&
+      Gem::Version.new(ActiveSupport::VERSION::STRING) < Gem::Version.new('4.1.0')
+  end
+
+  execute do
+    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

@@ -0,0 +1,50 @@
+module Rollbar
+  module Delayed
+    class JobData
+      attr_reader :job
+
+      def initialize(job)
+        @job = job
+      end
+
+      def to_hash
+        job_data = extract_job_data
+
+        handler_parent = job_data['job'] || job_data
+        handler_parent['handler'] = handler_data
+
+        job_data
+      end
+
+      private
+
+      def extract_job_data
+        if job.respond_to?(:as_json)
+          job.as_json
+        else
+          Hash[job.to_hash.map { |k, v| [k.to_s, v] }]
+        end
+      end
+
+      def handler_data
+        payload_object = job.payload_object
+
+        return payload_object unless payload_object.respond_to?(:object)
+
+        object_data(payload_object.object)
+      rescue StandardError
+        {}
+      end
+
+      def object_data(object)
+        {
+          :method_name => job.payload_object.method_name,
+          :args => job.payload_object.args,
+          :object => object.is_a?(Class) ? object.name : object.to_s
+        }
+      rescue StandardError
+        {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require 'delayed_job'
+require 'rollbar/plugins/delayed_job/job_data'
+
+module Rollbar
+  module Delayed
+    class << self
+      attr_accessor :wrapped
+    end
+
+    class RollbarPlugin < ::Delayed::Plugin
+      callbacks do |lifecycle|
+        lifecycle.around(:invoke_job, &Delayed.invoke_job_callback)
+        lifecycle.after(:failure) do |_, job, _, _|
+          data = Rollbar::Delayed.build_job_data(job)
+
+          # 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
+
+    self.wrapped = false
+
+    def self.wrap_worker
+      return if wrapped
+
+      ::Delayed::Worker.plugins << RollbarPlugin
+
+      self.wrapped = true
+    end
+
+    def self.wrap_worker!
+      self.wrapped = false
+
+      wrap_worker
+    end
+
+    def self.invoke_job_callback
+      proc do |job, *args, &block|
+        begin
+          if Rollbar.configuration.dj_use_scoped_block
+            data = Rollbar::Delayed.build_job_data(job)
+            Rollbar.scoped(:request => data) { block.call(job, *args) }
+          else
+            block.call(job, *args)
+          end
+        rescue StandardError => e
+          report(e, job)
+
+          raise e
+        end
+      end
+    end
+
+    def self.report(e, job)
+      return if skip_report?(job)
+
+      data = build_job_data(job)
+
+      ::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
+
+    def self.build_job_data(job)
+      return nil unless ::Rollbar.configuration.report_dj_data
+
+      JobData.new(job).to_hash
+    end
+  end
+end

data/lib/rollbar/plugins/delayed_job.rb

@@ -0,0 +1,12 @@
+Rollbar.plugins.define('delayed_job') do
+  dependency { !configuration.disable_monkey_patch }
+  dependency do
+    defined?(Delayed) && defined?(Delayed::Worker) && configuration.delayed_job_enabled
+  end
+
+  execute do
+    require 'rollbar/plugins/delayed_job/plugin'
+
+    Rollbar::Delayed.wrap_worker
+  end
+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

@@ -0,0 +1,65 @@
+Rollbar.plugins.define('goalie') do
+  dependency { !configuration.disable_monkey_patch }
+  dependency { defined?(Goalie) }
+
+  execute do
+    module Rollbar
+      module Goalie
+        def render_exception_with_rollbar(env, exception)
+          exception_data = nil
+
+          begin
+            controller = env['action_controller.instance']
+            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 StandardError => 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
+          case exception_data
+          when Hash
+            env['rollbar.exception_uuid'] = exception_data[:uuid]
+            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
+          render_exception_without_rollbar(env, exception)
+        end
+      end
+    end
+  end
+
+  execute do
+    Goalie::CustomErrorPages.class_eval do
+      include Rollbar::Goalie
+
+      alias_method :render_exception_without_rollbar, :render_exception
+      alias_method :render_exception, :render_exception_with_rollbar
+    end
+  end
+end

data/lib/rollbar/plugins/rack.rb

@@ -0,0 +1,18 @@
+Rollbar.plugins.define('rack') do
+  dependency { !configuration.disable_monkey_patch }
+  dependency { !configuration.disable_rack_monkey_patch }
+
+  execute do
+    if defined?(Rack::Builder)
+      require 'rollbar/middleware/rack'
+      require 'rollbar/middleware/rack/builder'
+      Rack::Builder.send(:include, Rollbar::Middleware::Rack::Builder)
+    end
+
+    if defined?(Rack::Test::Session)
+      require 'rollbar/middleware/rack'
+      require 'rollbar/middleware/rack/test_session'
+      Rack::Test::Session.send(:include, Rollbar::Middleware::Rack::TestSession)
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'rollbar/request_data_extractor'
+require 'rollbar/util'
+
+module Rollbar
+  module Rails
+    module ControllerMethods
+      include RequestDataExtractor
+
+      def rollbar_person_data
+        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),
+            :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
+          {}
+        end
+      rescue NameError
+        {}
+      end
+
+      def rollbar_request_data
+        extract_request_data_from_rack(request.env)
+      end
+
+      # for backwards compatabilty with the old ratchetio-gem
+      def ratchetio_person_data
+        rollbar_person_data
+      end
+
+      # for backwards compatabilty with the old ratchetio-gem
+      def ratchetio_request_data
+        rollbar_request_data
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Rollbar
+  class ErrorSubscriber
+    def report(error, handled:, severity:, context:, source: nil)
+      # The default `nil` for capture_uncaught means `true`. so check for false.
+      return unless handled || Rollbar.configuration.capture_uncaught != false
+
+      extra = context.is_a?(Hash) ? context.deep_dup : {}
+      extra[:custom_data_method_context] = source
+      Rollbar.log(severity, error, extra)
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'rails/railtie'
+require 'rollbar/plugins/rails/railtie_mixin'
+
+module Rollbar
+  class Railtie < ::Rails::Railtie
+    include Rollbar::RailtieMixin
+
+    initializer 'rollbar.middleware.rails' do |app|
+      require 'rollbar/middleware/rails/rollbar'
+      require 'rollbar/middleware/rails/show_exceptions'
+
+      app.config.middleware.insert_after ActionDispatch::ShowExceptions,
+                                         Rollbar::Middleware::Rails::RollbarMiddleware
+      ActionDispatch::ShowExceptions.send(:include,
+                                          Rollbar::Middleware::Rails::ShowExceptions)
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'rails/railtie'
+require 'rollbar/plugins/rails/railtie_mixin'
+
+module Rollbar
+  class Railtie < ::Rails::Railtie
+    include Rollbar::RailtieMixin
+
+    initializer 'rollbar.middleware.rails' do |app|
+      require 'rollbar/middleware/rails/rollbar'
+      require 'rollbar/middleware/rails/show_exceptions'
+
+      app.config.middleware.insert_after ActionDispatch::DebugExceptions,
+                                         Rollbar::Middleware::Rails::RollbarMiddleware
+      ActionDispatch::DebugExceptions.send(:include,
+                                           Rollbar::Middleware::Rails::ShowExceptions)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Rollbar
+  module RailtieMixin
+    extend ActiveSupport::Concern
+
+    included do
+      rake_tasks do
+        require 'rollbar/rake_tasks'
+      end
+
+      initializer 'rollbar.configuration' do
+        config.after_initialize do
+          Rollbar.preconfigure do |config|
+            config.default_logger = proc { ::Rails.logger }
+            config.environment ||= ::Rails.env
+            config.root ||= ::Rails.root
+            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"
+              else
+                "#{::Rails.application.class.parent_name}.rollbar"
+              end
+            end
+          end
+        end
+      end
+
+      initializer 'rollbar.controller_methods' do
+        ActiveSupport.on_load(:action_controller) do
+          # lazily load action_controller methods
+          require 'rollbar/plugins/rails/controller_methods'
+          include Rollbar::Rails::ControllerMethods
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/plugins/rails.rb

@@ -0,0 +1,89 @@
+Rollbar.plugins.define('rails32-errors') do
+  dependency { defined?(Rails::VERSION) && Rails::VERSION::MAJOR >= 3 }
+  dependency { Gem::Version.new(Rails::VERSION::STRING) >= Gem::Version.new('3.2') }
+
+  execute! do
+    require 'rollbar/plugins/rails/railtie32'
+  end
+end
+
+Rollbar.plugins.define('rails30-errors') do
+  dependency { defined?(Rails::VERSION) && Rails::VERSION::MAJOR >= 3 }
+  dependency { Gem::Version.new(Rails::VERSION::STRING) < Gem::Version.new('3.2') }
+
+  execute! do
+    require 'rollbar/plugins/rails/railtie30'
+  end
+end
+
+Rollbar.plugins.define('rails-rollbar.js') do
+  dependency { defined?(Rails::VERSION) && Rails::VERSION::MAJOR >= 3 }
+
+  execute! do
+    module Rollbar
+      module Js
+        module Frameworks
+          # Adds Rollbar::Middleware::Js to the Rails middleware stack
+          # We need to delay the final insert to the last moment since
+          # this feature may be disable.
+          # But we need to prepare the middleware insert now because
+          # we need to use our Rails railtie initializer in case the
+          # customer is using SecureHeaders > 3.0
+          class Rails
+            def load(plugin)
+              plugin_execute = plugin_execute_proc_body(plugin)
+
+              return after_secure_headers(&plugin_execute) if secure_headers_middleware?
+
+              plugin_execute.call
+            end
+
+            def after_secure_headers(&block)
+              Rollbar::Railtie.initializer('rollbar.js.frameworks.rails',
+                                           :after => 'secure_headers.middleware', &block)
+            end
+
+            def plugin_execute_proc_body(plugin)
+              proc do
+                plugin.execute do
+                  if Rollbar.configuration.js_enabled
+                    require 'rollbar/middleware/js'
+
+                    config = {
+                      :options => Rollbar.configuration.js_options,
+                      :enabled => Rollbar.configuration.js_enabled
+                    }
+                    ::Rails.configuration.middleware.use(::Rollbar::Middleware::Js,
+                                                         config)
+                  end
+                end
+              end
+            end
+
+            def secure_headers_middleware?
+              begin
+                require 'secure_headers'
+              rescue LoadError
+                # Skip loading
+              end
+
+              defined?(::SecureHeaders::Middleware)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  execute! do
+    Rollbar::Js::Frameworks::Rails.new.load(self)
+  end
+end
+
+Rollbar.plugins.define('rails-error-subscriber') do
+  dependency { defined?(Rails::VERSION) && Rails::VERSION::MAJOR >= 7 }
+
+  execute! do
+    require 'rollbar/plugins/rails/error_subscriber'
+  end
+end