newrelic_rpm 3.12.0.288 → 9.10.2

data/lib/new_relic/agent/new_relic_service.rb

@@ -1,146 +1,165 @@
-# 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 'zlib'
 require 'new_relic/agent/audit_logger'
 require 'new_relic/agent/new_relic_service/encoders'
 require 'new_relic/agent/new_relic_service/marshaller'
 require 'new_relic/agent/new_relic_service/json_marshaller'
-require 'new_relic/agent/new_relic_service/pruby_marshaller'
+require 'new_relic/agent/new_relic_service/security_policy_settings'
 
 module NewRelic
   module Agent
     class NewRelicService
       # Specifies the version of the agent's communication protocol with
       # the NewRelic hosted site.
-
-      PROTOCOL_VERSION = 14
-      # 1f147a42: v10 (tag 3.5.3.17)
-      # cf0d1ff1: v9 (tag 3.5.0)
-      # 14105: v8 (tag 2.10.3)
-      # (no v7)
-      # 10379: v6 (not tagged)
-      # 4078:  v5 (tag 2.5.4)
-      # 2292:  v4 (tag 2.3.6)
-      # 1754:  v3 (tag 2.3.0)
-      # 534:   v2 (shows up in 2.1.0, our first tag)
+      PROTOCOL_VERSION = 17
 
       # These include Errno connection errors, and all indicate that the
       # underlying TCP connection may be in a bad state.
-      CONNECTION_ERRORS = [Timeout::Error, EOFError, SystemCallError, SocketError].freeze
-
-      attr_accessor :request_timeout, :agent_id
-      attr_reader :collector, :marshaller, :metric_id_cache
-
-      def initialize(license_key=nil, collector=control.server)
-        @license_key = license_key || Agent.config[:license_key]
+      CONNECTION_ERRORS = [Net::OpenTimeout, Net::ReadTimeout, EOFError, SystemCallError, SocketError]
+      # TODO: MAJOR VERSION - Net::WriteTimeout wasn't defined until Ruby 2.6.
+      #       Once support for Ruby 2.5 is dropped, we should simply include
+      #       Net::WriteTimeout in the connection errors array directly instead
+      #       of with a conditional
+      CONNECTION_ERRORS << Net::WriteTimeout if defined?(Net::WriteTimeout)
+      CONNECTION_ERRORS.freeze
+
+      # The maximum number of times to attempt an HTTP request
+      MAX_ATTEMPTS = 2
+
+      # Don't perform compression on the payload unless its uncompressed size is
+      # greater than or equal to this number of bytes. In testing with
+      # Ruby 2.2 - 3.1, we determined an absolute minimum value for ASCII to be
+      # 535 bytes to obtain at least a 10% savings in size. It is recommended
+      # that this value be kept above that 535 number. It is also important to
+      # consider the CPU cost involved with performing compression and to find
+      # a balance between CPU cycles spent and bandwidth saved. A good
+      # reasonable default here is 2048 bytes, which is a tried and true Apache
+      # Tomcat default (as of v8.5.78)
+      MIN_BYTE_SIZE_TO_COMPRESS = 2048
+
+      attr_accessor :request_timeout
+      attr_reader :collector, :marshaller, :agent_id
+
+      def initialize(license_key = nil, collector = control.server)
+        @license_key = license_key
         @collector = collector
+        @configured_collector = collector
         @request_timeout = Agent.config[:timeout]
-        @metric_id_cache = {}
+        @ssl_cert_store = nil
+        @in_session = nil
+        @agent_id = nil
+        @shared_tcp_connection = nil
+        @request_headers_map = nil
+        reset_remote_method_uris
+
+        prep_audit_logger
+        prep_marshaller
+      end
 
+      def prep_audit_logger
         @audit_logger = ::NewRelic::Agent::AuditLogger.new
         Agent.config.register_callback(:'audit_log.enabled') do |enabled|
           @audit_logger.enabled = enabled
         end
-        Agent.config.register_callback(:ssl) do |ssl|
-          if !ssl
-            ::NewRelic::Agent.logger.warn("Agent is configured not to use SSL when communicating with New Relic's servers")
-          else
-            ::NewRelic::Agent.logger.debug("Agent is configured to use SSL")
-          end
-        end
+      end
 
+      def prep_marshaller
         Agent.config.register_callback(:marshaller) do |marshaller|
-          begin
-            if marshaller == 'json'
-              @marshaller = JsonMarshaller.new
-            else
-              @marshaller = PrubyMarshaller.new
-            end
-          rescue LoadError
-            ::NewRelic::Agent.logger.warn("JSON marshaller requested, but the 'json' gem was not available, falling back to pruby. This will not be supported in future versions of the agent.")
-            @marshaller = PrubyMarshaller.new
+          if marshaller != 'json'
+            ::NewRelic::Agent.logger.warn("Non-JSON marshaller '#{marshaller}' requested but not supported, using " \
+              'JSON marshaller instead. pruby marshalling has been removed as of version 3.14.0.')
           end
+
+          @marshaller = JsonMarshaller.new
         end
       end
 
-      def connect(settings={})
-        if host = get_redirect_host
-          @collector = NewRelic::Control.instance.server_from_host(host)
+      def agent_id=(id)
+        # Remote URIs have the agent run ID in them, so we need to
+        # clear out our cached values whenever the run ID changes.
+        #
+        reset_remote_method_uris
+        @agent_id = id
+      end
+
+      def connect(settings = {})
+        @request_headers_map = nil
+        security_policies = nil
+        if response = preconnect
+          if host = response['redirect_host']
+            @collector = NewRelic::Control.instance.server_from_host(host)
+          end
+          if policies = response['security_policies']
+            security_policies = SecurityPolicySettings.preliminary_settings(policies)
+            settings.merge!(security_policies)
+          end
         end
         response = invoke_remote(:connect, [settings])
-        @agent_id = response['agent_run_id']
+        @request_headers_map = response['request_headers_map']
+        self.agent_id = response['agent_run_id']
+        response.merge!(security_policies) if security_policies
         response
       end
 
-      def get_redirect_host
-        invoke_remote(:get_redirect_host)
+      def preconnect
+        token = Agent.config[:security_policies_token]
+
+        if token && !token.empty?
+          response = invoke_remote(:preconnect, [{'security_policies_token' => token, 'high_security' => false}])
+
+          validator = SecurityPolicySettings::Validator.new(response)
+          validator.validate_matching_agent_config!
+
+          response
+        elsif Agent.config[:high_security]
+          invoke_remote(:preconnect, [{'high_security' => true}])
+        else
+          invoke_remote(:preconnect, [{'high_security' => false}])
+        end
       end
 
       def shutdown(time)
         invoke_remote(:shutdown, [@agent_id, time.to_i]) if @agent_id
       end
 
-      def reset_metric_id_cache
-        @metric_id_cache = {}
-      end
-
       def force_restart
-        reset_metric_id_cache
         close_shared_connection
       end
 
-      # takes an array of arrays of spec and id, adds it into the
-      # metric cache so we can save the collector some work by
-      # sending integers instead of strings the next time around
-      def fill_metric_id_cache(pairs_of_specs_and_ids)
-        Array(pairs_of_specs_and_ids).each do |metric_spec_hash, metric_id|
-          metric_spec = MetricSpec.new(metric_spec_hash['name'],
-                                       metric_spec_hash['scope'])
-          metric_id_cache[metric_spec] = metric_id
-        end
-      rescue => e
-        # If we've gotten this far, we don't want this error to propagate and
-        # make this post appear to have been non-successful, which would trigger
-        # re-aggregation of the same metric data into the next post, so just log
-        NewRelic::Agent.logger.error("Failed to fill metric ID cache from response, error details follow ", e)
-      end
-
-      # The collector wants to recieve metric data in a format that's different
+      # The collector wants to receive metric data in a format that's different
       # from how we store it internally, so this method handles the translation.
-      # It also handles translating metric names to IDs using our metric ID cache.
       def build_metric_data_array(stats_hash)
         metric_data_array = []
         stats_hash.each do |metric_spec, stats|
           # Omit empty stats as an optimization
           unless stats.is_reset?
-            metric_id = metric_id_cache[metric_spec]
-            metric_data = if metric_id
-              NewRelic::MetricData.new(nil, stats, metric_id)
-            else
-              NewRelic::MetricData.new(metric_spec, stats, nil)
-            end
-            metric_data_array << metric_data
+            metric_data_array << NewRelic::MetricData.new(metric_spec, stats)
           end
         end
         metric_data_array
       end
 
       def metric_data(stats_hash)
+        # let the serverless handler handle serialization
+        return NewRelic::Agent.agent.serverless_handler.metric_data(stats_hash) if NewRelic::Agent.agent.serverless?
+
         timeslice_start = stats_hash.started_at
-        timeslice_end  = stats_hash.harvested_at || Time.now
+        timeslice_end = stats_hash.harvested_at || Process.clock_gettime(Process::CLOCK_REALTIME)
         metric_data_array = build_metric_data_array(stats_hash)
-        result = invoke_remote(
+        invoke_remote(
           :metric_data,
-          [@agent_id, timeslice_start.to_f, timeslice_end.to_f, metric_data_array],
+          [@agent_id, timeslice_start, timeslice_end, metric_data_array],
           :item_count => metric_data_array.size
         )
-        fill_metric_id_cache(result)
-        result
       end
 
       def error_data(unsent_errors)
+        # let the serverless handler handle serialization
+        return NewRelic::Agent.agent.serverless_handler.error_data(unsent_errors) if NewRelic::Agent.agent.serverless?
+
         invoke_remote(:error_data, [@agent_id, unsent_errors],
           :item_count => unsent_errors.size)
       end
@@ -167,34 +186,50 @@ module NewRelic
         invoke_remote(:agent_command_results, [@agent_id, results])
       end
 
-      def get_xray_metadata(xray_ids)
-        invoke_remote(:get_xray_metadata, [@agent_id, *xray_ids])
-      end
-
       def analytic_event_data(data)
-        invoke_remote(:analytic_event_data, [@agent_id, data],
-          :item_count => data.size)
+        _, items = data
+        invoke_remote(:analytic_event_data, [@agent_id, *data],
+          :item_count => items.size)
       end
 
       def custom_event_data(data)
-        invoke_remote(:custom_event_data, [@agent_id, data],
-          :item_count => data.size)
+        _, items = data
+        invoke_remote(:custom_event_data, [@agent_id, *data],
+          :item_count => items.size)
       end
 
-      def utilization_data(data)
-        invoke_remote(:utilization_data, data)
+      def log_event_data(data)
+        payload, size = LogEventAggregator.payload_to_melt_format(data)
+        invoke_remote(:log_event_data, payload, :item_count => size)
       end
 
-      # We do not compress if content is smaller than 64kb.  There are
-      # problems with bugs in Ruby in some versions that expose us
-      # to a risk of segfaults if we compress aggressively.
-      def compress_request_if_needed(data)
+      def error_event_data(data)
+        metadata, items = data
+        response = invoke_remote(:error_event_data, [@agent_id, *data], :item_count => items.size)
+        NewRelic::Agent.record_metric('Supportability/Events/TransactionError/Sent', :count => items.size)
+        NewRelic::Agent.record_metric('Supportability/Events/TransactionError/Seen', :count => metadata[:events_seen])
+        response
+      end
+
+      def span_event_data(data)
+        metadata, items = data
+        response = invoke_remote(:span_event_data, [@agent_id, *data], :item_count => items.size)
+        NewRelic::Agent.record_metric('Supportability/Events/SpanEvents/Sent', :count => items.size)
+        NewRelic::Agent.record_metric('Supportability/Events/SpanEvents/Seen', :count => metadata[:events_seen])
+        response
+      end
+
+      def compress_request_if_needed(data, endpoint)
         encoding = 'identity'
-        if data.size > 64 * 1024
-          data = Encoders::Compressed.encode(data)
-          encoding = 'deflate'
+        if data.size >= MIN_BYTE_SIZE_TO_COMPRESS
+          encoding = Agent.config[:compressed_content_encoding]
+          data = if encoding == 'deflate'
+            Encoders::Compressed::Deflate.encode(data)
+          else
+            Encoders::Compressed::Gzip.encode(data)
+          end
         end
-        check_post_size(data)
+        check_post_size(data, endpoint)
         [data, encoding]
       end
 
@@ -202,10 +237,10 @@ module NewRelic
       # represents 1 tcp connection which may transmit multiple HTTP requests
       # via keep-alive.
       def session(&block)
-        raise ArgumentError, "#{self.class}#shared_connection must be passed a block" unless block_given?
+        raise ArgumentError, "#{self.class}#shared_connection must be passed a block" unless block
 
         begin
-          t0 = Time.now
+          t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           @in_session = true
           if NewRelic::Agent.config[:aggressive_keepalive]
             session_with_keepalive(&block)
@@ -213,7 +248,7 @@ module NewRelic
             session_without_keepalive(&block)
           end
         rescue *CONNECTION_ERRORS => e
-          elapsed = Time.now - t0
+          elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t0
           raise NewRelic::Agent::ServerConnectionException, "Recoverable error connecting to #{@collector} after #{elapsed} seconds: #{e}"
         ensure
           @in_session = false
@@ -222,22 +257,20 @@ module NewRelic
 
       def session_with_keepalive(&block)
         establish_shared_connection
-        block.call
+        yield
       end
 
       def session_without_keepalive(&block)
         begin
           establish_shared_connection
-          block.call
+          yield
         ensure
           close_shared_connection
         end
       end
 
       def establish_shared_connection
-        unless @shared_tcp_connection
-          @shared_tcp_connection = create_and_start_http_connection
-        end
+        @shared_tcp_connection ||= create_and_start_http_connection
         @shared_tcp_connection
       end
 
@@ -279,63 +312,80 @@ module NewRelic
         # Jruby 1.6.8 requires a gem for full ssl support and will throw
         # an error when use_ssl=(true) is called and jruby-openssl isn't
         # installed
-        conn.use_ssl     = true
+        conn.use_ssl = true
         conn.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        conn.cert_store  = ssl_cert_store
+        set_cert_store(conn)
       rescue StandardError, LoadError
-        msg = "Agent is configured to use SSL, but SSL is not available in the environment. "
-        msg << "Either disable SSL in the agent configuration, or install SSL support."
+        msg = 'SSL is not available in the environment; please install SSL support.'
         raise UnrecoverableAgentException.new(msg)
       end
 
+      def set_cert_store(conn)
+        if NewRelic::Agent.config[:ca_bundle_path]
+          conn.cert_store = ssl_cert_store
+        else
+          ::NewRelic::Agent.logger.debug('Using default security certificates')
+        end
+      end
+
       def start_connection(conn)
         NewRelic::Agent.logger.debug("Opening TCP connection to #{conn.address}:#{conn.port}")
-        NewRelic::TimerLib.timeout(@request_timeout) { conn.start }
-        conn
+        conn.start
       end
 
       def setup_connection_timeouts(conn)
-        # We use Timeout explicitly instead of this
-        conn.read_timeout = nil
+        conn.open_timeout = @request_timeout
+        conn.read_timeout = @request_timeout
+        # TODO: MAJOR VERSION - #write_timeout= requires Ruby 2.6+, so remove
+        #       the conditional check once support for Ruby 2.5 is dropped
+        conn.write_timeout = @request_timeout if conn.respond_to?(:write_timeout=)
 
         if conn.respond_to?(:keep_alive_timeout) && NewRelic::Agent.config[:aggressive_keepalive]
           conn.keep_alive_timeout = NewRelic::Agent.config[:keep_alive_timeout]
         end
       end
 
-      # Return the Net::HTTP with proxy configuration given the NewRelic::Control::Server object.
       def create_http_connection
-        proxy_server = control.proxy_server
-        # Proxy returns regular HTTP if @proxy_host is nil (the default)
-        http_class = Net::HTTP::Proxy(proxy_server.name, proxy_server.port,
-                                      proxy_server.user, proxy_server.password)
-
-        if proxy_server.name
-          ::NewRelic::Agent.logger.debug("Using proxy server #{proxy_server.name}:#{proxy_server.port}")
-        end
-
-        conn = http_class.new((@collector.ip || @collector.name), @collector.port)
-        setup_connection_for_ssl(conn) if Agent.config[:ssl]
+        conn = prep_connection
+        setup_connection_for_ssl(conn)
         setup_connection_timeouts(conn)
 
         ::NewRelic::Agent.logger.debug("Created net/http handle to #{conn.address}:#{conn.port}")
         conn
       end
 
+      def prep_connection
+        return Net::HTTP.new(@collector.name, @collector.port) unless Agent.config[:proxy_host]
+
+        ::NewRelic::Agent.logger.debug("Using proxy server #{Agent.config[:proxy_host]}:#{Agent.config[:proxy_port]}")
+        prep_proxy_connection
+      end
+
+      def prep_proxy_connection
+        proxy = Net::HTTP::Proxy(
+          Agent.config[:proxy_host],
+          Agent.config[:proxy_port],
+          Agent.config[:proxy_user],
+          Agent.config[:proxy_pass]
+        )
+        proxy.new(@collector.name, @collector.port)
+      end
+
       def create_and_start_http_connection
         conn = create_http_connection
         start_connection(conn)
         conn
+      rescue Net::OpenTimeout
+        ::NewRelic::Agent.logger.info('Timed out while attempting to connect. For SSL issues, you may need to install system-level CA Certificates to be used by Net::HTTP.')
+        raise
       end
 
       # The path to the certificate file used to verify the SSL
       # connection if verify_peer is enabled
       def cert_file_path
         if path_override = NewRelic::Agent.config[:ca_bundle_path]
-          NewRelic::Agent.logger.warn("Couldn't find CA bundle from configured ca_bundle_path: #{path_override}") unless File.exists? path_override
+          NewRelic::Agent.logger.warn("Couldn't find CA bundle from configured ca_bundle_path: #{path_override}") unless File.exist?(path_override)
           path_override
-        else
-          File.expand_path(File.join(control.newrelic_root, 'cert', 'cacert.pem'))
         end
       end
 
@@ -343,7 +393,7 @@ module NewRelic
         @marshaller.dump(data)
         true
       rescue StandardError, SystemStackError => e
-        NewRelic::Agent.logger.warn("Unable to marshal environment report on connect.", e)
+        NewRelic::Agent.logger.warn('Unable to marshal environment report on connect.', e)
         false
       end
 
@@ -354,68 +404,195 @@ module NewRelic
         NewRelic::Control.instance
       end
 
-      # The path on the server that we should post our data to
-      def remote_method_uri(method, format)
-        params = {'run_id' => @agent_id, 'marshal_format' => format}
-        uri = "/agent_listener/#{PROTOCOL_VERSION}/#{@license_key}/#{method}"
-        uri << '?' + params.map do |k,v|
+      def prep_headers(opts)
+        headers = {
+          'Content-Encoding' => opts[:encoding],
+          'Host' => opts[:collector].name
+        }
+        headers.merge!(@request_headers_map) if @request_headers_map
+        headers
+      end
+
+      def prep_request(opts)
+        headers = prep_headers(opts)
+        if Agent.config[:put_for_data_send]
+          request = Net::HTTP::Put.new(opts[:uri], headers)
+        else
+          request = Net::HTTP::Post.new(opts[:uri], headers)
+        end
+        @audit_logger.log_request_headers(filtered_uri(opts[:uri]), headers)
+        request['user-agent'] = user_agent
+        request.content_type = 'application/octet-stream'
+        request.body = opts[:data]
+        request
+      end
+
+      def relay_request(request, opts)
+        response = nil
+        attempts = 0
+
+        begin
+          attempts += 1
+          response = attempt_request(request, opts)
+        rescue *CONNECTION_ERRORS => e
+          close_shared_connection
+          if attempts < MAX_ATTEMPTS
+            ::NewRelic::Agent.logger.debug("Retrying request to #{opts[:collector]}#{filtered_uri(opts[:uri])} after #{e}")
+            retry
+          else
+            raise ServerConnectionException, "Recoverable error talking to #{@collector} after #{attempts} attempts: #{e}"
+          end
+        end
+
+        log_response(response)
+        response
+      end
+
+      def attempt_request(request, opts)
+        conn = http_connection
+        ::NewRelic::Agent.logger.debug("Sending request to #{opts[:collector]}#{filtered_uri(opts[:uri])} with #{request.method}")
+        conn.request(request)
+      end
+
+      def handle_error_response(response, endpoint)
+        case response
+        when Net::HTTPRequestTimeOut,
+             Net::HTTPTooManyRequests,
+             Net::HTTPInternalServerError,
+             Net::HTTPServiceUnavailable,
+             Net::OpenTimeout,
+             Net::ReadTimeout
+          handle_server_connection_exception(response, endpoint)
+        when Net::HTTPBadRequest,
+             Net::HTTPForbidden,
+             Net::HTTPNotFound,
+             Net::HTTPMethodNotAllowed,
+             Net::HTTPProxyAuthenticationRequired,
+             Net::HTTPLengthRequired,
+             Net::HTTPRequestEntityTooLarge,
+             Net::HTTPRequestURITooLong,
+             Net::HTTPUnsupportedMediaType,
+             Net::HTTPExpectationFailed,
+             Net::HTTPRequestHeaderFieldsTooLarge
+          handle_unrecoverable_server_exception(response, endpoint)
+        when Net::HTTPConflict,
+             Net::HTTPUnauthorized
+          handle_unauthorized_error_response(response, endpoint)
+          raise ForceRestartException, "#{response.code}: #{response.message}"
+        when Net::HTTPGone
+          handle_gone_response(response, endpoint)
+        else
+          # TODO: MAJOR VERSION - Net::WriteTimeout wasn't defined until
+          #       Ruby 2.6, so it can't be included in the case statement
+          #       as a constant and instead needs to be found here. Once
+          #       support for Ruby 2.5 is dropped, we should have
+          #       Net::WriteTimeout sit in the 'when' clause above alongside
+          #       Net::OpenTimeout and Net::ReadTimeout and this entire if/else
+          #       conditional can be removed.
+          if response.respond_to?(:name) && response.name == 'Net::WriteTimeout'
+            handle_server_connection_exception(response, endpoint)
+          else
+            record_endpoint_attempts_supportability_metrics(endpoint)
+            record_error_response_supportability_metrics(response.code)
+            raise UnrecoverableServerException, "#{response.code}: #{response.message}"
+          end
+        end
+        response
+      end
+
+      def handle_server_connection_exception(response, endpoint)
+        record_endpoint_attempts_supportability_metrics(endpoint)
+        raise ServerConnectionException, "#{response.code}: #{response.message}"
+      end
+
+      def handle_unrecoverable_server_exception(response, endpoint)
+        record_endpoint_attempts_supportability_metrics(endpoint)
+        record_error_response_supportability_metrics(response.code)
+        raise UnrecoverableServerException, "#{response.code}: #{response.message}"
+      end
+
+      def handle_unauthorized_error_response(response, endpoint)
+        record_endpoint_attempts_supportability_metrics(endpoint)
+        record_error_response_supportability_metrics(response.code)
+      end
+
+      def handle_gone_response(response, endpoint)
+        record_endpoint_attempts_supportability_metrics(endpoint)
+        record_error_response_supportability_metrics(response.code)
+        raise ForceDisconnectException, "#{response.code}: #{response.message}"
+      end
+
+      def remote_method_uri(method)
+        @remote_method_uris[method]
+      end
+
+      def reset_remote_method_uris
+        @remote_method_uris = Hash.new do |hash, remote_method|
+          hash[remote_method] = generate_remote_method_uri(remote_method)
+        end
+      end
+
+      def generate_remote_method_uri(method)
+        params = {
+          'protocol_version' => PROTOCOL_VERSION,
+          'license_key' => license_key,
+          'run_id' => @agent_id,
+          'method' => method,
+          'marshal_format' => 'json' # Other formats are explicitly
+          # ruled out; see the initializer
+        }
+
+        uri = +'/agent_listener/invoke_raw_method?'
+        uri << params.map do |k, v|
           next unless v
+
           "#{k}=#{v}"
         end.compact.join('&')
         uri
       end
 
+      def license_key
+        @license_key ||= Agent.config[:license_key]
+      end
+
       # send a message via post to the actual server. This attempts
       # to automatically compress the data via zlib if it is large
       # enough to be worth compressing, and handles any errors the
       # server may return
       def invoke_remote(method, payload = [], options = {})
-        start_ts = Time.now
+        return NewRelic::Agent.agent.serverless_handler.store_payload(method, payload) if NewRelic::Agent.agent.serverless?
 
-        data, size, serialize_finish_ts = nil
-        begin
-          data = @marshaller.dump(payload, options)
-        rescue StandardError, SystemStackError => e
-          handle_serialization_error(method, e)
-        end
-        serialize_finish_ts = Time.now
-
-        data, encoding = compress_request_if_needed(data)
-        size = data.size
-
-        uri = remote_method_uri(method, @marshaller.format)
-        full_uri = "#{@collector}#{uri}"
-
-        @audit_logger.log_request(full_uri, payload, @marshaller)
-        response = send_request(:data      => data,
-                                :uri       => uri,
-                                :encoding  => encoding,
-                                :collector => @collector)
+        start_ts = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        request_send_ts, response_check_ts = nil
+        data, encoding, size, serialize_finish_ts = marshal_payload(method, payload, options)
+        prep_collector(method)
+        response, request_send_ts, response_check_ts = invoke_remote_send_request(method, payload, data, encoding)
         @marshaller.load(decompress_response(response))
       ensure
-        record_timing_supportability_metrics(method, start_ts, serialize_finish_ts)
-        if size
-          record_size_supportability_metrics(method, size, options[:item_count])
+        unless NewRelic::Agent.agent.serverless?
+          record_timing_supportability_metrics(method, start_ts, serialize_finish_ts, request_send_ts, response_check_ts)
+          record_size_supportability_metrics(method, size, options[:item_count]) if size
         end
       end
 
       def handle_serialization_error(method, e)
-        NewRelic::Agent.increment_metric("Supportability/serialization_failure")
+        NewRelic::Agent.increment_metric('Supportability/serialization_failure')
         NewRelic::Agent.increment_metric("Supportability/serialization_failure/#{method}")
-        msg = "Failed to serialize #{method} data using #{@marshaller.class.to_s}: #{e.inspect}"
+        msg = "Failed to serialize #{method} data using #{@marshaller.class}: #{e.inspect}"
         error = SerializationError.new(msg)
         error.set_backtrace(e.backtrace)
         raise error
       end
 
-      def record_timing_supportability_metrics(method, start_ts, serialize_finish_ts)
+      def record_timing_supportability_metrics(method, start_ts, serialize_finish_ts, request_send_ts, response_check_ts)
         serialize_time = serialize_finish_ts && (serialize_finish_ts - start_ts)
-        duration = (Time.now - start_ts).to_f
-        NewRelic::Agent.record_metric("Supportability/invoke_remote", duration)
-        NewRelic::Agent.record_metric("Supportability/invoke_remote/#{method.to_s}", duration)
+        request_duration = response_check_ts && (response_check_ts - request_send_ts)
+        if request_duration
+          NewRelic::Agent.record_metric("Supportability/Agent/Collector/#{method}/Duration", request_duration)
+        end
         if serialize_time
-          NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize", serialize_time)
-          NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize/#{method.to_s}", serialize_time)
+          NewRelic::Agent.record_metric('Supportability/invoke_remote_serialize', serialize_time)
+          NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize/#{method}", serialize_time)
         end
       end
 
@@ -429,8 +606,8 @@ module NewRelic
       # of items as arguments.
       def record_size_supportability_metrics(method, size_bytes, item_count)
         metrics = [
-          "Supportability/invoke_remote_size",
-          "Supportability/invoke_remote_size/#{method.to_s}"
+          'Supportability/Ruby/Collector/Output/Bytes',
+          "Supportability/Ruby/Collector/#{method}/Output/Bytes"
         ]
         # we may not have an item count, in which case, just record 0 for the exclusive time
         item_count ||= 0
@@ -439,9 +616,11 @@ module NewRelic
 
       # Raises an UnrecoverableServerException if the post_string is longer
       # than the limit configured in the control object
-      def check_post_size(post_string)
-        return if post_string.size < Agent.config[:post_size_limit]
-        ::NewRelic::Agent.logger.debug "Tried to send too much data: #{post_string.size} bytes"
+      def check_post_size(post_string, endpoint)
+        return if post_string.size < Agent.config[:max_payload_size_in_bytes]
+
+        ::NewRelic::Agent.logger.debug("Tried to send too much data: #{post_string.size} bytes")
+        NewRelic::Agent.increment_metric("Supportability/Ruby/Collector/#{endpoint}/MaxPayloadSizeLimit")
         raise UnrecoverableServerException.new('413 Request Entity Too Large')
       end
 
@@ -456,65 +635,33 @@ module NewRelic
       #                    contact
       #  - :data => the data to send as the body of the request
       def send_request(opts)
-        request = Net::HTTP::Post.new(opts[:uri], 'CONTENT-ENCODING' => opts[:encoding], 'HOST' => opts[:collector].name)
-        request['user-agent'] = user_agent
-        request.content_type = "application/octet-stream"
-        request.body = opts[:data]
+        request = prep_request(opts)
+        response = relay_request(request, opts)
+        return response if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
 
-        response     = nil
-        attempts     = 0
-        max_attempts = 2
-
-        begin
-          attempts += 1
-          conn = http_connection
-          ::NewRelic::Agent.logger.debug "Sending request to #{opts[:collector]}#{opts[:uri]}"
-          NewRelic::TimerLib.timeout(@request_timeout) do
-            response = conn.request(request)
-          end
-        rescue *CONNECTION_ERRORS => e
-          close_shared_connection
-          if attempts < max_attempts
-            ::NewRelic::Agent.logger.debug("Retrying request to #{opts[:collector]}#{opts[:uri]} after #{e}")
-            retry
-          else
-            raise ServerConnectionException, "Recoverable error talking to #{@collector} after #{attempts} attempts: #{e}"
-          end
-        end
+        handle_error_response(response, opts[:endpoint])
+      end
 
-        log_response(response)
+      def log_response(response)
+        ::NewRelic::Agent.logger.debug("Received response, status: #{response.code}, encoding: '#{response['content-encoding']}'")
+      end
 
-        case response
-        when Net::HTTPSuccess
-          true # do nothing
-        when Net::HTTPUnauthorized
-          raise LicenseException, 'Invalid license key, please visit support.newrelic.com'
-        when Net::HTTPServiceUnavailable
-          raise ServerConnectionException, "Service unavailable (#{response.code}): #{response.message}"
-        when Net::HTTPGatewayTimeOut
-          raise ServerConnectionException, "Gateway timeout (#{response.code}): #{response.message}"
-        when Net::HTTPRequestEntityTooLarge
-          raise UnrecoverableServerException, '413 Request Entity Too Large'
-        when Net::HTTPUnsupportedMediaType
-          raise UnrecoverableServerException, '415 Unsupported Media Type'
-        else
-          raise ServerConnectionException, "Unexpected response from server (#{response.code}): #{response.message}"
-        end
-        response
+      # Per protocol 17, this metric should be recorded for all error response codes
+      # that cause data to be discarded.
+      def record_error_response_supportability_metrics(response_code)
+        ::NewRelic::Agent.increment_metric("Supportability/Agent/Collector/HTTPError/#{response_code}")
       end
 
-      def log_response(response)
-        ::NewRelic::Agent.logger.debug "Received response, status: #{response.code}, encoding: '#{response['content-encoding']}'"
+      def record_endpoint_attempts_supportability_metrics(endpoint)
+        ::NewRelic::Agent.increment_metric("Supportability/Agent/Collector/#{endpoint}/Attempts")
       end
 
       # Decompresses the response from the server, if it is gzip
       # encoded, otherwise returns it verbatim
       def decompress_response(response)
-        if response['content-encoding'] == 'gzip'
-          Zlib::GzipReader.new(StringIO.new(response.body)).read
-        else
-          response.body
-        end
+        return response.body unless response['content-encoding'] == 'gzip'
+
+        Zlib::GzipReader.new(StringIO.new(response.body)).read
       end
 
       # Sets the user agent for connections to the server, to
@@ -522,16 +669,49 @@ module NewRelic
       # the ruby version and also zlib version if available since
       # that may cause corrupt compression if there is a problem.
       def user_agent
-        ruby_description = ''
-        # note the trailing space!
-        ruby_description << "(ruby #{::RUBY_VERSION} #{::RUBY_PLATFORM}) " if defined?(::RUBY_VERSION) && defined?(::RUBY_PLATFORM)
-        zlib_version = ''
-        zlib_version << "zlib/#{Zlib.zlib_version}" if defined?(::Zlib) && Zlib.respond_to?(:zlib_version)
+        if defined?(::RUBY_VERSION) && defined?(::RUBY_PLATFORM)
+          ruby_description = "(ruby #{::RUBY_VERSION} #{::RUBY_PLATFORM}) " # NOTE: the trailing space!
+        end
+        zlib_version = "zlib/#{Zlib.zlib_version}" if defined?(::Zlib) && Zlib.respond_to?(:zlib_version)
         "NewRelic-RubyAgent/#{NewRelic::VERSION::STRING} #{ruby_description}#{zlib_version}"
       end
 
-      # Used to wrap errors reported to agent by the collector
-      class CollectorError < StandardError; end
+      def marshal_payload(method, payload, options)
+        begin
+          data = @marshaller.dump(payload, options)
+        rescue StandardError, SystemStackError => e
+          handle_serialization_error(method, e)
+        end
+        serialize_finish_ts = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        size = data.size # only the uncompressed size is reported
+        data, encoding = compress_request_if_needed(data, method)
+
+        [data, encoding, size, serialize_finish_ts]
+      end
+
+      def prep_collector(method)
+        # Preconnect needs to always use the configured collector host, not the redirect host
+        # We reset it here so we are always using the configured collector during our creation of the new connection
+        # and we also don't want to keep the previous redirect host around anymore
+        @collector = @configured_collector if method == :preconnect
+      end
+
+      def invoke_remote_send_request(method, payload, data, encoding)
+        uri = remote_method_uri(method)
+        @audit_logger.log_request("#{@collector}#{filtered_uri(uri)}", payload, @marshaller)
+        request_send_ts = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        response = send_request(:data => data,
+          :uri       => uri,
+          :encoding  => encoding,
+          :collector => @collector,
+          :endpoint  => method)
+        [response, request_send_ts, Process.clock_gettime(Process::CLOCK_MONOTONIC)]
+      end
+
+      def filtered_uri(uri)
+        uri.gsub(license_key, ASTERISK * license_key.size)
+      end
     end
   end
 end