honeybadger 2.0.0.beta.4 → 2.0.0.beta.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ba1be7a850ea94ace04e9efa6fa6d4c6e0ac1db6
-  data.tar.gz: c38fd1d1ef9abb8fe11cb6e753e492b6b8693b7e
+  metadata.gz: edb87206be0175b43798167c6e093aed0e558197
+  data.tar.gz: 87c340cd804c678a4c9a5e4623fd3a670bc088a7
 SHA512:
-  metadata.gz: 71ceaf81608805c2e63f8eff80f9e78d77c5a7e3793aa9b27d8850dcea79801d19a588f41a722388d9c1d06ff4d5feb1b30fad4860574dd0a5325329cef419f8
-  data.tar.gz: 1336df3462a84175207ab6c6f4fac477f2ed64ba990a0fad4bdd5472316befc2ccc40f1e720b7876c4ee75befb866a88166448e2feeb5c9f46d40d0ac937f712
+  metadata.gz: 4c943955fad4f187e3bd56c20fb8ab0b6eb08751d3811dbcc929f62a55473bd6279b78bbb6c2def674883bbb08f5fe5fa3c6c06afb396274602c067b08f1b049
+  data.tar.gz: eacf1d47e855c9cff4be194ce6c127b203173923a88a10dbbe85af4c38632c249d7c213a146c8d5b3af58cf97c4012524bbdf98dc3da87332147744720df5536

data/lib/honeybadger/agent.rb

@@ -51,10 +51,10 @@ module Honeybadger
       end
 
       if config[:disabled]
-        config.logger.info('Unable to start Honeybadger -- disabled by configuration.')
+        config.logger.warn('Unable to start Honeybadger -- disabled by configuration.')
         return false
       elsif !config.valid?
-        config.logger.warn('Unable to start Honeybadger -- invalid configuration.')
+        config.logger.warn('Unable to start Honeybadger -- api_key is missing or invalid.')
         return false
       elsif !config.ping
         config.logger.warn('Unable to start Honeybadger -- failed to connect to server.')
@@ -98,6 +98,20 @@ module Honeybadger
       @at_exit
     end
 
+    # Internal: Not for public consumption. :)
+    #
+    # Prefer dependency injection over accessing config directly, but some
+    # cases (such as the delayed_job plugin) necessitate it.
+    #
+    # Returns the Agent's config if running, otherwise default config
+    def self.config
+      if running?
+        instance.send(:config)
+      else
+        @config ||= Config.new
+      end
+    end
+
     def initialize(config)
       @config = config
       @worker = Worker.new(config)
@@ -108,11 +122,14 @@ module Honeybadger
       end
     end
 
-    def_delegators :@worker, :start, :fork, :trace, :timing, :increment
+    def_delegators :@worker, :stop, :fork, :trace, :timing, :increment
+
+    def start
+      unless worker.backend.kind_of?(Backend::Server)
+        warn('Initializing development backend: data will not be reported.')
+      end
 
-    def stop(force = false)
-      info("Shutting down Honeybadger version #{VERSION}")
-      worker.stop(force)
+      worker.start
     end
 
     def notice(opts)

data/lib/honeybadger/backend/debug.rb

@@ -2,9 +2,12 @@ require 'honeybadger/backend/null'
 
 module Honeybadger
   module Backend
+    # Internal: Logs the notice payload rather than sending it. The purpose of
+    # this backend is primarily for programmatically inspecting JSON payloads
+    # in integration tests.
     class Debug < Null
       def notify(feature, payload)
-        logger.debug("notifying debug backend of feature=#{feature}\n\t#{payload.to_json}")
+        logger.unknown("notifying debug backend of feature=#{feature}\n\t#{payload.to_json}")
         super
       end
     end

data/lib/honeybadger/backend/null.rb

@@ -5,7 +5,6 @@ module Honeybadger
     class Null < Base
       def initialize(*args)
         super
-        logger.warn('Initializing development backend: data will not be reported.')
       end
 
       def notify(feature, payload)

data/lib/honeybadger/cli.rb

@@ -68,7 +68,7 @@ module Honeybadger
         out = StringIO.new
         $stdout = out
 
-        Agent.at_exit do
+        flush = Proc.new do
           $stdout = STDOUT
           File.open(options[:file], 'w+') do |f|
             out.rewind
@@ -77,11 +77,15 @@ module Honeybadger
 
           say("Output written to #{options[:file]}", :green)
         end
-      end
 
-      ENV['HONEYBADGER_LOGGING_PATH']  ||= 'STDOUT'
-      ENV['HONEYBADGER_LOGGING_LEVEL'] ||= '0'
-      ENV['HONEYBADGER_REPORT_DATA']   ||= 'true'
+        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
+      end
 
       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.
@@ -89,15 +93,24 @@ module Honeybadger
       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']       = 'true'
+
       config = Config.new(rails_framework_opts)
       say("\nConfiguration\n\n", :bold)
       output_config(config.to_hash)
 
+      say("\nStarting Honeybadger\n\n", :bold)
+      Honeybadger.start(config) unless load_rails_env(verbose: true)
+
       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
 
@@ -106,14 +119,15 @@ module Honeybadger
     def install(api_key)
       say("Installing Honeybadger #{VERSION}")
 
-      ENV['HONEYBADGER_LOGGING_PATH']  ||= 'STDOUT'
-      ENV['HONEYBADGER_LOGGING_LEVEL'] ||= '2'
-      ENV['HONEYBADGER_REPORT_DATA']   ||= 'true'
-
       exit(1) unless !options[:platform] || load_platform(options[:platform], options[:app])
 
       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'
+
       config = Config.new(rails_framework_opts)
       config[:api_key] = api_key
 

data/lib/honeybadger/config.rb

@@ -44,15 +44,15 @@ module Honeybadger
 
       update(Env.new(ENV))
 
-      self.logger = Logging::SupplementedLogger.new(build_logger(l))
-      Logging::BootLogger.instance.flush(logger)
+      @logger = Logging::ConfigLogger.new(self, build_logger(l))
+      Logging::BootLogger.instance.flush(@logger)
 
       @features = Hash[FEATURES.map{|f| [f, true] }]
     end
 
     def_delegators :@values, :update
 
-    attr_reader :features
+    attr_reader :logger, :features
 
     def get(key)
       key = key.to_sym
@@ -97,12 +97,8 @@ module Honeybadger
       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
+    def debug?
+      self[:debug]
     end
 
     # Internal: Optional path to honeybadger.log log file. If nil, STDOUT will be used
@@ -204,8 +200,8 @@ api_key: #{self[:api_key]}
       end
     end
 
-    def log_level
-      case self[:'logging.level'].to_s
+    def log_level(key = :'logging.level')
+      case self[key].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

data/lib/honeybadger/config/defaults.rb

@@ -46,7 +46,7 @@ module Honeybadger
         default: false
       },
       development_environments: {
-        description: 'Environments which are disabled by default (use report_data to enable/disable explicitly).',
+        description: 'Environments which will not report data by default (use report_data to enable/disable explicitly).',
         default: ['development'.freeze, 'test'.freeze, 'cucumber'.freeze].freeze
       },
       plugins: {
@@ -69,6 +69,10 @@ module Honeybadger
         description: 'The log level.',
         default: 'INFO'
       },
+      :'logging.tty_level' => {
+        description: 'Level to log when attached to a terminal (anything < logging.level will always be ignored).',
+        default: 'DEBUG'
+      },
       :'connection.secure' => {
         description: 'Use SSL when sending data.',
         default: true
@@ -180,6 +184,10 @@ module Honeybadger
       :'traces.threshold' => {
         description: 'The threshold in seconds to send traces.',
         default: 2000
+      },
+      :'delayed_job.attempt_threshold' => {
+        description: 'The number of attempts before notifications will be sent.',
+        default: 0
       }
     }.freeze
 

data/lib/honeybadger/logging.rb

@@ -6,27 +6,32 @@ module Honeybadger
   module Logging
     PREFIX = '** [Honeybadger] '.freeze
 
+    # Internal: Logging helper methods. Requires a Honeybadger::Config @config
+    # instance variable to exist and/or #logger to be defined. Each
+    # method is defined/block captured in this module rather than delegating to
+    # the logger directly to avoid extra object allocation.
     module Helper
       def debug(msg = nil)
-        return if Logger::Severity::DEBUG < logger.level
+        return true unless logger.debug?
         msg = yield if block_given?
         logger.debug(msg)
       end
+      alias :d :debug
 
       def info(msg = nil)
-        return if Logger::Severity::INFO < logger.level
+        return true if Logger::Severity::INFO < logger.level
         msg = yield if block_given?
         logger.info(msg)
       end
 
       def warn(msg = nil)
-        return if Logger::Severity::WARN < logger.level
+        return true if Logger::Severity::WARN < logger.level
         msg = yield if block_given?
         logger.warn(msg)
       end
 
       def error(msg = nil)
-        return if Logger::Severity::ERROR < logger.level
+        return true if Logger::Severity::ERROR < logger.level
         msg = yield if block_given?
         logger.error(msg)
       end
@@ -43,7 +48,7 @@ module Honeybadger
         end
       end
 
-      def add(severity, message)
+      def add(severity, msg)
         raise NotImplementedError, 'must define #add on subclass.'
       end
 
@@ -52,7 +57,26 @@ module Honeybadger
       end
     end
 
-    class FormattedLogger < Base
+    class BootLogger < Base
+      include Singleton
+
+      def initialize
+        @messages = []
+      end
+
+      def add(severity, msg)
+        @messages << [severity, msg]
+      end
+
+      def flush(logger)
+        @messages.each do |msg|
+          logger.add(*msg)
+        end
+        @messages.clear
+      end
+    end
+
+    class StandardLogger < Base
       def initialize(logger = Logger.new('/dev/null'))
         raise ArgumentError, 'logger not specified' unless logger
         raise ArgumentError, 'logger must be a logger' unless logger.respond_to?(:add)
@@ -60,67 +84,79 @@ module Honeybadger
         @logger = logger
       end
 
-      def add(severity, message)
-        @logger.add(severity, format_message(message))
+      def add(severity, msg)
+        @logger.add(severity, msg)
       end
 
       def level
         @logger.level
       end
-
-      private
-
-      def format_message(message)
-        return message unless message.kind_of?(String)
-        PREFIX + message
-      end
     end
 
-    class BootLogger < Base
-      include Singleton
-
-      def initialize
-        @messages = []
+    class FormattedLogger < StandardLogger
+      def add(severity, msg)
+        super(severity, format_message(msg))
       end
 
-      def add(severity, message)
-        @messages << [severity, message]
-      end
+      private
 
-      def flush(logger)
-        @messages.each do |msg|
-          logger.add(*msg)
-        end
-        @messages.clear
+      def format_message(msg)
+        return msg unless msg.kind_of?(String)
+        PREFIX + msg
       end
     end
 
-    class SupplementedLogger < SimpleDelegator
+    class ConfigLogger < StandardLogger
       LOCATE_CALLER_LOCATION = Regexp.new("#{Regexp.escape(__FILE__)}").freeze
       CALLER_LOCATION = Regexp.new("#{Regexp.escape(File.expand_path('../../../', __FILE__))}/(.*)").freeze
 
       INFO_SUPPLEMENT = ' level=%s pid=%s'.freeze
       DEBUG_SUPPLEMENT = ' at=%s'.freeze
 
-      def initialize(logger = Logger.new('/dev/null'))
-        raise ArgumentError, 'logger not specified' unless logger
-        super
+      def initialize(config, logger = Logger.new('/dev/null'))
+        @config = config
+        @tty = STDOUT.tty?
+        @tty_level = @config.log_level(:'logging.tty_level')
+        super(logger)
       end
 
-      Logger::Severity.constants.each do |severity|
-        define_method l = severity.downcase do |msg|
-          __getobj__().send(l, supplement(msg, l))
+      def add(severity, msg)
+        return true if suppress_tty?(severity)
+
+        # There is no debug level in Honeybadger. Debug logs will be logged at
+        # the info level if the debug config option is on.
+        if severity == Logger::Severity::DEBUG
+          return true if suppress_debug?
+          super(Logger::Severity::INFO, supplement(msg, Logger::Severity::DEBUG))
+        else
+          super(severity, supplement(msg, severity))
         end
       end
 
+      def debug?
+        @config.debug?
+      end
+
       private
 
-      def supplement(msg, level)
-        msg << sprintf(INFO_SUPPLEMENT, level, Process.pid)
-        if level == :debug && l = caller_location
-          msg << sprintf(DEBUG_SUPPLEMENT, l.dump)
+      def suppress_debug?
+        !debug?
+      end
+
+      def suppress_tty?(severity)
+        @tty && severity < @tty_level
+      end
+
+      def supplement(msg, severity)
+        return msg unless msg.kind_of?(String)
+
+        r = msg.dup
+        r << sprintf(INFO_SUPPLEMENT, severity, Process.pid)
+        if severity == Logger::Severity::DEBUG && l = caller_location
+          r << sprintf(DEBUG_SUPPLEMENT, l.dump)
         end
-        msg
+
+        r
       end
 
       def caller_location

data/lib/honeybadger/plugins/delayed_job/plugin.rb

@@ -23,7 +23,7 @@ module Honeybadger
                   :attempts      => job.attempts,
                   :queue         => job.queue
                 }
-              )
+              ) if job.attempts.to_i >= ::Honeybadger::Agent.config[:'delayed_job.attempt_threshold'].to_i
               raise error
             ensure
               ::Honeybadger.context.clear!

data/lib/honeybadger/version.rb

@@ -1,4 +1,4 @@
 module Honeybadger
   # Public: The current String Honeybadger version.
-  VERSION = '2.0.0.beta.4'.freeze
+  VERSION = '2.0.0.beta.5'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: honeybadger
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta.4
+  version: 2.0.0.beta.5
 platform: ruby
 authors:
 - Honeybadger Industries LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-15 00:00:00.000000000 Z
+date: 2014-09-24 00:00:00.000000000 Z
 dependencies: []
 description: Make managing application errors a more pleasant experience.
 email: