honeybadger 1.0.0

data/features/support/honeybadger_shim.rb.template

@@ -0,0 +1,8 @@
+require 'sham_rack'
+
+ShamRack.at("api.honeybadger.io") do |env|
+  response = <<-end_json
+{"id":"123456789"}
+  end_json
+  ["200 OK", { "Content-type" => "application/json" }, [response]]
+end

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 'honeybadger'
+require 'honeybadger/rake_handler'
+
+Honeybadger.configure do |c|
+end
+
+# Should catch exception
+task :honeybadger do
+  Honeybadger.configuration.rescue_rake_exceptions = true
+  stub_tty_output(true)
+  raise_exception
+end
+
+# Should not catch exception
+task :honeybadger_disabled do
+  Honeybadger.configuration.rescue_rake_exceptions = false
+  stub_tty_output(true)
+  raise_exception
+end
+
+# Should not catch exception as tty_output is true
+task :honeybadger_autodetect_from_terminal do
+  Honeybadger.configuration.rescue_rake_exceptions = nil
+  stub_tty_output(true)
+  raise_exception
+end
+
+# Should catch exception as tty_output is false
+task :honeybadger_autodetect_not_from_terminal do
+  Honeybadger.configuration.rescue_rake_exceptions = nil
+  stub_tty_output(false)
+  raise_exception
+end
+
+task :honeybadger_not_yet_configured do
+  Honeybadger.configuration.rescue_rake_exceptions = true
+  stub_tty_output(true)
+  stub_empty_sender
+  raise_exception
+end
+
+module Honeybadger
+  def self.notify_or_ignore(*args)
+    # TODO if you need to check more params, you'll have to use json.dump or something
+    $stderr.puts "honeybadger #{args[1][:component]}"
+  end
+end
+
+def stub_empty_sender
+  Honeybadger.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/generators/honeybadger/honeybadger_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 HoneybadgerGenerator < Rails::Generator::Base
+  def add_options!(opt)
+    opt.on('-k', '--api-key=key', String, "Your Honeybadger API key")                                           { |v| options[:api_key] = v}
+    opt.on('-h', '--heroku',              "Use the Heroku addon to provide your Honeybadger 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/honeybadger.rb"
+      exit
+    end
+    if plugin_is_present?
+      puts "You must first remove the honeybadger plugin. Please run: script/plugin remove honeybadger"
+      exit
+    end
+    record do |m|
+      m.directory 'lib/tasks'
+      m.file 'honeybadger_tasks.rake', 'lib/tasks/honeybadger_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/honeybadger.rb',
+            :assigns => {:api_key => api_key_expression}
+        else
+          m.template 'initializer.rb', 'config/honeybadger.rb',
+            :assigns => {:api_key => api_key_expression}
+          m.append_to 'config/environment.rb', "require 'config/honeybadger'"
+        end
+      end
+      determine_api_key if heroku?
+      m.rake "honeybadger:test --trace", :generate_only => true
+    end
+  end
+
+  def api_key_expression
+    s = if options[:api_key]
+          "'#{options[:api_key]}'"
+        elsif options[:heroku]
+          "ENV['HONEYBADGER_API_KEY']"
+        end
+  end
+
+  def determine_api_key
+    puts "Attempting to determine your API Key from Heroku..."
+    ENV['HONEYBADGER_API_KEY'] = heroku_api_key
+    if ENV['HONEYBADGER_API_KEY'].blank?
+      puts "... Failed."
+      puts "WARNING: We were unable to detect the Honeybadger API Key from your Heroku environment."
+      puts "Your Heroku application environment may not be configured correctly."
+      exit 1
+    else
+      puts "... Done."
+      puts "Heroku's Honeybadger API Key is '#{ENV['HONEYBADGER_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|honeybadger)_api_key",options[:app]).split.find {|x| x unless x.blank?}
+  end
+
+  def heroku?
+    options[:heroku] ||
+      system("grep HONEYBADGER_API_KEY config/initializers/honeybadger.rb") ||
+      system("grep HONEYBADGER_API_KEY config/environment.rb")
+  end
+
+  def use_initializer?
+    Rails::VERSION::MAJOR > 1
+  end
+
+  def api_key_configured?
+    File.exists?('config/initializers/honeybadger.rb') ||
+      system("grep Honeybadger config/environment.rb")
+  end
+
+  def capistrano_hook
+    IO.read(source_path('capistrano_hook.rb'))
+  end
+
+  def plugin_is_present?
+    File.exists?('vendor/plugins/honeybadger')
+  end
+end