rollbar 0.8.0

data/lib/rollbar/configuration.rb

@@ -0,0 +1,64 @@
+require 'logger'
+
+module Rollbar
+  class Configuration
+
+    attr_accessor :access_token
+    attr_accessor :async_handler
+    attr_accessor :branch
+    attr_accessor :default_logger
+    attr_accessor :enabled
+    attr_accessor :endpoint
+    attr_accessor :environment
+    attr_accessor :exception_level_filters
+    attr_accessor :filepath
+    attr_accessor :framework
+    attr_accessor :logger
+    attr_accessor :person_method
+    attr_accessor :person_id_method
+    attr_accessor :person_username_method
+    attr_accessor :person_email_method
+    attr_accessor :root
+    attr_accessor :scrub_fields
+    attr_accessor :use_async
+    attr_accessor :use_eventmachine
+    attr_accessor :web_base
+    attr_accessor :write_to_file
+
+    DEFAULT_ENDPOINT = 'https://api.rollbar.com/api/1/item/'
+    DEFAULT_WEB_BASE = 'https://rollbar.com'
+
+    def initialize
+      @async_handler = nil
+      @default_logger = lambda { Logger.new(STDERR) }
+      @enabled = true
+      @endpoint = DEFAULT_ENDPOINT
+      @exception_level_filters = {
+        'ActiveRecord::RecordNotFound' => 'warning',
+        'AbstractController::ActionNotFound' => 'warning',
+        'ActionController::RoutingError' => 'warning'
+      }
+      @framework = 'Plain'
+      @person_method = 'current_user'
+      @person_id_method = 'id'
+      @person_username_method = 'username'
+      @person_email_method = 'email'
+      @scrub_fields = [:passwd, :password, :password_confirmation, :secret,
+                       :confirm_password, :password_confirmation]
+      @use_async = false
+      @web_base = DEFAULT_WEB_BASE
+      @write_to_file = false
+      @use_eventmachine = false
+    end
+    
+    def use_eventmachine=(value)
+      require 'em-http-request' if value
+      @use_eventmachine = value
+    end
+
+    # allow params to be read like a hash
+    def [](option)
+      send(option)
+    end
+  end
+end

data/lib/rollbar/delayed_job.rb

@@ -0,0 +1,25 @@
+# based on http://bit.ly/VGdfVI
+
+module Delayed
+  module Plugins
+    class Rollbar < Plugin
+      module ReportErrors
+        def error(job, error)
+          # send the job object as the 'request data'
+          ::Rollbar.report_exception(error, job)
+          super if defined?(super)
+        end
+      end
+
+      callbacks do |lifecycle|
+        lifecycle.before(:invoke_job) do |job|
+          payload = job.payload_object
+          payload = payload.object if payload.is_a? Delayed::PerformableMethod
+          payload.extend ReportErrors
+        end
+      end
+    end
+  end
+end
+
+Delayed::Worker.plugins << Delayed::Plugins::Rollbar

data/lib/rollbar/exception_reporter.rb

@@ -0,0 +1,24 @@
+module Rollbar
+  module ExceptionReporter
+    include RequestDataExtractor
+
+    def report_exception_to_rollbar(env, exception)
+      rollbar_debug "[Rollbar] Reporting exception: #{exception.try(:message)}", :error
+      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)
+      env['rollbar.exception_uuid'] = exception_data[:uuid]
+      rollbar_debug "[Rollbar] Exception uuid saved in env: #{exception_data[:uuid]}"
+    rescue => e
+      rollbar_debug "[Rollbar] Exception while reporting exception to Rollbar: #{e.try(:message)}"
+    end
+
+    def rollbar_debug(message, level = :debug)
+      if defined?(Rails)
+        ::Rails.logger.send(level, message)
+      else
+        puts message
+      end
+    end
+  end
+end

data/lib/rollbar/goalie.rb

@@ -0,0 +1,33 @@
+module Goalie
+  class CustomErrorPages
+    alias_method :orig_render_exception, :render_exception
+    
+    private
+
+    def render_exception(env, exception)
+      exception_data = nil
+      begin
+        controller = env['action_controller.instance']
+        request_data = controller.try(:rollbar_request_data)
+        person_data = controller.try(:rollbar_person_data)
+        exception_data = Rollbar.report_exception(exception, request_data, person_data)
+      rescue => e
+        # TODO use logger here?
+        puts "[Rollbar] Exception while reporting exception to Rollbar: #{e}" 
+      end
+      
+      # if an exception was reported, save uuid in the env
+      # so it can be displayed to the user on the error page
+      if exception_data
+        begin
+          env['rollbar.exception_uuid'] = exception_data[:uuid]
+        rescue => e
+          puts "[Rollbar] Exception saving uuid in env: #{e}"
+        end
+      end
+
+      # now continue as normal
+      orig_render_exception(env, exception)
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Rollbar
+  module Middleware
+    module Rack
+      module Builder
+        include ExceptionReporter
+
+        def call_with_rollbar(env)
+          call_without_rollbar(env)
+        rescue => exception
+          report_exception_to_rollbar(env, exception)
+          raise exception
+        end
+
+        def self.included(base)
+          base.send(:alias_method, :call_without_rollbar, :call)
+          base.send(:alias_method, :call, :call_with_rollbar)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Rollbar
+  module Middleware
+    module Rack
+      module TestSession
+        include ExceptionReporter
+
+        def process_request_with_rollbar(uri, env, &block)
+          process_request_without_rollbar(uri, env, &block)
+        rescue => exception
+          report_exception_to_rollbar(env, exception)
+          raise exception
+        end
+
+        def env_for_with_rollbar(path, env)
+          env_for_without_rollbar(path, env)
+        rescue => exception
+          report_exception_to_rollbar(env, exception)
+          raise exception
+        end
+
+        def self.included(base)
+          base.send(:alias_method, :process_request_without_rollbar, :process_request)
+          base.send(:alias_method, :process_request, :process_request_with_rollbar)
+
+          base.send(:alias_method, :env_for_without_rollbar, :env_for)
+          base.send(:alias_method, :env_for, :env_for_with_rollbar)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Rollbar
+  module Middleware
+    module Rails
+      module ShowExceptions
+        include ExceptionReporter
+
+        def render_exception_with_rollbar(env, exception)
+          report_exception_to_rollbar(env, exception)
+          render_exception_without_rollbar(env, exception)
+        end
+
+        def call_with_rollbar(env)
+          call_without_rollbar(env)
+        rescue => exception
+          report_exception_to_rollbar(env, exception)
+          raise exception
+        end
+
+        def self.included(base)
+          base.send(:alias_method_chain, :render_exception, :rollbar)
+          base.send(:alias_method_chain, :call, :rollbar)
+        end
+      end
+    end
+  end
+end

data/lib/rollbar/rack.rb

@@ -0,0 +1,9 @@
+if defined?(Rack::Builder)
+  require 'rollbar/middleware/rack/builder'
+  Rack::Builder.send(:include, Rollbar::Middleware::Rack::Builder)
+end
+
+if defined?(Rack::Test::Session)
+  require 'rollbar/middleware/rack/test_session'
+  Rack::Test::Session.send(:include, Rollbar::Middleware::Rack::TestSession)
+end

data/lib/rollbar/rails.rb

@@ -0,0 +1,22 @@
+require 'rollbar'
+
+module Rollbar
+  module Rails
+    def self.initialize
+      rails_logger = if defined?(::Rails.logger)
+                       ::Rails.logger
+                     elsif defined?(RAILS_DEFAULT_LOGGER)
+                       RAILS_DEFAULT_LOGGER
+                     end
+
+      Rollbar.configure do |config|
+        config.logger = rails_logger
+        config.environment = defined?(::Rails.env) && ::Rails.env || defined?(RAILS_ENV) && RAILS_ENV
+        config.root = defined?(::Rails.root) && ::Rails.root || defined?(RAILS_ROOT) && RAILS_ROOT
+        config.framework = defined?(::Rails.version) && "Rails: #{::Rails.version}" || defined?(::Rails::VERSION::STRING) && "Rails: #{::Rails::VERSION::STRING}"
+      end
+    end
+  end
+end
+
+Rollbar::Rails.initialize

data/lib/rollbar/rails/controller_methods.rb

@@ -0,0 +1,28 @@
+module Rollbar
+  module Rails
+    module ControllerMethods
+      include RequestDataExtractor
+
+      def rollbar_person_data
+        user = send(Rollbar.configuration.person_method)
+        # 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)
+          }
+        else
+          {}
+        end
+      rescue NoMethodError, NameError
+        {}
+      end
+
+      def rollbar_request_data
+        extract_request_data_from_rack(request.env)
+      end
+
+    end
+  end
+end

data/lib/rollbar/railtie.rb

@@ -0,0 +1,37 @@
+require 'rails'
+require 'rollbar'
+
+module Rollbar
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      require 'rollbar/rake_tasks'
+    end
+
+    config.after_initialize do
+      Rollbar.configure do |config|
+        config.logger ||= ::Rails.logger
+        config.environment ||= ::Rails.env
+        config.root ||= ::Rails.root
+        config.framework = "Rails: #{::Rails::VERSION::STRING}"
+        config.filepath ||= ::Rails.application.class.parent_name + '.rollbar'
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        # lazily load action_controller methods
+        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/rake.rb

@@ -0,0 +1,9 @@
+module Rake
+  class Application
+    alias_method :orig_display_error_message, :display_error_message
+    def display_error_message(ex)
+      Rollbar.report_exception(ex)
+      orig_display_error_message(ex)
+    end
+  end
+end

data/lib/rollbar/rake_tasks.rb

@@ -0,0 +1,60 @@
+require 'rollbar'
+
+namespace :rollbar do
+  desc "Verify your gem installation by sending a test exception to Rollbar"
+  task :test => [:environment] do
+    Rails.logger = defined?(ActiveSupport::TaggedLogging) ?
+      ActiveSupport::TaggedLogging.new(Logger.new(STDOUT)) :
+      Logger.new(STDOUT)
+
+    Rails.logger.level = Logger::DEBUG
+    Rollbar.configure do |config|
+      config.logger = Rails.logger
+    end
+
+    class RollbarTestingException < RuntimeError; end
+
+    unless Rollbar.configuration.access_token
+      puts "Rollbar needs an access token configured. Check the README for instructions."
+      exit
+    end
+
+    begin
+      require './app/controllers/application_controller'
+    rescue LoadError
+    end
+
+    unless defined?(ApplicationController)
+      puts "No ApplicationController found, using ActionController::Base instead"
+      class ApplicationController < ActionController::Base; end
+    end
+
+    puts "Setting up the controller."
+    class ApplicationController
+      prepend_before_filter :test_rollbar
+      def test_rollbar
+        puts "Raising RollbarTestingException to simulate app failure."
+        raise RollbarTestingException.new, 'Testing rollbar with "rake rollbar:test". If you can see this, it works.'
+      end
+
+      def verify
+      end
+
+      def logger
+        nil
+      end
+    end
+    
+    class RollbarTestController < ApplicationController; end
+
+    Rails.application.routes_reloader.execute_if_updated
+    Rails.application.routes.draw do
+      match 'verify' => 'application#verify', :as => 'verify'
+    end
+
+    puts "Processing..."
+    env = Rack::MockRequest.env_for("/verify")
+
+    Rails.application.call(env)
+  end
+end

data/lib/rollbar/request_data_extractor.rb

@@ -0,0 +1,115 @@
+module Rollbar
+  module RequestDataExtractor
+    ATTACHMENT_CLASSES = %w[
+      ActionDispatch::Http::UploadedFile
+      Rack::Multipart::UploadedFile
+    ].freeze
+
+    def extract_person_data_from_controller(env)
+      controller = env['action_controller.instance']
+      person_data = controller ? controller.try(:rollbar_person_data) : {}
+    end
+
+    def extract_request_data_from_rack(env)
+      sensitive_params = sensitive_params_list(env)
+      request_params = rollbar_request_params(env)
+      cookies = rollbar_filtered_params(sensitive_params, rollbar_request_cookies(env))
+      get_params = rollbar_filtered_params(sensitive_params, rollbar_get_params(env))
+      post_params = rollbar_filtered_params(sensitive_params, rollbar_post_params(env))
+    
+      {
+        :params => get_params.merge(post_params).merge(request_params),
+        :url => rollbar_url(env),
+        :user_ip => rollbar_user_ip(env),
+        :headers => rollbar_headers(env),
+        :GET => get_params,
+        :POST => post_params,
+        :cookies => cookies,
+        :session => env['rack.session.options'],
+        :method => rollbar_request_method(env)
+      }
+    end
+
+    private
+
+    def rollbar_request_method(env)
+      env['REQUEST_METHOD'] || env[:method]
+    end
+
+    def rollbar_headers(env)
+      env.keys.grep(/^HTTP_/).map do |header|
+        name = header.gsub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
+        { name => env[header] }
+      end.inject(:merge)
+    end
+
+    def rollbar_url(env)
+      scheme = env['rack.url_scheme']
+      host = env['HTTP_HOST'] || env['SERVER_NAME']
+      path = env['ORIGINAL_FULLPATH'] || env['REQUEST_URI']
+      unless path.nil? || path.empty?
+        path = '/' + path.to_s if path.to_s.slice(0, 1) != '/'
+      end
+
+      [scheme, '://', host, path].join
+    end
+
+    def rollbar_user_ip(env)
+      (env['action_dispatch.remote_ip'] || env['HTTP_X_REAL_IP'] || env['HTTP_X_FORWARDED_FOR'] || env['REMOTE_ADDR']).to_s
+    end
+
+    def rollbar_request_params(env)
+      route = ::Rails.application.routes.recognize_path(env['PATH_INFO']) rescue {}
+      {
+        :controller => route[:controller],
+        :action => route[:action],
+        :format => route[:format],
+      }
+    end
+
+    def rollbar_get_params(env)
+      rack_request(env).GET
+    rescue
+      {}
+    end
+
+    def rollbar_post_params(env)
+      rack_request(env).POST
+    rescue
+      {}
+    end
+
+    def rollbar_request_cookies(env)
+      rack_request(env).cookie
+    rescue
+      {}
+    end
+
+    def rack_request(env)
+      @rack_request ||= Rack::Request.new(env)
+    end
+
+    def rollbar_filtered_params(sensitive_params, params)
+      params.inject({}) do |result, (key, value)|
+        if key.to_sym.in?(sensitive_params)
+          result[key] = '*' * (value.length rescue 8)
+        elsif value.is_a?(Hash)
+          result[key] = rollbar_filtered_params(sensitive_params, value)
+        elsif value.class.name.in?(ATTACHMENT_CLASSES)
+          result[key] = {
+            :content_type => value.content_type,
+            :original_filename => value.original_filename,
+            :size => value.tempfile.size
+          } rescue 'Uploaded file'
+        else
+          result[key] = value
+        end
+        result
+      end
+    end
+
+    def sensitive_params_list(env)
+      Rollbar.configuration.scrub_fields |= Array(env['action_dispatch.parameter_filter'])
+    end
+  end
+end