newrelic_rpm 6.8.0.360 → 8.13.1

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/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'socket'
 require 'net/https'
@@ -8,6 +8,9 @@ require 'net/http'
 require 'logger'
 require 'zlib'
 require 'stringio'
+require 'new_relic/constants'
+require 'new_relic/traced_thread'
+require 'new_relic/coerce'
 require 'new_relic/agent/autostart'
 require 'new_relic/agent/harvester'
 require 'new_relic/agent/hostname'
@@ -15,15 +18,15 @@ require 'new_relic/agent/new_relic_service'
 require 'new_relic/agent/pipe_service'
 require 'new_relic/agent/configuration/manager'
 require 'new_relic/agent/database'
+require 'new_relic/agent/instrumentation/resque/helper'
 require 'new_relic/agent/commands/agent_command_router'
 require 'new_relic/agent/event_listener'
-require 'new_relic/agent/cross_app_monitor'
-require 'new_relic/agent/distributed_trace_monitor'
-require 'new_relic/agent/trace_context_request_monitor'
-require 'new_relic/agent/synthetics_monitor'
+require 'new_relic/agent/distributed_tracing'
+require 'new_relic/agent/monitors'
 require 'new_relic/agent/transaction_event_recorder'
 require 'new_relic/agent/custom_event_aggregator'
 require 'new_relic/agent/span_event_aggregator'
+require 'new_relic/agent/log_event_aggregator'
 require 'new_relic/agent/sampler_collection'
 require 'new_relic/agent/javascript_instrumentor'
 require 'new_relic/agent/vm/monotonic_gc_profiler'
@@ -34,9 +37,13 @@ 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
     # activated.  It collects performance data from ruby applications
     # in realtime as the application runs, and periodically sends that
@@ -46,45 +53,56 @@ module NewRelic
         ::NewRelic::Agent.config
       end
 
-      def initialize
-        @started = false
-        @event_loop = nil
-
-        @service = NewRelicService.new
-
-        @events                    = NewRelic::Agent::EventListener.new
-        @stats_engine              = NewRelic::Agent::StatsEngine.new
-        @transaction_sampler       = NewRelic::Agent::TransactionSampler.new
-        @sql_sampler               = NewRelic::Agent::SqlSampler.new
-        @agent_command_router      = NewRelic::Agent::Commands::AgentCommandRouter.new(@events)
-        @cross_app_monitor         = NewRelic::Agent::CrossAppMonitor.new(@events)
-        @distributed_trace_monitor = NewRelic::Agent::DistributedTraceMonitor.new(@events)
-        @trace_context_monitor     = NewRelic::Agent::TraceContextRequestMonitor.new(@events)
-        @synthetics_monitor        = NewRelic::Agent::SyntheticsMonitor.new(@events)
-        @error_collector           = NewRelic::Agent::ErrorCollector.new @events
-        @transaction_rules         = NewRelic::Agent::RulesEngine.new
-        @harvest_samplers          = NewRelic::Agent::SamplerCollection.new(@events)
-        @monotonic_gc_profiler     = NewRelic::Agent::VM::MonotonicGCProfiler.new
-        @javascript_instrumentor   = NewRelic::Agent::JavascriptInstrumentor.new(@events)
-        @adaptive_sampler          = NewRelic::Agent::AdaptiveSampler.new(self.class.config[:sampling_target],
-                                                                          self.class.config[:sampling_target_period_in_seconds])
-
-        @harvester       = NewRelic::Agent::Harvester.new(@events)
-        @after_fork_lock = Mutex.new
+      include NewRelic::Agent::StartWorkerThread
+      include NewRelic::Agent::SpecialStartup
+      include NewRelic::Agent::Startup
+      include NewRelic::Agent::Shutdown
 
-        @transaction_event_recorder = NewRelic::Agent::TransactionEventRecorder.new @events
-        @custom_event_aggregator    = NewRelic::Agent::CustomEventAggregator.new @events
-        @span_event_aggregator      = NewRelic::Agent::SpanEventAggregator.new @events
+      def initialize
+        init_basics
+        init_components
+        init_event_handlers
+        setup_attribute_filter
+      end
 
-        @connect_state      = :pending
-        @connect_attempts   = 0
-        @waited_on_connect  = nil
-        @connected_pid      = nil
+      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
 
-        setup_attribute_filter
+      def init_components
+        @service = NewRelicService.new
+        @events = EventListener.new
+        @stats_engine = StatsEngine.new
+        @transaction_sampler = TransactionSampler.new
+        @sql_sampler = SqlSampler.new
+        @transaction_rules = RulesEngine.new
+        @monotonic_gc_profiler = VM::MonotonicGCProfiler.new
+        @adaptive_sampler = AdaptiveSampler.new(Agent.config[:sampling_target],
+          Agent.config[:sampling_target_period_in_seconds])
+      end
+
+      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
@@ -95,8 +113,10 @@ module NewRelic
         end
       end
 
+      public
+
       def refresh_attribute_filter
-        @attribute_filter = NewRelic::Agent::AttributeFilter.new(NewRelic::Agent.config)
+        @attribute_filter = AttributeFilter.new(Agent.config)
       end
 
       # contains all the class-level methods for NewRelic::Agent::Agent
@@ -111,7 +131,6 @@ module NewRelic
       # Holds all the methods defined on NewRelic::Agent::Agent
       # instances
       module InstanceMethods
-
         # the statistics engine that holds all the timeslice data
         attr_reader :stats_engine
         # the transaction sampler that handles recording transactions
@@ -129,23 +148,27 @@ module NewRelic
         # cross application tracing ids and encoding
         attr_reader :cross_process_id
         attr_reader :cross_app_encoding_bytes
-        attr_reader :cross_app_monitor
         # service for communicating with collector
         attr_accessor :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.
         attr_reader :events
+
+        # listens and responds to events that need to process headers
+        # for synthetics and distributed tracing
+        attr_reader :monitors
         # Transaction and metric renaming rules as provided by the
         # 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
         attr_reader :custom_event_aggregator
         attr_reader :span_event_aggregator
+        attr_reader :log_event_aggregator
         attr_reader :transaction_event_recorder
         attr_reader :attribute_filter
         attr_reader :adaptive_sampler
@@ -167,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
@@ -182,69 +205,51 @@ module NewRelic
         # * <tt>:keep_retrying => false</tt> if we try to initiate a new
         #   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={})
+        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)
-          @service = NewRelic::Agent::PipeService.new(channel_id)
+          @service = PipeService.new(channel_id)
           if connected?
             @connected_pid = Process.pid
           else
             ::NewRelic::Agent.logger.debug("Child process #{Process.pid} not reporting to non-connected parent (process #{Process.ppid}).")
-            @service.shutdown(Time.now)
+            @service.shutdown
             disconnect
           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
-          NewRelic::Agent.config.remove_config_type(:manual)
-          NewRelic::Agent.config.remove_config_type(:server)
-        end
-
-        def stop_event_loop
-          @event_loop.stop if @event_loop
+          Agent.config.remove_config_type(:manual)
+          Agent.config.remove_config_type(:server)
         end
 
         def trap_signals_for_litespeed
@@ -256,20 +261,10 @@ 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
-        def set_record_sql(should_record) #THREAD_LOCAL_ACCESS
+        def set_record_sql(should_record) # THREAD_LOCAL_ACCESS
           state = Tracer.state
           prev = state.record_sql
           state.record_sql = should_record
@@ -280,266 +275,16 @@ module NewRelic
         # thread. This uses a stack which allows us to disable tracing
         # children of a transaction without affecting the tracing of
         # the whole transaction
-        def push_trace_execution_flag(should_trace=false) #THREAD_LOCAL_ACCESS
+        def push_trace_execution_flag(should_trace = false) # THREAD_LOCAL_ACCESS
           Tracer.state.push_traced(should_trace)
         end
 
         # Pop the current trace execution status.  Restore trace execution status
         # to what it was before we pushed the current flag.
-        def pop_trace_execution_flag #THREAD_LOCAL_ACCESS
+        def pop_trace_execution_flag # THREAD_LOCAL_ACCESS
           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?
-            (
-              Agent.config[:send_data_on_exit]  &&
-              !sinatra_classic_app?
-            )
-          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?
-            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::LanguageSupport.can_fork? &&
-              !NewRelic::Agent::PipeChannelManager.listener.started?
-          end
-
-          def in_resque_child_process?
-            defined?(@service) && @service.is_a?(NewRelic::Agent::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!
@@ -548,6 +293,7 @@ module NewRelic
           @transaction_event_recorder.drop_buffered_data
           @custom_event_aggregator.reset!
           @span_event_aggregator.reset!
+          @log_event_aggregator.reset!
           @sql_sampler.reset!
 
           if Agent.config[:clear_transaction_state_after_fork]
@@ -559,159 +305,17 @@ module NewRelic
         # This is necessary for cases where we're in a forked child and Ruby
         # might be holding locks for background thread that aren't there anymore.
         def reset_objects_with_locks
-          @stats_engine = NewRelic::Agent::StatsEngine.new
+          @stats_engine = StatsEngine.new
         end
 
         def flush_pipe_data
-          if connected? && @service.is_a?(::NewRelic::Agent::PipeService)
-            transmit_data
-            transmit_analytic_event_data
-            transmit_custom_event_data
-            transmit_error_event_data
-            transmit_span_event_data
+          if connected? && @service.is_a?(PipeService)
+            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
-
-          ANALYTIC_EVENT_DATA = "analytic_event_data".freeze
-          CUSTOM_EVENT_DATA = "custom_event_data".freeze
-          ERROR_EVENT_DATA = "error_event_data".freeze
-          SPAN_EVENT_DATA = "span_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 ANALYTIC_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(: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 = NewRelic::Agent::Threading::AgentThread.create('Worker Loop') do
-            deferred_work!(connection_options)
-          end
-        end
-
         # A shorthand for NewRelic::Control.instance
         def control
           NewRelic::Control.instance
@@ -742,7 +346,7 @@ module NewRelic
           # Don't connect if we're already connected, or if we tried to connect
           # and were rejected with prejudice because of a license issue, unless
           # we're forced to by force_reconnect.
-          def should_connect?(force=false)
+          def should_connect?(force = false)
             force || (!connected? && !disconnected?)
           end
 
@@ -750,10 +354,8 @@ module NewRelic
           # /agents/agent-specs/Collector-Response-Handling.md, retry
           # connections after a specific backoff sequence to prevent
           # hammering the server.
-          CONNECT_RETRY_PERIODS = [15, 15, 30, 60, 120, 300]
-
           def connect_retry_period
-            CONNECT_RETRY_PERIODS[connect_attempts] || 300
+            NewRelic::CONNECT_RETRY_PERIODS[connect_attempts] || NewRelic::MAX_RETRY_PERIOD
           end
 
           def note_connect_failure
@@ -764,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
@@ -777,7 +379,8 @@ 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
 
@@ -806,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
@@ -870,26 +474,26 @@ module NewRelic
               raise WaitOnConnectTimeout, "Agent was unable to connect in #{timeout} seconds."
             end
           end
-
         end
         include Connect
 
         def container_for_endpoint(endpoint)
           case endpoint
-          when :metric_data             then @stats_engine
+          when :metric_data then @stats_engine
           when :transaction_sample_data then @transaction_sampler
-          when :error_data              then @error_collector.error_trace_aggregator
-          when :error_event_data        then @error_collector.error_event_aggregator
-          when :analytic_event_data     then transaction_event_aggregator
-          when :custom_event_data       then @custom_event_aggregator
-          when :span_event_data         then span_event_aggregator
-          when :sql_trace_data          then @sql_sampler
+          when :error_data then @error_collector.error_trace_aggregator
+          when :error_event_data then @error_collector.error_event_aggregator
+          when :analytic_event_data then transaction_event_aggregator
+          when :custom_event_data then @custom_event_aggregator
+          when :span_event_data then span_event_aggregator
+          when :sql_trace_data then @sql_sampler
+          when :log_event_data then @log_event_aggregator
           end
         end
 
         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
@@ -920,16 +524,11 @@ module NewRelic
         #   This is useful primarily when re-establishing a new connection after
         #   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)
-
+        def connect(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
@@ -941,19 +540,34 @@ module NewRelic
         rescue NewRelic::Agent::UnrecoverableAgentException => e
           handle_unrecoverable_agent_error(e)
         rescue StandardError, Timeout::Error, NewRelic::Agent::ServerConnectionException => e
-          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
+          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
 
+        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)
+          return false unless opts[:keep_retrying]
+
+          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
         # directory of this project
         def determine_home_directory
@@ -979,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
@@ -1024,7 +638,7 @@ module NewRelic
         end
 
         def harvest_and_send_timeslice_data
-          NewRelic::Agent::TransactionTimeAggregator.harvest!
+          TransactionTimeAggregator.harvest!
           harvest_and_send_from_container(@stats_engine, :metric_data)
         end
 
@@ -1052,7 +666,7 @@ module NewRelic
 
         def harvest_and_send_analytic_event_data
           harvest_and_send_from_container(transaction_event_aggregator, :analytic_event_data)
-          harvest_and_send_from_container(synthetics_event_aggregator,  :analytic_event_data)
+          harvest_and_send_from_container(synthetics_event_aggregator, :analytic_event_data)
         end
 
         def harvest_and_send_custom_event_data
@@ -1060,13 +674,17 @@ 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
           harvest_and_send_from_container(span_event_aggregator, :span_event_data)
         end
 
+        def harvest_and_send_log_event_data
+          harvest_and_send_from_container(@log_event_aggregator, :log_event_data)
+        end
+
         def check_for_and_handle_agent_commands
           begin
             @agent_command_router.check_for_and_handle_agent_commands
@@ -1107,39 +725,39 @@ module NewRelic
           transmit_single_data_type(:harvest_and_send_span_event_data, SPAN_EVENT)
         end
 
+        LOG_EVENT = "LogEvent".freeze
+        def transmit_log_event_data
+          transmit_single_data_type(:harvest_and_send_log_event_data, LOG_EVENT)
+        end
+
         def transmit_single_data_type(harvest_method, supportability_name)
-          now = Time.now
+          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)
           end
         ensure
-          duration = (Time.now - now).to_f
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - now
           NewRelic::Agent.record_metric("Supportability/#{supportability_name}Harvest", duration)
         end
 
         def transmit_data
-          now = Time.now
-          ::NewRelic::Agent.logger.debug "Sending data to New Relic Service"
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          ::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_data_types
 
             check_for_and_handle_agent_commands
             harvest_and_send_for_agent_commands
           end
         ensure
           NewRelic::Agent::Database.close_connections
-          duration = (Time.now - now).to_f
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - now
           NewRelic::Agent.record_metric('Supportability/Harvest', duration)
         end
 
@@ -1156,28 +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
-
-              if @connected_pid == $$ && !@service.kind_of?(NewRelic::Agent::NewRelicService)
-                ::NewRelic::Agent.logger.debug "Sending New Relic service agent run shutdown message"
-                @service.shutdown(Time.now.to_f)
-              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