honeybadger 5.10.2 → 5.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 731b775f529f5438fd4062d5bebb966c9725ecc6cbbd8a1f1f62a92ae55ca9dd
-  data.tar.gz: 1ce0d3753f7d9b8500cba7453a282ae30f2017331bb03af8c604a19a3376f3e4
+  metadata.gz: 238281f2485599809a1cbde2313f3b3dbcce4e8ef2fb251b47190d6e2f5c5ce4
+  data.tar.gz: 82c41d922f89c1e9f0d3392086d6e3f2c2437842dba791715df324eacb3bf150
 SHA512:
-  metadata.gz: 6c59f15225ef73eb3dc066a88eb442a2f3cc64e475ab6c32b8997298d084318d56e994a81f38263ff6bf813a569dcb11d2850374dba0d4bbc86f8ff6c4b87895
-  data.tar.gz: 21e79a0a3483a5cbf6a1fbe70508d9d550b38a392c716fe9a23500050c01e42642b2ca1a73cc29708931d92b52375b801c1cf5c8141a6d8395c3536e4c1116f6
+  metadata.gz: 9186cbd806cd63e77c15b355502a1f3f666469b294324c01c55a92b85f29aaa7d5e5ba51b008f57e8f484ac9089679236cd7038dd8af40a7f97b91f05ef0cfde
+  data.tar.gz: 0f95f4ed9bd07fa00d57c0443b279283275824acd6d7dba60dc36b04cd26c1575b706ae633c7bb579a6d6cc44a328b70c898de68998940512b70563608fca442

data/CHANGELOG.md

@@ -1,6 +1,25 @@
 # Change Log
 
 
+## [5.11.1](https://github.com/honeybadger-io/honeybadger-ruby/compare/v5.11.0...v5.11.1) (2024-06-07)
+
+
+### Bug Fixes
+
+* do GoodJob.on_thread_error check via hash instead of method ([#558](https://github.com/honeybadger-io/honeybadger-ruby/issues/558)) ([d2aa464](https://github.com/honeybadger-io/honeybadger-ruby/commit/d2aa4640e371e3985310fb30ad5a356807d2bab3))
+
+## [5.11.0](https://github.com/honeybadger-io/honeybadger-ruby/compare/v5.10.2...v5.11.0) (2024-06-04)
+
+
+### Features
+
+* add insights instrumentation - events and metrics ([#539](https://github.com/honeybadger-io/honeybadger-ruby/issues/539)) ([d173ac5](https://github.com/honeybadger-io/honeybadger-ruby/commit/d173ac53b45be6b9036c292d8efc5002d8b354b1))
+
+
+### Bug Fixes
+
+* access GoodJob config via Rails.application.config ([#554](https://github.com/honeybadger-io/honeybadger-ruby/issues/554)) ([37b7786](https://github.com/honeybadger-io/honeybadger-ruby/commit/37b7786e9fefdaa23ccd45ca55a0573b0a832f58))
+
 ## [5.10.2](https://github.com/honeybadger-io/honeybadger-ruby/compare/v5.10.1...v5.10.2) (2024-05-24)
 
 

data/lib/honeybadger/agent.rb

@@ -8,7 +8,10 @@ require 'honeybadger/plugin'
 require 'honeybadger/logging'
 require 'honeybadger/worker'
 require 'honeybadger/events_worker'
+require 'honeybadger/metrics_worker'
 require 'honeybadger/breadcrumbs'
+require 'honeybadger/registry'
+require 'honeybadger/registry_execution'
 
 module Honeybadger
   # The Honeybadger agent contains all the methods for interacting with the
@@ -358,6 +361,7 @@ module Honeybadger
     ensure
       worker.flush
       events_worker&.flush
+      metrics_worker&.flush
     end
 
     # Stops the Honeybadger service.
@@ -367,6 +371,7 @@ module Honeybadger
     def stop(force = false)
       worker.shutdown(force)
       events_worker&.shutdown(force)
+      metrics_worker&.shutdown(force)
       true
     end
 
@@ -387,20 +392,46 @@ module Honeybadger
     def event(event_type, payload = {})
       init_events_worker
 
-      ts = DateTime.now.new_offset(0).rfc3339
+      ts = Time.now.utc.strftime("%FT%T.%LZ")
       merged = {ts: ts}
 
       if event_type.is_a?(String)
-        merged.merge!(event_type: event_type)
+        merged[:event_type] = event_type
       else
         merged.merge!(Hash(event_type))
       end
 
+      if (request_id = context_manager.get_request_id)
+        merged[:request_id] = request_id
+      end
+
+      if config[:'events.attach_hostname']
+        merged[:hostname] = config[:hostname].to_s
+      end
+
       merged.merge!(Hash(payload))
 
+      return if config.ignored_events.any? { |check| merged[:event_type]&.match?(check) }
+
       events_worker.push(merged)
     end
 
+    # @api private
+    def collect(collector)
+      return unless config.insights_enabled?
+
+      init_metrics_worker
+      metrics_worker.push(collector)
+    end
+
+    # @api private
+    def registry
+      return @registry if defined?(@registry)
+      @registry = Honeybadger::Registry.new.tap do |r|
+        collect(Honeybadger::RegistryExecution.new(r, config, {}))
+      end
+    end
+
     # @api private
     attr_reader :config
 
@@ -467,13 +498,15 @@ 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)
       yield
     ensure
       context_manager.set_rack_env(nil)
+      context_manager.set_request_id(nil)
     end
 
     # @api private
-    attr_reader :worker, :events_worker
+    attr_reader :worker, :events_worker, :metrics_worker
 
     # @api private
     # @!method init!(...)
@@ -485,6 +518,35 @@ module Honeybadger
     # @see Config#backend
     def_delegators :config, :backend
 
+    # @api private
+    # @!method time
+    # @see Honeybadger::Instrumentation#time
+    def_delegator :instrumentation, :time
+
+    # @api private
+    # @!method histogram
+    # @see Honeybadger::Instrumentation#histogram
+    def_delegator :instrumentation, :histogram
+
+    # @api private
+    # @!method gauge
+    # @see Honeybadger::Instrumentation#gauge
+    def_delegator :instrumentation, :gauge
+
+    # @api private
+    # @!method increment_counter
+    # @see Honeybadger::Instrumentation#increment_counter
+    def_delegator :instrumentation, :increment_counter
+
+    # @api private
+    # @!method decrement_counter
+    # @see Honeybadger::Instrumentation#decrement_counter
+    def_delegator :instrumentation, :decrement_counter
+
+    def instrumentation
+      @instrumentation ||= Honeybadger::Instrumentation.new(self)
+    end
+
     private
 
     def validate_notify_opts!(opts)
@@ -520,6 +582,11 @@ module Honeybadger
       @events_worker = EventsWorker.new(config)
     end
 
+    def init_metrics_worker
+      return if @metrics_worker
+      @metrics_worker = MetricsWorker.new(config)
+    end
+
     def with_error_handling
       yield
     rescue => ex

data/lib/honeybadger/config/defaults.rb

@@ -91,9 +91,14 @@ module Honeybadger
         default: 100,
         type: Integer
       },
+      :'events.max_queue_size' => {
+        description: 'Maximum number of event for the event worker queue.',
+        default: 10000,
+        type: Integer
+      },
       :'events.batch_size' => {
         description: 'Send events batch if n events have accumulated',
-        default: 100,
+        default: 1000,
         type: Integer
       },
       :'events.timeout' => {
@@ -101,6 +106,16 @@ module Honeybadger
         default: 30_000,
         type: Integer
       },
+      :'events.attach_hostname' => {
+        description: 'Add the hostname to all event paylaods.',
+        default: true,
+        type: Boolean
+      },
+      :'events.ignore' => {
+        description: 'A list of events to ignore. Use a string to specify exact matches, or regex for more flexibility.',
+        default: [],
+        type: Array
+      },
       plugins: {
         description: 'An optional list of plugins to load. Default is to load all plugins.',
         default: nil,
@@ -311,6 +326,36 @@ module Honeybadger
         default: true,
         type: Boolean
       },
+      :'sidekiq.insights.cluster_collection' => {
+        description: 'Collect cluster based metrics for Sidekiq.',
+        default: true,
+        type: Boolean
+      },
+      :'sidekiq.insights.collection_interval' => {
+        description: 'The frequency in which Sidekiq cluster metrics are sampled.',
+        default: 60,
+        type: Integer
+      },
+      :'solid_queue.insights.cluster_collection' => {
+        description: 'Collect cluster based metrics for SolidQueue.',
+        default: true,
+        type: Boolean
+      },
+      :'solid_queue.insights.collection_interval' => {
+        description: 'The frequency in which SolidQueue cluster metrics are sampled.',
+        default: 60,
+        type: Integer
+      },
+      :'net_http.insights.enabled' => {
+        description: 'Allow automatic instrumentation of Net::HTTP requests.',
+        default: true,
+        type: Boolean
+      },
+      :'net_http.insights.full_url' => {
+        description: 'Record the full request url during instrumentation.',
+        default: false,
+        type: Boolean
+      },
       :'sinatra.enabled' => {
         description: 'Enable Sinatra auto-initialization.',
         default: true,
@@ -343,6 +388,16 @@ module Honeybadger
         description: 'Enable/Disable automatic breadcrumbs from log messages.',
         default: true,
         type: Boolean
+      },
+      :'insights.enabled' => {
+        description: "Enable/Disable Honeybadger Insights built-in instrumentation.",
+        default: false,
+        type: Boolean
+      },
+      :'insights.registry_flush_interval' => {
+        description: "Number of seconds between registry flushes.",
+        default: 60,
+        type: Integer
       }
     }.freeze
 

data/lib/honeybadger/config.rb

@@ -188,6 +188,12 @@ module Honeybadger
       DEFAULTS[:'exceptions.ignore'] | Array(ignore)
     end
 
+    def ignored_events
+      self[:'events.ignore'].map do |check|
+        check.is_a?(String) ? /^#{check}$/ : check
+      end
+    end
+
     def ca_bundle_path
       if self[:'connection.system_ssl_cert_chain'] && File.exist?(OpenSSL::X509::DEFAULT_CERT_FILE)
         OpenSSL::X509::DEFAULT_CERT_FILE
@@ -224,6 +230,10 @@ module Honeybadger
       self[:max_queue_size]
     end
 
+    def events_max_queue_size
+      self[:'events.max_queue_size']
+    end
+
     def events_batch_size
       self[:'events.batch_size']
     end
@@ -262,6 +272,28 @@ module Honeybadger
       includes_token?(self[:plugins], name)
     end
 
+    def insights_enabled?
+      return false if defined?(::Rails.application) && ::Rails.const_defined?("Console")
+      !!self[:'insights.enabled']
+    end
+
+    def cluster_collection?(name)
+      return false unless insights_enabled?
+      return true if self[:"#{name}.insights.cluster_collection"].nil?
+      !!self[:"#{name}.insights.cluster_collection"]
+    end
+
+    def collection_interval(name)
+      return nil unless insights_enabled?
+      self[:"#{name}.insights.collection_interval"]
+    end
+
+    def load_plugin_insights?(name)
+      return false unless insights_enabled?
+      return true if self[:"#{name}.insights.enabled"].nil?
+      !!self[:"#{name}.insights.enabled"]
+    end
+
     def root_regexp
       return @root_regexp if @root_regexp
       return nil if @no_root

data/lib/honeybadger/context_manager.rb

@@ -61,15 +61,24 @@ module Honeybadger
       @mutex.synchronize { @rack_env }
     end
 
+    def set_request_id(request_id)
+      @mutex.synchronize { @request_id = request_id }
+    end
+
+    def get_request_id
+      @mutex.synchronize { @request_id }
+    end
+
     private
 
-    attr_accessor :custom, :rack_env
+    attr_accessor :custom, :rack_env, :request_id
 
     def _initialize
       @mutex.synchronize do
         @global_context = nil
         @local_context = nil
         @rack_env = nil
+        @request_id = nil
       end
     end
   end

data/lib/honeybadger/counter.rb

@@ -0,0 +1,18 @@
+require 'honeybadger/metric'
+
+module Honeybadger
+  class Counter < Metric
+    def count(by=1)
+      return unless by
+
+      @samples += 1
+
+      @counter ||= 0
+      @counter = @counter + by
+    end
+
+    def payloads
+      [{ counter: @counter }]
+    end
+  end
+end

data/lib/honeybadger/events_worker.rb

@@ -44,7 +44,7 @@ module Honeybadger
     def push(msg)
       return false unless start
 
-      if queue.size >= config.max_queue_size
+      if queue.size >= config.events_max_queue_size
         warn { sprintf('Unable to send event; reached max queue size of %s.', queue.size) }
         return false
       end

data/lib/honeybadger/gauge.rb

@@ -0,0 +1,30 @@
+require 'honeybadger/metric'
+
+module Honeybadger
+  class Gauge < Metric
+    def record(value)
+      return unless value
+
+      @samples += 1
+
+      @total ||= 0
+      @total = @total + value
+
+      @min = value if @min.nil? || @min > value
+      @max = value if @max.nil? || @max < value
+      @avg = @total.to_f / @samples
+      @latest = value
+    end
+
+    def payloads
+      [
+        {
+          min: @min,
+          max: @max,
+          avg: @avg,
+          latest: @latest
+        }
+      ]
+    end
+  end
+end

data/lib/honeybadger/histogram.rb

@@ -0,0 +1,32 @@
+require 'honeybadger/metric'
+
+module Honeybadger
+  class Histogram < Metric
+    DEFAULT_BINS = [0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0]
+    INFINITY = 1e20.to_f # not quite, but pretty much
+
+    def record(value)
+      return unless value
+
+      @samples += 1
+      @bin_counts ||= Hash.new(0)
+      @bin_counts[find_bin(value)] += 1
+    end
+
+    def find_bin(value)
+      bin = bins.find {|b| b >= value  }
+      bin = INFINITY if bin.nil?
+      bin
+    end
+
+    def bins
+      @attributes.fetch(:bins, DEFAULT_BINS).sort
+    end
+
+    def payloads
+      [{
+        bins: (bins + [INFINITY]).map { |bin| [bin.to_f, @bin_counts[bin]] }
+      }]
+    end
+  end
+end

data/lib/honeybadger/instrumentation.rb

@@ -0,0 +1,124 @@
+require 'honeybadger/histogram'
+require 'honeybadger/timer'
+require 'honeybadger/counter'
+require 'honeybadger/gauge'
+
+module Honeybadger
+  # +Honeybadger::Instrumentation+ defines the API for collecting metric data from anywhere
+  # in an application. These class methods may be used directly, or from the Honeybadger singleton
+  # instance. There are three usage variations as show in the example below:
+  #
+  # @example
+  #
+  # class TicketsController < ApplicationController
+  #   def create
+  #     # pass a block
+  #     Honeybadger.time('create.ticket') { Ticket.create(params[:ticket]) }
+  #
+  #     # pass a lambda argument
+  #     Honeybadger.time 'create.ticket', ->{ Ticket.create(params[:ticket]) }
+  #
+  #     # pass the duration argument
+  #     duration = timing_method { Ticket.create(params[:ticket]) }
+  #     Honeybadger.time 'create.ticket', duration: duration
+  #   end
+  # end
+  #
+  #
+  class Instrumentation
+    attr_reader :agent
+
+    def initialize(agent)
+      @agent = agent
+    end
+
+    def registry
+      agent.registry
+    end
+
+    # returns two parameters, the first is the duration of the execution, and the second is
+    # the return value of the passed block
+    def monotonic_timer
+      start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      result = yield
+      finish_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      [((finish_time - start_time) * 1000).round(2), result]
+    end
+
+    def time(name, *args)
+      attributes = extract_attributes(args)
+      callable = extract_callable(args)
+      duration = attributes.delete(:duration)
+
+      if callable
+        duration = monotonic_timer{ callable.call }[0]
+      elsif block_given?
+        duration = monotonic_timer{ yield }[0]
+      end
+
+      raise 'No duration found' if duration.nil?
+
+      Honeybadger::Timer.register(registry, name, attributes).tap do |timer|
+        timer.record(duration)
+      end
+    end
+
+    def histogram(name, *args)
+      attributes = extract_attributes(args)
+      callable = extract_callable(args)
+      duration = attributes.delete(:duration)
+
+      if callable
+        duration = monotonic_timer{ callable.call }[0]
+      elsif block_given?
+        duration = monotonic_timer{ yield }[0]
+      end
+
+      raise 'No duration found' if duration.nil?
+
+      Honeybadger::Histogram.register(registry, name, attributes).tap do |histogram|
+        histogram.record(duration)
+      end
+    end
+
+    def increment_counter(name, *args)
+      attributes = extract_attributes(args)
+      by = extract_callable(args)&.call || attributes.delete(:by) || 1
+      by = yield if block_given?
+
+      Honeybadger::Counter.register(registry, name, attributes).tap do |counter|
+        counter.count(by)
+      end
+    end
+
+    def decrement_counter(name, *args)
+      attributes = extract_attributes(args)
+      by = extract_callable(args)&.call || attributes.delete(:by) || 1
+      by = yield if block_given?
+
+      Honeybadger::Counter.register(registry, name, attributes).tap do |counter|
+        counter.count(by * -1)
+      end
+    end
+
+    def gauge(name, *args)
+      attributes = extract_attributes(args)
+      value = extract_callable(args)&.call || attributes.delete(:value)
+      value = yield if block_given?
+
+      Honeybadger::Gauge.register(registry, name, attributes).tap do |gauge|
+        gauge.record(value)
+      end
+    end
+
+    # @api private
+    def extract_attributes(args)
+      args.select { |a| a.is_a?(Hash) }.first || {}
+    end
+
+    # @api private
+    def extract_callable(args)
+      args.select { |a| a.respond_to?(:call) }.first
+    end
+  end
+end

data/lib/honeybadger/instrumentation_helper.rb

@@ -0,0 +1,120 @@
+require 'honeybadger/instrumentation'
+
+module Honeybadger
+  # +Honeybadger::InstrumentationHelper+ is a module that can be included into any class. This module
+  # provides a convenient DSL around the instrumentation methods to prvoide a cleaner interface.
+  # There are three usage variations as show in the example below:
+  #
+  # @example
+  #
+  # class TicketsController < ApplicationController
+  #   include Honeybadger::InstrumentationHelper
+  #
+  #   def create
+  #     metric_source 'controller'
+  #     metric_attributes { foo: 'bar' } # These attributes get tagged to all metrics called after.
+  #
+  #     # pass a block
+  #     time('create.ticket') { Ticket.create(params[:ticket]) }
+  #
+  #     # pass a lambda argument
+  #     time 'create.ticket', ->{ Ticket.create(params[:ticket]) }
+  #
+  #     # pass the duration argument
+  #     duration = timing_method { Ticket.create(params[:ticket]) }
+  #     time 'create.ticket', duration: duration
+  #   end
+  # end
+  #
+  #
+  module InstrumentationHelper
+
+    # returns two parameters, the first is the duration of the execution, and the second is
+    # the return value of the passed block
+    def monotonic_timer
+      metric_instrumentation.monotonic_timer { yield }
+    end
+
+    def metric_source(source)
+      @metric_source = source
+    end
+
+    def metric_agent(agent)
+      @metric_agent = agent
+    end
+
+    def metric_instrumentation
+      @metric_instrumentation ||= @metric_agent ? Honeybadger::Instrumentation.new(@metric_agent) : Honeybadger.instrumentation
+    end
+
+    def metric_attributes(attributes)
+      raise "metric_attributes expects a hash" unless attributes.is_a?(Hash)
+      @metric_attributes = attributes
+    end
+
+    def time(name, *args)
+      attributes = extract_attributes(args)
+      callable = extract_callable(args)
+      if callable
+        metric_instrumentation.time(name, attributes, ->{ callable.call })
+      elsif block_given?
+        metric_instrumentation.time(name, attributes, ->{ yield })
+      elsif attributes.keys.include?(:duration)
+        metric_instrumentation.time(name, attributes)
+      end
+    end
+
+    def histogram(name, *args)
+      attributes = extract_attributes(args)
+      callable = extract_callable(args)
+      if callable
+        metric_instrumentation.histogram(name, attributes, ->{ callable.call })
+      elsif block_given?
+        metric_instrumentation.histogram(name, attributes, ->{ yield })
+      elsif attributes.keys.include?(:duration)
+        metric_instrumentation.histogram(name, attributes)
+      end
+    end
+
+    def increment_counter(name, *args)
+      attributes = extract_attributes(args)
+      by = extract_callable(args)&.call || attributes.delete(:by) || 1
+      if block_given?
+        metric_instrumentation.increment_counter(name, attributes, ->{ yield })
+      else
+        metric_instrumentation.increment_counter(name, attributes.merge(by: by))
+      end
+    end
+
+    def decrement_counter(name, *args)
+      attributes = extract_attributes(args)
+      by = extract_callable(args)&.call || attributes.delete(:by) || 1
+      if block_given?
+        metric_instrumentation.decrement_counter(name, attributes, ->{ yield })
+      else
+        metric_instrumentation.decrement_counter(name, attributes.merge(by: by))
+      end
+    end
+
+    def gauge(name, *args)
+      attributes = extract_attributes(args)
+      value = extract_callable(args)&.call || attributes.delete(:value)
+      if block_given?
+        metric_instrumentation.gauge(name, attributes, ->{ yield })
+      else
+        metric_instrumentation.gauge(name, attributes.merge(value: value))
+      end
+    end
+
+    # @api private
+    def extract_attributes(args)
+      attributes = metric_instrumentation.extract_attributes(args)
+      attributes.merge(metric_source: @metric_source).merge(@metric_attributes || {}).compact
+    end
+
+    # @api private
+    def extract_callable(args)
+      metric_instrumentation.extract_callable(args)
+    end
+  end
+end