newrelic_rpm 5.5.0.348 → 7.2.0

data/lib/new_relic/agent/transaction/trace_node.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.
 
 module NewRelic
   module Agent
@@ -21,11 +21,18 @@ module NewRelic
           @entry_timestamp = relative_start
           @metric_name     = metric_name || UNKNOWN_NODE_NAME
           @exit_timestamp  = relative_end
-          @children    = nil
-          @params          = params
+          @children        = nil
+          @params          = select_allowed_params(params)
           @parent_node     = parent
         end
 
+        def select_allowed_params params
+          return unless params
+          params.select do |p|
+            NewRelic::Agent.instance.attribute_filter.allows_key? p, AttributeFilter::DST_TRANSACTION_SEGMENTS
+          end
+        end
+
         # sets the final timestamp on a node to indicate the exit
         # point of the node
         def end_trace(timestamp)
@@ -36,16 +43,13 @@ module NewRelic
           to_debug_str(0)
         end
 
-        EMPTY_HASH = {}.freeze
-        EMPTY_ARRAY = [].freeze
-
         def to_array
-          params = @params ? @params : EMPTY_HASH
+          params = @params ? @params : NewRelic::EMPTY_HASH
           [ NewRelic::Helper.time_to_millis(@entry_timestamp),
             NewRelic::Helper.time_to_millis(@exit_timestamp),
             NewRelic::Coerce.string(@metric_name),
             params ] +
-            [ (@children ? @children.map{|s| s.to_array} : EMPTY_ARRAY) ]
+            [ (@children ? @children.map{|s| s.to_array} : NewRelic::EMPTY_ARRAY) ]
         end
 
         def path_string

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

@@ -1,110 +1,11 @@
 # 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.
-
-require 'new_relic/agent/transaction/segment'
-require 'new_relic/agent/transaction/datastore_segment'
-require 'new_relic/agent/transaction/external_request_segment'
-require 'new_relic/agent/transaction/message_broker_segment'
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 module NewRelic
   module Agent
     class Transaction
       module Tracing
-        module ClassMethods
-          def start_segment(name:nil,
-                            unscoped_metrics:nil,
-                            start_time: nil,
-                            parent: nil)
-
-            # ruby 2.0.0 does not support required kwargs
-            raise ArgumentError, 'missing required argument: name' if name.nil?
-
-            segment = Segment.new name, unscoped_metrics, start_time
-
-            start_and_add_segment segment, parent
-          end
-
-          UNKNOWN_PRODUCT = "Unknown".freeze
-          UNKNOWN_OPERATION = "other".freeze
-
-          def start_datastore_segment(product: nil,
-                                      operation: nil,
-                                      collection: nil,
-                                      host: nil,
-                                      port_path_or_id: nil,
-                                      database_name: nil,
-                                      start_time: nil,
-                                      parent: nil)
-
-            product ||= UNKNOWN_PRODUCT
-            operation ||= UNKNOWN_OPERATION
-
-            segment = DatastoreSegment.new product, operation, collection, host, port_path_or_id, database_name
-            start_and_add_segment segment, parent
-          end
-
-          def start_external_request_segment(library: nil,
-                                             uri: nil,
-                                             procedure: nil,
-                                             start_time: nil,
-                                             parent: nil)
-
-            # ruby 2.0.0 does not support required kwargs
-            raise ArgumentError, 'missing required argument: library' if library.nil?
-            raise ArgumentError, 'missing required argument: uri' if uri.nil?
-            raise ArgumentError, 'missing required argument: procedure' if procedure.nil?
-
-            segment = ExternalRequestSegment.new library, uri, procedure, start_time
-            start_and_add_segment segment, parent
-          end
-
-          # @api private
-          #
-          def start_message_broker_segment(action: nil,
-                                           library: nil,
-                                           destination_type: nil,
-                                           destination_name: nil,
-                                           headers: nil,
-                                           parameters: nil,
-                                           start_time: nil,
-                                           parent: nil)
-
-            # ruby 2.0.0 does not support required kwargs
-            raise ArgumentError, 'missing required argument: action' if action.nil?
-            raise ArgumentError, 'missing required argument: library' if library.nil?
-            raise ArgumentError, 'missing required argument: destination_type' if destination_type.nil?
-            raise ArgumentError, 'missing required argument: destination_name' if destination_name.nil?
-
-            segment = MessageBrokerSegment.new(
-              action: action,
-              library: library,
-              destination_type: destination_type,
-              destination_name: destination_name,
-              headers: headers,
-              parameters: parameters,
-              start_time: start_time
-            )
-            start_and_add_segment segment, parent
-          end
-
-          private
-
-          def start_and_add_segment segment, parent = nil
-            state = NewRelic::Agent::TransactionState.tl_get
-            if (txn = state.current_transaction) && state.is_execution_traced?
-              txn.add_segment segment, parent
-            else
-              segment.record_metrics = false
-            end
-            segment.start
-            segment
-          end
-        end
-
-        def self.included base
-          base.extend ClassMethods
-        end
 
         attr_reader :current_segment
 

data/lib/new_relic/agent/transaction/transaction_sample_buffer.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.
 
 module NewRelic
   module Agent

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.
 
 # 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,8 @@
 # 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
@@ -31,16 +32,17 @@ module NewRelic
       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,16 +51,17 @@ 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']
+          attrs[SAMPLED_KEY] = payload[:sampled] if payload.key?(:sampled)
+          attrs[PRIORITY_KEY] = payload[:priority]
           append_synthetics payload, attrs
           append_cat payload, attrs
-          append_distributed_trace_intrinsics payload, attrs
+          DistributedTraceAttributes.copy_to_hash payload, attrs
           PayloadMetricMapping.append_mapped_metrics payload[:metrics], attrs
         end
 
@@ -75,14 +78,6 @@ module NewRelic
         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,7 +1,7 @@
 # -*- 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.
 
 require 'newrelic_rpm' unless defined?( NewRelic )
 require 'new_relic/agent' unless defined?( NewRelic::Agent )

data/lib/new_relic/agent/transaction_event_primitive.rb

@@ -1,6 +1,7 @@
 # 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 +9,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,30 +17,28 @@ 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 = {
@@ -51,11 +50,11 @@ module NewRelic
         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]
 
@@ -76,22 +75,12 @@ module NewRelic
         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])
@@ -100,19 +89,19 @@ module NewRelic
 
       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
         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,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.
 require 'new_relic/agent/transaction_event_aggregator'
 require 'new_relic/agent/synthetics_event_aggregator'
 require 'new_relic/agent/transaction_event_primitive'
@@ -14,9 +14,9 @@ module NewRelic
       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

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.
 
 # 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

data/lib/new_relic/agent/transaction_sampler.rb

@@ -1,10 +1,9 @@
 # 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.
 
 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
@@ -19,13 +18,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
 

data/lib/new_relic/agent/transaction_time_aggregator.rb

@@ -1,8 +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.
-
-require 'objspace'
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 # This module powers the Busy calculation for the Capacity report in
 # APM (https://rpm.newrelic.com/accounts/.../applications/.../optimize/capacity_analysis).
@@ -23,37 +21,37 @@ module NewRelic
         h[k] = TransactionStats.new nil, 0.0
       end
 
-      def reset!(now = Time.now)
-        @harvest_cycle_started_at = now
+      def reset!(timestamp = Time.now)
+        @harvest_cycle_started_at = timestamp
         @stats.clear
       end
 
-      def transaction_start(now = Time.now)
+      def transaction_start(timestamp = Time.now)
         @lock.synchronize do
-          set_transaction_start_time now
+          set_transaction_start_time timestamp
         end
       end
 
-      def transaction_stop(now = Time.now)
+      def transaction_stop(timestamp = Time.now, starting_thread_id = current_thread)
         @lock.synchronize do
-          record_elapsed_transaction_time_until now
-          set_transaction_start_time nil
+          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!(now = Time.now)
+      def harvest!(timestamp = Time.now)
         active_threads = 0
         result = @lock.synchronize do
           # Sum up the transaction times spent in each thread
           elapsed_transaction_time = @stats.inject(0.0) do |total, (thread_id, entry)|
-            total + transaction_time_in_thread(thread_id, entry, now)
+            total + transaction_time_in_thread(timestamp, thread_id, entry)
           end
 
           active_threads = @stats.size
-          elapsed_harvest_time      = (now - @harvest_cycle_started_at) * active_threads
-          @harvest_cycle_started_at = now
+          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
           # that have transactions still open (we'll count the rest of
@@ -81,12 +79,16 @@ module NewRelic
                       :transaction_stop,
                       :harvest!
 
-      class <<self
+      class << self
         private
 
-        def record_elapsed_transaction_time_until(timestamp, thread_id: current_thread)
-          @stats[thread_id].elapsed_transaction_time +=
-            (timestamp - (@stats[thread_id].transaction_started_at || 0.0))
+        def record_elapsed_transaction_time_until(timestamp, thread_id = current_thread)
+          if @stats[thread_id].transaction_started_at
+            @stats[thread_id].elapsed_transaction_time +=
+              (timestamp - (@stats[thread_id].transaction_started_at || 0.0))
+          else
+            log_missing_elapsed_transaction_time
+          end
         end
 
         def in_transaction?(thread_id = current_thread)
@@ -98,33 +100,55 @@ module NewRelic
         end
 
         def thread_is_alive?(thread_id)
-          thread = ObjectSpace._id2ref(thread_id)
+          thread = thread_by_id thread_id
           thread && thread.alive?
         rescue StandardError
           false
         end
 
-        def set_transaction_start_time(timestamp)
-          @stats[current_thread].transaction_started_at = timestamp
+        # ObjectSpace is faster on MRI, but disabled by default on JRuby for
+        # perfomance reasons. We have two implmentations of `thread_by_id`
+        # based on ruby implementation.
+        if RUBY_ENGINE == 'jruby'
+          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
+            ObjectSpace._id2ref(thread_id)
+          end
+        end
+
+        def set_transaction_start_time(timestamp, thread_id = current_thread)
+          @stats[thread_id].transaction_started_at = timestamp
         end
 
-        def split_transaction_at_harvest(now, thread_id: nil)
+        def split_transaction_at_harvest(timestamp, thread_id = nil)
           raise ArgumentError, 'thread_id required' unless thread_id
-          @stats[thread_id].transaction_started_at = now
+          @stats[thread_id].transaction_started_at = timestamp
           @stats[thread_id].elapsed_transaction_time = 0.0
         end
 
-        def transaction_time_in_thread thread_id, entry, now
+        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 now, thread_id: 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 now, thread_id: thread_id
+          split_transaction_at_harvest timestamp, thread_id
 
           elapsed
         end
+
+        def log_missing_elapsed_transaction_time
+          transaction_name = Tracer.current_transaction &&
+            Tracer.current_transaction.best_name ||
+              "unknown"
+          NewRelic::Agent.logger.warn("Unable to calculate elapsed transaction time for #{transaction_name}")
+        end
       end
     end
   end