airbrake 3.0.rc1

data/lib/airbrake/rack.rb

@@ -0,0 +1,42 @@
+module Airbrake
+  # Middleware for Rack applications. Any errors raised by the upstream
+  # application will be delivered to Airbrake and re-raised.
+  #
+  # Synopsis:
+  #
+  #   require 'rack'
+  #   require 'airbrake'
+  #
+  #   Airbrake.configure do |config|
+  #     config.api_key = 'my_api_key'
+  #   end
+  #
+  #   app = Rack::Builder.app do
+  #     use Airbrake::Rack
+  #     run lambda { |env| raise "Rack down" }
+  #   end
+  #
+  # Use a standard Airbrake.configure call to configure your api key.
+  class Rack
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      begin
+        response = @app.call(env)
+      rescue Exception => raised
+        error_id = Airbrake.notify_or_ignore(raised, :rack_env => env)
+        env['airbrake.error_id'] = error_id
+        raise
+      end
+
+      if env['rack.exception']
+        error_id = Airbrake.notify_or_ignore(env['rack.exception'], :rack_env => env)
+        env['airbrake.error_id'] = error_id
+      end
+
+      response
+    end
+  end
+end

data/lib/airbrake/rails.rb

@@ -0,0 +1,41 @@
+require 'airbrake'
+require 'airbrake/rails/controller_methods'
+require 'airbrake/rails/action_controller_catcher'
+require 'airbrake/rails/error_lookup'
+require 'airbrake/rails/javascript_notifier'
+
+module Airbrake
+  module Rails
+    def self.initialize
+      if defined?(ActionController::Base)
+        ActionController::Base.send(:include, Airbrake::Rails::ActionControllerCatcher)
+        ActionController::Base.send(:include, Airbrake::Rails::ErrorLookup)
+        ActionController::Base.send(:include, Airbrake::Rails::ControllerMethods)
+        ActionController::Base.send(:include, Airbrake::Rails::JavascriptNotifier)
+      end
+
+      rails_logger = if defined?(::Rails.logger)
+                       ::Rails.logger
+                     elsif defined?(RAILS_DEFAULT_LOGGER)
+                       RAILS_DEFAULT_LOGGER
+                     end
+
+      if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:middleware)
+        ::Rails.configuration.middleware.insert_after 'ActionController::Failsafe',
+                                                      Airbrake::Rack
+        ::Rails.configuration.middleware.insert_after 'Rack::Lock',
+                                                      Airbrake::UserInformer
+      end
+
+      Airbrake.configure(true) do |config|
+        config.logger = rails_logger
+        config.environment_name = RAILS_ENV  if defined?(RAILS_ENV)
+        config.project_root     = RAILS_ROOT if defined?(RAILS_ROOT)
+        config.framework        = "Rails: #{::Rails::VERSION::STRING}" if defined?(::Rails::VERSION)
+      end
+    end
+  end
+end
+
+Airbrake::Rails.initialize
+

data/lib/airbrake/rails/action_controller_catcher.rb

@@ -0,0 +1,30 @@
+module Airbrake
+  module Rails
+    module ActionControllerCatcher
+
+      # Sets up an alias chain to catch exceptions when Rails does
+      def self.included(base) #:nodoc:
+        base.send(:alias_method, :rescue_action_in_public_without_airbrake, :rescue_action_in_public)
+        base.send(:alias_method, :rescue_action_in_public, :rescue_action_in_public_with_airbrake)
+      end
+
+      private
+
+      # Overrides the rescue_action method in ActionController::Base, but does not inhibit
+      # any custom processing that is defined with Rails 2's exception helpers.
+      def rescue_action_in_public_with_airbrake(exception)
+        unless airbrake_ignore_user_agent?
+          error_id = Airbrake.notify_or_ignore(exception, airbrake_request_data)
+          request.env['airbrake.error_id'] = error_id
+        end
+        rescue_action_in_public_without_airbrake(exception)
+      end
+
+      def airbrake_ignore_user_agent? #:nodoc:
+        # Rails 1.2.6 doesn't have request.user_agent, so check for it here
+        user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
+        Airbrake.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+      end
+    end
+  end
+end

data/lib/airbrake/rails/controller_methods.rb

@@ -0,0 +1,68 @@
+module Airbrake
+  module Rails
+    module ControllerMethods
+      private
+
+      # This method should be used for sending manual notifications while you are still
+      # inside the controller. Otherwise it works like Airbrake.notify.
+      def notify_airbrake(hash_or_exception)
+        unless airbrake_local_request?
+          Airbrake.notify(hash_or_exception, airbrake_request_data)
+        end
+      end
+      
+      def airbrake_local_request?
+        if defined?(::Rails.application.config)
+          ::Rails.application.config.consider_all_requests_local || request.local?
+        else
+          consider_all_requests_local || local_request?
+        end
+      end
+
+      def airbrake_ignore_user_agent? #:nodoc:
+        # Rails 1.2.6 doesn't have request.user_agent, so check for it here
+        user_agent = request.respond_to?(:user_agent) ? request.user_agent : request.env["HTTP_USER_AGENT"]
+        Airbrake.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
+      end
+
+      def airbrake_request_data
+        { :parameters       => airbrake_filter_if_filtering(params.to_hash),
+          :session_data     => airbrake_filter_if_filtering(airbrake_session_data),
+          :controller       => params[:controller],
+          :action           => params[:action],
+          :url              => airbrake_request_url,
+          :cgi_data         => airbrake_filter_if_filtering(request.env) }
+      end
+
+      def airbrake_filter_if_filtering(hash)
+        return hash if ! hash.is_a?(Hash)
+
+        if respond_to?(:filter_parameters)
+          filter_parameters(hash) rescue hash
+        else
+          hash
+        end
+      end
+
+      def airbrake_session_data
+        if session.respond_to?(:to_hash)
+          session.to_hash
+        else
+          session.data
+        end
+      end
+
+      def airbrake_request_url
+        url = "#{request.protocol}#{request.host}"
+
+        unless [80, 443].include?(request.port)
+          url << ":#{request.port}"
+        end
+
+        url << request.fullpath
+        url
+      end
+    end
+  end
+end
+

data/lib/airbrake/rails/error_lookup.rb

@@ -0,0 +1,33 @@
+module Airbrake
+  module Rails
+    module ErrorLookup
+
+      # Sets up an alias chain to catch exceptions when Rails does
+      def self.included(base) #:nodoc:
+        base.send(:alias_method, :rescue_action_locally_without_airbrake, :rescue_action_locally)
+        base.send(:alias_method, :rescue_action_locally, :rescue_action_locally_with_airbrake)
+      end
+
+      private
+
+      def rescue_action_locally_with_airbrake(exception)
+        result = rescue_action_locally_without_airbrake(exception)
+
+        if Airbrake.configuration.development_lookup
+          path   = File.join(File.dirname(__FILE__), '..', '..', 'templates', 'rescue.erb')
+          notice = Airbrake.build_lookup_hash_for(exception, airbrake_request_data)
+
+          result << @template.render(
+            :file          => path,
+            :use_full_path => false,
+            :locals        => { :host    => Airbrake.configuration.host,
+                                :api_key => Airbrake.configuration.api_key,
+                                :notice  => notice })
+        end
+
+        result
+      end
+    end
+  end
+end
+

data/lib/airbrake/rails/javascript_notifier.rb

@@ -0,0 +1,42 @@
+module Airbrake
+  module Rails
+    module JavascriptNotifier
+      def self.included(base) #:nodoc:
+        base.send :helper_method, :airbrake_javascript_notifier
+      end
+
+      private
+
+      def airbrake_javascript_notifier
+        return unless Airbrake.configuration.public?
+
+        path = File.join File.dirname(__FILE__), '..', '..', 'templates', 'javascript_notifier.erb'
+        host = Airbrake.configuration.host.dup
+        port = Airbrake.configuration.port
+        host << ":#{port}" unless [80, 443].include?(port)
+
+        options              = {
+          :file              => path,
+          :layout            => false,
+          :use_full_path     => false,
+          :locals            => {
+            :host            => host,
+            :api_key         => Airbrake.configuration.api_key,
+            :environment     => Airbrake.configuration.environment_name,
+            :action_name     => action_name,
+            :controller_name => controller_name,
+            :url             => request.url
+          }
+        }
+
+        if @template
+          @template.render(options)
+        else
+          render_to_string(options)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/airbrake/rails3_tasks.rb

@@ -0,0 +1,82 @@
+require 'airbrake'
+require File.join(File.dirname(__FILE__), 'shared_tasks')
+
+namespace :airbrake do
+  desc "Verify your gem installation by sending a test exception to the airbrake service"
+  task :test => [:environment] do
+    Rails.logger = Logger.new(STDOUT)
+    Rails.logger.level = Logger::DEBUG
+    Airbrake.configure(true) do |config|
+      config.logger = Rails.logger
+    end
+
+    require './app/controllers/application_controller'
+
+    class AirbrakeTestingException < RuntimeError; end
+
+    unless Airbrake.configuration.api_key
+      puts "Airbrake needs an API key configured! Check the README to see how to add it."
+      exit
+    end
+
+    Airbrake.configuration.development_environments = []
+
+    puts "Configuration:"
+    Airbrake.configuration.to_hash.each do |key, value|
+      puts sprintf("%25s: %s", key.to_s, value.inspect.slice(0, 55))
+    end
+
+    unless defined?(ApplicationController)
+      puts "No ApplicationController found"
+      exit
+    end
+
+    puts 'Setting up the Controller.'
+    class ApplicationController
+      # This is to bypass any filters that may prevent access to the action.
+      prepend_before_filter :test_airbrake
+      def test_airbrake
+        puts "Raising '#{exception_class.name}' to simulate application failure."
+        raise exception_class.new, 'Testing airbrake via "rake airbrake:test". If you can see this, it works.'
+      end
+
+      # def rescue_action(exception)
+      #   rescue_action_in_public exception
+      # end
+
+      # Ensure we actually have an action to go to.
+      def verify; end
+
+      # def consider_all_requests_local
+      #   false
+      # end
+
+      # def local_request?
+      #   false
+      # end
+
+      def exception_class
+        exception_name = ENV['EXCEPTION'] || "AirbrakeTestingException"
+        Object.const_get(exception_name)
+      rescue
+        Object.const_set(exception_name, Class.new(Exception))
+      end
+
+      def logger
+        nil
+      end
+    end
+    class AirbrakeVerificationController < ApplicationController; end
+
+    Rails.application.routes_reloader.execute_if_updated
+    Rails.application.routes.draw do
+      match 'verify' => 'application#verify', :as => 'verify'
+    end
+
+    puts 'Processing request.'
+    env = Rack::MockRequest.env_for("/verify")
+
+    Rails.application.call(env)
+  end
+end
+

data/lib/airbrake/railtie.rb

@@ -0,0 +1,33 @@
+require 'airbrake'
+require 'rails'
+
+module Airbrake
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      require 'airbrake/rake_handler'
+      require "airbrake/rails3_tasks"
+    end
+
+    initializer "airbrake.use_rack_middleware" do |app|
+      app.config.middleware.use "Airbrake::Rack"
+      app.config.middleware.insert 0, "Airbrake::UserInformer"
+    end
+
+    config.after_initialize do
+      Airbrake.configure(true) do |config|
+        config.logger           ||= Rails.logger
+        config.environment_name ||= Rails.env
+        config.project_root     ||= Rails.root
+        config.framework        = "Rails: #{::Rails::VERSION::STRING}"
+      end
+
+      if defined?(::ActionController::Base)
+        require 'airbrake/rails/javascript_notifier'
+        require 'airbrake/rails/controller_methods'
+
+        ::ActionController::Base.send(:include, Airbrake::Rails::ControllerMethods)
+        ::ActionController::Base.send(:include, Airbrake::Rails::JavascriptNotifier)
+      end
+    end
+  end
+end

data/lib/airbrake/rake_handler.rb

@@ -0,0 +1,65 @@
+# Patch Rake::Application to handle errors with Airbrake
+module Airbrake::RakeHandler
+  def self.included(klass)
+    klass.class_eval do
+      include Rake087Methods unless defined?(Rake::VERSION) && Rake::VERSION >= '0.9.0'
+      alias_method :display_error_message_without_airbrake, :display_error_message
+      alias_method :display_error_message, :display_error_message_with_airbrake
+    end
+  end
+
+  def display_error_message_with_airbrake(ex)
+    if Airbrake.configuration.rescue_rake_exceptions || 
+        (Airbrake.configuration.rescue_rake_exceptions===nil && !self.tty_output?)
+
+      Airbrake.notify(ex, :component => reconstruct_command_line, :cgi_data => ENV)
+    end
+
+    display_error_message_without_airbrake(ex)
+  end
+
+  def reconstruct_command_line
+    "rake #{ARGV.join( ' ' )}"
+  end
+  
+  # This module brings Rake 0.8.7 error handling to 0.9.0 standards
+  module Rake087Methods
+    # Method taken from Rake 0.9.0 source
+    # 
+    # Provide standard exception handling for the given block.
+    def standard_exception_handling
+      begin
+        yield
+      rescue SystemExit => ex
+        # Exit silently with current status
+        raise
+      rescue OptionParser::InvalidOption => ex
+        $stderr.puts ex.message
+        exit(false)
+      rescue Exception => ex
+        # Exit with error message
+        display_error_message(ex)
+        exit(false)
+      end
+    end
+
+    # Method extracted from Rake 0.8.7 source
+    def display_error_message(ex)
+      $stderr.puts "#{name} aborted!"
+      $stderr.puts ex.message
+      if options.trace
+        $stderr.puts ex.backtrace.join("\n")
+      else
+        $stderr.puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+        $stderr.puts "(See full trace by running task with --trace)"
+      end
+    end
+  end
+end
+
+Rake.application.instance_eval do
+  class << self
+    include Airbrake::RakeHandler
+  end
+end
+