honeybadger 5.0.2 → 5.1.0

data/lib/honeybadger/plugins/rails.rb

@@ -1,63 +1,72 @@
-require 'honeybadger/plugin'
-
-module Honeybadger
-  module Plugins
-    module Rails
-      module ExceptionsCatcher
-        # Adds additional Honeybadger info to Request env when an
-        # exception is rendered in Rails' middleware.
-        #
-        # @param [Hash, ActionDispatch::Request] arg The Rack env +Hash+ in
-        #   Rails 3.0-4.2. After Rails 5 +arg+ is an +ActionDispatch::Request+.
-        # @param [Exception] exception The error which was rescued.
-        #
-        # @return The super value of the middleware's +#render_exception()+
-        #   method.
-        def render_exception(arg, exception)
-          if arg.kind_of?(::ActionDispatch::Request)
-            request = arg
-            env = request.env
-          else
-            request = ::Rack::Request.new(arg)
-            env = arg
-          end
-
-          env['honeybadger.exception'] = exception
-          env['honeybadger.request.url'] = request.url rescue nil
-
-          super(arg, exception)
-        end
-      end
-
-      class ErrorSubscriber
-        def self.report(exception, handled:, severity:, context: {}, source: nil)
-          return if source && ::Honeybadger.config[:'rails.subscriber_ignore_sources'].any? { |regex| regex.match?(source) }
-
-          tags = ["severity:#{severity}", "handled:#{handled}"]
-          tags << "source:#{source}" if source
-          Honeybadger.notify(exception, context: context, tags: tags)
-        end
-      end
-
-      Plugin.register :rails_exceptions_catcher do
-        requirement { defined?(::Rails.application) && ::Rails.application }
-
-        execution do
-          require 'rack/request'
-          if defined?(::ActionDispatch::DebugExceptions)
-            # Rails 3.2.x+
-            ::ActionDispatch::DebugExceptions.prepend(ExceptionsCatcher)
-          elsif defined?(::ActionDispatch::ShowExceptions)
-            # Rails 3.0.x and 3.1.x
-            ::ActionDispatch::ShowExceptions.prepend(ExceptionsCatcher)
-          end
-
-          if defined?(::ActiveSupport::ErrorReporter)
-            # Rails 7
-            ::Rails.error.subscribe(ErrorSubscriber)
-          end
-        end
-      end
-    end
-  end
-end
+require 'honeybadger/plugin'
+
+module Honeybadger
+  module Plugins
+    module Rails
+      module ExceptionsCatcher
+        # Adds additional Honeybadger info to Request env when an
+        # exception is rendered in Rails' middleware.
+        #
+        # @param [Hash, ActionDispatch::Request] arg The Rack env +Hash+ in
+        #   Rails 3.0-4.2. After Rails 5 +arg+ is an +ActionDispatch::Request+.
+        # @param [Exception] exception The error which was rescued.
+        #
+        # @return The super value of the middleware's +#render_exception()+
+        #   method.
+        def render_exception(arg, exception, *args)
+          if arg.kind_of?(::ActionDispatch::Request)
+            request = arg
+            env = request.env
+          else
+            request = ::Rack::Request.new(arg)
+            env = arg
+          end
+
+          env['honeybadger.exception'] = exception
+          env['honeybadger.request.url'] = request.url rescue nil
+
+          super(arg, exception, *args)
+        end
+      end
+
+      class ErrorSubscriber
+        def self.report(exception, handled:, severity:, context: {}, source: nil)
+          # We only report unhandled errors (`Rails.error.handle`)
+          # Unhandled errors will be caught by our integrations (eg middleware), which have richer context
+          return unless handled
+
+          return if source_ignored?(source)
+
+          tags = ["severity:#{severity}", "handled:#{handled}"]
+          tags << "source:#{source}" if source
+          Honeybadger.notify(exception, context: context, tags: tags)
+        end
+
+        def self.source_ignored?(source)
+          source && ::Honeybadger.config[:'rails.subscriber_ignore_sources'].any? do |ignored_source|
+            ignored_source.is_a?(Regexp) ? ignored_source.match?(source) : (ignored_source == source)
+          end
+        end
+      end
+
+      Plugin.register :rails_exceptions_catcher do
+        requirement { defined?(::Rails.application) && ::Rails.application }
+
+        execution do
+          require 'rack/request'
+          if defined?(::ActionDispatch::DebugExceptions)
+            # Rails 3.2.x+
+            ::ActionDispatch::DebugExceptions.prepend(ExceptionsCatcher)
+          elsif defined?(::ActionDispatch::ShowExceptions)
+            # Rails 3.0.x and 3.1.x
+            ::ActionDispatch::ShowExceptions.prepend(ExceptionsCatcher)
+          end
+
+          if defined?(::ActiveSupport::ErrorReporter) # Rails 7
+            ::Rails.error.subscribe(ErrorSubscriber)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/resque.rb

@@ -1,72 +1,72 @@
-require 'honeybadger/plugin'
-require 'honeybadger/ruby'
-
-module Honeybadger
-  module Plugins
-    module Resque
-      module Extension
-        # Executed before +on_failure+ hook; the flush is necessary so that
-        # errors reported within jobs get sent before the worker dies.
-        def around_perform_with_honeybadger(*args)
-          Honeybadger.flush { yield }
-        end
-
-        def after_perform_with_honeybadger(*args)
-          Honeybadger.clear!
-        end
-
-        # Error notifications must be synchronous as the +on_failure+ hook is
-        # executed after +around_perform+.
-        def on_failure_with_honeybadger(e, *args)
-          Honeybadger.notify(e, parameters: { job_arguments: args }, sync: true) if send_exception_to_honeybadger?(e, args)
-        ensure
-          Honeybadger.clear!
-        end
-
-        def send_exception_to_honeybadger?(e, args)
-          return true unless respond_to?(:retry_criteria_valid?)
-          return true if ::Honeybadger.config[:'resque.resque_retry.send_exceptions_when_retrying']
-
-          !retry_criteria_valid?(e)
-        rescue => e
-          Honeybadger.notify(e, parameters: { job_arguments: args }, sync: true)
-        end
-      end
-
-      module Installer
-        def self.included(base)
-          base.send(:alias_method, :payload_class_without_honeybadger, :payload_class)
-          base.send(:alias_method, :payload_class, :payload_class_with_honeybadger)
-        end
-
-        def payload_class_with_honeybadger
-          payload_class_without_honeybadger.tap do |klass|
-            unless klass.respond_to?(:around_perform_with_honeybadger)
-              klass.instance_eval do
-                extend(::Honeybadger::Plugins::Resque::Extension)
-              end
-            end
-          end
-        end
-      end
-
-      Plugin.register do
-        requirement { defined?(::Resque::Job) }
-
-        requirement do
-          if resque_honeybadger = defined?(::Resque::Failure::Honeybadger)
-            logger.warn("Support for Resque has been moved " \
-                        "to the honeybadger gem. Please remove " \
-                        "resque-honeybadger from your " \
-                        "Gemfile.")
-          end
-          !resque_honeybadger
-        end
-
-        execution do
-          ::Resque::Job.send(:include, Installer)
-        end
-      end
-    end
-  end
-end
+require 'honeybadger/plugin'
+require 'honeybadger/ruby'
+
+module Honeybadger
+  module Plugins
+    module Resque
+      module Extension
+        # Executed before +on_failure+ hook; the flush is necessary so that
+        # errors reported within jobs get sent before the worker dies.
+        def around_perform_with_honeybadger(*args)
+          Honeybadger.flush { yield }
+        end
+
+        def after_perform_with_honeybadger(*args)
+          Honeybadger.clear!
+        end
+
+        # Error notifications must be synchronous as the +on_failure+ hook is
+        # executed after +around_perform+.
+        def on_failure_with_honeybadger(e, *args)
+          Honeybadger.notify(e, parameters: { job_arguments: args }, sync: true) if send_exception_to_honeybadger?(e, args)
+        ensure
+          Honeybadger.clear!
+        end
+
+        def send_exception_to_honeybadger?(e, args)
+          return true unless respond_to?(:retry_criteria_valid?)
+          return true if ::Honeybadger.config[:'resque.resque_retry.send_exceptions_when_retrying']
+
+          !retry_criteria_valid?(e)
+        rescue => e
+          Honeybadger.notify(e, parameters: { job_arguments: args }, sync: true)
+        end
+      end
+
+      module Installer
+        def self.included(base)
+          base.send(:alias_method, :payload_class_without_honeybadger, :payload_class)
+          base.send(:alias_method, :payload_class, :payload_class_with_honeybadger)
+        end
+
+        def payload_class_with_honeybadger
+          payload_class_without_honeybadger.tap do |klass|
+            unless klass.respond_to?(:around_perform_with_honeybadger)
+              klass.instance_eval do
+                extend(::Honeybadger::Plugins::Resque::Extension)
+              end
+            end
+          end
+        end
+      end
+
+      Plugin.register do
+        requirement { defined?(::Resque::Job) }
+
+        requirement do
+          if resque_honeybadger = defined?(::Resque::Failure::Honeybadger)
+            logger.warn("Support for Resque has been moved " \
+                        "to the honeybadger gem. Please remove " \
+                        "resque-honeybadger from your " \
+                        "Gemfile.")
+          end
+          !resque_honeybadger
+        end
+
+        execution do
+          ::Resque::Job.send(:include, Installer)
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/shoryuken.rb

@@ -1,52 +1,52 @@
-require 'honeybadger/plugin'
-require 'honeybadger/ruby'
-
-module Honeybadger
-  module Plugins
-    module Shoryuken
-      class Middleware
-        def call(_worker, _queue, sqs_msg, body)
-          begin
-            yield
-          rescue => e
-            if attempt_threshold <= receive_count(sqs_msg)
-              Honeybadger.notify(e, parameters: notification_params(body))
-            end
-
-            raise e
-          end
-        ensure
-          Honeybadger.clear!
-        end
-
-        private
-
-        def attempt_threshold
-          ::Honeybadger.config[:'shoryuken.attempt_threshold'].to_i
-        end
-
-        def receive_count(sqs_msg)
-          return 0 if sqs_msg.is_a?(Array)
-
-          sqs_msg.attributes['ApproximateReceiveCount'.freeze].to_i
-        end
-
-        def notification_params(body)
-          body.is_a?(Array) ? { batch: body } : { body: body }
-        end
-      end
-
-      Plugin.register do
-        requirement { defined?(::Shoryuken) }
-
-        execution do
-          ::Shoryuken.configure_server do |config|
-            config.server_middleware do |chain|
-              chain.add Middleware
-            end
-          end
-        end
-      end
-    end
-  end
-end
+require 'honeybadger/plugin'
+require 'honeybadger/ruby'
+
+module Honeybadger
+  module Plugins
+    module Shoryuken
+      class Middleware
+        def call(_worker, _queue, sqs_msg, body)
+          begin
+            yield
+          rescue => e
+            if attempt_threshold <= receive_count(sqs_msg)
+              Honeybadger.notify(e, parameters: notification_params(body))
+            end
+
+            raise e
+          end
+        ensure
+          Honeybadger.clear!
+        end
+
+        private
+
+        def attempt_threshold
+          ::Honeybadger.config[:'shoryuken.attempt_threshold'].to_i
+        end
+
+        def receive_count(sqs_msg)
+          return 0 if sqs_msg.is_a?(Array)
+
+          sqs_msg.attributes['ApproximateReceiveCount'.freeze].to_i
+        end
+
+        def notification_params(body)
+          body.is_a?(Array) ? { batch: body } : { body: body }
+        end
+      end
+
+      Plugin.register do
+        requirement { defined?(::Shoryuken) }
+
+        execution do
+          ::Shoryuken.configure_server do |config|
+            config.server_middleware do |chain|
+              chain.add Middleware
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/sidekiq.rb

@@ -1,62 +1,71 @@
-require 'honeybadger/plugin'
-require 'honeybadger/ruby'
-
-module Honeybadger
-  module Plugins
-    module Sidekiq
-      class Middleware
-        def call(_worker, _msg, _queue)
-          Honeybadger.clear!
-          yield
-        end
-      end
-
-      Plugin.register do
-        requirement { defined?(::Sidekiq) }
-
-        execution do
-          ::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|
-              sidekiq.error_handlers << lambda { |ex, params|
-                job = params[:job] || params
-                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
-
-                  # 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 ? (sidekiq.options[:max_retries] || default_max_retry_attempts) : job_retry.to_i
-
-                  limit = [retry_limit, threshold].min
-
-                  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
-
-                Honeybadger.notify(ex, opts)
-              }
-            end
-          end
-        end
-      end
-    end
-  end
-end
+require 'honeybadger/plugin'
+require 'honeybadger/ruby'
+
+module Honeybadger
+  module Plugins
+    module Sidekiq
+      class Middleware
+        def call(_worker, _msg, _queue)
+          Honeybadger.clear!
+          yield
+        end
+      end
+
+      Plugin.register do
+        requirement { defined?(::Sidekiq) }
+
+        execution do
+          ::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|
+
+              sidekiq.error_handlers << lambda { |ex, sidekiq_params|
+                params = sidekiq_params.dup
+                if defined?(::Sidekiq::Config) && params[:_config].is_a?(::Sidekiq::Config)
+                  params[:_config] = params[:_config].instance_variable_get(:@options)
+                end
+
+                job = params[:job] || params
+
+                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
+
+                  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
+
+                  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
+
+                Honeybadger.notify(ex, opts)
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/sucker_punch.rb

@@ -1,18 +1,18 @@
-require 'honeybadger/plugin'
-require 'honeybadger/ruby'
-
-module Honeybadger
-  Plugin.register do
-    requirement { defined?(::SuckerPunch) }
-
-    execution do
-      if SuckerPunch.respond_to?(:exception_handler=) # >= v2
-        SuckerPunch.exception_handler = ->(ex, klass, args) { Honeybadger.notify(ex, { :component => klass, :parameters => args }) }
-      else
-        SuckerPunch.exception_handler do |ex, klass, args|
-          Honeybadger.notify(ex, { :component => klass, :parameters => args })
-        end
-      end
-    end
-  end
-end
+require 'honeybadger/plugin'
+require 'honeybadger/ruby'
+
+module Honeybadger
+  Plugin.register do
+    requirement { defined?(::SuckerPunch) }
+
+    execution do
+      if SuckerPunch.respond_to?(:exception_handler=) # >= v2
+        SuckerPunch.exception_handler = ->(ex, klass, args) { Honeybadger.notify(ex, { :component => klass, :parameters => args }) }
+      else
+        SuckerPunch.exception_handler do |ex, klass, args|
+          Honeybadger.notify(ex, { :component => klass, :parameters => args })
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/thor.rb

@@ -1,32 +1,32 @@
-require 'honeybadger/plugin'
-require 'honeybadger/ruby'
-
-module Honeybadger
-  module Plugins
-    module Thor
-      def self.included(base)
-        base.class_eval do
-          no_commands do
-            alias_method :invoke_command_without_honeybadger, :invoke_command
-            alias_method :invoke_command, :invoke_command_with_honeybadger
-          end
-        end
-      end
-
-      def invoke_command_with_honeybadger(*args)
-        invoke_command_without_honeybadger(*args)
-      rescue Exception => e
-        Honeybadger.notify(e)
-        raise
-      end
-    end
-
-    Plugin.register do
-      requirement { defined?(::Thor.no_commands) }
-
-      execution do
-        ::Thor.send(:include, Thor)
-      end
-    end
-  end
-end
+require 'honeybadger/plugin'
+require 'honeybadger/ruby'
+
+module Honeybadger
+  module Plugins
+    module Thor
+      def self.included(base)
+        base.class_eval do
+          no_commands do
+            alias_method :invoke_command_without_honeybadger, :invoke_command
+            alias_method :invoke_command, :invoke_command_with_honeybadger
+          end
+        end
+      end
+
+      def invoke_command_with_honeybadger(*args)
+        invoke_command_without_honeybadger(*args)
+      rescue Exception => e
+        Honeybadger.notify(e)
+        raise
+      end
+    end
+
+    Plugin.register do
+      requirement { defined?(::Thor.no_commands) }
+
+      execution do
+        ::Thor.send(:include, Thor)
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/warden.rb

@@ -1,19 +1,19 @@
-require 'honeybadger/plugin'
-require 'honeybadger/ruby'
-
-module Honeybadger
-  Plugin.register do
-    requirement { defined?(::Warden::Manager.after_set_user) }
-
-    execution do
-      ::Warden::Manager.after_set_user do |user, auth, opts|
-        if user.respond_to?(:id)
-          ::Honeybadger.context({
-            :user_scope => opts[:scope].to_s,
-            :user_id => user.id.to_s
-          })
-        end
-      end
-    end
-  end
-end
+require 'honeybadger/plugin'
+require 'honeybadger/ruby'
+
+module Honeybadger
+  Plugin.register do
+    requirement { defined?(::Warden::Manager.after_set_user) }
+
+    execution do
+      ::Warden::Manager.after_set_user do |user, auth, opts|
+        if user.respond_to?(:id)
+          ::Honeybadger.context({
+            :user_scope => opts[:scope].to_s,
+            :user_id => user.id.to_s
+          })
+        end
+      end
+    end
+  end
+end