newrelic_rpm 5.5.0.348 → 7.2.0

data/bin/nrdebug

@@ -2,7 +2,7 @@
 
 # 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 'tempfile'
 require 'rbconfig'

data/config.dot

@@ -18,6 +18,7 @@ digraph AgentEnabled {
   "[error_collector.capture_source]"
   "[error_collector.enabled]"
   "[error_collector.ignore_errors]"
+  "[error_collector.max_backtrace_frames]"
   "[browser_monitoring.auto_instrument]"
   "[license_key]"
   "[verify_certificate]"

data/init.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.
 
 # This is the initialization for the New Relic Ruby Agent when used as
 # a plugin

data/install.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.
 
 if __FILE__ == $0 || $0 =~ /script\/plugin/ || File.basename($0) == 'rake'
   $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), 'lib'))

data/lib/new_relic/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 'forwardable'
 
@@ -26,16 +26,15 @@ module NewRelic
 
     require 'new_relic/version'
     require 'new_relic/local_environment'
-    require 'new_relic/metrics'
     require 'new_relic/metric_spec'
     require 'new_relic/metric_data'
     require 'new_relic/noticed_error'
+    require 'new_relic/agent/noticible_error'
     require 'new_relic/supportability_helper'
 
     require 'new_relic/agent/encoding_normalizer'
     require 'new_relic/agent/stats'
     require 'new_relic/agent/chained_call'
-    require 'new_relic/agent/cross_app_monitor'
     require 'new_relic/agent/agent'
     require 'new_relic/agent/method_tracer'
     require 'new_relic/agent/worker_loop'
@@ -45,8 +44,10 @@ module NewRelic
     require 'new_relic/agent/sql_sampler'
     require 'new_relic/agent/commands/thread_profiler_session'
     require 'new_relic/agent/error_collector'
+    require 'new_relic/agent/error_filter'   
     require 'new_relic/agent/sampler'
     require 'new_relic/agent/database'
+    require 'new_relic/agent/database_adapter'
     require 'new_relic/agent/datastores'
     require 'new_relic/agent/pipe_channel_manager'
     require 'new_relic/agent/configuration'
@@ -55,6 +56,9 @@ module NewRelic
     require 'new_relic/agent/system_info'
     require 'new_relic/agent/external'
     require 'new_relic/agent/deprecator'
+    require 'new_relic/agent/logging'
+    require 'new_relic/agent/distributed_tracing'
+    require 'new_relic/agent/attribute_processing'
 
     require 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -76,7 +80,11 @@ module NewRelic
     class ForceDisconnectException < StandardError; end
 
     # An exception that forces an agent to restart.
-    class ForceRestartException < StandardError; end
+    class ForceRestartException < StandardError
+      def message
+        "#{super}, restarting."
+      end
+    end
 
     # Used to blow out of a periodic task without logging a an error, such as for routine
     # failures.
@@ -276,12 +284,6 @@ module NewRelic
     def notice_error(exception, options={})
       record_api_supportability_metric(:notice_error)
 
-      if options.has_key?(:trace_only)
-        NewRelic::Agent.logger.log_once(:warn, :trace_only_deprecated,
-          'Passing the :trace_only option to NewRelic::Agent.notice_error is deprecated. Please use :expected instead.')
-        options[:expected] = options.delete(:trace_only)
-      end
-
       Transaction.notice_error(exception, options)
       nil # don't return a noticed error datastructure. it can only hurt.
     end
@@ -346,10 +348,9 @@ module NewRelic
     # @api public
     #
     def manual_start(options={})
-      record_api_supportability_metric(:manual_start)
-
       raise "Options must be a hash" unless Hash === options
       NewRelic::Control.instance.init_plugin({ :agent_enabled => true, :sync_startup => true }.merge(options))
+      record_api_supportability_metric(:manual_start)
     end
 
     # Register this method as a callback for processes that fork
@@ -487,7 +488,7 @@ module NewRelic
     # Yield to the block without collecting any metrics or traces in
     # any of the subsequent calls.  If executed recursively, will keep
     # track of the first entry point and turn on tracing again after
-    # leaving that block.  This uses the thread local TransactionState.
+    # leaving that block.  This uses the thread local Tracer::State.
     #
     # @api public
     #
@@ -544,13 +545,13 @@ module NewRelic
 
     # Check to see if we are capturing metrics currently on this thread.
     def tl_is_execution_traced?
-      NewRelic::Agent::TransactionState.tl_get.is_execution_traced?
+      NewRelic::Agent::Tracer.state.is_execution_traced?
     end
 
     # helper method to check the thread local to determine whether sql
     # is being recorded or not
     def tl_is_sql_recorded?
-      NewRelic::Agent::TransactionState.tl_get.is_sql_recorded?
+      NewRelic::Agent::Tracer.state.is_sql_recorded?
     end
 
     # @!group Adding custom attributes to traces
@@ -563,6 +564,12 @@ module NewRelic
     # these custom attributes will also be present in the script injected into
     # the response body, making them available on Insights PageView events.
     #
+    #
+    # @param [Hash] params      A Hash of attributes to be attached to the transaction event.
+    #                           Keys should be strings or symbols, and values
+    #                           may be strings, symbols, numeric values or
+    #                           booleans.
+    #
     # @api public
     #
     def add_custom_attributes(params) #THREAD_LOCAL_ACCESS
@@ -571,11 +578,43 @@ module NewRelic
       if params.is_a? Hash
         txn = Transaction.tl_current
         txn.add_custom_attributes(params) if txn
+
+        segment = ::NewRelic::Agent::Tracer.current_segment
+        if segment
+          # Make sure not to override existing segment-level custom attributes
+          segment_custom_keys = segment.attributes.custom_attributes.keys.map(&:to_sym)
+          segment.add_custom_attributes(params.reject { |k, _v| segment_custom_keys.include?(k.to_sym) })
+        end
       else
         ::NewRelic::Agent.logger.warn("Bad argument passed to #add_custom_attributes. Expected Hash but got #{params.class}")
       end
     end
 
+    # Add custom attributes to the span event for the current span. Attributes will be visible on spans in the
+    # New Relic Distributed Tracing UI and on span events in New Relic Insights.
+    #
+    # Custom attributes will not be transmitted when +high_security+ setting is enabled or
+    # +custom_attributes+ setting is disabled.
+    #
+    # @param [Hash] params      A Hash of attributes to be attached to the span event.
+    #                           Keys should be strings or symbols, and values
+    #                           may be strings, symbols, numeric values or
+    #                           booleans.
+    #
+    # @see https://docs.newrelic.com/docs/using-new-relic/welcome-new-relic/get-started/glossary#span
+    # @api public
+    def add_custom_span_attributes params
+      record_api_supportability_metric :add_custom_span_attributes
+
+      if params.is_a? Hash
+        if segment = NewRelic::Agent::Tracer.current_segment
+          segment.add_custom_attributes params
+        end
+      else
+        ::NewRelic::Agent.logger.warn "Bad argument passed to #add_custom_span_attributes. Expected Hash but got #{params.class}"
+      end
+    end
+
     # @!endgroup
 
     # @!group Transaction naming
@@ -584,7 +623,9 @@ module NewRelic
     # apply a reasonable default based on framework routing, but in
     # cases where this is insufficient, this can be used to manually
     # control the name of the transaction.
-    # The category of transaction can be specified via the +:category+ option:
+    #
+    # The category of transaction can be specified via the +:category+ option.
+    # The following are the only valid categories:
     #
     # * <tt>:category => :controller</tt> indicates that this is a
     #   controller action and will appear with all the other actions.
@@ -634,8 +675,8 @@ module NewRelic
     # @param [String] method the name of the finder method or other method to
     # identify the operation with.
     #
-    def with_database_metric_name(model, method = nil, product = nil, &block) #THREAD_LOCAL_ACCESS
-      if txn = Transaction.tl_current
+    def with_database_metric_name(model, method = nil, product = nil, &block)
+      if txn = Tracer.current_transaction
         txn.with_database_metric_name(model, method, product, &block)
       else
         yield
@@ -656,6 +697,54 @@ module NewRelic
       NewRelic::Agent.logger.debug "Ignoring exception during %p event notification" % [event_type]
     end
 
+    # @!group Trace and Entity metadata
+
+    TRACE_ID_KEY = 'trace.id'.freeze
+    SPAN_ID_KEY = 'span.id'.freeze
+    ENTITY_NAME_KEY = 'entity.name'.freeze
+    ENTITY_TYPE_KEY = 'entity.type'.freeze
+    ENTITY_GUID_KEY = 'entity.guid'.freeze
+    HOSTNAME_KEY = 'hostname'.freeze
+
+    ENTITY_TYPE = 'SERVICE'.freeze
+
+    # Returns a new hash containing trace and entity metadata that can be used
+    # to relate data to a trace or to an entity in APM.
+    #
+    # This hash includes:
+    # * trace.id    - The current trace id, if there is a current trace id. This
+    #   value may be omitted.
+    # * span.id     - The current span id, if there is a current span.  This
+    #   value may be omitted.
+    # * entity.name - The name of the current application. This is read from
+    #   the +app_name+ key in your config.  If there are multiple application
+    #   names, the first one is used.
+    # * entity.type - The entity type is hardcoded to the string +'SERVICE'+.
+    # * entity.guid - The guid of the current entity.
+    # * hostname    - The fully qualified hostname.
+    #
+    # @api public
+    def linking_metadata
+      metadata = Hash.new
+      metadata[ENTITY_NAME_KEY] = config[:app_name][0]
+      metadata[ENTITY_TYPE_KEY] = ENTITY_TYPE
+      metadata[HOSTNAME_KEY] = Hostname.get
+
+      if entity_guid = config[:entity_guid]
+        metadata[ENTITY_GUID_KEY] = entity_guid
+      end
+
+      if trace_id = Tracer.current_trace_id
+        metadata[TRACE_ID_KEY] = trace_id
+      end
+      if span_id = Tracer.current_span_id
+        metadata[SPAN_ID_KEY] = span_id
+      end
+      metadata
+    end
+
+    #@!endgroup
+
     # @!group Manual browser monitoring configuration
 
     # This method returns a string suitable for inclusion in a page - known as
@@ -670,13 +759,15 @@ module NewRelic
     # In previous agents there was a corresponding footer required, but all the
     # work is now done by this single method.
     #
+    # @param [String] nonce The nonce to use in the javascript tag for browser instrumentation
+    #
     # @api public
     #
-    def browser_timing_header
+    def browser_timing_header(nonce=nil)
       record_api_supportability_metric(:browser_timing_header)
 
       return "" unless agent
-      agent.javascript_instrumentor.browser_timing_header
+      agent.javascript_instrumentor.browser_timing_header(nonce)
     end
 
     # @!endgroup

data/lib/new_relic/agent/adaptive_sampler.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.
 
 module NewRelic
   module Agent

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,6 +8,8 @@ require 'net/http'
 require 'logger'
 require 'zlib'
 require 'stringio'
+require 'new_relic/constants'
+require 'new_relic/coerce'
 require 'new_relic/agent/autostart'
 require 'new_relic/agent/harvester'
 require 'new_relic/agent/hostname'
@@ -15,11 +17,11 @@ 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/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'
@@ -30,6 +32,8 @@ require 'new_relic/agent/utilization_data'
 require 'new_relic/environment_report'
 require 'new_relic/agent/attribute_filter'
 require 'new_relic/agent/adaptive_sampler'
+require 'new_relic/agent/connect/request_builder'
+require 'new_relic/agent/connect/response_handler'
 
 module NewRelic
   module Agent
@@ -46,35 +50,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)
-        @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)
+        @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
-        @span_event_aggregator      = NewRelic::Agent::SpanEventAggregator.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 +89,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,17 +128,20 @@ 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.
@@ -146,6 +151,7 @@ module NewRelic
         attr_reader :transaction_event_recorder
         attr_reader :attribute_filter
         attr_reader :adaptive_sampler
+        attr_reader :environment_report
 
         def transaction_event_aggregator
           @transaction_event_recorder.transaction_event_aggregator
@@ -155,6 +161,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.
@@ -200,7 +210,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
@@ -231,12 +241,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
@@ -262,7 +285,7 @@ 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
@@ -273,13 +296,13 @@ module NewRelic
         # 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
@@ -327,7 +350,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
@@ -340,7 +363,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
 
@@ -373,10 +396,8 @@ module NewRelic
           end
 
           def should_install_exit_handler?
-            (
-              Agent.config[:send_data_on_exit]  &&
-              !sinatra_classic_app?
-            )
+            return false unless Agent.config[:send_data_on_exit]
+            !sinatra_classic_app? || Agent.config[:force_install_exit_handler]
           end
 
           def install_exit_handler
@@ -450,12 +471,12 @@ module NewRelic
           # 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?
+              NewRelic::Agent::Instrumentation::Resque::Helper.resque_fork_per_job? &&
+              !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,
@@ -476,8 +497,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
 
@@ -527,7 +548,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
@@ -543,7 +564,7 @@ module NewRelic
           @sql_sampler.reset!
 
           if Agent.config[:clear_transaction_state_after_fork]
-            TransactionState.tl_clear
+            Tracer.clear_state
           end
         end
 
@@ -551,13 +572,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
 
@@ -571,40 +595,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
@@ -624,7 +656,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
 
@@ -632,7 +664,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)
@@ -688,7 +720,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
@@ -727,12 +759,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
@@ -766,106 +798,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']
-
-            security_policies = config_data.delete('security_policies')
-
-            add_server_side_config(config_data)
-            add_security_policy_config(security_policies) if security_policies
-
-            log_connection!(config_data)
-            @transaction_rules = RulesEngine.create_transaction_rules(config_data)
-            @stats_engine.metric_rules = RulesEngine.create_metric_rules(config_data)
-
-            # If you're adding something else here to respond to the server-side config,
-            # use Agent.instance.events.subscribe(:finished_configuring) callback instead!
+          # 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 add_server_side_config(config_data)
-            if config_data['agent_config']
-              ::NewRelic::Agent.logger.debug "Using config from server"
+          def log_collector_messages(messages)
+            messages.each do |message|
+              ::NewRelic::Agent.logger.send(message['level'].downcase, message['message'])
             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)
           end
 
-          def add_security_policy_config(security_policies)
-            ::NewRelic::Agent.logger.info 'Installing security policies'
-            security_policy_source = NewRelic::Agent::Configuration::SecurityPolicySource.new(security_policies)
-            Agent.config.replace_or_add_config(security_policy_source)
-            # drop data collected before applying security policies
-            drop_buffered_data
+          # apdex_f is always 4 times the apdex_t
+          def apdex_f
+            (4 * Agent.config[:apdex_t]).to_f
           end
 
           class WaitOnConnectTimeout < StandardError
@@ -897,22 +882,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
 
@@ -972,7 +941,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
@@ -983,6 +952,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
@@ -996,15 +969,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
@@ -1075,7 +1039,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
 
@@ -1104,19 +1068,27 @@ 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(span_event_aggregator,        :span_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
@@ -1130,18 +1102,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, "SpanEvent")
+          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
@@ -1163,6 +1147,7 @@ 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
@@ -1187,7 +1172,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"