honeybadger 4.4.2 → 4.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fac77f5cc8573711baf81c791a3f7377ef05e931c36a05be1e7b00225f1f4cbd
-  data.tar.gz: 8c622aa94f759c54d074c23dd7836c285449abb0399bd34642e616b352096f36
+  metadata.gz: 7cfde073c6afe9ef4757d7aaa4d86913ffb178a8d65907f0c872f1a55467c8bb
+  data.tar.gz: 66b637f1a022ddb27fe6ed8b64af4781d2a90bb7cdb644df349885614e56184b
 SHA512:
-  metadata.gz: 6c1a4792a723264e8f633f41d62ba85eeef2a895fe5dd14eccd3f9bce9820b0565338618a0057508295a9e0c4661b5fb8da25a45e54f2b09c11ed4a9fb1fbdf7
-  data.tar.gz: 872d754f468b46308632c668b8fdaa4b06786f517d16dd15f503aa05a7a814351f6c3f1c8e15b304441afd1a8cf01e1bbdbd7002ae8fd9f8abce96e4c14f7aab
+  metadata.gz: e4414164bbb59e6d82ff0d4ce1be1e9630f3c3fe8a35ca419740e899d0623d3375e9ef681fb402e4d5286fa01b9aac55e3190ad85f34467c9323404a6ea8fb4a
+  data.tar.gz: 3e8ffe0c2f9a877ca9abdf910ca556e6f9e11e6e865482807e6f03581e1c8ffc6a811c4629e91e613e037060014b589970a40910eb9758418ec2bcfe041e2e4b

data/CHANGELOG.md

@@ -5,6 +5,22 @@ adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+## [4.5.0] - 2019-08-05
+### Changed
+- Default `max_queue_size` has been reduced from 1000 to 100.
+
+### Added
+- Added `Notice#causes`, which allows cause data to be mutated in
+  `before_notify` callbacks (useful for filtering purposes).
+- Added `Notice#cause=`, which allows the cause to be changed or disabled
+  in `before_notify` callbacks.
+- Added extra shutdown logging.
+
+### Fixed
+- `Honeybadger.notify(exception, cause: nil)` will now prevent the cause from
+  being reported.
+- When throttled, queued notices will be discarded during shutdown.
+
 ## [4.4.2] - 2019-08-01
 ### Fixed
 - Handle ActiveSupport::Notifications passing nil started or finished time

data/lib/honeybadger/agent.rb

@@ -323,7 +323,7 @@ module Honeybadger
     # @example
     #   Honeybadger.stop # => nil
     def stop(force = false)
-      worker.send(force ? :shutdown! : :shutdown)
+      worker.shutdown(force)
       true
     end
 

data/lib/honeybadger/config/defaults.rb

@@ -81,7 +81,7 @@ module Honeybadger
       },
       max_queue_size: {
         description: 'Maximum number of items for each worker queue.',
-        default: 1000,
+        default: 100,
         type: Integer
       },
       plugins: {

data/lib/honeybadger/notice.rb

@@ -55,6 +55,17 @@ module Honeybadger
     # The Regexp used to strip invalid characters from individual tags.
     TAG_SANITIZER = /[^\w]/.freeze
 
+    # @api private
+    class Cause
+      attr_accessor :error_class, :error_message, :backtrace
+
+      def initialize(cause)
+        self.error_class = cause.class.name
+        self.error_message = cause.message
+        self.backtrace = cause.backtrace
+      end
+    end
+
     # The unique ID of this notice which can be used to reference the error in
     # Honeybadger.
     attr_reader :id
@@ -64,6 +75,13 @@ module Honeybadger
 
     # The exception cause if available.
     attr_reader :cause
+    def cause=(cause)
+      @cause = cause
+      @causes = unwrap_causes(cause)
+    end
+
+    # @return [Cause] A list of exception causes (see {Cause})
+    attr_reader :causes
 
     # The backtrace from the given exception or hash.
     attr_accessor :backtrace
@@ -163,15 +181,13 @@ module Honeybadger
       @request_sanitizer = Util::Sanitizer.new(filters: params_filters)
 
       @exception = unwrap_exception(opts[:exception])
-      @cause = opts[:cause] || exception_cause(@exception) || $!
-
-      @causes = unwrap_causes(@cause)
 
       self.error_class = exception_attribute(:error_class, 'Notice') {|exception| exception.class.name }
       self.error_message = exception_attribute(:error_message, 'No message provided') do |exception|
         "#{exception.class.name}: #{exception.message}"
       end
       self.backtrace = exception_attribute(:backtrace, caller)
+      self.cause = opts.key?(:cause) ? opts[:cause] : (exception_cause(@exception) || $!)
 
       self.context = construct_context_hash(opts, exception)
       self.local_variables = local_variables_from_exception(exception, config)
@@ -213,7 +229,7 @@ module Honeybadger
           backtrace: s(parse_backtrace(backtrace)),
           fingerprint: fingerprint_hash,
           tags: s(tags),
-          causes: s(causes)
+          causes: s(prepare_causes(causes))
         },
         request: request,
         server: {
@@ -256,8 +272,8 @@ module Honeybadger
 
     private
 
-    attr_reader :config, :opts, :stats, :now, :pid, :causes,
-      :request_sanitizer, :rack_env
+    attr_reader :config, :opts, :stats, :now, :pid, :request_sanitizer,
+      :rack_env
 
     def ignore_by_origin?
       return false if opts[:origin] != :rake
@@ -492,16 +508,12 @@ module Honeybadger
     #
     # cause - The first cause to unwrap.
     #
-    # Returns Array causes (in Hash payload format).
+    # Returns the Array of Cause instances.
     def unwrap_causes(cause)
       causes, c, i = [], cause, 0
 
       while c && i < MAX_EXCEPTION_CAUSES
-        causes << {
-          class: c.class.name,
-          message: c.message,
-          backtrace: parse_backtrace(c.backtrace || caller)
-        }
+        causes << Cause.new(c)
         i += 1
         c = exception_cause(c)
       end
@@ -509,6 +521,21 @@ module Honeybadger
       causes
     end
 
+    # Convert list of causes into payload format.
+    #
+    # causes - Array of Cause instances.
+    #
+    # Returns the Array of causes in Hash payload format.
+    def prepare_causes(causes)
+      causes.map {|c|
+        {
+          class: c.error_class,
+          message: c.error_message,
+          backtrace: parse_backtrace(c.backtrace)
+        }
+      }
+    end
+
     def params_filters
       config.params_filters + rails_params_filters
     end

data/lib/honeybadger/version.rb

@@ -1,4 +1,4 @@
 module Honeybadger
   # The current String Honeybadger version.
-  VERSION = '4.4.2'.freeze
+  VERSION = '4.5.0'.freeze
 end

data/lib/honeybadger/worker.rb

@@ -14,37 +14,34 @@ module Honeybadger
     # Sub-class thread so we have a named thread (useful for debugging in Thread.list).
     class Thread < ::Thread; end
 
-    # A queue which enforces a maximum size.
-    class Queue < ::Queue
-      attr_reader :max_size
-
-      def initialize(max_size)
-        @mutex = Mutex.new
-        @max_size = max_size
-        super()
-      end
-
-      def push(msg)
-        @mutex.synchronize do
-          super unless size >= max_size
-        end
-      end
-    end
-
+    # Used to signal the worker to shutdown.
     SHUTDOWN = :__hb_worker_shutdown!
 
+    # The base number for the exponential backoff formula when calculating the
+    # throttle interval. `1.05 ** throttle` will reach an interval of 2 minutes
+    # after around 100 429 responses from the server.
+    BASE_THROTTLE = 1.05
+
     def initialize(config)
       @config = config
-      @throttles = []
+      @throttle = 0
+      @throttle_interval = 0
       @mutex = Mutex.new
       @marker = ConditionVariable.new
-      @queue = Queue.new(config.max_queue_size)
+      @queue = Queue.new
       @shutdown = false
       @start_at = nil
+      @pid = Process.pid
     end
 
     def push(msg)
       return false unless start
+
+      if queue.size >= config.max_queue_size
+        warn { sprintf('Unable to report error; reached max queue size of %s. id=%s', queue.size, msg.id) }
+        return false
+      end
+
       queue.push(msg)
     end
 
@@ -52,44 +49,28 @@ module Honeybadger
       handle_response(msg, notify_backend(msg))
     end
 
-    def shutdown
+    def shutdown(force = false)
       d { 'shutting down worker' }
 
       mutex.synchronize do
         @shutdown = true
-        @pid = nil
-        queue.push(SHUTDOWN)
-      end
-
-      return true unless thread
-
-      r = true
-      unless Thread.current.eql?(thread)
-        begin
-          r = !!thread.join
-        ensure
-          shutdown! unless r
-        end
       end
 
-      r
-    end
+      return true if force
+      return true unless thread&.alive?
 
-    def shutdown!
-      mutex.synchronize do
-        @shutdown = true
-        @pid = nil
-        queue.clear
+      if throttled?
+        warn { sprintf('Unable to report %s error(s) to Honeybadger (currently throttled)', queue.size) } unless queue.empty?
+        return true
       end
 
-      d { 'killing worker thread' }
-
-      if thread
-        Thread.kill(thread)
-        thread.join # Allow ensure blocks to execute.
-      end
+      info { sprintf('Waiting to report %s error(s) to Honeybadger', queue.size) } unless queue.empty?
 
-      true
+      queue.push(SHUTDOWN)
+      !!thread.join
+    ensure
+      queue.clear
+      kill!
     end
 
     # Blocks until queue is processed up to this point in time.
@@ -109,7 +90,7 @@ module Honeybadger
         @shutdown = false
         @start_at = nil
 
-        return true if thread && thread.alive?
+        return true if thread&.alive?
 
         @pid = Process.pid
         @thread = Thread.new { run }
@@ -120,24 +101,48 @@ module Honeybadger
 
     private
 
-    attr_reader :config, :queue, :pid, :mutex, :marker,
-      :thread, :throttles
+    attr_reader :config, :queue, :pid, :mutex, :marker, :thread, :throttle,
+      :throttle_interval, :start_at
 
     def_delegator :config, :backend
 
+    def shutdown?
+      mutex.synchronize { @shutdown }
+    end
+
+    def suspended?
+      mutex.synchronize { start_at && Time.now.to_i < start_at }
+    end
+
     def can_start?
-      mutex.synchronize do
-        return true unless @shutdown
-        return false unless @start_at
-        Time.now.to_i >= @start_at
+      return false if shutdown?
+      return false if suspended?
+      true
+    end
+
+    def throttled?
+      mutex.synchronize { throttle > 0 }
+    end
+
+    def kill!
+      d { 'killing worker thread' }
+
+      if thread
+        Thread.kill(thread)
+        thread.join # Allow ensure blocks to execute.
       end
+
+      true
     end
 
     def suspend(interval)
-      mutex.synchronize { @start_at = Time.now.to_i + interval }
+      mutex.synchronize do
+        @start_at = Time.now.to_i + interval
+        queue.clear
+      end
 
       # Must be performed last since this may kill the current thread.
-      shutdown!
+      kill!
     end
 
     def run
@@ -155,7 +160,7 @@ module Honeybadger
       end
     rescue Exception => e
       error {
-        msg = "error in worker thread (shutting down) class=%s message=%s\n\t%s"
+        msg = "Error in worker thread (shutting down) class=%s message=%s\n\t%s"
         sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
       }
     ensure
@@ -164,46 +169,54 @@ module Honeybadger
 
     def work(msg)
       send_now(msg)
+
+      if shutdown? && throttled?
+        warn { sprintf('Unable to report %s error(s) to Honeybadger (currently throttled)', queue.size) } if queue.size > 1
+        kill!
+        return
+      end
+
       sleep(throttle_interval)
     rescue StandardError => e
       error {
         msg = "Error in worker thread class=%s message=%s\n\t%s"
         sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
       }
-      sleep(1)
-    end
-
-    def throttle_interval
-      return 0 unless throttles[0]
-      mutex.synchronize do
-        throttles.reduce(1) {|a,e| a*e }
-      end
     end
 
     def notify_backend(payload)
-      debug { sprintf('worker notifying backend id=%s', payload.id) }
+      d { sprintf('worker notifying backend id=%s', payload.id) }
       backend.notify(:notices, payload)
     end
 
-    def add_throttle(t)
+    def calc_throttle_interval
+      ((BASE_THROTTLE ** throttle) - 1).round(3)
+    end
+
+    def inc_throttle
       mutex.synchronize do
-        throttles.push(t)
+        @throttle += 1
+        @throttle_interval = calc_throttle_interval
+        throttle
       end
     end
 
-    def del_throttle
+    def dec_throttle
       mutex.synchronize do
-        throttles.shift
+        return nil if throttle == 0
+        @throttle -= 1
+        @throttle_interval = calc_throttle_interval
+        throttle
       end
     end
 
     def handle_response(msg, response)
-      debug { sprintf('worker response code=%s message=%s', response.code, response.message.to_s.dump) }
+      d { sprintf('worker response id=%s code=%s message=%s', msg.id, response.code, response.message.to_s.dump) }
 
       case response.code
       when 429, 503
-        warn { sprintf('Error report failed: project is sending too many errors. id=%s code=%s throttle=1.25 interval=%s', msg.id, response.code, throttle_interval) }
-        add_throttle(1.25)
+        throttle = inc_throttle
+        warn { sprintf('Error report failed: project is sending too many errors. id=%s code=%s throttle=%s interval=%s', msg.id, response.code, throttle, throttle_interval) }
       when 402
         warn { sprintf('Error report failed: payment is required. id=%s code=%s', msg.id, response.code) }
         suspend(3600)
@@ -211,8 +224,8 @@ module Honeybadger
         warn { sprintf('Error report failed: API key is invalid. id=%s code=%s', msg.id, response.code) }
         suspend(3600)
       when 201
-        if throttle = del_throttle
-          info { sprintf('Success ⚡ https://app.honeybadger.io/notice/%s id=%s code=%s throttle=%s interval=%s', msg.id, msg.id, response.code, throttle_interval, response.code) }
+        if throttle = dec_throttle
+          info { sprintf('Success ⚡ https://app.honeybadger.io/notice/%s id=%s code=%s throttle=%s interval=%s', msg.id, msg.id, response.code, throttle, throttle_interval) }
         else
           info { sprintf('Success ⚡ https://app.honeybadger.io/notice/%s id=%s code=%s', msg.id, msg.id, response.code) }
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: honeybadger
 version: !ruby/object:Gem::Version
-  version: 4.4.2
+  version: 4.5.0
 platform: ruby
 authors:
 - Honeybadger Industries LLC
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-01 00:00:00.000000000 Z
+date: 2019-08-05 00:00:00.000000000 Z
 dependencies: []
 description: Make managing application errors a more pleasant experience.
 email: