newrelic_rpm 4.8.0.341 → 6.13.1

data/lib/new_relic/agent/adaptive_sampler.rb

@@ -0,0 +1,104 @@
+# 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.
+
+module NewRelic
+  module Agent
+    class AdaptiveSampler
+
+      def initialize target_samples = 10, period_duration = 60
+        @target = target_samples
+        @seen = 0
+        @seen_last = 0
+        @sampled_count = 0
+        @period_duration = period_duration
+        @first_period = true
+        @period_start = Time.now.to_f
+        @lock = Mutex.new
+        register_config_callbacks
+      end
+
+      # Called at the beginning of each transaction, increments seen and
+      # returns a boolean indicating if we should mark the transaction as
+      # sampled. This uses the adaptive sampling algorithm.
+      def sampled?
+        @lock.synchronize do
+          reset_if_period_expired!
+          sampled = if @first_period
+            @sampled_count < 10
+          elsif @sampled_count < @target
+            rand(@seen_last) < @target
+          else
+            rand(@seen) < (@target ** (@target / @sampled_count) - @target ** 0.5)
+          end
+
+          @sampled_count += 1 if sampled
+          @seen += 1
+
+          sampled
+        end
+      end
+
+      def stats
+        @lock.synchronize do
+          {
+            target: @target,
+            seen: @seen,
+            seen_last: @seen_last,
+            sampled_count: @sampled_count
+          }
+        end
+      end
+
+      private
+
+      def reset_if_period_expired!
+        now = Time.now.to_f
+        return unless @period_start + @period_duration <= now
+
+        elapsed_periods = Integer((now - @period_start) / @period_duration)
+        @period_start = @period_start + elapsed_periods * @period_duration
+
+        @first_period = false
+        @seen_last = elapsed_periods > 1 ? 0 : @seen
+        @seen = 0
+        @sampled_count = 0
+      end
+
+      def register_config_callbacks
+        register_sampling_target_callback
+        register_sampling_period_callback
+      end
+
+      def register_sampling_target_callback
+        NewRelic::Agent.config.register_callback(:sampling_target) do |target|
+          target_changed = false
+          @lock.synchronize do
+            if @target != target
+              @target = target
+              target_changed = true
+            end
+          end
+          if target_changed
+            NewRelic::Agent.logger.debug "Sampling target set to: #{target}"
+          end
+        end
+      end
+
+      def register_sampling_period_callback
+        NewRelic::Agent.config.register_callback(:sampling_target_period_in_seconds) do |period_duration|
+          period_changed = false
+          @lock.synchronize do
+            if @period_duration != period_duration
+              @period_duration = period_duration
+              period_changed = true
+            end
+          end
+          if period_changed
+            NewRelic::Agent.logger.debug "Sampling period set to: #{period_duration}"
+          end
+        end
+      end
+    end
+  end
+end

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.
 
 require 'socket'
 require 'net/https'
@@ -8,7 +8,8 @@ require 'net/http'
 require 'logger'
 require 'zlib'
 require 'stringio'
-require 'new_relic/agent/sampled_buffer'
+require 'new_relic/constants'
+require 'new_relic/coerce'
 require 'new_relic/agent/autostart'
 require 'new_relic/agent/harvester'
 require 'new_relic/agent/hostname'
@@ -18,19 +19,20 @@ require 'new_relic/agent/configuration/manager'
 require 'new_relic/agent/database'
 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/synthetics_monitor'
-require 'new_relic/agent/synthetics_event_buffer'
+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/sampler_collection'
 require 'new_relic/agent/javascript_instrumentor'
 require 'new_relic/agent/vm/monotonic_gc_profiler'
 require 'new_relic/agent/utilization_data'
 require 'new_relic/environment_report'
 require 'new_relic/agent/attribute_filter'
-require 'new_relic/agent/throughput_monitor'
+require 'new_relic/agent/adaptive_sampler'
+require 'new_relic/agent/connect/request_builder'
+require 'new_relic/agent/connect/response_handler'
 
 module NewRelic
   module Agent
@@ -47,34 +49,33 @@ module NewRelic
       def initialize
         @started = false
         @event_loop = nil
+        @worker_thread = 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)
-        @synthetics_monitor        = NewRelic::Agent::SyntheticsMonitor.new(@events)
-        @error_collector           = NewRelic::Agent::ErrorCollector.new
-        @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)
-        @throughput_monitor        = NewRelic::Agent::ThroughputMonitor.new
-
-        @harvester       = NewRelic::Agent::Harvester.new(@events)
+        @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])
+
+        @harvester       = Harvester.new @events
         @after_fork_lock = Mutex.new
 
-        @transaction_event_recorder = NewRelic::Agent::TransactionEventRecorder.new
-
-        @custom_event_aggregator      = NewRelic::Agent::CustomEventAggregator.new
+        @transaction_event_recorder = TransactionEventRecorder.new @events
+        @custom_event_aggregator    = CustomEventAggregator.new @events
+        @span_event_aggregator      = SpanEventAggregator.new @events
 
         @connect_state      = :pending
         @connect_attempts   = 0
-        @environment_report = nil
         @waited_on_connect  = nil
         @connected_pid      = nil
 
@@ -87,13 +88,13 @@ module NewRelic
       def setup_attribute_filter
         refresh_attribute_filter
 
-        @events.subscribe(:finished_configuring) do
+        @events.subscribe(:initial_configuration_complete) do
           refresh_attribute_filter
         end
       end
 
       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
@@ -126,25 +127,30 @@ 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_reader :transaction_rules
+        attr_accessor :transaction_rules
         # Responsbile 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 :transaction_event_recorder
         attr_reader :attribute_filter
-        attr_reader :throughput_monitor
+        attr_reader :adaptive_sampler
+        attr_reader :environment_report
 
         def transaction_event_aggregator
           @transaction_event_recorder.transaction_event_aggregator
@@ -154,6 +160,10 @@ module NewRelic
           @transaction_event_recorder.synthetics_event_aggregator
         end
 
+        def agent_id=(agent_id)
+          @service.agent_id = agent_id
+        end
+
         # This method should be called in a forked process after a fork.
         # It assumes the parent process initialized the agent, but does
         # not assume the agent started.
@@ -183,7 +193,8 @@ module NewRelic
           return if !needs_restart ||
             !Agent.config[:agent_enabled] ||
             !Agent.config[:monitor_mode] ||
-            disconnected?
+            disconnected? ||
+            !control.security_settings_valid?
 
           ::NewRelic::Agent.logger.debug "Starting the worker thread in #{Process.pid} (parent #{Process.ppid}) after forking."
 
@@ -198,7 +209,7 @@ module NewRelic
         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
@@ -229,12 +240,25 @@ module NewRelic
         end
 
         def revert_to_default_configuration
-          NewRelic::Agent.config.remove_config_type(:manual)
-          NewRelic::Agent.config.remove_config_type(:server)
+          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
@@ -260,34 +284,24 @@ module NewRelic
         # 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
-          state = TransactionState.tl_get
+          state = Tracer.state
           prev = state.record_sql
           state.record_sql = should_record
           prev.nil? || prev
         end
 
-        # Sets a thread local variable as to whether we should or
-        # should not record transaction traces in the current
-        # thread. Returns the previous value, if there is one
-        def set_record_tt(should_record) #THREAD_LOCAL_ACCESS
-          state = TransactionState.tl_get
-          prev = state.record_tt
-          state.record_tt = should_record
-          prev.nil? || prev
-        end
-
         # Push flag indicating whether we should be tracing in this
         # 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
-          TransactionState.tl_get.push_traced(should_trace)
+          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
-          TransactionState.tl_get.pop_traced
+          Tracer.state.pop_traced
         end
 
         # Herein lies the corpse of the former 'start' method. May
@@ -335,7 +349,7 @@ module NewRelic
           end
 
           def log_app_name
-            ::NewRelic::Agent.logger.info "Application: #{Agent.config.app_names.join(", ")}"
+            ::NewRelic::Agent.logger.info "Application: #{Agent.config[:app_name].join(", ")}"
           end
 
           def log_ignore_url_regexes
@@ -348,7 +362,7 @@ module NewRelic
 
           # Logs the configured application names
           def app_name_configured?
-            names = Agent.config.app_names
+            names = Agent.config[:app_name]
             return names.respond_to?(:any?) && names.any?
           end
 
@@ -459,11 +473,11 @@ module NewRelic
           def defer_for_resque?
             NewRelic::Agent.config[:dispatcher] == :resque &&
               NewRelic::LanguageSupport.can_fork? &&
-              !NewRelic::Agent::PipeChannelManager.listener.started?
+              !PipeChannelManager.listener.started?
           end
 
           def in_resque_child_process?
-            defined?(@service) && @service.is_a?(NewRelic::Agent::PipeService)
+            defined?(@service) && @service.is_a?(PipeService)
           end
 
           # Sanity-check the agent configuration and start the agent,
@@ -484,8 +498,8 @@ module NewRelic
             @harvester.mark_started
 
             unless in_resque_child_process?
-              generate_environment_report
               install_exit_handler
+              environment_for_connect
               @harvest_samplers.load_samplers unless Agent.config[:disable_samplers]
             end
 
@@ -535,7 +549,7 @@ module NewRelic
           check_config_and_start_agent
           log_version_and_pid
 
-          events.subscribe(:finished_configuring) do
+          events.subscribe(:initial_configuration_complete) do
             log_ignore_url_regexes
           end
         end
@@ -547,10 +561,11 @@ module NewRelic
           @transaction_sampler.reset!
           @transaction_event_recorder.drop_buffered_data
           @custom_event_aggregator.reset!
+          @span_event_aggregator.reset!
           @sql_sampler.reset!
 
           if Agent.config[:clear_transaction_state_after_fork]
-            TransactionState.tl_clear
+            Tracer.clear_state
           end
         end
 
@@ -558,13 +573,16 @@ 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)
+          if connected? && @service.is_a?(PipeService)
             transmit_data
-            transmit_event_data
+            transmit_analytic_event_data
+            transmit_custom_event_data
+            transmit_error_event_data
+            transmit_span_event_data
           end
         end
 
@@ -578,40 +596,48 @@ module NewRelic
             EventLoop.new
           end
 
-          # Never allow any data type to be reported more frequently than once
-          # per second.
-          MIN_ALLOWED_REPORT_PERIOD = 1.0
+          LOG_ONCE_KEYS_RESET_PERIOD = 60.0
 
-          def report_period_for(method)
-            config_key = "data_report_periods.#{method}".to_sym
-            period = Agent.config[config_key]
-            if !period
-              period = Agent.config[:data_report_period]
-              ::NewRelic::Agent.logger.warn("Could not find configured period for #{method}, falling back to data_report_period (#{period} s)")
-            end
-            if period < MIN_ALLOWED_REPORT_PERIOD
-              ::NewRelic::Agent.logger.warn("Configured #{config_key} was #{period}, but minimum allowed is #{MIN_ALLOWED_REPORT_PERIOD}, using #{MIN_ALLOWED_REPORT_PERIOD}.")
-              period = MIN_ALLOWED_REPORT_PERIOD
-            end
-            period
+          # 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
 
-          LOG_ONCE_KEYS_RESET_PERIOD = 60.0
+          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(:report_data) do
+            @event_loop.on(data_harvest) do
               transmit_data
             end
-            @event_loop.on(:report_event_data) do
-              transmit_event_data
+
+            @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],       :report_data)
-            @event_loop.fire_every(report_period_for(:analytic_event_data), :report_event_data)
-            @event_loop.fire_every(LOG_ONCE_KEYS_RESET_PERIOD,              :reset_log_once_keys)
+            @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
@@ -631,7 +657,7 @@ module NewRelic
           # is the worker thread that gathers data and talks to the
           # server.
           def handle_force_disconnect(error)
-            ::NewRelic::Agent.logger.warn "New Relic forced this agent to disconnect (#{error.message})"
+            ::NewRelic::Agent.logger.warn "Agent received a ForceDisconnectException from the server, disconnecting. (#{error.message})"
             disconnect
           end
 
@@ -639,7 +665,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 this agent process:"
+            ::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)
@@ -695,7 +721,7 @@ module NewRelic
           end
 
           ::NewRelic::Agent.logger.debug "Creating Ruby Agent worker thread."
-          @worker_thread = NewRelic::Agent::Threading::AgentThread.create('Worker Loop') do
+          @worker_thread = Threading::AgentThread.create('Worker Loop') do
             deferred_work!(connection_options)
           end
         end
@@ -734,12 +760,12 @@ module NewRelic
             force || (!connected? && !disconnected?)
           end
 
-          # Retry period is a minute for each failed attempt that
-          # we've made. This should probably do some sort of sane TCP
-          # backoff to prevent hammering the server, but a minute for
-          # each attempt seems to work reasonably well.
+          # Per the spec at
+          # /agents/agent-specs/Collector-Response-Handling.md, retry
+          # connections after a specific backoff sequence to prevent
+          # hammering the server.
           def connect_retry_period
-            [600, connect_attempts * 60].min
+            NewRelic::CONNECT_RETRY_PERIODS[connect_attempts] || NewRelic::MAX_RETRY_PERIOD
           end
 
           def note_connect_failure
@@ -773,91 +799,59 @@ module NewRelic
             shutdown
           end
 
-          def generate_environment_report
-            @environment_report = environment_for_connect
-          end
-
           # Checks whether we should send environment info, and if so,
           # returns the snapshot from the local environment.
           # Generating the EnvironmentReport has the potential to trigger
           # require calls in Rails environments, so this method should only
           # be called synchronously from on the main thread.
           def environment_for_connect
-            Agent.config[:send_environment_info] ? Array(EnvironmentReport.new) : []
+            @environment_report ||= Agent.config[:send_environment_info] ? Array(EnvironmentReport.new) : []
           end
 
-          # We've seen objects in the environment report (Rails.env in
-          # particular) that can't seralize to JSON. Cope with that here and
-          # clear out so downstream code doesn't have to check again.
-          def sanitize_environment_report
-            if !@service.valid_to_marshal?(@environment_report)
-              @environment_report = []
-            end
+          # Constructs and memoizes an event_harvest_config hash to be used in
+          # the payload sent during connect (and reconnect)
+          def event_harvest_config
+            @event_harvest_config ||= Configuration::EventHarvestConfig.from_config(Agent.config)
           end
 
-          # Initializes the hash of settings that we send to the
-          # server. Returns a literal hash containing the options
-          def connect_settings
-            sanitize_environment_report
-
-            {
-              :pid           => $$,
-              :host          => local_host,
-              :display_host  => Agent.config[:'process_host.display_name'],
-              :app_name      => Agent.config.app_names,
-              :language      => 'ruby',
-              :labels        => Agent.config.parsed_labels,
-              :agent_version => NewRelic::VERSION::STRING,
-              :environment   => @environment_report,
-              :settings      => Agent.config.to_collector_hash,
-              :high_security => Agent.config[:high_security],
-              :utilization   => UtilizationData.new.to_collector_hash,
-              :identifier    => "ruby:#{local_host}:#{Agent.config.app_names.sort.join(',')}"
-            }
-          end
-
-          # Returns connect data passed back from the server
+          # Builds the payload to send to the connect service,
+          # connects, then configures the agent using the response from
+          # the connect service
           def connect_to_server
-            @service.connect(connect_settings)
-          end
+            request_builder = ::NewRelic::Agent::Connect::RequestBuilder.new \
+              @service,
+              Agent.config,
+              event_harvest_config,
+              environment_for_connect
+            connect_response = @service.connect request_builder.connect_payload
 
-          # apdex_f is always 4 times the apdex_t
-          def apdex_f
-            (4 * Agent.config[:apdex_t]).to_f
-          end
+            response_handler = ::NewRelic::Agent::Connect::ResponseHandler.new(self, Agent.config)
+            response_handler.configure_agent(connect_response)
 
-          # Sets the collector host and connects to the server, then
-          # invokes the final configuration with the returned data
-          def query_server_for_configuration
-            finish_setup(connect_to_server)
+            log_connection connect_response if connect_response
+            connect_response
           end
 
-          # Takes a hash of configuration data returned from the
-          # server and uses it to set local variables and to
-          # initialize various parts of the agent that are configured
-          # separately.
-          #
-          # Can accommodate most arbitrary data - anything extra is
-          # ignored unless we say to do something with it here.
-          def finish_setup(config_data)
-            return if config_data == nil
-
-            @service.agent_id = config_data['agent_run_id']
-
-            if config_data['agent_config']
-              ::NewRelic::Agent.logger.debug "Using config from server"
+          # 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}"
+            if config_data['messages'] && config_data['messages'].any?
+              log_collector_messages(config_data['messages'])
             end
+          end
 
-            ::NewRelic::Agent.logger.debug "Server provided config: #{config_data.inspect}"
-            server_config = NewRelic::Agent::Configuration::ServerSource.new(config_data, Agent.config)
-            Agent.config.replace_or_add_config(server_config)
-            log_connection!(config_data)
-
-            @transaction_rules = RulesEngine.create_transaction_rules(config_data)
-            @stats_engine.metric_rules = RulesEngine.create_metric_rules(config_data)
+          def log_collector_messages(messages)
+            messages.each do |message|
+              ::NewRelic::Agent.logger.send(message['level'].downcase, message['message'])
+            end
+          end
 
-            # If you're adding something else here to respond to the server-side config,
-            # use Agent.instance.events.subscribe(:finished_configuring) callback instead!
+          # apdex_f is always 4 times the apdex_t
+          def apdex_f
+            (4 * Agent.config[:apdex_t]).to_f
           end
 
           class WaitOnConnectTimeout < StandardError
@@ -889,22 +883,6 @@ module NewRelic
             end
           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}"
-            if config_data['messages'] && config_data['messages'].any?
-              log_collector_messages(config_data['messages'])
-            end
-          end
-
-          def log_collector_messages(messages)
-            messages.each do |message|
-              ::NewRelic::Agent.logger.send(message['level'].downcase, message['message'])
-            end
-          end
         end
         include Connect
 
@@ -916,6 +894,7 @@ module NewRelic
           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
           end
         end
@@ -963,7 +942,7 @@ module NewRelic
           return unless should_connect?(opts[:force_reconnect])
 
           ::NewRelic::Agent.logger.debug "Connecting Process to New Relic: #$0"
-          query_server_for_configuration
+          connect_to_server
           @connected_pid = $$
           @connect_state = :connected
           signal_connected
@@ -974,6 +953,10 @@ module NewRelic
         rescue NewRelic::Agent::UnrecoverableAgentException => e
           handle_unrecoverable_agent_error(e)
         rescue StandardError, Timeout::Error, NewRelic::Agent::ServerConnectionException => e
+          # 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
@@ -987,15 +970,6 @@ module NewRelic
           raise
         end
 
-        # Who am I? Well, this method can tell you your hostname.
-        def determine_host
-          NewRelic::Agent::Hostname.get
-        end
-
-        def local_host
-          @local_host ||= determine_host
-        end
-
         # Delegates to the control class to determine the root
         # directory of this project
         def determine_home_directory
@@ -1066,7 +1040,7 @@ module NewRelic
         end
 
         def harvest_and_send_timeslice_data
-          NewRelic::Agent::BusyCalculator.harvest_busy
+          TransactionTimeAggregator.harvest!
           harvest_and_send_from_container(@stats_engine, :metric_data)
         end
 
@@ -1094,19 +1068,28 @@ 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(@custom_event_aggregator,      :custom_event_data)
+          harvest_and_send_from_container(synthetics_event_aggregator,  :analytic_event_data)
+        end
+
+        def harvest_and_send_custom_event_data
+          harvest_and_send_from_container(@custom_event_aggregator, :custom_event_data)
         end
 
         def harvest_and_send_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 check_for_and_handle_agent_commands
           begin
             @agent_command_router.check_for_and_handle_agent_commands
           rescue ForceRestartException, ForceDisconnectException
             raise
+          rescue UnrecoverableServerException => 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
@@ -1120,14 +1103,30 @@ module NewRelic
           NewRelic::Agent.record_metric("Supportability/remote_unavailable/#{endpoint.to_s}", 0.0)
         end
 
-        def transmit_event_data
-          transmit_single_data_type(:harvest_and_send_analytic_event_data, "TransactionEvent")
+        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
+        def transmit_custom_event_data
+          transmit_single_data_type(:harvest_and_send_custom_event_data, CUSTOM_EVENT)
+        end
+
+        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
+        def transmit_span_event_data
+          transmit_single_data_type(:harvest_and_send_span_event_data, SPAN_EVENT)
         end
 
         def transmit_single_data_type(harvest_method, supportability_name)
           now = Time.now
 
-          msg = "Sending #{harvest_method.to_s.gsub("harvest_and_send_", "")} to New Relic Service"
+          msg = "Sending #{supportability_name} data to New Relic Service"
           ::NewRelic::Agent.logger.debug msg
 
           @service.session do # use http keep-alive
@@ -1149,12 +1148,12 @@ module NewRelic
             harvest_and_send_transaction_traces
             harvest_and_send_slowest_sql
             harvest_and_send_timeslice_data
+            harvest_and_send_span_event_data
 
             check_for_and_handle_agent_commands
             harvest_and_send_for_agent_commands
           end
         ensure
-          throughput_monitor.reset!
           NewRelic::Agent::Database.close_connections
           duration = (Time.now - now).to_f
           NewRelic::Agent.record_metric('Supportability/Harvest', duration)
@@ -1174,7 +1173,10 @@ module NewRelic
 
               @events.notify(:before_shutdown)
               transmit_data
-              transmit_event_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"