airbrakeV4rails5 4.3.8

data/lib/airbrake/rails.rb

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

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

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

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

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

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