honeybadger 5.16.0 → 5.26.4

data/lib/honeybadger/instrumentation_helper.rb

@@ -56,7 +56,7 @@ module Honeybadger
         metric_instrumentation.time(name, attributes, ->{ callable.call })
       elsif block_given?
         metric_instrumentation.time(name, attributes, ->{ yield })
-      elsif attributes.keys.include?(:duration)
+      else
         metric_instrumentation.time(name, attributes)
       end
     end
@@ -68,38 +68,44 @@ module Honeybadger
         metric_instrumentation.histogram(name, attributes, ->{ callable.call })
       elsif block_given?
         metric_instrumentation.histogram(name, attributes, ->{ yield })
-      elsif attributes.keys.include?(:duration)
+      else
         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?
+      callable = extract_callable(args)
+      if callable
+        metric_instrumentation.increment_counter(name, attributes, ->{ callable.call })
+      elsif block_given?
         metric_instrumentation.increment_counter(name, attributes, ->{ yield })
       else
-        metric_instrumentation.increment_counter(name, attributes.merge(by: by))
+        metric_instrumentation.increment_counter(name, attributes)
       end
     end
 
     def decrement_counter(name, *args)
       attributes = extract_attributes(args)
-      by = extract_callable(args)&.call || attributes.delete(:by) || 1
-      if block_given?
+      callable = extract_callable(args)
+      if callable
+        metric_instrumentation.decrement_counter(name, attributes, ->{ callable.call })
+      elsif block_given?
         metric_instrumentation.decrement_counter(name, attributes, ->{ yield })
       else
-        metric_instrumentation.decrement_counter(name, attributes.merge(by: by))
+        metric_instrumentation.decrement_counter(name, attributes)
       end
     end
 
     def gauge(name, *args)
       attributes = extract_attributes(args)
-      value = extract_callable(args)&.call || attributes.delete(:value)
-      if block_given?
+      callable = extract_callable(args)
+      if callable
+        metric_instrumentation.gauge(name, attributes, ->{ callable.call })
+      elsif block_given?
         metric_instrumentation.gauge(name, attributes, ->{ yield })
       else
-        metric_instrumentation.gauge(name, attributes.merge(value: value))
+        metric_instrumentation.gauge(name, attributes)
       end
     end
 

data/lib/honeybadger/karafka.rb

@@ -0,0 +1,301 @@
+require 'honeybadger/instrumentation_helper'
+
+module Honeybadger
+  module Karafka
+    class ErrorsListener
+      # Sends error details to Honeybadger
+      #
+      # @param event [Karafka::Core::Monitoring::Event]
+      def on_error_occurred(event)
+        context = {
+          type: event[:type]
+        }
+        tags = ["type:#{event[:type]}"]
+
+        if (consumer = event.payload[:caller]).respond_to?(:messages)
+          messages = consumer.messages
+          metadata = messages.metadata
+          consumer_group_id = consumer.topic.consumer_group.id
+
+          context[:topic] = metadata.topic
+          context[:partition] = metadata.partition
+          context[:consumer_group] = consumer_group_id
+        end
+
+        Honeybadger.notify(event[:error], context: context)
+      end
+    end
+
+    class InsightsListener
+      include ::Honeybadger::InstrumentationHelper
+
+      # Value object for storing a single rdkafka metric publishing details
+      RdKafkaMetric = Struct.new(:type, :scope, :name, :key_location)
+
+      # All the rdkafka metrics we want to publish
+      #
+      # By default we publish quite a lot so this can be tuned
+      # Note, that the once with `_d` come from Karafka, not rdkafka or Kafka
+      RD_KAFKA_METRICS = [
+        # Client metrics
+        RdKafkaMetric.new(:increment_counter, :root, 'messages_consumed', 'rxmsgs_d'),
+        RdKafkaMetric.new(:increment_counter, :root, 'messages_consumed_bytes', 'rxmsg_bytes'),
+
+        # Broker metrics
+        RdKafkaMetric.new(:increment_counter, :brokers, 'consume_attempts', 'txretries_d'),
+        RdKafkaMetric.new(:increment_counter, :brokers, 'consume_errors', 'txerrs_d'),
+        RdKafkaMetric.new(:increment_counter, :brokers, 'receive_errors', 'rxerrs_d'),
+        RdKafkaMetric.new(:increment_counter, :brokers, 'connection_connects', 'connects_d'),
+        RdKafkaMetric.new(:increment_counter, :brokers, 'connection_disconnects', 'disconnects_d'),
+        RdKafkaMetric.new(:gauge, :brokers, 'network_latency_avg', %w[rtt avg]),
+        RdKafkaMetric.new(:gauge, :brokers, 'network_latency_p95', %w[rtt p95]),
+        RdKafkaMetric.new(:gauge, :brokers, 'network_latency_p99', %w[rtt p99]),
+
+        # Topics metrics
+        RdKafkaMetric.new(:gauge, :topics, 'consumer_lags', 'consumer_lag_stored'),
+        RdKafkaMetric.new(:gauge, :topics, 'consumer_lags_delta', 'consumer_lag_stored_d')
+      ].freeze
+
+      # Metrics that sum values on topics levels and not on partition levels
+      AGGREGATED_RD_KAFKA_METRICS = [
+        # Topic aggregated metrics
+        RdKafkaMetric.new(:gauge, :topics, 'consumer_aggregated_lag', 'consumer_lag_stored')
+      ].freeze
+
+      def initialize
+        metric_source("karafka")
+      end
+
+      # Hooks up to Karafka instrumentation for emitted statistics
+      #
+      # @param event [Karafka::Core::Monitoring::Event]
+      def on_statistics_emitted(event)
+        if Honeybadger.config.load_plugin_insights_events?(:karafka)
+          Honeybadger.event("statistics_emitted.karafka", event.payload)
+        end
+
+        return unless Honeybadger.config.load_plugin_insights_metrics?(:karafka)
+
+        statistics = event[:statistics]
+        consumer_group_id = event[:consumer_group_id]
+
+        base_tags = { consumer_group: consumer_group_id }
+
+        RD_KAFKA_METRICS.each do |metric|
+          report_metric(metric, statistics, base_tags)
+        end
+
+        report_aggregated_topics_metrics(statistics, consumer_group_id)
+      end
+
+      # Publishes aggregated topic-level metrics that are sum of per partition metrics
+      #
+      # @param statistics [Hash] hash with all the statistics emitted
+      # @param consumer_group_id [String] cg in context which we operate
+      def report_aggregated_topics_metrics(statistics, consumer_group_id)
+        AGGREGATED_RD_KAFKA_METRICS.each do |metric|
+          statistics.fetch('topics').each do |topic_name, topic_values|
+            sum = 0
+
+            topic_values['partitions'].each do |partition_name, partition_statistics|
+              next if partition_name == '-1'
+              # Skip until lag info is available
+              next if partition_statistics['consumer_lag'] == -1
+              next if partition_statistics['consumer_lag_stored'] == -1
+
+              sum += partition_statistics.dig(*metric.key_location)
+            end
+
+            public_send(
+              metric.type,
+              metric.name,
+              value: sum,
+              consumer_group: consumer_group_id,
+              topic: topic_name
+            )
+          end
+        end
+      end
+
+      # Increases the errors count by 1
+      #
+      # @param event [Karafka::Core::Monitoring::Event]
+      def on_error_occurred(event)
+        extra_tags = { type: event[:type] }
+
+        if event.payload[:caller].respond_to?(:messages)
+          extra_tags.merge!(consumer_tags(event.payload[:caller]))
+        end
+
+        if Honeybadger.config.load_plugin_insights_events?(:karafka)
+          Honeybadger.event("error.occurred.karafka", error: event[:error], **extra_tags)
+        end
+
+        if Honeybadger.config.load_plugin_insights_metrics?(:karafka)
+          increment_counter('error_occurred', value: 1, **extra_tags)
+        end
+      end
+
+      # Reports how many messages we've polled and how much time did we spend on it
+      #
+      # @param event [Karafka::Core::Monitoring::Event]
+      def on_connection_listener_fetch_loop_received(event)
+        time_taken = event[:time]
+        messages_count = event[:messages_buffer].size
+        consumer_group_id = event[:subscription_group].consumer_group.id
+        extra_tags = { consumer_group: consumer_group_id }
+
+        if Honeybadger.config.load_plugin_insights_metrics?(:karafka)
+          histogram('listener_polling_time_taken', value: time_taken, **extra_tags)
+          histogram('listener_polling_messages', value: messages_count, **extra_tags)
+        end
+      end
+
+      # Here we report majority of things related to processing as we have access to the
+      # consumer
+      # @param event [Karafka::Core::Monitoring::Event]
+      def on_consumer_consumed(event)
+        consumer = event.payload[:caller]
+        messages = consumer.messages
+        metadata = messages.metadata
+
+        tags = consumer_tags(consumer)
+
+        if Honeybadger.config.load_plugin_insights_events?(:karafka)
+          event_context = tags.merge({
+            consumer: consumer.class.name,
+            duration: event[:time],
+            processing_lag: metadata.processing_lag,
+            consumption_lag: metadata.consumption_lag,
+            processed: messages.count
+          })
+          Honeybadger.event("consumer.consumed.karafka", event_context)
+        end
+
+        if Honeybadger.config.load_plugin_insights_metrics?(:karafka)
+          increment_counter('consumer_messages', value: messages.count, **tags)
+          increment_counter('consumer_batches', value: 1, **tags)
+          gauge('consumer_offset', value: metadata.last_offset, **tags)
+          histogram('consumer_consumed_time_taken', value: event[:time], **tags)
+          histogram('consumer_batch_size', value: messages.count, **tags)
+          histogram('consumer_processing_lag', value: metadata.processing_lag, **tags)
+          histogram('consumer_consumption_lag', value: metadata.consumption_lag, **tags)
+        end
+      end
+
+      {
+        revoked: :revoked,
+        shutdown: :shutdown,
+        ticked: :tick
+      }.each do |after, name|
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              # Keeps track of user code execution
+              #
+              # @param event [Karafka::Core::Monitoring::Event]
+              def on_consumer_#{after}(event)
+                if Honeybadger.config.load_plugin_insights_metrics?(:karafka)
+                  tags = consumer_tags(event.payload[:caller])
+                  increment_counter('consumer_#{name}', value: 1, **tags)
+                end
+              end
+        RUBY
+      end
+
+      # Worker related metrics
+      # @param event [Karafka::Core::Monitoring::Event]
+      def on_worker_process(event)
+        jq_stats = event[:jobs_queue].statistics
+
+        if Honeybadger.config.load_plugin_insights_metrics?(:karafka)
+          gauge('worker_total_threads', value: ::Karafka::App.config.concurrency)
+          histogram('worker_processing', value: jq_stats[:busy])
+          histogram('worker_enqueued_jobs', value: jq_stats[:enqueued])
+        end
+      end
+
+      # We report this metric before and after processing for higher accuracy
+      # Without this, the utilization would not be fully reflected
+      # @param event [Karafka::Core::Monitoring::Event]
+      def on_worker_processed(event)
+        jq_stats = event[:jobs_queue].statistics
+
+        if Honeybadger.config.load_plugin_insights_metrics?(:karafka)
+          histogram('worker_processing', value: jq_stats[:busy])
+        end
+      end
+
+      private
+
+      # Reports a given metric statistics to Honeybadger
+      # @param metric [RdKafkaMetric] metric value object
+      # @param statistics [Hash] hash with all the statistics emitted
+      # @param base_tags [Array<String>] base tags we want to start with
+      def report_metric(metric, statistics, base_tags)
+        case metric.scope
+        when :root
+          public_send(
+            metric.type,
+            metric.name,
+            value: statistics.fetch(*metric.key_location),
+            **base_tags
+          )
+        when :brokers
+          statistics.fetch('brokers').each_value do |broker_statistics|
+            # Skip bootstrap nodes
+            # Bootstrap nodes have nodeid -1, other nodes have positive
+            # node ids
+            next if broker_statistics['nodeid'] == -1
+
+            public_send(
+              metric.type,
+              metric.name,
+              value: broker_statistics.dig(*metric.key_location),
+              **base_tags.merge(broker: broker_statistics['nodename'])
+            )
+          end
+        when :topics
+          statistics.fetch('topics').each do |topic_name, topic_values|
+            topic_values['partitions'].each do |partition_name, partition_statistics|
+              next if partition_name == '-1'
+              # Skip until lag info is available
+              next if partition_statistics['consumer_lag'] == -1
+              next if partition_statistics['consumer_lag_stored'] == -1
+
+              # Skip if we do not own the fetch assignment
+              next if partition_statistics['fetch_state'] == 'stopped'
+              next if partition_statistics['fetch_state'] == 'none'
+
+              public_send(
+                metric.type,
+                metric.name,
+                value: partition_statistics.dig(*metric.key_location),
+                **base_tags.merge({
+                  topic: topic_name,
+                  partition: partition_name
+                })
+              )
+            end
+          end
+        else
+          raise ArgumentError, metric.scope
+        end
+      end
+
+      # Builds basic per consumer tags for publication
+      #
+      # @param consumer [Karafka::BaseConsumer]
+      # @return [Array<String>]
+      def consumer_tags(consumer)
+        messages = consumer.messages
+        metadata = messages.metadata
+        consumer_group_id = consumer.topic.consumer_group.id
+
+        {
+          topic: metadata.topic,
+          partition: metadata.partition,
+          consumer_group: consumer_group_id
+        }
+      end
+    end
+  end
+end

data/lib/honeybadger/notice.rb

@@ -144,6 +144,9 @@ module Honeybadger
     # Custom details data
     attr_accessor :details
 
+    # The ID of the request which caused this notice.
+    attr_accessor :request_id
+
     # The parsed exception backtrace. Lines in this backtrace that are from installed gems
     # have the base path for gem installs replaced by "[GEM_ROOT]", while those in the project
     # have "[PROJECT_ROOT]".
@@ -213,13 +216,14 @@ module Honeybadger
       self.api_key = opts[:api_key] || config[:api_key]
       self.tags = construct_tags(opts[:tags]) | construct_tags(context[:tags])
 
-      self.url       = opts[:url]        || request_hash[:url]      || nil
-      self.action    = opts[:action]     || request_hash[:action]   || nil
-      self.component = opts[:controller] || opts[:component]        || request_hash[:component] || nil
-      self.params    = opts[:parameters] || opts[:params]           || request_hash[:params] || {}
-      self.session   = opts[:session]    || request_hash[:session]  || {}
-      self.cgi_data  = opts[:cgi_data]   || request_hash[:cgi_data] || {}
-      self.details   = opts[:details]    || {}
+      self.url        = opts[:url]        || request_hash[:url]      || nil
+      self.action     = opts[:action]     || request_hash[:action]   || nil
+      self.component  = opts[:controller] || opts[:component]        || request_hash[:component] || nil
+      self.params     = opts[:parameters] || opts[:params]           || request_hash[:params] || {}
+      self.session    = opts[:session]    || request_hash[:session]  || {}
+      self.cgi_data   = opts[:cgi_data]   || request_hash[:cgi_data] || {}
+      self.details    = opts[:details]    || {}
+      self.request_id = opts[:request_id] || nil
 
       self.session = opts[:session][:data] if opts[:session] && opts[:session][:data]
 
@@ -261,6 +265,9 @@ module Honeybadger
           stats: stats,
           time: now,
           pid: pid
+        },
+        correlation_context: {
+          request_id: s(request_id)
         }
       }
     end

data/lib/honeybadger/notification_subscriber.rb

@@ -3,25 +3,48 @@ require 'honeybadger/util/sql'
 
 module Honeybadger
   class NotificationSubscriber
+    include Honeybadger::InstrumentationHelper
+
     def start(name, id, payload)
-      @start_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      payload[:_start_time] = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
     end
 
     def finish(name, id, payload)
-      @finish_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-
+      finish_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
       return unless process?(name, payload)
 
       payload = {
         instrumenter_id: id,
-        duration: ((@finish_time - @start_time) * 1000).round(2)
+        duration: ((finish_time - payload.delete(:_start_time)) * 1000).round(2)
       }.merge(format_payload(payload).compact)
 
       record(name, payload)
     end
 
     def record(name, payload)
-      Honeybadger.event(name, payload)
+      if Honeybadger.config.load_plugin_insights_events?(:rails)
+        Honeybadger.event(name, payload)
+      end
+
+      if Honeybadger.config.load_plugin_insights_metrics?(:rails)
+        metric_source 'rails'
+        record_metrics(name, payload)
+      end
+    end
+
+    def record_metrics(name, payload)
+      case name
+      when 'sql.active_record'
+        gauge('duration.sql.active_record', value: payload[:duration], **payload.slice(:query))
+      when 'process_action.action_controller'
+        gauge('duration.process_action.action_controller', value: payload[:duration], **payload.slice(:method, :controller, :action, :format, :status))
+        gauge('db_runtime.process_action.action_controller', value: payload[:db_runtime], **payload.slice(:method, :controller, :action, :format, :status))
+        gauge('view_runtime.process_action.action_controller', value: payload[:view_runtime], **payload.slice(:method, :controller, :action, :format, :status))
+      when 'perform.active_job'
+        gauge('duration.perform.active_job', value: payload[:duration], **payload.slice(:job_class, :queue_name))
+      when /^cache_.*.active_support$/
+        gauge("duration.#{name}", value: payload[:duration], **payload.slice(:store, :key))
+      end
     end
 
     def process?(event, payload)
@@ -109,25 +132,22 @@ module Honeybadger
     end
   end
 
-  class ActiveJobMetricsSubscriber < NotificationSubscriber
-    include Honeybadger::InstrumentationHelper
-
+  class ActionMailerSubscriber < NotificationSubscriber
     def format_payload(payload)
-      {
-        job_class: payload[:job].class.to_s,
-        queue_name: payload[:job].queue_name
-      }
-    end
+      # Don't include the mail object in the payload...
+      mail = payload.delete(:mail)
+
+      # ... but do include any attachment filenames
+      attachment_info = if mail&.attachments&.any?
+        { attachments: mail.attachments.map { |a| { filename: a.filename } } }
+      else
+        {}
+      end
 
-    def record(name, payload)
-      metric_source 'active_job'
-      histogram name, { bins: [30, 60, 120, 300, 1800, 3600, 21_600] }.merge(payload)
+      payload.merge(attachment_info)
     end
   end
 
-  class ActionMailerSubscriber < NotificationSubscriber
-  end
-
   class ActiveStorageSubscriber < NotificationSubscriber
   end
 end

data/lib/honeybadger/plugins/active_job.rb

@@ -51,11 +51,10 @@ module Honeybadger
         end
 
         execution do
-          ::ActiveJob::Base.set_callback(:perform, :around, &ActiveJob.method(:perform_around))
+          ::ActiveJob::Base.set_callback(:perform, :around, &ActiveJob.method(:perform_around)) if Honeybadger.config[:'exceptions.enabled']
 
           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

data/lib/honeybadger/plugins/autotuner.rb

@@ -10,17 +10,20 @@ module Honeybadger
         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 }
+            if config.load_plugin_insights_events?(:autotuner)
+              Honeybadger.event('stats.autotuner', metrics)
+            end
+
+            if config.load_plugin_insights_metrics?(:autotuner)
+              metric_source 'autotuner'
+              metrics.each do |key, val|
+                gauge key, ->{ val }
+              end
             end
           end
         end

data/lib/honeybadger/plugins/delayed_job.rb

@@ -15,6 +15,7 @@ module Honeybadger
     end
 
     execution do
+      return unless Honeybadger.config[:'exceptions.enabled']
       require 'honeybadger/plugins/delayed_job/plugin'
       ::Delayed::Worker.plugins << Plugins::DelayedJob::Plugin
     end

data/lib/honeybadger/plugins/faktory.rb

@@ -15,6 +15,7 @@ module Honeybadger
         requirement { defined?(::Faktory) }
 
         execution do
+          return unless Honeybadger.config[:'exceptions.enabled']
           ::Faktory.configure_worker do |faktory|
             faktory.worker_middleware do |chain|
               chain.prepend Middleware

data/lib/honeybadger/plugins/karafka.rb

@@ -6,25 +6,16 @@ module Honeybadger
       requirement { defined?(::Karafka) && ::Karafka.respond_to?(:monitor) }
 
       execution do
-        ::Karafka.monitor.subscribe("error.occurred") do |event|
-          Honeybadger.notify(event[:error])
-          Honeybadger.event("error.occurred.karafka", error: event[:error]) if config.load_plugin_insights?(:karafka)
+        require 'honeybadger/karafka'
+
+        if Honeybadger.config[:'exceptions.enabled']
+          errors_listener = ::Honeybadger::Karafka::ErrorsListener.new
+          ::Karafka.monitor.subscribe(errors_listener)
+          ::Karafka.producer.monitor.subscribe(errors_listener) if ::Karafka.respond_to?(:producer)
         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,
-              processing_lag: event.payload[:caller].messages.metadata.processing_lag,
-              partition: event.payload[:caller].messages.metadata.partition
-            }
-
-            Honeybadger.event("consumer.consumed.karafka", context)
-          end
+          ::Karafka.monitor.subscribe(::Honeybadger::Karafka::InsightsListener.new)
         end
       end
     end

data/lib/honeybadger/plugins/net_http.rb

@@ -7,6 +7,12 @@ module Honeybadger
   module Plugins
     module Net
       module HTTP
+        @@hb_config = ::Honeybadger.config
+
+        def self.set_hb_config(config)
+          @@hb_config = config
+        end
+
         def request(request_data, body = nil, &block)
           return super unless started?
           return super if hb?
@@ -18,19 +24,26 @@ module Honeybadger
               status: response_data.code.to_i
             }.merge(parsed_uri_data(request_data))
 
-            Honeybadger.event('request.net_http', context)
+            if @@hb_config.load_plugin_insights_events?(:net_http)
+              Honeybadger.event('request.net_http', context)
+            end
+
+            if @@hb_config.load_plugin_insights_metrics?(:net_http)
+              context.delete(:url)
+              Honeybadger.gauge('duration.request', context.merge(metric_source: 'net_http'))
+            end
           end[1] # return the response data only
         end
 
         def hb?
-          address.to_s[/#{Honeybadger.config[:'connection.host'].to_s}/]
+          address.to_s[/#{@@hb_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']
+            uri_data[:url] = uri.to_s if @@hb_config[:'net_http.insights.full_url']
           end
         end
 
@@ -43,6 +56,7 @@ module Honeybadger
           requirement { config.load_plugin_insights?(:net_http) }
 
           execution do
+            Honeybadger::Plugins::Net::HTTP.set_hb_config(config)
             ::Net::HTTP.send(:prepend, Honeybadger::Plugins::Net::HTTP)
           end
         end

data/lib/honeybadger/plugins/rails.rb

@@ -64,7 +64,13 @@ module Honeybadger
             ::ActionDispatch::ShowExceptions.prepend(ExceptionsCatcher)
           end
 
-          if defined?(::ActiveSupport::ErrorReporter) # Rails 7
+          if Honeybadger.config[:'exceptions.enabled'] && defined?(::ActiveSupport::ErrorReporter) # Rails 7
+            if defined?(::ActiveSupport::ExecutionContext)
+              ::ActiveSupport::ExecutionContext.after_change do
+                Honeybadger.context(::ActiveSupport::ExecutionContext.to_h)
+              end
+            end
+
             ::Rails.error.subscribe(ErrorSubscriber)
           end
         end

data/lib/honeybadger/plugins/resque.rb

@@ -64,6 +64,7 @@ module Honeybadger
         end
 
         execution do
+          return unless Honeybadger.config[:'exceptions.enabled']
           ::Resque::Job.send(:include, Installer)
         end
       end

data/lib/honeybadger/plugins/shoryuken.rb

@@ -40,6 +40,7 @@ module Honeybadger
         requirement { defined?(::Shoryuken) }
 
         execution do
+          return unless Honeybadger.config[:'exceptions.enabled']
           ::Shoryuken.configure_server do |config|
             config.server_middleware do |chain|
               chain.add Middleware