cloudtrapper 0.0.2.pre

data/features/support/env.rb

@@ -0,0 +1,18 @@
+require 'active_support'
+require 'nokogiri'
+require 'rspec'
+
+PROJECT_ROOT     = File.expand_path(File.join(File.dirname(__FILE__), '..', '..')).freeze
+TEMP_DIR         = File.join(PROJECT_ROOT, 'tmp').freeze
+LOCAL_RAILS_ROOT = File.join(TEMP_DIR, 'rails_root').freeze
+BUILT_GEM_ROOT   = File.join(TEMP_DIR, 'built_gems').freeze
+LOCAL_GEM_ROOT   = File.join(TEMP_DIR, 'local_gems').freeze
+RACK_FILE        = File.join(TEMP_DIR, 'rack_app.rb').freeze
+
+Before do
+  FileUtils.mkdir_p(TEMP_DIR)
+  FileUtils.rm_rf(BUILT_GEM_ROOT)
+  FileUtils.rm_rf(LOCAL_RAILS_ROOT)
+  FileUtils.rm_f(RACK_FILE)
+  FileUtils.mkdir_p(BUILT_GEM_ROOT)
+end

data/features/support/matchers.rb

@@ -0,0 +1,35 @@
+RSpec::Matchers.define :have_content do |xpath, content|
+  match do |document|
+    @elements = document.search(xpath)
+
+    if @elements.empty?
+      false
+    else
+      element_with_content = document.at("#{xpath}[contains(.,'#{content}')]")
+
+      if element_with_content.nil?
+        @found = @elements.collect { |element| element.content }
+
+        false
+      else
+        true
+      end
+    end
+  end
+
+  failure_message_for_should do |document|
+    if @elements.empty?
+      "In XML:\n#{document}\nNo element at #{xpath}"
+    else
+      "In XML:\n#{document}\nGot content #{@found.inspect} at #{xpath} instead of #{content.inspect}"
+    end
+  end
+
+  failure_message_for_should_not do |document|
+    unless @elements.empty?
+      "In XML:\n#{document}\nExpcted no content #{content.inspect} at #{xpath}"
+    end
+  end
+end
+
+World(RSpec::Matchers)

data/features/support/rails.rb

@@ -0,0 +1,201 @@
+module RailsHelpers
+  def rails_root_exists?
+    File.exists?(environment_path)
+  end
+
+  def application_controller_filename
+    controller_filename = File.join(rails_root, 'app', 'controllers', "application_controller.rb")
+  end
+
+  def rails3?
+    rails_version =~ /^3/
+  end
+
+  def rails_root
+    LOCAL_RAILS_ROOT
+  end
+
+  def rails_uses_rack?
+    rails3? || rails_version =~ /^2\.3/
+  end
+
+  def rails_version
+    @rails_version ||= begin
+      if ENV["RAILS_VERSION"]
+        ENV["RAILS_VERSION"]
+      elsif bundler_manages_gems?
+        rails_version = open(gemfile_path).read.match(/gem.*rails["'].*["'](.+)["']/)[1]
+      else
+        environment_file = File.join(rails_root, 'config', 'environment.rb')
+        rails_version = `grep RAILS_GEM_VERSION #{environment_file}`.match(/[\d.]+/)[0]
+      end
+    end
+  end
+
+  def bundler_manages_gems?
+    File.exists?(gemfile_path)
+  end
+
+  def gemfile_path
+    gemfile = File.join(rails_root, 'Gemfile')
+  end
+
+  def rails_manages_gems?
+    rails_version =~ /^2\.[123]/
+  end
+
+  def rails_supports_initializers?
+    rails3? || rails_version =~ /^2\./
+  end
+
+  def rails_finds_generators_in_gems?
+    rails3? || rails_version =~ /^2\./
+  end
+
+  def version_string
+    ENV['RAILS_VERSION'] || `tail -n 1 SUPPORTED_RAILS_VERSIONS` # use latest version if ENV["RAILS_VERSION"] is undefined
+  end
+
+  def environment_path
+    File.join(rails_root, 'config', 'environment.rb')
+  end
+
+  def rakefile_path
+    File.join(rails_root, 'Rakefile')
+  end
+
+  def bundle_gem(gem_name, version = nil)
+    File.open(gemfile_path, 'a') do |file|
+      gem = "gem '#{gem_name}'"
+      gem += ", '#{version}'" if version
+      file.puts(gem)
+    end
+  end
+
+  def config_gem(gem_name, version = nil)
+    run     = "Rails::Initializer.run do |config|"
+    insert  = "  config.gem '#{gem_name}'"
+    insert += ", :version => '#{version}'" if version
+    content = File.read(environment_path)
+    content = "require 'thread'\n#{content}"
+    if content.sub!(run, "#{run}\n#{insert}")
+      File.open(environment_path, 'wb') { |file| file.write(content) }
+    else
+      raise "Couldn't find #{run.inspect} in #{environment_path}"
+    end
+  end
+
+  def config_gem_dependencies
+    insert = <<-END
+    if Gem::VERSION >= "1.3.6"
+      module Rails
+        class GemDependency
+          def requirement
+            r = super
+            (r == Gem::Requirement.default) ? nil : r
+          end
+        end
+      end
+    end
+    END
+    run     = "Rails::Initializer.run do |config|"
+    content = File.read(environment_path)
+    if content.sub!(run, "#{insert}\n#{run}")
+      File.open(environment_path, 'wb') { |file| file.write(content) }
+    else
+      raise "Couldn't find #{run.inspect} in #{environment_path}"
+    end
+  end
+
+  def require_thread
+    content = File.read(rakefile_path)
+    content = "require 'thread'\n#{content}"
+    File.open(rakefile_path, 'wb') { |file| file.write(content) }
+  end
+
+  def perform_request(uri, environment = 'production')
+    if rails3?
+      request_script = <<-SCRIPT
+        require File.expand_path('../config/environment', __FILE__)
+
+
+        env      = Rack::MockRequest.env_for(#{uri.inspect})
+        response = RailsRoot::Application.call(env)
+
+
+        response = response.last if response.last.is_a?(ActionDispatch::Response)
+
+        if response.is_a?(Array)
+          puts response.join
+        else
+          puts response.body
+        end
+      SCRIPT
+      File.open(File.join(rails_root, 'request.rb'), 'w') { |file| file.write(request_script) }
+      @terminal.cd(rails_root)
+      @terminal.run("ruby -rthread ./script/rails runner -e #{environment} request.rb")
+    elsif rails_uses_rack?
+      request_script = <<-SCRIPT
+        require File.expand_path('../config/environment', __FILE__)
+
+        env = Rack::MockRequest.env_for(#{uri.inspect})
+        app = Rack::Lint.new(ActionController::Dispatcher.new)
+
+        status, headers, body = app.call(env)
+
+        response = ""
+        if body.respond_to?(:to_str)
+          response << body
+        else
+          body.each { |part| response << part }
+        end
+
+        puts response
+      SCRIPT
+      File.open(File.join(rails_root, 'request.rb'), 'w') { |file| file.write(request_script) }
+      @terminal.cd(rails_root)
+      @terminal.run("ruby -rthread ./script/runner -e #{environment} request.rb")
+    else
+      uri = URI.parse(uri)
+      request_script = <<-SCRIPT
+        require 'cgi'
+        class CGIWrapper < CGI
+          def initialize(*args)
+            @env_table = {}
+            @stdinput = $stdin
+            super(*args)
+          end
+          attr_reader :env_table
+        end
+        $stdin = StringIO.new("")
+        cgi = CGIWrapper.new
+        cgi.env_table.update({
+          'HTTPS'          => 'off',
+          'REQUEST_METHOD' => "GET",
+          'HTTP_HOST'      => #{[uri.host, uri.port].join(':').inspect},
+          'SERVER_PORT'    => #{uri.port.inspect},
+          'REQUEST_URI'    => #{uri.request_uri.inspect},
+          'PATH_INFO'      => #{uri.path.inspect},
+          'QUERY_STRING'   => #{uri.query.inspect}
+        })
+        require 'dispatcher' unless defined?(ActionController::Dispatcher)
+        Dispatcher.dispatch(cgi)
+      SCRIPT
+      File.open(File.join(rails_root, 'request.rb'), 'w') { |file| file.write(request_script) }
+      @terminal.cd(rails_root)
+      @terminal.run("ruby -rthread ./script/runner -e #{environment} request.rb")
+    end
+  end
+
+  def monkeypatch_old_version
+    monkeypatchin= <<-MONKEYPATCHIN
+
+    MissingSourceFile::REGEXPS << [/^cannot load such file -- (.+)$/i, 1]
+
+    MONKEYPATCHIN
+
+    File.open(File.join(rails_root,"config","initializers", 'monkeypatchin.rb'), 'w') { |file| file.write(monkeypatchin) }
+  end
+end
+
+World(RailsHelpers)

data/features/support/rake/Rakefile

@@ -0,0 +1,68 @@
+# A test harness for RakeHandler
+#
+require 'rake'
+require 'rubygems'
+require 'cloudtrapper'
+require 'cloudtrapper/rake_handler'
+
+Cloudtrapper.configure do |c|
+end
+
+# Should catch exception
+task :cloudtrapper do
+  Cloudtrapper.configuration.rescue_rake_exceptions = true
+  stub_tty_output(true)
+  raise_exception
+end
+
+# Should not catch exception
+task :cloudtrapper_disabled do
+  Cloudtrapper.configuration.rescue_rake_exceptions = false
+  stub_tty_output(true)
+  raise_exception
+end
+
+# Should not catch exception as tty_output is true
+task :cloudtrapper_autodetect_from_terminal do
+  Cloudtrapper.configuration.rescue_rake_exceptions = nil
+  stub_tty_output(true)
+  raise_exception
+end
+
+# Should catch exception as tty_output is false
+task :cloudtrapper_autodetect_not_from_terminal do
+  Cloudtrapper.configuration.rescue_rake_exceptions = nil
+  stub_tty_output(false)
+  raise_exception
+end
+
+task :cloudtrapper_not_yet_configured do
+  Cloudtrapper.configuration.rescue_rake_exceptions = true
+  stub_tty_output(true)
+  stub_empty_sender
+  raise_exception
+end
+
+module Cloudtrapper
+  def self.notify(*args)
+    # TODO if you need to check more params, you'll have to use json.dump or something
+    $stderr.puts "cloudtrapper #{args[1][:component]}"
+  end
+end
+
+def stub_empty_sender
+  Cloudtrapper.sender = nil
+end
+
+def stub_tty_output(value)
+  Rake.application.instance_eval do
+    @tty_output_stub = value
+    def tty_output?
+      @tty_output_stub
+    end
+  end
+end
+
+def raise_exception
+  raise 'TEST'
+end

data/features/support/terminal.rb

@@ -0,0 +1,107 @@
+require 'fileutils'
+
+Before do
+  @terminal = Terminal.new
+end
+
+After do |story|
+  if story.failed?
+    # puts @terminal.output
+  end
+end
+
+class Terminal
+  attr_reader :output, :status
+  attr_accessor :environment_variables, :invoke_heroku_rake_tasks_locally
+
+  def initialize
+    @cwd = FileUtils.pwd
+    @output = ""
+    @status = 0
+    @logger = Logger.new(File.join(TEMP_DIR, 'terminal.log'))
+
+    @invoke_heroku_rake_tasks_locally = false
+
+    @environment_variables = {
+      "GEM_HOME" => LOCAL_GEM_ROOT,
+      "GEM_PATH" => "#{LOCAL_GEM_ROOT}:#{BUILT_GEM_ROOT}",
+      "PATH" => "#{gem_bin_path}:#{ENV['PATH']}"
+    }
+  end
+
+  def cd(directory)
+    @cwd = directory
+  end
+
+  def run(command)
+    command = optionally_invoke_heroku_rake_tasks_locally(command)
+
+    output << "#{command}\n"
+    FileUtils.cd(@cwd) do
+      # The ; forces ruby to shell out so the env settings work right
+      cmdline = "#{environment_settings} #{command} 2>&1 ; "
+      logger.debug(cmdline)
+      result = `#{cmdline}`
+      logger.debug(result)
+      output << result
+    end
+    @status = $?
+  end
+
+  def optionally_invoke_heroku_rake_tasks_locally(command)
+    if invoke_heroku_rake_tasks_locally
+      command.sub(/^heroku /, '')
+    else
+      command
+    end
+  end
+
+  def echo(string)
+    logger.debug(string)
+  end
+
+  def flush!
+    @output = ""
+  end
+
+  def build_and_install_gem(gemspec)
+    pkg_dir = File.join(TEMP_DIR, 'pkg')
+    FileUtils.mkdir_p(pkg_dir)
+    output = `gem build #{gemspec} 2>&1`
+    gem_file = Dir.glob("*.gem").first
+    unless gem_file
+      raise "Gem didn't build:\n#{output}"
+    end
+    target = File.join(pkg_dir, gem_file)
+    FileUtils.mv(gem_file, target)
+    install_gem_to(LOCAL_GEM_ROOT, target)
+  end
+
+  def install_gem(gem)
+    install_gem_to(LOCAL_GEM_ROOT, gem)
+  end
+
+  def uninstall_gem(gem)
+    `gem uninstall -i #{LOCAL_GEM_ROOT} #{gem}`
+  end
+
+  def prepend_path(path)
+    @environment_variables['PATH'] = path + ":" + @environment_variables['PATH']
+  end
+
+  private
+
+  def install_gem_to(root, gem)
+    `gem install -i #{root} --no-ri --no-rdoc #{gem}`
+  end
+
+  def environment_settings
+    @environment_variables.map { |key, value| "#{key}=#{value}" }.join(' ')
+  end
+
+  def gem_bin_path
+    File.join(LOCAL_GEM_ROOT, "bin")
+  end
+
+  attr_reader :logger
+end

data/features/user_informer.feature

@@ -0,0 +1,63 @@
+Feature: Inform the user of the cloudtrapper notice that was just created
+
+  Background:
+    Given I have built and installed the "cloudtrapper" gem
+
+  Scenario: Rescue an exception in a controller
+    When I generate a new Rails application
+    And I configure the Cloudtrapper shim
+    And I configure my application to require the "cloudtrapper" gem
+    And I run the cloudtrapper generator with "-k myapikey"
+    And I define a response for "TestController#index":
+      """
+      raise RuntimeError, "some message"
+      """
+    And the response page for a "500" error is
+      """
+      <!-- AIRBRAKE ERROR -->
+      """
+    And I route "/test/index" to "test#index"
+    And I perform a request to "http://example.com:123/test/index?param=value"
+    Then I should see "Cloudtrapper Error b6817316-9c45-ed26-45eb-780dbb86aadb"
+
+  Scenario: Rescue an exception in a controller with a custom error string
+    When I generate a new Rails application
+    And I configure the Cloudtrapper shim
+    And I configure my application to require the "cloudtrapper" gem
+    And I configure the notifier to use the following configuration lines:
+    """
+    config.user_information = 'Error #{{ error_id }}'
+    """
+    And I run the cloudtrapper generator with "-k myapikey"
+    And I define a response for "TestController#index":
+      """
+      raise RuntimeError, "some message"
+      """
+    And the response page for a "500" error is
+      """
+      <!-- AIRBRAKE ERROR -->
+      """
+    And I route "/test/index" to "test#index"
+    And I perform a request to "http://example.com:123/test/index?param=value"
+    Then I should see "Error #b6817316-9c45-ed26-45eb-780dbb86aadb"
+
+  Scenario: Don't inform them user
+    When I generate a new Rails application
+    And I configure the Cloudtrapper shim
+    And I configure my application to require the "cloudtrapper" gem
+    And I configure the notifier to use the following configuration lines:
+    """
+    config.user_information = false
+    """
+    And I run the cloudtrapper generator with "-k myapikey"
+    And I define a response for "TestController#index":
+      """
+      raise RuntimeError, "some message"
+      """
+    And the response page for a "500" error is
+      """
+      <!-- AIRBRAKE ERROR -->
+      """
+    And I route "/test/index" to "test#index"
+    And I perform a request to "http://example.com:123/test/index?param=value"
+    Then I should not see "Cloudtrapper Error b6817316-9c45-ed26-45eb-780dbb86aadb"

data/generators/cloudtrapper/airbrake_generator.rb

@@ -0,0 +1,94 @@
+require File.expand_path(File.dirname(__FILE__) + "/lib/insert_commands.rb")
+require File.expand_path(File.dirname(__FILE__) + "/lib/rake_commands.rb")
+
+class CloudtrapperGenerator < Rails::Generator::Base
+  def add_options!(opt)
+    opt.on('-k', '--api-key=key', String, "Your Cloudtrapper API key")                                               { |v| options[:api_key] = v}
+    opt.on('-h', '--heroku',              "Use the Heroku addon to provide your Cloudtrapper API key")               { |v| options[:heroku]  = v}
+    opt.on('-a', '--app=myapp', String,   "Your Heroku app name (only required if deploying to >1 Heroku app)") { |v| options[:app]     = v}
+  end
+
+  def manifest
+    if !api_key_configured? && !options[:api_key] && !options[:heroku]
+      puts "Must pass --api-key or --heroku or create config/initializers/cloudtrapper.rb"
+      exit
+    end
+    if plugin_is_present?
+      puts "You must first remove the cloudtrapper plugin. Please run: script/plugin remove cloudtrapper"
+      exit
+    end
+    record do |m|
+      m.directory 'lib/tasks'
+      m.file 'cloudtrapper_tasks.rake', 'lib/tasks/cloudtrapper_tasks.rake'
+      if ['config/deploy.rb', 'Capfile'].all? { |file| File.exists?(file) }
+        m.append_to 'config/deploy.rb', capistrano_hook
+      end
+      if api_key_expression
+        if use_initializer?
+          m.template 'initializer.rb', 'config/initializers/cloudtrapper.rb',
+            :assigns => {:api_key => api_key_expression}
+        else
+          m.template 'initializer.rb', 'config/cloudtrapper.rb',
+            :assigns => {:api_key => api_key_expression}
+          m.append_to 'config/environment.rb', "require 'config/cloudtrapper'"
+        end
+      end
+      determine_api_key if heroku?
+      m.rake "cloudtrapper:test --trace", :generate_only => true
+    end
+  end
+
+  def api_key_expression
+    s = if options[:api_key]
+      "'#{options[:api_key]}'"
+    elsif options[:heroku]
+      "ENV['HOPTOAD_API_KEY']"
+    end
+  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 Cloudtrapper API Key from your Heroku environment."
+      puts "Your Heroku application environment may not be configured correctly."
+      exit 1
+    else
+      puts "... Done."
+      puts "Heroku's Cloudtrapper 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|cloudtrapper)_api_key",options[:app]).split.find {|x| x unless x.blank?}
+  end
+
+  def heroku?
+    options[:heroku] ||
+      system("grep HOPTOAD_API_KEY config/initializers/cloudtrapper.rb") ||
+      system("grep HOPTOAD_API_KEY config/environment.rb")
+  end
+
+  def use_initializer?
+    Rails::VERSION::MAJOR > 1
+  end
+
+  def api_key_configured?
+    File.exists?('config/initializers/cloudtrapper.rb') ||
+      system("grep Cloudtrapper config/environment.rb")
+  end
+
+  def capistrano_hook
+    IO.read(source_path('capistrano_hook.rb'))
+  end
+
+  def plugin_is_present?
+    File.exists?('vendor/plugins/cloudtrapper')
+  end
+end

data/generators/cloudtrapper/lib/insert_commands.rb

@@ -0,0 +1,34 @@
+# Mostly pinched from http://github.com/ryanb/nifty-generators/tree/master
+
+Rails::Generator::Commands::Base.class_eval do
+  def file_contains?(relative_destination, line)
+    File.read(destination_path(relative_destination)).include?(line)
+  end
+end
+
+Rails::Generator::Commands::Create.class_eval do
+  def append_to(file, line)
+    logger.insert "#{line} appended to #{file}"
+    unless options[:pretend] || file_contains?(file, line)
+      File.open(file, "a") do |file|
+        file.puts
+        file.puts line
+      end
+    end
+  end
+end
+
+Rails::Generator::Commands::Destroy.class_eval do
+  def append_to(file, line)
+    logger.remove "#{line} removed from #{file}"
+    unless options[:pretend]
+      gsub_file file, "\n#{line}", ''
+    end
+  end
+end
+
+Rails::Generator::Commands::List.class_eval do
+  def append_to(file, line)
+    logger.insert "#{line} appended to #{file}"
+  end
+end

data/generators/cloudtrapper/lib/rake_commands.rb

@@ -0,0 +1,24 @@
+Rails::Generator::Commands::Create.class_eval do
+  def rake(cmd, opts = {})
+    logger.rake "rake #{cmd}"
+    unless system("rake #{cmd}")
+      logger.rake "#{cmd} failed. Rolling back"      
+      command(:destroy).invoke!
+    end
+  end
+end
+
+Rails::Generator::Commands::Destroy.class_eval do
+  def rake(cmd, opts = {})
+    unless opts[:generate_only]
+      logger.rake "rake #{cmd}"
+      system "rake #{cmd}"
+    end
+  end
+end
+
+Rails::Generator::Commands::List.class_eval do
+  def rake(cmd, opts = {})
+    logger.rake "rake #{cmd}"
+  end
+end

data/generators/cloudtrapper/templates/capistrano_hook.rb

@@ -0,0 +1,6 @@
+
+Dir[File.join(File.dirname(__FILE__), '..', 'vendor', 'gems', 'cloudtrapper-*')].each do |vendored_notifier|
+  $: << File.join(vendored_notifier, 'lib')
+end
+
+require 'cloudtrapper/capistrano'

data/generators/cloudtrapper/templates/cloudtrapper_tasks.rake

@@ -0,0 +1,25 @@
+# Don't load anything when running the gems:* tasks.
+# Otherwise, cloudtrapper will be considered a framework gem.
+# https://thoughtbot.lighthouseapp.com/projects/14221/tickets/629
+unless ARGV.any? {|a| a =~ /^gems/}
+
+  Dir[File.join(Rails.root, 'vendor', 'gems', 'cloudtrapper-*')].each do |vendored_notifier|
+    $: << File.join(vendored_notifier, 'lib')
+  end
+
+  begin
+    require 'cloudtrapper/tasks'
+  rescue LoadError => exception
+    namespace :cloudtrapper do
+      %w(deploy test log_stdout).each do |task_name|
+        desc "Missing dependency for cloudtrapper:#{task_name}"
+        task task_name do
+          $stderr.puts "Failed to run cloudtrapper:#{task_name} because of missing dependency."
+          $stderr.puts "You probably need to run `rake gems:install` to install the cloudtrapper gem"
+          abort exception.inspect
+        end
+      end
+    end
+  end
+
+end

data/generators/cloudtrapper/templates/initializer.rb

@@ -0,0 +1,6 @@
+<% if Rails::VERSION::MAJOR < 3 && Rails::VERSION::MINOR < 2 -%>
+require 'cloudtrapper/rails'
+<% end -%>
+Cloudtrapper.configure do |config|
+  config.api_key = <%= api_key_expression %>
+end

data/install.rb

@@ -0,0 +1 @@
+puts IO.read(File.join(File.dirname(__FILE__), 'INSTALL'))