honeybadger 5.16.0 → 5.26.4

data/lib/honeybadger/plugins/sidekiq.rb

@@ -38,10 +38,14 @@ module Honeybadger
             raise
           ensure
             context.merge!(duration: duration, status: status)
-            Honeybadger.event('perform.sidekiq', context)
+            if Honeybadger.config.load_plugin_insights_events?(:sidekiq)
+              Honeybadger.event('perform.sidekiq', context)
+            end
 
-            metric_source 'sidekiq'
-            histogram 'perform', { bins: [30, 60, 120, 300, 1800, 3600, 21_600] }.merge(context.slice(:worker, :queue, :duration))
+            if Honeybadger.config.load_plugin_insights_metrics?(:sidekiq)
+              metric_source 'sidekiq'
+              gauge 'perform', context.slice(:worker, :queue, :duration)
+            end
           end
         end
       end
@@ -55,7 +59,9 @@ module Honeybadger
             queue: queue
           }
 
-          Honeybadger.event('enqueue.sidekiq', context)
+          if Honeybadger.config.load_plugin_insights_events?(:sidekiq)
+            Honeybadger.event('enqueue.sidekiq', context)
+          end
 
           yield
         end
@@ -67,60 +73,62 @@ module Honeybadger
         requirement { defined?(::Sidekiq) }
 
         execution do
-          ::Sidekiq.configure_server do |sidekiq|
-            sidekiq.server_middleware do |chain|
-              chain.prepend Middleware
+          if Honeybadger.config[:'exceptions.enabled']
+            ::Sidekiq.configure_server do |sidekiq|
+              sidekiq.server_middleware do |chain|
+                chain.prepend Middleware
+              end
             end
-          end
 
-          if defined?(::Sidekiq::VERSION) && ::Sidekiq::VERSION > '3'
-            ::Sidekiq.configure_server do |sidekiq|
+            if defined?(::Sidekiq::VERSION) && ::Sidekiq::VERSION > '3'
+              ::Sidekiq.configure_server do |sidekiq|
 
-              sidekiq_default_configuration = (::Sidekiq::VERSION > '7') ?
-                ::Sidekiq.default_configuration : Class.new
+                sidekiq_default_configuration = (::Sidekiq::VERSION > '7') ?
+                  ::Sidekiq.default_configuration : Class.new
 
-              sidekiq.error_handlers << lambda { |ex, sidekiq_params, sidekiq_config = sidekiq_default_configuration|
-                params = sidekiq_params.dup
-                if defined?(::Sidekiq::Config)
-                  if params[:_config].is_a?(::Sidekiq::Config) # Sidekiq > 6 and < 7.1.5
-                    params[:_config] = params[:_config].instance_variable_get(:@options)
-                  else # Sidekiq >= 7.1.5
-                    params[:_config] = sidekiq_config.instance_variable_get(:@options)
+                sidekiq.error_handlers << lambda { |ex, sidekiq_params, sidekiq_config = sidekiq_default_configuration|
+                  params = sidekiq_params.dup
+                  if defined?(::Sidekiq::Config)
+                    if params[:_config].is_a?(::Sidekiq::Config) # Sidekiq > 6 and < 7.1.5
+                      params[:_config] = params[:_config].instance_variable_get(:@options)
+                    else # Sidekiq >= 7.1.5
+                      params[:_config] = sidekiq_config.instance_variable_get(:@options)
+                    end
                   end
-                end
 
-                job = params[:job] || params
+                  job = params[:job] || params
 
-                job_retry = job['retry'.freeze]
+                  job_retry = job['retry'.freeze]
 
-                if (threshold = config[:'sidekiq.attempt_threshold'].to_i) > 0 && job_retry
-                  # We calculate the job attempts to determine the need to
-                  # skip. Sidekiq's first job execution will have nil for the
-                  # 'retry_count' job key. The first retry will have 0 set for
-                  # the 'retry_count' key, incrementing on each execution
-                  # afterwards.
-                  retry_count = job['retry_count'.freeze]
-                  attempt = retry_count ? retry_count + 1 : 0
+                  if (threshold = config[:'sidekiq.attempt_threshold'].to_i) > 0 && job_retry
+                    # We calculate the job attempts to determine the need to
+                    # skip. Sidekiq's first job execution will have nil for the
+                    # 'retry_count' job key. The first retry will have 0 set for
+                    # the 'retry_count' key, incrementing on each execution
+                    # afterwards.
+                    retry_count = job['retry_count'.freeze]
+                    attempt = retry_count ? retry_count + 1 : 0
 
-                  max_retries = (::Sidekiq::VERSION > '7') ?
-                    ::Sidekiq.default_configuration[:max_retries] : sidekiq.options[:max_retries]
-                  # Ensure we account for modified max_retries setting
-                  default_max_retry_attempts = defined?(::Sidekiq::JobRetry::DEFAULT_MAX_RETRY_ATTEMPTS) ? ::Sidekiq::JobRetry::DEFAULT_MAX_RETRY_ATTEMPTS : 25
-                  retry_limit = job_retry == true ? (max_retries || default_max_retry_attempts) : job_retry.to_i
+                    max_retries = (::Sidekiq::VERSION > '7') ?
+                      ::Sidekiq.default_configuration[:max_retries] : sidekiq.options[:max_retries]
+                    # Ensure we account for modified max_retries setting
+                    default_max_retry_attempts = defined?(::Sidekiq::JobRetry::DEFAULT_MAX_RETRY_ATTEMPTS) ? ::Sidekiq::JobRetry::DEFAULT_MAX_RETRY_ATTEMPTS : 25
+                    retry_limit = job_retry == true ? (max_retries || default_max_retry_attempts) : job_retry.to_i
 
-                  limit = [retry_limit, threshold].min
+                    limit = [retry_limit, threshold].min
 
-                  return if attempt < limit
-                end
+                    return if attempt < limit
+                  end
 
-                opts = { parameters: params }
-                if config[:'sidekiq.use_component']
-                  opts[:component] = job['wrapped'.freeze] || job['class'.freeze]
-                  opts[:action] = 'perform' if opts[:component]
-                end
+                  opts = { parameters: params }
+                  if config[:'sidekiq.use_component']
+                    opts[:component] = job['wrapped'.freeze] || job['class'.freeze]
+                    opts[:action] = 'perform' if opts[:component]
+                  end
 
-                Honeybadger.notify(ex, opts)
-              }
+                  Honeybadger.notify(ex, opts)
+                }
+              end
             end
           end
 
@@ -161,47 +169,67 @@ module Honeybadger
           end
         end
 
+        collect_sidekiq_stats = -> do
+          stats = ::Sidekiq::Stats.new
+          data = stats.as_json
+          data[:queues] = {}
+
+          ::Sidekiq::Queue.all.each do |queue|
+            data[:queues][queue.name] ||= {}
+            data[:queues][queue.name][:latency] = (queue.latency * 1000).ceil
+            data[:queues][queue.name][:depth] = queue.size
+          end
+
+          Hash.new(0).tap do |busy_counts|
+            ::Sidekiq::Workers.new.each do |_pid, _tid, work|
+              payload = work.respond_to?(:payload) ? work.payload : work["payload"]
+              payload = JSON.parse(payload) if payload.is_a?(String)
+              busy_counts[payload["queue"]] += 1
+            end
+          end.each do |queue_name, busy_count|
+            data[:queues][queue_name] ||= {}
+            data[:queues][queue_name][:busy] = busy_count
+          end
+
+          processes = ::Sidekiq::ProcessSet.new.to_enum(:each).to_a
+          data[:capacity] = processes.map { |process| process["concurrency"] }.sum
+
+          process_utilizations = processes.map do |process|
+            next unless process["concurrency"].to_f > 0
+            process["busy"] / process["concurrency"].to_f
+          end.compact
+
+          if process_utilizations.any?
+            utilization = process_utilizations.sum / process_utilizations.length.to_f
+            data[:utilization] = utilization
+          end
+
+          data
+        end
+
         collect do
           if config.cluster_collection?(:sidekiq) && (leader_checker.nil? || leader_checker.collect?)
-            metric_source 'sidekiq'
-
-            stats = ::Sidekiq::Stats.new
-
-            gauge 'active_workers', ->{ stats.workers_size }
-            gauge 'active_processes', ->{ stats.processes_size }
-            gauge 'jobs_processed', ->{ stats.processed }
-            gauge 'jobs_failed', ->{ stats.failed }
-            gauge 'jobs_scheduled', ->{ stats.scheduled_size }
-            gauge 'jobs_enqueued', ->{ stats.enqueued }
-            gauge 'jobs_dead', ->{ stats.dead_size }
-            gauge 'jobs_retry', ->{ stats.retry_size }
-
-            ::Sidekiq::Queue.all.each do |queue|
-              gauge 'queue_latency', { queue: queue.name }, ->{ (queue.latency * 1000).ceil }
-              gauge 'queue_depth', { queue: queue.name }, ->{ queue.size }
-            end
+            stats = collect_sidekiq_stats.call
 
-            Hash.new(0).tap do |busy_counts|
-              ::Sidekiq::Workers.new.each do |_pid, _tid, work|
-                payload = work.respond_to?(:payload) ? work.payload : work["payload"]
-                payload = JSON.parse(payload) if payload.is_a?(String)
-                busy_counts[payload["queue"]] += 1
-              end
-            end.each do |queue_name, busy_count|
-              gauge 'queue_busy', { queue: queue_name }, ->{ busy_count }
+            if Honeybadger.config.load_plugin_insights_events?(:sidekiq)
+              Honeybadger.event('stats.sidekiq', stats.except('stats').merge(stats['stats']))
             end
 
-            processes = ::Sidekiq::ProcessSet.new.to_enum(:each).to_a
-            gauge 'capacity', ->{ processes.map { |process| process["concurrency"] }.sum }
+            if Honeybadger.config.load_plugin_insights_metrics?(:sidekiq)
+              metric_source 'sidekiq'
 
-            process_utilizations = processes.map do |process|
-              next unless process["concurrency"].to_f > 0
-              process["busy"] / process["concurrency"].to_f
-            end.compact
+              stats['stats'].each do |name, value|
+                gauge name, value: value
+              end
+
+              stats[:queues].each do |queue_name, data|
+                data.each do |key, value|
+                  gauge "queue_#{key}", queue: queue_name, value: value
+                end
+              end
 
-            if process_utilizations.any?
-              utilization = process_utilizations.sum / process_utilizations.length.to_f
-              gauge 'utilization', ->{ utilization }
+              gauge 'capacity', value: stats[:capacity] if stats[:capacity]
+              gauge 'utilization', value: stats[:utilization] if stats[:utilization]
             end
           end
         end

data/lib/honeybadger/plugins/solid_queue.rb

@@ -4,20 +4,46 @@ module Honeybadger
       Plugin.register :solid_queue do
         requirement { config.load_plugin_insights?(:solid_queue) && defined?(::SolidQueue) }
 
+        collect_solid_queue_stats = -> do
+          data = {}
+          data[:stats] = {
+            jobs_in_progress: ::SolidQueue::ClaimedExecution.count,
+            jobs_blocked: ::SolidQueue::BlockedExecution.count,
+            jobs_failed: ::SolidQueue::FailedExecution.count,
+            jobs_scheduled: ::SolidQueue::ScheduledExecution.count,
+            jobs_processed: ::SolidQueue::Job.where.not(finished_at: nil).count,
+            active_workers: ::SolidQueue::Process.where(kind: "Worker").count,
+            active_dispatchers: ::SolidQueue::Process.where(kind: "Dispatcher").count
+          }
+
+          data[:queues] = {}
+
+          ::SolidQueue::Queue.all.each do |queue|
+            data[:queues][queue.name] = { depth: queue.size }
+          end
+
+          data
+        end
+
         collect do
+          stats = collect_solid_queue_stats.call
+
           if config.cluster_collection?(:solid_queue)
-            metric_source 'solid_queue'
-
-            gauge 'jobs_in_progress', ->{ ::SolidQueue::ClaimedExecution.count }
-            gauge 'jobs_blocked', ->{ ::SolidQueue::BlockedExecution.count }
-            gauge 'jobs_failed', ->{ ::SolidQueue::FailedExecution.count }
-            gauge 'jobs_scheduled', ->{ ::SolidQueue::ScheduledExecution.count }
-            gauge 'jobs_processed', ->{ ::SolidQueue::Job.where.not(finished_at: nil).count }
-            gauge 'active_workers', ->{ ::SolidQueue::Process.where(kind: "Worker").count }
-            gauge 'active_dispatchers', ->{ ::SolidQueue::Process.where(kind: "Dispatcher").count }
-
-            ::SolidQueue::Queue.all.each do |queue|
-              gauge 'queue_depth', { queue: queue.name }, ->{ queue.size }
+            if Honeybadger.config.load_plugin_insights_events?(:solid_queue)
+              Honeybadger.event('stats.solid_queue', stats.except(:stats).merge(stats[:stats]))
+            end
+
+            if Honeybadger.config.load_plugin_insights_metrics?(:solid_queue)
+              metric_source 'solid_queue'
+              stats[:stats].each do |stat_name, value|
+                gauge stat_name, value: value
+              end
+
+              stats[:queues].each do |queue_name, data|
+                data.each do |key, value|
+                  gauge "queue_#{key}", queue: queue_name, value: value
+                end
+              end
             end
           end
         end

data/lib/honeybadger/plugins/sucker_punch.rb

@@ -6,6 +6,7 @@ module Honeybadger
     requirement { defined?(::SuckerPunch) }
 
     execution do
+      return unless Honeybadger.config[:'exceptions.enabled']
       if SuckerPunch.respond_to?(:exception_handler=) # >= v2
         SuckerPunch.exception_handler = ->(ex, klass, args) { Honeybadger.notify(ex, { :component => klass, :parameters => args }) }
       else

data/lib/honeybadger/plugins/thor.rb

@@ -25,6 +25,7 @@ module Honeybadger
       requirement { defined?(::Thor.no_commands) }
 
       execution do
+        return unless Honeybadger.config[:'exceptions.enabled']
         ::Thor.send(:include, Thor)
       end
     end

data/lib/honeybadger/registry_execution.rb

@@ -19,6 +19,7 @@ module Honeybadger
 
     def call
       @registry.metrics.each do |metric|
+        next if metric.samples == 0
         metric.event_payloads.each do |payload|
           Honeybadger.event(payload.merge(interval: @interval))
         end

data/lib/honeybadger/version.rb

@@ -1,4 +1,4 @@
 module Honeybadger
   # The current String Honeybadger version.
-  VERSION = '5.16.0'.freeze
+  VERSION = '5.26.4'.freeze
 end

data/lib/puma/plugin/honeybadger.rb

@@ -12,7 +12,7 @@ module Honeybadger
         in_background do
           loop do
             puma_plugin.record
-            sleep 1
+            sleep [::Honeybadger.config.collection_interval(:puma).to_i, 1].max
           end
         end
       end
@@ -35,8 +35,14 @@ module Honeybadger
     end
 
     def record_puma_stats(stats, context={})
-      STATS_KEYS.each do |stat|
-        gauge stat, context, ->{ stats[stat] } if stats[stat]
+      if Honeybadger.config.load_plugin_insights_events?(:puma)
+        Honeybadger.event('stats.puma', context.merge(stats))
+      end
+
+      if Honeybadger.config.load_plugin_insights_metrics?(:puma)
+        STATS_KEYS.each do |stat|
+          gauge stat, context, ->{ stats[stat] } if stats[stat]
+        end
       end
     end
   end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: honeybadger
 version: !ruby/object:Gem::Version
-  version: 5.16.0
+  version: 5.26.4
 platform: ruby
 authors:
 - Honeybadger Industries LLC
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-09-19 00:00:00.000000000 Z
+date: 2025-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -24,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Make managing application errors a more pleasant experience.
 email:
 - support@honeybadger.io
@@ -81,6 +94,7 @@ files:
 - lib/honeybadger/init/sinatra.rb
 - lib/honeybadger/instrumentation.rb
 - lib/honeybadger/instrumentation_helper.rb
+- lib/honeybadger/karafka.rb
 - lib/honeybadger/logging.rb
 - lib/honeybadger/metric.rb
 - lib/honeybadger/metrics_worker.rb
@@ -175,7 +189,6 @@ metadata:
   documentation_uri: https://docs.honeybadger.io/lib/ruby/
   homepage_uri: https://www.honeybadger.io/for/ruby/
   source_code_uri: https://github.com/honeybadger-io/honeybadger-ruby
-post_install_message: 
 rdoc_options:
 - "--markup=tomdoc"
 - "--main=README.md"
@@ -193,8 +206,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
-signing_key: 
+rubygems_version: 3.7.0.dev
 specification_version: 4
 summary: Error reports you can be happy about.
 test_files: []