rollbar 2.7.1 → 2.8.0

data/lib/rollbar.rb

@@ -11,6 +11,7 @@ end
 
 require 'rollbar/version'
 require 'rollbar/json'
+require 'rollbar/js'
 require 'rollbar/configuration'
 require 'rollbar/encoding'
 require 'rollbar/logger_proxy'
@@ -20,6 +21,8 @@ require 'rollbar/railtie' if defined?(Rails::VERSION)
 require 'rollbar/delay/girl_friday' if defined?(GirlFriday)
 require 'rollbar/delay/thread'
 require 'rollbar/truncation'
+require 'rollbar/exceptions'
+require 'rollbar/lazy_store'
 
 module Rollbar
   ATTACHMENT_CLASSES = %w[
@@ -33,18 +36,20 @@ module Rollbar
   class Notifier
     attr_accessor :configuration
     attr_accessor :last_report
+    attr_reader :scope_object
 
     @file_semaphore = Mutex.new
 
-    def initialize(parent_notifier = nil, payload_options = nil)
+    def initialize(parent_notifier = nil, payload_options = nil, scope = nil)
       if parent_notifier
         @configuration = parent_notifier.configuration.clone
+        @scope_object = parent_notifier.scope_object.clone
 
-        if payload_options
-          Rollbar::Util.deep_merge(@configuration.payload_options, payload_options)
-        end
+        Rollbar::Util.deep_merge(@configuration.payload_options, payload_options) if payload_options
+        Rollbar::Util.deep_merge(@scope_object, scope) if scope
       else
         @configuration = ::Rollbar::Configuration.new
+        @scope_object = ::Rollbar::LazyStore.new(scope)
       end
     end
 
@@ -62,11 +67,12 @@ module Rollbar
     end
 
     def scope(options = {})
-      self.class.new(self, options)
+      self.class.new(self, nil, options)
     end
 
     def scope!(options = {})
-      Rollbar::Util.deep_merge(@configuration.payload_options, options)
+      Rollbar::Util.deep_merge(scope_object, options)
+
       self
     end
 
@@ -117,33 +123,28 @@ module Rollbar
     def log(level, *args)
       return 'disabled' unless configuration.enabled
 
-      message = nil
-      exception = nil
-      extra = nil
-
-      args.each do |arg|
-        if arg.is_a?(String)
-          message = arg
-        elsif arg.is_a?(Exception)
-          exception = arg
-        elsif arg.is_a?(Hash)
-          extra = arg
-        end
-      end
-
+      message, exception, extra = extract_arguments(args)
       use_exception_level_filters = extra && extra.delete(:use_exception_level_filters) == true
 
       return 'ignored' if ignored?(exception, use_exception_level_filters)
 
-      if use_exception_level_filters
-        exception_level = filtered_level(exception)
-        level = exception_level if exception_level
+      begin
+        call_before_process(:level => level,
+                            :exception => exception,
+                            :message => message,
+                            :extra => extra)
+      rescue Rollbar::Ignore
+        return 'ignored'
       end
 
+      level = lookup_exception_level(level, exception,
+                                     use_exception_level_filters)
+
       begin
         report(level, message, exception, extra)
       rescue Exception => e
         report_internal_error(e)
+
         'error'
       end
     end
@@ -241,6 +242,56 @@ module Rollbar
 
     private
 
+    def call_before_process(options)
+      options = {
+        :level => options[:level],
+        :scope => scope_object,
+        :exception => options[:exception],
+        :message => options[:message],
+        :extra => options[:extra]
+      }
+      handlers = configuration.before_process
+
+      handlers.each do |handler|
+        begin
+          handler.call(options)
+        rescue Rollbar::Ignore
+          raise
+        rescue => e
+          log_error("[Rollbar] Error calling the `before_process` hook: #{e}")
+
+          break
+        end
+      end
+    end
+
+    def extract_arguments(args)
+      message = nil
+      exception = nil
+      extra = nil
+
+      args.each do |arg|
+        if arg.is_a?(String)
+          message = arg
+        elsif arg.is_a?(Exception)
+          exception = arg
+        elsif arg.is_a?(Hash)
+          extra = arg
+        end
+      end
+
+      [message, exception, extra]
+    end
+
+    def lookup_exception_level(orig_level, exception, use_exception_level_filters)
+      return orig_level unless use_exception_level_filters
+
+      exception_level = filtered_level(exception)
+      return exception_level if exception_level
+
+      orig_level
+    end
+
     def ignored?(exception, use_exception_level_filters = false)
       return false unless exception
       return true if use_exception_level_filters && filtered_level(exception) == 'ignore'
@@ -336,10 +387,7 @@ module Rollbar
       data[:uuid] = SecureRandom.uuid if defined?(SecureRandom) && SecureRandom.respond_to?(:uuid)
 
       Rollbar::Util.deep_merge(data, configuration.payload_options)
-
-      data[:person] = data[:person].call if data[:person].respond_to?(:call)
-      data[:request] = data[:request].call if data[:request].respond_to?(:call)
-      data[:context] = data[:context].call if data[:context].respond_to?(:call)
+      Rollbar::Util.deep_merge(data, scope_object)
 
       # Our API doesn't allow null context values, so just delete
       # the key if value is nil.
@@ -352,9 +400,37 @@ module Rollbar
 
       enforce_valid_utf8(payload)
 
+      call_transform(:level => level,
+                     :exception => exception,
+                     :message => message,
+                     :extra => extra,
+                     :payload => payload)
+
       payload
     end
 
+    def call_transform(options)
+      options = {
+        :level => options[:level],
+        :scope => scope_object,
+        :exception => options[:exception],
+        :message => options[:message],
+        :extra => options[:extra],
+        :payload => options[:payload]
+      }
+      handlers = configuration.transform
+
+      handlers.each do |handler|
+        begin
+          handler.call(options)
+        rescue => e
+          log_error("[Rollbar] Error calling the `transform` hook: #{e}")
+
+          break
+        end
+      end
+    end
+
     def build_payload_body(message, exception, extra)
       extra = Rollbar::Util.deep_merge(custom_data, extra || {}) if custom_data_method?
 
@@ -372,7 +448,7 @@ module Rollbar
     def report_custom_data_error(e)
       data = safely.error(e)
 
-      return {} unless data[:uuid]
+      return {} unless data.is_a?(Hash) && data[:uuid]
 
       uuid_url = uuid_rollbar_url(data)
 
@@ -744,6 +820,8 @@ module Rollbar
     # to configure it without initializing any of the third party hooks
     def preconfigure
       yield(configuration)
+
+      reset_notifier!
     end
 
     def configure
@@ -752,9 +830,7 @@ module Rollbar
 
       yield(configuration)
 
-      require_hooks
-      require_core_extensions
-
+      prepare
       reset_notifier!
     end
 
@@ -774,10 +850,24 @@ module Rollbar
       @configuration ||= Configuration.new
     end
 
+    def scope_object
+      @scope_obejct ||= ::Rollbar::LazyStore.new({})
+    end
+
     def safely?
       configuration.safely?
     end
 
+    def prepare
+      prepare_js
+      require_hooks
+      require_core_extensions
+    end
+
+    def prepare_js
+      ::Rollbar::Js.prepare if configuration.js_enabled
+    end
+
     def require_hooks
       return if configuration.disable_monkey_patch
       wrap_delayed_worker
@@ -786,7 +876,7 @@ module Rollbar
       require 'rollbar/sidekiq' if defined?(Sidekiq)
       require 'rollbar/active_job' if defined?(ActiveJob)
       require 'rollbar/goalie' if defined?(Goalie)
-      require 'rollbar/rack' if defined?(Rack)
+      require 'rollbar/rack' if defined?(Rack) unless configuration.disable_rack_monkey_patch
       require 'rollbar/rake' if defined?(Rake)
     end
 

data/lib/rollbar/configuration.rb

@@ -6,11 +6,13 @@ module Rollbar
     attr_accessor :access_token
     attr_accessor :async_handler
     attr_accessor :branch
+    attr_accessor :before_process
     attr_accessor :code_version
     attr_accessor :custom_data_method
     attr_accessor :delayed_job_enabled
     attr_accessor :default_logger
     attr_accessor :disable_monkey_patch
+    attr_accessor :disable_rack_monkey_patch
     attr_accessor :disable_core_monkey_patch
     attr_accessor :dj_threshold
     attr_accessor :enabled
@@ -31,6 +33,8 @@ module Rollbar
     attr_accessor :report_dj_data
     attr_accessor :request_timeout
     attr_accessor :root
+    attr_accessor :js_options
+    attr_accessor :js_enabled
     attr_accessor :safely
     attr_accessor :scrub_fields
     attr_accessor :scrub_user
@@ -40,6 +44,7 @@ module Rollbar
     attr_accessor :uncaught_exception_level
     attr_accessor :scrub_headers
     attr_accessor :sidekiq_threshold
+    attr_accessor :transform
     attr_accessor :verify_ssl_peer
     attr_accessor :use_async
     attr_accessor :use_eventmachine
@@ -55,12 +60,14 @@ module Rollbar
 
     def initialize
       @async_handler = nil
+      @before_process = []
       @code_version = nil
       @custom_data_method = nil
       @default_logger = lambda { Logger.new(STDERR) }
       @delayed_job_enabled = true
       @disable_monkey_patch = false
       @disable_core_monkey_patch = false
+      @disable_rack_monkey_patch = false
       @dj_threshold = 0
       @enabled = nil  # set to true when configure is called
       @endpoint = DEFAULT_ENDPOINT
@@ -82,6 +89,8 @@ module Rollbar
       @populate_empty_backtraces = false
       @report_dj_data = true
       @request_timeout = 3
+      @js_enabled = false
+      @js_options = {}
       @scrub_fields = [:passwd, :password, :password_confirmation, :secret,
                        :confirm_password, :password_confirmation, :secret_token,
                        :api_key, :access_token ]
@@ -92,6 +101,7 @@ module Rollbar
       @scrub_headers = ['Authorization']
       @sidekiq_threshold = 0
       @safely = false
+      @transform = []
       @use_async = false
       @use_eventmachine = false
       @verify_ssl_peer = true
@@ -164,6 +174,14 @@ module Rollbar
       end.flatten.uniq.map(&:gem_dir)
     end
 
+    def before_process=(*handler)
+      @before_process = Array(handler)
+    end
+
+    def transform=(*handler)
+      @transform = Array(handler)
+    end
+
     # allow params to be read like a hash
     def [](option)
       send(option)

data/lib/rollbar/exceptions.rb

@@ -0,0 +1,3 @@
+module Rollbar
+  class Ignore < StandardError; end
+end

data/lib/rollbar/js.rb

@@ -0,0 +1,32 @@
+require "rollbar/js/version"
+
+module Rollbar
+  module Js
+    extend self
+
+    attr_reader :framework
+    attr_reader :framework_loader
+
+    def prepare
+      @framework ||= detect_framework
+      @framework_loader ||= load_framework_class.new
+
+      @framework_loader.prepare
+    end
+
+    private
+
+    def detect_framework
+      case
+      when defined?(::Rails::VERSION)
+        :rails
+      end
+    end
+
+    def load_framework_class
+      require "rollbar/js/frameworks/#{framework}"
+
+      Rollbar::Js::Frameworks.const_get(framework.to_s.capitalize)
+    end
+  end
+end

data/lib/rollbar/js/frameworks.rb

@@ -0,0 +1,6 @@
+module Rollbar
+  module Js
+    module Frameworks
+    end
+  end
+end

data/lib/rollbar/js/frameworks/rails.rb

@@ -0,0 +1,29 @@
+module Rollbar
+  module Js
+    module Frameworks
+      class Rails
+        attr_accessor :prepared
+
+        alias prepared? prepared
+
+        def prepare
+          return if prepared?
+
+          require 'rollbar/js/middleware'
+
+          config = {
+            :options => Rollbar.configuration.js_options,
+            :enabled => Rollbar.configuration.js_enabled
+          }
+          rails_config.middleware.use(::Rollbar::Js::Middleware, config)
+
+          self.prepared = true
+        end
+
+        def rails_config
+          ::Rails.configuration
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/js/middleware.rb

@@ -0,0 +1,129 @@
+require 'rack'
+require 'rack/response'
+
+
+module Rollbar
+  module Js
+    class Middleware
+      attr_reader :app
+      attr_reader :config
+
+      JS_IS_INJECTED_KEY = 'rollbar.js_is_injected'
+      SNIPPET = File.read(File.expand_path('../../../../data/rollbar.snippet.js', __FILE__))
+
+      def initialize(app, config)
+        @app = app
+        @config = config
+      end
+
+      def call(env)
+        result = app.call(env)
+
+        _call(env, result)
+      end
+
+      private
+
+      def _call(env, result)
+        return result unless should_add_js?(env, result[0], result[1])
+
+        if response_string = add_js(result[2])
+          env[JS_IS_INJECTED_KEY] = true
+          response = ::Rack::Response.new(response_string, result[0], result[1])
+
+          response.finish
+        else
+          result
+        end
+      rescue => e
+        Rollbar.log_error("[Rollbar] Rollbar.js could not be added because #{e} exception")
+        result
+      end
+
+      def enabled?
+        !!config[:enabled]
+      end
+
+      def should_add_js?(env, status, headers)
+        enabled? &&
+          status == 200 &&
+          !env[JS_IS_INJECTED_KEY] &&
+          html?(headers) &&
+          !attachment?(headers) &&
+          !streaming?(env)
+      end
+
+      def html?(headers)
+        headers['Content-Type'] && headers['Content-Type'].include?('text/html')
+      end
+
+      def attachment?(headers)
+        headers['Content-Disposition'].to_s.include?('attachment')
+      end
+
+      def streaming?(env)
+        return false unless defined?(ActionController::Live)
+
+        env['action_controller.instance'].class.included_modules.include?(ActionController::Live)
+      end
+
+      def add_js(response)
+        body = join_body(response)
+        close_old_response(response)
+
+        return nil unless body
+
+        head_open_end = find_end_of_head_open(body)
+        return nil unless head_open_end
+
+        if head_open_end
+          body = body[0..head_open_end] <<
+                 config_js_tag <<
+                 snippet_js_tag <<
+                 body[head_open_end..-1]
+        end
+
+        body
+      rescue => e
+        Rollbar.log_error("[Rollbar] Rollbar.js could not be added because #{e} exception")
+        nil
+      end
+
+      def find_end_of_head_open(body)
+        head_open = body.index('<head')
+        body.index('>', head_open) + 1 if head_open
+      end
+
+      def join_body(response)
+        source = nil
+        response.each { |fragment| source ? (source << fragment.to_s) : (source = fragment.to_s)}
+        source
+      end
+
+      def close_old_response(response)
+        response.close if response.respond_to?(:close)
+      end
+
+      def config_js_tag
+        script_tag("var _rollbarConfig = #{config[:options].to_json};")
+      end
+
+      def snippet_js_tag
+        script_tag(js_snippet)
+      end
+
+      def js_snippet
+        SNIPPET
+      end
+
+      def script_tag(content)
+        html_safe_if_needed("\n<script type=\"text/javascript\">#{content}</script>")
+      end
+
+      def html_safe_if_needed(string)
+        string = string.html_safe if string.respond_to?(:html_safe)
+        string
+      end
+    end
+  end
+end