newrelic_rpm 6.3.0.355 → 9.2.0

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

@@ -1,17 +1,16 @@
-# 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/range_extensions'
-require 'securerandom'
+require 'new_relic/agent/guid_generator'
 
 module NewRelic
   module Agent
     class Transaction
       class AbstractSegment
-        # This class is the base class for all segments. It is reponsible for
+        # This class is the base class for all segments. It is responsible for
         # timing, naming, and defining lifecycle callbacks. One of the more
-        # complex responsibilites of this class is computing exclusive duration.
+        # complex responsibilities of this class is computing exclusive duration.
         # One of the reasons for this complexity is that exclusive time will be
         # computed using time ranges or by recording an aggregate value for
         # a segments children time. The reason for this is that computing
@@ -20,44 +19,55 @@ module NewRelic
         # after its parent. We will use the optimized exclusive duration
         # calculation in all other cases.
         #
-        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid
-        attr_accessor :name, :parent, :children_time, :transaction
+        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid, :starting_segment_key
+        attr_accessor :name, :parent, :children_time, :transaction, :transaction_name
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
+        attr_reader :noticed_error
 
-        def initialize name=nil, start_time=nil
+        def initialize(name = nil, start_time = nil)
           @name = name
+          @starting_segment_key = NewRelic::Agent::Tracer.current_segment_key
+          @transaction_name = nil
           @transaction = nil
-          @guid = SecureRandom.hex(8)
+          @guid = NewRelic::Agent::GuidGenerator.generate_guid
           @parent = nil
           @params = nil
           @start_time = start_time if start_time
           @end_time = nil
           @duration = 0.0
           @exclusive_duration = 0.0
+          @children_timings = []
           @children_time = 0.0
-          @children_time_ranges = nil
           @active_children = 0
           @range_recorded = false
           @concurrent_children = false
           @record_metrics = true
           @record_scoped_metric = true
           @record_on_finish = false
+          @noticed_error = nil
+          @code_filepath = nil
+          @code_function = nil
+          @code_lineno = nil
+          @code_namespace = nil
         end
 
         def start
-          @start_time ||= Time.now
+          @start_time ||= Process.clock_gettime(Process::CLOCK_REALTIME)
           return unless transaction
-          parent.child_start self if parent
+
+          parent&.child_start(self)
         end
 
         def finish
-          @end_time = Time.now
-          @duration = end_time.to_f - start_time.to_f
+          @end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
+          @duration = end_time - start_time
+
           return unless transaction
+
           run_complete_callbacks
           finalize if record_on_finish?
         rescue => e
-          NewRelic::Agent.logger.error "Exception finishing segment: #{name}", e
+          NewRelic::Agent.logger.error("Exception finishing segment: #{name}", e)
         end
 
         def finished?
@@ -91,21 +101,39 @@ module NewRelic
         end
 
         def time_range
-          @start_time.to_f .. @end_time.to_f
-        end
-
-        def children_time_ranges
-          @children_time_ranges ||= []
+          @start_time.to_f..@end_time.to_f
         end
 
         def children_time_ranges?
-          !!@children_time_ranges
+          !@children_timings.empty?
         end
 
         def concurrent_children?
           @concurrent_children
         end
 
+        def code_information=(info = {})
+          return unless info[:filepath]
+
+          @code_filepath = info[:filepath]
+          @code_function = info[:function]
+          @code_lineno = info[:lineno]
+          @code_namespace = info[:namespace]
+        end
+
+        def all_code_information_present?
+          @code_filepath && @code_function && @code_lineno && @code_namespace
+        end
+
+        def code_attributes
+          return ::NewRelic::EMPTY_HASH unless all_code_information_present?
+
+          @code_attributes ||= {'code.filepath' => @code_filepath,
+                                'code.function' => @code_function,
+                                'code.lineno' => @code_lineno,
+                                'code.namespace' => @code_namespace}
+        end
+
         INSPECT_IGNORE = [:@transaction, :@transaction_state].freeze
 
         def inspect
@@ -119,6 +147,33 @@ module NewRelic
         def transaction_assigned
         end
 
+        def set_noticed_error(noticed_error)
+          if @noticed_error
+            NewRelic::Agent.logger.debug( \
+              "Segment: #{name} overwriting previously noticed " \
+              "error: #{@noticed_error.inspect} with: #{noticed_error.inspect}"
+            )
+          end
+          @noticed_error = noticed_error
+        end
+
+        def notice_error(exception, options = {})
+          if Agent.config[:high_security]
+            NewRelic::Agent.logger.debug( \
+              "Segment: #{name} ignores notice_error for " \
+              "error: #{exception.inspect} because :high_security is enabled"
+            )
+          else
+            NewRelic::Agent.instance.error_collector.notice_segment_error(self, exception, options)
+          end
+        end
+
+        def noticed_error_attributes
+          return unless @noticed_error
+
+          @noticed_error.attributes_from_notice_error
+        end
+
         protected
 
         attr_writer :range_recorded
@@ -127,20 +182,20 @@ module NewRelic
           @range_recorded
         end
 
-        def child_start segment
+        def child_start(segment)
           @active_children += 1
-          @concurrent_children = @concurrent_children || @active_children > 1
+          @concurrent_children ||= @active_children > 1
 
           transaction.async = true if @concurrent_children
         end
 
-        def child_complete segment
+        def child_complete(segment)
           @active_children -= 1
-          record_child_time segment
+          record_child_time(segment)
 
           if finished?
             transaction.async = true
-            parent.descendant_complete self, segment
+            parent&.descendant_complete(self, segment)
           end
         end
 
@@ -150,71 +205,67 @@ module NewRelic
         # an ancestor whose end time is greater than or equal to the descendant's
         # we can stop the propagation. We pass along the direct child so we can
         # make any corrections needed for exclusive time calculation.
+        def descendant_complete(child, descendant)
+          add_child_timing(descendant)
 
-        def descendant_complete child, descendant
-          RangeExtensions.merge_or_append descendant.time_range,
-                                            children_time_ranges
           # If this child's time was previously added to this segment's
           # aggregate children time, we need to re-record it using a time range
           # for proper exclusive time calculation
           unless child.range_recorded?
             self.children_time -= child.duration
-            record_child_time_as_range child
+            record_child_time_as_range(child)
           end
 
           if parent && finished? && descendant.end_time >= end_time
-            parent.descendant_complete self, descendant
+            parent.descendant_complete(self, descendant)
           end
         end
 
         private
 
+        def add_child_timing(segment)
+          @children_timings << [segment.start_time, segment.end_time]
+        end
+
         def force_finish
           finish
-          NewRelic::Agent.logger.warn "Segment: #{name} was unfinished at " \
-            "the end of transaction. Timing information for this segment's" \
-            "parent #{parent.name} in #{transaction.best_name} may be inaccurate."
+          NewRelic::Agent.logger.send(transaction.async? ? :debug : :warn, "Segment: #{name} was unfinished at " \
+            "the end of transaction. Timing information for this segment's " \
+            "parent #{parent&.name} in #{transaction.best_name} may be inaccurate.")
         end
 
         def run_complete_callbacks
           segment_complete
-          parent.child_complete self if parent
-          transaction.segment_complete self
+          parent&.child_complete(self)
+          transaction.segment_complete(self)
         end
 
         def record_metrics
-          raise NotImplementedError, "Subclasses must implement record_metrics"
+          raise NotImplementedError, 'Subclasses must implement record_metrics'
         end
 
         # callback for subclasses to override
         def segment_complete
         end
 
-        def record_child_time child
+        def record_child_time(child)
           if concurrent_children? || finished? && end_time < child.end_time
-            record_child_time_as_range child
+            record_child_time_as_range(child)
           else
-            record_child_time_as_number child
+            record_child_time_as_number(child)
           end
         end
 
-        def record_child_time_as_range child
-          RangeExtensions.merge_or_append child.time_range,
-                                          children_time_ranges
+        def record_child_time_as_range(child)
+          add_child_timing(child)
           child.range_recorded = true
         end
 
-        def record_child_time_as_number child
+        def record_child_time_as_number(child)
           self.children_time += child.duration
         end
 
         def record_exclusive_duration
-          overlapping_duration = if children_time_ranges?
-            RangeExtensions.compute_overlap time_range, children_time_ranges
-          else
-            0.0
-          end
-
           @exclusive_duration = duration - children_time - overlapping_duration
           transaction.total_time += @exclusive_duration
           params[:exclusive_duration_millis] = @exclusive_duration * 1000 if transaction.async?
@@ -224,6 +275,51 @@ module NewRelic
           transaction.metrics
         end
 
+        def ranges_intersect?(r1, r2)
+          r1.begin > r2.begin ? r2.cover?(r1.begin) : r1.cover?(r2.begin)
+        end
+
+        def range_overlap(range)
+          return 0.0 unless ranges_intersect?(range, time_range)
+
+          [range.end, time_range.end].min - [range.begin, time_range.begin].max
+        end
+
+        # Child segments operating concurrently with this segment may have
+        # start and end times that overlap with this segment's own times. The
+        # amount of overlap needs to be removed from the `children_time` total
+        # when calculating an `@exclusive_duration` value to be added to the
+        # transaction's total time.
+        #
+        # If there aren't any child segments, return 0.0. Otherwise, take the
+        # `@children_timings` array of arrays (each array holds a child
+        # segment's start time and end time), sort it by the first elements
+        # (start times), and use the start and finish times to create Range
+        # objects. Combine all of the child segment ranges that overlap with
+        # one another into new bigger ranges. Then take those bigger ranges
+        # and calculate how much overlap there is between them and this
+        # segment's own time range. Keep a running sum of all of the overlap
+        # amounts and then return it.
+        def overlapping_duration
+          sum = 0.0
+          return sum unless children_time_ranges?
+
+          @children_timings.sort_by!(&:first)
+          range = Range.new(*@children_timings.first)
+          (1..(@children_timings.size - 1)).each do |i|
+            possible = Range.new(*@children_timings[i])
+
+            if ranges_intersect?(range, possible)
+              range = range.begin..possible.end
+            else
+              sum += range_overlap(range)
+              range = possible
+            end
+          end
+
+          sum += range_overlap(range)
+        end
+
         def transaction_state
           @transaction_state ||= if @transaction
             transaction.state

data/lib/new_relic/agent/transaction/datastore_segment.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/segment'
 require 'new_relic/agent/datastores/metric_helper'
@@ -11,33 +11,31 @@ module NewRelic
   module Agent
     class Transaction
       class DatastoreSegment < Segment
-
         UNKNOWN = 'unknown'.freeze
 
         attr_reader :product, :operation, :collection, :sql_statement, :nosql_statement, :host, :port_path_or_id
         attr_accessor :database_name, :record_sql
 
-
-        def initialize product, operation, collection = nil, host = nil, port_path_or_id = nil, database_name = nil, start_time = nil
+        def initialize(product, operation, collection = nil, host = nil, port_path_or_id = nil, database_name = nil, start_time = nil)
           @product = product
           @operation = operation
           @collection = collection
           @sql_statement = nil
           @nosql_statement = nil
           @record_sql = true
-          set_instance_info host, port_path_or_id
-          @database_name = database_name ? database_name.to_s : nil
-          super Datastores::MetricHelper.scoped_metric_for(product, operation, collection),
+          set_instance_info(host, port_path_or_id)
+          @database_name = database_name&.to_s
+          super(Datastores::MetricHelper.scoped_metric_for(product, operation, collection),
                 nil,
-                start_time
+                start_time)
         end
 
-        def set_instance_info host = nil, port_path_or_id = nil
+        def set_instance_info(host = nil, port_path_or_id = nil)
           port_path_or_id = port_path_or_id.to_s if port_path_or_id
           host_present = host && !host.empty?
           ppi_present = port_path_or_id && !port_path_or_id.empty?
 
-          host = NewRelic::Agent::Hostname.get_external host if host_present
+          host = NewRelic::Agent::Hostname.get_external(host) if host_present
 
           case
           when host_present && ppi_present
@@ -57,15 +55,16 @@ module NewRelic
           end
         end
 
-        def notice_sql sql
-          _notice_sql sql
+        def notice_sql(sql)
+          _notice_sql(sql)
           nil
         end
 
         # @api private
-        def _notice_sql sql, config=nil, explainer=nil, binds=nil, name=nil
+        def _notice_sql(sql, config = nil, explainer = nil, binds = nil, name = nil)
           return unless record_sql?
-          @sql_statement = Database::Statement.new sql, config, explainer, binds, name, host, port_path_or_id, database_name
+
+          @sql_statement = Database::Statement.new(sql, config, explainer, binds, name, host, port_path_or_id, database_name)
         end
 
         # Method for simplifying attaching non-SQL data statements to a
@@ -85,8 +84,9 @@ module NewRelic
         #   please ensure all data passed to this method is safe to transmit to
         #   New Relic.
 
-        def notice_nosql_statement nosql_statement
+        def notice_nosql_statement(nosql_statement)
           return unless record_sql?
+
           @nosql_statement = Database.truncate_query(nosql_statement)
           nil
         end
@@ -120,8 +120,9 @@ module NewRelic
         NEWLINE = "\n".freeze
 
         def add_backtrace_parameter
-           return unless duration >= Agent.config[:'transaction_tracer.stack_trace_threshold']
-           params[:backtrace] = caller.join(NEWLINE)
+          return unless duration >= Agent.config[:'transaction_tracer.stack_trace_threshold']
+
+          params[:backtrace] = caller.join(NEWLINE)
         end
 
         def notice_sql_statement
@@ -138,8 +139,11 @@ module NewRelic
         end
 
         def record_span_event
+          # don't record a span event if the transaction is ignored
+          return if transaction.ignore?
+
           aggregator = ::NewRelic::Agent.agent.span_event_aggregator
-          priority   = transaction.priority
+          priority = transaction.priority
 
           aggregator.record(priority: priority) do
             SpanEventPrimitive.for_datastore_segment(self)

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

@@ -0,0 +1,185 @@
+# 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/trace_context'
+require 'new_relic/agent/transaction/distributed_tracing'
+require 'new_relic/agent/distributed_tracing/cross_app_tracing'
+
+module NewRelic
+  module Agent
+    class Transaction
+      class DistributedTracer
+        include NewRelic::Agent::CrossAppTracing
+        include DistributedTracing
+        include TraceContext
+
+        attr_reader :transaction
+        attr_accessor :parent_transaction_id
+
+        def parent_guid
+          if trace_context_header_data
+            trace_context_header_data.parent_id
+          elsif distributed_trace_payload
+            distributed_trace_payload.id
+          end
+        end
+
+        def accept_incoming_request(request, transport_type = nil)
+          accept_incoming_transport_type(request, transport_type)
+          if trace_parent_header_present?(request)
+            accept_trace_context_incoming_request(request)
+          else
+            accept_distributed_tracing_incoming_request(request)
+          end
+        end
+
+        def caller_transport_type
+          @caller_transport_type ||= 'Unknown'
+        end
+
+        def accept_transport_type_from_api(value)
+          @caller_transport_type = DistributedTraceTransportType.from(value)
+        end
+
+        def accept_incoming_transport_type(request, transport_type)
+          if transport_type.to_s == NewRelic::EMPTY_STR
+            @caller_transport_type = DistributedTraceTransportType.for_rack_request(request)
+          else
+            @caller_transport_type = DistributedTraceTransportType.from(transport_type)
+          end
+        end
+
+        def initialize(transaction)
+          @transaction = transaction
+        end
+
+        def record_metrics
+          record_cross_app_metrics
+          DistributedTraceMetrics.record_metrics_for_transaction(transaction)
+        end
+
+        def append_payload(payload)
+          append_cat_info(payload)
+          DistributedTraceAttributes.copy_from_transaction( \
+            transaction,
+            trace_state_payload || distributed_trace_payload,
+            payload
+          )
+        end
+
+        def log_request_headers(headers, direction = 'OUTGOING')
+          printed_headers = headers.is_a?(NewRelic::Agent::HTTPClients::AbstractRequest) ? headers.headers : headers
+          NewRelic::Agent.logger.debug("#{direction} REQUEST HEADERS: #{printed_headers}")
+        end
+
+        def insert_headers(headers)
+          return unless NewRelic::Agent.agent.connected?
+
+          insert_trace_context_header(headers)
+          insert_distributed_trace_header(headers)
+          insert_cross_app_header(headers)
+          log_request_headers(headers)
+        end
+
+        def consume_message_headers(headers, tracer_state, transport_type)
+          log_request_headers(headers, 'INCOMING')
+          consume_message_distributed_tracing_headers(headers, transport_type)
+          consume_message_cross_app_tracing_headers(headers, tracer_state)
+          consume_message_synthetics_headers(headers)
+        rescue => e
+          NewRelic::Agent.logger.error('Error in consume_message_headers', e)
+        end
+
+        def assign_intrinsics
+          if dt_enabled?
+            DistributedTraceAttributes.copy_to_attributes(transaction.payload, transaction.attributes)
+          elsif is_cross_app?
+            assign_cross_app_intrinsics
+          end
+        end
+
+        def insert_distributed_trace_header(headers)
+          return unless dt_enabled?
+          return if Agent.config[:'exclude_newrelic_header']
+
+          payload = create_distributed_trace_payload
+          headers[NewRelic::NEWRELIC_KEY] = payload.http_safe if payload
+        end
+
+        def insert_cat_headers(headers)
+          return unless CrossAppTracing.cross_app_enabled?
+
+          @is_cross_app_caller = true
+          insert_message_headers(headers,
+            transaction.guid,
+            cat_trip_id,
+            cat_path_hash,
+            transaction.raw_synthetics_header)
+        end
+
+        private
+
+        def dt_enabled?
+          Agent.config[:'distributed_tracing.enabled']
+        end
+
+        def consume_message_synthetics_headers(headers)
+          synthetics_header = headers[CrossAppTracing::NR_MESSAGE_BROKER_SYNTHETICS_HEADER]
+          if synthetics_header and
+              incoming_payload = ::JSON.load(deobfuscate(synthetics_header)) and
+              SyntheticsMonitor.is_valid_payload?(incoming_payload) and
+              SyntheticsMonitor.is_supported_version?(incoming_payload) and
+              SyntheticsMonitor.is_trusted?(incoming_payload)
+
+            transaction.raw_synthetics_header = synthetics_header
+            transaction.synthetics_payload = incoming_payload
+          end
+        rescue => e
+          NewRelic::Agent.logger.error('Error in consume_message_synthetics_header', e)
+        end
+
+        def consume_message_distributed_tracing_headers(headers, transport_type)
+          return unless dt_enabled?
+
+          accept_incoming_transport_type(headers, transport_type)
+
+          newrelic_trace_key = NewRelic::CANDIDATE_NEWRELIC_KEYS.detect do |key|
+            headers.has_key?(key)
+          end
+          return unless newrelic_trace_key && (payload = headers[newrelic_trace_key])
+
+          accept_distributed_trace_payload(payload)
+        end
+
+        def consume_message_cross_app_tracing_headers(headers, tracer_state)
+          return unless CrossAppTracing.cross_app_enabled?
+          return unless CrossAppTracing.message_has_crossapp_request_header?(headers)
+
+          accept_cross_app_payload(headers, tracer_state)
+          CrossAppTracing.assign_intrinsic_transaction_attributes(tracer_state)
+        end
+
+        def accept_cross_app_payload(headers, tracer_state)
+          encoded_id = headers[CrossAppTracing::NR_MESSAGE_BROKER_ID_HEADER]
+          decoded_id = encoded_id.nil? ? EMPTY_STRING : deobfuscate(encoded_id)
+
+          return unless CrossAppTracing.trusted_valid_cross_app_id?(decoded_id)
+
+          txn_header = headers[CrossAppTracing::NR_MESSAGE_BROKER_TXN_HEADER]
+          txn_info = ::JSON.load(deobfuscate(txn_header))
+          payload = CrossAppPayload.new(decoded_id, transaction, txn_info)
+
+          @cross_app_payload = payload
+        rescue => e
+          NewRelic::Agent.logger.debug("Failure deserializing encoded header in #{self.class}, #{e.class}, #{e.message}")
+          nil
+        end
+
+        def deobfuscate(message)
+          CrossAppTracing.obfuscator.deobfuscate(message)
+        end
+      end
+    end
+  end
+end