Revert commits

lib/honeybadger/agent.rb

@@ -125,11 +125,6 @@ def initialize(opts = {})
     # @return [String] UUID reference to the notice within Honeybadger.
     # @return [false] when ignored.
     def notify(exception_or_opts = nil, opts = {}, **kwargs)
-      if !config[:'notices.enabled']
-        debug { 'disabled feature=notices' }
-        return false
-      end
-
       opts = opts.dup
       opts.merge!(kwargs)
 

lib/honeybadger/init/hanami.rb

@@ -8,7 +8,7 @@
 
 Honeybadger.load_plugins!
 
-if Hanami::VERSION >= '2.0' && Honeybadger.config[:'exceptions.enabled']
+if Hanami::VERSION >= '2.0'
   Hanami.app.instance_eval do
     config.middleware.use Honeybadger::Rack::UserFeedback
     config.middleware.use Honeybadger::Rack::UserInformer

lib/honeybadger/init/rails.rb

@@ -14,11 +14,9 @@ class Railtie < ::Rails::Railtie
         initializer 'honeybadger.install_middleware' do |app|
           honeybadger_config = Honeybadger::Agent.instance.config
 
-          if honeybadger_config[:'exceptions.enabled']
-            app.config.middleware.insert(0, Honeybadger::Rack::ErrorNotifier)
-            app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserInformer) if honeybadger_config[:'user_informer.enabled']
-            app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserFeedback) if honeybadger_config[:'feedback.enabled']
-          end
+          app.config.middleware.insert(0, Honeybadger::Rack::ErrorNotifier)
+          app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserInformer) if honeybadger_config[:'user_informer.enabled']
+          app.config.middleware.insert_before(Honeybadger::Rack::ErrorNotifier, Honeybadger::Rack::UserFeedback) if honeybadger_config[:'feedback.enabled']
         end
 
         config.before_initialize do

lib/honeybadger/plugins/active_job.rb

@@ -51,7 +51,7 @@ def context(job) # rubocop:disable Metrics/MethodLength
         end
 
         execution do
-          ::ActiveJob::Base.set_callback(:perform, :around, &ActiveJob.method(:perform_around)) if Honeybadger.config[:'exceptions.enabled']
+          ::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)

lib/honeybadger/plugins/delayed_job.rb

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

lib/honeybadger/plugins/faktory.rb

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

lib/honeybadger/plugins/karafka.rb

@@ -8,11 +8,9 @@ module Plugins
       execution do
         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
+        errors_listener = ::Honeybadger::Karafka::ErrorsListener.new
+        ::Karafka.monitor.subscribe(errors_listener)
+        ::Karafka.producer.monitor.subscribe(errors_listener) if ::Karafka.respond_to?(:producer)
 
         if config.load_plugin_insights?(:karafka)
           ::Karafka.monitor.subscribe(::Honeybadger::Karafka::InsightsListener.new)

lib/honeybadger/plugins/resque.rb

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

lib/honeybadger/plugins/shoryuken.rb

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

lib/honeybadger/plugins/sidekiq.rb

@@ -73,62 +73,60 @@ def call(worker, msg, queue, _redis)
         requirement { defined?(::Sidekiq) }
 
         execution do
-          if Honeybadger.config[:'exceptions.enabled']
-            ::Sidekiq.configure_server do |sidekiq|
-              sidekiq.server_middleware do |chain|
-                chain.prepend Middleware
-              end
+          ::Sidekiq.configure_server do |sidekiq|
+            sidekiq.server_middleware do |chain|
+              chain.prepend Middleware
             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)
-                    end
+              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
 
-                  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)
-                }
-              end
+                Honeybadger.notify(ex, opts)
+              }
             end
           end
 

lib/honeybadger/plugins/sucker_punch.rb

@@ -6,7 +6,6 @@ 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

lib/honeybadger/plugins/thor.rb

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