honeybadger 5.29.1 → 6.0.0

data/lib/honeybadger/notice.rb

@@ -1,39 +1,39 @@
-require 'json'
-require 'securerandom'
-require 'forwardable'
-
-require 'honeybadger/version'
-require 'honeybadger/backtrace'
-require 'honeybadger/conversions'
-require 'honeybadger/util/stats'
-require 'honeybadger/util/sanitizer'
-require 'honeybadger/util/request_hash'
-require 'honeybadger/util/request_payload'
+require "json"
+require "securerandom"
+require "forwardable"
+
+require "honeybadger/version"
+require "honeybadger/backtrace"
+require "honeybadger/conversions"
+require "honeybadger/util/stats"
+require "honeybadger/util/sanitizer"
+require "honeybadger/util/request_hash"
+require "honeybadger/util/request_payload"
 
 module Honeybadger
   # @api private
   NOTIFIER = {
-    name: 'honeybadger-ruby'.freeze,
-    url: 'https://github.com/honeybadger-io/honeybadger-ruby'.freeze,
+    name: "honeybadger-ruby".freeze,
+    url: "https://github.com/honeybadger-io/honeybadger-ruby".freeze,
     version: VERSION,
-    language: 'ruby'.freeze
+    language: "ruby".freeze
   }.freeze
 
   # @api private
   # Substitution for gem root in backtrace lines.
-  GEM_ROOT = '[GEM_ROOT]'.freeze
+  GEM_ROOT = "[GEM_ROOT]".freeze
 
   # @api private
   # Substitution for project root in backtrace lines.
-  PROJECT_ROOT = '[PROJECT_ROOT]'.freeze
+  PROJECT_ROOT = "[PROJECT_ROOT]".freeze
 
   # @api private
   # Empty String (used for equality comparisons and assignment).
-  STRING_EMPTY = ''.freeze
+  STRING_EMPTY = "".freeze
 
   # @api private
   # A Regexp which matches non-blank characters.
-  NOT_BLANK = /\S/.freeze
+  NOT_BLANK = /\S/
 
   # @api private
   # Matches lines beginning with ./
@@ -53,11 +53,11 @@ module Honeybadger
 
     # @api private
     # The String character used to split tag strings.
-    TAG_SEPERATOR = /,|\s/.freeze
+    TAG_SEPERATOR = /,|\s/
 
     # @api private
     # The Regexp used to strip invalid characters from individual tags.
-    TAG_SANITIZER = /\s/.freeze
+    TAG_SANITIZER = /\s/
 
     # @api private
     class Cause
@@ -177,20 +177,20 @@ module Honeybadger
         c = (PROJECT_ROOT_CACHE[config[:root]] ||= {})
         return c[line] if c.has_key?(line)
         c[line] ||= if config.root_regexp
-                      line.sub(config.root_regexp, PROJECT_ROOT)
-                    else
-                      line
-                    end
+          line.sub(config.root_regexp, PROJECT_ROOT)
+        else
+          line
+        end
       },
       lambda { |line| line.sub(RELATIVE_ROOT, STRING_EMPTY) },
-      lambda { |line| line if line !~ %r{lib/honeybadger} }
+      lambda { |line| line if !%r{lib/honeybadger}.match?(line) }
     ].freeze
 
     # @api private
     def initialize(config, opts = {})
-      @now   = Time.now.utc
-      @pid   = Process.pid
-      @id    = SecureRandom.uuid
+      @now = Time.now.utc
+      @pid = Process.pid
+      @id = SecureRandom.uuid
       @stats = Util::Stats.all
 
       @opts = opts
@@ -201,10 +201,10 @@ module Honeybadger
 
       @exception = unwrap_exception(opts[:exception])
 
-      self.error_class = exception_attribute(:error_class, 'Notice') {|exception| exception.class.name }
-      self.error_message = exception_attribute(:error_message, 'No message provided') do |exception|
+      self.error_class = exception_attribute(:error_class, "Notice") { |exception| exception.class.name }
+      self.error_message = exception_attribute(:error_message, "No message provided") do |exception|
         message = exception.respond_to?(:detailed_message) ?
-          exception.detailed_message(highlight: false).sub(" (#{exception.class.name})", '') # Gems like error_highlight append the exception class name
+          exception.detailed_message(highlight: false).sub(" (#{exception.class.name})", "") # Gems like error_highlight append the exception class name
           : exception.message
         "#{exception.class.name}: #{message}"
       end
@@ -216,13 +216,13 @@ 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]     || context[:_action]       || request_hash[:action]    || nil
-      self.component  = opts[:controller] || opts[:component]        || context[:_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] || context[:_action] || request_hash[:action] || nil
+      self.component = opts[:controller] || opts[:component] || context[:_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]
@@ -305,13 +305,12 @@ module Honeybadger
 
     def ignore_by_origin?
       return false if opts[:origin] != :rake
-      return false if config[:'exceptions.rescue_rake']
+      return false if config[:"exceptions.rescue_rake"]
       true
     end
 
     def ignore_by_callbacks?
-      config.exception_filter &&
-        config.exception_filter.call(self)
+      config.exception_filter&.call(self)
     end
 
     # Gets a property named "attribute" of an exception, either from
@@ -353,7 +352,7 @@ module Honeybadger
     #
     # Returns true or false.
     def ignore_by_class?(ignored_class = nil)
-      @ignore_by_class ||= Proc.new do |ignored_class|
+      @ignore_by_class ||= proc do |ignored_class|
         case error_class
         when (ignored_class.respond_to?(:name) ? ignored_class.name : ignored_class)
           true
@@ -388,7 +387,7 @@ module Honeybadger
         cgi_data: cgi_data,
         sanitizer: request_sanitizer
       }
-      request.delete_if {|k,v| config.excluded_request_keys.include?(k) }
+      request.delete_if { |k, v| config.excluded_request_keys.include?(k) }
       Util::RequestPayload.build(request)
     end
 
@@ -444,7 +443,7 @@ module Honeybadger
       Array(tags).flatten.each do |val|
         val.to_s.split(TAG_SEPERATOR).each do |tag|
           tag.gsub!(TAG_SANITIZER, STRING_EMPTY)
-          ret << tag if tag =~ NOT_BLANK
+          ret << tag if NOT_BLANK.match?(tag)
         end
       end
 
@@ -471,27 +470,25 @@ module Honeybadger
           if BINDING_HAS_SOURCE_LOCATION
             b.source_location[0]
           else
-            b.eval('__FILE__')
+            b.eval("__FILE__")
           end =~ /^#{Regexp.escape(config[:root].to_s)}/
         }
       end
 
       binding ||= exception.__honeybadger_bindings_stack[0]
 
-      vars = binding.eval('local_variables')
+      vars = binding.eval("local_variables")
       results =
-        vars.inject([]) { |acc, arg|
+        vars.each_with_object([]) { |arg, acc|
           begin
             result = binding.eval(arg.to_s)
             acc << [arg, result]
           rescue NameError
             # Do Nothing
           end
-
-          acc
         }
 
-      result_hash = Hash[results]
+      result_hash = results.to_h
       request_sanitizer.sanitize(result_hash)
     end
 
@@ -499,7 +496,7 @@ module Honeybadger
     #
     # Returns true to send local_variables.
     def send_local_variables?(config)
-      config[:'exceptions.local_variables']
+      config[:"exceptions.local_variables"]
     end
 
     # Parse Backtrace from exception backtrace.
@@ -512,7 +509,7 @@ module Honeybadger
         backtrace,
         filters: construct_backtrace_filters(opts),
         config: config,
-        source_radius: config[:'exceptions.source_radius']
+        source_radius: config[:"exceptions.source_radius"]
       ).to_a
     end
 
@@ -523,7 +520,7 @@ module Honeybadger
     #
     # Returns the Exception to report.
     def unwrap_exception(exception)
-      return exception unless config[:'exceptions.unwrap']
+      return exception unless config[:"exceptions.unwrap"]
       exception_cause(exception) || exception
     end
 
@@ -534,11 +531,11 @@ module Honeybadger
     # Returns the Exception cause.
     def exception_cause(exception)
       e = exception
-      if e.respond_to?(:cause) && e.cause && e.cause.is_a?(Exception)
+      if e.respond_to?(:cause) && e.cause&.is_a?(Exception)
         e.cause
-      elsif e.respond_to?(:original_exception) && e.original_exception && e.original_exception.is_a?(Exception)
+      elsif e.respond_to?(:original_exception) && e.original_exception&.is_a?(Exception)
         e.original_exception
-      elsif e.respond_to?(:continued_exception) && e.continued_exception && e.continued_exception.is_a?(Exception)
+      elsif e.respond_to?(:continued_exception) && e.continued_exception&.is_a?(Exception)
         e.continued_exception
       end
     end
@@ -566,7 +563,7 @@ module Honeybadger
     #
     # Returns the Array of causes in Hash payload format.
     def prepare_causes(causes)
-      causes.map {|c|
+      causes.map { |c|
         {
           class: c.error_class,
           message: c.error_message,
@@ -580,7 +577,7 @@ module Honeybadger
     end
 
     def rails_params_filters
-      rack_env && Array(rack_env['action_dispatch.parameter_filter']) or []
+      rack_env && Array(rack_env["action_dispatch.parameter_filter"]) or []
     end
   end
 end

data/lib/honeybadger/notification_subscriber.rb

@@ -1,5 +1,5 @@
-require 'honeybadger/instrumentation_helper'
-require 'honeybadger/util/sql'
+require "honeybadger/instrumentation_helper"
+require "honeybadger/util/sql"
 
 module Honeybadger
   class NotificationSubscriber
@@ -27,21 +27,21 @@ module Honeybadger
       end
 
       if Honeybadger.config.load_plugin_insights_metrics?(:rails)
-        metric_source '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 "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
@@ -95,11 +95,11 @@ module Honeybadger
   end
 
   class ActionViewSubscriber < NotificationSubscriber
-    PROJECT_ROOT = defined?(::Rails) ? ::Rails.root.to_s : ''
+    PROJECT_ROOT = defined?(::Rails) ? ::Rails.root.to_s : ""
 
     def format_payload(payload)
       {
-        view: payload[:identifier].to_s.gsub(PROJECT_ROOT, '[PROJECT_ROOT]'),
+        view: payload[:identifier].to_s.gsub(PROJECT_ROOT, "[PROJECT_ROOT]"),
         layout: payload[:layout]
       }
     end
@@ -139,7 +139,7 @@ module Honeybadger
 
       # ... but do include any attachment filenames
       attachment_info = if mail&.attachments&.any?
-        { attachments: mail.attachments.map { |a| { filename: a.filename } } }
+        {attachments: mail.attachments.map { |a| {filename: a.filename} }}
       else
         {}
       end

data/lib/honeybadger/plugin.rb

@@ -1,5 +1,5 @@
-require 'forwardable'
-require 'honeybadger/instrumentation_helper'
+require "forwardable"
+require "honeybadger/instrumentation_helper"
 
 module Honeybadger
   # +Honeybadger::Plugin+ defines the API for registering plugins with
@@ -84,7 +84,7 @@ module Honeybadger
       # @return nil
       def register(name = nil, &block)
         name ||= name_from_caller(caller) or
-          raise(ArgumentError, 'Plugin name is required, but was nil.')
+          raise(ArgumentError, "Plugin name is required, but was nil.")
         instances[key = name.to_sym] and fail("Already registered: #{name}")
         instances[key] = new(name).tap { |d| d.instance_eval(&block) }
       end
@@ -95,7 +95,7 @@ module Honeybadger
           if config.load_plugin?(name)
             plugin.load!(config)
           else
-            config.logger.debug(sprintf('skip plugin name=%s reason=disabled', name))
+            config.logger.debug(sprintf("skip plugin name=%s reason=disabled", name))
           end
         end
       end
@@ -157,11 +157,11 @@ module Honeybadger
 
     # @api private
     def initialize(name)
-      @name         = name
-      @loaded       = false
+      @name = name
+      @loaded = false
       @requirements = []
-      @executions   = []
-      @collectors   = []
+      @executions = []
+      @collectors = []
     end
 
     # Define a requirement. All requirement blocks must return +true+ for the
@@ -231,13 +231,13 @@ module Honeybadger
     #   end
     #
     # @return nil
-    def collect(options={}, &block)
+    def collect(options = {}, &block)
       @collectors << [options, block]
     end
 
     # @api private
     def ok?(config)
-      @requirements.all? {|r| Execution.new(config, &r).call }
+      @requirements.all? { |r| Execution.new(config, &r).call }
     rescue => e
       config.logger.error(sprintf("plugin error name=%s class=%s message=%s\n\t%s", name, e.class, e.message.dump, Array(e.backtrace).join("\n\t")))
       false
@@ -246,15 +246,15 @@ module Honeybadger
     # @api private
     def load!(config)
       if @loaded
-        config.logger.debug(sprintf('skip plugin name=%s reason=loaded', name))
+        config.logger.debug(sprintf("skip plugin name=%s reason=loaded", name))
         return false
       elsif ok?(config)
-        config.logger.debug(sprintf('load plugin name=%s', name))
-        @executions.each {|e| Execution.new(config, &e).call }
-        @collectors.each {|o,b| CollectorExecution.new(name, config, o, &b).register! }
+        config.logger.debug(sprintf("load plugin name=%s", name))
+        @executions.each { |e| Execution.new(config, &e).call }
+        @collectors.each { |o, b| CollectorExecution.new(name, config, o, &b).register! }
         @loaded = true
       else
-        config.logger.debug(sprintf('skip plugin name=%s reason=requirement', name))
+        config.logger.debug(sprintf("skip plugin name=%s reason=requirement", name))
       end
 
       @loaded
@@ -265,9 +265,7 @@ module Honeybadger
     end
 
     # @api private
-    def collectors
-      @collectors
-    end
+    attr_reader :collectors
 
     # @api private
     def loaded?

data/lib/honeybadger/plugins/active_job.rb

@@ -1,4 +1,4 @@
-require 'honeybadger/notification_subscriber'
+require "honeybadger/notification_subscriber"
 
 module Honeybadger
   module Plugins
@@ -11,19 +11,21 @@ module Honeybadger
           Honeybadger.clear!
           context = context(job)
           block.call
-        rescue StandardError => e
-          Honeybadger.notify(
-            e,
-            context: context,
-            parameters: { arguments: job.arguments }
-          ) if job.executions >= Honeybadger.config[:'active_job.attempt_threshold'].to_i
+        rescue => e
+          if job.executions >= Honeybadger.config[:"active_job.attempt_threshold"].to_i
+            Honeybadger.notify(
+              e,
+              context: context,
+              parameters: {arguments: job.arguments}
+            )
+          end
           raise e
         end
 
         def context(job) # rubocop:disable Metrics/MethodLength
           {
             component: job.class,
-            action: 'perform',
+            action: "perform",
             enqueued_at: job.try(:enqueued_at),
             executions: job.executions,
             job_class: job.class,
@@ -51,7 +53,7 @@ module Honeybadger
         end
 
         execution do
-          ::ActiveJob::Base.set_callback(:perform, :around, prepend: true, &ActiveJob.method(:perform_around)) if Honeybadger.config[:'exceptions.enabled']
+          ::ActiveJob::Base.set_callback(:perform, :around, prepend: true, &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)

data/lib/honeybadger/plugins/autotuner.rb

@@ -1,5 +1,5 @@
-require 'honeybadger/instrumentation_helper'
-require 'honeybadger/plugin'
+require "honeybadger/instrumentation_helper"
+require "honeybadger/plugin"
 
 module Honeybadger
   module Plugins
@@ -16,13 +16,13 @@ module Honeybadger
 
           ::Autotuner.metrics_reporter = proc do |metrics|
             if config.load_plugin_insights_events?(:autotuner)
-              Honeybadger.event('stats.autotuner', metrics)
+              Honeybadger.event("stats.autotuner", metrics)
             end
 
             if config.load_plugin_insights_metrics?(:autotuner)
-              metric_source 'autotuner'
+              metric_source "autotuner"
               metrics.each do |key, val|
-                gauge key, ->{ val }
+                gauge key, -> { val }
               end
             end
           end

data/lib/honeybadger/plugins/breadcrumbs.rb

@@ -1,5 +1,5 @@
-require 'honeybadger/plugin'
-require 'honeybadger/breadcrumbs/logging'
+require "honeybadger/plugin"
+require "honeybadger/breadcrumbs/logging"
 
 module Honeybadger
   module Plugins
@@ -41,19 +41,19 @@ module Honeybadger
     # See RailsBreadcrumbs.send_breadcrumb_notification for specifics on the
     # options for customization
     Plugin.register :breadcrumbs do
-      requirement { config[:'breadcrumbs.enabled'] }
+      requirement { config[:"breadcrumbs.enabled"] }
 
       execution do
         # Rails specific breadcrumb events
         #
         if defined?(::Rails.application) && ::Rails.application
-          config[:'breadcrumbs.active_support_notifications'].each do |name, config|
+          config[:"breadcrumbs.active_support_notifications"].each do |name, config|
             RailsBreadcrumbs.subscribe_to_notification(name, config)
           end
-          ActiveSupport::LogSubscriber.prepend(Honeybadger::Breadcrumbs::LogSubscriberInjector) if config[:'breadcrumbs.logging.enabled']
+          ActiveSupport::LogSubscriber.prepend(Honeybadger::Breadcrumbs::LogSubscriberInjector) if config[:"breadcrumbs.logging.enabled"]
         end
 
-        ::Logger.prepend(Honeybadger::Breadcrumbs::LogWrapper) if config[:'breadcrumbs.logging.enabled']
+        ::Logger.prepend(Honeybadger::Breadcrumbs::LogWrapper) if config[:"breadcrumbs.logging.enabled"]
       end
     end
 
@@ -73,7 +73,7 @@ module Honeybadger
       # @option notification_config [Proc] :transform A proc that accepts the data payload. The return value will replace the current data hash (optional)
       #
       def self.send_breadcrumb_notification(name, duration, notification_config, data = {})
-        return if notification_config[:exclude_when] && notification_config[:exclude_when].call(data)
+        return if notification_config[:exclude_when]&.call(data)
 
         message =
           case (m = notification_config[:message])

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

@@ -1,5 +1,5 @@
-require 'delayed_job'
-require 'honeybadger/ruby'
+require "delayed_job"
+require "honeybadger/ruby"
 
 module Honeybadger
   module Plugins
@@ -8,46 +8,45 @@ module Honeybadger
         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'
+              if job.payload_object.instance_of?(::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
-              )
+            ::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
+            block.call(job)
+          rescue => error
+            if job.attempts.to_i >= ::Honeybadger.config[:"delayed_job.attempt_threshold"].to_i
               ::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!
+                component: component,
+                action: action,
+                error_class: error.class.name,
+                error_message: "#{error.class.name}: #{error.message}",
+                backtrace: error.backtrace,
+                exception: error
+              )
             end
+            raise error
+          ensure
+            ::Honeybadger.clear!
           end
         end
       end

data/lib/honeybadger/plugins/delayed_job.rb

@@ -1,11 +1,11 @@
-require 'honeybadger/plugin'
+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)
+      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 " \
@@ -15,8 +15,8 @@ module Honeybadger
     end
 
     execution do
-      return unless Honeybadger.config[:'exceptions.enabled']
-      require 'honeybadger/plugins/delayed_job/plugin'
+      return unless Honeybadger.config[:"exceptions.enabled"]
+      require "honeybadger/plugins/delayed_job/plugin"
       ::Delayed::Worker.plugins << Plugins::DelayedJob::Plugin
     end
   end