honeybadger 6.9.3 → 6.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fe7e1dc021b03b75e886083cda940bd73ac4613427229e0b9a08c4e65badf548
-  data.tar.gz: ea2e996262898454537f1e65e394d4d1cd93226420dab1d0d66ad8b408cac200
+  metadata.gz: bd51e9013ebffeda55792fca6ed7837bc8e9199aeb570e898bc74ea80df9cb66
+  data.tar.gz: 92787b0bfd6fa3401685a131f17f2b2d22a29e37db9781bc3ff9dd9afd442829
 SHA512:
-  metadata.gz: 8ae65e4be79d6ed5761b54139488681f1d5a591f8a5f1b44185e17d4322120f2a280055704a1a56e5e0836bb12f2dcf2c91372f9e0c0c9b06a488e69089fd7ce
-  data.tar.gz: 8ac9bb344ab71c34de08a8eefb3bb7dc2393d7c29d6f59f6cbe289d6c428a699cc679d599088d2d6c87f8e1a6de9069cc079f156b272385299e25b2e81361002
+  metadata.gz: 5abd942300193e9eb8a94dc5449d18b5f8dad03dcd21c67fa1b3aaa0ac39cfc3d13989add2757cff83a93faf33ca218a53745f91cfdecd4f95388641eb680c4d
+  data.tar.gz: 50afe4ea98c6181129622c0cf84aae411f80d6321331f964882b23eded3eefad0d0afa6b5994b1e3b801a4b512895ef02fa00fc8ba32078dcfad2ad2adf8a09d

data/CHANGELOG.md

@@ -1,6 +1,28 @@
 # Change Log
 
 
+## [6.10.1](https://github.com/honeybadger-io/honeybadger-ruby/compare/v6.10.0...v6.10.1) (2026-10-30)
+
+
+### Bug Fixes
+
+* update bundled CA certificates ([#858](https://github.com/honeybadger-io/honeybadger-ruby/issues/858)) ([4f5489e](https://github.com/honeybadger-io/honeybadger-ruby/commit/4f5489ef806e3f9a8681063408cf4ec015d8aadf))
+
+### Changed
+
+* The bundled CA certificates no longer include roots that Mozilla has removed. If you set `connection.host` to your own server and TLS verification fails after upgrading, set `connection.system_ssl_cert_chain: true` or `connection.ssl_ca_bundle_path` ([#858](https://github.com/honeybadger-io/honeybadger-ruby/issues/858))
+
+## [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)
 
 

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/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/version.rb

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