honeybadger 5.29.1 → 6.0.0

data/lib/honeybadger/plugins/faktory.rb

@@ -1,5 +1,5 @@
-require 'honeybadger/plugin'
-require 'honeybadger/ruby'
+require "honeybadger/plugin"
+require "honeybadger/ruby"
 
 module Honeybadger
   module Plugins
@@ -15,7 +15,7 @@ module Honeybadger
         requirement { defined?(::Faktory) }
 
         execution do
-          return unless Honeybadger.config[:'exceptions.enabled']
+          return unless Honeybadger.config[:"exceptions.enabled"]
           ::Faktory.configure_worker do |faktory|
             faktory.worker_middleware do |chain|
               chain.prepend Middleware
@@ -26,21 +26,21 @@ module Honeybadger
             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 = 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')
+                  retry_count = job.dig("failure", "retry_count")
                   attempt = retry_count ? retry_count + 1 : 0
 
-                  limit = [job['retry'].to_i, threshold].min
+                  limit = [job["retry"].to_i, threshold].min
 
                   return if attempt < limit
                 end
 
-                opts[:component] = job['jobtype']
-                opts[:action] = 'perform'
+                opts[:component] = job["jobtype"]
+                opts[:action] = "perform"
               end
 
               Honeybadger.notify(ex, opts)

data/lib/honeybadger/plugins/karafka.rb

@@ -1,4 +1,4 @@
-require 'honeybadger/plugin'
+require "honeybadger/plugin"
 
 module Honeybadger
   module Plugins
@@ -6,9 +6,9 @@ module Honeybadger
       requirement { defined?(::Karafka) && ::Karafka.respond_to?(:monitor) }
 
       execution do
-        require 'honeybadger/karafka'
+        require "honeybadger/karafka"
 
-        if Honeybadger.config[:'exceptions.enabled']
+        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)

data/lib/honeybadger/plugins/lambda.rb

@@ -1,5 +1,5 @@
-require 'honeybadger/plugin'
-require 'honeybadger/util/lambda'
+require "honeybadger/plugin"
+require "honeybadger/util/lambda"
 
 module Honeybadger
   module Plugins
@@ -26,19 +26,17 @@ module Honeybadger
         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)
+              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
+              super(event: event, context: context)
+            rescue => e
+              Honeybadger.notify(e)
+              raise
             end
           end
         end
 
-        self.singleton_class.prepend(mod)
+        singleton_class.prepend(mod)
         Kernel.singleton_class.prepend(mod) if self == TOPLEVEL_BINDING.eval("self")
       end
     end
@@ -49,7 +47,7 @@ module Honeybadger
 
       execution do
         config[:sync] = true
-        config[:'exceptions.notify_at_exit'] = false
+        config[:"exceptions.notify_at_exit"] = false
 
         main = TOPLEVEL_BINDING.eval("self")
         main.extend(LambdaExtension)

data/lib/honeybadger/plugins/local_variables.rb

@@ -1,5 +1,5 @@
-require 'honeybadger/plugin'
-require 'honeybadger/backtrace'
+require "honeybadger/plugin"
+require "honeybadger/backtrace"
 
 module Honeybadger
   module Plugins
@@ -24,10 +24,10 @@ module Honeybadger
       end
 
       Plugin.register do
-        requirement { config[:'exceptions.local_variables'] }
+        requirement { config[:"exceptions.local_variables"] }
         requirement { defined?(::BindingOfCaller) }
         requirement do
-          if res = defined?(::BetterErrors)
+          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 " \

data/lib/honeybadger/plugins/net_http.rb

@@ -1,7 +1,7 @@
-require 'net/http'
-require 'honeybadger/plugin'
-require 'honeybadger/instrumentation'
-require 'resolv'
+require "net/http"
+require "honeybadger/plugin"
+require "honeybadger/instrumentation"
+require "resolv"
 
 module Honeybadger
   module Plugins
@@ -25,31 +25,31 @@ module Honeybadger
             }.merge(parsed_uri_data(request_data))
 
             if @@hb_config.load_plugin_insights_events?(:net_http)
-              Honeybadger.event('request.net_http', context)
+              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'))
+              Honeybadger.gauge("duration.request", context.merge(metric_source: "net_http"))
             end
           end[1] # return the response data only
         end
 
         def hb?
-          address.to_s[/#{@@hb_config[:'connection.host'].to_s}/]
+          address.to_s[/#{@@hb_config[:"connection.host"]}/]
         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 @@hb_config[:'net_http.insights.full_url']
+            uri_data[:url] = uri.to_s if @@hb_config[:"net_http.insights.full_url"]
           end
         end
 
         def build_uri(request_data)
-          hostname = (address[/#{Resolv::IPv6::Regex}/]) ? "[#{address}]" : address
-          URI.parse("#{use_ssl? ? 'https' : 'http'}://#{hostname}#{request_data.path}")
+          hostname = address[/#{Resolv::IPv6::Regex}/o] ? "[#{address}]" : address
+          URI.parse("#{use_ssl? ? "https" : "http"}://#{hostname}#{request_data.path}")
         end
 
         Plugin.register :net_http do

data/lib/honeybadger/plugins/passenger.rb

@@ -1,5 +1,5 @@
-require 'honeybadger/plugin'
-require 'honeybadger/agent'
+require "honeybadger/plugin"
+require "honeybadger/agent"
 
 module Honeybadger
   module Plugins
@@ -9,11 +9,11 @@ module Honeybadger
 
         execution do
           ::PhusionPassenger.on_event(:starting_worker_process) do |forked|
-            logger.debug('Starting passenger worker process')
+            logger.debug("Starting passenger worker process")
           end
 
           ::PhusionPassenger.on_event(:stopping_worker_process) do
-            logger.debug('Stopping passenger worker process')
+            logger.debug("Stopping passenger worker process")
             Honeybadger.stop
           end
         end

data/lib/honeybadger/plugins/rails.rb

@@ -1,5 +1,5 @@
-require 'honeybadger/plugin'
-require 'honeybadger/notification_subscriber'
+require "honeybadger/plugin"
+require "honeybadger/notification_subscriber"
 
 module Honeybadger
   module Plugins
@@ -15,7 +15,7 @@ module Honeybadger
         # @return The super value of the middleware's +#render_exception()+
         #   method.
         def render_exception(arg, exception, *args)
-          if arg.kind_of?(::ActionDispatch::Request)
+          if arg.is_a?(::ActionDispatch::Request)
             request = arg
             env = request.env
           else
@@ -23,10 +23,14 @@ module Honeybadger
             env = arg
           end
 
-          env['honeybadger.exception'] = exception
-          env['honeybadger.request.url'] = request.url rescue nil
+          env["honeybadger.exception"] = exception
+          env["honeybadger.request.url"] = begin
+            request.url
+          rescue
+            nil
+          end
 
-          super(arg, exception, *args)
+          super
         end
       end
 
@@ -45,7 +49,7 @@ module Honeybadger
         end
 
         def self.source_ignored?(source)
-          source && ::Honeybadger.config[:'rails.subscriber_ignore_sources'].any? do |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
@@ -55,7 +59,7 @@ module Honeybadger
         requirement { defined?(::Rails.application) && ::Rails.application }
 
         execution do
-          require 'rack/request'
+          require "rack/request"
           if defined?(::ActionDispatch::DebugExceptions)
             # Rails 3.2.x+
             ::ActionDispatch::DebugExceptions.prepend(ExceptionsCatcher)
@@ -64,7 +68,7 @@ module Honeybadger
             ::ActionDispatch::ShowExceptions.prepend(ExceptionsCatcher)
           end
 
-          if Honeybadger.config[:'exceptions.enabled'] && 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)

data/lib/honeybadger/plugins/resque.rb

@@ -1,5 +1,5 @@
-require 'honeybadger/plugin'
-require 'honeybadger/ruby'
+require "honeybadger/plugin"
+require "honeybadger/ruby"
 
 module Honeybadger
   module Plugins
@@ -18,18 +18,18 @@ module Honeybadger
         # 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)
+          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']
+          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)
+          Honeybadger.notify(e, parameters: {job_arguments: args}, sync: true)
         end
       end
 
@@ -54,7 +54,7 @@ module Honeybadger
         requirement { defined?(::Resque::Job) }
 
         requirement do
-          if resque_honeybadger = defined?(::Resque::Failure::Honeybadger)
+          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 " \
@@ -64,7 +64,7 @@ module Honeybadger
         end
 
         execution do
-          return unless Honeybadger.config[:'exceptions.enabled']
+          return unless Honeybadger.config[:"exceptions.enabled"]
           ::Resque::Job.send(:include, Installer)
         end
       end

data/lib/honeybadger/plugins/shoryuken.rb

@@ -1,5 +1,5 @@
-require 'honeybadger/plugin'
-require 'honeybadger/ruby'
+require "honeybadger/plugin"
+require "honeybadger/ruby"
 
 module Honeybadger
   module Plugins
@@ -22,17 +22,17 @@ module Honeybadger
         private
 
         def attempt_threshold
-          ::Honeybadger.config[:'shoryuken.attempt_threshold'].to_i
+          ::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
+          sqs_msg.attributes["ApproximateReceiveCount".freeze].to_i
         end
 
         def notification_params(body)
-          body.is_a?(Array) ? { batch: body } : { body: body }
+          body.is_a?(Array) ? {batch: body} : {body: body}
         end
       end
 
@@ -40,7 +40,7 @@ module Honeybadger
         requirement { defined?(::Shoryuken) }
 
         execution do
-          return unless Honeybadger.config[:'exceptions.enabled']
+          return unless Honeybadger.config[:"exceptions.enabled"]
           ::Shoryuken.configure_server do |config|
             config.server_middleware do |chain|
               chain.add Middleware

data/lib/honeybadger/plugins/sidekiq.rb

@@ -1,6 +1,6 @@
-require 'honeybadger/instrumentation_helper'
-require 'honeybadger/plugin'
-require 'honeybadger/ruby'
+require "honeybadger/instrumentation_helper"
+require "honeybadger/plugin"
+require "honeybadger/ruby"
 
 module Honeybadger
   module Plugins
@@ -16,14 +16,14 @@ module Honeybadger
         include Honeybadger::InstrumentationHelper
 
         def call(worker, msg, queue, &block)
-          if msg["wrapped"]
-            context = {
+          context = if msg["wrapped"]
+            {
               jid: msg["jid"],
               worker: msg["wrapped"],
               queue: queue
             }
           else
-            context = {
+            {
               jid: msg["jid"],
               worker: msg["class"],
               queue: queue
@@ -32,19 +32,20 @@ module Honeybadger
 
           begin
             duration = Honeybadger.instrumentation.monotonic_timer { block.call }[0]
-            status = 'success'
-          rescue Exception => e
-            status = 'failure'
+            status = "success"
+          rescue
+            status = "failure"
             raise
           ensure
-            context.merge!(duration: duration, status: status)
+            context[:duration] = duration
+            context[:status] = status
             if Honeybadger.config.load_plugin_insights_events?(:sidekiq)
-              Honeybadger.event('perform.sidekiq', context)
+              Honeybadger.event("perform.sidekiq", context)
             end
 
             if Honeybadger.config.load_plugin_insights_metrics?(:sidekiq)
-              metric_source 'sidekiq'
-              gauge 'perform', context.slice(:worker, :queue, :duration)
+              metric_source "sidekiq"
+              gauge "perform", context.slice(:worker, :queue, :duration)
             end
           end
         end
@@ -60,7 +61,7 @@ module Honeybadger
           }
 
           if Honeybadger.config.load_plugin_insights_events?(:sidekiq)
-            Honeybadger.event('enqueue.sidekiq', context)
+            Honeybadger.event("enqueue.sidekiq", context)
           end
 
           yield
@@ -73,57 +74,56 @@ module Honeybadger
         requirement { defined?(::Sidekiq) }
 
         execution do
-          if Honeybadger.config[:'exceptions.enabled']
+          if Honeybadger.config[:"exceptions.enabled"]
             ::Sidekiq.configure_server do |sidekiq|
               sidekiq.server_middleware do |chain|
                 chain.prepend Middleware
               end
             end
 
-            if defined?(::Sidekiq::VERSION) && ::Sidekiq::VERSION > '3'
+            if defined?(::Sidekiq::VERSION) && ::Sidekiq::VERSION > "3"
               ::Sidekiq.configure_server do |sidekiq|
-
-                sidekiq_default_configuration = (::Sidekiq::VERSION > '7') ?
+                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)
+                    params[:_config] = if params[:_config].is_a?(::Sidekiq::Config) # Sidekiq > 6 and < 7.1.5
+                      params[:_config].instance_variable_get(:@options)
                     else # Sidekiq >= 7.1.5
-                      params[:_config] = sidekiq_config.instance_variable_get(:@options)
+                      sidekiq_config.instance_variable_get(:@options)
                     end
                   end
 
                   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
+                  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]
+                    retry_count = job["retry_count".freeze]
                     attempt = retry_count ? retry_count + 1 : 0
 
-                    max_retries = (::Sidekiq::VERSION > '7') ?
+                    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
+                    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]
+                  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)
@@ -133,38 +133,42 @@ module Honeybadger
           end
 
           if config.load_plugin_insights?(:sidekiq)
-            require "sidekiq"
-            require "sidekiq/api"
+            begin
+              require "sidekiq"
+              require "sidekiq/api"
 
-            if Gem::Version.new(::Sidekiq::VERSION) >= Gem::Version.new('6.5')
-              require "sidekiq/component"
+              if Gem::Version.new(::Sidekiq::VERSION) >= Gem::Version.new("6.5")
+                require "sidekiq/component"
 
-              class SidekiqClusterCollectionChecker
-                include ::Sidekiq::Component
-                def initialize(config)
-                  @config = config
-                end
+                class SidekiqClusterCollectionChecker
+                  include ::Sidekiq::Component
+                  def initialize(config)
+                    @config = config
+                  end
 
-                def collect?
-                  return true unless defined?(::Sidekiq::Enterprise)
-                  leader?
+                  def collect?
+                    return true unless defined?(::Sidekiq::Enterprise)
+                    leader?
+                  end
                 end
               end
-            end
 
-            ::Sidekiq.configure_server do |config|
-              config.server_middleware { |chain| chain.add(ServerMiddlewareInstrumentation) }
-              config.client_middleware { |chain| chain.add(ClientMiddlewareInstrumentation) }
+              ::Sidekiq.configure_server do |config|
+                config.server_middleware { |chain| chain.add(ServerMiddlewareInstrumentation) }
+                config.client_middleware { |chain| chain.add(ClientMiddlewareInstrumentation) }
 
-              if defined?(SidekiqClusterCollectionChecker)
-                config.on(:startup) do
-                  leader_checker = SidekiqClusterCollectionChecker.new(config)
+                if defined?(SidekiqClusterCollectionChecker)
+                  config.on(:startup) do
+                    leader_checker = SidekiqClusterCollectionChecker.new(config)
+                  end
                 end
               end
-            end
 
-            ::Sidekiq.configure_client do |config|
-              config.client_middleware { |chain| chain.add(ClientMiddlewareInstrumentation) }
+              ::Sidekiq.configure_client do |config|
+                config.client_middleware { |chain| chain.add(ClientMiddlewareInstrumentation) }
+              end
+            rescue LoadError
+              # Sidekiq is not loaded, so we don't need to do anything
             end
           end
         end
@@ -212,13 +216,13 @@ module Honeybadger
             stats = collect_sidekiq_stats.call
 
             if Honeybadger.config.load_plugin_insights_events?(:sidekiq)
-              Honeybadger.event('stats.sidekiq', stats.except('stats').merge(stats['stats']))
+              Honeybadger.event("stats.sidekiq", stats.except("stats").merge(stats["stats"]))
             end
 
             if Honeybadger.config.load_plugin_insights_metrics?(:sidekiq)
-              metric_source 'sidekiq'
+              metric_source "sidekiq"
 
-              stats['stats'].each do |name, value|
+              stats["stats"].each do |name, value|
                 gauge name, value: value
               end
 
@@ -228,8 +232,8 @@ module Honeybadger
                 end
               end
 
-              gauge 'capacity', value: stats[:capacity] if stats[:capacity]
-              gauge 'utilization', value: stats[:utilization] if stats[: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

@@ -20,7 +20,7 @@ module Honeybadger
           data[:queues] = {}
 
           ::SolidQueue::Queue.all.each do |queue|
-            data[:queues][queue.name] = { depth: queue.size }
+            data[:queues][queue.name] = {depth: queue.size}
           end
 
           data
@@ -31,11 +31,11 @@ module Honeybadger
             stats = collect_solid_queue_stats.call
 
             if Honeybadger.config.load_plugin_insights_events?(:solid_queue)
-              Honeybadger.event('stats.solid_queue', stats.except(:stats).merge(stats[:stats]))
+              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'
+              metric_source "solid_queue"
               stats[:stats].each do |stat_name, value|
                 gauge stat_name, value: value
               end

data/lib/honeybadger/plugins/sucker_punch.rb

@@ -1,17 +1,17 @@
-require 'honeybadger/plugin'
-require 'honeybadger/ruby'
+require "honeybadger/plugin"
+require "honeybadger/ruby"
 
 module Honeybadger
   Plugin.register do
     requirement { defined?(::SuckerPunch) }
 
     execution do
-      return unless Honeybadger.config[:'exceptions.enabled']
+      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 }) }
+        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 })
+          Honeybadger.notify(ex, {component: klass, parameters: args})
         end
       end
     end

data/lib/honeybadger/plugins/system.rb

@@ -1,5 +1,5 @@
-require 'honeybadger/util/stats'
-require 'honeybadger/plugin'
+require "honeybadger/util/stats"
+require "honeybadger/plugin"
 
 module Honeybadger
   module Plugins
@@ -8,7 +8,7 @@ module Honeybadger
         requirement { Util::Stats::HAS_MEM || Util::Stats::HAS_LOAD }
 
         collect do
-          Honeybadger.event('report.system', Util::Stats.all)
+          Honeybadger.event("report.system", Util::Stats.all)
         end
       end
     end