honeybadger 6.9.2 → 6.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a87b6390eaeefa3027fa561efe5c289817d3bf7785d5e9f7ba0d56bf0937141
-  data.tar.gz: a191e258298fbe566e6a7914fef8647f3b3dfb3c0ab83dfa0aaa1689ba4f30d7
+  metadata.gz: 0a8b90189275576b1cb4bca4f7ee77db0fe316415a03239cd61ce1585deddb42
+  data.tar.gz: b5c7cdbcfd8a655009872a9b3e02f7aec6917684172fc5b270c8cf559b46f52f
 SHA512:
-  metadata.gz: dd5b1e3392c7d74312d66bf50a9a80ae7534526a717fbc68e851283bd0ff02f2f9d578bd6730b32364d4e9ca1dd1b3031e52191aa148c1da72634733c9a3a16b
-  data.tar.gz: f3c484065df9a52ef468140d725681238cf8701a5bf819f80fd06e36b0f515eea94245d42ab9682c44801ede8036fe227b7b546deca7c90fb2fa7bd0cf28790e
+  metadata.gz: 666daade7949f2d486498eda33d6f74fb411a1745081e212aeb838b1cb9dd72ad9125d3631b6d0a6fe4e225ab251ead2a7d5c4e41fa00ba093435914f671861e
+  data.tar.gz: 7c24c28bf5184bb79d7c1e87ce7ba1f36ffff14863b8cc50582cf8b01cc5e07a220ae51f0f4d41df384ffc88dafcce797ee03a54eaf0df3563e6dab9396e0070

data/CHANGELOG.md

@@ -1,6 +1,24 @@
 # Change Log
 
 
+## [6.10.0](https://github.com/honeybadger-io/honeybadger-ruby/compare/v6.9.3...v6.10.0) (2026-10-20)
+
+
+### Bug Fixes
+
+* retry notices and events on short Retry-After instead of dropping them ([#847](https://github.com/honeybadger-io/honeybadger-ruby/issues/847)) ([bb948b3](https://github.com/honeybadger-io/honeybadger-ruby/commit/bb948b309f2dcc6c01c052f8ea3519c5a68187ac))
+
+### Changed
+
+* Default `events.max_queue_size` has been reduced from 100,000 to 10,000; raise it if your app sends large bursts of events ([#847](https://github.com/honeybadger-io/honeybadger-ruby/issues/847))
+
+## [6.9.3](https://github.com/honeybadger-io/honeybadger-ruby/compare/v6.9.2...v6.9.3) (2026-09-29)
+
+
+### Bug Fixes
+
+* propagate the Rails request ID to notices and Insights events ([#848](https://github.com/honeybadger-io/honeybadger-ruby/issues/848)) ([23edb08](https://github.com/honeybadger-io/honeybadger-ruby/commit/23edb08f4fda3b3f66fb697c5ec5502f39aeb127))
+
 ## [6.9.2](https://github.com/honeybadger-io/honeybadger-ruby/compare/v6.9.1...v6.9.2) (2026-09-15)
 
 

data/lib/honeybadger/agent.rb

@@ -579,13 +579,18 @@ module Honeybadger
     # @api private
     def with_rack_env(rack_env, &block)
       context_manager.set_rack_env(rack_env)
-      context_manager.set_request_id(rack_env["action_dispatch.request_id"] || SecureRandom.uuid)
+      context_manager.set_request_id(SecureRandom.uuid)
       yield
     ensure
       context_manager.set_rack_env(nil)
       context_manager.set_request_id(nil)
     end
 
+    # @api private
+    def set_request_id(request_id)
+      context_manager.set_request_id(request_id)
+    end
+
     # @api private
     attr_reader :worker, :events_worker, :metrics_worker
 

data/lib/honeybadger/backend/base.rb

@@ -9,7 +9,10 @@ module Honeybadger
     class Response
       NOT_BLANK = /\S/
 
-      attr_reader :code, :body, :message, :error
+      attr_reader :code, :body, :message, :error, :retry_after, :limit_reason
+
+      # Longest Retry-After, in seconds, accepted for a single retry delay.
+      MAX_RETRY_AFTER = 60
 
       FRIENDLY_ERRORS = {
         429 => "Your project is currently sending too many errors.\nThis issue should resolve itself once error traffic is reduced.".freeze,
@@ -36,6 +39,9 @@ module Honeybadger
       def initialize(*args)
         if (response = args.first).is_a?(Net::HTTPResponse)
           @code, @body, @message = response.code.to_i, response.body.to_s, response.message
+          @retry_after = parse_retry_after(response["Retry-After"])
+          # Why a 429 was sent, e.g. "overloaded".
+          @limit_reason = response["Honeybadger-Limit-Reason"]&.strip&.downcase
         else
           @code, @body, @message = args
         end
@@ -48,6 +54,26 @@ module Honeybadger
         @success
       end
 
+      # The server is briefly unavailable (502/503/504, or 429 with
+      # Limit-Reason "overloaded") and Retry-After is absent or at most
+      # MAX_RETRY_AFTER. Hold the payload and retry it. Any other 429 means
+      # the server is rejecting data.
+      def retryable?
+        return false if retry_after && retry_after > MAX_RETRY_AFTER
+        [502, 503, 504].include?(code) || (code == 429 && limit_reason == "overloaded")
+      end
+
+      # Seconds to drop queued data and reject new data, or nil if this isn't
+      # a rejection.
+      def reject_interval
+        return if retryable?
+        case code
+        when 429 then retry_after || 60
+        when 502, 503, 504 then retry_after
+        when 401, 403 then retry_after || 3600
+        end
+      end
+
       def error_message
         return message if code == :error
         return error if code == 403 && NOT_BLANK.match?(error)
@@ -60,6 +86,15 @@ module Honeybadger
 
       private
 
+      # Positive integer seconds only. Zero, negative, HTTP-date, and other
+      # values are treated as absent; Honeybadger only sends seconds.
+      def parse_retry_after(value)
+        return nil unless value
+        return nil unless /\A\d+\z/.match?(value.strip)
+        seconds = value.to_i
+        (seconds > 0) ? seconds : nil
+      end
+
       def parse_error(body)
         return unless NOT_BLANK.match?(body)
         obj = JSON.parse(body)

data/lib/honeybadger/config/defaults.rb

@@ -115,7 +115,7 @@ module Honeybadger
       },
       "events.max_queue_size": {
         description: "Maximum number of event for the event worker queue.",
-        default: 100000,
+        default: 10000,
         type: Integer
       },
       "events.batch_size": {

data/lib/honeybadger/events_worker.rb

@@ -16,25 +16,21 @@ module Honeybadger
 
     # Used to signal the worker to shutdown.
     SHUTDOWN = :__hb_worker_shutdown!
-    FLUSH = :__hb_worker_flush!
     CHECK_TIMEOUT = :__hb_worker_check_timeout!
 
-    # 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
+    # Number of times a batch is resent while the server is unavailable
+    # (6 attempts in total). Each batch gets its own retries.
+    MAX_RETRIES = 5
 
     # TODO: These could be configurable?
 
     def initialize(config)
       @config = config
-      @throttle = 0
-      @throttle_interval = 0
       @mutex = Mutex.new
-      @marker = ConditionVariable.new
+      @flush_signal = ConditionVariable.new
       @queue = Queue.new
-      @send_queue = Queue.new
       @shutdown = false
+      @flushes = 0
       @start_at = nil
       @pid = Process.pid
       @send_queue = []
@@ -67,13 +63,7 @@ module Honeybadger
       return true if force
       return true unless thread&.alive?
 
-      if throttled?
-        warn { sprintf("Unable to send %s event(s) to Honeybadger (currently throttled)", queue.size) } unless queue.empty?
-        return true
-      end
-
       info { sprintf("Waiting to send %s events(s) to Honeybadger", queue.size) } unless queue.empty?
-      queue.push(FLUSH)
       queue.push(SHUTDOWN)
       !!thread.join
     ensure
@@ -81,13 +71,18 @@ module Honeybadger
       kill!
     end
 
-    # Blocks until queue is processed up to this point in time.
+    # Blocks until queue is processed up to this point in time. Retries are
+    # skipped while a flush is pending, since the caller is waiting.
     def flush
       mutex.synchronize do
         if thread&.alive?
-          queue.push(FLUSH)
-          queue.push(marker)
-          marker.wait(mutex)
+          @flushes += 1
+          queue.push(flush_signal)
+          begin
+            flush_signal.wait(mutex)
+          ensure
+            @flushes -= 1
+          end
         end
       end
     end
@@ -111,8 +106,8 @@ module Honeybadger
 
     private
 
-    attr_reader :config, :queue, :pid, :mutex, :marker, :thread, :timeout_thread, :throttle,
-      :throttle_interval, :start_at, :send_queue, :last_sent
+    attr_reader :config, :queue, :pid, :mutex, :flush_signal, :thread, :timeout_thread,
+      :start_at, :send_queue, :last_sent
 
     def_delegator :config, :backend
 
@@ -120,6 +115,10 @@ module Honeybadger
       mutex.synchronize { @shutdown }
     end
 
+    def flushing?
+      mutex.synchronize { @flushes > 0 }
+    end
+
     def suspended?
       mutex.synchronize { start_at && Time.now.to_i < start_at }
     end
@@ -130,10 +129,6 @@ module Honeybadger
       true
     end
 
-    def throttled?
-      mutex.synchronize { throttle > 0 }
-    end
-
     def kill!
       d { "killing worker thread" }
 
@@ -150,10 +145,18 @@ module Honeybadger
       true
     end
 
+    # Drops queued and pending events and rejects new ones (push returns
+    # false) for +interval+ seconds. The thread restarts on the first push after that.
     def suspend(interval)
+      warn { sprintf("Dropping queued events and rejecting new ones for %ss", interval) }
       mutex.synchronize do
         @start_at = Time.now.to_i + interval
         queue.clear
+        send_queue.clear
+        if @dropped_events > 0
+          warn { sprintf("Dropped %s messages due to exceeding max queue size of %s", @dropped_events, config.events_max_queue_size) }
+        end
+        @dropped_events = 0
       end
 
       # Must be performed last since this may kill the current thread.
@@ -175,10 +178,13 @@ module Honeybadger
         end
         loop do
           case msg = queue.pop
-          when SHUTDOWN then break
+          when SHUTDOWN
+            send_pending_batch
+            break
           when CHECK_TIMEOUT then check_timeout
-          when FLUSH then flush_send_queue
-          when ConditionVariable then signal_marker(msg)
+          when flush_signal
+            send_pending_batch
+            signal_flush_done
           else work(msg)
           end
         end
@@ -191,7 +197,7 @@ module Honeybadger
         sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
       }
     ensure
-      release_marker
+      release_flush_waiters
     end
 
     def check_timeout
@@ -209,16 +215,35 @@ module Honeybadger
     end
 
     def send_batch
-      send_now(mutex.synchronize { send_queue })
+      # batch is send_queue itself; clearing send_queue also clears batch.
+      batch = mutex.synchronize { send_queue }
+      response = send_to_backend(batch)
+      MAX_RETRIES.times do
+        break unless response.retryable?
+        break unless wait(response.retry_after || rand(5..15))
+        response = send_to_backend(batch)
+      end
+      handle_response(response)
+      if (interval = response.reject_interval)
+        suspend(interval) # clears the batch and terminates this thread
+      end
+
       mutex.synchronize do
         @last_sent = Time.now
-        debug { sprintf("Sending %s events", send_queue.length) }
+        debug { sprintf("Finished attempting to send %s events", send_queue.length) }
         send_queue.clear
         if @dropped_events > 0
           warn { sprintf("Dropped %s messages due to exceeding max queue size of %s", @dropped_events, config.events_max_queue_size) }
         end
         @dropped_events = 0
       end
+
+      # Shutting down while the server is unavailable: stop without sending
+      # the rest of the queue.
+      if shutdown? && response.retryable?
+        warn { "Shutting down while the server is unavailable; dropping queued events" }
+        kill!
+      end
     end
 
     def check_and_send
@@ -228,7 +253,7 @@ module Honeybadger
       end
     end
 
-    def flush_send_queue
+    def send_pending_batch
       return if mutex.synchronize { send_queue.empty? }
       send_batch
     rescue => e
@@ -241,14 +266,6 @@ module Honeybadger
     def work(msg)
       enqueue_msg(msg)
       check_and_send
-
-      if shutdown? && throttled?
-        warn { sprintf("Unable to send %s events(s) to Honeybadger (currently throttled)", queue.size) } if queue.size > 1
-        kill!
-        return
-      end
-
-      sleep(throttle_interval)
     rescue => e
       error {
         msg = "Error in worker thread class=%s message=%s\n\t%s"
@@ -261,49 +278,33 @@ module Honeybadger
       backend.event(msg)
     end
 
-    def calc_throttle_interval
-      ((BASE_THROTTLE**throttle) - 1).round(3)
-    end
-
-    def inc_throttle
-      mutex.synchronize do
-        @throttle += 1
-        @throttle_interval = calc_throttle_interval
-        throttle
-      end
-    end
-
-    def dec_throttle
-      mutex.synchronize do
-        return nil if throttle == 0
-        @throttle -= 1
-        @throttle_interval = calc_throttle_interval
-        throttle
+    # Sleeps in one-second steps so shutdown or a flush can interrupt.
+    # Returns false if one did, including during the final second; the
+    # batch in hand is then dropped.
+    def wait(seconds)
+      seconds.times do
+        return false if shutdown? || flushing?
+        sleep(1)
       end
+      !(shutdown? || flushing?)
     end
 
     def handle_response(response)
       d { sprintf("events_worker response code=%s message=%s", response.code, response.message.to_s.dump) }
 
       case response.code
-      when 429, 503
-        throttle = inc_throttle
-        debug { sprintf("Insights Event send failed: project is sending too many events. code=%s throttle=%s interval=%s", response.code, throttle, throttle_interval) }
-        suspend(3600)
-      when 402
-        warn { sprintf("Insights Event send failed: payment is required. code=%s", response.code) }
-        suspend(3600)
-      when 403
+      when 429, 502, 503, 504
+        if response.retryable?
+          warn { sprintf("Insights Event send failed: server unavailable, dropping this batch. code=%s", response.code) }
+        else
+          warn { sprintf("Insights Event send failed: server is rejecting data. code=%s reason=%s", response.code, response.limit_reason) }
+        end
+      when 401, 403
         warn { sprintf("Insights Event send failed: %s code=%s", response.error_message, response.code) }
-        suspend(3600)
       when 413
         warn { sprintf("Insights Event send failed: Payload is too large. code=%s", response.code) }
       when 201
-        if (throttle = dec_throttle)
-          debug { sprintf("Success ⚡ Insights Event sent code=%s throttle=%s interval=%s", response.code, throttle, throttle_interval) }
-        else
-          debug { sprintf("Success ⚡ Insights Event sent code=%s", response.code) }
-        end
+        debug { sprintf("Success ⚡ Insights Event sent code=%s", response.code) }
       when :stubbed
         debug { "Success ⚡ Development mode is enabled; This event will be sent after app is deployed." }
       when :error
@@ -313,17 +314,22 @@ module Honeybadger
       end
     end
 
-    # Release the marker. Important to perform during cleanup when shutting
-    # down, otherwise it could end up waiting indefinitely.
-    def release_marker
-      signal_marker(marker)
+    # Wake every waiting flush. Important to perform during cleanup when
+    # shutting down, otherwise they could end up waiting indefinitely.
+    def release_flush_waiters
+      if mutex.owned?
+        flush_signal.broadcast
+      else
+        mutex.synchronize { flush_signal.broadcast }
+      end
     end
 
-    def signal_marker(marker)
+    # Wakes the flush waiting on this point in the queue.
+    def signal_flush_done
       if mutex.owned?
-        marker.signal
+        flush_signal.signal
       else
-        mutex.synchronize { marker.signal }
+        mutex.synchronize { flush_signal.signal }
       end
     end
   end

data/lib/honeybadger/init/rails.rb

@@ -2,6 +2,7 @@ require "rails"
 require "yaml"
 
 require "honeybadger/ruby"
+require "honeybadger/rack/request_id"
 
 module Honeybadger
   module Init
@@ -14,8 +15,14 @@ module Honeybadger
         initializer "honeybadger.install_middleware" do |app|
           honeybadger_config = Honeybadger::Agent.instance.config
 
-          if honeybadger_config[:"exceptions.enabled"]
+          # ErrorNotifier also sets up the request context that Insights events
+          # read. Agent#notify does nothing when exceptions are disabled.
+          if honeybadger_config[:"exceptions.enabled"] || honeybadger_config[:"insights.enabled"]
             app.config.middleware.insert(0, Honeybadger::Rack::ErrorNotifier)
+            app.config.middleware.insert_after(::ActionDispatch::RequestId, Honeybadger::Rack::RequestId)
+          end
+
+          if honeybadger_config[:"exceptions.enabled"]
             app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserInformer) if honeybadger_config[:"user_informer.enabled"]
             app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserFeedback) if honeybadger_config[:"feedback.enabled"]
           end

data/lib/honeybadger/metrics_worker.rb

@@ -18,7 +18,7 @@ module Honeybadger
       @config = config
       @interval_seconds = 1
       @mutex = Mutex.new
-      @marker = ConditionVariable.new
+      @flush_signal = ConditionVariable.new
       @queue = Queue.new
       @shutdown = false
       @start_at = nil
@@ -60,8 +60,8 @@ module Honeybadger
     def flush
       mutex.synchronize do
         if thread&.alive?
-          queue.push(marker)
-          marker.wait(mutex)
+          queue.push(flush_signal)
+          flush_signal.wait(mutex)
         end
       end
     end
@@ -84,7 +84,7 @@ module Honeybadger
 
     private
 
-    attr_reader :config, :queue, :pid, :mutex, :marker, :thread, :interval_seconds, :start_at
+    attr_reader :config, :queue, :pid, :mutex, :flush_signal, :thread, :interval_seconds, :start_at
 
     def shutdown?
       mutex.synchronize { @shutdown }
@@ -127,7 +127,7 @@ module Honeybadger
         loop do
           case msg = queue.pop
           when SHUTDOWN then break
-          when ConditionVariable then signal_marker(msg)
+          when flush_signal then signal_flush_done
           else work(msg)
           end
         end
@@ -140,7 +140,7 @@ module Honeybadger
         sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
       }
     ensure
-      release_marker
+      release_flush_waiters
     end
 
     def work(msg)
@@ -160,17 +160,22 @@ module Honeybadger
       sleep(interval_seconds)
     end
 
-    # Release the marker. Important to perform during cleanup when shutting
-    # down, otherwise it could end up waiting indefinitely.
-    def release_marker
-      signal_marker(marker)
+    # Wake every waiting flush. Important to perform during cleanup when
+    # shutting down, otherwise they could end up waiting indefinitely.
+    def release_flush_waiters
+      if mutex.owned?
+        flush_signal.broadcast
+      else
+        mutex.synchronize { flush_signal.broadcast }
+      end
     end
 
-    def signal_marker(marker)
+    # Wakes the flush waiting on this point in the queue.
+    def signal_flush_done
       if mutex.owned?
-        marker.signal
+        flush_signal.signal
       else
-        mutex.synchronize { marker.signal }
+        mutex.synchronize { flush_signal.signal }
       end
     end
   end

data/lib/honeybadger/rack/request_id.rb

@@ -0,0 +1,27 @@
+require "honeybadger/ruby"
+
+module Honeybadger
+  module Rack
+    # @api private
+    #
+    # Copies the request ID assigned by ActionDispatch::RequestId into the
+    # Honeybadger context. Must sit after ActionDispatch::RequestId in the
+    # middleware stack.
+    #
+    # No ensure/cleanup here: ErrorNotifier owns the request lifecycle and
+    # clears state after the stack unwinds. Clearing here would nil the ID
+    # before ErrorNotifier builds the notice on exception.
+    class RequestId
+      def initialize(app, agent = nil)
+        @app = app
+        @agent = agent if agent.is_a?(Agent)
+      end
+
+      def call(env)
+        request_id = env["action_dispatch.request_id"]
+        (@agent || Honeybadger::Agent.instance).set_request_id(request_id) if request_id
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/honeybadger/version.rb

@@ -1,4 +1,4 @@
 module Honeybadger
   # The current String Honeybadger version.
-  VERSION = "6.9.2".freeze
+  VERSION = "6.10.0".freeze
 end

data/lib/honeybadger/worker.rb

@@ -17,19 +17,17 @@ module Honeybadger
     # 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
+    # Number of times a notice is resent while the server is unavailable
+    # (6 attempts in total). Each notice gets its own retries.
+    MAX_RETRIES = 5
 
     def initialize(config)
       @config = config
-      @throttle = 0
-      @throttle_interval = 0
       @mutex = Mutex.new
-      @marker = ConditionVariable.new
+      @flush_signal = ConditionVariable.new
       @queue = Queue.new
       @shutdown = false
+      @flushes = 0
       @start_at = nil
       @pid = Process.pid
     end
@@ -45,6 +43,7 @@ module Honeybadger
       queue.push(msg)
     end
 
+    # Sends synchronously without retrying.
     def send_now(msg)
       response = notify_backend(msg)
       run_after_notify_hooks(msg, response)
@@ -61,11 +60,6 @@ module Honeybadger
       return true if force
       return true unless thread&.alive?
 
-      if throttled?
-        warn { sprintf("Unable to report %s error(s) to Honeybadger (currently throttled)", queue.size) } unless queue.empty?
-        return true
-      end
-
       info { sprintf("Waiting to report %s error(s) to Honeybadger", queue.size) } unless queue.empty?
 
       queue.push(SHUTDOWN)
@@ -75,12 +69,18 @@ module Honeybadger
       kill!
     end
 
-    # Blocks until queue is processed up to this point in time.
+    # Blocks until queue is processed up to this point in time. Retries are
+    # skipped while a flush is pending, since the caller is waiting.
     def flush
       mutex.synchronize do
         if thread&.alive?
-          queue.push(marker)
-          marker.wait(mutex)
+          @flushes += 1
+          queue.push(flush_signal)
+          begin
+            flush_signal.wait(mutex)
+          ensure
+            @flushes -= 1
+          end
         end
       end
     end
@@ -103,8 +103,7 @@ module Honeybadger
 
     private
 
-    attr_reader :config, :queue, :pid, :mutex, :marker, :thread, :throttle,
-      :throttle_interval, :start_at
+    attr_reader :config, :queue, :pid, :mutex, :flush_signal, :thread, :start_at
 
     def_delegator :config, :backend
 
@@ -112,6 +111,10 @@ module Honeybadger
       mutex.synchronize { @shutdown }
     end
 
+    def flushing?
+      mutex.synchronize { @flushes > 0 }
+    end
+
     def suspended?
       mutex.synchronize { start_at && Time.now.to_i < start_at }
     end
@@ -122,10 +125,6 @@ module Honeybadger
       true
     end
 
-    def throttled?
-      mutex.synchronize { throttle > 0 }
-    end
-
     def kill!
       d { "killing worker thread" }
 
@@ -137,7 +136,10 @@ module Honeybadger
       true
     end
 
+    # Drops queued notices and rejects new ones (push returns false) for
+    # +interval+ seconds. The thread restarts on the first push after that.
     def suspend(interval)
+      warn { sprintf("Dropping queued errors and rejecting new ones for %ss", interval) }
       mutex.synchronize do
         @start_at = Time.now.to_i + interval
         queue.clear
@@ -153,7 +155,7 @@ module Honeybadger
         loop do
           case msg = queue.pop
           when SHUTDOWN then break
-          when ConditionVariable then signal_marker(msg)
+          when flush_signal then signal_flush_done
           else work(msg)
           end
         end
@@ -166,19 +168,28 @@ module Honeybadger
         sprintf(msg, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
       }
     ensure
-      release_marker
+      release_flush_waiters
     end
 
     def work(msg)
-      send_now(msg)
+      response = notify_backend(msg)
+      MAX_RETRIES.times do
+        break unless response.retryable?
+        break unless wait(response.retry_after || rand(5..15))
+        response = notify_backend(msg)
+      end
+      run_after_notify_hooks(msg, response)
+      handle_response(msg, response)
+      if (interval = response.reject_interval)
+        suspend(interval) # terminates this thread
+      end
 
-      if shutdown? && throttled?
-        warn { sprintf("Unable to report %s error(s) to Honeybadger (currently throttled)", queue.size) } if queue.size > 1
+      # Shutting down while the server is unavailable: stop without sending
+      # the rest of the queue.
+      if shutdown? && response.retryable?
+        warn { "Shutting down while the server is unavailable; dropping queued errors" }
         kill!
-        return
       end
-
-      sleep(throttle_interval)
     rescue => e
       error {
         msg = "Error in worker thread class=%s message=%s\n\t%s"
@@ -206,49 +217,34 @@ module Honeybadger
       }
     end
 
-    def calc_throttle_interval
-      ((BASE_THROTTLE**throttle) - 1).round(3)
-    end
-
-    def inc_throttle
-      mutex.synchronize do
-        @throttle += 1
-        @throttle_interval = calc_throttle_interval
-        throttle
-      end
-    end
-
-    def dec_throttle
-      mutex.synchronize do
-        return nil if throttle == 0
-        @throttle -= 1
-        @throttle_interval = calc_throttle_interval
-        throttle
+    # Sleeps in one-second steps so shutdown or a flush can interrupt.
+    # Returns false if one did, including during the final second; the
+    # payload in hand is then dropped.
+    def wait(seconds)
+      seconds.times do
+        return false if shutdown? || flushing?
+        sleep(1)
       end
+      !(shutdown? || flushing?)
     end
 
     def handle_response(msg, response)
       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
-        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)
-      when 403
+      when 429, 502, 503, 504
+        if response.retryable?
+          warn { sprintf("Error report failed: server unavailable, giving up on this error. id=%s code=%s", msg.id, response.code) }
+        else
+          warn { sprintf("Error report failed: server is rejecting data. id=%s code=%s reason=%s", msg.id, response.code, response.limit_reason) }
+        end
+      when 401, 403
         warn { sprintf("Error report failed: %s id=%s code=%s", response.error_message, msg.id, response.code) }
-        suspend(3600)
       when 413
         warn { sprintf("Error report failed: Payload is too large. id=%s code=%s", msg.id, response.code) }
       when 201
         host = config.get(:"connection.ui_host")
-        if (throttle = dec_throttle)
-          info { sprintf("Success ⚡ https://%s/notice/%s id=%s code=%s throttle=%s interval=%s", host, msg.id, msg.id, response.code, throttle, throttle_interval) }
-        else
-          info { sprintf("Success ⚡ https://%s/notice/%s id=%s code=%s", host, msg.id, msg.id, response.code) }
-        end
+        info { sprintf("Success ⚡ https://%s/notice/%s id=%s code=%s", host, msg.id, msg.id, response.code) }
       when :stubbed
         debug { sprintf("Success ⚡ Development mode is enabled; this error will be reported if it occurs after you deploy your app. id=%s", msg.id) }
       when :error
@@ -258,17 +254,22 @@ module Honeybadger
       end
     end
 
-    # Release the marker. Important to perform during cleanup when shutting
-    # down, otherwise it could end up waiting indefinitely.
-    def release_marker
-      signal_marker(marker)
+    # Wake every waiting flush. Important to perform during cleanup when
+    # shutting down, otherwise they could end up waiting indefinitely.
+    def release_flush_waiters
+      if mutex.owned?
+        flush_signal.broadcast
+      else
+        mutex.synchronize { flush_signal.broadcast }
+      end
     end
 
-    def signal_marker(marker)
+    # Wakes the flush waiting on this point in the queue.
+    def signal_flush_done
       if mutex.owned?
-        marker.signal
+        flush_signal.signal
       else
-        mutex.synchronize { marker.signal }
+        mutex.synchronize { flush_signal.signal }
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: honeybadger
 version: !ruby/object:Gem::Version
-  version: 6.9.2
+  version: 6.10.0
 platform: ruby
 authors:
   - Honeybadger Industries LLC
@@ -131,6 +131,7 @@ files:
   - lib/honeybadger/plugins/thor.rb
   - lib/honeybadger/plugins/warden.rb
   - lib/honeybadger/rack/error_notifier.rb
+  - lib/honeybadger/rack/request_id.rb
   - lib/honeybadger/rack/user_feedback.rb
   - lib/honeybadger/rack/user_informer.rb
   - lib/honeybadger/registry.rb
@@ -217,7 +218,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       - !ruby/object:Gem::Version
         version: "0"
 requirements: []
-rubygems_version: 4.1.0.beta1
+rubygems_version: 4.1.0.beta2
 specification_version: 4
 summary: "Full-stack error tracking, performance monitoring, logging, and more."
 test_files: []