airbrake 3.1.6 → 3.1.7

data/lib/airbrake/rack.rb

@@ -22,6 +22,7 @@ module Airbrake
   class Rack
     def initialize(app)
       @app = app
+      Airbrake.configuration.framework = "Rack: #{::Rack.release}"
     end
 
     def ignored_user_agent?(env)
@@ -32,23 +33,31 @@ module Airbrake
         any? { |ua| ua === env['HTTP_USER_AGENT'] }
     end
 
-    def notify_airbrake(exception,env)
-      Airbrake.notify_or_ignore(exception,:rack_env => env) unless ignored_user_agent?(env)
+    def notify_airbrake(exception, env)
+      unless ignored_user_agent?(env)
+        Airbrake.notify_or_ignore(exception, :rack_env => env)
+      end
     end
 
     def call(env)
+      @env = env
       begin
-        response = @app.call(env)
+        response = @app.call(@env)
       rescue Exception => raised
-        env['airbrake.error_id'] = notify_airbrake(raised,env)
-        raise
+        @env['airbrake.error_id'] = notify_airbrake(raised, @env)
+        raise raised
       end
 
-      if env['rack.exception']
-        env['airbrake.error_id'] = notify_airbrake(env['rack.exception'],env)
+      if framework_exception
+        @env['airbrake.error_id'] = notify_airbrake(framework_exception, @env)
       end
 
       response
     end
+
+    def framework_exception
+      @env['rack.exception']
+    end
+
   end
 end

data/lib/airbrake/rails/action_controller_catcher.rb

@@ -2,10 +2,12 @@ module Airbrake
   module Rails
     module ActionControllerCatcher
 
-      # Sets up an alias chain to catch exceptions when Rails does
+      # Sets up an alias chain to catch exceptions for Rails 2
       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)
+        if base.method_defined?(:rescue_action_in_public)
+          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
       end
 
       private

data/lib/airbrake/rails/controller_methods.rb

@@ -20,7 +20,7 @@ module Airbrake
       # 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)
+          Airbrake.notify_or_ignore(hash_or_exception, airbrake_request_data)
         end
       end
 
@@ -74,11 +74,11 @@ module Airbrake
 
       def airbrake_current_user
         user = begin current_user rescue current_member end
-        user.attributes.select do |k, v|
-          Airbrake.configuration.
-            user_attributes.map(&:to_sym).
-            include? k.to_sym unless v.blank?
-        end.symbolize_keys
+        h = {}
+        Airbrake.configuration.user_attributes.map(&:to_sym).each do |attr|
+          h[attr.to_sym] = user.send(attr) if user.respond_to? attr
+        end
+        h
       rescue NoMethodError, NameError
         {}
       end

data/lib/airbrake/rails/error_lookup.rb

@@ -4,8 +4,10 @@ module Airbrake
 
       # 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)
+        if base.method_defined?(:rescue_action_locally)
+          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
       end
 
       private

data/lib/airbrake/rails/javascript_notifier.rb

@@ -7,9 +7,7 @@ module Airbrake
 
       private
 
-      def airbrake_javascript_notifier
-        return unless Airbrake.configuration.public?
-
+      def airbrake_javascript_notifier_options
         path = File.join File.dirname(__FILE__), '..', '..', 'templates', 'javascript_notifier.erb'
         host = Airbrake.configuration.host.dup
         port = Airbrake.configuration.port
@@ -28,6 +26,12 @@ module Airbrake
             :url             => request.url
           }
         }
+      end
+
+      def airbrake_javascript_notifier
+        return unless Airbrake.configuration.public?
+
+        options = airbrake_javascript_notifier_options
 
         res = if @template
           @template.render(options)

data/lib/airbrake/rails/middleware.rb

@@ -0,0 +1,65 @@
+module Airbrake
+  module Rails
+    # Rack middleware for Rails applications. Any errors raised by the upstream
+    # application will be delivered to Airbrake and re-raised.
+    #
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @env = env
+
+        begin
+          response = @app.call(@env)
+        rescue Exception => exception
+          @env['airbrake.error_id'] = notify_airbrake(exception)
+          raise exception
+        end
+
+        if framework_exception
+          @env["airbrake.error_id"] = notify_airbrake(framework_exception)
+        end
+
+        response
+      end
+
+      private
+
+      def controller
+        @env["action_controller.instance"]
+      end
+
+      def after_airbrake_handler(exception)
+        if defined?(controller.rescue_action_in_public_without_airbrake)
+          controller.rescue_action_in_public_without_airbrake(exception)
+        end
+      end
+
+      def notify_airbrake(exception)
+        unless ignored_user_agent?
+          error_id = Airbrake.notify_or_ignore(exception, request_data)
+          after_airbrake_handler(exception)
+          error_id
+        end
+      end
+
+      def request_data
+        controller.try(:airbrake_request_data) || {:rack_env => @env}
+      end
+
+      def ignored_user_agent?
+        true if Airbrake.
+          configuration.
+          ignore_user_agent.
+          flatten.
+          any? { |ua| ua === @env['HTTP_USER_AGENT'] }
+      end
+
+      def framework_exception
+        @env["action_dispatch.exception"]
+      end
+    end
+  end
+end

data/lib/airbrake/rails3_tasks.rb

@@ -20,20 +20,28 @@ namespace :airbrake do
       end
     end
 
+    # Sets up verbose logging
     Rails.logger.level = Logger::DEBUG
     Airbrake.configure(true) do |config|
       config.logger = Rails.logger
     end
 
+    # Override Rails exception middleware, so we stop cluttering STDOUT
+    class ActionDispatch::DebugExceptions; def call(env); @app.call(env); end; end
+    class ActionDispatch::ShowExceptions; def call(env); @app.call(env); end; end
+
     require './app/controllers/application_controller'
 
     class AirbrakeTestingException < RuntimeError; end
 
+    # Checks if api_key is set
     unless Airbrake.configuration.api_key
       puts "Airbrake needs an API key configured! Check the README to see how to add it."
       exit
     end
 
+    # Enables Airbrake reporting on all environments,
+    # so we don't have to worry about invoking the task in production
     Airbrake.configuration.development_environments = []
 
     puts "Configuration:"
@@ -52,44 +60,31 @@ namespace :airbrake do
       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.'
+        raise exception_class.new, "\nTesting 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'
+      get 'verify' => 'application#verify', :as => 'verify'
     end
 
     puts 'Processing request.'
-    env = Rack::MockRequest.env_for("/verify")
+
+    config = Rails.application.config
+    protocol = (config.respond_to?(:force_ssl) && config.force_ssl) ? 'https' : 'http'
+
+    env = Rack::MockRequest.env_for("#{protocol}://www.example.com/verify")
 
     Rails.application.call(env)
 

data/lib/airbrake/railtie.rb

@@ -1,16 +1,18 @@
 require 'airbrake'
 require 'rails'
 
+require 'airbrake/rails/middleware'
+
 module Airbrake
   class Railtie < ::Rails::Railtie
     rake_tasks do
       require 'airbrake/rake_handler'
-      require "airbrake/rails3_tasks"
+      require 'airbrake/rails3_tasks'
     end
 
-    initializer "airbrake.use_rack_middleware" do |app|
+    initializer "airbrake.middleware" do |app|
+      app.config.middleware.use "Airbrake::Rails::Middleware"
       app.config.middleware.insert 0, "Airbrake::UserInformer"
-      app.config.middleware.insert_after "Airbrake::UserInformer","Airbrake::Rack"
     end
 
     config.after_initialize do
@@ -24,24 +26,15 @@ module Airbrake
       ActiveSupport.on_load(:action_controller) do
         # Lazily load action_controller methods
         #
-        require 'airbrake/rails/javascript_notifier'
         require 'airbrake/rails/controller_methods'
 
-        include Airbrake::Rails::JavascriptNotifier
         include Airbrake::Rails::ControllerMethods
       end
 
-      if defined?(::ActionDispatch::DebugExceptions)
-        # We should catch the exceptions in ActionDispatch::DebugExceptions in Rails 3.2.x.
-        #
-        require 'airbrake/rails/middleware/exceptions_catcher'
-        ::ActionDispatch::DebugExceptions.send(:include,Airbrake::Rails::Middleware::ExceptionsCatcher)
-      elsif defined?(::ActionDispatch::ShowExceptions)
-        # ActionDispatch::DebugExceptions is not defined in Rails 3.0.x and 3.1.x so
-        # catch the exceptions in ShowExceptions.
-        #
-        require 'airbrake/rails/middleware/exceptions_catcher'
-        ::ActionDispatch::ShowExceptions.send(:include,Airbrake::Rails::Middleware::ExceptionsCatcher)
+      if defined?(::ActionController::Base)
+        require 'airbrake/rails/javascript_notifier'
+
+        ::ActionController::Base.send(:include, Airbrake::Rails::JavascriptNotifier)
       end
     end
   end

data/lib/airbrake/rake_handler.rb

@@ -13,14 +13,14 @@ module Airbrake::RakeHandler
         (Airbrake.configuration.rescue_rake_exceptions ||
           (Airbrake.configuration.rescue_rake_exceptions===nil && !self.tty_output?))
 
-      Airbrake.notify_or_ignore(ex, :component => reconstruct_command_line, :cgi_data => environment_info)
+      Airbrake.notify_or_ignore(ex, :component => 'rake', :action => reconstruct_command_line, :cgi_data => environment_info)
     end
 
     display_error_message_without_airbrake(ex)
   end
 
   def reconstruct_command_line
-    "rake #{ARGV.join( ' ' )}"
+    ARGV.join( ' ' )
   end
 
   def environment_info

data/lib/airbrake/sender.rb

@@ -2,7 +2,17 @@ module Airbrake
   # Sends out the notice to Airbrake
   class Sender
 
-    NOTICES_URI = '/notifier_api/v2/notices/'.freeze
+    NOTICES_URI = '/notifier_api/v2/notices'.freeze
+    HEADERS = {
+      :xml => {
+      'Content-type' => 'text/xml',
+      'Accept'       => 'text/xml, application/xml'
+    },:json => {
+      'Content-Type' => 'application/json',
+      'Accept'       => 'application/json'
+    }}
+
+    JSON_API_URI = '/api/v3/projects'.freeze
     HTTP_ERRORS = [Timeout::Error,
                    Errno::EINVAL,
                    Errno::ECONNRESET,
@@ -23,21 +33,26 @@ module Airbrake
         :secure,
         :use_system_ssl_cert_chain,
         :http_open_timeout,
-        :http_read_timeout
+        :http_read_timeout,
+        :project_id,
+        :api_key
       ].each do |option|
         instance_variable_set("@#{option}", options[option])
       end
     end
 
+
     # Sends the notice data off to Airbrake for processing.
     #
     # @param [Notice or String] notice The notice to be sent off
     def send_to_airbrake(notice)
-      data = notice.respond_to?(:to_xml) ? notice.to_xml : notice
+      data = prepare_notice(notice)
       http = setup_http_connection
 
       response = begin
-                   http.post(url.path, data, HEADERS)
+                   http.post(url.respond_to?(:path) ? url.path : url,
+                             data,
+                             headers)
                  rescue *HTTP_ERRORS => e
                    log :level => :error,
                        :message => "Unable to contact the Airbrake server. HTTP Error=#{e}"
@@ -78,15 +93,46 @@ module Airbrake
                 :secure,
                 :use_system_ssl_cert_chain,
                 :http_open_timeout,
-                :http_read_timeout
+                :http_read_timeout,
+                :project_id,
+                :api_key
 
     alias_method :secure?, :secure
     alias_method :use_system_ssl_cert_chain?, :use_system_ssl_cert_chain
 
   private
 
+    def prepare_notice(notice)
+      if json_api_enabled?
+        begin
+          JSON.parse(notice)
+          notice
+        rescue
+          notice.to_json
+        end
+      else
+        notice.respond_to?(:to_xml) ? notice.to_xml : notice
+      end
+    end
+
+    def api_url
+      if json_api_enabled?
+        "#{JSON_API_URI}/#{project_id}/notices?key=#{api_key}"
+      else
+        NOTICES_URI
+      end
+    end
+
+    def headers
+      if json_api_enabled?
+        HEADERS[:json]
+      else
+        HEADERS[:xml]
+      end
+    end
+
     def url
-      URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
+      URI.parse("#{protocol}://#{host}:#{port}").merge(api_url)
     end
 
     def log(opts = {})
@@ -124,5 +170,10 @@ module Airbrake
                       "Error: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}"
       raise e
     end
+
+    def json_api_enabled?
+      !!(host =~ /collect.airbrake.io/) &&
+        project_id.present?
+    end
   end
 end