newrelic_rpm 6.3.0.355 → 9.2.0

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,39 +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_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,
@@ -49,40 +51,35 @@ 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
           attrs[NAME_KEY] = payload[:name]
           attrs[DURATION_KEY] = payload[:duration]
-          attrs[SAMPLED_KEY] = payload[:'sampled'] if Agent.config[:'distributed_tracing.enabled']
-          attrs[PRIORITY_KEY] = payload[:'priority']
-          append_synthetics payload, attrs
-          append_cat payload, attrs
-          append_distributed_trace_intrinsics payload, attrs
-          PayloadMetricMapping.append_mapped_metrics payload[:metrics], attrs
+          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)
+        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
-
-      def append_distributed_trace_intrinsics payload, sample
-        return unless Agent.config[:'distributed_tracing.enabled']
-        DistributedTracePayload::INTRINSIC_KEYS.each do |key|
-          value = payload[key]
-          sample[key] = value unless value.nil?
-        end
-      end
     end
   end
 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_payload'
+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 Agent.config[:'distributed_tracing.enabled']
+        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)
-        append_distributed_trace_intrinsics(intrinsics, payload)
+        DistributedTraceAttributes.copy_to_hash(payload, intrinsics)
 
         attributes = payload[:attributes]
 
@@ -65,54 +63,44 @@ 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)
         end
       end
 
-      def append_distributed_trace_intrinsics(sample, payload)
-        return unless Agent.config[:'distributed_tracing.enabled']
-        DistributedTracePayload::INTRINSIC_KEYS.each do |key|
-          value = payload[key]
-          sample[key] = value unless value.nil?
-        end
-      end
-
       def optionally_append(sample_key, payload_key, sample, payload)
         if payload.include?(payload_key)
           sample[sample_key] = string(payload[payload_key])
         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
-        @transaction_event_aggregator = NewRelic::Agent::TransactionEventAggregator.new
-        @synthetics_event_aggregator = NewRelic::Agent::SyntheticsEventAggregator.new
+      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,15 +1,13 @@
-# 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'
-require 'new_relic/agent/transaction/xray_sample_buffer'
 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').
     #
@@ -19,13 +17,10 @@ module NewRelic
     #
     # @api public
     class TransactionSampler
-      attr_reader :last_sample, :xray_sample_buffer
+      attr_reader :last_sample
 
       def initialize
-        @xray_sample_buffer = NewRelic::Agent::Transaction::XraySampleBuffer.new
-
         @sample_buffers = []
-        @sample_buffers << @xray_sample_buffer
         @sample_buffers << NewRelic::Agent::Transaction::SlowestSampleBuffer.new
         @sample_buffers << NewRelic::Agent::Transaction::SyntheticsSampleBuffer.new
 
@@ -37,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
@@ -72,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
@@ -86,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
@@ -118,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