airbrake 4.3.8 → 5.0.0

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/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/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
-

data/lib/airbrake/railtie.rb

@@ -1,46 +0,0 @@
-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'
-    end
-
-    initializer "airbrake.middleware" do |app|
-
-      middleware = if defined?(ActionDispatch::DebugExceptions)
-        # Rails >= 3.2.0
-        "ActionDispatch::DebugExceptions"
-      else
-        # Rails < 3.2.0
-        "ActionDispatch::ShowExceptions"
-      end
-
-      app.config.middleware.insert_after middleware,
-        "Airbrake::Rails::Middleware"
-
-      app.config.middleware.insert 0, "Airbrake::UserInformer"
-    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/controller_methods'
-
-        include Airbrake::Rails::ControllerMethods
-      end
-    end
-  end
-end

data/lib/airbrake/rake_handler.rb

@@ -1,75 +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(exception)
-    if Airbrake.sender && Airbrake.configuration &&
-        (Airbrake.configuration.rescue_rake_exceptions ||
-          (Airbrake.configuration.rescue_rake_exceptions===nil && !self.tty_output?))
-
-      Airbrake.notify_or_ignore(exception,
-                                :component => 'rake',
-                                :action    => reconstruct_command_line,
-                                :cgi_data  => environment_info,
-                                :ignore    => Airbrake.configuration.ignore_rake)
-    end
-
-    display_error_message_without_airbrake(exception)
-  end
-
-  def reconstruct_command_line
-    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

data/lib/airbrake/response.rb

@@ -1,29 +0,0 @@
-module Airbrake
-  class Response
-    def self.pretty_format(xml_body)
-      new(xml_body)
-    rescue
-      xml_body
-    end
-
-    def to_s
-      output = "\n"
-      output = "UUID: #{@id}"
-      output << "\n"
-      output << "URL:  #{@url}"
-      output
-    end
-
-    private
-
-    def initialize(xml_body)
-      @xml_body = xml_body
-      @url      = parse_tag("url")
-      @id       = parse_tag("id")
-    end
-
-    def parse_tag(name)
-      @xml_body.match(%r{<#{name}[^>]*>(.*?)</#{name}>})[1]
-    end
-  end
-end

data/lib/airbrake/sender.rb

@@ -1,213 +0,0 @@
-module Airbrake
-  # Sends out the notice to Airbrake
-  class Sender
-
-    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,
-                   EOFError,
-                   Net::HTTPBadResponse,
-                   Net::HTTPHeaderSyntaxError,
-                   Net::ProtocolError,
-                   Errno::ECONNREFUSED,
-                   OpenSSL::SSL::SSLError].freeze
-
-    def initialize(options = {})
-      [ :proxy_host,
-        :proxy_port,
-        :proxy_user,
-        :proxy_pass,
-        :protocol,
-        :host,
-        :port,
-        :secure,
-        :use_system_ssl_cert_chain,
-        :http_open_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 = prepare_notice(notice)
-      http = setup_http_connection
-
-      response = begin
-                   http.post(request_uri,
-                             data,
-                             headers)
-                 rescue *HTTP_ERRORS => e
-                   log :level => :error,
-                       :message => "Unable to contact the Airbrake server. HTTP Error=#{e}"
-                   nil
-                 end
-
-      case response
-      when Net::HTTPSuccess then
-        log :level => :info,
-            :message => "Success: #{response.class}",
-            :response => response
-      else
-        log :level => :error,
-            :message => "Failure: #{response.class}",
-            :response => response,
-            :notice => notice
-      end
-
-      if response && response.respond_to?(:body)
-        error_id = response.body.match(%r{<id[^>]*>(.*?)</id>})
-        error_id[1] if error_id
-      end
-    rescue => e
-      log :level => :error,
-        :message => "[Airbrake::Sender#send_to_airbrake] Cannot send notification. Error: #{e.class}" +
-        " - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}"
-
-      nil
-    end
-
-    attr_reader :proxy_host,
-                :proxy_port,
-                :proxy_user,
-                :proxy_pass,
-                :protocol,
-                :host,
-                :port,
-                :secure,
-                :use_system_ssl_cert_chain,
-                :http_open_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(api_url)
-    end
-
-    def log(opts = {})
-      (opts[:logger] || logger).send(opts[:level], LOG_PREFIX + opts[:message])
-      Airbrake.report_environment_info
-      Airbrake.report_response_body(opts[:response].body) if opts[:response] && opts[:response].respond_to?(:body)
-      Airbrake.report_notice(opts[:notice]) if opts[:notice]
-    end
-
-    def logger
-      Airbrake.logger
-    end
-
-    def setup_http_connection
-      http =
-        Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass).
-        new(url.host, url.port)
-
-      http.read_timeout = http_read_timeout
-      http.open_timeout = http_open_timeout
-
-      if secure?
-        http.use_ssl     = true
-
-        http.ca_file      = Airbrake.configuration.ca_bundle_path
-        http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
-      else
-        http.use_ssl     = false
-      end
-
-      http
-    rescue => e
-      log :level => :error,
-          :message => "[Airbrake::Sender#setup_http_connection] Failure initializing the HTTP connection.\n" +
-                      "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 =~ /\S/
-    end
-
-    # Use request_uri[0] to keep the query since it contains the API_KEY.
-    #
-    # [0] http://ruby-doc.org/stdlib-2.2.2/libdoc/uri/rdoc/URI/HTTP.html#method-i-request_uri
-    def request_uri
-      url.respond_to?(:request_uri) ? url.request_uri : url
-    end
-  end
-
-  class CollectingSender < Sender
-    # Used when test mode is enabled, to store the last XML notice locally
-
-    attr_writer :last_notice_path
-
-    def last_notice
-      File.read last_notice_path
-    end
-
-    def last_notice_path
-      File.expand_path(File.join("..", "..", "..", "resources", "notice.xml"), __FILE__)
-    end
-
-    def send_to_airbrake(notice)
-      data = prepare_notice(notice)
-
-      notices_file = File.open(last_notice_path, "w") do |file|
-        file.puts data
-      end
-
-      super(notice)
-    ensure
-      notices_file.close if notices_file
-    end
-  end
-end

data/lib/airbrake/shared_tasks.rb

@@ -1,59 +0,0 @@
-namespace :airbrake do
-  desc "Notify Airbrake of a new deploy."
-  task :deploy do
-    require 'airbrake_tasks'
-
-    if defined?(Rails.root)
-      initializer_file = Rails.root.join('config', 'initializers','airbrake.rb')
-
-      if initializer_file.exist?
-        load initializer_file
-      else
-        Rake::Task[:environment].invoke
-      end
-    end
-
-    AirbrakeTasks.deploy(:rails_env      => ENV['TO'],
-                         :scm_revision   => ENV['REVISION'],
-                         :scm_repository => ENV['REPO'],
-                         :local_username => ENV['USER'],
-                         :dry_run        => ENV['DRY_RUN'])
-  end
-
-  task :log_stdout do
-    require 'logger'
-    RAILS_DEFAULT_LOGGER = Logger.new(STDOUT)
-  end
-
-  namespace :heroku do
-    desc "Install Heroku deploy notifications addon"
-    task :add_deploy_notification => [:environment] do
-
-      def get_heroku_vars
-        config = `heroku config --shell`
-        array_of_vars = config.split.map do |var|
-          var.partition("=").tap {|part| part.delete_at(1)}
-        end.flatten
-        @heroku_vars = Hash[*array_of_vars]
-      end
-
-      get_heroku_vars
-
-      heroku_rails_env = @heroku_vars["RAILS_ENV"]        || ENV["RAILS_ENV"] || "production"
-      heroku_api_key   = @heroku_vars["AIRBRAKE_API_KEY"] || Airbrake.configuration.api_key || ENV["AIRBRAKE_API_KEY"]
-      heroku_app       = ENV["HEROKU_APP"]
-      repo             = `git config --get remote.origin.url` || ENV["REPO"]
-
-      command = %Q(heroku addons:add deployhooks:http --url="http://airbrake.io/deploys.txt?api_key=#{heroku_api_key})
-      command << "&deploy[local_username]={{user}}"
-      command << "&deploy[scm_revision]={{head_long}}"
-      command << "&deploy[rails_env]=#{heroku_rails_env}"  if heroku_rails_env
-      command << "&deploy[scm_repository]=#{repo}"         if repo
-      command << '"'
-      command << " --app=#{heroku_app}"                    if heroku_app
-
-      puts "\nRunning:\n#{command}\n"
-      puts `#{command}`
-    end
-  end
-end

data/lib/airbrake/sidekiq.rb

@@ -1,8 +0,0 @@
-gem 'sidekiq', '>= 3.0'
-require 'sidekiq'
-
-Sidekiq.configure_server do |config|
-  config.error_handlers << lambda do |exception, context|
-    Airbrake.notify_or_ignore(exception, :parameters => context)
-  end
-end