airbrake 3.1.6 → 11.0.0

data/lib/airbrake/sender.rb

@@ -1,128 +0,0 @@
-module Airbrake
-  # Sends out the notice to Airbrake
-  class Sender
-
-    NOTICES_URI = '/notifier_api/v2/notices/'.freeze
-    HTTP_ERRORS = [Timeout::Error,
-                   Errno::EINVAL,
-                   Errno::ECONNRESET,
-                   EOFError,
-                   Net::HTTPBadResponse,
-                   Net::HTTPHeaderSyntaxError,
-                   Net::ProtocolError,
-                   Errno::ECONNREFUSED].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
-      ].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 = notice.respond_to?(:to_xml) ? notice.to_xml : notice
-      http = setup_http_connection
-
-      response = begin
-                   http.post(url.path, 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
-
-    alias_method :secure?, :secure
-    alias_method :use_system_ssl_cert_chain?, :use_system_ssl_cert_chain
-
-  private
-
-    def url
-      URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
-    end
-
-    def log(opts = {})
-      opts[:logger].send opts[:level], LOG_PREFIX + opts[:message] if opts[:logger]
-      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
-  end
-end

data/lib/airbrake/shared_tasks.rb

@@ -1,47 +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'],
-                        :api_key        => ENV['API_KEY'],
-                        :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 heroku_var(var)
-        `heroku config | grep -E "#{var.upcase}" | awk '{ print $3; }'`.strip
-      end
-
-      heroku_rails_env = heroku_var("rails_env")
-      heroku_api_key = heroku_var("(hoptoad|airbrake)_api_key").split.find {|x| x unless x.blank?} ||
-        Airbrake.configuration.api_key
-
-      command = %Q(heroku addons:add deployhooks:http --url="http://airbrake.io/deploys.txt?deploy[rails_env]=#{heroku_rails_env}&api_key=#{heroku_api_key}")
-
-      puts "\nRunning:\n#{command}\n"
-      puts `#{command}`
-    end
-  end
-end

data/lib/airbrake/tasks.rb

@@ -1,83 +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 => ['airbrake:log_stdout', :environment] do
-    RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
-
-    require 'action_controller/test_process'
-
-    Dir["app/controllers/application*.rb"].each { |file| require(File.expand_path(file)) } 
-
-    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 = []
-
-    catcher = Airbrake::Rails::ActionControllerCatcher
-    in_controller = ApplicationController.included_modules.include?(catcher)
-    in_base = ActionController::Base.included_modules.include?(catcher)
-    if !in_controller || !in_base
-      puts "Rails initialization did not occur"
-      exit
-    end
-
-    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"
-        exception_name.split("::").inject(Object){|klass, name| klass.const_get(name)}
-      rescue
-        Object.const_set(exception_name.gsub(/:+/, "_"), Class.new(Exception))
-      end
-
-      def logger
-        nil
-      end
-    end
-    class AirbrakeVerificationController < ApplicationController; end
-
-    puts 'Processing request.'
-    request = ActionController::TestRequest.new("REQUEST_URI" => "/airbrake_verification_controller")
-    response = ActionController::TestResponse.new
-    AirbrakeVerificationController.new.process(request, response)
-  end
-end
-

data/lib/airbrake/user_informer.rb

@@ -1,27 +0,0 @@
-module Airbrake
-  class UserInformer
-    def initialize(app)
-      @app = app
-    end
-
-    def replacement(with)
-      Airbrake.configuration.user_information.gsub(/\{\{\s*error_id\s*\}\}/, with.to_s)
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      if env['airbrake.error_id'] && Airbrake.configuration.user_information
-        new_body = []
-        replace  = replacement(env['airbrake.error_id'])
-        body.each do |chunk|
-          new_body << chunk.gsub("<!-- AIRBRAKE ERROR -->", replace)
-        end
-        body.close if body.respond_to?(:close)
-        headers['Content-Length'] = new_body.sum(&:bytesize).to_s
-        body = new_body
-      end
-      [status, headers, body]
-    end
-  end
-end
-

data/lib/airbrake_tasks.rb

@@ -1,64 +0,0 @@
-require 'net/http'
-require 'uri'
-
-# Capistrano tasks for notifying Airbrake of deploys
-module AirbrakeTasks
-
-  # Alerts Airbrake of a deploy.
-  #
-  # @param [Hash] opts Data about the deploy that is set to Airbrake
-  #
-  # @option opts [String] :api_key Api key of you Airbrake application
-  # @option opts [String] :rails_env Environment of the deploy (production, staging)
-  # @option opts [String] :scm_revision The given revision/sha that is being deployed
-  # @option opts [String] :scm_repository Address of your repository to help with code lookups
-  # @option opts [String] :local_username Who is deploying
-  def self.deploy(opts = {})
-    api_key = opts.delete(:api_key) || Airbrake.configuration.api_key
-    if api_key.blank?
-      puts "I don't seem to be configured with an API key.  Please check your configuration."
-      return false
-    end
-
-    if opts[:rails_env].blank?
-      puts "I don't know to which Rails environment you are deploying (use the TO=production option)."
-      return false
-    end
-
-    dry_run = opts.delete(:dry_run)
-    params = {'api_key' => api_key}
-    opts.each {|k,v| params["deploy[#{k}]"] = v }
-
-    host = Airbrake.configuration.host || 'api.airbrake.io'
-    port = Airbrake.configuration.port
-
-    proxy = Net::HTTP.Proxy(Airbrake.configuration.proxy_host,
-                            Airbrake.configuration.proxy_port,
-                            Airbrake.configuration.proxy_user,
-                            Airbrake.configuration.proxy_pass)
-    http = proxy.new(host, port)
-
-
-
-    # Handle Security
-    if Airbrake.configuration.secure?
-      http.use_ssl      = true
-      http.ca_file      = Airbrake.configuration.ca_bundle_path
-      http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
-    end
-
-    post = Net::HTTP::Post.new("/deploys.txt")
-    post.set_form_data(params)
-
-    if dry_run
-      puts http.inspect, params.inspect
-      return true
-    else
-      response = http.request(post)
-
-      puts response.body
-      return Net::HTTPSuccess === response
-    end
-  end
-end
-

data/lib/rails/generators/airbrake/airbrake_generator.rb

@@ -1,100 +0,0 @@
-require 'rails/generators'
-
-class AirbrakeGenerator < Rails::Generators::Base
-
-  class_option :api_key, :aliases => "-k", :type => :string, :desc => "Your Airbrake API key"
-  class_option :heroku, :type => :boolean, :desc => "Use the Heroku addon to provide your Airbrake API key"
-  class_option :app, :aliases => "-a", :type => :string, :desc => "Your Heroku app name (only required if deploying to >1 Heroku app)"
-
-  def self.source_root
-    @_airbrake_source_root ||= File.expand_path("../../../../../generators/airbrake/templates", __FILE__)
-  end
-
-  def install
-    ensure_api_key_was_configured
-    ensure_plugin_is_not_present
-    append_capistrano_hook
-    generate_initializer unless api_key_configured?
-    determine_api_key if heroku?
-    test_airbrake
-  end
-
-  private
-
-  def ensure_api_key_was_configured
-    if !options[:api_key] && !options[:heroku] && !api_key_configured?
-      puts "Must pass --api-key or --heroku or create config/initializers/airbrake.rb"
-      exit
-    end
-  end
-
-  def ensure_plugin_is_not_present
-    if plugin_is_present?
-      puts "You must first remove the airbrake plugin. Please run: script/plugin remove airbrake"
-      exit
-    end
-  end
-
-  def append_capistrano_hook
-    if File.exists?('config/deploy.rb') && File.exists?('Capfile')
-      append_file('config/deploy.rb', <<-HOOK)
-
-        require './config/boot'
-        require 'airbrake/capistrano'
-      HOOK
-    end
-  end
-
-  def api_key_expression
-    s = if options[:api_key]
-      "'#{options[:api_key]}'"
-    elsif options[:heroku]
-      "ENV['HOPTOAD_API_KEY']"
-    end
-  end
-
-  def generate_initializer
-    template 'initializer.rb', 'config/initializers/airbrake.rb'
-  end
-
-  def determine_api_key
-    puts "Attempting to determine your API Key from Heroku..."
-    ENV['HOPTOAD_API_KEY'] = heroku_api_key
-    if ENV['HOPTOAD_API_KEY'].blank?
-      puts "... Failed."
-      puts "WARNING: We were unable to detect the Airbrake API Key from your Heroku environment."
-      puts "Your Heroku application environment may not be configured correctly."
-      exit 1
-    else
-      puts "... Done."
-      puts "Heroku's Airbrake API Key is '#{ENV['HOPTOAD_API_KEY']}'"
-    end
-  end
-
-  def heroku_var(var,app_name = nil)
-    app = app_name ? "--app #{app_name}" : ''
-    `heroku config #{app} | grep -E "#{var.upcase}" | awk '{ print $3; }'`.strip
-  end
-
-  def heroku_api_key
-    heroku_var("(hoptoad|airbrake)_api_key",options[:app]).split.find {|x| x unless x.blank?}
-  end
-
-  def heroku?
-    options[:heroku] ||
-      system("grep HOPTOAD_API_KEY config/initializers/airbrake.rb") ||
-      system("grep HOPTOAD_API_KEY config/environment.rb")
-  end
-
-  def api_key_configured?
-    File.exists?('config/initializers/airbrake.rb')
-  end
-
-  def test_airbrake
-    puts run("rake airbrake:test --trace")
-  end
-
-  def plugin_is_present?
-    File.exists?('vendor/plugins/airbrake')
-  end
-end