airbrakeV4rails5 4.3.8

data/lib/airbrake/railtie.rb

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

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

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

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

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

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

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