honeybadger 5.0.2 → 5.1.0

data/lib/honeybadger/plugins/delayed_job/plugin.rb

@@ -1,56 +1,56 @@
-require 'delayed_job'
-require 'honeybadger/ruby'
-
-module Honeybadger
-  module Plugins
-    module DelayedJob
-      class Plugin < ::Delayed::Plugin
-        callbacks do |lifecycle|
-          lifecycle.around(:invoke_job) do |job, &block|
-            begin
-
-              begin
-                if job.payload_object.class.name == 'ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper'
-                  #buildin support for Rails 4.2 ActiveJob
-                  component = job.payload_object.job_data['job_class']
-                  action = 'perform'
-                else
-                  #buildin support for Delayed::PerformableMethod
-                  component = job.payload_object.object.is_a?(Class) ? job.payload_object.object.name : job.payload_object.object.class.name
-                  action    = job.payload_object.method_name.to_s
-                end
-              rescue #fallback to support all other classes
-                component = job.payload_object.class.name
-                action    = 'perform'
-              end
-
-              ::Honeybadger.context(
-                :component     => component,
-                :action        => action,
-                :job_id        => job.id,
-                :handler       => job.handler,
-                :last_error    => job.last_error,
-                :attempts      => job.attempts,
-                :queue         => job.queue
-              )
-
-              block.call(job)
-            rescue Exception => error
-              ::Honeybadger.notify(
-                :component     => component,
-                :action        => action,
-                :error_class   => error.class.name,
-                :error_message => "#{ error.class.name }: #{ error.message }",
-                :backtrace     => error.backtrace,
-                :exception     => error
-              ) if job.attempts.to_i >= ::Honeybadger.config[:'delayed_job.attempt_threshold'].to_i
-              raise error
-            ensure
-              ::Honeybadger.clear!
-            end
-          end
-        end
-      end
-    end
-  end
-end
+require 'delayed_job'
+require 'honeybadger/ruby'
+
+module Honeybadger
+  module Plugins
+    module DelayedJob
+      class Plugin < ::Delayed::Plugin
+        callbacks do |lifecycle|
+          lifecycle.around(:invoke_job) do |job, &block|
+            begin
+
+              begin
+                if job.payload_object.class.name == 'ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper'
+                  #buildin support for Rails 4.2 ActiveJob
+                  component = job.payload_object.job_data['job_class']
+                  action = 'perform'
+                else
+                  #buildin support for Delayed::PerformableMethod
+                  component = job.payload_object.object.is_a?(Class) ? job.payload_object.object.name : job.payload_object.object.class.name
+                  action    = job.payload_object.method_name.to_s
+                end
+              rescue #fallback to support all other classes
+                component = job.payload_object.class.name
+                action    = 'perform'
+              end
+
+              ::Honeybadger.context(
+                :component     => component,
+                :action        => action,
+                :job_id        => job.id,
+                :handler       => job.handler,
+                :last_error    => job.last_error,
+                :attempts      => job.attempts,
+                :queue         => job.queue
+              )
+
+              block.call(job)
+            rescue Exception => error
+              ::Honeybadger.notify(
+                :component     => component,
+                :action        => action,
+                :error_class   => error.class.name,
+                :error_message => "#{ error.class.name }: #{ error.message }",
+                :backtrace     => error.backtrace,
+                :exception     => error
+              ) if job.attempts.to_i >= ::Honeybadger.config[:'delayed_job.attempt_threshold'].to_i
+              raise error
+            ensure
+              ::Honeybadger.clear!
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/delayed_job.rb

@@ -1,22 +1,22 @@
-require 'honeybadger/plugin'
-
-module Honeybadger
-  Plugin.register do
-    requirement { defined?(::Delayed::Plugin) }
-    requirement { defined?(::Delayed::Worker.plugins) }
-    requirement do
-      if delayed_job_honeybadger = defined?(::Delayed::Plugins::Honeybadger)
-        logger.warn("Support for Delayed Job has been moved " \
-                    "to the honeybadger gem. Please remove " \
-                    "delayed_job_honeybadger from your " \
-                    "Gemfile.")
-      end
-      !delayed_job_honeybadger
-    end
-
-    execution do
-      require 'honeybadger/plugins/delayed_job/plugin'
-      ::Delayed::Worker.plugins << Plugins::DelayedJob::Plugin
-    end
-  end
-end
+require 'honeybadger/plugin'
+
+module Honeybadger
+  Plugin.register do
+    requirement { defined?(::Delayed::Plugin) }
+    requirement { defined?(::Delayed::Worker.plugins) }
+    requirement do
+      if delayed_job_honeybadger = defined?(::Delayed::Plugins::Honeybadger)
+        logger.warn("Support for Delayed Job has been moved " \
+                    "to the honeybadger gem. Please remove " \
+                    "delayed_job_honeybadger from your " \
+                    "Gemfile.")
+      end
+      !delayed_job_honeybadger
+    end
+
+    execution do
+      require 'honeybadger/plugins/delayed_job/plugin'
+      ::Delayed::Worker.plugins << Plugins::DelayedJob::Plugin
+    end
+  end
+end

data/lib/honeybadger/plugins/faktory.rb

@@ -1,52 +1,52 @@
-require 'honeybadger/plugin'
-require 'honeybadger/ruby'
-
-module Honeybadger
-  module Plugins
-    module Faktory
-      class Middleware
-        def call(worker, job)
-          Honeybadger.clear!
-          yield
-        end
-      end
-
-      Plugin.register do
-        requirement { defined?(::Faktory) }
-
-        execution do
-          ::Faktory.configure_worker do |faktory|
-            faktory.worker_middleware do |chain|
-              chain.prepend Middleware
-            end
-          end
-
-          ::Faktory.configure_worker do |faktory|
-            faktory.error_handlers << lambda do |ex, params|
-              opts = {parameters: params}
-
-              if job = params[:job]
-                if (threshold = config[:'faktory.attempt_threshold'].to_i) > 0
-                  # If job.failure is nil, it is the first attempt. The first
-                  # retry has a job.failure.retry_count of 0, which would be
-                  # the second attempt in our case.
-                  retry_count = job.dig('failure', 'retry_count')
-                  attempt = retry_count ? retry_count + 1 : 0
-
-                  limit = [job['retry'].to_i, threshold].min
-
-                  return if attempt < limit
-                end
-
-                opts[:component] = job['jobtype']
-                opts[:action] = 'perform'
-              end
-
-              Honeybadger.notify(ex, opts)
-            end
-          end
-        end
-      end
-    end
-  end
-end
+require 'honeybadger/plugin'
+require 'honeybadger/ruby'
+
+module Honeybadger
+  module Plugins
+    module Faktory
+      class Middleware
+        def call(worker, job)
+          Honeybadger.clear!
+          yield
+        end
+      end
+
+      Plugin.register do
+        requirement { defined?(::Faktory) }
+
+        execution do
+          ::Faktory.configure_worker do |faktory|
+            faktory.worker_middleware do |chain|
+              chain.prepend Middleware
+            end
+          end
+
+          ::Faktory.configure_worker do |faktory|
+            faktory.error_handlers << lambda do |ex, params|
+              opts = {parameters: params}
+
+              if job = params[:job]
+                if (threshold = config[:'faktory.attempt_threshold'].to_i) > 0
+                  # If job.failure is nil, it is the first attempt. The first
+                  # retry has a job.failure.retry_count of 0, which would be
+                  # the second attempt in our case.
+                  retry_count = job.dig('failure', 'retry_count')
+                  attempt = retry_count ? retry_count + 1 : 0
+
+                  limit = [job['retry'].to_i, threshold].min
+
+                  return if attempt < limit
+                end
+
+                opts[:component] = job['jobtype']
+                opts[:action] = 'perform'
+              end
+
+              Honeybadger.notify(ex, opts)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/lambda.rb

@@ -1,71 +1,71 @@
-require 'honeybadger/plugin'
-require 'honeybadger/util/lambda'
-
-module Honeybadger
-  module Plugins
-    module LambdaExtension
-      # Wrap Lambda handlers so exceptions can be automatically captured
-      #
-      # Usage:
-      #
-      # # Automatically included in the top-level main object
-      # hb_wrap_handler :my_handler_1, :my_handler_2
-      #
-      # def my_handler_1(event:, context:)
-      # end
-      #
-      # class MyLambdaApp
-      #   extend ::Honeybadger::Plugins::LambdaExtension
-      #
-      #   hb_wrap_handler :my_handler_1, :my_handler_2
-      #
-      #   def self.my_handler_1(event:, context:)
-      #   end
-      # end
-      def hb_wrap_handler(*handler_names)
-        mod = Module.new do
-          handler_names.each do |handler|
-            define_method(handler) do |event:, context:|
-              begin
-                Honeybadger.context(aws_request_id: context.aws_request_id) if context.respond_to?(:aws_request_id)
-
-                super(event: event, context: context)
-              rescue => e
-                Honeybadger.notify(e)
-                raise
-              end
-            end
-          end
-        end
-
-        self.singleton_class.prepend(mod)
-        Kernel.singleton_class.prepend(mod) if self == TOPLEVEL_BINDING.eval("self")
-      end
-    end
-
-    # @api private
-    Plugin.register :lambda do
-      requirement { Util::Lambda.lambda_execution? }
-
-      execution do
-        config[:sync] = true
-        config[:'exceptions.notify_at_exit'] = false
-
-        main = TOPLEVEL_BINDING.eval("self")
-        main.extend(LambdaExtension)
-
-        (config[:before_notify] ||= []) << lambda do |notice|
-          data = Util::Lambda.normalized_data
-
-          notice.component = data["function"]
-          notice.action = data["handler"]
-          notice.details["Lambda Details"] = data
-
-          if (trace_id = Util::Lambda.trace_id)
-            notice.context[:lambda_trace_id] = trace_id
-          end
-        end
-      end
-    end
-  end
-end
+require 'honeybadger/plugin'
+require 'honeybadger/util/lambda'
+
+module Honeybadger
+  module Plugins
+    module LambdaExtension
+      # Wrap Lambda handlers so exceptions can be automatically captured
+      #
+      # Usage:
+      #
+      # # Automatically included in the top-level main object
+      # hb_wrap_handler :my_handler_1, :my_handler_2
+      #
+      # def my_handler_1(event:, context:)
+      # end
+      #
+      # class MyLambdaApp
+      #   extend ::Honeybadger::Plugins::LambdaExtension
+      #
+      #   hb_wrap_handler :my_handler_1, :my_handler_2
+      #
+      #   def self.my_handler_1(event:, context:)
+      #   end
+      # end
+      def hb_wrap_handler(*handler_names)
+        mod = Module.new do
+          handler_names.each do |handler|
+            define_method(handler) do |event:, context:|
+              begin
+                Honeybadger.context(aws_request_id: context.aws_request_id) if context.respond_to?(:aws_request_id)
+
+                super(event: event, context: context)
+              rescue => e
+                Honeybadger.notify(e)
+                raise
+              end
+            end
+          end
+        end
+
+        self.singleton_class.prepend(mod)
+        Kernel.singleton_class.prepend(mod) if self == TOPLEVEL_BINDING.eval("self")
+      end
+    end
+
+    # @api private
+    Plugin.register :lambda do
+      requirement { Util::Lambda.lambda_execution? }
+
+      execution do
+        config[:sync] = true
+        config[:'exceptions.notify_at_exit'] = false
+
+        main = TOPLEVEL_BINDING.eval("self")
+        main.extend(LambdaExtension)
+
+        (config[:before_notify] ||= []) << lambda do |notice|
+          data = Util::Lambda.normalized_data
+
+          notice.component = data["function"]
+          notice.action = data["handler"]
+          notice.details["Lambda Details"] = data
+
+          if (trace_id = Util::Lambda.trace_id)
+            notice.context[:lambda_trace_id] = trace_id
+          end
+        end
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/local_variables.rb

@@ -1,44 +1,44 @@
-require 'honeybadger/plugin'
-require 'honeybadger/backtrace'
-
-module Honeybadger
-  module Plugins
-    module LocalVariables
-      module ExceptionExtension
-        def self.included(base)
-          base.send(:alias_method, :set_backtrace_without_honeybadger, :set_backtrace)
-          base.send(:alias_method, :set_backtrace, :set_backtrace_with_honeybadger)
-        end
-
-        def set_backtrace_with_honeybadger(*args, &block)
-          if caller.none? { |loc| loc.match(::Honeybadger::Backtrace::Line::INPUT_FORMAT) && Regexp.last_match(1) == __FILE__ }
-            @__honeybadger_bindings_stack = binding.callers.drop(1)
-          end
-
-          set_backtrace_without_honeybadger(*args, &block)
-        end
-
-        def __honeybadger_bindings_stack
-          @__honeybadger_bindings_stack || []
-        end
-      end
-
-      Plugin.register do
-        requirement { config[:'exceptions.local_variables'] }
-        requirement { defined?(::BindingOfCaller) }
-        requirement do
-          if res = defined?(::BetterErrors)
-            logger.warn("The local variables feature is incompatible with the " \
-                        "better_errors gem; to remove this warning, set " \
-                        "exceptions.local_variables to false for environments " \
-                        "which load better_errors.")
-          end
-          !res
-        end
-        requirement { !::Exception.included_modules.include?(ExceptionExtension) }
-
-        execution { ::Exception.send(:include, ExceptionExtension) }
-      end
-    end
-  end
-end
+require 'honeybadger/plugin'
+require 'honeybadger/backtrace'
+
+module Honeybadger
+  module Plugins
+    module LocalVariables
+      module ExceptionExtension
+        def self.included(base)
+          base.send(:alias_method, :set_backtrace_without_honeybadger, :set_backtrace)
+          base.send(:alias_method, :set_backtrace, :set_backtrace_with_honeybadger)
+        end
+
+        def set_backtrace_with_honeybadger(*args, &block)
+          if caller.none? { |loc| loc.match(::Honeybadger::Backtrace::Line::INPUT_FORMAT) && Regexp.last_match(1) == __FILE__ }
+            @__honeybadger_bindings_stack = binding.callers.drop(1)
+          end
+
+          set_backtrace_without_honeybadger(*args, &block)
+        end
+
+        def __honeybadger_bindings_stack
+          @__honeybadger_bindings_stack || []
+        end
+      end
+
+      Plugin.register do
+        requirement { config[:'exceptions.local_variables'] }
+        requirement { defined?(::BindingOfCaller) }
+        requirement do
+          if res = defined?(::BetterErrors)
+            logger.warn("The local variables feature is incompatible with the " \
+                        "better_errors gem; to remove this warning, set " \
+                        "exceptions.local_variables to false for environments " \
+                        "which load better_errors.")
+          end
+          !res
+        end
+        requirement { !::Exception.included_modules.include?(ExceptionExtension) }
+
+        execution { ::Exception.send(:include, ExceptionExtension) }
+      end
+    end
+  end
+end

data/lib/honeybadger/plugins/passenger.rb

@@ -1,23 +1,23 @@
-require 'honeybadger/plugin'
-require 'honeybadger/agent'
-
-module Honeybadger
-  module Plugins
-    module Passenger
-      Plugin.register do
-        requirement { defined?(::PhusionPassenger.on_event) }
-
-        execution do
-          ::PhusionPassenger.on_event(:starting_worker_process) do |forked|
-            logger.debug('Starting passenger worker process')
-          end
-
-          ::PhusionPassenger.on_event(:stopping_worker_process) do
-            logger.debug('Stopping passenger worker process')
-            Honeybadger.stop
-          end
-        end
-      end
-    end
-  end
-end
+require 'honeybadger/plugin'
+require 'honeybadger/agent'
+
+module Honeybadger
+  module Plugins
+    module Passenger
+      Plugin.register do
+        requirement { defined?(::PhusionPassenger.on_event) }
+
+        execution do
+          ::PhusionPassenger.on_event(:starting_worker_process) do |forked|
+            logger.debug('Starting passenger worker process')
+          end
+
+          ::PhusionPassenger.on_event(:stopping_worker_process) do
+            logger.debug('Stopping passenger worker process')
+            Honeybadger.stop
+          end
+        end
+      end
+    end
+  end
+end