newrelic_rpm 4.0.0.332 → 6.13.1

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

@@ -1,51 +1,112 @@
 # 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/range_extensions'
+require 'new_relic/agent/guid_generator'
 
 module NewRelic
   module Agent
     class Transaction
       class AbstractSegment
-        attr_reader :start_time, :end_time, :duration, :exclusive_duration
-        attr_accessor :name, :children_time, :transaction
+        # This class is the base class for all segments. It is reponsible for
+        # timing, naming, and defining lifecycle callbacks. One of the more
+        # complex responsibilites 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
+        # exclusive duration using time ranges is expensive and it's only
+        # necessary if a segment's children run concurrently, or a segment ends
+        # 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, :transaction_name
+        attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
+        attr_reader :noticed_error
 
-        def initialize name=nil
+        def initialize name=nil, start_time=nil
           @name = name
+          @transaction_name = nil
+          @transaction = nil
+          @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_time = 0.0
+          @children_time_ranges = nil
+          @active_children = 0
+          @range_recorded = false
+          @concurrent_children = false
           @record_metrics = true
-          @transaction = nil
+          @record_scoped_metric = true
+          @record_on_finish = false
+          @noticed_error = nil
         end
 
         def start
-          @start_time = Time.now
+          @start_time ||= Time.now
+          return unless transaction
+          parent.child_start self if parent
         end
 
         def finish
           @end_time = Time.now
           @duration = end_time.to_f - start_time.to_f
-          @exclusive_duration = duration - children_time
-          if transaction
-            record_metrics if record_metrics?
-            segment_complete
-            transaction.segment_complete self
-          end
+          return unless transaction
+          run_complete_callbacks
+          finalize if record_on_finish?
         rescue => e
-          # This rescue block was added for the benefit of this test:
-          # test/multiverse/suites/bare/standalone_instrumentation_test.rb
-          # See the top of the test for details.
           NewRelic::Agent.logger.error "Exception finishing segment: #{name}", e
         end
 
+        def finished?
+          !!@end_time
+        end
+
         def record_metrics?
           @record_metrics
         end
 
-        def record_metrics= value
-          @record_metrics = value
+        def record_scoped_metric?
+          @record_scoped_metric
         end
 
-        def record_metrics
-          raise NotImplementedError, "Subclasses must implement record_metrics"
+        def record_on_finish?
+          @record_on_finish
+        end
+
+        def finalize
+          force_finish unless finished?
+          record_exclusive_duration
+          record_metrics if record_metrics?
+        end
+
+        def params
+          @params ||= {}
+        end
+
+        def params?
+          !!@params
+        end
+
+        def time_range
+          @start_time.to_f .. @end_time.to_f
+        end
+
+        def children_time_ranges
+          @children_time_ranges ||= []
+        end
+
+        def children_time_ranges?
+          !!@children_time_ranges
+        end
+
+        def concurrent_children?
+          @concurrent_children
         end
 
         INSPECT_IGNORE = [:@transaction, :@transaction_state].freeze
@@ -57,12 +118,135 @@ module NewRelic
           sprintf('#<%s:0x%x %s>', self.class.name, object_id, ivars.join(', '))
         end
 
+        # callback for subclasses to override
+        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
+
+        def range_recorded?
+          @range_recorded
+        end
+
+        def child_start segment
+          @active_children += 1
+          @concurrent_children = @concurrent_children || @active_children > 1
+
+          transaction.async = true if @concurrent_children
+        end
+
+        def child_complete segment
+          @active_children -= 1
+          record_child_time segment
+
+          if finished?
+            transaction.async = true
+            parent.descendant_complete self, segment
+          end
+        end
+
+        # When a child segment completes after its parent, we need to propagate
+        # the information about the descendant further up the tree so that
+        # ancestors can properly account for exclusive time. Once we've reached
+        # 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
+          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
+          end
+
+          if parent && finished? && descendant.end_time >= end_time
+            parent.descendant_complete self, descendant
+          end
+        end
+
         private
 
+        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."
+        end
+
+        def run_complete_callbacks
+          segment_complete
+          parent.child_complete self if parent
+          transaction.segment_complete self
+        end
+
+        def record_metrics
+          raise NotImplementedError, "Subclasses must implement record_metrics"
+        end
+
         # callback for subclasses to override
         def segment_complete
         end
 
+        def record_child_time child
+          if concurrent_children? || finished? && end_time < child.end_time
+            record_child_time_as_range child
+          else
+            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
+          child.range_recorded = true
+        end
+
+        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?
+        end
+
         def metric_cache
           transaction.metrics
         end
@@ -71,7 +255,7 @@ module NewRelic
           @transaction_state ||= if @transaction
             transaction.state
           else
-            TransactionState.tl_get
+            Tracer.state
           end
         end
       end

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.
 
 require 'new_relic/agent/transaction/segment'
 require 'new_relic/agent/datastores/metric_helper'
@@ -15,17 +15,21 @@ module NewRelic
         UNKNOWN = 'unknown'.freeze
 
         attr_reader :product, :operation, :collection, :sql_statement, :nosql_statement, :host, :port_path_or_id
-        attr_accessor :database_name
+        attr_accessor :database_name, :record_sql
 
-        def initialize product, operation, collection = nil, host = nil, port_path_or_id = nil, database_name = 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)
+          super Datastores::MetricHelper.scoped_metric_for(product, operation, collection),
+                nil,
+                start_time
         end
 
         def set_instance_info host = nil, port_path_or_id = nil
@@ -55,6 +59,7 @@ module NewRelic
 
         def notice_sql sql
           _notice_sql sql
+          nil
         end
 
         # @api private
@@ -63,58 +68,82 @@ module NewRelic
           @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
+        # transaction. For instance, Mongo or CQL queries, Memcached or Redis
+        # keys would all be appropriate data to attach as statements.
+        #
+        # Data passed to this method is NOT obfuscated by New Relic, so please
+        # ensure that user information is obfuscated if the agent setting
+        # `transaction_tracer.record_sql` is set to `obfuscated`
+        #
+        # @param [String] nosql_statement text of the statement to capture.
+        #
+        # @note THERE ARE SECURITY CONCERNS WHEN CAPTURING STATEMENTS!
+        #   This method will properly ignore statements when the user has turned
+        #   off capturing queries, but it is not able to obfuscate arbitrary data!
+        #   To prevent exposing user information embedded in captured queries,
+        #   please ensure all data passed to this method is safe to transmit to
+        #   New Relic.
+
         def notice_nosql_statement nosql_statement
           return unless record_sql?
-          @nosql_statement = nosql_statement
+          @nosql_statement = Database.truncate_query(nosql_statement)
+          nil
         end
 
-        private
-
         def record_metrics
           @unscoped_metrics = Datastores::MetricHelper.unscoped_metrics_for(product, operation, collection, host, port_path_or_id)
           super
         end
 
+        private
+
         def segment_complete
-          add_segment_parameters
           notice_sql_statement if sql_statement
           notice_statement if nosql_statement
-        end
-
-        def add_segment_parameters
-          instance_reporting_enabled = NewRelic::Agent.config[:'datastore_tracer.instance_reporting.enabled']
-          db_name_reporting_enabled = NewRelic::Agent.config[:'datastore_tracer.database_name_reporting.enabled']
-          return unless instance_reporting_enabled || db_name_reporting_enabled
-
-          params = {}
-          add_instance_parameters params if instance_reporting_enabled
-          add_database_name_parameter params if db_name_reporting_enabled
+          add_instance_parameters
+          add_database_name_parameter
+          add_backtrace_parameter
 
-          NewRelic::Agent.instance.transaction_sampler.add_node_parameters params
+          super
         end
 
-        def add_instance_parameters params
+        def add_instance_parameters
           params[:host] = host if host
           params[:port_path_or_id] = port_path_or_id if port_path_or_id
         end
 
-        def add_database_name_parameter(params)
+        def add_database_name_parameter
           params[:database_name] = database_name if database_name
         end
 
+        NEWLINE = "\n".freeze
+
+        def add_backtrace_parameter
+           return unless duration >= Agent.config[:'transaction_tracer.stack_trace_threshold']
+           params[:backtrace] = caller.join(NEWLINE)
+        end
+
         def notice_sql_statement
-          NewRelic::Agent.instance.transaction_sampler.notice_sql_statement(sql_statement, duration)
+          params[:sql] = sql_statement
           NewRelic::Agent.instance.sql_sampler.notice_sql_statement(sql_statement.dup, name, duration)
-          nil
         end
 
         def notice_statement
-          NewRelic::Agent.instance.transaction_sampler.notice_nosql_statement(nosql_statement, duration)
-          nil
+          params[:statement] = nosql_statement
         end
 
         def record_sql?
-          transaction_state.is_sql_recorded?
+          transaction_state.is_sql_recorded? && @record_sql
+        end
+
+        def record_span_event
+          aggregator = ::NewRelic::Agent.agent.span_event_aggregator
+          priority   = transaction.priority
+
+          aggregator.record(priority: priority) do
+            SpanEventPrimitive.for_datastore_segment(self)
+          end
         end
       end
     end

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

@@ -0,0 +1,171 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+require 'new_relic/agent/transaction/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 insert_headers request
+          insert_trace_context_header request
+          insert_distributed_trace_header request
+          insert_cross_app_header request
+        end
+
+        def consume_message_headers headers, tracer_state, transport_type
+          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 Agent.config[:'distributed_tracing.enabled']
+            DistributedTraceAttributes.copy_to_attributes transaction.payload, transaction.attributes
+          elsif is_cross_app?
+            assign_cross_app_intrinsics
+          end
+        end
+
+        def insert_distributed_trace_header request
+          return unless Agent.config[:'distributed_tracing.enabled']
+          return if Agent.config[:'exclude_newrelic_header']
+          payload = create_distributed_trace_payload
+          request[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 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 Agent.config[:'distributed_tracing.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
+