honeybadger 6.6.2 → 6.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03a414b7ec784574a3164541f03d9e2b60d3a4af1d09b754d5c630282b3f0c12
-  data.tar.gz: 26afeb772bb5e998ed9a15a213697b72d3415ffadfc858fc1419913daa5ca500
+  metadata.gz: c0df809e34f5f0cbd3e4d63c411f215dc2f9418b8909a7aedb9a5fb6c454afbe
+  data.tar.gz: e811145ad02eef49a8078d3cb827ad47cdf35693a986a55e12bf2a6108f1b052
 SHA512:
-  metadata.gz: 7ac887b4d796a351c0578cd52b492ca5e75a0232ff9f8fb1ab5f323608bfae9224d1e46a6ae8bd928b88cc5e424f65e5683e204c8c14ab9c7c639d76de651522
-  data.tar.gz: 0ba659e647134528493c16665e40efa33d7ef4ad13af4472005119d807941d4e3c6be047671d8a0588b3b064b71a8cf6d12d3a7402287e029cf4f66dd5173575
+  metadata.gz: e4470a6b43117aad7db8069fe87287fc8486c9b02a79ebf43184228251fb81eeb3549b7458593f0ee0ce0e9784b85790b2ad3b97bc01c0cf46d98f49bafd2699
+  data.tar.gz: 2aefdc40100c38c1707642be6ab04d0a72248b09734ef8f681e06753f3945854fbcc07f2e89f71ee3477fca1177e273899bb470983cabeb62b080ebafd0f04be

data/CHANGELOG.md

@@ -1,6 +1,28 @@
 # Change Log
 
 
+## [6.9.0](https://github.com/honeybadger-io/honeybadger-ruby/compare/v6.8.0...v6.9.0) (2026-06-11)
+
+
+### Features
+
+* make RubyLLM insights subscriber configurable ([#829](https://github.com/honeybadger-io/honeybadger-ruby/issues/829)) ([fc9ff42](https://github.com/honeybadger-io/honeybadger-ruby/commit/fc9ff42689b87f972183286d34c7e4059bf23442))
+
+## [6.8.0](https://github.com/honeybadger-io/honeybadger-ruby/compare/v6.7.0...v6.8.0) (2026-06-10)
+
+
+### Features
+
+* add RubyLLM monitoring plugin ([#827](https://github.com/honeybadger-io/honeybadger-ruby/issues/827)) ([4b2c32d](https://github.com/honeybadger-io/honeybadger-ruby/commit/4b2c32d933b1dd35599b2a292027d50458f2c384))
+
+## [6.7.0](https://github.com/honeybadger-io/honeybadger-ruby/compare/v6.6.2...v6.7.0) (2026-06-05)
+
+
+### Features
+
+* add after_notify hooks ([#825](https://github.com/honeybadger-io/honeybadger-ruby/issues/825)) ([950fee2](https://github.com/honeybadger-io/honeybadger-ruby/commit/950fee2bb2ab81ebbfa20ea34b36045bd6b57034))
+* make backtrace limit configurable ([#824](https://github.com/honeybadger-io/honeybadger-ruby/issues/824)) ([f62ce3a](https://github.com/honeybadger-io/honeybadger-ruby/commit/f62ce3ab09ffa497fbfb2ec1fa193359b66b1a23))
+
 ## [6.6.2](https://github.com/honeybadger-io/honeybadger-ruby/compare/v6.6.0...v6.6.1) (2026-05-29)
 
 

data/lib/honeybadger/backtrace.rb

@@ -4,6 +4,8 @@ module Honeybadger
   # @api private
   # Front end to parsing the backtrace for each notice.
   class Backtrace
+    DEFAULT_LIMIT = 1000
+
     # Handles backtrace parsing line by line.
     class Line
       # Backtrace line regexp (optionally allowing leading X: for windows support).
@@ -122,19 +124,20 @@ module Honeybadger
         Line.parse(unparsed_line.to_s, opts)
       end.compact
 
-      new(lines)
+      new(lines, opts.fetch(:limit, DEFAULT_LIMIT))
     end
 
-    def initialize(lines)
+    def initialize(lines, limit = DEFAULT_LIMIT)
       self.lines = lines
       self.application_lines = lines.select(&:application?)
+      self.limit = limit || DEFAULT_LIMIT
     end
 
     # Convert Backtrace to arry.
     #
     # Returns array containing backtrace lines.
     def to_ary
-      lines.take(1000).map { |l| {number: l.filtered_number, file: l.filtered_file, method: l.filtered_method, source: l.source} }
+      lines.take(limit.clamp(0..)).map { |l| {number: l.filtered_number, file: l.filtered_file, method: l.filtered_method, source: l.source} }
     end
     alias_method :to_a, :to_ary
 
@@ -153,7 +156,7 @@ module Honeybadger
     end
 
     def to_s
-      lines.map(&:to_s).join("\n")
+      lines.join("\n")
     end
 
     def inspect
@@ -172,6 +175,8 @@ module Honeybadger
 
     attr_writer :lines, :application_lines
 
+    attr_accessor :limit
+
     class << self
       private
 

data/lib/honeybadger/config/defaults.rb

@@ -1,5 +1,6 @@
 require "socket"
 require "honeybadger/breadcrumbs/active_support"
+require "honeybadger/backtrace"
 
 module Honeybadger
   class Config
@@ -321,6 +322,11 @@ module Honeybadger
         default: 2,
         type: Integer
       },
+      "exceptions.backtrace_limit": {
+        description: "The maximum number of backtrace lines to include in error reports.",
+        default: Backtrace::DEFAULT_LIMIT,
+        type: Integer
+      },
       "exceptions.local_variables": {
         description: "Enable sending local variables. Requires binding_of_caller to be loaded.",
         default: false,
@@ -568,6 +574,16 @@ module Honeybadger
         description: "Enable automatic data collection for Flipper.",
         default: true,
         type: Boolean
+      },
+      "ruby_llm.insights.enabled": {
+        description: "Enable automatic data collection for RubyLLM.",
+        default: true,
+        type: Boolean
+      },
+      "ruby_llm.insights.subscriber": {
+        description: "Fully qualified class name of a custom subscriber for RubyLLM instrumentation. A class constant may also be given via Ruby configuration. Defaults to Honeybadger::RubyLLMSubscriber.",
+        default: nil,
+        type: String
       }
     }.freeze
 

data/lib/honeybadger/config/ruby.rb

@@ -89,21 +89,61 @@ module Honeybadger
       def before_notify(action = nil, &block)
         hooks = Array(get(:before_notify)).dup
 
-        if action && validate_before_action(action, "notify")
+        if action && validate_hook_action(action, "before notify", 1)
           hooks << action
-        elsif block_given? && validate_before_action(block, "notify")
+        elsif block_given? && validate_hook_action(block, "before notify", 1)
           hooks << block
         end
 
         hash[:before_notify] = hooks
       end
 
+      # Run a hook after each error notice delivery attempt.
+      #
+      # The hook is called for every backend response, including successful
+      # deliveries. Response codes are usually HTTP status integers, but may be
+      # symbols such as :stubbed or :error for non-server backends or connection
+      # failures. Filter with exact response codes (e.g. `response.code == 413`)
+      # rather than broad integer comparisons, or use `response.success?`.
+      # (Note: `response.error_message` may raise for non-HTTP responses like `:stubbed`.)
+      #
+      # Prefer `Honeybadger.event` for reporting failed notice deliveries. Calling
+      # `Honeybadger.notify` from this hook can trigger another after_notify call;
+      # guard against self-reporting loops if a notice must be sent.
+      #
+      # @example Report oversized notice payloads
+      #   config.after_notify do |notice, response|
+      #     next unless response.code == 413
+      #
+      #     Honeybadger.event("honeybadger.notice_rejected", {
+      #       reason: "payload_too_large",
+      #       notice_id: notice.id,
+      #       payload_bytes: notice.to_json.bytesize
+      #     })
+      #   end
+      #
+      # @yieldparam notice [Honeybadger::Notice] The notice that was sent.
+      # @yieldparam response [Honeybadger::Backend::Response] The backend response.
+      # @return [Array<Proc>] configured hooks
+      # @api public
+      def after_notify(action = nil, &block)
+        hooks = Array(get(:after_notify)).dup
+
+        if action && validate_hook_action(action, "after notify", 2)
+          hooks << action
+        elsif block_given? && validate_hook_action(block, "after notify", 2)
+          hooks << block
+        end
+
+        hash[:after_notify] = hooks
+      end
+
       def before_event(action = nil, &block)
         hooks = Array(get(:before_event)).dup
 
-        if action && validate_before_action(action, "event")
+        if action && validate_hook_action(action, "before event", 1)
           hooks << action
-        elsif block_given? && validate_before_action(block, "event")
+        elsif block_given? && validate_hook_action(block, "before event", 1)
           hooks << block
         end
 
@@ -139,18 +179,18 @@ module Honeybadger
 
       private
 
-      def validate_before_action(action, type)
+      def validate_hook_action(action, name, arity)
         if !action.respond_to?(:call)
           logger.warn(
-            "You attempted to add a before #{type} hook that does not respond " \
+            "You attempted to add a #{name} hook that does not respond " \
             "to #call. We are discarding this hook so your intended behavior " \
             "will not occur."
           )
           false
-        elsif action.arity != 1
+        elsif action.arity != arity
           logger.warn(
-            "You attempted to add a before #{type} hook that has an arity " \
-            "other than one. We are discarding this hook so your intended " \
+            "You attempted to add a #{name} hook that has an arity " \
+            "other than #{arity}. We are discarding this hook so your intended " \
             "behavior will not occur."
           )
           false

data/lib/honeybadger/config.rb

@@ -92,6 +92,10 @@ module Honeybadger
       (ruby[:before_notify] || []).clone
     end
 
+    def after_notify_hooks
+      (ruby[:after_notify] || []).clone
+    end
+
     def before_event_hooks
       (ruby[:before_event] || []).clone
     end

data/lib/honeybadger/notice.rb

@@ -509,7 +509,8 @@ module Honeybadger
         backtrace,
         filters: construct_backtrace_filters(opts),
         config: config,
-        source_radius: config[:"exceptions.source_radius"]
+        source_radius: config[:"exceptions.source_radius"],
+        limit: config[:"exceptions.backtrace_limit"]
       ).to_a
     end
 

data/lib/honeybadger/plugins/ruby_llm.rb

@@ -0,0 +1,69 @@
+require "honeybadger/plugin"
+require "honeybadger/notification_subscriber"
+
+module Honeybadger
+  module Plugins
+    module RubyLLM
+      Plugin.register :ruby_llm do
+        requirement { defined?(::RubyLLM) }
+        requirement { defined?(::ActiveSupport::Notifications) }
+
+        execution do
+          if config.load_plugin_insights?(:ruby_llm)
+            class_name = config[:"ruby_llm.insights.subscriber"].to_s.strip
+            subscriber = if class_name.empty?
+              Honeybadger::RubyLLMSubscriber.new
+            else
+              begin
+                candidate = Object.const_get(class_name).new
+                unless candidate.respond_to?(:start) && candidate.respond_to?(:finish)
+                  raise TypeError, "does not respond to #start and #finish"
+                end
+                candidate
+              rescue => e
+                logger.error("Unable to load ruby_llm.insights.subscriber=#{class_name} (#{e.class}: #{e.message}); falling back to Honeybadger::RubyLLMSubscriber")
+                Honeybadger::RubyLLMSubscriber.new
+              end
+            end
+
+            # request.ruby_llm is intentionally excluded: it fires for every
+            # provider HTTP request (including retries and streams) and
+            # duplicates chat-level metadata.
+            ::ActiveSupport::Notifications.subscribe(
+              /(chat|tool_call|embedding|image|moderation|transcription|models\.refresh)\.ruby_llm/,
+              subscriber
+            )
+          end
+        end
+      end
+    end
+  end
+end
+
+module Honeybadger
+  class RubyLLMSubscriber < NotificationSubscriber
+    # Payloads carry full Ruby objects (chat, messages, responses, tool
+    # arguments, inputs), which may contain sensitive content. Allow only
+    # scalar metadata through.
+    def format_payload(name, payload)
+      case name
+      when "chat.ruby_llm"
+        payload.slice(:provider, :provider_class, :model, :message_count, :temperature, :tool_choice, :tool_call_limit, :streaming, :response_model, :response_role, :tool_call, :input_tokens, :output_tokens, :cached_tokens, :cache_creation_tokens, :thinking_tokens, :exception)
+      when "tool_call.ruby_llm"
+        payload.slice(:provider, :provider_class, :model, :tool_name, :tool_call_id, :result_class, :exception)
+      when "embedding.ruby_llm"
+        payload.slice(:provider, :provider_class, :model, :dimensions, :response_model, :input_tokens, :embedding_dimensions, :embedding_count, :exception)
+      when "image.ruby_llm"
+        payload.slice(:provider, :provider_class, :model, :size, :response_model, :exception)
+      when "moderation.ruby_llm"
+        payload.slice(:provider, :provider_class, :model, :flagged, :exception)
+      when "transcription.ruby_llm"
+        payload.slice(:provider, :provider_class, :model, :language, :response_model, :input_tokens, :output_tokens, :exception)
+      when "models.refresh.ruby_llm"
+        payload.slice(:remote_only, :model_count, :exception)
+      else
+        payload.slice(:provider, :provider_class, :model, :exception)
+      end
+    end
+  end
+end

data/lib/honeybadger/version.rb

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

data/lib/honeybadger/worker.rb

@@ -46,7 +46,9 @@ module Honeybadger
     end
 
     def send_now(msg)
-      handle_response(msg, notify_backend(msg))
+      response = notify_backend(msg)
+      run_after_notify_hooks(msg, response)
+      handle_response(msg, response)
     end
 
     def shutdown(force = false)
@@ -189,6 +191,21 @@ module Honeybadger
       backend.notify(:notices, payload)
     end
 
+    def run_after_notify_hooks(msg, response)
+      config.after_notify_hooks.each do |hook|
+        with_error_handling { hook.call(msg, response) }
+      end
+    end
+
+    def with_error_handling
+      yield
+    rescue => ex
+      error {
+        msg = "Rescued an error in an after notify hook class=%s message=%s\n\t%s"
+        sprintf(msg, ex.class, ex.message.dump, Array(ex.backtrace).join("\n\t"))
+      }
+    end
+
     def calc_throttle_interval
       ((BASE_THROTTLE**throttle) - 1).round(3)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: honeybadger
 version: !ruby/object:Gem::Version
-  version: 6.6.2
+  version: 6.9.0
 platform: ruby
 authors:
   - Honeybadger Industries LLC
@@ -122,6 +122,7 @@ files:
   - lib/honeybadger/plugins/passenger.rb
   - lib/honeybadger/plugins/rails.rb
   - lib/honeybadger/plugins/resque.rb
+  - lib/honeybadger/plugins/ruby_llm.rb
   - lib/honeybadger/plugins/shoryuken.rb
   - lib/honeybadger/plugins/sidekiq.rb
   - lib/honeybadger/plugins/solid_queue.rb