airbrake 3.0.rc1

data/lib/airbrake/sender.rb

@@ -0,0 +1,83 @@
+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, :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 [String] data The XML notice to be sent off
+    def send_to_airbrake(data)
+      logger.debug { "Sending request to #{url.to_s}:\n#{data}" } if logger
+
+      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     = OpenSSL::X509::DEFAULT_CERT_FILE if File.exist?(OpenSSL::X509::DEFAULT_CERT_FILE)
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      else
+        http.use_ssl     = false
+      end
+
+      response = begin
+                   http.post(url.path, data, HEADERS)
+                 rescue *HTTP_ERRORS => e
+                   log :error, "Timeout while contacting the Airbrake server."
+                   nil
+                 end
+
+      case response
+      when Net::HTTPSuccess then
+        log :info, "Success: #{response.class}", response
+      else
+        log :error, "Failure: #{response.class}", response
+      end
+
+      if response && response.respond_to?(:body)
+        error_id = response.body.match(%r{<error-id[^>]*>(.*?)</error-id>})
+        error_id[1] if error_id
+      end
+    end
+
+    private
+
+    attr_reader :proxy_host, :proxy_port, :proxy_user, :proxy_pass, :protocol,
+      :host, :port, :secure, :http_open_timeout, :http_read_timeout
+
+    def url
+      URI.parse("#{protocol}://#{host}:#{port}").merge(NOTICES_URI)
+    end
+
+    def log(level, message, response = nil)
+      logger.send level, LOG_PREFIX + message if logger
+      Airbrake.report_environment_info
+      Airbrake.report_response_body(response.body) if response && response.respond_to?(:body)
+    end
+
+    def logger
+      Airbrake.logger
+    end
+
+  end
+end

data/lib/airbrake/shared_tasks.rb

@@ -0,0 +1,30 @@
+namespace :airbrake do
+  desc "Notify Airbrake of a new deploy."
+  task :deploy => :environment do
+    require 'airbrake_tasks'
+    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
+      heroku_api_key = `heroku console 'puts ENV[%{AIRBRAKE_API_KEY}]' | head -n 1`.strip
+      heroku_rails_env = `heroku console 'puts RAILS_ENV' | head -n 1`.strip
+
+      command = %Q(heroku addons:add deployhooks:http url="http://airbrakeapp.com/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

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

@@ -0,0 +1,25 @@
+module Airbrake
+  class UserInformer
+    def initialize(app)
+      @app = app
+    end
+
+    def replacement(with)
+      @replacement ||= 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 = []
+        body.each do |chunk|
+          new_body << chunk.gsub("<!-- AIRBRAKE ERROR -->", replacement(env['airbrake.error_id']))
+        end
+        headers['Content-Length'] = new_body.sum(&:length).to_s
+        body = new_body
+      end
+      [status, headers, body]
+    end
+  end
+end
+

data/lib/airbrake/version.rb

@@ -0,0 +1,3 @@
+module Airbrake
+  VERSION = "3.0.rc1".freeze
+end

data/lib/airbrake_tasks.rb

@@ -0,0 +1,50 @@
+require 'net/http'
+require 'uri'
+require 'active_support'
+
+# 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] :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 = {})
+    if Airbrake.configuration.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' => opts.delete(:api_key) ||
+                             Airbrake.configuration.api_key}
+    opts.each {|k,v| params["deploy[#{k}]"] = v }
+
+    url = URI.parse("http://#{Airbrake.configuration.host || 'airbrakeapp.com'}/deploys.txt")
+
+    proxy = Net::HTTP.Proxy(Airbrake.configuration.proxy_host,
+                            Airbrake.configuration.proxy_port,
+                            Airbrake.configuration.proxy_user,
+                            Airbrake.configuration.proxy_pass)
+
+    if dry_run
+      puts url, params.inspect
+      return true
+    else
+      response = proxy.post_form(url, params)
+
+      puts response.body
+      return Net::HTTPSuccess === response
+    end
+  end
+end
+

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

@@ -0,0 +1,96 @@
+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['AIRBRAKE_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['AIRBRAKE_API_KEY'] = heroku_api_key
+    if ENV['AIRBRAKE_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['AIRBRAKE_API_KEY']}'"
+    end
+  end
+
+  def heroku_api_key
+    app = options[:app] ? " --app #{options[:app]}" : ''
+    `heroku console#{app} 'puts ENV[%{AIRBRAKE_API_KEY}]'`.split("\n").first
+  end
+
+  def heroku?
+    options[:heroku] ||
+      system("grep AIRBRAKE_API_KEY config/initializers/airbrake.rb") ||
+      system("grep AIRBRAKE_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

data/lib/templates/javascript_notifier.erb

@@ -0,0 +1,13 @@
+<%= javascript_tag %Q{
+    var notifierJsScheme = (("https:" == document.location.protocol) ? "https://" : "http://");
+    document.write(unescape("%3Cscript src='" + notifierJsScheme + "#{host}/javascripts/notifier.js' type='text/javascript'%3E%3C/script%3E"));
+  }
+%>
+
+<%= javascript_tag %Q{
+    Airbrake.setKey('#{api_key}');
+    Airbrake.setHost('#{host}');
+    Airbrake.setEnvironment('#{environment}');
+    Airbrake.setErrorDefaults({ url: "#{escape_javascript url}", component: "#{controller_name}", action: "#{action_name}" });
+  } 
+%>

data/lib/templates/rescue.erb

@@ -0,0 +1,91 @@
+<script type="text/javascript">
+var Airbrake = {
+  host    : <%= host.to_json %>,
+  api_key : <%= api_key.to_json %>,
+  notice  : <%= notice.to_json %>,
+  message : 'This error exists in production!',
+
+  initialize: function() {
+    if (this.initialized) {
+      return;
+    } else {
+      this.initialized = true;
+    }
+
+    var data = [];
+
+    for (var key in this.notice) {
+      data[data.length] = 'notice[' + key + ']=' + this.notice[key];
+    }
+
+    data[data.length] = 'notice[api_key]=' + this.api_key;
+    data[data.length] = 'callback=Airbrake.onSuccess';
+    data[data.length] = '_=' + (new Date()).getTime();
+
+    var head = document.getElementsByTagName('head')[0];
+    var done = false;
+
+    var
+    script = document.createElement('script');
+    script.src  = 'http://' + this.host + '/notices_api/v1/notices/exist?' +
+                  data.join('&');
+    script.type = 'text/javascript';
+    script.onload = script.onreadystatechange = function(){
+      if (!done && (!this.readyState ||
+          this.readyState == 'loaded' || this.readyState == 'complete')) {
+
+        done = true;
+
+        // Handle memory leak in IE. (via jQuery)
+        script.onload = script.onreadystatechange = null;
+        head.removeChild(script);
+      }
+    };
+
+    head.appendChild(script);
+  },
+
+  onSuccess: function(error) {
+    var body    = document.getElementsByTagName('body')[0];
+    var text    = document.createTextNode(this.message);
+    var element = document.createElement('a');
+
+    element.id   = 'airbrake';
+    element.href = 'http://' + error.subdomain + '.' + this.host +
+                   '/projects/' + error.project_id + '/errors/' + error.id;
+    element.appendChild(text);
+
+    body.insertBefore(element, body.firstChild);
+
+    var h1      = document.getElementsByTagName('h1')[0];
+    var pre     = document.getElementsByTagName('pre')[0];
+    var wrapper = document.createElement('div');
+
+    wrapper.id = 'wrapper';
+    wrapper.appendChild(h1);
+    wrapper.appendChild(pre);
+
+    body.insertBefore(wrapper, body.children[1]);
+  }
+};
+
+window.onload = function() {
+  Airbrake.initialize.apply(Hoptoad);
+};
+</script>
+
+<style type="text/css">
+#airbrake {
+  background: #FFF url(http://airbrakeapp.com/images/fell-off-the-toad.gif) no-repeat top right;
+  color: #F00;
+  padding: 45px 101px 45px 12px;
+  font-size: 14px;
+  font-weight: bold;
+  display: block;
+  float: right;
+}
+
+#wrapper {
+  padding-right: 360px;
+}
+</style>