airbrake 4.3.8 → 5.0.0.rc.1

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

data/lib/airbrake/sinatra.rb

@@ -1,40 +0,0 @@
-module Airbrake
-  # Middleware for Sinatra applications. Any errors raised by the upstream
-  # application will be delivered to Airbrake and re-raised.
-
-  # Synopsis:
-
-  #   require 'sinatra'
-  #   require 'airbrake'
-
-  #   Airbrake.configure do |config|
-  #     config.api_key = 'my api key'
-  #   end
-
-  #   use Airbrake::Sinatra
-
-  #   get '/' do
-  #     raise "Sinatra has left the building"
-  #   end
-  #
-  # Use a standard Airbrake.configure call to configure your api key.
-  class Sinatra < Rack
-
-    def initialize(app)
-      super
-      Airbrake.configuration.environment_name ||= environment_name(app)
-      Airbrake.configuration.framework        = "Sinatra: #{::Sinatra::VERSION}"
-    end
-
-    def framework_exception(env)
-      env['sinatra.error']
-    end
-
-    def environment_name(app)
-      "#{app.settings.environment}"
-    rescue
-      ENV["RACK_ENV"] || warn("[Airbrake] Couldn't determine environment name automatically. "\
-        "Please set your environment name manually by setting 'config.environment_name='.")
-    end
-  end
-end