newrelic_rpm 9.1.0 → 9.21.0

data/lib/new_relic/agent/transaction/request_attributes.rb

@@ -8,21 +8,28 @@ module NewRelic
   module Agent
     class Transaction
       class RequestAttributes
-        attr_reader :request_path, :referer, :accept, :content_length, :content_type,
-          :host, :port, :user_agent, :request_method
+        # the HTTP standard has "referrer" mispelled as "referer"
+        attr_reader :accept, :content_length, :content_type, :host, :other_headers, :port, :referer, :request_method,
+          :request_path, :user_agent
 
         HTTP_ACCEPT_HEADER_KEY = 'HTTP_ACCEPT'.freeze
 
+        BASE_HEADERS = %w[CONTENT_LENGTH CONTENT_TYPE HTTP_ACCEPT HTTP_REFERER HTTP_USER_AGENT PATH_INFO REMOTE_HOST
+          REQUEST_METHOD REQUEST_URI SERVER_PORT].freeze
+
+        ATTRIBUTE_PREFIX = 'request.headers.'
+
         def initialize(request)
           @request_path = path_from_request(request)
           @referer = referer_from_request(request)
           @accept = attribute_from_env(request, HTTP_ACCEPT_HEADER_KEY)
           @content_length = content_length_from_request(request)
-          @content_type = attribute_from_request(request, :content_type)
+          @content_type = content_type_attribute_from_request(request)
           @host = attribute_from_request(request, :host)
           @port = port_from_request(request)
           @user_agent = attribute_from_request(request, :user_agent)
           @request_method = attribute_from_request(request, :request_method)
+          @other_headers = other_headers_from_request(request)
         end
 
         def assign_agent_attributes(txn)
@@ -31,14 +38,12 @@ module NewRelic
             AttributeFilter::DST_ERROR_COLLECTOR
 
           if referer
-            txn.add_agent_attribute(:'request.headers.referer', referer, AttributeFilter::DST_ERROR_COLLECTOR)
+            destinations = allow_other_headers? ? default_destinations : AttributeFilter::DST_ERROR_COLLECTOR
+            txn.add_agent_attribute(:'request.headers.referer', referer, destinations)
           end
 
           if request_path
-            txn.add_agent_attribute(:'request.uri',
-              request_path,
-              AttributeFilter::DST_TRANSACTION_TRACER |
-                AttributeFilter::DST_ERROR_COLLECTOR)
+            txn.add_agent_attribute(:'request.uri', request_path, default_destinations)
           end
 
           if accept
@@ -64,6 +69,14 @@ module NewRelic
           if request_method
             txn.add_agent_attribute(:'request.method', request_method, default_destinations)
           end
+
+          if port && allow_other_headers?
+            txn.add_agent_attribute(:'request.headers.port', port, default_destinations)
+          end
+
+          other_headers.each do |header, value|
+            txn.add_agent_attribute(header, value, default_destinations)
+          end
         end
 
         private
@@ -85,12 +98,10 @@ module NewRelic
         # rails construct the PATH_INFO enviroment variable improperly and we're generally
         # being defensive.
 
-        ROOT_PATH = '/'.freeze
-
         def path_from_request(request)
           path = attribute_from_request(request, :path) || ''
           path = HTTPClients::URIUtil.strip_query_string(path)
-          path.empty? ? ROOT_PATH : path
+          path.empty? ? NewRelic::ROOT : path
         end
 
         def content_length_from_request(request)
@@ -111,11 +122,43 @@ module NewRelic
           end
         end
 
+        def content_type_attribute_from_request(request)
+          # Rails 7.0 changed the behavior of `content_type`. We want just the MIME type, so use `media_type` if available.
+          # https://guides.rubyonrails.org/upgrading_ruby_on_rails.html#actiondispatch-request-content-type-now-returns-content-type-header-as-it-is
+          content_type = if request.respond_to?(:media_type)
+            :media_type
+          elsif request.respond_to?(:content_type)
+            :content_type
+          end
+
+          request.send(content_type) if content_type
+        end
+
         def attribute_from_env(request, key)
           if env = attribute_from_request(request, :env)
             env[key]
           end
         end
+
+        def allow_other_headers?
+          NewRelic::Agent.config[:allow_all_headers] && !NewRelic::Agent.config[:high_security]
+        end
+
+        def other_headers_from_request(request)
+          # confirm that `request` is an instance of `Rack::Request` by checking
+          # for #each_header
+          return NewRelic::EMPTY_HASH unless allow_other_headers? && request.respond_to?(:each_header)
+
+          request.each_header.with_object({}) do |(header, value), hash|
+            next if BASE_HEADERS.include?(header)
+
+            hash[formatted_header(header)] = value
+          end
+        end
+
+        def formatted_header(raw_name)
+          "#{ATTRIBUTE_PREFIX}#{NewRelic::LanguageSupport.camelize_with_first_letter_downcased(raw_name)}".to_sym
+        end
       end
     end
   end

data/lib/new_relic/agent/transaction/trace_context.rb

@@ -95,7 +95,7 @@ module NewRelic
 
         def create_trace_state_payload
           unless Agent.config[:'distributed_tracing.enabled']
-            NewRelic::Agent.logger.warn('Not configured to create WC3 trace context payload')
+            NewRelic::Agent.logger.warn('Not configured to create W3C trace context payload')
             return
           end
 
@@ -136,10 +136,8 @@ module NewRelic
 
           transaction.distributed_tracer.parent_transaction_id = payload.transaction_id
 
-          unless payload.sampled.nil?
-            transaction.sampled = payload.sampled
-            transaction.priority = payload.priority if payload.priority
-          end
+          determine_sampling_decision(payload, header_data.trace_parent['trace_flags'])
+
           NewRelic::Agent.increment_metric(ACCEPT_SUCCESS_METRIC)
           true
         rescue => e
@@ -148,6 +146,37 @@ module NewRelic
           false
         end
 
+        def determine_sampling_decision(payload, trace_flags)
+          if trace_flags == '01'
+            set_priority_and_sampled(NewRelic::Agent.config[:'distributed_tracing.sampler.remote_parent_sampled'], payload)
+          elsif trace_flags == '00'
+            set_priority_and_sampled(NewRelic::Agent.config[:'distributed_tracing.sampler.remote_parent_not_sampled'], payload)
+          else
+            use_nr_tracestate_sampled(payload)
+          end
+        rescue
+          use_nr_tracestate_sampled(payload)
+        end
+
+        def use_nr_tracestate_sampled(payload)
+          unless payload.sampled.nil?
+            transaction.sampled = payload.sampled
+            transaction.priority = payload.priority if payload.priority
+          end
+        end
+
+        def set_priority_and_sampled(config, payload)
+          if config == 'always_on'
+            transaction.sampled = true
+            transaction.priority = 2.0
+          elsif config == 'always_off'
+            transaction.sampled = false
+            transaction.priority = 0
+          else # default
+            use_nr_tracestate_sampled(payload)
+          end
+        end
+
         def ignore_trace_context?
           if trace_context_header_data
             NewRelic::Agent.increment_metric(IGNORE_MULTIPLE_ACCEPT_METRIC)

data/lib/new_relic/agent/transaction/tracing.rb

@@ -22,20 +22,36 @@ module NewRelic
 
         def add_segment(segment, parent = nil)
           segment.transaction = self
-          segment.parent = parent || current_segment
+          segment.parent = parent || thread_starting_span || current_segment
           set_current_segment(segment)
           if @segments.length < segment_limit
-            @segments << segment
+            @segment_lock.synchronize { @segments << segment }
           else
             segment.record_on_finish = true
             ::NewRelic::Agent.logger.debug("Segment limit of #{segment_limit} reached, ceasing collection.")
+
+            if finished?
+              ::NewRelic::Agent.logger.debug("Transaction #{best_name} has finished but segments still being created, resetting state.")
+              NewRelic::Agent::Tracer.state.reset
+              NewRelic::Agent.record_metric('Supportability/Transaction/SegmentLimitReachedAfterFinished/ResetState', 1)
+            end
           end
           segment.transaction_assigned
         end
 
+        def thread_starting_span
+          # if the previous current segment was in another thread, use the thread local parent
+          if ThreadLocalStorage[:newrelic_thread_span_parent] &&
+              current_segment &&
+              current_segment.starting_segment_key != NewRelic::Agent::Tracer.current_segment_key
+
+            ThreadLocalStorage[:newrelic_thread_span_parent]
+          end
+        end
+
         def segment_complete(segment)
           # if parent was in another thread, remove the current_segment entry for this thread
-          if segment.parent && segment.parent.starting_segment_key != NewRelic::Agent::Tracer.current_segment_key
+          if segment.parent&.starting_segment_key != NewRelic::Agent::Tracer.current_segment_key
             remove_current_segment_by_thread_id(NewRelic::Agent::Tracer.current_segment_key)
           else
             set_current_segment(segment.parent)
@@ -49,7 +65,7 @@ module NewRelic
         private
 
         def finalize_segments
-          segments.each { |s| s.finalize }
+          @segment_lock.synchronize { segments.each { |s| s&.finalize } }
         end
 
         WEB_TRANSACTION_TOTAL_TIME = 'WebTransactionTotalTime'.freeze

data/lib/new_relic/agent/transaction.rb

@@ -31,11 +31,12 @@ module NewRelic
       RAKE_PREFIX = "#{OTHER_TRANSACTION_PREFIX}Rake/"
       MESSAGE_PREFIX = "#{OTHER_TRANSACTION_PREFIX}Message/"
       RACK_PREFIX = "#{CONTROLLER_PREFIX}Rack/"
+      RODA_PREFIX = "#{CONTROLLER_PREFIX}Roda/"
       SINATRA_PREFIX = "#{CONTROLLER_PREFIX}Sinatra/"
       GRAPE_PREFIX = "#{CONTROLLER_PREFIX}Grape/"
       ACTION_CABLE_PREFIX = "#{CONTROLLER_PREFIX}ActionCable/"
 
-      WEB_TRANSACTION_CATEGORIES = [:web, :controller, :uri, :rack, :sinatra, :grape, :middleware, :action_cable].freeze
+      WEB_TRANSACTION_CATEGORIES = %i[action_cable controller grape middleware rack roda sinatra web uri].freeze
 
       MIDDLEWARE_SUMMARY_METRICS = ['Middleware/all'].freeze
       WEB_SUMMARY_METRIC = 'HttpDispatcher'
@@ -89,7 +90,7 @@ module NewRelic
       attr_reader :transaction_trace
 
       # Fields for tracking synthetics requests
-      attr_accessor :raw_synthetics_header, :synthetics_payload
+      attr_accessor :raw_synthetics_header, :synthetics_payload, :synthetics_info_payload, :raw_synthetics_info_header
 
       # Return the currently active transaction, or nil.
       def self.tl_current
@@ -214,6 +215,7 @@ module NewRelic
         @nesting_max_depth = 0
         @current_segment_by_thread = {}
         @current_segment_lock = Mutex.new
+        @segment_lock = Mutex.new
         @segments = []
 
         self.default_name = options[:transaction_name]
@@ -289,7 +291,7 @@ module NewRelic
       end
 
       def sampled?
-        return unless Agent.config[:'distributed_tracing.enabled']
+        return false unless Agent.config[:'distributed_tracing.enabled']
 
         if @sampled.nil?
           @sampled = NewRelic::Agent.instance.adaptive_sampler.sampled?
@@ -436,7 +438,11 @@ module NewRelic
       end
 
       def initial_segment
-        segments.first
+        segments&.first
+      end
+
+      def finished?
+        initial_segment&.finished?
       end
 
       def create_initial_segment(options = {})
@@ -515,7 +521,7 @@ module NewRelic
       end
 
       def finish
-        return unless state.is_execution_traced?
+        return unless state.is_execution_traced? && initial_segment
 
         @end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
         @duration = @end_time - @start_time
@@ -541,8 +547,8 @@ module NewRelic
       end
 
       def user_defined_rules_ignore?
-        return unless request_path
-        return if (rules = NewRelic::Agent.config[:"rules.ignore_url_regexes"]).empty?
+        return false unless request_path
+        return false if (rules = NewRelic::Agent.config[:"rules.ignore_url_regexes"]).empty?
 
         rules.any? do |rule|
           request_path.match(rule)
@@ -618,11 +624,24 @@ module NewRelic
           attributes.add_intrinsic_attribute(:synthetics_resource_id, synthetics_resource_id)
           attributes.add_intrinsic_attribute(:synthetics_job_id, synthetics_job_id)
           attributes.add_intrinsic_attribute(:synthetics_monitor_id, synthetics_monitor_id)
+          attributes.add_intrinsic_attribute(:synthetics_type, synthetics_info('type'))
+          attributes.add_intrinsic_attribute(:synthetics_initiator, synthetics_info('initiator'))
+
+          synthetics_additional_attributes do |key, value|
+            attributes.add_intrinsic_attribute(key, value)
+          end
         end
 
         distributed_tracer.assign_intrinsics
       end
 
+      def synthetics_additional_attributes(&block)
+        synthetics_info('attributes')&.each do |k, v|
+          new_key = "synthetics_#{NewRelic::LanguageSupport.snakeize(k.to_s)}".to_sym
+          yield(new_key, v.to_s)
+        end
+      end
+
       def calculate_gc_time
         gc_stop_snapshot = NewRelic::Agent::StatsEngine::GCProfiler.take_snapshot
         NewRelic::Agent::StatsEngine::GCProfiler.record_delta(gc_start_snapshot, gc_stop_snapshot)
@@ -702,6 +721,10 @@ module NewRelic
         info[4]
       end
 
+      def synthetics_info(key)
+        synthetics_info_payload[key] if synthetics_info_payload
+      end
+
       def append_apdex_perf_zone(payload)
         if recording_web_transaction?
           bucket = apdex_bucket(duration, apdex_t)
@@ -725,6 +748,12 @@ module NewRelic
         payload[:synthetics_resource_id] = synthetics_resource_id
         payload[:synthetics_job_id] = synthetics_job_id
         payload[:synthetics_monitor_id] = synthetics_monitor_id
+        payload[:synthetics_type] = synthetics_info('type')
+        payload[:synthetics_initiator] = synthetics_info('initiator')
+
+        synthetics_additional_attributes do |key, value|
+          payload[key] = value
+        end
       end
 
       def merge_metrics
@@ -788,13 +817,9 @@ module NewRelic
       end
 
       def had_error_affecting_apdex?
-        @exceptions.each do |exception, options|
-          ignored = NewRelic::Agent.instance.error_collector.error_is_ignored?(exception)
-          expected = options[:expected]
-
-          return true unless ignored || expected
+        @exceptions.each.any? do |exception, options|
+          NewRelic::Agent.instance.error_collector.error_affects_apdex?(exception, options)
         end
-        false
       end
 
       def apdex_bucket(duration, current_apdex_t)

data/lib/new_relic/agent/transaction_error_primitive.rb

@@ -16,23 +16,29 @@ module NewRelic
     module TransactionErrorPrimitive
       extend self
 
-      SAMPLE_TYPE = 'TransactionError'.freeze
-      TYPE_KEY = 'type'.freeze
-      ERROR_CLASS_KEY = 'error.class'.freeze
-      ERROR_MESSAGE_KEY = 'error.message'.freeze
-      ERROR_EXPECTED_KEY = 'error.expected'.freeze
-      TIMESTAMP_KEY = 'timestamp'.freeze
-      PORT_KEY = 'port'.freeze
-      NAME_KEY = 'transactionName'.freeze
-      DURATION_KEY = 'duration'.freeze
-      SAMPLED_KEY = 'sampled'.freeze
-      GUID_KEY = 'nr.transactionGuid'.freeze
-      REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'.freeze
-      SYNTHETICS_RESOURCE_ID_KEY = 'nr.syntheticsResourceId'.freeze
-      SYNTHETICS_JOB_ID_KEY = 'nr.syntheticsJobId'.freeze
-      SYNTHETICS_MONITOR_ID_KEY = 'nr.syntheticsMonitorId'.freeze
-      PRIORITY_KEY = 'priority'.freeze
-      SPAN_ID_KEY = 'spanId'.freeze
+      SAMPLE_TYPE = 'TransactionError'
+      TYPE_KEY = 'type'
+      ERROR_CLASS_KEY = 'error.class'
+      ERROR_MESSAGE_KEY = 'error.message'
+      ERROR_EXPECTED_KEY = 'error.expected'
+      TIMESTAMP_KEY = 'timestamp'
+      PORT_KEY = 'port'
+      NAME_KEY = 'transactionName'
+      DURATION_KEY = 'duration'
+      SAMPLED_KEY = 'sampled'
+      CAT_GUID_KEY = 'nr.transactionGuid'
+      CAT_REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'
+      SYNTHETICS_RESOURCE_ID_KEY = 'nr.syntheticsResourceId'
+      SYNTHETICS_JOB_ID_KEY = 'nr.syntheticsJobId'
+      SYNTHETICS_MONITOR_ID_KEY = 'nr.syntheticsMonitorId'
+      SYNTHETICS_TYPE_KEY = 'nr.syntheticsType'
+      SYNTHETICS_INITIATOR_KEY = 'nr.syntheticsInitiator'
+      SYNTHETICS_KEY_PREFIX = 'nr.synthetics'
+      PRIORITY_KEY = 'priority'
+      SPAN_ID_KEY = 'spanId'
+      GUID_KEY = 'guid'
+
+      SYNTHETICS_PAYLOAD_EXPECTED = [:synthetics_resource_id, :synthetics_job_id, :synthetics_monitor_id, :synthetics_type, :synthetics_initiator]
 
       def create(noticed_error, payload, span_id)
         [
@@ -52,7 +58,10 @@ module NewRelic
         }
 
         attrs[SPAN_ID_KEY] = span_id if span_id
+        # don't use safe navigation - leave off keys with missing values
+        # instead of using nil
         attrs[PORT_KEY] = noticed_error.request_port if noticed_error.request_port
+        attrs[GUID_KEY] = noticed_error.transaction_id if noticed_error.transaction_id
 
         if payload
           attrs[NAME_KEY] = payload[:name]
@@ -71,14 +80,25 @@ module NewRelic
       end
 
       def append_synthetics(payload, sample)
+        return unless payload[:synthetics_job_id]
+
         sample[SYNTHETICS_RESOURCE_ID_KEY] = payload[:synthetics_resource_id] if payload[:synthetics_resource_id]
         sample[SYNTHETICS_JOB_ID_KEY] = payload[:synthetics_job_id] if payload[:synthetics_job_id]
         sample[SYNTHETICS_MONITOR_ID_KEY] = payload[:synthetics_monitor_id] if payload[:synthetics_monitor_id]
+        sample[SYNTHETICS_TYPE_KEY] = payload[:synthetics_type] if payload[:synthetics_type]
+        sample[SYNTHETICS_INITIATOR_KEY] = payload[:synthetics_initiator] if payload[:synthetics_initiator]
+
+        payload.each do |k, v|
+          next unless k.to_s.start_with?('synthetics_') && !SYNTHETICS_PAYLOAD_EXPECTED.include?(k)
+
+          new_key = SYNTHETICS_KEY_PREFIX + NewRelic::LanguageSupport.camelize(k.to_s.gsub('synthetics_', ''))
+          sample[new_key] = v
+        end
       end
 
       def append_cat(payload, sample)
-        sample[GUID_KEY] = payload[:guid] if payload[:guid]
-        sample[REFERRING_TRANSACTION_GUID_KEY] = payload[:referring_transaction_guid] if payload[:referring_transaction_guid]
+        sample[CAT_GUID_KEY] = payload[:guid] if payload[:guid]
+        sample[CAT_REFERRING_TRANSACTION_GUID_KEY] = payload[:referring_transaction_guid] if payload[:referring_transaction_guid]
       end
     end
   end

data/lib/new_relic/agent/transaction_event_primitive.rb

@@ -38,6 +38,11 @@ module NewRelic
       SYNTHETICS_RESOURCE_ID_KEY = 'nr.syntheticsResourceId'
       SYNTHETICS_JOB_ID_KEY = 'nr.syntheticsJobId'
       SYNTHETICS_MONITOR_ID_KEY = 'nr.syntheticsMonitorId'
+      SYNTHETICS_TYPE_KEY = 'nr.syntheticsType'
+      SYNTHETICS_INITIATOR_KEY = 'nr.syntheticsInitiator'
+      SYNTHETICS_KEY_PREFIX = 'nr.synthetics'
+
+      SYNTHETICS_PAYLOAD_EXPECTED = [:synthetics_resource_id, :synthetics_job_id, :synthetics_monitor_id, :synthetics_type, :synthetics_initiator]
 
       def create(payload)
         intrinsics = {
@@ -71,9 +76,23 @@ module NewRelic
         optionally_append(SYNTHETICS_RESOURCE_ID_KEY, :synthetics_resource_id, sample, payload)
         optionally_append(SYNTHETICS_JOB_ID_KEY, :synthetics_job_id, sample, payload)
         optionally_append(SYNTHETICS_MONITOR_ID_KEY, :synthetics_monitor_id, sample, payload)
+        optionally_append(SYNTHETICS_TYPE_KEY, :synthetics_type, sample, payload)
+        optionally_append(SYNTHETICS_INITIATOR_KEY, :synthetics_initiator, sample, payload)
+        append_synthetics_info_attributes(sample, payload)
         append_cat_alternate_path_hashes(sample, payload)
       end
 
+      def append_synthetics_info_attributes(sample, payload)
+        return unless payload.include?(:synthetics_job_id)
+
+        payload.each do |k, v|
+          next unless k.to_s.start_with?('synthetics_') && !SYNTHETICS_PAYLOAD_EXPECTED.include?(k)
+
+          new_key = SYNTHETICS_KEY_PREFIX + NewRelic::LanguageSupport.camelize(k.to_s.gsub('synthetics_', ''))
+          sample[new_key] = v.to_s
+        end
+      end
+
       def append_cat_alternate_path_hashes(sample, payload)
         if payload.include?(:cat_alternate_path_hashes)
           sample[CAT_ALTERNATE_PATH_HASHES_KEY] = payload[:cat_alternate_path_hashes].sort.join(COMMA)

data/lib/new_relic/agent/transaction_time_aggregator.rb

@@ -150,7 +150,7 @@ module NewRelic
           # rubocop:disable Style/SafeNavigation
           transaction_name = transaction_name = Tracer.current_transaction &&
             Tracer.current_transaction.best_name ||
-            'unknown'
+            NewRelic::UNKNOWN_LOWER
           # rubocop:enable Style/SafeNavigation
           NewRelic::Agent.logger.warn("Unable to calculate elapsed transaction time for #{transaction_name}")
         end

data/lib/new_relic/agent/utilization/ecs.rb

@@ -0,0 +1,22 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/utilization/vendor'
+
+module NewRelic
+  module Agent
+    module Utilization
+      class ECS < Vendor
+        vendor_name 'ecs'
+        endpoint ENV['ECS_CONTAINER_METADATA_URI'] || ''
+        headers 'Metadata' => 'true'
+        keys %w[DockerId]
+
+        def transform_key(key)
+          'ecs' + key
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization/ecs_v4.rb

@@ -0,0 +1,22 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/utilization/vendor'
+
+module NewRelic
+  module Agent
+    module Utilization
+      class ECSV4 < Vendor
+        vendor_name 'ecs_v4'
+        endpoint ENV['ECS_CONTAINER_METADATA_URI_V4'] || ''
+        headers 'Metadata' => 'true'
+        keys %w[DockerId]
+
+        def transform_key(key)
+          'ecs' + key
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/utilization/gcp.rb

@@ -24,10 +24,8 @@ module NewRelic
           body
         end
 
-        SLASH = '/'.freeze
-
         def trim_leading(value)
-          value.split(SLASH).last
+          value.split(NewRelic::SLASH).last
         end
       end
     end

data/lib/new_relic/agent/utilization/vendor.rb

@@ -75,14 +75,12 @@ module NewRelic
           processed_headers = headers
           raise if processed_headers.value?(:error)
 
-          Timeout.timeout(1) do
-            response = nil
-            Net::HTTP.start(endpoint.host, endpoint.port) do |http|
-              req = Net::HTTP::Get.new(endpoint, processed_headers)
-              response = http.request(req)
-            end
-            response
+          response = nil
+          Net::HTTP.start(endpoint.host, endpoint.port, open_timeout: 1, read_timeout: 1) do |http|
+            req = Net::HTTP::Get.new(endpoint, processed_headers)
+            response = http.request(req)
           end
+          response
         rescue
           NewRelic::Agent.logger.debug("#{vendor_name} environment not detected")
         end

data/lib/new_relic/agent/utilization_data.rb

@@ -6,6 +6,8 @@ require 'new_relic/agent/utilization/aws'
 require 'new_relic/agent/utilization/gcp'
 require 'new_relic/agent/utilization/azure'
 require 'new_relic/agent/utilization/pcf'
+require 'new_relic/agent/utilization/ecs'
+require 'new_relic/agent/utilization/ecs_v4'
 
 module NewRelic
   module Agent
@@ -84,18 +86,51 @@ module NewRelic
         result
       end
 
+      def append_ecs_info(collector_hash)
+        return unless Agent.config[:'utilization.detect_aws']
+
+        Thread.new do
+          # try v4 first, and only try unversioned endpoint if v4 fails
+          ecs = Utilization::ECSV4.new
+          if ecs.detect
+            collector_hash[:vendors] ||= {}
+            collector_hash[:vendors][:ecs] = ecs.metadata
+          else
+            ecs = Utilization::ECS.new
+            if ecs.detect
+              collector_hash[:vendors] ||= {}
+              collector_hash[:vendors][:ecs] = ecs.metadata
+            end
+          end
+        end
+      end
+
       def append_vendor_info(collector_hash)
+        threads = []
+        complete = false
+
+        # ecs needs be checked even if AWS check succeeds
+        ecs_thread = append_ecs_info(collector_hash)
+
         VENDORS.each_pair do |klass, config_option|
           next unless Agent.config[config_option]
 
-          vendor = klass.new
+          threads << Thread.new do
+            vendor = klass.new
 
-          if vendor.detect
-            collector_hash[:vendors] ||= {}
-            collector_hash[:vendors][vendor.vendor_name.to_sym] = vendor.metadata
-            break
+            if vendor.detect
+              collector_hash[:vendors] ||= {}
+              collector_hash[:vendors][vendor.vendor_name.to_sym] = vendor.metadata
+
+              complete = true
+            end
           end
         end
+
+        while complete == false && threads.any?(&:alive?)
+          sleep 0.01
+        end
+        ecs_thread&.join
       end
 
       def append_docker_info(collector_hash)