cloudtrapper 0.0.2.pre

data/lib/cloudtrapper/rails3_tasks.rb

@@ -0,0 +1,85 @@
+require 'cloudtrapper'
+require File.join(File.dirname(__FILE__), 'shared_tasks')
+
+namespace :cloudtrapper do
+  desc "Verify your gem installation by sending a test exception to the cloudtrapper service"
+  task :test => [:environment] do
+    Rails.logger = defined?(ActiveSupport::TaggedLogging) ?
+      ActiveSupport::TaggedLogging.new(Logger.new(STDOUT)) :
+      Logger.new(STDOUT)
+
+    Rails.logger.level = Logger::DEBUG
+    Cloudtrapper.configure(true) do |config|
+      config.logger = Rails.logger
+    end
+
+    require './app/controllers/application_controller'
+
+    class CloudtrapperTestingException < RuntimeError; end
+
+    unless Cloudtrapper.configuration.api_key
+      puts "Cloudtrapper needs an API key configured! Check the README to see how to add it."
+      exit
+    end
+
+    Cloudtrapper.configuration.development_environments = []
+
+    puts "Configuration:"
+    Cloudtrapper.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_cloudtrapper
+      def test_cloudtrapper
+        puts "Raising '#{exception_class.name}' to simulate application failure."
+        raise exception_class.new, 'Testing cloudtrapper via "rake cloudtrapper: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'] || "CloudtrapperTestingException"
+        Object.const_get(exception_name)
+      rescue
+        Object.const_set(exception_name, Class.new(Exception))
+      end
+
+      def logger
+        nil
+      end
+    end
+    class CloudtrapperVerificationController < ApplicationController; end
+
+    Rails.application.routes_reloader.execute_if_updated
+    Rails.application.routes.draw do
+      match 'verify' => 'application#verify', :as => 'verify'
+    end
+
+    puts 'Processing request.'
+    env = Rack::MockRequest.env_for("/verify")
+
+    Rails.application.call(env)
+  end
+end
+

data/lib/cloudtrapper/railtie.rb

@@ -0,0 +1,48 @@
+require 'cloudtrapper'
+require 'rails'
+
+module Cloudtrapper
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      require 'cloudtrapper/rake_handler'
+      require "cloudtrapper/rails3_tasks"
+    end
+
+    initializer "cloudtrapper.use_rack_middleware" do |app|
+      app.config.middleware.insert 0, "Cloudtrapper::UserInformer"
+      app.config.middleware.insert_after "Cloudtrapper::UserInformer","Cloudtrapper::Rack"
+    end
+
+    config.after_initialize do
+      Cloudtrapper.configure(true) do |config|
+        config.logger           ||= ::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 'cloudtrapper/rails/javascript_notifier'
+        require 'cloudtrapper/rails/controller_methods'
+
+        include Cloudtrapper::Rails::JavascriptNotifier
+        include Cloudtrapper::Rails::ControllerMethods
+      end
+
+      if defined?(::ActionDispatch::DebugExceptions)
+        # We should catch the exceptions in ActionDispatch::DebugExceptions in Rails 3.2.x.
+        #
+        require 'cloudtrapper/rails/middleware/exceptions_catcher'
+        ::ActionDispatch::DebugExceptions.send(:include,Cloudtrapper::Rails::Middleware::ExceptionsCatcher)
+      elsif defined?(::ActionDispatch::ShowExceptions)
+        # ActionDispatch::DebugExceptions is not defined in Rails 3.0.x and 3.1.x so
+        # catch the exceptions in ShowExceptions.
+        #
+        require 'cloudtrapper/rails/middleware/exceptions_catcher'
+        ::ActionDispatch::ShowExceptions.send(:include,Cloudtrapper::Rails::Middleware::ExceptionsCatcher)
+      end
+    end
+  end
+end

data/lib/cloudtrapper/rake_handler.rb

@@ -0,0 +1,66 @@
+# Patch Rake::Application to handle errors with Cloudtrapper
+module Cloudtrapper::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_cloudtrapper, :display_error_message
+      alias_method :display_error_message, :display_error_message_with_cloudtrapper
+    end
+  end
+
+  def display_error_message_with_cloudtrapper(ex)
+    if Cloudtrapper.sender && Cloudtrapper.configuration &&
+        (Cloudtrapper.configuration.rescue_rake_exceptions ||
+          (Cloudtrapper.configuration.rescue_rake_exceptions===nil && !self.tty_output?))
+
+      Cloudtrapper.notify_or_ignore(ex, :component => reconstruct_command_line, :cgi_data => ENV)
+    end
+
+    display_error_message_without_cloudtrapper(ex)
+  end
+
+  def reconstruct_command_line
+    "rake #{ARGV.join( ' ' )}"
+  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 Cloudtrapper::RakeHandler
+  end
+end
+

data/lib/cloudtrapper/sender.rb

@@ -0,0 +1,116 @@
+module Cloudtrapper
+  # Sends out the notice to Cloudtrapper
+  class Sender
+
+    NOTICES_URI = '/api/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 Cloudtrapper for processing.
+    #
+    # @param [String] data The XML notice to be sent off
+    def send_to_cloudtrapper(data)
+      http = setup_http_connection
+
+      response = begin
+                   http.post(url.path, data, HEADERS)
+                 rescue *HTTP_ERRORS => e
+                   log :error, "Unable to contact the Cloudtrapper server. HTTP Error=#{e}"
+                   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{<id[^>]*>(.*?)</id>})
+        error_id[1] if error_id
+      end
+    rescue => e
+      log :error, "[Cloudtrapper::Sender#send_to_cloudtrapper] 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(level, message, response = nil)
+      logger.send level, LOG_PREFIX + message if logger
+      Cloudtrapper.report_environment_info
+      Cloudtrapper.report_response_body(response.body) if response && response.respond_to?(:body)
+    end
+
+    def logger
+      Cloudtrapper.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      = Cloudtrapper.configuration.ca_bundle_path
+        http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
+      else
+        http.use_ssl     = false
+      end
+
+      http
+    rescue => e
+      log :error, "[Cloudtrapper::Sender#setup_http_connection] Failure initializing the HTTP connection.\nError: #{e.class} - #{e.message}\nBacktrace:\n#{e.backtrace.join("\n\t")}"
+      raise e
+    end
+
+  end
+end

data/lib/cloudtrapper/shared_tasks.rb

@@ -0,0 +1,36 @@
+namespace :cloudtrapper do
+  desc "Notify Cloudtrapper of a new deploy."
+  task :deploy => :environment do
+    require 'cloudtrapper_tasks'
+    CloudtrapperTasks.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|cloudtrapper)_api_key").split.find {|x| x unless x.blank?} ||
+        Cloudtrapper.configuration.api_key
+
+      command = %Q(heroku addons:add deployhooks:http --url="http://cloudtrapper.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/cloudtrapper/tasks.rb

@@ -0,0 +1,83 @@
+require 'cloudtrapper'
+require File.join(File.dirname(__FILE__), 'shared_tasks')
+
+namespace :cloudtrapper do
+  desc "Verify your gem installation by sending a test exception to the cloudtrapper service"
+  task :test => ['cloudtrapper: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 CloudtrapperTestingException < RuntimeError; end
+
+    unless Cloudtrapper.configuration.api_key
+      puts "Cloudtrapper needs an API key configured! Check the README to see how to add it."
+      exit
+    end
+
+    Cloudtrapper.configuration.development_environments = []
+
+    catcher = Cloudtrapper::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:"
+    Cloudtrapper.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_cloudtrapper
+      def test_cloudtrapper
+        puts "Raising '#{exception_class.name}' to simulate application failure."
+        raise exception_class.new, 'Testing cloudtrapper via "rake cloudtrapper: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'] || "CloudtrapperTestingException"
+        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 CloudtrapperVerificationController < ApplicationController; end
+
+    puts 'Processing request.'
+    request = ActionController::TestRequest.new("REQUEST_URI" => "/cloudtrapper_verification_controller")
+    response = ActionController::TestResponse.new
+    CloudtrapperVerificationController.new.process(request, response)
+  end
+end
+

data/lib/cloudtrapper/user_informer.rb

@@ -0,0 +1,27 @@
+module Cloudtrapper
+  class UserInformer
+    def initialize(app)
+      @app = app
+    end
+
+    def replacement(with)
+      Cloudtrapper.configuration.user_information.gsub(/\{\{\s*error_id\s*\}\}/, with.to_s)
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      if env['cloudtrapper.error_id'] && Cloudtrapper.configuration.user_information
+        new_body = []
+        replace  = replacement(env['cloudtrapper.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/cloudtrapper/version.rb

@@ -0,0 +1,3 @@
+module Cloudtrapper
+  VERSION = "0.0.2.pre".freeze
+end

data/lib/cloudtrapper.rb

@@ -0,0 +1,155 @@
+require 'net/http'
+require 'net/https'
+require 'rubygems'
+begin
+  require 'active_support'
+  require 'active_support/core_ext'
+rescue LoadError
+  require 'activesupport'
+  require 'activesupport/core_ext'
+end
+require 'cloudtrapper/version'
+require 'cloudtrapper/configuration'
+require 'cloudtrapper/notice'
+require 'cloudtrapper/sender'
+require 'cloudtrapper/backtrace'
+require 'cloudtrapper/rack'
+require 'cloudtrapper/user_informer'
+
+require 'cloudtrapper/railtie' if defined?(Rails::Railtie)
+
+module Cloudtrapper
+  API_VERSION = "2.2"
+  LOG_PREFIX = "** [Cloudtrapper] "
+
+  HEADERS = {
+    'Content-type'             => 'text/xml',
+    'Accept'                   => 'text/xml, application/xml'
+  }
+
+  class << self
+    # The sender object is responsible for delivering formatted data to the Cloudtrapper server.
+    # Must respond to #send_to_cloudtrapper. See Cloudtrapper::Sender.
+    attr_accessor :sender
+
+    # A Cloudtrapper configuration object. Must act like a hash and return sensible
+    # values for all Cloudtrapper configuration options. See Cloudtrapper::Configuration.
+    attr_writer :configuration
+
+    # Tell the log that the Notifier is good to go
+    def report_ready
+      write_verbose_log("Notifier #{VERSION} ready to catch errors")
+    end
+
+    # Prints out the environment info to the log for debugging help
+    def report_environment_info
+      write_verbose_log("Environment Info: #{environment_info}")
+    end
+
+    # Prints out the response body from Cloudtrapper for debugging help
+    def report_response_body(response)
+      write_verbose_log("Response from Cloudtrapper: \n#{response}")
+    end
+
+    # Returns the Ruby version, Rails version, and current Rails environment
+    def environment_info
+      info = "[Ruby: #{RUBY_VERSION}]"
+      info << " [#{configuration.framework}]" if configuration.framework
+      info << " [Env: #{configuration.environment_name}]" if configuration.environment_name
+    end
+
+    # Writes out the given message to the #logger
+    def write_verbose_log(message)
+      logger.info LOG_PREFIX + message if logger
+    end
+
+    # Look for the Rails logger currently defined
+    def logger
+      self.configuration.logger
+    end
+
+    # Call this method to modify defaults in your initializers.
+    #
+    # @example
+    #   Cloudtrapper.configure do |config|
+    #     config.api_key = '1234567890abcdef'
+    #     config.secure  = false
+    #   end
+    def configure(silent = false)
+      yield(configuration)
+      self.sender = Sender.new(configuration)
+      report_ready unless silent
+      self.sender
+    end
+
+    # The configuration object.
+    # @see Cloudtrapper.configure
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Sends an exception manually using this method, even when you are not in a controller.
+    #
+    # @param [Exception] exception The exception you want to notify Cloudtrapper about.
+    # @param [Hash] opts Data that will be sent to Cloudtrapper.
+    #
+    # @option opts [String] :api_key The API key for this project. The API key is a unique identifier that Cloudtrapper uses for identification.
+    # @option opts [String] :error_message The error returned by the exception (or the message you want to log).
+    # @option opts [String] :backtrace A backtrace, usually obtained with +caller+.
+    # @option opts [String] :rack_env The Rack environment.
+    # @option opts [String] :session The contents of the user's session.
+    # @option opts [String] :environment_name The application environment name.
+    def notify(exception, opts = {})
+      send_notice(build_notice_for(exception, opts))
+    end
+
+    # Sends the notice unless it is one of the default ignored exceptions
+    # @see Cloudtrapper.notify
+    def notify_or_ignore(exception, opts = {})
+      notice = build_notice_for(exception, opts)
+      send_notice(notice) unless notice.ignore?
+    end
+
+    def build_lookup_hash_for(exception, options = {})
+      notice = build_notice_for(exception, options)
+
+      result = {}
+      result[:action]           = notice.action      rescue nil
+      result[:component]        = notice.component   rescue nil
+      result[:error_class]      = notice.error_class if notice.error_class
+      result[:environment_name] = 'production'
+
+      unless notice.backtrace.lines.empty?
+        result[:file]        = notice.backtrace.lines.first.file
+        result[:line_number] = notice.backtrace.lines.first.number
+      end
+
+      result
+    end
+
+    private
+
+    def send_notice(notice)
+      if configuration.public?
+        sender.send_to_cloudtrapper(notice.to_xml)
+      end
+    end
+
+    def build_notice_for(exception, opts = {})
+      exception = unwrap_exception(exception)
+      opts = opts.merge(:exception => exception) if exception.is_a?(Exception)
+      opts = opts.merge(exception.to_hash) if exception.respond_to?(:to_hash)
+      Notice.new(configuration.merge(opts))
+    end
+
+    def unwrap_exception(exception)
+      if exception.respond_to?(:original_exception)
+        exception.original_exception
+      elsif exception.respond_to?(:continued_exception)
+        exception.continued_exception
+      else
+        exception
+      end
+    end
+  end
+end

data/lib/cloudtrapper_tasks.rb

@@ -0,0 +1,65 @@
+require 'net/http'
+require 'uri'
+require 'active_support'
+
+# Capistrano tasks for notifying Cloudtrapper of deploys
+module CloudtrapperTasks
+
+  # Alerts Cloudtrapper of a deploy.
+  #
+  # @param [Hash] opts Data about the deploy that is set to Cloudtrapper
+  #
+  # @option opts [String] :api_key Api key of you Cloudtrapper 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) || Cloudtrapper.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 = Cloudtrapper.configuration.host || 'api.cloudtrapper.io'
+    port = Cloudtrapper.configuration.port
+
+    proxy = Net::HTTP.Proxy(Cloudtrapper.configuration.proxy_host,
+                            Cloudtrapper.configuration.proxy_port,
+                            Cloudtrapper.configuration.proxy_user,
+                            Cloudtrapper.configuration.proxy_pass)
+    http = proxy.new(host, port)
+
+
+
+    # Handle Security
+    if Cloudtrapper.configuration.secure?
+      http.use_ssl      = true
+      http.ca_file      = Cloudtrapper.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
+