newrelic_rpm 6.8.0.360 → 9.2.2

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/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
 
 # 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
@@ -8,40 +8,41 @@
 # the transaction event aggregator and the synthetics container.
 
 require 'new_relic/agent/payload_metric_mapping'
-require 'new_relic/agent/distributed_trace_payload'
-require 'new_relic/agent/distributed_trace_intrinsics'
+require 'new_relic/agent/distributed_tracing/distributed_trace_payload'
+require 'new_relic/agent/distributed_tracing/distributed_trace_attributes'
 
 module NewRelic
   module Agent
     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
+      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
+      def create(noticed_error, payload, span_id)
         [
-          intrinsic_attributes_for(noticed_error, payload),
+          intrinsic_attributes_for(noticed_error, payload, span_id),
           noticed_error.custom_attributes,
           noticed_error.agent_attributes
         ]
       end
 
-      def intrinsic_attributes_for noticed_error, payload
+      def intrinsic_attributes_for(noticed_error, payload, span_id)
         attrs = {
           TYPE_KEY => SAMPLE_TYPE,
           ERROR_CLASS_KEY => noticed_error.exception_class_name,
@@ -50,6 +51,7 @@ module NewRelic
           TIMESTAMP_KEY => noticed_error.timestamp.to_f
         }
 
+        attrs[SPAN_ID_KEY] = span_id if span_id
         attrs[PORT_KEY] = noticed_error.request_port if noticed_error.request_port
 
         if payload
@@ -57,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
-          DistributedTraceIntrinsics.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,44 +1,44 @@
 # -*- ruby -*-
-# 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 '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)
-          raise ArgumentError, "Expected priority and block, or event"
+      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
-        NewRelic::Agent.logger.debug("Sampled %d / %d (%.1f %%) requests this cycle, %d / %d (%.1f %%) since startup" % [
+      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],
           (metadata[:captured].to_f / metadata[:seen] * 100.0),
@@ -48,8 +48,8 @@ module NewRelic
         ])
 
         engine = NewRelic::Agent.instance.stats_engine
-        engine.tl_record_supportability_metric_count("TransactionEventAggregator/requests", metadata[:seen])
-        engine.tl_record_supportability_metric_count("TransactionEventAggregator/samples", metadata[:captured])
+        engine.tl_record_supportability_metric_count('TransactionEventAggregator/requests', metadata[:seen])
+        engine.tl_record_supportability_metric_count('TransactionEventAggregator/samples', metadata[:captured])
       end
     end
   end

data/lib/new_relic/agent/transaction_event_primitive.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.
+# 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
@@ -8,7 +8,7 @@
 # the transaction event aggregator and the synthetics container.
 
 require 'new_relic/agent/payload_metric_mapping'
-require 'new_relic/agent/distributed_trace_intrinsics'
+require 'new_relic/agent/distributed_tracing/distributed_trace_attributes'
 
 module NewRelic
   module Agent
@@ -16,46 +16,44 @@ module NewRelic
       include NewRelic::Coerce
       extend self
 
+      COMMA = ','
+
       # The type field of the sample
-      SAMPLE_TYPE              = 'Transaction'.freeze
+      SAMPLE_TYPE = 'Transaction'
 
       # Strings for static keys of the sample structure
-      TYPE_KEY                       = 'type'.freeze
-      TIMESTAMP_KEY                  = 'timestamp'.freeze
-      NAME_KEY                       = 'name'.freeze
-      DURATION_KEY                   = 'duration'.freeze
-      ERROR_KEY                      = 'error'.freeze
-      SAMPLED_KEY                    = 'sampled'.freeze
-      PRIORITY_KEY                   = 'priority'.freeze
-      GUID_KEY                       = 'nr.guid'.freeze
-      REFERRING_TRANSACTION_GUID_KEY = 'nr.referringTransactionGuid'.freeze
-      CAT_PATH_HASH_KEY              = 'nr.pathHash'.freeze
-      CAT_REFERRING_PATH_HASH_KEY    = 'nr.referringPathHash'.freeze
-      CAT_ALTERNATE_PATH_HASHES_KEY  = 'nr.alternatePathHashes'.freeze
-      APDEX_PERF_ZONE_KEY            = 'nr.apdexPerfZone'.freeze
-      SYNTHETICS_RESOURCE_ID_KEY     = "nr.syntheticsResourceId".freeze
-      SYNTHETICS_JOB_ID_KEY          = "nr.syntheticsJobId".freeze
-      SYNTHETICS_MONITOR_ID_KEY      = "nr.syntheticsMonitorId".freeze
-
-
-      # To avoid allocations when we have empty custom or agent attributes
-      EMPTY_HASH = {}.freeze
+      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'
 
       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)
 
-        NewRelic::Agent::PayloadMetricMapping.append_mapped_metrics(payload[:metrics], intrinsics)
+        PayloadMetricMapping.append_mapped_metrics(payload[:metrics], intrinsics)
         append_optional_attributes(intrinsics, payload)
-        DistributedTraceIntrinsics.copy_to_hash payload, intrinsics
+        DistributedTraceAttributes.copy_to_hash(payload, intrinsics)
 
         attributes = payload[:attributes]
 
@@ -65,19 +63,17 @@ 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
 
-      COMMA = ','.freeze
-
       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)
@@ -90,21 +86,21 @@ module NewRelic
         end
       end
 
-      def custom_attributes attributes
+      def custom_attributes(attributes)
         if attributes
-          result = attributes.custom_attributes_for(NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS)
+          result = attributes.custom_attributes_for(AttributeFilter::DST_TRANSACTION_EVENTS)
           result.freeze
         else
-          EMPTY_HASH
+          NewRelic::EMPTY_HASH
         end
       end
 
-      def agent_attributes attributes
+      def agent_attributes(attributes)
         if attributes
-          result = attributes.agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS)
+          result = attributes.agent_attributes_for(AttributeFilter::DST_TRANSACTION_EVENTS)
           result.freeze
         else
-          EMPTY_HASH
+          NewRelic::EMPTY_HASH
         end
       end
     end

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/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 '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/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
 
 # 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/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 '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,15 +32,15 @@ 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
 
         Agent.config.register_callback(:'transaction_tracer.record_sql') do |config|
           if config == 'raw'
-            ::NewRelic::Agent.logger.warn("Agent is configured to send raw SQL to the service")
+            ::NewRelic::Agent.logger.warn('Agent is configured to send raw SQL to the service')
           end
         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
@@ -82,7 +81,7 @@ module NewRelic
           begin
             sample.prepare_to_send!
           rescue => e
-            NewRelic::Agent.logger.error("Failed to prepare transaction trace. Error: ", e)
+            NewRelic::Agent.logger.error('Failed to prepare transaction trace. Error: ', e)
             false
           else
             true
@@ -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/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
 
 # 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,24 @@ module NewRelic
         end
 
         def thread_is_alive?(thread_id)
-          thread = thread_by_id thread_id
-          thread && thread.alive?
+          thread = thread_by_id(thread_id)
+          # needs else branch coverage
+          thread && thread.alive? # rubocop:disable Style/SafeNavigation
         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,26 +128,30 @@ 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
 
+        # this method has no test coverage
         def log_missing_elapsed_transaction_time
-          transaction_name = Tracer.current_transaction &&
+          # rubocop:disable Style/SafeNavigation
+          transaction_name = transaction_name = Tracer.current_transaction &&
             Tracer.current_transaction.best_name ||
-              "unknown"
+            'unknown'
+          # rubocop:enable Style/SafeNavigation
           NewRelic::Agent.logger.warn("Unable to calculate elapsed transaction time for #{transaction_name}")
         end
       end