rollbar 1.1.0 → 1.2.0

data/lib/rollbar/active_record_extension.rb

@@ -5,7 +5,7 @@ module Rollbar
     def report_validation_errors_to_rollbar
       self.errors.full_messages.each do |error|
         Rollbar.log_info "[Rollbar] Reporting form validation error: #{error} for #{self.to_s}"
-        Rollbar.report_message("Form Validation Error: #{error} for #{self.to_s}")
+        Rollbar.warning("Form Validation Error: #{error} for #{self.to_s}")
       end
     end
   end

data/lib/rollbar/configuration.rb

@@ -20,6 +20,7 @@ module Rollbar
     attr_accessor :framework
     attr_accessor :ignored_person_ids
     attr_accessor :logger
+    attr_accessor :payload_options
     attr_accessor :person_method
     attr_accessor :person_id_method
     attr_accessor :person_username_method
@@ -28,6 +29,7 @@ module Rollbar
     attr_accessor :request_timeout
     attr_accessor :root
     attr_accessor :scrub_fields
+    attr_accessor :uncaught_exception_level
     attr_accessor :scrub_headers
     attr_accessor :use_async
     attr_accessor :use_eventmachine
@@ -57,6 +59,7 @@ module Rollbar
       @failover_handlers = []
       @framework = 'Plain'
       @ignored_person_ids = []
+      @payload_options = {}
       @person_method = 'current_user'
       @person_id_method = 'id'
       @person_username_method = 'username'
@@ -66,6 +69,7 @@ module Rollbar
       @request_timeout = 3
       @scrub_fields = [:passwd, :password, :password_confirmation, :secret,
                        :confirm_password, :password_confirmation, :secret_token]
+      @uncaught_exception_level = 'error'
       @scrub_headers = ['Authorization']
       @use_async = false
       @use_eventmachine = false
@@ -73,6 +77,15 @@ module Rollbar
       @write_to_file = false
     end
 
+    def initialize_copy(orig)
+      super
+
+      instance_variables.each do |var|
+        instance_var = instance_variable_get(var)
+        instance_variable_set(var, Rollbar::Util::deep_copy(instance_var))
+      end
+    end
+
     def use_sidekiq(options = {})
       require 'rollbar/delay/sidekiq' if defined?(Sidekiq)
       @use_async      = true
@@ -133,5 +146,9 @@ module Rollbar
     def [](option)
       send(option)
     end
+
+    def logger
+      @logger ||= default_logger.call
+    end
   end
 end

data/lib/rollbar/core_ext/thread.rb

@@ -0,0 +1,9 @@
+class Thread
+  def initialize_with_rollbar(*args, &block)
+    self[:_rollbar_notifier] ||= Rollbar.notifier.scope
+    initialize_without_rollbar(*args, &block)
+  end
+
+  alias_method :initialize_without_rollbar, :initialize
+  alias_method :initialize, :initialize_with_rollbar
+end

data/lib/rollbar/exception_reporter.rb

@@ -3,10 +3,9 @@ module Rollbar
     include RequestDataExtractor
 
     def report_exception_to_rollbar(env, exception)
-      Rollbar.log_error "Reporting exception: #{exception.message}"
-      request_data = extract_request_data_from_rack(env)
-      person_data = extract_person_data_from_controller(env)
-      exception_data = Rollbar.report_exception(exception, request_data, person_data)
+      Rollbar.log_debug "[Rollbar] Reporting exception: #{exception.try(:message)}"
+      
+      exception_data = Rollbar.log(Rollbar.configuration.uncaught_exception_level, exception)
       
       if exception_data.is_a?(Hash)
         env['rollbar.exception_uuid'] = exception_data[:uuid]
@@ -17,7 +16,7 @@ module Rollbar
         Rollbar.log_debug "[Rollbar] Exception not reported because it was ignored"
       end
     rescue => e
-      Rollbar.log_debug "[Rollbar] Exception while reporting exception to Rollbar: #{e.message}"
+      Rollbar.log_warning "[Rollbar] Exception while reporting exception to Rollbar: #{e.message}"
     end
   end
 end

data/lib/rollbar/logger_proxy.rb

@@ -0,0 +1,32 @@
+module Rollbar
+  class LoggerProxy
+    attr_reader :object
+
+    def initialize(object)
+      @object = object
+    end
+
+    def debug(message)
+      log('debug', message)
+    end
+
+    def info(message)
+      log('info', message)
+    end
+
+    def warn(message)
+      log('warn', message)
+    end
+
+    def error(message)
+      log('error', message)
+    end
+
+    def log(level, message)
+      @object.send(level, message)
+    rescue
+      puts "[Rollbar] Error logging #{level}:"
+      puts "[Rollbar] #{message}"
+    end
+  end
+end

data/lib/rollbar/middleware/rack/builder.rb

@@ -1,14 +1,32 @@
+require 'rollbar/exception_reporter'
+require 'rollbar/request_data_extractor'
+
 module Rollbar
   module Middleware
     module Rack
       module Builder
         include ExceptionReporter
+        include RequestDataExtractor
 
         def call_with_rollbar(env)
-          call_without_rollbar(env)
-        rescue Exception => exception
-          report_exception_to_rollbar(env, exception)
-          raise exception
+          Rollbar.reset_notifier!
+
+          Rollbar.scoped(fetch_scope(env)) do
+            begin
+              call_without_rollbar(env)
+            rescue ::Exception => exception
+              report_exception_to_rollbar(env, exception)
+              raise
+            end
+          end
+        end
+
+        def fetch_scope(env)
+          request_data = extract_request_data_from_rack(env)
+          { :request => request_data }
+        rescue Exception => e
+          report_exception_to_rollbar(env, e)
+          raise
         end
 
         def self.included(base)

data/lib/rollbar/middleware/rails/rollbar.rb

@@ -0,0 +1,62 @@
+module Rollbar
+  module Middleware
+    module Rails
+      class RollbarMiddleware
+        include RequestDataExtractor
+        include ExceptionReporter
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          Rollbar.reset_notifier!
+
+          Rollbar.scoped(fetch_scope(env)) do
+            begin
+              response = @app.call(env)
+
+              if (framework_exception = env['action_dispatch.exception'])
+                report_exception_to_rollbar(env, framework_exception)
+              end
+
+              response
+            rescue Exception => exception
+              report_exception_to_rollbar(env, exception)
+              raise
+            end
+          end
+        end
+
+        def fetch_scope(env)
+          request_data = extract_request_data_from_rack(env)
+
+          # Scope a new notifier with request data and a Proc for person data
+          # for any reports that happen while a controller is handling a request
+          {
+            :request => request_data,
+            :person => person_data_proc(env),
+            :context => context(request_data)
+          }
+        end
+
+        def person_data_proc(env)
+          block = proc { extract_person_data_from_controller(env) }
+          return block unless defined?(ActiveRecord::Base)
+
+          proc do
+            ActiveRecord::Base.connection_pool.with_connection(&block)
+          end
+        end
+
+        def context(request_data)
+          return unless request_data[:route]
+
+          route = request_data[:route]
+          # make sure route is a hash built by RequestDataExtractor
+          return "#{route[:controller]}" + '#' + "#{route[:action]}" if route.is_a?(Hash) && !route.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/middleware/rails/show_exceptions.rb

@@ -6,18 +6,16 @@ module Rollbar
 
         def render_exception_with_rollbar(env, exception)
           key = 'action_dispatch.show_detailed_exceptions'
-
-          # don't report production exceptions here as it is done below
-          # in call_with_rollbar() when show_detailed_exception is false
-          if not env.has_key?(key) or env[key]
+          if exception.is_a? ActionController::RoutingError and env[key]
             report_exception_to_rollbar(env, exception)
           end
+          
           render_exception_without_rollbar(env, exception)
         end
 
         def call_with_rollbar(env)
           call_without_rollbar(env)
-        rescue Exception => exception
+        rescue ActionController::RoutingError => exception
           # won't reach here if show_detailed_exceptions is true
           report_exception_to_rollbar(env, exception)
           raise exception

data/lib/rollbar/middleware/sinatra.rb

@@ -1,21 +1,37 @@
 require 'rollbar'
 require 'rollbar/exception_reporter'
+require 'rollbar/request_data_extractor'
 
 module Rollbar
   module Middleware
     class Sinatra
       include ::Rollbar::ExceptionReporter
+      include RequestDataExtractor
 
       def initialize(app)
         @app = app
       end
 
       def call(env)
-        response = @app.call(env)
-        report_exception_to_rollbar(env, framework_error(env)) if framework_error(env)
-        response
-      rescue ::Exception => exception
-        report_exception_to_rollbar(env, exception)
+        Rollbar.reset_notifier!
+
+        Rollbar.scoped(fetch_scope(env)) do
+          begin
+            response = @app.call(env)
+            report_exception_to_rollbar(env, framework_error(env)) if framework_error(env)
+            response
+          rescue Exception => e
+            report_exception_to_rollbar(env, e)
+            raise
+          end
+        end
+      end
+
+      def fetch_scope(env)
+        request_data = extract_request_data_from_rack(env)
+        { :request => request_data }
+      rescue Exception => e
+        report_exception_to_rollbar(env, e)
         raise
       end
 

data/lib/rollbar/railtie.rb

@@ -6,11 +6,24 @@ module Rollbar
     rake_tasks do
       require 'rollbar/rake_tasks'
     end
-
-    if defined? ActiveRecord
-      initializer 'rollbar.middleware.rails' do |app|
-        require 'rollbar/middleware/rails/rollbar_request_store'
-        app.config.middleware.use Rollbar::Middleware::Rails::RollbarRequestStore
+    
+    initializer 'rollbar.middleware.rails' do |app|
+      if defined?(ActionDispatch::DebugExceptions)
+        # Rails 3.2.x+
+        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)
+      elsif defined?(ActionDispatch::ShowExceptions)
+        # Rails 3.0.x and 3.1.x
+        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
 
@@ -28,16 +41,6 @@ module Rollbar
         require 'rollbar/rails/controller_methods'
         include Rollbar::Rails::ControllerMethods
       end
-
-      if defined?(ActionDispatch::DebugExceptions)
-        # Rails 3.2.x
-        require 'rollbar/middleware/rails/show_exceptions'
-        ActionDispatch::DebugExceptions.send(:include, Rollbar::Middleware::Rails::ShowExceptions)
-      elsif defined?(ActionDispatch::ShowExceptions)
-        # Rails 3.0.x and 3.1.x
-        require 'rollbar/middleware/rails/show_exceptions'
-        ActionDispatch::ShowExceptions.send(:include, Rollbar::Middleware::Rails::ShowExceptions)
-      end
     end
   end
 end

data/lib/rollbar/request_data_extractor.rb

@@ -1,10 +1,7 @@
+require 'multi_json'
+
 module Rollbar
   module RequestDataExtractor
-    ATTACHMENT_CLASSES = %w[
-      ActionDispatch::Http::UploadedFile
-      Rack::Multipart::UploadedFile
-    ].freeze
-
     def extract_person_data_from_controller(env)
       if env.has_key? 'rollbar.person_data'
         person_data = env['rollbar.person_data'] || {}
@@ -23,11 +20,12 @@ module Rollbar
       request_params = rollbar_filtered_params(sensitive_params, rollbar_request_params(env))
       get_params = rollbar_filtered_params(sensitive_params, rollbar_get_params(rack_req))
       post_params = rollbar_filtered_params(sensitive_params, rollbar_post_params(rack_req))
+      raw_post_params = rollbar_filtered_params(sensitive_params, rollbar_raw_post_params(rack_req))
       cookies = rollbar_filtered_params(sensitive_params, rollbar_request_cookies(rack_req))
       session = rollbar_filtered_params(sensitive_params, env['rack.session.options'])
       route_params = rollbar_filtered_params(sensitive_params, rollbar_route_params(env))
 
-      params = request_params.merge(get_params).merge(post_params)
+      params = request_params.merge(get_params).merge(post_params).merge(raw_post_params)
 
       data = {
         :params => params,
@@ -101,6 +99,15 @@ module Rollbar
       {}
     end
 
+    def rollbar_raw_post_params(rack_req)
+      return {} unless rack_req.env['CONTENT_TYPE'] =~ %r{application/json}i
+
+      params = MultiJson.decode(rack_req.body.read)
+      rack_req.body.rewind
+
+      params
+    end
+
     def rollbar_request_params(env)
       env['action_dispatch.request.parameters'] || {}
     end
@@ -125,18 +132,20 @@ module Rollbar
     end
 
     def rollbar_filtered_params(sensitive_params, params)
-      @sensitive_params_regexp ||= Regexp.new(sensitive_params.map{ |val| Regexp.escape(val.to_s).to_s }.join('|'), true)
+      sensitive_params_regexp = Regexp.new(sensitive_params.map{ |val| Regexp.escape(val.to_s).to_s }.join('|'), true)
 
       if params.nil?
         {}
       else
         params.to_hash.inject({}) do |result, (key, value)|
-          if @sensitive_params_regexp =~ key.to_s
+          if sensitive_params_regexp =~ key.to_s
             result[key] = rollbar_scrubbed(value)
           elsif value.is_a?(Hash)
             result[key] = rollbar_filtered_params(sensitive_params, value)
           elsif value.is_a?(Array)
-            result[key] = value.map {|v| v.is_a?(Hash) ? rollbar_filtered_params(sensitive_params, v) : v}
+            result[key] = value.map do |v|
+              v.is_a?(Hash) ? rollbar_filtered_params(sensitive_params, v) : v
+            end
           elsif ATTACHMENT_CLASSES.include?(value.class.name)
             result[key] = {
               :content_type => value.content_type,
@@ -146,6 +155,7 @@ module Rollbar
           else
             result[key] = value
           end
+
           result
         end
       end

data/lib/rollbar/util.rb

@@ -37,6 +37,45 @@ module Rollbar
       end
     end
     
+    def self.iterate_and_update_hash(hash, block)
+      hash.each do |k, v|
+        if v.is_a?(Hash)
+          self.iterate_and_update_hash(v, block)
+        else
+          hash[k] = block.call(k, v)
+        end
+      end
+    end
+    
+    def self.deep_copy(obj)
+      if obj.is_a?(Hash)
+        result = obj.clone
+        obj.each {|k, v| result[k] = deep_copy(v)}
+        result
+      elsif obj.is_a?(Array)
+        result = obj.clone
+        result.clear
+        obj.each {|v| result << deep_copy(v)}
+        result
+      else
+        obj
+      end
+    end
+    
+    def self.deep_merge(hash1, hash2)
+      hash2.each_key do |k|
+        if hash1[k].is_a? Hash and hash2[k].is_a? Hash
+          hash1[k] = deep_merge(hash1[k], hash2[k])
+        elsif hash1[k].is_a? Array and hash2[k].is_a? Array
+          hash1[k] += deep_copy(hash2[k])
+        elsif hash2[k]
+          hash1[k] = deep_copy(hash2[k])
+        end
+      end
+      
+      hash1
+    end
+    
     def self.truncate(str, length)
       ellipsis = '...'