honeybadger 2.7.2 → 3.0.0.beta1

data/lib/honeybadger/backend.rb

@@ -1,5 +1,11 @@
 require 'forwardable'
 
+require 'honeybadger/backend/base'
+require 'honeybadger/backend/server'
+require 'honeybadger/backend/test'
+require 'honeybadger/backend/null'
+require 'honeybadger/backend/debug'
+
 module Honeybadger
   module Backend
     class BackendError < StandardError; end
@@ -16,11 +22,5 @@ module Honeybadger
     def self.for(backend)
       mapping[backend] or raise(BackendError, "Unable to locate backend: #{backend}")
     end
-
-    autoload :Base, 'honeybadger/backend/base'
-    autoload :Server, 'honeybadger/backend/server'
-    autoload :Test, 'honeybadger/backend/test'
-    autoload :Null, 'honeybadger/backend/null'
-    autoload :Debug, 'honeybadger/backend/debug'
   end
 end

data/lib/honeybadger/backend/base.rb

@@ -11,6 +11,13 @@ module Honeybadger
 
       attr_reader :code, :body, :message, :error
 
+      FRIENDLY_ERRORS = {
+        429 => "Your project is currently sending too many errors.\nThis issue should resolve itself once error traffic is reduced.".freeze,
+        503 => "Your project is currently sending too many errors.\nThis issue should resolve itself once error traffic is reduced.".freeze,
+        402 => "The project owner's billing information has expired (or the trial has ended).\nPlease check your payment details or email support@honeybadger.io for help.".freeze,
+        403 => "The API key is invalid. Please check your API key and try again.".freeze
+      }.freeze
+
       # Public: Initializes the Response instance.
       #
       # response - With 1 argument Net::HTTPResponse, the code, body, and
@@ -37,6 +44,10 @@ module Honeybadger
         @success
       end
 
+      def error_message
+        FRIENDLY_ERRORS[code] || message
+      end
+
       private
 
       def parse_error(body)

data/lib/honeybadger/backend/server.rb

@@ -15,17 +15,7 @@ module Honeybadger
         deploys: '/v1/deploys'.freeze
       }.freeze
 
-      HTTP_ERRORS = [Timeout::Error,
-                     Errno::EINVAL,
-                     Errno::ECONNRESET,
-                     Errno::ECONNREFUSED,
-                     Errno::ENETUNREACH,
-                     EOFError,
-                     Net::HTTPBadResponse,
-                     Net::HTTPHeaderSyntaxError,
-                     Net::ProtocolError,
-                     OpenSSL::SSL::SSLError,
-                     SocketError].freeze
+      HTTP_ERRORS = Util::HTTP::ERRORS
 
       def initialize(config)
         @http = Util::HTTP.new(config)
@@ -42,9 +32,7 @@ module Honeybadger
         ENDPOINTS[feature] or raise(BackendError, "Unknown feature: #{feature}")
         Response.new(@http.post(ENDPOINTS[feature], payload, payload_headers(payload)))
       rescue *HTTP_ERRORS => e
-        Response.new(:error, nil, "HTTP Error: #{e.class}").tap do |response|
-          error { sprintf('http error class=%s message=%s', e.class, e.message.dump) }
-        end
+        Response.new(:error, nil, "HTTP Error: #{e.class}")
       end
 
       private

data/lib/honeybadger/cli.rb

@@ -2,8 +2,6 @@ $:.unshift(File.expand_path('../../../vendor/cli', __FILE__))
 
 require 'thor'
 
-require 'honeybadger'
-require 'honeybadger/cli/heroku'
 require 'honeybadger/cli/main'
 
 module Honeybadger

data/lib/honeybadger/cli/deploy.rb

@@ -0,0 +1,42 @@
+require 'forwardable'
+require 'honeybadger/cli/main'
+require 'honeybadger/util/http'
+
+module Honeybadger
+  module CLI
+    class Deploy
+      extend Forwardable
+
+      def initialize(options, args, config)
+        @options = options
+        @args = args
+        @config = config
+        @shell = ::Thor::Base.shell.new
+      end
+
+      def run
+        payload = {
+          environment: options['environment'],
+          revision: options['revision'],
+          repository: options['repository'],
+          local_username: options['user']
+        }
+
+        http = Util::HTTP.new(config)
+        result = http.post('/v1/deploys', payload)
+        if result.code == '201'
+          say("Deploy notification complete.", :green)
+        else
+          say("Invalid response from server: #{result.code}", :red)
+          exit(1)
+        end
+      end
+
+      private
+
+      attr_reader :options, :args, :config
+
+      def_delegator :@shell, :say
+    end
+  end
+end

data/lib/honeybadger/cli/exec.rb

@@ -0,0 +1,138 @@
+require 'erb'
+require 'forwardable'
+require 'honeybadger/cli/main'
+require 'honeybadger/util/http'
+require 'honeybadger/util/stats'
+require 'open3'
+require 'ostruct'
+require 'thor/shell'
+
+module Honeybadger
+  module CLI
+    class Exec
+      extend Forwardable
+
+      FAILED_TEMPLATE = <<-MSG
+Honeybadger detected failure or error output for the command:
+`<%= args.join(' ') %>`
+
+PROCESS ID: <%= pid %>
+
+RESULT CODE: <%= code %>
+
+ERROR OUTPUT:
+<%= stderr %>
+
+STANDARD OUTPUT:
+<%= stdout %>
+MSG
+
+      NO_EXEC_TEMPLATE = <<-MSG
+Honeybadger failed to execute the following command:
+`<%= args.join(' ') %>`
+
+The command was not executable. Try adjusting permissions on the file.
+MSG
+
+      NOT_FOUND_TEMPLATE = <<-MSG
+Honeybadger failed to execute the following command:
+`<%= args.join(' ') %>`
+
+The command was not found. Make sure it exists in your PATH.
+MSG
+
+      def initialize(options, args, config)
+        @options = options
+        @args = args
+        @config = config
+        @shell = ::Thor::Base.shell.new
+      end
+
+      def run
+        result = exec_cmd
+        return if result.success
+
+        payload = {
+          api_key: config.get(:api_key),
+          notifier: NOTIFIER,
+          error: {
+            class: 'honeybdager exec error',
+            message: result.msg
+          },
+          request: {
+            context: {
+              executable: args.first,
+              code: result.code,
+              pid: result.pid
+            }
+          },
+          server: {
+            project_root: Dir.pwd,
+            environment_name: config.get(:env),
+            time: Time.now,
+            stats: Util::Stats.all
+          }
+        }
+
+        http = Util::HTTP.new(config)
+
+        begin
+          response = http.post('/v1/notices', payload)
+        rescue
+          say(result.msg)
+          raise
+        end
+
+        if response.code != '201'
+          say(result.msg)
+          say("\nFailed to notify Honeybadger: #{response.code}", :red)
+          exit(1)
+        end
+
+        unless quiet?
+          say(result.msg)
+          say("\nSuccessfully notified Honeybadger")
+        end
+
+        exit(0)
+      end
+
+      private
+
+      attr_reader :options, :args, :config
+
+      def_delegator :@shell, :say
+
+      def quiet?
+        !!options[:quiet]
+      end
+
+      def exec_cmd
+        stdout, stderr, status = Open3.capture3(args.join(' '))
+
+        pid = status.pid
+        code = status.to_i
+        msg = ERB.new(FAILED_TEMPLATE).result(binding) unless status.success?
+
+        OpenStruct.new(
+          msg: msg,
+          pid: pid,
+          code: code,
+          stdout: stdout,
+          stderr: stderr,
+          success: status.success? && stderr =~ BLANK
+        )
+      rescue Errno::EACCES, Errno::ENOEXEC
+        OpenStruct.new(
+          msg: ERB.new(NO_EXEC_TEMPLATE).result(binding),
+          code: 126
+        )
+      rescue Errno::ENOENT
+        OpenStruct.new(
+          msg: ERB.new(NOT_FOUND_TEMPLATE).result(binding),
+          code: 127
+        )
+      end
+    end
+  end
+end

data/lib/honeybadger/cli/heroku.rb

@@ -1,10 +1,6 @@
-require 'honeybadger/cli/helpers'
-
 module Honeybadger
   module CLI
     class Heroku < Thor
-      include Helpers
-
       class_option :app, aliases: :'-a', type: :string, default: nil, desc: 'Specify optional Heroku APP'
 
       desc 'install_deploy_notification', 'Install Heroku deploy notifications addon'
@@ -37,19 +33,10 @@ module Honeybadger
       def install(api_key)
         say("Installing Honeybadger #{VERSION} for Heroku")
 
-        load_rails(verbose: true)
-
-        ENV['HONEYBADGER_LOGGING_LEVEL']     = '2'
-        ENV['HONEYBADGER_LOGGING_TTY_LEVEL'] = '0'
-        ENV['HONEYBADGER_LOGGING_PATH']      = 'STDOUT'
-        ENV['HONEYBADGER_REPORT_DATA']       = 'true'
-
-        ENV['HONEYBADGER_API_KEY'] = api_key
-
         app = options[:app] || detect_heroku_app(false)
         say("Adding config HONEYBADGER_API_KEY=#{api_key} to Heroku.", :magenta)
         unless write_heroku_env({'HONEYBADGER_API_KEY' => api_key}, app)
-          say('Unable to update heroku config. Do you need to specify an app name?', :red)
+          say('Unable to update heroku config. You may need to specify an app name with --app APP', :red)
           exit(1)
         end
 
@@ -61,14 +48,6 @@ module Honeybadger
           say("To install manually, try `honeybadger heroku install_deploy_notification#{app ? " -a #{app}" : ""} -k #{api_key} --environment ENVIRONMENT`", :yellow)
         end
 
-        config = Config.new(rails_framework_opts)
-        Honeybadger.start(config) unless load_rails_env(verbose: true)
-        say('Sending test notice')
-        unless Agent.instance && send_test(false)
-          say("Honeybadger is installed, but failed to send a test notice. Try `HONEYBADGER_API_KEY=#{api_key} honeybadger test`.", :red)
-          exit(1)
-        end
-
         say("Installation complete. Happy 'badgering!", :green)
       end
 

data/lib/honeybadger/cli/install.rb

@@ -0,0 +1,74 @@
+require 'forwardable'
+require 'honeybadger/cli/main'
+require 'honeybadger/cli/test'
+require 'pathname'
+
+module Honeybadger
+  module CLI
+    class Install
+      extend Forwardable
+
+      def initialize(options, api_key)
+        @options = options
+        @api_key = api_key
+        @shell = ::Thor::Base.shell.new
+      end
+
+      def run
+        say("Installing Honeybadger #{VERSION}")
+
+        begin
+          require File.join(Dir.pwd, 'config', 'application.rb')
+        rescue LoadError
+          nil
+        end
+
+        root = defined?(Rails.root) ? Rails.root : Pathname.new(Dir.pwd)
+        config_root = defined?(Rails.root) ? root.join('config') : root
+        config_path = config_root.join('honeybadger.yml')
+
+        if config_path.exist?
+          say("You're already on Honeybadger, so you're all set.", :yellow)
+        else
+          say("Writing configuration to: #{config_path}", :yellow)
+
+          path = config_path
+
+          if path.exist?
+            say("The configuration file #{config_path} already exists.", :red)
+            exit(1)
+          elsif !path.dirname.writable?
+            say("The configuration path #{config_path.dirname} is not writable.", :red)
+            exit(1)
+          end
+
+          File.open(path, 'w+') do |file|
+            file.write(<<-CONFIG)
+---
+api_key: '#{api_key}'
+CONFIG
+          end
+        end
+
+        if (capfile = root.join('Capfile')).exist?
+          if capfile.read.match(/honeybadger/)
+            say("Detected Honeybadger in Capfile; skipping Capistrano installation.", :yellow)
+          else
+            say("Appending Capistrano tasks to: #{capfile}", :yellow)
+            File.open(capfile, 'a') do |f|
+              f.puts("\nrequire 'capistrano/honeybadger'")
+            end
+          end
+        end
+
+        Test.new({install: true}.freeze).run
+      end
+
+      private
+
+      attr_reader :options, :api_key
+
+      def_delegator :@shell, :say
+    end
+  end
+end

data/lib/honeybadger/cli/main.rb

@@ -1,195 +1,180 @@
-require 'stringio'
-
-require 'honeybadger/cli/helpers'
+require 'honeybadger/cli/deploy'
+require 'honeybadger/cli/exec'
+require 'honeybadger/cli/heroku'
+require 'honeybadger/cli/install'
+require 'honeybadger/cli/notify'
+require 'honeybadger/cli/test'
+require 'honeybadger/config'
+require 'honeybadger/config/defaults'
+require 'honeybadger/util/http'
+require 'honeybadger/version'
+require 'logger'
 
 module Honeybadger
   module CLI
+    BLANK = /\A\s*\z/
+
+    NOTIFIER = {
+      name: 'honeybadger-ruby (cli)'.freeze,
+      url: 'https://github.com/honeybadger-io/honeybadger-ruby'.freeze,
+      version: VERSION,
+      language: nil
+    }.freeze
+
     class Main < Thor
-      include Helpers
+      def self.project_options
+        option :api_key,     required: false, aliases: :'-k', type: :string, desc: 'Api key of your Honeybadger application'
+        option :environment, required: false, aliases: [:'-e', :'-env'], type: :string, desc: 'Environment this command is being executed in (i.e. "production", "staging")'
+      end
 
-      class HoneybadgerTestingException < RuntimeError; end
+      desc 'install API_KEY', 'Install Honeybadger into a new project'
+      def install(api_key)
+        Install.new(options, api_key).run
+      rescue => e
+        log_error(e)
+        exit(1)
+      end
 
-      NOT_BLANK = Regexp.new('\S').freeze
+      desc 'test', 'Send a test notification from Honeybadger'
+      option :dry_run, type: :boolean, aliases: :'-d', default: false, desc: 'Skip sending data to Honeybadger'
+      option :file,    type: :string,  aliases: :'-f', default: nil, desc: 'Write the output to FILE'
+      def test
+        Test.new(options).run
+      rescue => e
+        log_error(e)
+        exit(1)
+      end
 
       desc 'deploy', 'Notify Honeybadger of deployment'
-      option :environment, aliases: :'-e', type: :string, desc: 'Environment of the deploy (i.e. "production", "staging")'
-      option :revision, aliases: :'-s', type: :string, desc: 'The revision/sha that is being deployed'
-      option :repository, aliases: :'-r', type: :string, desc: 'The address of your repository'
-      option :user, aliases: :'-u', type: :string, default: ENV['USER'] || ENV['USERNAME'], desc: 'The local user who is deploying'
-      option :api_key, aliases: :'-k', type: :string, desc: 'Api key of your Honeybadger application'
+      project_options
+      option :repository, required: true, type: :string, aliases: :'-r', desc: 'The address of your repository'
+      option :revision,   required: true, type: :string, aliases: :'-s', desc: 'The revision/sha that is being deployed'
+      option :user,       required: true, type: :string, aliases: :'-u', default: ENV['USER'] || ENV['USERNAME'], desc: 'The local user who is deploying'
       def deploy
-        load_rails(verbose: true)
+        config = build_config(options)
 
-        payload = Hash[[:environment, :revision, :repository].map {|k| [k, options[k]] }]
-        payload[:local_username] = options[:user]
-
-        ENV['HONEYBADGER_LOGGING_LEVEL']     = '2'
-        ENV['HONEYBADGER_LOGGING_TTY_LEVEL'] = '0'
-        ENV['HONEYBADGER_LOGGING_PATH']      = 'STDOUT'
-        ENV['HONEYBADGER_REPORT_DATA']       = 'true'
-
-        say('Loading configuration')
-        config = Config.new(rails_framework_opts)
-        config.update(api_key: options[:api_key]) if options[:api_key] =~ NOT_BLANK
-
-        unless (payload[:environment] ||= config[:env]) =~ NOT_BLANK
-          say('Unable to determine environment. (see: `honeybadger help deploy`)', :red)
-          exit(1)
+        if config.get(:api_key).to_s =~ BLANK
+          say("No value provided for required options '--api-key'")
+          return
         end
 
-        unless config.valid?
-          say("Invalid configuration: #{config.inspect}", :red)
-          exit(1)
-        end
+        Deploy.new(options, [], config).run
+      rescue => e
+        log_error(e)
+        exit(1)
+      end
 
-        response = config.backend.notify(:deploys, payload)
-        if response.success?
-          say("Deploy notification for #{payload[:environment]} complete.", :green)
-        else
-          say("Deploy notification failed: #{response.code}", :red)
-          exit(1)
+      desc 'notify', 'Notify Honeybadger of an error'
+      project_options
+      option :class,       required: true, type: :string, aliases: :'-c', default: 'CLI Notification', desc: 'The class name of the error. (Default: CLI Notification)'
+      option :message,     required: true, type: :string, aliases: :'-m', desc: 'The error message.'
+      option :action,      required: false, type: :string, aliases: :'-a', desc: 'The action.'
+      option :component,   required: false, type: :string, aliases: :'-C', desc: 'The component.'
+      option :fingerprint, required: false, type: :string, aliases: :'-f', desc: 'The component.'
+      option :tags,        required: false, type: :string, aliases: :'-t', desc: 'The tags.'
+      option :url,         required: false, type: :string, aliases: :'-u', desc: 'The URL.'
+      def notify
+        config = build_config(options)
+
+        if config.get(:api_key).to_s =~ BLANK
+          say("No value provided for required options '--api-key'")
+          return
         end
+
+        Notify.new(options, [], config).run
       rescue => e
-        say("An error occurred during deploy notification: #{e}\n\t#{e.backtrace.join("\n\t")}", :red)
+        log_error(e)
         exit(1)
       end
 
-      desc 'config', 'List configuration options'
-      option :default, aliases: :'-d', type: :boolean, default: true, desc: 'Output default options'
-      def config
-        load_rails
-        config = Config.new(rails_framework_opts)
-        output_config(config.to_hash(options[:default]))
-      end
+      desc 'exec', 'Execute a command. If the exit status is not 0, report the result to Honeybadger'
+      project_options
+      option :quiet, required: false, type: :boolean, aliases: :'-q', default: false, desc: 'Suppress all output unless Honeybdager notification fails.'
+      def exec(*args)
+        config = build_config(options)
 
-      desc 'test', 'Output test/debug information'
-      option :dry_run, aliases: :'-d', type: :boolean, default: false, desc: 'Skip sending data to Honeybadger'
-      option :file, aliases: :'-f', type: :string, default: nil, desc: 'Write the output to FILE'
-      def test
-        if options[:file]
-          out = StringIO.new
-          $stdout = out
-
-          flush = Proc.new do
-            $stdout = STDOUT
-            File.open(options[:file], 'w+') do |f|
-              out.rewind
-              out.each_line {|l| f.write(l) }
-            end
-
-            say("Output written to #{options[:file]}", :green)
-          end
-
-          Agent.at_exit(&flush)
-
-          at_exit do
-            # If the agent couldn't be started, the callback should happen here
-            # instead.
-            flush.() unless Agent.running?
-          end
+        if config.get(:api_key).to_s =~ BLANK
+          say("No value provided for required options '--api-key'")
+          return
         end
 
-        say("Detecting framework\n\n", :bold)
-        load_rails(verbose: true)
-
-        ENV['HONEYBADGER_LOGGING_LEVEL']     = '0'
-        ENV['HONEYBADGER_LOGGING_TTY_LEVEL'] = '0'
-        ENV['HONEYBADGER_LOGGING_PATH']      = 'STDOUT'
-        ENV['HONEYBADGER_DEBUG']             = 'true'
-        ENV['HONEYBADGER_REPORT_DATA']       = options[:dry_run] ? 'false' : 'true'
+        Exec.new(options, args, config).run
+      rescue => e
+        log_error(e)
+        exit(1)
+      end
 
-        config = Config.new(rails_framework_opts)
-        say("\nConfiguration\n\n", :bold)
-        output_config(config.to_hash)
+      desc 'heroku SUBCOMMAND ...ARGS', 'Manage Honeybadger on Heroku'
+      subcommand 'heroku', Heroku
 
-        say("\nStarting Honeybadger\n\n", :bold)
-        Honeybadger.start(config) unless load_rails_env(verbose: true)
+      private
 
-        say("\nSending test notice\n\n", :bold)
-        send_test
+      def fetch_value(options, key)
+        options[key] == key ? nil : options[key]
+      end
 
-        say("\nRunning at exit hooks\n\n", :bold)
+      def build_config(options)
+        config = Config.new(logger: Logger.new('/dev/null'))
+        config.set(:api_key, fetch_value(options, 'api_key')) if options.has_key?('api_key')
+        config.set(:env, fetch_value(options, 'environment')) if options.has_key?('environment')
+        config.init!({
+          framework: :cli
+        })
+        config
       end
 
-      desc 'install API_KEY', 'Install Honeybadger into the current directory using API_KEY'
-      option :test, aliases: :'-t', type: :boolean, default: nil, desc: 'Send a test error'
-      def install(api_key)
-        say("Installing Honeybadger #{VERSION}")
+      def log_error(e)
+        case e
+        when *Util::HTTP::ERRORS
+          say(<<-MSG, :red)
+!! --- Failed to notify Honeybadger ------------------------------------------- !!
+
+# What happened?
+
+  We encountered an HTTP error while contacting our service. Issues like this are
+  usually temporary.
+
+# Error details
 
-        load_rails(verbose: true)
+  #{e.class}: #{e.message}\n    at #{e.backtrace && e.backtrace.first}
 
-        ENV['HONEYBADGER_LOGGING_LEVEL']     = '2'
-        ENV['HONEYBADGER_LOGGING_TTY_LEVEL'] = '0'
-        ENV['HONEYBADGER_LOGGING_PATH']      = 'STDOUT'
-        ENV['HONEYBADGER_REPORT_DATA']       = 'true'
+# What can I do?
 
-        config = Config.new(rails_framework_opts)
-        config[:api_key] = api_key.to_s
+  - Retry the command.
+  - Make sure you can connect to api.honeybadger.io (`ping api.honeybadger.io`).
+  - If you continue to see this message, email us at support@honeybadger.io
+    (don't forget to attach this output!)
 
-        if (path = config.config_path).exist?
-          say("You're already on Honeybadger, so you're all set.", :yellow)
+!! --- End -------------------------------------------------------------------- !!
+MSG
         else
-          say("Writing configuration to: #{path}", :yellow)
-
-          begin
-            config.write
-          rescue Config::ConfigError => e
-            error("Error: Unable to write configuration file:\n\t#{e}")
-            return
-          rescue StandardError => e
-            error("Error: Unable to write configuration file:\n\t#{e.class} -- #{e.message}\n\t#{e.backtrace.join("\n\t")}")
-            return
-          end
-        end
+          say(<<-MSG, :red)
+!! --- Honeybadger command failed --------------------------------------------- !!
 
-        if (capfile = Pathname.new(config[:root]).join('Capfile')).exist?
-          if capfile.read.match(/honeybadger/)
-            say("Detected Honeybadger in Capfile; skipping Capistrano installation.", :yellow)
-          else
-            say("Appending Capistrano tasks to: #{capfile}", :yellow)
-            File.open(capfile, 'a') do |f|
-              f.puts("\nrequire 'capistrano/honeybadger'")
-            end
-          end
-        end
+# What did you try to do?
 
-        if options[:test].nil? || options[:test]
-          Honeybadger.start(config) unless load_rails_env(verbose: true)
-          say('Sending test notice', :yellow)
-          unless Agent.instance && send_test(false)
-            say('Honeybadger is installed, but failed to send a test notice. Try `honeybadger test`.', :red)
-            exit(1)
-          end
-        end
+  You tried to execute the following command:
+  `honeybadger #{ARGV.join(' ')}`
 
-        say("Installation complete. Happy 'badgering!", :green)
-      end
+# What actually happend?
 
-      desc 'heroku SUBCOMMAND ...ARGS', 'Manage Honeybadger on Heroku'
-      subcommand 'heroku', Heroku
+  We encountered a Ruby exception and were forced to cancel your request.
 
-      private
+# Error details
 
-      def output_config(nested_hash, hierarchy = [])
-        nested_hash.each_pair do |key, value|
-          if value.kind_of?(Hash)
-            say(tab_indent(hierarchy.size) << "#{key}:")
-            output_config(value, hierarchy + [key])
-          else
-            dotted_key = (hierarchy + [key]).join('.').to_sym
-            say(tab_indent(hierarchy.size) << "#{key}:")
-            indent = tab_indent(hierarchy.size+1)
-            say(indent + "Description: #{Config::OPTIONS[dotted_key][:description]}")
-            say(indent + "Type: #{Config::OPTIONS[dotted_key].fetch(:type, String).name.split('::').last}")
-            say(indent + "Default: #{Config::OPTIONS[dotted_key][:default].inspect}")
-            say(indent + "Current: #{value.inspect}")
-          end
-        end
-      end
+  #{e.class}: #{e.message}
+    #{e.backtrace && e.backtrace.join("\n    ")}
+
+# What can I do?
+
+  - If you're calling the `install` or `test` command in a Rails app, make sure
+    you can boot the Rails console: `bundle exec rails console`.
+  - Retry the command.
+  - If you continue to see this message, email us at support@honeybadger.io
+    (don't forget to attach this output!)
 
-      def tab_indent(number)
-        ''.tap do |s|
-          number.times { s << "\s\s" }
+!! --- End -------------------------------------------------------------------- !!
+MSG
         end
       end
     end