newrelic_rpm 8.16.0 → 9.1.0

data/lib/new_relic/agent/agent.rb

@@ -142,20 +142,16 @@ module NewRelic
         # the transaction sampler that handles recording transactions
         attr_reader :transaction_sampler
         attr_reader :sql_sampler
-        # manages agent commands we receive from the collector, and the handlers
-        attr_reader :agent_command_router
         # error collector is a simple collection of recorded errors
         attr_reader :error_collector
-        attr_reader :harvest_samplers
         # whether we should record raw, obfuscated, or no sql
         attr_reader :record_sql
         # builder for JS agent scripts to inject
         attr_reader :javascript_instrumentor
         # cross application tracing ids and encoding
         attr_reader :cross_process_id
-        attr_reader :cross_app_encoding_bytes
         # service for communicating with collector
-        attr_accessor :service
+        attr_reader :service
         # Global events dispatcher. This will provides our primary mechanism
         # for agent-wide events, such as finishing configuration, error notification
         # and request before/after from Rack.
@@ -168,8 +164,6 @@ module NewRelic
         # collector on connect.  The former are applied during txns,
         # the latter during harvest.
         attr_accessor :transaction_rules
-        # Responsible for restarting the harvest thread
-        attr_reader :harvester
         # GC::Profiler.total_time is not monotonic so we wrap it.
         attr_reader :monotonic_gc_profiler
         attr_reader :custom_event_aggregator
@@ -178,7 +172,6 @@ module NewRelic
         attr_reader :transaction_event_recorder
         attr_reader :attribute_filter
         attr_reader :adaptive_sampler
-        attr_reader :environment_report
 
         def transaction_event_aggregator
           @transaction_event_recorder.transaction_event_aggregator
@@ -262,8 +255,8 @@ module NewRelic
           # if litespeed, then ignore all future SIGUSR1 - it's
           # litespeed trying to shut us down
           if Agent.config[:dispatcher] == :litespeed
-            Signal.trap("SIGUSR1", "IGNORE")
-            Signal.trap("SIGTERM", "IGNORE")
+            Signal.trap('SIGUSR1', 'IGNORE')
+            Signal.trap('SIGTERM', 'IGNORE')
           end
         end
 
@@ -355,12 +348,6 @@ module NewRelic
         end
 
         public :merge_data_for_endpoint
-
-        # Delegates to the control class to determine the root
-        # directory of this project
-        def determine_home_directory
-          control.root
-        end
       end
 
       extend ClassMethods

data/lib/new_relic/agent/agent_helpers/connect.rb

@@ -64,7 +64,7 @@ module NewRelic
         def handle_license_error(error)
           ::NewRelic::Agent.logger.error( \
             error.message, \
-            "Visit NewRelic.com to obtain a valid license key, or to upgrade your account."
+            'Visit NewRelic.com to obtain a valid license key, or to upgrade your account.'
           )
           disconnect
         end
@@ -115,7 +115,7 @@ module NewRelic
           ::NewRelic::Agent.logger.debug("Connected to NewRelic Service at #{@service.collector.name}")
           ::NewRelic::Agent.logger.debug("Agent Run       = #{@service.agent_id}.")
           ::NewRelic::Agent.logger.debug("Connection data = #{config_data.inspect}")
-          if config_data['messages'] && config_data['messages'].any?
+          if config_data['messages']&.any?
             log_collector_messages(config_data['messages'])
           end
         end
@@ -126,11 +126,6 @@ module NewRelic
           end
         end
 
-        # apdex_f is always 4 times the apdex_t
-        def apdex_f
-          (Agent.config[:apdex_t] * 4).to_f
-        end
-
         class WaitOnConnectTimeout < StandardError
         end
 
@@ -149,7 +144,7 @@ module NewRelic
           return if connected?
 
           @waited_on_connect = true
-          NewRelic::Agent.logger.debug("Waiting on connect to complete.")
+          NewRelic::Agent.logger.debug('Waiting on connect to complete.')
 
           @wait_on_connect_mutex.synchronize do
             @wait_on_connect_condition.wait(@wait_on_connect_mutex, timeout)
@@ -162,7 +157,7 @@ module NewRelic
 
         def connect_options(options)
           {
-            keep_retrying: Agent.config[:keep_retrying],
+            keep_retrying: true,
             force_reconnect: Agent.config[:force_reconnect]
           }.merge(options)
         end
@@ -203,7 +198,7 @@ module NewRelic
         rescue StandardError, Timeout::Error, NewRelic::Agent::ServerConnectionException => e
           retry if retry_from_error?(e, opts)
         rescue Exception => e
-          ::NewRelic::Agent.logger.error("Exception of unexpected type during Agent#connect():", e)
+          ::NewRelic::Agent.logger.error('Exception of unexpected type during Agent#connect():', e)
 
           raise
         end

data/lib/new_relic/agent/agent_helpers/harvest.rb

@@ -133,18 +133,18 @@ module NewRelic
           rescue ForceRestartException, ForceDisconnectException
             raise
           rescue UnrecoverableServerException => e
-            NewRelic::Agent.logger.warn("get_agent_commands message was rejected by remote service, discarding. " \
-              "Error: ", e)
+            NewRelic::Agent.logger.warn('get_agent_commands message was rejected by remote service, discarding. ' \
+              'Error: ', e)
           rescue ServerConnectionException => e
             log_remote_unavailable(:get_agent_commands, e)
           rescue => e
-            NewRelic::Agent.logger.info("Error during check_for_and_handle_agent_commands, will retry later: ", e)
+            NewRelic::Agent.logger.info('Error during check_for_and_handle_agent_commands, will retry later: ', e)
           end
         end
 
         def log_remote_unavailable(endpoint, e)
           NewRelic::Agent.logger.debug("Unable to send #{endpoint} data, will try again later. Error: ", e)
-          NewRelic::Agent.record_metric("Supportability/remote_unavailable", 0.0)
+          NewRelic::Agent.record_metric('Supportability/remote_unavailable', 0.0)
           NewRelic::Agent.record_metric("Supportability/remote_unavailable/#{endpoint.to_s}", 0.0)
         end
       end

data/lib/new_relic/agent/agent_helpers/shutdown.rb

@@ -11,7 +11,7 @@ module NewRelic
         def shutdown
           return unless started?
 
-          ::NewRelic::Agent.logger.info("Starting Agent shutdown")
+          ::NewRelic::Agent.logger.info('Starting Agent shutdown')
 
           stop_event_loop
           trap_signals_for_litespeed
@@ -48,22 +48,22 @@ module NewRelic
               transmit_data_types
               shutdown_service
 
-              ::NewRelic::Agent.logger.debug("Graceful disconnect complete")
+              ::NewRelic::Agent.logger.debug('Graceful disconnect complete')
             rescue Timeout::Error, StandardError => e
               ::NewRelic::Agent.logger.debug("Error when disconnecting #{e.class.name}: #{e.message}")
             end
           else
-            ::NewRelic::Agent.logger.debug("Bypassing graceful disconnect - agent not connected")
+            ::NewRelic::Agent.logger.debug('Bypassing graceful disconnect - agent not connected')
           end
         end
 
         def shutdown_service
           if @connected_pid == $$ && !@service.kind_of?(NewRelic::Agent::NewRelicService)
-            ::NewRelic::Agent.logger.debug("Sending New Relic service agent run shutdown message")
+            ::NewRelic::Agent.logger.debug('Sending New Relic service agent run shutdown message')
             @service.shutdown
           else
             ::NewRelic::Agent.logger.debug("This agent connected from parent process #{@connected_pid}--not sending " \
-              "shutdown")
+              'shutdown')
           end
         end
       end

data/lib/new_relic/agent/agent_helpers/special_startup.rb

@@ -10,9 +10,8 @@ module NewRelic
         # requests, we need to wait until the children are forked
         # before connecting, otherwise the parent process sends useless data
         def using_forking_dispatcher?
-          # TODO: MAJOR VERSION - remove :rainbows
-          if [:puma, :passenger, :rainbows, :unicorn].include?(Agent.config[:dispatcher])
-            ::NewRelic::Agent.logger.info("Deferring startup of agent reporting thread because " \
+          if [:puma, :passenger, :unicorn].include?(Agent.config[:dispatcher])
+            ::NewRelic::Agent.logger.info('Deferring startup of agent reporting thread because ' \
               "#{Agent.config[:dispatcher]} may fork.")
             true
           else
@@ -66,7 +65,7 @@ module NewRelic
         def install_exit_handler
           return unless should_install_exit_handler?
 
-          NewRelic::Agent.logger.debug("Installing at_exit handler")
+          NewRelic::Agent.logger.debug('Installing at_exit handler')
           at_exit { shutdown }
         end
       end

data/lib/new_relic/agent/agent_helpers/start_worker_thread.rb

@@ -8,23 +8,23 @@ module NewRelic
       module StartWorkerThread
         LOG_ONCE_KEYS_RESET_PERIOD = 60.0
 
-        TRANSACTION_EVENT_DATA = "transaction_event_data".freeze
-        CUSTOM_EVENT_DATA = "custom_event_data".freeze
-        ERROR_EVENT_DATA = "error_event_data".freeze
-        SPAN_EVENT_DATA = "span_event_data".freeze
-        LOG_EVENT_DATA = "log_event_data".freeze
+        TRANSACTION_EVENT_DATA = 'transaction_event_data'.freeze
+        CUSTOM_EVENT_DATA = 'custom_event_data'.freeze
+        ERROR_EVENT_DATA = 'error_event_data'.freeze
+        SPAN_EVENT_DATA = 'span_event_data'.freeze
+        LOG_EVENT_DATA = 'log_event_data'.freeze
 
         # Try to launch the worker thread and connect to the server.
         #
         # See #connect for a description of connection_options.
         def start_worker_thread(connection_options = {})
           if disable = NewRelic::Agent.config[:disable_harvest_thread]
-            NewRelic::Agent.logger.info("Not starting Ruby Agent worker thread because :disable_harvest_thread is " \
+            NewRelic::Agent.logger.info('Not starting Ruby Agent worker thread because :disable_harvest_thread is ' \
               "#{disable}")
             return
           end
 
-          ::NewRelic::Agent.logger.debug("Creating Ruby Agent worker thread.")
+          ::NewRelic::Agent.logger.debug('Creating Ruby Agent worker thread.')
           @worker_thread = Threading::AgentThread.create('Worker Loop') do
             deferred_work!(connection_options)
           end
@@ -42,11 +42,11 @@ module NewRelic
         # The use-case where this typically arises is in cronjob scheduled rake tasks where there's
         # also some network stability/latency issues happening.
         def stop_event_loop
-          @event_loop.stop if @event_loop
+          @event_loop&.stop
           # Wait the end of the event loop thread.
           if @worker_thread
             unless @worker_thread.join(3)
-              ::NewRelic::Agent.logger.debug("Event loop thread did not stop within 3 seconds")
+              ::NewRelic::Agent.logger.debug('Event loop thread did not stop within 3 seconds')
             end
           end
         end
@@ -60,36 +60,13 @@ module NewRelic
         end
 
         def create_and_run_event_loop
-          data_harvest = :"#{Agent.config[:data_report_period]}_second_harvest"
-          event_harvest = :"#{Agent.config[:event_report_period]}_second_harvest"
-
           @event_loop = create_event_loop
+          data_harvest = :"#{Agent.config[:data_report_period]}_second_harvest"
           @event_loop.on(data_harvest) do
             transmit_data
           end
-
-          @event_loop.on(interval_for(TRANSACTION_EVENT_DATA)) do
-            transmit_analytic_event_data
-          end
-          @event_loop.on(interval_for(CUSTOM_EVENT_DATA)) do
-            transmit_custom_event_data
-          end
-          @event_loop.on(interval_for(ERROR_EVENT_DATA)) do
-            transmit_error_event_data
-          end
-          @event_loop.on(interval_for(SPAN_EVENT_DATA)) do
-            transmit_span_event_data
-          end
-          @event_loop.on(interval_for(LOG_EVENT_DATA)) do
-            transmit_log_event_data
-          end
-
-          @event_loop.on(:reset_log_once_keys) do
-            ::NewRelic::Agent.logger.clear_already_logged
-          end
-          @event_loop.fire_every(Agent.config[:data_report_period], data_harvest)
-          @event_loop.fire_every(Agent.config[:event_report_period], event_harvest)
-          @event_loop.fire_every(LOG_ONCE_KEYS_RESET_PERIOD, :reset_log_once_keys)
+          establish_interval_transmissions
+          establish_fire_everies(data_harvest)
 
           @event_loop.run
         end
@@ -100,7 +77,7 @@ module NewRelic
         def handle_force_restart(error)
           ::NewRelic::Agent.logger.debug(error.message)
           drop_buffered_data
-          @service.force_restart if @service
+          @service&.force_restart
           @connect_state = :pending
           sleep(30)
         end
@@ -109,7 +86,7 @@ module NewRelic
         # is the worker thread that gathers data and talks to the
         # server.
         def handle_force_disconnect(error)
-          ::NewRelic::Agent.logger.warn("Agent received a ForceDisconnectException from the server, disconnecting. " \
+          ::NewRelic::Agent.logger.warn('Agent received a ForceDisconnectException from the server, disconnecting. ' \
             "(#{error.message})")
           disconnect
         end
@@ -118,7 +95,7 @@ module NewRelic
         # it and disconnecting the agent, since we are now in an
         # unknown state.
         def handle_other_error(error)
-          ::NewRelic::Agent.logger.error("Unhandled error in worker thread, disconnecting.")
+          ::NewRelic::Agent.logger.error('Unhandled error in worker thread, disconnecting.')
           # These errors are fatal (that is, they will prevent the agent from
           # reporting entirely), so we really want backtraces when they happen
           ::NewRelic::Agent.logger.log_exception(:error, error)
@@ -156,11 +133,42 @@ module NewRelic
                 # never reaches here unless there is a problem or
                 # the agent is exiting
               else
-                ::NewRelic::Agent.logger.debug("No connection.  Worker thread ending.")
+                ::NewRelic::Agent.logger.debug('No connection.  Worker thread ending.')
               end
             end
           end
         end
+
+        private
+
+        def establish_interval_transmissions
+          @event_loop.on(interval_for(TRANSACTION_EVENT_DATA)) do
+            transmit_analytic_event_data
+          end
+          @event_loop.on(interval_for(CUSTOM_EVENT_DATA)) do
+            transmit_custom_event_data
+          end
+          @event_loop.on(interval_for(ERROR_EVENT_DATA)) do
+            transmit_error_event_data
+          end
+          @event_loop.on(interval_for(SPAN_EVENT_DATA)) do
+            transmit_span_event_data
+          end
+          @event_loop.on(interval_for(LOG_EVENT_DATA)) do
+            transmit_log_event_data
+          end
+        end
+
+        def establish_fire_everies(data_harvest)
+          @event_loop.on(:reset_log_once_keys) do
+            ::NewRelic::Agent.logger.clear_already_logged
+          end
+
+          event_harvest = :"#{Agent.config[:event_report_period]}_second_harvest"
+          @event_loop.fire_every(Agent.config[:data_report_period], data_harvest)
+          @event_loop.fire_every(Agent.config[:event_report_period], event_harvest)
+          @event_loop.fire_every(LOG_ONCE_KEYS_RESET_PERIOD, :reset_log_once_keys)
+        end
       end
     end
   end

data/lib/new_relic/agent/agent_helpers/startup.rb

@@ -14,7 +14,7 @@ module NewRelic
         # Check whether we have already started, which is an error condition
         def already_started?
           if started?
-            ::NewRelic::Agent.logger.error("Agent Started Already!")
+            ::NewRelic::Agent.logger.error('Agent Started Already!')
             true
           end
         end
@@ -87,15 +87,15 @@ module NewRelic
         end
 
         def log_app_name
-          ::NewRelic::Agent.logger.info("Application: #{Agent.config[:app_name].join(", ")}")
+          ::NewRelic::Agent.logger.info("Application: #{Agent.config[:app_name].join(', ')}")
         end
 
         def log_ignore_url_regexes
           regexes = NewRelic::Agent.config[:'rules.ignore_url_regexes']
 
           unless regexes.empty?
-            ::NewRelic::Agent.logger.info("Ignoring URLs that match the following regexes: " \
-              "#{regexes.map(&:inspect).join(", ")}.")
+            ::NewRelic::Agent.logger.info('Ignoring URLs that match the following regexes: ' \
+              "#{regexes.map(&:inspect).join(', ')}.")
           end
         end
 
@@ -138,10 +138,10 @@ module NewRelic
           if Agent.config[:license_key] && Agent.config[:license_key].length > 0
             true
           else
-            ::NewRelic::Agent.logger.warn("No license key found. " +
-              "This often means your newrelic.yml file was not found, or it lacks a section for the running " \
+            ::NewRelic::Agent.logger.warn('No license key found. ' +
+              'This often means your newrelic.yml file was not found, or it lacks a section for the running ' \
               "environment, '#{NewRelic::Control.instance.env}'. You may also want to try linting your newrelic.yml " \
-              "to ensure it is valid YML.")
+              'to ensure it is valid YML.')
             false
           end
         end
@@ -169,21 +169,21 @@ module NewRelic
           return false if already_started? || disabled?
 
           if defer_for_delayed_job?
-            ::NewRelic::Agent.logger.debug("Deferring startup for DelayedJob")
+            ::NewRelic::Agent.logger.debug('Deferring startup for DelayedJob')
             return false
           end
 
           if defer_for_resque?
-            ::NewRelic::Agent.logger.debug("Deferring startup for Resque in case it daemonizes")
+            ::NewRelic::Agent.logger.debug('Deferring startup for Resque in case it daemonizes')
             return false
           end
 
           unless app_name_configured?
-            NewRelic::Agent.logger.error("No application name configured.",
-              "The Agent cannot start without at least one. Please check your ",
-              "newrelic.yml and ensure that it is valid and has at least one ",
+            NewRelic::Agent.logger.error('No application name configured.',
+              'The Agent cannot start without at least one. Please check your ',
+              'newrelic.yml and ensure that it is valid and has at least one ',
               "value set for app_name in the #{NewRelic::Control.instance.env} ",
-              "environment.")
+              'environment.')
             return false
           end
 

data/lib/new_relic/agent/agent_helpers/transmit.rb

@@ -6,27 +6,27 @@ module NewRelic
   module Agent
     module AgentHelpers
       module Transmit
-        TRANSACTION_EVENT = "TransactionEvent".freeze
+        TRANSACTION_EVENT = 'TransactionEvent'.freeze
         def transmit_analytic_event_data
           transmit_single_data_type(:harvest_and_send_analytic_event_data, TRANSACTION_EVENT)
         end
 
-        CUSTOM_EVENT = "CustomEvent".freeze
+        CUSTOM_EVENT = 'CustomEvent'.freeze
         def transmit_custom_event_data
           transmit_single_data_type(:harvest_and_send_custom_event_data, CUSTOM_EVENT)
         end
 
-        ERROR_EVENT = "ErrorEvent".freeze
+        ERROR_EVENT = 'ErrorEvent'.freeze
         def transmit_error_event_data
           transmit_single_data_type(:harvest_and_send_error_event_data, ERROR_EVENT)
         end
 
-        SPAN_EVENT = "SpanEvent".freeze
+        SPAN_EVENT = 'SpanEvent'.freeze
         def transmit_span_event_data
           transmit_single_data_type(:harvest_and_send_span_event_data, SPAN_EVENT)
         end
 
-        LOG_EVENT = "LogEvent".freeze
+        LOG_EVENT = 'LogEvent'.freeze
         def transmit_log_event_data
           transmit_single_data_type(:harvest_and_send_log_event_data, LOG_EVENT)
         end
@@ -47,7 +47,7 @@ module NewRelic
 
         def transmit_data
           now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          ::NewRelic::Agent.logger.debug("Sending data to New Relic Service")
+          ::NewRelic::Agent.logger.debug('Sending data to New Relic Service')
 
           @events.notify(:before_harvest)
           @service.session do # use http keep-alive

data/lib/new_relic/agent/agent_logger.rb

@@ -13,7 +13,7 @@ module NewRelic
     class AgentLogger
       include LogOnce
 
-      def initialize(root = "", override_logger = nil)
+      def initialize(root = '', override_logger = nil)
         @already_logged_lock = Mutex.new
         clear_already_logged
         create_log(root, override_logger)
@@ -53,13 +53,13 @@ module NewRelic
       # default behavior of backtraces logged at debug, use one of the methods
       # above and pass an Exception as one of the args.
       def log_exception(level, e, backtrace_level = level)
-        @log.send(level, "%p: %s" % [e.class, e.message])
+        @log.send(level, '%p: %s' % [e.class, e.message])
         @log.send(backtrace_level) do
           backtrace = backtrace_from_exception(e)
           if backtrace
             "Debugging backtrace:\n" + backtrace.join("\n  ")
           else
-            "No backtrace available."
+            'No backtrace available.'
           end
         end
       end
@@ -150,11 +150,11 @@ module NewRelic
       end
 
       LOG_LEVELS = {
-        "debug" => ::Logger::DEBUG,
-        "info" => ::Logger::INFO,
-        "warn" => ::Logger::WARN,
-        "error" => ::Logger::ERROR,
-        "fatal" => ::Logger::FATAL
+        'debug' => ::Logger::DEBUG,
+        'info' => ::Logger::INFO,
+        'warn' => ::Logger::WARN,
+        'error' => ::Logger::ERROR,
+        'fatal' => ::Logger::FATAL
       }
 
       def self.log_level_for(level)
@@ -165,7 +165,7 @@ module NewRelic
         @hostname = NewRelic::Agent::Hostname.get
         @prefix = wants_stdout? ? '** [NewRelic]' : ''
         @log.formatter = proc do |severity, timestamp, progname, msg|
-          "#{@prefix}[#{timestamp.strftime("%F %H:%M:%S %z")} #{@hostname} (#{$$})] #{severity} : #{msg}\n"
+          "#{@prefix}[#{timestamp.strftime('%F %H:%M:%S %z')} #{@hostname} (#{$$})] #{severity} : #{msg}\n"
         end
       end
 

data/lib/new_relic/agent/attribute_filter.rb

@@ -124,8 +124,6 @@ module NewRelic
 
       def prep_capture_params_rules(config)
         build_rule(['request.parameters.*'], include_destinations_for_capture_params(config[:capture_params]), true)
-        build_rule(['job.resque.args.*'], include_destinations_for_capture_params(config[:'resque.capture_params']), true)
-        build_rule(['job.sidekiq.args.*'], include_destinations_for_capture_params(config[:'sidekiq.capture_params']), true)
       end
 
       def prep_datastore_rules(config)
@@ -275,8 +273,8 @@ module NewRelic
       attr_reader :attribute_name, :destinations, :is_include, :wildcard
 
       def initialize(attribute_name, destinations, is_include)
-        @attribute_name = attribute_name.sub(/\*$/, "")
-        @wildcard = attribute_name.end_with?("*")
+        @attribute_name = attribute_name.sub(/\*$/, '')
+        @wildcard = attribute_name.end_with?('*')
         @is_include = is_include
         @destinations = is_include ? destinations : ~destinations
       end

data/lib/new_relic/agent/attribute_processing.rb

@@ -7,8 +7,8 @@ module NewRelic
     module AttributeProcessing
       module_function
 
-      EMPTY_HASH_STRING_LITERAL = "{}".freeze
-      EMPTY_ARRAY_STRING_LITERAL = "[]".freeze
+      EMPTY_HASH_STRING_LITERAL = '{}'.freeze
+      EMPTY_ARRAY_STRING_LITERAL = '[]'.freeze
 
       def flatten_and_coerce(object, prefix = nil, result = {}, &blk)
         if object.is_a?(Hash)

data/lib/new_relic/agent/audit_logger.rb

@@ -32,9 +32,9 @@ module NewRelic
 
         @log.info("REQUEST HEADERS: #{headers}")
       rescue StandardError, SystemStackError, SystemCallError => e
-        ::NewRelic::Agent.logger.warn("Failed writing request headers to audit log", e)
+        ::NewRelic::Agent.logger.warn('Failed writing request headers to audit log', e)
       rescue Exception => e
-        ::NewRelic::Agent.logger.warn("Failed writing request headers to audit log with exception. Re-raising in case of interrupt.", e)
+        ::NewRelic::Agent.logger.warn('Failed writing request headers to audit log with exception. Re-raising in case of interrupt.', e)
         raise
       end
 
@@ -50,9 +50,9 @@ module NewRelic
         @log.info("REQUEST: #{uri}")
         @log.info("REQUEST BODY: #{request_body}")
       rescue StandardError, SystemStackError, SystemCallError => e
-        ::NewRelic::Agent.logger.warn("Failed writing to audit log", e)
+        ::NewRelic::Agent.logger.warn('Failed writing to audit log', e)
       rescue Exception => e
-        ::NewRelic::Agent.logger.warn("Failed writing to audit log with exception. Re-raising in case of interrupt.", e)
+        ::NewRelic::Agent.logger.warn('Failed writing to audit log with exception. Re-raising in case of interrupt.', e)
         raise
       end
 
@@ -64,7 +64,7 @@ module NewRelic
         if wants_stdout?
           # Using $stdout global for easier reassignment in testing
           @log = ::Logger.new($stdout)
-          ::NewRelic::Agent.logger.info("Audit log enabled to STDOUT")
+          ::NewRelic::Agent.logger.info('Audit log enabled to STDOUT')
         elsif path = ensure_log_path
           @log = ::Logger.new(path)
           ::NewRelic::Agent.logger.info("Audit log enabled at '#{path}'")

data/lib/new_relic/agent/autostart.rb

@@ -28,7 +28,7 @@ module NewRelic
           !in_denylisted_rake_task?
       end
 
-      COMMA = ",".freeze
+      COMMA = ','.freeze
 
       def denylisted_constants?
         denylisted?(NewRelic::Agent.config[:'autostart.denylisted_constants']) do |name|

data/lib/new_relic/agent/commands/agent_command.rb

@@ -10,8 +10,8 @@ module NewRelic
 
         def initialize(raw_collector_command)
           @id = raw_collector_command[0]
-          @name = raw_collector_command[1]["name"]
-          @arguments = raw_collector_command[1]["arguments"]
+          @name = raw_collector_command[1]['name']
+          @arguments = raw_collector_command[1]['arguments']
         end
       end
     end

data/lib/new_relic/agent/commands/agent_command_router.rb

@@ -29,7 +29,8 @@ module NewRelic
           @handlers['start_profiler'] = proc { |cmd| thread_profiler_session.handle_start_command(cmd) }
           @handlers['stop_profiler'] = proc { |cmd| thread_profiler_session.handle_stop_command(cmd) }
 
-          if event_listener
+          # the following statement needs else branch coverage
+          if event_listener # rubocop:disable Style/SafeNavigation
             event_listener.subscribe(:before_shutdown, &method(:on_before_shutdown))
           end
         end
@@ -77,10 +78,10 @@ module NewRelic
 
         def log_profiles(profiles)
           if profiles.empty?
-            ::NewRelic::Agent.logger.debug("No thread profiles with data found to send.")
+            ::NewRelic::Agent.logger.debug('No thread profiles with data found to send.')
           else
             profile_descriptions = profiles.map { |p| p.to_log_description }
-            ::NewRelic::Agent.logger.debug("Sending thread profiles [#{profile_descriptions.join(", ")}]")
+            ::NewRelic::Agent.logger.debug("Sending thread profiles [#{profile_descriptions.join(', ')}]")
           end
         end
 
@@ -114,7 +115,7 @@ module NewRelic
         end
 
         SUCCESS_RESULT = NewRelic::EMPTY_HASH
-        ERROR_KEY = "error"
+        ERROR_KEY = 'error'
 
         def success
           SUCCESS_RESULT