honeybadger 5.10.2 → 5.11.1

data/lib/honeybadger/metric.rb

@@ -0,0 +1,47 @@
+module Honeybadger
+  class Metric
+    attr_reader :name, :attributes, :samples
+
+    def self.metric_type
+      name.split('::').last.downcase
+    end
+
+    def self.signature(metric_type, name, attributes)
+      Digest::SHA1.hexdigest("#{metric_type}-#{name}-#{attributes.keys.join('-')}-#{attributes.values.join('-')}").to_sym
+    end
+
+    def self.register(registry, metric_name, attributes)
+      registry.get(metric_type, metric_name, attributes) ||
+        registry.register(new(metric_name, attributes))
+    end
+
+    def initialize(name, attributes)
+      @name = name
+      @attributes = attributes || {}
+      @samples = 0
+    end
+
+    def metric_type
+      self.class.metric_type
+    end
+
+    def signature
+      self.class.signature(metric_type, name, attributes)
+    end
+
+    def base_payload
+      attributes.merge({
+        event_type: "metric.hb",
+        metric_name: name,
+        metric_type: metric_type,
+        samples: samples
+      })
+    end
+
+    def event_payloads
+      payloads.map do |payload|
+        base_payload.merge(payload)
+      end
+    end
+  end
+end

data/lib/honeybadger/metrics_worker.rb

@@ -0,0 +1,175 @@
+require 'honeybadger/logging'
+
+module Honeybadger
+  # A concurrent queue to execute plugin collect blocks and registry.
+  # @api private
+  class MetricsWorker
+    extend Forwardable
+
+    include Honeybadger::Logging::Helper
+
+    # Sub-class thread so we have a named thread (useful for debugging in Thread.list).
+    class Thread < ::Thread; end
+
+    # Used to signal the worker to shutdown.
+    SHUTDOWN = :__hb_worker_shutdown!
+
+    def initialize(config)
+      @config = config
+      @interval_seconds = 1
+      @mutex = Mutex.new
+      @marker = ConditionVariable.new
+      @queue = Queue.new
+      @shutdown = false
+      @start_at = nil
+      @pid = Process.pid
+    end
+
+    def push(msg)
+      return false unless config.insights_enabled?
+      return false unless start
+
+      queue.push(msg)
+    end
+
+    def send_now(msg)
+      return if msg.tick > 0
+
+      msg.call
+      msg.reset
+    end
+
+    def shutdown(force = false)
+      d { 'shutting down worker' }
+
+      mutex.synchronize do
+        @shutdown = true
+      end
+
+      return true if force
+      return true unless thread&.alive?
+
+      queue.push(SHUTDOWN)
+      !!thread.join
+    ensure
+      queue.clear
+      kill!
+    end
+
+    # Blocks until queue is processed up to this point in time.
+    def flush
+      mutex.synchronize do
+        if thread && thread.alive?
+          queue.push(marker)
+          marker.wait(mutex)
+        end
+      end
+    end
+
+    def start
+      return false unless can_start?
+
+      mutex.synchronize do
+        @shutdown = false
+        @start_at = nil
+
+        return true if thread&.alive?
+
+        @pid = Process.pid
+        @thread = Thread.new { run }
+      end
+
+      true
+    end
+
+    private
+
+    attr_reader :config, :queue, :pid, :mutex, :marker, :thread, :interval_seconds, :start_at
+
+    def shutdown?
+      mutex.synchronize { @shutdown }
+    end
+
+    def suspended?
+      mutex.synchronize { start_at && Time.now.to_i < start_at }
+    end
+
+    def can_start?
+      return false if shutdown?
+      return false if suspended?
+      true
+    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 do
+        @start_at = Time.now.to_i + interval
+        queue.clear
+      end
+
+      # Must be performed last since this may kill the current thread.
+      kill!
+    end
+
+    def run
+      begin
+        d { 'worker started' }
+        loop do
+          case msg = queue.pop
+          when SHUTDOWN then break
+          when ConditionVariable then signal_marker(msg)
+          else work(msg)
+          end
+        end
+      ensure
+        d { 'stopping worker' }
+      end
+    rescue Exception => e
+      error {
+        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
+      release_marker
+    end
+
+    def work(msg)
+      send_now(msg)
+
+      if shutdown?
+        kill!
+        return
+      end
+    rescue StandardError => e
+      error {
+        err = "Error in worker thread class=%s message=%s\n\t%s"
+        sprintf(err, e.class, e.message.dump, Array(e.backtrace).join("\n\t"))
+      }
+    ensure
+      queue.push(msg) unless shutdown? || suspended?
+      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)
+    end
+
+    def signal_marker(marker)
+      mutex.synchronize do
+        marker.signal
+      end
+    end
+  end
+end

data/lib/honeybadger/notification_subscriber.rb

@@ -0,0 +1,99 @@
+require 'honeybadger/instrumentation_helper'
+
+module Honeybadger
+  class NotificationSubscriber
+    def start(name, id, payload)
+      @start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+    end
+
+    def finish(name, id, payload)
+      @finish_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+
+      return unless process?(name)
+
+      payload = {
+        instrumenter_id: id,
+        duration: ((@finish_time - @start_time) * 1000).round(2)
+      }.merge(format_payload(payload).compact)
+
+      record(name, payload)
+    end
+
+    def record(name, payload)
+      Honeybadger.event(name, payload)
+    end
+
+    def process?(event)
+      true
+    end
+
+    def format_payload(payload)
+      payload
+    end
+  end
+
+  class ActionControllerSubscriber < NotificationSubscriber
+    def format_payload(payload)
+      payload.except(:headers, :request, :response)
+    end
+  end
+
+  class ActionControllerCacheSubscriber < NotificationSubscriber
+  end
+
+  class ActiveSupportCacheSubscriber < NotificationSubscriber
+  end
+
+  class ActionViewSubscriber < NotificationSubscriber
+    PROJECT_ROOT = defined?(::Rails) ? ::Rails.root.to_s : ''
+
+    def format_payload(payload)
+      {
+        view: payload[:identifier].to_s.gsub(PROJECT_ROOT, '[PROJECT_ROOT]'),
+        layout: payload[:layout]
+      }
+    end
+  end
+
+  class ActiveRecordSubscriber < NotificationSubscriber
+    def format_payload(payload)
+      {
+        query: payload[:sql].to_s.gsub(/\s+/, ' ').strip,
+        async: payload[:async]
+      }
+    end
+  end
+
+  class ActiveJobSubscriber < NotificationSubscriber
+    def format_payload(payload)
+      job = payload[:job]
+      payload.except(:job).merge({
+        job_class: job.class,
+        job_id: job.job_id,
+        queue_name: job.queue_name
+      })
+    end
+  end
+
+  class ActiveJobMetricsSubscriber < NotificationSubscriber
+    include Honeybadger::InstrumentationHelper
+
+    def format_payload(payload)
+      {
+        job_class: payload[:job].class,
+        queue_name: payload[:job].queue_name
+      }
+    end
+
+    def record(name, payload)
+      metric_source 'active_job'
+      histogram name, { bins: [30, 60, 120, 300, 1800, 3600, 21_600] }.merge(payload)
+    end
+  end
+
+  class ActionMailerSubscriber < NotificationSubscriber
+  end
+
+  class ActiveStorageSubscriber < NotificationSubscriber
+  end
+end

data/lib/honeybadger/plugin.rb

@@ -1,4 +1,5 @@
 require 'forwardable'
+require 'honeybadger/instrumentation_helper'
 
 module Honeybadger
   # +Honeybadger::Plugin+ defines the API for registering plugins with
@@ -7,6 +8,11 @@ module Honeybadger
   # optional dependencies and load the plugin for each dependency only if it's
   # present in the application.
   #
+  # Plugins may also define a collect block that is repeatedly called from
+  # within a thread. The MetricsWorker contains a loop that will call all
+  # enabled plugins' collect method, and then sleep for 1 second. This block
+  # is useful for collecting and/or sending metrics at regular intervals.
+  #
   # See the plugins/ directory for examples of official plugins. If you're
   # interested in developing a plugin for Honeybadger, see the Integration
   # Guide: https://docs.honeybadger.io/ruby/gem-reference/integration.html
@@ -37,6 +43,14 @@ module Honeybadger
   #             Honeybadger.notify(exception)
   #           end
   #         end
+  #
+  #         collect do
+  #           # This block will be periodically called at regular intervals. Here you can
+  #           # gather metrics or inspect services. See the Honeybadger::InstrumentationHelper
+  #           # module to see availble methods for metric collection.
+  #           gauge 'scheduled_jobs', -> { MyFramework.stats.scheduled_jobs.count }
+  #           gauge 'latency', -> { MyFramework.stats.latency }
+  #         end
   #       end
   #     end
   #   end
@@ -53,13 +67,15 @@ module Honeybadger
         @@instances
       end
 
-      # Register a new plugin with Honeybadger. See {#requirement} and {#execution}.
+      # Register a new plugin with Honeybadger. See {#requirement}, {#execution}, and
+      # {#collect}..
       #
       # @example
       #
       #   Honeybadger::Plugin.register 'my_framework' do
       #     requirement { }
       #     execution { }
+      #     collect { }
       #   end
       #
       # @param [String, Symbol] name The optional name of the plugin. Should use
@@ -111,12 +127,41 @@ module Honeybadger
       def_delegator :@config, :logger
     end
 
+    # @api private
+    class CollectorExecution < Execution
+      include Honeybadger::InstrumentationHelper
+
+      DEFAULT_COLLECTION_INTERVAL = 60
+
+      def initialize(name, config, options, &block)
+        @name = name
+        @config = config
+        @options = options
+        @block = block
+        @interval = config.collection_interval(name) || options.fetch(:interval, DEFAULT_COLLECTION_INTERVAL)
+        @end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + @interval
+      end
+
+      def tick
+        @end_time - ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      end
+
+      def reset
+        @end_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + @interval
+      end
+
+      def register!
+        Honeybadger.collect(self)
+      end
+    end
+
     # @api private
     def initialize(name)
       @name         = name
       @loaded       = false
       @requirements = []
       @executions   = []
+      @collectors   = []
     end
 
     # Define a requirement. All requirement blocks must return +true+ for the
@@ -165,6 +210,31 @@ module Honeybadger
       @executions << block
     end
 
+    # Define an collect block. Collect blocks will be added to an execution
+    # queue if requirement blocks return +true+. The block will be called as frequently
+    # as once per second, but can be configured to increase it's interval.
+    #
+    # @example
+    #
+    #   Honeybadger::Plugin.register 'my_framework' do
+    #     requirement { defined?(MyFramework) }
+    #
+    #     collect do
+    #       stats = MyFramework.stats
+    #       gauge 'capacity', -> { stats.capcity }
+    #     end
+    #
+    #     collect(interval: 10) do
+    #       stats = MyFramework.more_expensive_stats
+    #       gauge 'other_stat', -> { stats.expensive_metric }
+    #     end
+    #   end
+    #
+    # @return nil
+    def collect(options={}, &block)
+      @collectors << [options, block]
+    end
+
     # @api private
     def ok?(config)
       @requirements.all? {|r| Execution.new(config, &r).call }
@@ -181,6 +251,7 @@ module Honeybadger
       elsif ok?(config)
         config.logger.debug(sprintf('load plugin name=%s', name))
         @executions.each {|e| Execution.new(config, &e).call }
+        @collectors.each {|o,b| CollectorExecution.new(name, config, o, &b).register! }
         @loaded = true
       else
         config.logger.debug(sprintf('skip plugin name=%s reason=requirement', name))
@@ -193,6 +264,11 @@ module Honeybadger
       false
     end
 
+    # @api private
+    def collectors
+      @collectors
+    end
+
     # @api private
     def loaded?
       @loaded

data/lib/honeybadger/plugins/active_job.rb

@@ -1,3 +1,5 @@
+require 'honeybadger/notification_subscriber'
+
 module Honeybadger
   module Plugins
     module ActiveJob
@@ -33,17 +35,27 @@ module Honeybadger
         end
       end
 
-      Plugin.register do
+      Plugin.register :active_job do
         requirement do
           defined?(::Rails.application) &&
             ::Rails.application.config.respond_to?(:active_job) &&
-            (queue_adapter = ::Rails.application.config.active_job[:queue_adapter]) &&
-            !EXCLUDED_ADAPTERS.include?(queue_adapter.to_sym) &&
-            !(defined?(::GoodJob) && ::GoodJob.on_thread_error.nil? && queue_adapter.to_sym == :good_job) # Don't report errors if GoodJob is reporting them
+            !EXCLUDED_ADAPTERS.include?(::Rails.application.config.active_job[:queue_adapter].to_sym)
+        end
+
+        # Don't report errors if GoodJob is reporting them
+        requirement do
+          ::Rails.application.config.active_job[:queue_adapter].to_sym != :good_job ||
+            !::Rails.application.config.respond_to?(:good_job) ||
+            ::Rails.application.config.good_job[:on_thread_error].nil?
         end
 
         execution do
           ::ActiveJob::Base.set_callback(:perform, :around, &ActiveJob.method(:perform_around))
+
+          if config.load_plugin_insights?(:active_job)
+            ::ActiveSupport::Notifications.subscribe(/(enqueue_at|enqueue|enqueue_retry|enqueue_all|perform|retry_stopped|discard)\.active_job/, Honeybadger::ActiveJobSubscriber.new)
+            ::ActiveSupport::Notifications.subscribe('perform.active_job', Honeybadger::ActiveJobMetricsSubscriber.new)
+          end
         end
       end
     end

data/lib/honeybadger/plugins/autotuner.rb

@@ -0,0 +1,30 @@
+require 'honeybadger/instrumentation_helper'
+require 'honeybadger/plugin'
+
+module Honeybadger
+  module Plugins
+    module Autotuner
+      Plugin.register :autotuner do
+        requirement { config.load_plugin_insights?(:autotuner) && defined?(::Autotuner) }
+
+        execution do
+          singleton_class.include(Honeybadger::InstrumentationHelper)
+
+          ::Autotuner.enabled = true
+
+          ::Autotuner.reporter = proc do |report|
+            Honeybadger.event("report.autotuner", report: report.to_s)
+          end
+
+          metric_source 'autotuner'
+
+          ::Autotuner.metrics_reporter = proc do |metrics|
+            metrics.each do |key, val|
+              gauge key, ->{ val }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/karafka.rb

@@ -1,14 +1,29 @@
 require 'honeybadger/plugin'
-require 'honeybadger/ruby'
 
 module Honeybadger
   module Plugins
-    Plugin.register do
+    Plugin.register :karafka do
       requirement { defined?(::Karafka) }
 
       execution do
         ::Karafka.monitor.subscribe('error.occurred') do |event|
           Honeybadger.notify(event[:error])
+          Honeybadger.event('error.occurred', error: event[:error]) if config.load_plugin_insights?(:karafka)
+        end
+
+        if config.load_plugin_insights?(:karafka)
+          ::Karafka.monitor.subscribe("consumer.consumed") do |event|
+            context = {
+              duration: event.payload[:time],
+              consumer: event.payload[:caller].class.to_s,
+              id: event.payload[:caller].id,
+              topic: event.payload[:caller].messages.metadata.topic,
+              messages_count: event.payload[:caller].messages.metadata.size,
+              partition: event.payload[:caller].messages.metadata.partition
+            }
+
+            Honeybadger.event('consumer.consumed.karafka', context)
+          end
         end
       end
     end

data/lib/honeybadger/plugins/net_http.rb

@@ -0,0 +1,52 @@
+require 'net/http'
+require 'honeybadger/plugin'
+require 'honeybadger/instrumentation'
+require 'resolv'
+
+module Honeybadger
+  module Plugins
+    module Net
+      module HTTP
+        def request(request_data, body = nil, &block)
+          return super unless started?
+          return super if hb?
+
+          Honeybadger.instrumentation.monotonic_timer { super }.tap do |duration, response_data|
+            context = {
+              duration: duration,
+              method: request_data.method,
+              status: response_data.code.to_i
+            }.merge(parsed_uri_data(request_data))
+
+            Honeybadger.event('request.net_http', context)
+          end[1] # return the response data only
+        end
+
+        def hb?
+          address.to_s[/#{Honeybadger.config[:'connection.host'].to_s}/]
+        end
+
+        def parsed_uri_data(request_data)
+          uri = request_data.uri || build_uri(request_data)
+          {}.tap do |uri_data|
+            uri_data[:host] = uri.host
+            uri_data[:url] = uri.to_s if Honeybadger.config[:'net_http.insights.full_url']
+          end
+        end
+
+        def build_uri(request_data)
+          hostname = (address[/#{Resolv::IPv6::Regex}/]) ? "[#{address}]" : address
+          URI.parse("#{use_ssl? ? 'https' : 'http'}://#{hostname}#{request_data.path}")
+        end
+
+        Plugin.register :net_http do
+          requirement { config.load_plugin_insights?(:net_http) }
+
+          execution do
+            ::Net::HTTP.send(:prepend, Honeybadger::Plugins::Net::HTTP)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/rails.rb

@@ -1,4 +1,5 @@
 require 'honeybadger/plugin'
+require 'honeybadger/notification_subscriber'
 
 module Honeybadger
   module Plugins
@@ -68,6 +69,20 @@ module Honeybadger
           end
         end
       end
+
+      Plugin.register :rails do
+        requirement { config.load_plugin_insights?(:rails_metrics) && defined?(::Rails.application) && ::Rails.application }
+
+        execution do
+          ::ActiveSupport::Notifications.subscribe(/(process_action|send_file|redirect_to|halted_callback|unpermitted_parameters)\.action_controller/, Honeybadger::ActionControllerSubscriber.new)
+          ::ActiveSupport::Notifications.subscribe(/(write_fragment|read_fragment|expire_fragment|exist_fragment\?)\.action_controller/, Honeybadger::ActionControllerCacheSubscriber.new)
+          ::ActiveSupport::Notifications.subscribe(/cache_(read|read_multi|generate|fetch_hit|write|write_multi|increment|decrement|delete|delete_multi|cleanup|prune|exist\?)\.active_support/, Honeybadger::ActiveSupportCacheSubscriber.new)
+          ::ActiveSupport::Notifications.subscribe(/^render_(template|partial|collection)\.action_view/, Honeybadger::ActionViewSubscriber.new)
+          ::ActiveSupport::Notifications.subscribe("sql.active_record", Honeybadger::ActiveRecordSubscriber.new)
+          ::ActiveSupport::Notifications.subscribe("process.action_mailer", Honeybadger::ActionMailerSubscriber.new)
+          ::ActiveSupport::Notifications.subscribe(/(service_upload|service_download)\.active_storage/, Honeybadger::ActiveStorageSubscriber.new)
+        end
+      end
     end
   end
 end