newrelic_rpm 8.7.0 → 8.11.0

data/lib/new_relic/agent/agent.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'socket'
 require 'net/https'
@@ -37,6 +37,11 @@ require 'new_relic/agent/adaptive_sampler'
 require 'new_relic/agent/connect/request_builder'
 require 'new_relic/agent/connect/response_handler'
 
+require 'new_relic/agent/agent/start_worker_thread'
+require 'new_relic/agent/agent/startup'
+require 'new_relic/agent/agent/special_startup'
+require 'new_relic/agent/agent/shutdown'
+
 module NewRelic
   module Agent
     # The Agent is a singleton that is instantiated when the plugin is
@@ -48,44 +53,56 @@ module NewRelic
         ::NewRelic::Agent.config
       end
 
+      include NewRelic::Agent::StartWorkerThread
+      include NewRelic::Agent::SpecialStartup
+      include NewRelic::Agent::Startup
+      include NewRelic::Agent::Shutdown
+
       def initialize
+        init_basics
+        init_components
+        init_event_handlers
+        setup_attribute_filter
+      end
+
+      private
+
+      def init_basics
         @started = false
         @event_loop = nil
         @worker_thread = nil
+        @connect_state = :pending
+        @connect_attempts = 0
+        @waited_on_connect = nil
+        @connected_pid = nil
+        @wait_on_connect_mutex = Mutex.new
+        @after_fork_lock = Mutex.new
+        @wait_on_connect_condition = ConditionVariable.new
+      end
 
+      def init_components
         @service = NewRelicService.new
-
         @events = EventListener.new
         @stats_engine = StatsEngine.new
         @transaction_sampler = TransactionSampler.new
         @sql_sampler = SqlSampler.new
-        @agent_command_router = Commands::AgentCommandRouter.new @events
-        @monitors = Monitors.new @events
-        @error_collector = ErrorCollector.new @events
         @transaction_rules = RulesEngine.new
-        @harvest_samplers = SamplerCollection.new @events
         @monotonic_gc_profiler = VM::MonotonicGCProfiler.new
-        @javascript_instrumentor = JavascriptInstrumentor.new @events
         @adaptive_sampler = AdaptiveSampler.new(Agent.config[:sampling_target],
           Agent.config[:sampling_target_period_in_seconds])
+      end
 
-        @harvester = Harvester.new @events
-        @after_fork_lock = Mutex.new
-
-        @transaction_event_recorder = TransactionEventRecorder.new @events
-        @custom_event_aggregator = CustomEventAggregator.new @events
-        @span_event_aggregator = SpanEventAggregator.new @events
-        @log_event_aggregator = LogEventAggregator.new @events
-
-        @connect_state = :pending
-        @connect_attempts = 0
-        @waited_on_connect = nil
-        @connected_pid = nil
-
-        @wait_on_connect_mutex = Mutex.new
-        @wait_on_connect_condition = ConditionVariable.new
-
-        setup_attribute_filter
+      def init_event_handlers
+        @agent_command_router = Commands::AgentCommandRouter.new(@events)
+        @monitors = Monitors.new(@events)
+        @error_collector = ErrorCollector.new(@events)
+        @harvest_samplers = SamplerCollection.new(@events)
+        @javascript_instrumentor = JavaScriptInstrumentor.new(@events)
+        @harvester = Harvester.new(@events)
+        @transaction_event_recorder = TransactionEventRecorder.new(@events)
+        @custom_event_aggregator = CustomEventAggregator.new(@events)
+        @span_event_aggregator = SpanEventAggregator.new(@events)
+        @log_event_aggregator = LogEventAggregator.new(@events)
       end
 
       def setup_attribute_filter
@@ -96,6 +113,8 @@ module NewRelic
         end
       end
 
+      public
+
       def refresh_attribute_filter
         @attribute_filter = AttributeFilter.new(Agent.config)
       end
@@ -143,7 +162,7 @@ module NewRelic
         # collector on connect.  The former are applied during txns,
         # the latter during harvest.
         attr_accessor :transaction_rules
-        # Responsbile for restarting the harvest thread
+        # 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
@@ -171,7 +190,7 @@ module NewRelic
         # It assumes the parent process initialized the agent, but does
         # not assume the agent started.
         #
-        # The call is idempotent, but not re-entrant.
+        # The call is idempotent, but not reentrant.
         #
         # * It clears any metrics carried over from the parent process
         # * Restarts the sampler thread if necessary
@@ -187,28 +206,34 @@ module NewRelic
         #   connection, this tells me to only try it once so this method returns
         #   quickly if there is some kind of latency with the server.
         def after_fork(options = {})
+          return unless needs_after_fork_work?
+
+          ::NewRelic::Agent.logger.debug("Starting the worker thread in #{Process.pid} (parent #{Process.ppid}) after forking.")
+
+          channel_id = options[:report_to_channel]
+          install_pipe_service(channel_id) if channel_id
+
+          # Clear out locks and stats left over from parent process
+          reset_objects_with_locks
+          drop_buffered_data
+
+          setup_and_start_agent(options)
+        end
+
+        def needs_after_fork_work?
           needs_restart = false
           @after_fork_lock.synchronize do
             needs_restart = @harvester.needs_restart?
             @harvester.mark_started
           end
 
-          return if !needs_restart ||
+          return false if !needs_restart ||
             !Agent.config[:agent_enabled] ||
             !Agent.config[:monitor_mode] ||
             disconnected? ||
             !control.security_settings_valid?
 
-          ::NewRelic::Agent.logger.debug "Starting the worker thread in #{Process.pid} (parent #{Process.ppid}) after forking."
-
-          channel_id = options[:report_to_channel]
-          install_pipe_service(channel_id) if channel_id
-
-          # Clear out locks and stats left over from parent process
-          reset_objects_with_locks
-          drop_buffered_data
-
-          setup_and_start_agent(options)
+          true
         end
 
         def install_pipe_service(channel_id)
@@ -222,48 +247,11 @@ module NewRelic
           end
         end
 
-        # True if we have initialized and completed 'start'
-        def started?
-          @started
-        end
-
-        # Attempt a graceful shutdown of the agent, flushing any remaining
-        # data.
-        def shutdown
-          return unless started?
-          ::NewRelic::Agent.logger.info "Starting Agent shutdown"
-
-          stop_event_loop
-          trap_signals_for_litespeed
-          untraced_graceful_disconnect
-          revert_to_default_configuration
-
-          @started = nil
-          Control.reset
-        end
-
         def revert_to_default_configuration
           Agent.config.remove_config_type(:manual)
           Agent.config.remove_config_type(:server)
         end
 
-        # If the @worker_thread encounters an error during the attempt to connect to the collector
-        # then the connect attempts enter an exponential backoff retry loop.  To avoid potential
-        # race conditions with shutting down while also attempting to reconnect, we join the
-        # @worker_thread with a timeout threshold.  This allows potentially connecting and flushing
-        # pending data to the server, but without waiting indefinitely for a reconnect to succeed.
-        # 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
-          # 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"
-            end
-          end
-        end
-
         def trap_signals_for_litespeed
           # if litespeed, then ignore all future SIGUSR1 - it's
           # litespeed trying to shut us down
@@ -273,16 +261,6 @@ module NewRelic
           end
         end
 
-        def untraced_graceful_disconnect
-          begin
-            NewRelic::Agent.disable_all_tracing do
-              graceful_disconnect
-            end
-          rescue => e
-            ::NewRelic::Agent.logger.error e
-          end
-        end
-
         # Sets a thread local variable as to whether we should or
         # should not record sql in the current thread. Returns the
         # previous value, if there is one
@@ -307,255 +285,6 @@ module NewRelic
           Tracer.state.pop_traced
         end
 
-        # Herein lies the corpse of the former 'start' method. May
-        # its unmatched flog score rest in pieces.
-        module Start
-          # Check whether we have already started, which is an error condition
-          def already_started?
-            if started?
-              ::NewRelic::Agent.logger.error("Agent Started Already!")
-              true
-            end
-          end
-
-          # The agent is disabled when it is not force enabled by the
-          # 'agent_enabled' option (e.g. in a manual start), or
-          # enabled normally through the configuration file
-          def disabled?
-            !Agent.config[:agent_enabled]
-          end
-
-          # Log startup information that we almost always want to know
-          def log_startup
-            log_environment
-            log_dispatcher
-            log_app_name
-          end
-
-          # Log the environment the app thinks it's running in.
-          # Useful in debugging, as this is the key for config YAML lookups.
-          def log_environment
-            ::NewRelic::Agent.logger.info "Environment: #{NewRelic::Control.instance.env}"
-          end
-
-          # Logs the dispatcher to the log file to assist with
-          # debugging. When no debugger is present, logs this fact to
-          # assist with proper dispatcher detection
-          def log_dispatcher
-            dispatcher_name = Agent.config[:dispatcher].to_s
-
-            if dispatcher_name.empty?
-              ::NewRelic::Agent.logger.info 'No known dispatcher detected.'
-            else
-              ::NewRelic::Agent.logger.info "Dispatcher: #{dispatcher_name}"
-            end
-          end
-
-          def log_app_name
-            ::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(", ")}."
-            end
-          end
-
-          # Logs the configured application names
-          def app_name_configured?
-            names = Agent.config[:app_name]
-            return names.respond_to?(:any?) && names.any?
-          end
-
-          # Connecting in the foreground blocks further startup of the
-          # agent until we have a connection - useful in cases where
-          # you're trying to log a very-short-running process and want
-          # to get statistics from before a server connection
-          # (typically 20 seconds) exists
-          def connect_in_foreground
-            NewRelic::Agent.disable_all_tracing { connect(:keep_retrying => false) }
-          end
-
-          # This matters when the following three criteria are met:
-          #
-          # 1. A Sinatra 'classic' application is being run
-          # 2. The app is being run by executing the main file directly, rather
-          #    than via a config.ru file.
-          # 3. newrelic_rpm is required *after* sinatra
-          #
-          # In this case, the entire application runs from an at_exit handler in
-          # Sinatra, and if we were to install ours, it would be executed before
-          # the one in Sinatra, meaning that we'd shutdown the agent too early
-          # and never collect any data.
-          def sinatra_classic_app?
-            (
-              defined?(Sinatra::Application) &&
-              Sinatra::Application.respond_to?(:run) &&
-              Sinatra::Application.run?
-            )
-          end
-
-          def should_install_exit_handler?
-            return false unless Agent.config[:send_data_on_exit]
-            !sinatra_classic_app? || Agent.config[:force_install_exit_handler]
-          end
-
-          def install_exit_handler
-            return unless should_install_exit_handler?
-            NewRelic::Agent.logger.debug("Installing at_exit handler")
-            at_exit { shutdown }
-          end
-
-          # Classy logging of the agent version and the current pid,
-          # so we can disambiguate processes in the log file and make
-          # sure they're running a reasonable version
-          def log_version_and_pid
-            ::NewRelic::Agent.logger.debug "New Relic Ruby Agent #{NewRelic::VERSION::STRING} Initialized: pid = #{$$}"
-          end
-
-          # Warn the user if they have configured their agent not to
-          # send data, that way we can see this clearly in the log file
-          def monitoring?
-            if Agent.config[:monitor_mode]
-              true
-            else
-              ::NewRelic::Agent.logger.warn('Agent configured not to send data in this environment.')
-              false
-            end
-          end
-
-          # Tell the user when the license key is missing so they can
-          # fix it by adding it to the file
-          def has_license_key?
-            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 environment, '#{NewRelic::Control.instance.env}'. You may also want to try linting your newrelic.yml to ensure it is valid YML.")
-              false
-            end
-          end
-
-          # A correct license key exists and is of the proper length
-          def has_correct_license_key?
-            has_license_key? && correct_license_length
-          end
-
-          # A license key is an arbitrary 40 character string,
-          # usually looks something like a SHA1 hash
-          def correct_license_length
-            key = Agent.config[:license_key]
-
-            if key.length == 40
-              true
-            else
-              ::NewRelic::Agent.logger.error("Invalid license key: #{key}")
-              false
-            end
-          end
-
-          # If we're using a dispatcher that forks before serving
-          # 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 #{Agent.config[:dispatcher]} may fork."
-              true
-            else
-              false
-            end
-          end
-
-          # Return true if we're using resque and it hasn't had a chance to (potentially)
-          # daemonize itself. This avoids hanging when there's a Thread started
-          # before Resque calls Process.daemon (Jira RUBY-857)
-          def defer_for_resque?
-            NewRelic::Agent.config[:dispatcher] == :resque &&
-              NewRelic::Agent::Instrumentation::Resque::Helper.resque_fork_per_job? &&
-              !PipeChannelManager.listener.started?
-          end
-
-          def in_resque_child_process?
-            defined?(@service) && @service.is_a?(PipeService)
-          end
-
-          # Sanity-check the agent configuration and start the agent,
-          # setting up the worker thread and the exit handler to shut
-          # down the agent
-          def check_config_and_start_agent
-            return unless monitoring? && has_correct_license_key?
-            return if using_forking_dispatcher?
-            setup_and_start_agent
-          end
-
-          # This is the shared method between the main agent startup and the
-          # after_fork call restarting the thread in deferred dispatchers.
-          #
-          # Treatment of @started and env report is important to get right.
-          def setup_and_start_agent(options = {})
-            @started = true
-            @harvester.mark_started
-
-            unless in_resque_child_process?
-              install_exit_handler
-              environment_for_connect
-              @harvest_samplers.load_samplers unless Agent.config[:disable_samplers]
-            end
-
-            connect_in_foreground if Agent.config[:sync_startup]
-            start_worker_thread(options)
-          end
-        end
-
-        include Start
-
-        def defer_for_delayed_job?
-          NewRelic::Agent.config[:dispatcher] == :delayed_job &&
-            !NewRelic::DelayedJobInjection.worker_name
-        end
-
-        # Check to see if the agent should start, returning +true+ if it should.
-        def agent_should_start?
-          return false if already_started? || disabled?
-
-          if defer_for_delayed_job?
-            ::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"
-            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 ",
-              "value set for app_name in the #{NewRelic::Control.instance.env} ",
-              "environment."
-            return false
-          end
-
-          return true
-        end
-
-        # Logs a bunch of data and starts the agent, if needed
-        def start
-          return unless agent_should_start?
-
-          log_startup
-          check_config_and_start_agent
-          log_version_and_pid
-
-          events.subscribe(:initial_configuration_complete) do
-            log_ignore_url_regexes
-          end
-        end
-
         # Clear out the metric data, errors, and transaction traces, etc.
         def drop_buffered_data
           @stats_engine.reset!
@@ -581,160 +310,12 @@ module NewRelic
 
         def flush_pipe_data
           if connected? && @service.is_a?(PipeService)
-            transmit_data
-            transmit_analytic_event_data
-            transmit_custom_event_data
-            transmit_error_event_data
-            transmit_span_event_data
-            transmit_log_event_data
+            transmit_data_types
           end
         end
 
         private
 
-        # All of this module used to be contained in the
-        # start_worker_thread method - this is an artifact of
-        # refactoring and can be moved, renamed, etc at will
-        module StartWorkerThread
-          def create_event_loop
-            EventLoop.new
-          end
-
-          LOG_ONCE_KEYS_RESET_PERIOD = 60.0
-
-          # Certain event types may sometimes need to be on the same interval as metrics,
-          # so we will check config assigned in EventHarvestConfig to determine the interval
-          # on which to report them
-          def interval_for event_type
-            interval = Agent.config[:"event_report_period.#{event_type}"]
-            :"#{interval}_second_harvest"
-          end
-
-          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
-
-          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
-            @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)
-
-            @event_loop.run
-          end
-
-          # Handles the case where the server tells us to restart -
-          # this clears the data, clears connection attempts, and
-          # waits a while to reconnect.
-          def handle_force_restart(error)
-            ::NewRelic::Agent.logger.debug error.message
-            drop_buffered_data
-            @service.force_restart if @service
-            @connect_state = :pending
-            sleep 30
-          end
-
-          # when a disconnect is requested, stop the current thread, which
-          # 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. (#{error.message})"
-            disconnect
-          end
-
-          # Handles an unknown error in the worker thread by logging
-          # 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."
-            # 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)
-            disconnect
-          end
-
-          # a wrapper method to handle all the errors that can happen
-          # in the connection and worker thread system. This
-          # guarantees a no-throw from the background thread.
-          def catch_errors
-            yield
-          rescue NewRelic::Agent::ForceRestartException => e
-            handle_force_restart(e)
-            retry
-          rescue NewRelic::Agent::ForceDisconnectException => e
-            handle_force_disconnect(e)
-          rescue => e
-            handle_other_error(e)
-          end
-
-          # This is the method that is run in a new thread in order to
-          # background the harvesting and sending of data during the
-          # normal operation of the agent.
-          #
-          # Takes connection options that determine how we should
-          # connect to the server, and loops endlessly - typically we
-          # never return from this method unless we're shutting down
-          # the agent
-          def deferred_work!(connection_options)
-            catch_errors do
-              NewRelic::Agent.disable_all_tracing do
-                connect(connection_options)
-                if connected?
-                  create_and_run_event_loop
-                  # never reaches here unless there is a problem or
-                  # the agent is exiting
-                else
-                  ::NewRelic::Agent.logger.debug "No connection.  Worker thread ending."
-                end
-              end
-            end
-          end
-        end
-        include StartWorkerThread
-
-        # 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 #{disable}"
-            return
-          end
-
-          ::NewRelic::Agent.logger.debug "Creating Ruby Agent worker thread."
-          @worker_thread = Threading::AgentThread.create('Worker Loop') do
-            deferred_work!(connection_options)
-          end
-        end
-
         # A shorthand for NewRelic::Control.instance
         def control
           NewRelic::Control.instance
@@ -785,7 +366,7 @@ module NewRelic
           # to tell the user what happened, since this is not an error
           # we can handle gracefully.
           def log_error(error)
-            ::NewRelic::Agent.logger.error "Error establishing connection with New Relic Service at #{control.server}:", error
+            ::NewRelic::Agent.logger.error("Error establishing connection with New Relic Service at #{control.server}:", error)
           end
 
           # When the server sends us an error with the license key, we
@@ -828,26 +409,27 @@ module NewRelic
           # connects, then configures the agent using the response from
           # the connect service
           def connect_to_server
-            request_builder = ::NewRelic::Agent::Connect::RequestBuilder.new \
+            request_builder = ::NewRelic::Agent::Connect::RequestBuilder.new( \
               @service,
               Agent.config,
               event_harvest_config,
               environment_for_connect
-            connect_response = @service.connect request_builder.connect_payload
+            )
+            connect_response = @service.connect(request_builder.connect_payload)
 
             response_handler = ::NewRelic::Agent::Connect::ResponseHandler.new(self, Agent.config)
             response_handler.configure_agent(connect_response)
 
-            log_connection connect_response if connect_response
+            log_connection(connect_response) if connect_response
             connect_response
           end
 
           # Logs when we connect to the server, for debugging purposes
           # - makes sure we know if an agent has not connected
           def log_connection(config_data)
-            ::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}"
+            ::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?
               log_collector_messages(config_data['messages'])
             end
@@ -911,7 +493,7 @@ module NewRelic
 
         def merge_data_for_endpoint(endpoint, data)
           if data && !data.empty?
-            container = container_for_endpoint endpoint
+            container = container_for_endpoint(endpoint)
             if container.respond_to?(:has_metadata?) && container.has_metadata?
               container_for_endpoint(endpoint).merge!(data, false)
             else
@@ -943,15 +525,10 @@ module NewRelic
         #   forking off from a parent process.
         #
         def connect(options = {})
-          defaults = {
-            :keep_retrying => Agent.config[:keep_retrying],
-            :force_reconnect => Agent.config[:force_reconnect]
-          }
-          opts = defaults.merge(options)
-
+          opts = connect_options(options)
           return unless should_connect?(opts[:force_reconnect])
 
-          ::NewRelic::Agent.logger.debug "Connecting Process to New Relic: #$0"
+          ::NewRelic::Agent.logger.debug("Connecting Process to New Relic: #$0")
           connect_to_server
           @connected_pid = $$
           @connect_state = :connected
@@ -963,21 +540,32 @@ module NewRelic
         rescue NewRelic::Agent::UnrecoverableAgentException => e
           handle_unrecoverable_agent_error(e)
         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)
+
+          raise
+        end
+
+        def connect_options(options)
+          {
+            keep_retrying: Agent.config[:keep_retrying],
+            force_reconnect: Agent.config[:force_reconnect]
+          }.merge(options)
+        end
+
+        def retry_from_error?(e, opts)
           # Allow a killed (aborting) thread to continue exiting during shutdown.
           # See: https://github.com/newrelic/newrelic-ruby-agent/issues/340
           raise if Thread.current.status == 'aborting'
 
           log_error(e)
-          if opts[:keep_retrying]
-            note_connect_failure
-            ::NewRelic::Agent.logger.info "Will re-attempt in #{connect_retry_period} seconds"
-            sleep connect_retry_period
-            retry
-          end
-        rescue Exception => e
-          ::NewRelic::Agent.logger.error "Exception of unexpected type during Agent#connect():", e
+          return false unless opts[:keep_retrying]
 
-          raise
+          note_connect_failure
+          ::NewRelic::Agent.logger.info("Will re-attempt in #{connect_retry_period} seconds")
+          sleep(connect_retry_period)
+          true
         end
 
         # Delegates to the control class to determine the root
@@ -1005,14 +593,14 @@ module NewRelic
         #
         def harvest_and_send_from_container(container, endpoint)
           payload = harvest_from_container(container, endpoint)
-          sample_count = harvest_size container, payload
+          sample_count = harvest_size(container, payload)
           if sample_count > 0
             NewRelic::Agent.logger.debug("Sending #{sample_count} items to #{endpoint}")
             send_data_to_endpoint(endpoint, payload, container)
           end
         end
 
-        def harvest_size container, items
+        def harvest_size(container, items)
           if container.respond_to?(:has_metadata?) && container.has_metadata? && !items.empty?
             items.last.size
           else
@@ -1086,7 +674,7 @@ module NewRelic
         end
 
         def harvest_and_send_error_event_data
-          harvest_and_send_from_container @error_collector.error_event_aggregator, :error_event_data
+          harvest_and_send_from_container(@error_collector.error_event_aggregator, :error_event_data)
         end
 
         def harvest_and_send_span_event_data
@@ -1146,7 +734,7 @@ module NewRelic
           now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
           msg = "Sending #{supportability_name} data to New Relic Service"
-          ::NewRelic::Agent.logger.debug msg
+          ::NewRelic::Agent.logger.debug(msg)
 
           @service.session do # use http keep-alive
             self.send(harvest_method)
@@ -1158,17 +746,11 @@ 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
-            harvest_and_send_errors
-            harvest_and_send_error_event_data
-            harvest_and_send_transaction_traces
-            harvest_and_send_slowest_sql
-            harvest_and_send_timeslice_data
-            harvest_and_send_span_event_data
-            harvest_and_send_log_event_data
+            harvest_and_send_data_types
 
             check_for_and_handle_agent_commands
             harvest_and_send_for_agent_commands
@@ -1192,29 +774,47 @@ module NewRelic
               @service.request_timeout = 10
 
               @events.notify(:before_shutdown)
-              transmit_data
-              transmit_analytic_event_data
-              transmit_custom_event_data
-              transmit_error_event_data
-              transmit_span_event_data
-              transmit_log_event_data
-
-              if @connected_pid == $$ && !@service.kind_of?(NewRelic::Agent::NewRelicService)
-                ::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"
-              end
-              ::NewRelic::Agent.logger.debug "Graceful disconnect complete"
+              transmit_data_types
+              shutdown_service
+
+              ::NewRelic::Agent.logger.debug("Graceful disconnect complete")
             rescue Timeout::Error, StandardError => e
-              ::NewRelic::Agent.logger.debug "Error when disconnecting #{e.class.name}: #{e.message}"
+              ::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
       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")
+          @service.shutdown
+        else
+          ::NewRelic::Agent.logger.debug("This agent connected from parent process #{@connected_pid}--not sending shutdown")
+        end
+      end
+
+      def transmit_data_types
+        transmit_data
+        transmit_analytic_event_data
+        transmit_custom_event_data
+        transmit_error_event_data
+        transmit_span_event_data
+        transmit_log_event_data
+      end
+
+      def harvest_and_send_data_types
+        harvest_and_send_errors
+        harvest_and_send_error_event_data
+        harvest_and_send_transaction_traces
+        harvest_and_send_slowest_sql
+        harvest_and_send_timeslice_data
+        harvest_and_send_span_event_data
+        harvest_and_send_log_event_data
+      end
+
       extend ClassMethods
       include InstanceMethods
     end