airbrake 3.1.6 → 11.0.0

data/lib/airbrake/rails/action_controller_catcher.rb

@@ -1,30 +0,0 @@
-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

@@ -1,87 +0,0 @@
-module Airbrake
-  module Rails
-    module ControllerMethods
-
-      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),
-          :user             => airbrake_current_user
-        }
-      end
-
-      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? && (!request.env["HTTP_X_FORWARDED_FOR"]))
-        else
-          consider_all_requests_local || (local_request? && (!request.env["HTTP_X_FORWARDED_FOR"]))
-        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_filter_if_filtering(hash)
-        return hash if ! hash.is_a?(Hash)
-
-
-        if respond_to?(:filter_parameters) # Rails 2
-          filter_parameters(hash)
-        elsif defined?(ActionDispatch::Http::ParameterFilter) # Rails 3
-          ActionDispatch::Http::ParameterFilter.new(::Rails.application.config.filter_parameters).filter(hash)
-        else
-          hash
-        end rescue hash
-
-      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
-
-      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
-      rescue NoMethodError, NameError
-        {}
-      end
-    end
-  end
-end

data/lib/airbrake/rails/error_lookup.rb

@@ -1,33 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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.js_api_key,
-            :environment     => Airbrake.configuration.environment_name,
-            :action_name     => action_name,
-            :controller_name => controller_name,
-            :url             => request.url
-          }
-        }
-
-        res = if @template
-          @template.render(options)
-        else
-          render_to_string(options)
-        end
-
-        if res.respond_to?(:html_safe)
-          res.html_safe
-        else
-          res
-        end
-
-      end
-    end
-  end
-end

data/lib/airbrake/rails/middleware/exceptions_catcher.rb

@@ -1,33 +0,0 @@
-module Airbrake
-  module Rails
-    module Middleware
-      module ExceptionsCatcher
-        def self.included(base)
-          base.send(:alias_method_chain,:render_exception,:airbrake)
-        end
-
-        def skip_user_agent?(env)
-          user_agent = env["HTTP_USER_AGENT"]
-          ::Airbrake.configuration.ignore_user_agent.flatten.any? { |ua| ua === user_agent }
-        rescue
-          false
-        end
-
-        def render_exception_with_airbrake(env,exception)
-          begin
-            controller = env['action_controller.instance']
-            env['airbrake.error_id'] = Airbrake.
-              notify_or_ignore(exception,
-                               controller.try(:airbrake_request_data) || {:rack_env => env}) unless skip_user_agent?(env)
-            if defined?(controller.rescue_action_in_public_without_airbrake)
-              controller.rescue_action_in_public_without_airbrake(exception)
-            end
-          rescue
-            # do nothing
-          end
-          render_exception_without_airbrake(env,exception)
-        end
-      end
-    end
-  end
-end

data/lib/airbrake/rails3_tasks.rb

@@ -1,98 +0,0 @@
-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 = defined?(ActiveSupport::TaggedLogging) ?
-      ActiveSupport::TaggedLogging.new(Logger.new(STDOUT)) :
-      Logger.new(STDOUT)
-
-    def wait_for_threads
-      # if using multiple threads, we have to wait for
-      # them to finish
-      if GirlFriday.status.empty?
-        Thread.list.each do |thread|
-          thread.join unless thread == Thread.current
-        end
-      else
-        GirlFriday.shutdown!
-      end
-    end
-
-    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)
-
-    wait_for_threads
-  end
-end

data/lib/airbrake/railtie.rb

@@ -1,48 +0,0 @@
-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.insert 0, "Airbrake::UserInformer"
-      app.config.middleware.insert_after "Airbrake::UserInformer","Airbrake::Rack"
-    end
-
-    config.after_initialize do
-      Airbrake.configure(true) do |config|
-        config.logger           ||= config.async? ? ::Logger.new(STDERR) : ::Rails.logger
-        config.environment_name ||= ::Rails.env
-        config.project_root     ||= ::Rails.root
-        config.framework        = "Rails: #{::Rails::VERSION::STRING}"
-      end
-
-      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)
-      end
-    end
-  end
-end

data/lib/airbrake/rake_handler.rb

@@ -1,71 +0,0 @@
-# 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.sender && Airbrake.configuration &&
-        (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)
-    end
-
-    display_error_message_without_airbrake(ex)
-  end
-
-  def reconstruct_command_line
-    "rake #{ARGV.join( ' ' )}"
-  end
-
-  def environment_info
-    ENV.reject do |k|
-      Airbrake.configuration.rake_environment_filters.include? k
-    end
-  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