airbrake 4.3.8 → 5.0.0.rc.1

data/lib/airbrake/rails.rb

@@ -1,45 +0,0 @@
-require 'airbrake'
-require 'airbrake/rails/controller_methods'
-require 'airbrake/rails/action_controller_catcher'
-require 'airbrake/rails/error_lookup'
-
-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)
-      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)
-        if defined?(::ActionController::Failsafe)
-          ::Rails.configuration.middleware.insert_after 'ActionController::Failsafe',
-                                                        Airbrake::Rack
-        end
-        if defined?(::Rack::Lock)
-          ::Rails.configuration.middleware.insert_after 'Rack::Lock',
-                                                        Airbrake::UserInformer
-        else
-          ::Rails.configuration.middleware.insert_before 'Rack::Runtime',
-                                                         Airbrake::UserInformer
-        end
-      end
-
-      Airbrake.configure(true) do |config|
-        config.logger           = rails_logger
-        config.environment_name = defined?(::Rails.env) && ::Rails.env || defined?(RAILS_ENV) && RAILS_ENV
-        config.project_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
-
-Airbrake::Rails.initialize

data/lib/airbrake/rails/action_controller_catcher.rb

@@ -1,32 +0,0 @@
-module Airbrake
-  module Rails
-    module ActionControllerCatcher
-
-      # Sets up an alias chain to catch exceptions for Rails 2
-      def self.included(base) #:nodoc:
-        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
-
-      # 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,146 +0,0 @@
-module Airbrake
-  module Rails
-    module ControllerMethods
-
-      SLASH = "/"
-
-      def airbrake_request_data
-        {
-          :parameters       => airbrake_filter_if_filtering(to_hash(params)),
-          :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
-
-      def to_hash(params)
-        # Rails <= 4
-        return params.to_hash if params.respond_to?(:to_hash)
-
-        # Rails >= 5
-        params.to_unsafe_h
-      end
-
-      # 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_or_ignore(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 rails_3_or_4?
-          filter_rails3_parameters(hash)
-        else
-          hash
-        end
-      end
-
-      def rails_3_or_4?
-        defined?(::Rails.version) && ::Rails.version =~ /\A[34]/
-      end
-
-      def filter_rails3_parameters(hash)
-        ActionDispatch::Http::ParameterFilter.new(
-          ::Rails.application.config.filter_parameters
-        ).filter(recursive_stringify_keys(hash))
-      end
-
-      def recursive_stringify_keys(hash)
-        hash = hash.stringify_keys
-        hash.each do |k, v|
-          if v.is_a?(Hash)
-            hash[k] = v.respond_to?(:stringify_keys) ? recursive_stringify_keys(v) : nil # Rack::Session::Abstract::SessionHash has a stringify_keys method we should not call
-          end
-        end
-        hash
-      end
-
-      def airbrake_session_data
-        if session
-          if session.respond_to?(:to_hash)
-            session.to_hash
-          else
-            session.data
-          end
-        else
-          {:session => 'no session found'}
-        end
-      end
-
-      def airbrake_request_url
-        url = "#{request.protocol}#{request.host}"
-
-        unless [80, 443].include?(request.port)
-          url << ":#{request.port}"
-        end
-
-        unless request.fullpath[0] == SLASH
-          url << SLASH
-        end
-
-        url << request.fullpath
-      end
-
-      def airbrake_current_user
-        user = fetch_user
-
-        if user
-          Airbrake.configuration.user_attributes.map(&:to_sym).inject({}) do |hsh, attr|
-            begin
-              hsh[attr] = user.send(attr) if user.respond_to? attr
-              hsh
-            rescue
-              hsh
-            end
-          end
-        else
-          {}
-        end
-      end
-
-      def fetch_user
-        if defined?(current_user)
-          current_user
-        elsif defined?(current_member)
-          current_member
-        else
-          nil
-        end
-      rescue
-        nil
-      ensure
-        # The Airbrake middleware is first in the chain, before ActiveRecord::ConnectionAdapters::ConnectionManagement
-        # kicks in to do its thing. This can cause the connection pool to run out of connections.
-        if defined?(ActiveRecord::Base) && ActiveRecord::Base.respond_to?(:clear_active_connections!)
-          ActiveRecord::Base.clear_active_connections!
-        end
-      end
-    end
-  end
-end

data/lib/airbrake/rails/error_lookup.rb

@@ -1,35 +0,0 @@
-module Airbrake
-  module Rails
-    module ErrorLookup
-
-      # Sets up an alias chain to catch exceptions when Rails does
-      def self.included(base) #:nodoc:
-        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
-
-      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/middleware.rb

@@ -1,63 +0,0 @@
-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)
-        begin
-          response = @app.call(env)
-        rescue Exception => exception
-          env['airbrake.error_id'] = notify_airbrake(env, exception)
-          raise exception
-        end
-
-        if framework_exception = env["action_dispatch.exception"]
-          env["airbrake.error_id"] = notify_airbrake(env, framework_exception)
-        end
-
-        response
-      end
-
-      private
-
-      def controller(env)
-        env["action_controller.instance"]
-      end
-
-      def after_airbrake_handler(env, exception)
-        if controller(env).respond_to?(:rescue_action_in_public_without_airbrake)
-          controller(env).rescue_action_in_public_without_airbrake(exception)
-        end
-      end
-
-      def notify_airbrake(env, exception)
-        unless ignored_user_agent? env
-          error_id = Airbrake.notify_or_ignore(exception, request_data(env))
-          after_airbrake_handler(env, exception)
-          error_id
-        end
-      end
-
-      def request_data(env)
-        if controller(env).respond_to?(:airbrake_request_data)
-          controller(env).airbrake_request_data
-        else
-          {:rack_env => env}
-        end
-      end
-
-      def ignored_user_agent?(env)
-        true if Airbrake.
-          configuration.
-          ignore_user_agent.
-          flatten.
-          any? { |ua| ua === env['HTTP_USER_AGENT'] }
-      end
-    end
-  end
-end

data/lib/airbrake/rails3_tasks.rb

@@ -1,126 +0,0 @@
-require 'airbrake'
-require File.join(File.dirname(__FILE__), 'shared_tasks')
-
-def stub_rake_exception_handling!
-  # Override error handling in Rake so we don't clutter STDERR
-  # with unnecesarry stack trace
-  Rake.application.instance_eval do
-    class << self
-      def display_error_message_silent(exception)
-        puts exception
-      end
-      alias_method :display_error_message_old, :display_error_message
-      alias_method :display_error_message, :display_error_message_silent
-    end
-  end
-end
-
-def unstub_rake_exception_handling!
-  # Turns Rake exception handling back to normal
-  Rake.application.instance_eval do
-    class << self
-      def display_error_message_silent(exception)
-        display_error_message_old(exception)
-      end
-    end
-  end
-end
-
-namespace :airbrake do
-  desc "Verify your gem installation by sending a test exception to the airbrake service"
-  task :test => [:environment] do
-
-    stub_rake_exception_handling!
-
-    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
-
-    # 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
-    # with stack trace from Rails
-    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:"
-    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, "\nTesting airbrake via \"rake airbrake:test\"."\
-                                   " If you can see this, it works."
-      end
-
-      # Ensure we actually have an action to go to.
-      def verify; end
-
-      def exception_class
-        exception_name = ENV['EXCEPTION'] || "AirbrakeTestingException"
-        Object.const_get(exception_name)
-      rescue
-        Object.const_set(exception_name, Class.new(Exception))
-      end
-    end
-
-    Rails.application.routes.draw do
-      get 'verify' => 'application#verify', :as => 'verify', :via => :get
-    end
-
-    puts 'Processing request.'
-
-    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")
-    env['REMOTE_ADDR'] = '127.0.0.1'
-
-    Rails.application.call(env)
-
-    wait_for_threads if defined? GirlFriday
-
-    unstub_rake_exception_handling!
-  end
-end
-