newrelic_rpm 6.15.0 → 8.13.1

data/lib/new_relic/agent/transaction_error_primitive.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 # This module was introduced and largely extracted from the transaction event aggregator
 # when the synthetics container was extracted from it. Its purpose is to create the data
@@ -16,25 +16,25 @@ 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
+      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
+      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
 
-      def create noticed_error, payload, span_id
+      def create(noticed_error, payload, span_id)
         [
           intrinsic_attributes_for(noticed_error, payload, span_id),
           noticed_error.custom_attributes,
@@ -42,7 +42,7 @@ module NewRelic
         ]
       end
 
-      def intrinsic_attributes_for noticed_error, payload, span_id
+      def intrinsic_attributes_for(noticed_error, payload, span_id)
         attrs = {
           TYPE_KEY => SAMPLE_TYPE,
           ERROR_CLASS_KEY => noticed_error.exception_class_name,
@@ -59,22 +59,24 @@ module NewRelic
           attrs[DURATION_KEY] = payload[:duration]
           attrs[SAMPLED_KEY] = payload[:sampled] if payload.key?(:sampled)
           attrs[PRIORITY_KEY] = payload[:priority]
-          append_synthetics payload, attrs
-          append_cat payload, attrs
-          DistributedTraceAttributes.copy_to_hash payload, attrs
-          PayloadMetricMapping.append_mapped_metrics payload[:metrics], attrs
+          append_synthetics(payload, attrs)
+          append_cat(payload, attrs)
+          DistributedTraceAttributes.copy_to_hash(payload, attrs)
+          PayloadMetricMapping.append_mapped_metrics(payload[:metrics], attrs)
+        else
+          attrs[PRIORITY_KEY] = rand.round(NewRelic::PRIORITY_PRECISION)
         end
 
         attrs
       end
 
-      def append_synthetics payload, sample
+      def append_synthetics(payload, sample)
         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]
       end
 
-      def append_cat payload, sample
+      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]
       end

data/lib/new_relic/agent/transaction_event_aggregator.rb

@@ -1,43 +1,43 @@
 # -*- ruby -*-
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
-require 'newrelic_rpm' unless defined?( NewRelic )
-require 'new_relic/agent' unless defined?( NewRelic::Agent )
+require 'newrelic_rpm' unless defined?(NewRelic)
+require 'new_relic/agent' unless defined?(NewRelic::Agent)
 require 'new_relic/agent/event_aggregator'
 require 'new_relic/agent/priority_sampled_buffer'
 
 module NewRelic
   module Agent
     class TransactionEventAggregator < EventAggregator
-
       named :TransactionEventAggregator
-      capacity_key :'analytics_events.max_samples_stored'
-      enabled_key :'analytics_events.enabled'
+      capacity_key :'transaction_events.max_samples_stored'
+      enabled_key :'transaction_events.enabled'
       buffer_class PrioritySampledBuffer
 
-      def record priority: nil, event:nil, &blk
-        unless(event || priority && blk)
+      def record(priority: nil, event: nil, &blk)
+        unless event || priority && blk
           raise ArgumentError, "Expected priority and block, or event"
         end
 
         return unless enabled?
 
         @lock.synchronize do
-          @buffer.append priority: priority, event: event, &blk
+          @buffer.append(priority: priority, event: event, &blk)
           notify_if_full
         end
       end
 
       private
 
-      def after_harvest metadata
+      def after_harvest(metadata)
         return unless enabled?
-        record_sampling_rate metadata
+
+        record_sampling_rate(metadata)
       end
 
-      def record_sampling_rate(metadata) #THREAD_LOCAL_ACCESS
+      def record_sampling_rate(metadata) # THREAD_LOCAL_ACCESS
         NewRelic::Agent.logger.debug("Sampled %d / %d (%.1f %%) requests this cycle, %d / %d (%.1f %%) since startup" % [
           metadata[:captured],
           metadata[:seen],

data/lib/new_relic/agent/transaction_event_primitive.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 # frozen_string_literal: true
@@ -20,41 +19,41 @@ module NewRelic
       COMMA = ','
 
       # The type field of the sample
-      SAMPLE_TYPE              = 'Transaction'
+      SAMPLE_TYPE = 'Transaction'
 
       # Strings for static keys of the sample structure
-      TYPE_KEY                       = 'type'
-      TIMESTAMP_KEY                  = 'timestamp'
-      NAME_KEY                       = 'name'
-      DURATION_KEY                   = 'duration'
-      ERROR_KEY                      = 'error'
-      SAMPLED_KEY                    = 'sampled'
-      PRIORITY_KEY                   = 'priority'
-      GUID_KEY                       = 'nr.guid'
+      TYPE_KEY = 'type'
+      TIMESTAMP_KEY = 'timestamp'
+      NAME_KEY = 'name'
+      DURATION_KEY = 'duration'
+      ERROR_KEY = 'error'
+      SAMPLED_KEY = 'sampled'
+      PRIORITY_KEY = 'priority'
+      GUID_KEY = 'nr.guid'
       REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'
-      CAT_PATH_HASH_KEY              = 'nr.pathHash'
-      CAT_REFERRING_PATH_HASH_KEY    = 'nr.referringPathHash'
-      CAT_ALTERNATE_PATH_HASHES_KEY  = 'nr.alternatePathHashes'
-      APDEX_PERF_ZONE_KEY            = 'nr.apdexPerfZone'
-      SYNTHETICS_RESOURCE_ID_KEY     = "nr.syntheticsResourceId"
-      SYNTHETICS_JOB_ID_KEY          = "nr.syntheticsJobId"
-      SYNTHETICS_MONITOR_ID_KEY      = "nr.syntheticsMonitorId"
+      CAT_PATH_HASH_KEY = 'nr.pathHash'
+      CAT_REFERRING_PATH_HASH_KEY = 'nr.referringPathHash'
+      CAT_ALTERNATE_PATH_HASHES_KEY = 'nr.alternatePathHashes'
+      APDEX_PERF_ZONE_KEY = 'nr.apdexPerfZone'
+      SYNTHETICS_RESOURCE_ID_KEY = "nr.syntheticsResourceId"
+      SYNTHETICS_JOB_ID_KEY = "nr.syntheticsJobId"
+      SYNTHETICS_MONITOR_ID_KEY = "nr.syntheticsMonitorId"
 
       def create(payload)
         intrinsics = {
-        TIMESTAMP_KEY => float(payload[:start_timestamp]),
-        NAME_KEY      => string(payload[:name]),
-        DURATION_KEY  => float(payload[:duration]),
-        TYPE_KEY      => SAMPLE_TYPE,
-        ERROR_KEY     => payload[:error],
-        PRIORITY_KEY  => payload[:priority]
+          TIMESTAMP_KEY => float(payload[:start_timestamp]),
+          NAME_KEY => string(payload[:name]),
+          DURATION_KEY => float(payload[:duration]),
+          TYPE_KEY => SAMPLE_TYPE,
+          ERROR_KEY => payload[:error],
+          PRIORITY_KEY => payload[:priority]
         }
 
         intrinsics[SAMPLED_KEY] = payload[:sampled] if payload.key?(:sampled)
 
         PayloadMetricMapping.append_mapped_metrics(payload[:metrics], intrinsics)
         append_optional_attributes(intrinsics, payload)
-        DistributedTraceAttributes.copy_to_hash payload, intrinsics
+        DistributedTraceAttributes.copy_to_hash(payload, intrinsics)
 
         attributes = payload[:attributes]
 
@@ -64,14 +63,14 @@ module NewRelic
       private
 
       def append_optional_attributes(sample, payload)
-        optionally_append(GUID_KEY,                       :guid, sample, payload)
+        optionally_append(GUID_KEY, :guid, sample, payload)
         optionally_append(REFERRING_TRANSACTION_GUID_KEY, :referring_transaction_guid, sample, payload)
-        optionally_append(CAT_PATH_HASH_KEY,              :cat_path_hash, sample, payload)
-        optionally_append(CAT_REFERRING_PATH_HASH_KEY,    :cat_referring_path_hash, sample, payload)
-        optionally_append(APDEX_PERF_ZONE_KEY,            :apdex_perf_zone, sample, payload)
-        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(CAT_PATH_HASH_KEY, :cat_path_hash, sample, payload)
+        optionally_append(CAT_REFERRING_PATH_HASH_KEY, :cat_referring_path_hash, sample, payload)
+        optionally_append(APDEX_PERF_ZONE_KEY, :apdex_perf_zone, sample, payload)
+        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)
         append_cat_alternate_path_hashes(sample, payload)
       end
 
@@ -87,7 +86,7 @@ module NewRelic
         end
       end
 
-      def custom_attributes attributes
+      def custom_attributes(attributes)
         if attributes
           result = attributes.custom_attributes_for(AttributeFilter::DST_TRANSACTION_EVENTS)
           result.freeze
@@ -96,7 +95,7 @@ module NewRelic
         end
       end
 
-      def agent_attributes attributes
+      def agent_attributes(attributes)
         if attributes
           result = attributes.agent_attributes_for(AttributeFilter::DST_TRANSACTION_EVENTS)
           result.freeze

data/lib/new_relic/agent/transaction_event_recorder.rb

@@ -1,42 +1,43 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
 require 'new_relic/agent/transaction_event_aggregator'
 require 'new_relic/agent/synthetics_event_aggregator'
 require 'new_relic/agent/transaction_event_primitive'
 
 module NewRelic
   module Agent
-    # This is responsibile for recording transaction events and managing
+    # This is responsible for recording transaction events and managing
     # the relationship between events generated from synthetics requests
     # vs normal requests.
     class TransactionEventRecorder
       attr_reader :transaction_event_aggregator
       attr_reader :synthetics_event_aggregator
 
-      def initialize events
-        @transaction_event_aggregator = NewRelic::Agent::TransactionEventAggregator.new events
-        @synthetics_event_aggregator = NewRelic::Agent::SyntheticsEventAggregator.new events
+      def initialize(events)
+        @transaction_event_aggregator = NewRelic::Agent::TransactionEventAggregator.new(events)
+        @synthetics_event_aggregator = NewRelic::Agent::SyntheticsEventAggregator.new(events)
       end
 
-      def record payload
-        return unless NewRelic::Agent.config[:'analytics_events.enabled']
+      def record(payload)
+        return unless NewRelic::Agent.config[:'transaction_events.enabled']
 
-        if synthetics_event? payload
-          event = create_event payload
-          result = synthetics_event_aggregator.record event
-          transaction_event_aggregator.record event: event if result.nil?
+        if synthetics_event?(payload)
+          event = create_event(payload)
+          result = synthetics_event_aggregator.record(event)
+          transaction_event_aggregator.record(event: event) if result.nil?
         else
           transaction_event_aggregator.record(priority: payload[:priority]) { create_event(payload) }
         end
       end
 
-      def create_event payload
-        TransactionEventPrimitive.create payload
+      def create_event(payload)
+        TransactionEventPrimitive.create(payload)
       end
 
-      def synthetics_event? payload
-        payload.key? :synthetics_resource_id
+      def synthetics_event?(payload)
+        payload.key?(:synthetics_resource_id)
       end
 
       def drop_buffered_data

data/lib/new_relic/agent/transaction_metrics.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 # This class represents a set of metrics that were recorded during a single
 # transaction. Since the name of the transaction is not known until its end, we
@@ -10,11 +10,12 @@
 module NewRelic
   module Agent
     class TransactionMetrics
-      DEFAULT_PROC = Proc.new { |hash, name| hash[name] = NewRelic::Agent::Stats.new }
+      DEFAULT_PROC = proc { |hash, name| hash[name] = NewRelic::Agent::Stats.new }
 
       def initialize
+        @lock = Mutex.new
         @unscoped = Hash.new(&DEFAULT_PROC)
-        @scoped   = Hash.new(&DEFAULT_PROC)
+        @scoped = Hash.new(&DEFAULT_PROC)
       end
 
       # As a general rule, when recording a scoped metric, the corresponding
@@ -25,11 +26,11 @@ module NewRelic
       # propagate them into unscoped metrics as well when instances of this
       # class are merged into the global metric store.
       #
-      def record_scoped_and_unscoped(names, value=nil, aux=nil, &blk)
+      def record_scoped_and_unscoped(names, value = nil, aux = nil, &blk)
         _record_metrics(names, value, aux, @scoped, &blk)
       end
 
-      def record_unscoped(names, value=nil, aux=nil, &blk)
+      def record_unscoped(names, value = nil, aux = nil, &blk)
         _record_metrics(names, value, aux, @unscoped, &blk)
       end
 
@@ -42,11 +43,11 @@ module NewRelic
       end
 
       def each_unscoped
-        @unscoped.each { |name, stats| yield name, stats }
+        @lock.synchronize { @unscoped.each { |name, stats| yield(name, stats) } }
       end
 
       def each_scoped
-        @scoped.each { |name, stats| yield name, stats }
+        @lock.synchronize { @scoped.each { |name, stats| yield(name, stats) } }
       end
 
       def _record_metrics(names, value, aux, target, &blk)
@@ -54,10 +55,10 @@ module NewRelic
         case names
         when Array
           names.each do |name|
-            target[name].record(value, aux, &blk)
+            @lock.synchronize { target[name].record(value, aux, &blk) }
           end
         else
-          target[names].record(value, aux, &blk)
+          @lock.synchronize { target[names].record(value, aux, &blk) }
         end
       end
     end

data/lib/new_relic/agent/transaction_sampler.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/transaction/slowest_sample_buffer'
 require 'new_relic/agent/transaction/synthetics_sample_buffer'
@@ -8,7 +8,6 @@ require 'new_relic/agent/transaction/trace_builder'
 
 module NewRelic
   module Agent
-
     # This class contains the logic for recording and storing transaction
     # traces (sometimes referred to as 'transaction samples').
     #
@@ -33,9 +32,9 @@ module NewRelic
         Agent.config.register_callback(:'transaction_tracer.enabled') do |enabled|
           if enabled
             threshold = Agent.config[:'transaction_tracer.transaction_threshold']
-            ::NewRelic::Agent.logger.debug "Transaction tracing threshold is #{threshold} seconds."
+            ::NewRelic::Agent.logger.debug("Transaction tracing threshold is #{threshold} seconds.")
           else
-            ::NewRelic::Agent.logger.debug "Transaction traces will not be sent to the New Relic service."
+            ::NewRelic::Agent.logger.debug("Transaction traces will not be sent to the New Relic service.")
           end
         end
 
@@ -68,7 +67,7 @@ module NewRelic
 
       # Gather transaction traces that we'd like to transmit to the server.
       def harvest!
-        return [] unless enabled?
+        return NewRelic::EMPTY_ARRAY unless enabled?
 
         samples = @samples_lock.synchronize do
           @last_sample = nil
@@ -114,7 +113,7 @@ module NewRelic
         result.uniq!
         result.map! do |sample|
           if Transaction === sample
-            Transaction::TraceBuilder.build_trace sample
+            Transaction::TraceBuilder.build_trace(sample)
           else
             sample
           end

data/lib/new_relic/agent/transaction_time_aggregator.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 # This module powers the Busy calculation for the Capacity report in
 # APM (https://rpm.newrelic.com/accounts/.../applications/.../optimize/capacity_analysis).
@@ -12,36 +12,36 @@
 module NewRelic
   module Agent
     module TransactionTimeAggregator
-      TransactionStats = Struct.new :transaction_started_at, :elapsed_transaction_time
+      TransactionStats = Struct.new(:transaction_started_at, :elapsed_transaction_time)
 
-      @lock                     = Mutex.new
-      @harvest_cycle_started_at = Time.now
+      @lock = Mutex.new
+      @harvest_cycle_started_at = Process.clock_gettime(Process::CLOCK_REALTIME)
 
       @stats = Hash.new do |h, k|
-        h[k] = TransactionStats.new nil, 0.0
+        h[k] = TransactionStats.new(nil, 0.0)
       end
 
-      def reset!(timestamp = Time.now)
+      def reset!(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME))
         @harvest_cycle_started_at = timestamp
         @stats.clear
       end
 
-      def transaction_start(timestamp = Time.now)
+      def transaction_start(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME))
         @lock.synchronize do
-          set_transaction_start_time timestamp
+          set_transaction_start_time(timestamp)
         end
       end
 
-      def transaction_stop(timestamp = Time.now, starting_thread_id = current_thread)
+      def transaction_stop(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME), starting_thread_id = current_thread)
         @lock.synchronize do
-          record_elapsed_transaction_time_until timestamp, starting_thread_id
-          set_transaction_start_time nil, starting_thread_id
+          record_elapsed_transaction_time_until(timestamp, starting_thread_id)
+          set_transaction_start_time(nil, starting_thread_id)
         end
       end
 
       INSTANCE_BUSY_METRIC = 'Instance/Busy'.freeze
 
-      def harvest!(timestamp = Time.now)
+      def harvest!(timestamp = Process.clock_gettime(Process::CLOCK_REALTIME))
         active_threads = 0
         result = @lock.synchronize do
           # Sum up the transaction times spent in each thread
@@ -50,7 +50,7 @@ module NewRelic
           end
 
           active_threads = @stats.size
-          elapsed_harvest_time      = (timestamp - @harvest_cycle_started_at) * active_threads
+          elapsed_harvest_time = (timestamp - @harvest_cycle_started_at) * active_threads
           @harvest_cycle_started_at = timestamp
 
           # Clear out the stats for all threads, _except_ the live ones
@@ -75,9 +75,9 @@ module NewRelic
       end
 
       module_function :reset!,
-                      :transaction_start,
-                      :transaction_stop,
-                      :harvest!
+        :transaction_start,
+        :transaction_stop,
+        :harvest!
 
       class << self
         private
@@ -100,23 +100,23 @@ module NewRelic
         end
 
         def thread_is_alive?(thread_id)
-          thread = thread_by_id thread_id
+          thread = thread_by_id(thread_id)
           thread && thread.alive?
         rescue StandardError
           false
         end
 
         # ObjectSpace is faster on MRI, but disabled by default on JRuby for
-        # perfomance reasons. We have two implmentations of `thread_by_id`
+        # performance reasons. We have two implementations of `thread_by_id`
         # based on ruby implementation.
         if RUBY_ENGINE == 'jruby'
-          def thread_by_id thread_id
+          def thread_by_id(thread_id)
             Thread.list.detect { |t| t.object_id == thread_id }
           end
         else
           require 'objspace'
 
-          def thread_by_id thread_id
+          def thread_by_id(thread_id)
             ObjectSpace._id2ref(thread_id)
           end
         end
@@ -127,18 +127,19 @@ module NewRelic
 
         def split_transaction_at_harvest(timestamp, thread_id = nil)
           raise ArgumentError, 'thread_id required' unless thread_id
+
           @stats[thread_id].transaction_started_at = timestamp
           @stats[thread_id].elapsed_transaction_time = 0.0
         end
 
-        def transaction_time_in_thread timestamp, thread_id, entry
-          return entry.elapsed_transaction_time unless in_transaction? thread_id
+        def transaction_time_in_thread(timestamp, thread_id, entry)
+          return entry.elapsed_transaction_time unless in_transaction?(thread_id)
 
           # Count the portion of the transaction that's elapsed so far,...
-          elapsed = record_elapsed_transaction_time_until timestamp, thread_id
+          elapsed = record_elapsed_transaction_time_until(timestamp, thread_id)
 
           # ...then readjust the transaction start time to the next harvest
-          split_transaction_at_harvest timestamp, thread_id
+          split_transaction_at_harvest(timestamp, thread_id)
 
           elapsed
         end
@@ -146,7 +147,7 @@ module NewRelic
         def log_missing_elapsed_transaction_time
           transaction_name = Tracer.current_transaction &&
             Tracer.current_transaction.best_name ||
-              "unknown"
+            "unknown"
           NewRelic::Agent.logger.warn("Unable to calculate elapsed transaction time for #{transaction_name}")
         end
       end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/utilization/vendor'
 
@@ -8,9 +8,39 @@ module NewRelic
   module Agent
     module Utilization
       class AWS < Vendor
+        IMDS_BASE_URL = 'http://169.254.169.254/latest'.freeze
+        IMDS_KEYS = %w[instanceId instanceType availabilityZone].freeze
+        IMDS_TOKEN_TTL_SECS = '60'.freeze
+        TOKEN_OPEN_TIMEOUT_SECS = 1.freeze
+        TOKEN_READ_TIMEOUT_SECS = 1.freeze
+
+        class << self
+          def imds_token
+            uri = URI.parse("#{IMDS_BASE_URL}/api/token")
+            http = Net::HTTP.new(uri.hostname)
+            http.open_timeout = TOKEN_OPEN_TIMEOUT_SECS
+            http.read_timeout = TOKEN_READ_TIMEOUT_SECS
+            response = http.send_request('PUT',
+              uri.path,
+              '',
+              {'X-aws-ec2-metadata-token-ttl-seconds' => IMDS_TOKEN_TTL_SECS})
+            unless response.code == Vendor::SUCCESS
+              NewRelic::Agent.logger.debug('Failed to obtain an AWS token for use with IMDS - encountered ' \
+                                           "#{response.class} with HTTP response code #{response.code} - " \
+                                           'assuming non AWS')
+              return
+            end
+
+            response.body
+          rescue Net::OpenTimeout
+            NewRelic::Agent.logger.debug('Timed out waiting for AWS IMDS - assuming non AWS')
+          end
+        end
+
         vendor_name "aws"
-        endpoint "http://169.254.169.254/2016-09-02/dynamic/instance-identity/document"
-        keys ["instanceId", "instanceType", "availabilityZone"]
+        endpoint "#{IMDS_BASE_URL}/dynamic/instance-identity/document"
+        keys IMDS_KEYS
+        headers 'X-aws-ec2-metadata-token' => -> { imds_token }
         key_transforms :to_sym
       end
     end

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -9,9 +9,9 @@ module NewRelic
         vendor_name "azure"
         endpoint "http://169.254.169.254/metadata/instance/compute?api-version=2017-03-01"
         headers "Metadata" => "true"
-        keys ["vmId", "name", "vmSize", "location"]
+        keys %w[vmId name vmSize location]
         key_transforms :to_sym
       end
     end
   end
-end
+end