honeybadger 1.16.7 → 2.0.0.beta.1

data/lib/honeybadger/cli.rb

@@ -0,0 +1,367 @@
+$:.unshift(File.expand_path('../../../vendor/thor/lib', __FILE__))
+
+require 'thor'
+require 'honeybadger'
+require 'stringio'
+require 'logger'
+
+module Honeybadger
+  class CLI < Thor
+    class HoneybadgerTestingException < RuntimeError; end
+
+    NOT_BLANK = Regexp.new('\S').freeze
+
+    class_option :platform, aliases: :'-p', type: :string, default: nil, desc: 'Specify optional PLATFORM (e.g. "heroku")'
+    class_option :app, aliases: :'-a', type: :string, default: nil, desc: 'Specify optional APP with PLATFORM'
+
+    desc 'deploy', 'Notify Honeybadger of deployment'
+    option :environment, aliases: [:'-e', :'--env'], type: :string, desc: 'Environment of the deploy (i.e. "production", "staging")'
+    option :revision, aliases: [:'-r', :'--rev', :'--sha'], type: :string, desc: 'The revision/sha that is being deployed'
+    option :repository, aliases: :'--repo', type: :string, desc: 'The address of your repository'
+    option :local_username, aliases: [:'--user', :'-u'], type: :string, default: ENV['USER'] || ENV['USERNAME'], desc: 'The local user who is deploying'
+    option :api_key, aliases: [:'-k', :'--key'], type: :string, desc: 'Api key of your Honeybadger application'
+    def deploy
+      load_rails(verbose: true)
+      exit(1) unless !options[:platform] || load_platform(options[:platform], options[:app])
+
+      payload = Hash[[:environment, :revision, :repository, :local_username].map {|k| [k, options[k]] }]
+
+      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)
+      end
+
+      unless config.valid?
+        say("Invalid configuration: #{config.inspect}", :red)
+        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)
+      end
+    rescue => e
+      say("An error occurred during deploy notification: #{e}\n\t#{e.backtrace.join("\n\t")}", :red)
+      exit(1)
+    end
+
+    desc 'config', 'List configuration options'
+    option :default, aliases: :'-d', type: :boolean, default: true, desc: 'Output default options'
+    def config
+      exit(1) unless !options[:platform] || load_platform(options[:platform], options[:app])
+      load_rails
+      config = Config.new(rails_framework_opts)
+      output_config(config.to_hash(options[:default]))
+    end
+
+    desc 'debug', 'Output debug information'
+    option :test, aliases: :'-t', type: :boolean, default: false, desc: 'Send a test error'
+    option :file, aliases: :'-f', type: :string, default: nil, desc: 'Write the output to FILE.'
+    def debug
+      if options[:file]
+        out = StringIO.new
+        $stdout = out
+
+        Agent.at_exit 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
+      end
+
+      ENV['HONEYBADGER_LOGGING_PATH']  ||= 'STDOUT'
+      ENV['HONEYBADGER_LOGGING_LEVEL'] ||= '0'
+      ENV['HONEYBADGER_PUBLIC']        ||= 'true'
+
+      exit(1) unless !options[:platform] || load_platform(options[:platform], options[:app])
+      say("\n") if options[:platform] # Print a blank line if we just logged the platform.
+
+      say("Detecting framework\n\n", :bold)
+      load_rails(verbose: true)
+
+      config = Config.new(rails_framework_opts)
+      say("\nConfiguration\n\n", :bold)
+      output_config(config.to_hash)
+
+      if options[:test]
+        Honeybadger.start(config) unless load_rails_env(verbose: true)
+        say("\nSending test notice\n\n", :bold)
+        send_test
+      end
+      say("\nRunning at exit hooks\n\n", :bold)
+    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}")
+
+      ENV['HONEYBADGER_LOGGING_PATH']  ||= 'STDOUT'
+      ENV['HONEYBADGER_LOGGING_LEVEL'] ||= '2'
+      ENV['HONEYBADGER_PUBLIC']        ||= 'true'
+
+      exit(1) unless !options[:platform] || load_platform(options[:platform], options[:app])
+
+      load_rails(verbose: true)
+
+      config = Config.new(rails_framework_opts)
+      config[:api_key] = api_key
+
+      if options[:platform]
+        if options[:platform] == 'heroku'
+          say("Adding config HONEYBADGER_API_KEY=#{api_key} to heroku.", :magenta)
+          unless write_heroku_env({'HONEYBADGER_API_KEY' => api_key}, options[:app])
+            say('Unable to update heroku config. Do you need to specify an app name?', :red)
+            return
+          end
+        end
+      elsif (path = config.config_path).exist?
+        say("You're already on Honeybadger, so you're all set.", :yellow)
+        skip_test = true if options[:test].nil? # Only if it wasn't specified.
+      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
+
+      if !skip_test && (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 debug --test`.', :red)
+          return
+        end
+      end
+
+      say("Installation complete. Happy 'badgering!", :green)
+    end
+
+    private
+
+    def rails?(opts = {})
+      @rails ||= load_rails(opts)
+    end
+
+    def load_rails(opts = {})
+      begin
+        require 'honeybadger/init/rails'
+        if ::Rails::VERSION::MAJOR >= 3
+          say("Detected Rails #{::Rails::VERSION::STRING}") if opts[:verbose]
+        else
+          say("Error: Rails #{::Rails::VERSION::STRING} is unsupported.", :red)
+          exit(1)
+        end
+      rescue LoadError
+        say("Rails was not detected, loading standalone.") if opts[:verbose]
+        return @rails = false
+      rescue StandardError => e
+        say("Error while detecting Rails: #{e.class} -- #{e.message}", :red)
+        exit(1)
+      end
+
+      begin
+        require File.expand_path('config/application')
+      rescue LoadError
+        say('Error: could not load Rails application. Please ensure you run this command from your project root.', :red)
+        exit(1)
+      end
+
+      @rails = true
+    end
+
+    def load_rails_env(opts = {})
+      return false unless rails?(opts)
+
+      puts('Loading Rails environment') if opts[:verbose]
+      begin
+        require File.expand_path('config/environment')
+      rescue LoadError
+        say('Error: could not load Rails environment. Please ensure you run this command from your project root.', :red)
+        exit(1)
+      end
+
+      true
+    end
+
+    def rails_framework_opts
+      return {} unless defined?(::Rails)
+
+      {
+        :root           => ::Rails.root,
+        :env            => ::Rails.env,
+        :'config.path'  => ::Rails.root.join('config', 'honeybadger.yml'),
+        :framework_name => "Rails #{::Rails::VERSION::STRING}",
+        :api_key        => rails_secrets_api_key
+      }
+    end
+
+    def rails_secrets_api_key
+      if defined?(::Rails.application.secrets)
+        ::Rails.application.secrets.honeybadger_api_key
+      end
+    end
+
+    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 + "Default: #{Config::OPTIONS[dotted_key][:default].to_s}")
+          say(indent + "Current: #{value.to_s}")
+        end
+      end
+    end
+
+    def tab_indent(number)
+      ''.tap do |s|
+        number.times { s << "\s\s" }
+      end
+    end
+
+    def load_platform(platform, app = nil)
+      if platform.to_sym == :heroku
+        say("Using platform: #{platform}" << (app ? " (app: #{app})" : ""))
+        unless set_env_from_heroku(app)
+          say("Unable to load ENV from Heroku. Do you need to specify an app name?", :red)
+          return false
+        end
+      end
+
+      true
+    end
+
+    def read_heroku_env(app = nil)
+      cmd = ['heroku config']
+      cmd << "--app #{app}" if app
+      output = Bundler.with_clean_env { `#{cmd.join("\s")}` }
+      return false unless $?.to_i == 0
+      Hash[output.scan(/(HONEYBADGER_[^:]+):\s*(\S.*)\s*$/)]
+    end
+
+    def set_env_from_heroku(app = nil)
+      return false unless env = read_heroku_env(app)
+      env.each_pair do |k,v|
+        ENV[k] ||= v
+      end
+    end
+
+    def write_heroku_env(env, app = nil)
+      cmd = ["heroku config:set"]
+      Hash(env).each_pair {|k,v| cmd << "#{k}=#{v}" }
+      cmd << "--app #{app}" if app
+      Bundler.with_clean_env { `#{cmd.join("\s")}` }
+      $?.to_i == 0
+    end
+
+    def test_exception_class
+      exception_name = ENV['EXCEPTION'] || 'HoneybadgerTestingException'
+      Object.const_get(exception_name)
+    rescue
+      Object.const_set(exception_name, Class.new(Exception))
+    end
+
+    def send_test(verbose = true)
+      if defined?(::Rails)
+        rails_test(verbose)
+      else
+        standalone_test
+      end
+    end
+
+    def standalone_test
+      Honeybadger.notify(test_exception_class.new('Testing honeybadger via "honeybadger test". If you can see this, it works.'))
+    end
+
+    def rails_test(verbose = true)
+      if verbose
+        ::Rails.logger = if defined?(::ActiveSupport::TaggedLogging)
+                           ::ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
+                         else
+                           Logger.new(STDOUT)
+                         end
+        ::Rails.logger.level = Logger::INFO
+      end
+
+      # Suppress error logging in Rails' exception handling middleware. Rails 3.0
+      # uses ActionDispatch::ShowExceptions to rescue/show exceptions, but does
+      # not log anything but application trace. Rails 3.2 now falls back to
+      # logging the framework trace (moved to ActionDispatch::DebugExceptions),
+      # which caused cluttered output while running the test task.
+      defined?(::ActionDispatch::DebugExceptions) and
+        ::ActionDispatch::DebugExceptions.class_eval { def logger(*args) ; @logger ||= Logger.new('/dev/null') ; end }
+      defined?(::ActionDispatch::ShowExceptions) and
+      ::ActionDispatch::ShowExceptions.class_eval { def logger(*args) ; @logger ||= Logger.new('/dev/null') ; end }
+
+      # Detect and disable the better_errors gem
+      if defined?(::BetterErrors::Middleware)
+        say('Better Errors detected: temporarily disabling middleware.', :yellow)
+        ::BetterErrors::Middleware.class_eval { def call(env) @app.call(env); end }
+      end
+
+      begin
+        require './app/controllers/application_controller'
+      rescue LoadError
+        nil
+      end
+
+      unless defined?(::ApplicationController)
+        say('Error: No ApplicationController found.', :red)
+        return false
+      end
+
+      say('Setting up the Controller.')
+      ::ApplicationController.class_eval do
+        # This is to bypass any filters that may prevent access to the action.
+        prepend_before_filter :test_honeybadger
+        def test_honeybadger
+          puts "Raising '#{exception_class.name}' to simulate application failure."
+          raise exception_class.new, 'Testing honeybadger via "rake honeybadger:test". If you can see this, it works.'
+        end
+
+        # Ensure we actually have an action to go to.
+        def verify; end
+
+        def exception_class
+          exception_name = ENV['EXCEPTION'] || 'HoneybadgerTestingException'
+          Object.const_get(exception_name)
+        rescue
+          Object.const_set(exception_name, Class.new(Exception))
+        end
+      end
+
+      ::Rails.application.routes.draw do
+        match 'verify' => 'application#verify', :as => 'verify', :via => :get
+      end
+
+      say('Processing request.')
+
+      ssl = defined?(::Rails.configuration.force_ssl) && ::Rails.configuration.force_ssl
+      env = ::Rack::MockRequest.env_for("http#{ ssl ? 's' : nil }://www.example.com/verify", 'REMOTE_ADDR' => '127.0.0.1')
+
+      ::Rails.application.call(env)
+    end
+  end
+end

data/lib/honeybadger/config.rb

@@ -0,0 +1,333 @@
+require 'pathname'
+require 'delegate'
+require 'logger'
+require 'fileutils'
+require 'openssl'
+
+require 'honeybadger/version'
+require 'honeybadger/logging'
+require 'honeybadger/backend'
+require 'honeybadger/config/defaults'
+require 'honeybadger/util/http'
+require 'honeybadger/logging'
+
+module Honeybadger
+  class Config
+    extend Forwardable
+
+    include Logging::Helper
+
+    class ConfigError < StandardError; end
+
+    autoload :Callbacks, 'honeybadger/config/callbacks'
+    autoload :Env, 'honeybadger/config/env'
+    autoload :Yaml, 'honeybadger/config/yaml'
+
+    KEY_REPLACEMENT = Regexp.new('[^a-z\d_]', Regexp::IGNORECASE).freeze
+
+    DISALLOWED_KEYS = [:'config.path'].freeze
+
+    DOTTED_KEY = Regexp.new('\A([^\.]+)\.(.+)\z').freeze
+
+    NOT_BLANK = Regexp.new('\S').freeze
+
+    FEATURES = [:notices, :local_variables, :metrics, :traces].freeze
+
+    def initialize(opts = {})
+      l = opts.delete(:logger)
+
+      @values = opts
+
+      load_config_from_disk do |yml|
+        update(yml)
+      end
+
+      update(Env.new(ENV))
+
+      self.logger = Logging::SupplementedLogger.new(build_logger(l))
+      Logging::BootLogger.instance.flush(logger)
+
+      @features = Hash[FEATURES.map{|f| [f, true] }]
+    end
+
+    def_delegators :@values, :update
+
+    attr_reader :features
+
+    def get(key)
+      key = key.to_sym
+      if @values.include?(key)
+        @values[key]
+      else
+        DEFAULTS[key]
+      end
+    end
+    alias [] :get
+
+    def set(key, value)
+      @values[key] = value
+    end
+    alias []= :set
+
+    def to_hash(defaults = false)
+      hash = defaults ? DEFAULTS.merge(@values) : @values
+      undotify_keys(hash.select {|k,v| DEFAULTS.has_key?(k) })
+    end
+    alias :to_h :to_hash
+
+    def backend
+      Backend.for((self[:backend] || default_backend).to_sym).new(self)
+    end
+
+    def public?
+      return true if self[:public]
+      return false if self[:public] == false
+      !self[:env] || self[:environments].include?(self[:env])
+    end
+
+    def default_backend
+      if public?
+        :server
+      else
+        :null
+      end
+    end
+
+    def valid?
+      self[:api_key] =~ /\S/
+    end
+
+    def logger
+      @logger || Logging::SupplementedLogger.new(Logging::BootLogger.instance)
+    end
+
+    def logger=(logger)
+      @logger = logger.nil? ? Logger.new('/dev/null') : logger
+    end
+
+    # Internal: Optional path to honeybadger.log log file. If nil, STDOUT will be used
+    # instead.
+    #
+    # Returns the Pathname log path if a log path was specified.
+    def log_path
+      if self[:'logging.path'] && self[:'logging.path'] != 'STDOUT'
+        locate_absolute_path(self[:'logging.path'], self[:root])
+      end
+    end
+
+    # Internal: Path to honeybadger.yml configuration file; this should be the root
+    # directory if no path was specified.
+    #
+    # Returns the Pathname configuration path.
+    def config_path
+      locate_absolute_path(Array(self[:'config.path']).first, self[:root])
+    end
+
+    def config_paths
+      Array(self[:'config.path']).map do |c|
+        locate_absolute_path(c, self[:root])
+      end
+    end
+
+    def ca_bundle_path
+      if self[:'connection.system_ssl_cert_chain'] && File.exist?(OpenSSL::X509::DEFAULT_CERT_FILE)
+        OpenSSL::X509::DEFAULT_CERT_FILE
+      else
+        local_cert_path
+      end
+    end
+
+    def local_cert_path
+      File.expand_path(File.join('..', '..', '..', 'resources', 'ca-bundle.crt'), __FILE__)
+    end
+
+    def connection_port
+      if self[:'connection.port']
+        self[:'connection.port']
+      elsif self[:'connection.secure']
+        443
+      else
+        80
+      end
+    end
+
+    def connection_protocol
+      if self[:'connection.secure']
+        'https'
+      else
+        'http'
+      end
+    end
+
+    def request
+      Thread.current[:__honeybadger_request]
+    end
+
+    def with_request(request, &block)
+      Thread.current[:__honeybadger_request] = request
+      yield
+    ensure
+      Thread.current[:__honeybadger_request] = nil
+    end
+
+    def params_filters
+      self[:'request.filter_keys'] + rails_params_filters
+    end
+
+    def rails_params_filters
+      request && request.env['action_dispatch.parameter_filter'] or []
+    end
+
+    def write
+      path = config_path
+
+      if path.exist?
+        raise ConfigError, "The configuration file #{path} already exists."
+      elsif !path.dirname.writable?
+        raise ConfigError, "The configuration path #{path.dirname} is not writable."
+      end
+
+      File.open(path, 'w+') do |file|
+        file.write(<<-CONFIG)
+---
+api_key: #{self[:api_key]}
+                   CONFIG
+      end
+    end
+
+    def log_level
+      case self[:'logging.level'].to_s
+      when /\A(0|debug)\z/i then Logger::DEBUG
+      when /\A(1|info)\z/i  then Logger::INFO
+      when /\A(2|warn)\z/i  then Logger::WARN
+      when /\A(3|error)\z/i then Logger::ERROR
+      else
+        Logger::INFO
+      end
+    end
+
+    def load_plugin?(name)
+      return false if Array(self[:'plugins.skip']).include?(name)
+      return true  if self[:plugins].nil?
+      Array(self[:plugins]).include?(name)
+    end
+
+    def ping
+      if result = send_ping
+        @features = symbolize_keys(result['features']) if result['features']
+        return true
+      end
+
+      false
+    end
+
+    def framework
+      if self[:framework] =~ NOT_BLANK
+        self[:framework].to_sym
+      elsif defined?(::Rails::VERSION) && ::Rails::VERSION::STRING > '3.0'
+        :rails
+      elsif defined?(::Sinatra::VERSION)
+        :sinatra
+      elsif defined?(::Rack.release)
+        :rack
+      else
+        :ruby
+      end
+    end
+
+    def framework_name
+      case framework
+      when :rails then "Rails #{::Rails::VERSION::STRING}"
+      when :sinatra then "Sinatra #{::Sinatra::VERSION}"
+      when :rack then "Rack #{::Rack.release}"
+      else
+        "Ruby #{RUBY_VERSION}"
+      end
+    end
+
+    private
+
+    def ping_payload
+      {
+        version: VERSION,
+        framework: framework_name,
+        environment: self[:env],
+        hostname: self[:hostname],
+        config: to_hash
+      }
+    end
+
+    def send_ping
+      payload = ping_payload.to_json
+      debug { sprintf('ping payload=%s', payload.dump) }
+      response = backend.notify(:ping, payload)
+      if response.success?
+        debug { sprintf('ping response=%s', response.body.dump) }
+        JSON.parse(response.body)
+      else
+        warn do
+          msg = sprintf('ping failure code=%s', response.code)
+          msg << sprintf(' message=%s', response.message.dump) if response.message =~ NOT_BLANK
+          msg
+        end
+        nil
+      end
+    end
+
+    def locate_absolute_path(path, root)
+      path = Pathname.new(path)
+      if path.absolute?
+        path
+      else
+        Pathname.new(root).join(path)
+      end
+    end
+
+    def build_logger(default = nil)
+      if path = log_path
+        FileUtils.mkdir_p(path.dirname) unless path.dirname.writable?
+        Logger.new(path).tap do |logger|
+          logger.level = log_level
+          logger.formatter = Logger::Formatter.new
+        end
+      elsif self[:'logging.path'] != 'STDOUT' && default
+        default
+      else
+        logger = Logger.new($stdout)
+        logger.level = log_level
+        logger.formatter = lambda do |severity, datetime, progname, msg|
+          "#{msg}\n"
+        end
+        Logging::FormattedLogger.new(logger)
+      end
+    end
+
+    def load_config_from_disk
+      if (path = config_paths.find(&:exist?)) && path.file?
+        Yaml.new(path, self[:env]).tap do |yml|
+          yield(yml) if block_given?
+        end
+      end
+    rescue ConfigError => e
+      logger.error("Error while loading config from disk: #{e}")
+      nil
+    end
+
+    def undotify_keys(hash)
+      {}.tap do |new_hash|
+        hash.each_pair do |k,v|
+          if k.to_s =~ DOTTED_KEY
+            new_hash[$1] ||= {}
+            new_hash[$1] = undotify_keys(new_hash[$1].merge({$2 => v}))
+          else
+            new_hash[k] = v
+          end
+        end
+      end
+    end
+
+    def symbolize_keys(hash)
+      Hash[hash.map {|k,v| [k.to_sym, v] }]
+    end
+  end
+end