newrelic_rpm 3.12.0.288 → 9.10.2

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

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

@@ -0,0 +1,171 @@
+# 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/distributed_tracing/distributed_trace_payload'
+require 'new_relic/agent/distributed_tracing/distributed_trace_attributes'
+require 'new_relic/agent/distributed_tracing/distributed_trace_metrics'
+
+module NewRelic
+  module Agent
+    class Transaction
+      module DistributedTracing
+        attr_accessor :distributed_trace_payload
+        attr_writer :distributed_trace_payload_created
+
+        SUPPORTABILITY_DISTRIBUTED_TRACE = 'Supportability/DistributedTrace'
+        CREATE_PREFIX = "#{SUPPORTABILITY_DISTRIBUTED_TRACE}/CreatePayload"
+        ACCEPT_PREFIX = "#{SUPPORTABILITY_DISTRIBUTED_TRACE}/AcceptPayload"
+        IGNORE_PREFIX = "#{ACCEPT_PREFIX}/Ignored"
+
+        CREATE_SUCCESS_METRIC = "#{CREATE_PREFIX}/Success"
+        CREATE_EXCEPTION_METRIC = "#{CREATE_PREFIX}/Exception"
+        ACCEPT_SUCCESS_METRIC = "#{ACCEPT_PREFIX}/Success"
+        ACCEPT_EXCEPTION_METRIC = "#{ACCEPT_PREFIX}/Exception"
+        ACCEPT_PARSE_EXCEPTION_METRIC = "#{ACCEPT_PREFIX}/ParseException"
+
+        IGNORE_ACCEPT_AFTER_CREATE_METRIC = "#{IGNORE_PREFIX}/CreateBeforeAccept"
+        IGNORE_MULTIPLE_ACCEPT_METRIC = "#{IGNORE_PREFIX}/Multiple"
+        IGNORE_ACCEPT_NULL_METRIC = "#{IGNORE_PREFIX}/Null"
+        IGNORE_ACCEPT_MAJOR_VERSION_METRIC = "#{IGNORE_PREFIX}/MajorVersion"
+        IGNORE_ACCEPT_UNTRUSTED_ACCOUNT_METRIC = "#{IGNORE_PREFIX}/UntrustedAccount"
+
+        LBRACE = '{'
+        NULL_PAYLOAD = 'null'
+
+        NEWRELIC_TRACE_KEY = 'HTTP_NEWRELIC'
+
+        def accept_distributed_tracing_incoming_request(request)
+          return unless Agent.config[:'distributed_tracing.enabled']
+          return unless payload = request[NEWRELIC_TRACE_KEY]
+
+          accept_distributed_trace_payload(payload)
+        end
+
+        def distributed_trace_payload_created?
+          @distributed_trace_payload_created ||= false
+        end
+
+        def create_distributed_trace_payload
+          return unless Agent.config[:'distributed_tracing.enabled']
+
+          @distributed_trace_payload_created = true
+          payload = DistributedTracePayload.for_transaction(transaction)
+          NewRelic::Agent.increment_metric(CREATE_SUCCESS_METRIC)
+          payload
+        rescue => e
+          NewRelic::Agent.increment_metric(CREATE_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn('Failed to create distributed trace payload', e)
+          nil
+        end
+
+        def accept_distributed_trace_payload(payload)
+          return unless Agent.config[:'distributed_tracing.enabled']
+
+          return false if check_payload_ignored(payload)
+          return false unless check_payload_present(payload)
+          return false unless payload = decode_payload(payload)
+          return false unless check_required_fields_present(payload)
+          return false unless check_valid_version(payload)
+          return false unless check_trusted_account(payload)
+
+          assign_payload_and_sampling_params(payload)
+
+          NewRelic::Agent.increment_metric(ACCEPT_SUCCESS_METRIC)
+          true
+        rescue => e
+          NewRelic::Agent.increment_metric(ACCEPT_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn('Failed to accept distributed trace payload', e)
+          false
+        end
+
+        private
+
+        def check_payload_ignored(payload)
+          if distributed_trace_payload
+            NewRelic::Agent.increment_metric(IGNORE_MULTIPLE_ACCEPT_METRIC)
+            return true
+          elsif distributed_trace_payload_created?
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_AFTER_CREATE_METRIC)
+            return true
+          end
+          false
+        end
+
+        def check_payload_present(payload)
+          # We might be passed a Ruby `nil` object _or_ the JSON "null"
+          if payload.nil? || payload == NULL_PAYLOAD
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_NULL_METRIC)
+            return nil
+          end
+
+          payload
+        end
+
+        def decode_payload(payload)
+          decoded = if payload.start_with?(LBRACE)
+            DistributedTracePayload.from_json(payload)
+          else
+            DistributedTracePayload.from_http_safe(payload)
+          end
+
+          return nil unless check_payload_present(decoded)
+
+          decoded
+        rescue => e
+          NewRelic::Agent.increment_metric(ACCEPT_PARSE_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn('Error parsing distributed trace payload', e)
+          nil
+        end
+
+        def check_required_fields_present(payload)
+          if !payload.version.nil? &&
+              !payload.parent_account_id.nil? &&
+              !payload.parent_app_id.nil? &&
+              !payload.parent_type.nil? &&
+              (!payload.transaction_id.nil? || !payload.id.nil?) &&
+              !payload.trace_id.nil? &&
+              !payload.timestamp.nil?
+
+            true
+          else
+            NewRelic::Agent.increment_metric(ACCEPT_PARSE_EXCEPTION_METRIC)
+            false
+          end
+        end
+
+        def check_valid_version(payload)
+          if DistributedTracePayload.major_version_matches?(payload)
+            true
+          else
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_MAJOR_VERSION_METRIC)
+            false
+          end
+        end
+
+        def check_trusted_account(payload)
+          compare_key = payload.trusted_account_key || payload.parent_account_id
+          unless compare_key == NewRelic::Agent.config[:trusted_account_key]
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_UNTRUSTED_ACCOUNT_METRIC)
+            return false
+          end
+          true
+        end
+
+        def assign_payload_and_sampling_params(payload)
+          @distributed_trace_payload = payload
+          return if transaction.distributed_tracer.trace_context_header_data
+
+          transaction.trace_id = payload.trace_id
+          transaction.distributed_tracer.parent_transaction_id = payload.transaction_id
+          transaction.parent_span_id = payload.id
+
+          unless payload.sampled.nil?
+            transaction.sampled = payload.sampled
+            transaction.priority = payload.priority if payload.priority
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,265 @@
+# 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/segment'
+require 'new_relic/agent/http_clients/uri_util'
+
+module NewRelic
+  module Agent
+    class Transaction
+      #
+      # This class represents an external segment in a transaction trace.
+      #
+      # @api public
+      class ExternalRequestSegment < Segment
+        NR_SYNTHETICS_HEADER = 'X-NewRelic-Synthetics'
+        NR_SYNTHETICS_INFO_HEADER = 'X-NewRelic-Synthetics-Info'
+        APP_DATA_KEY = 'NewRelicAppData'
+
+        EXTERNAL_ALL = 'External/all'
+        EXTERNAL_ALL_WEB = 'External/allWeb'
+        EXTERNAL_ALL_OTHER = 'External/allOther'
+        MISSING_STATUS_CODE = 'MissingHTTPStatusCode'
+
+        attr_reader :library, :uri, :procedure, :http_status_code
+
+        def initialize(library, uri, procedure, start_time = nil) # :nodoc:
+          @library = library
+          @uri = HTTPClients::URIUtil.obfuscated_uri(uri)
+          @procedure = procedure
+          @host_header = nil
+          @app_data = nil
+          @http_status_code = nil
+          super(nil, nil, start_time)
+        end
+
+        def name # :nodoc:
+          @name ||= "External/#{host}/#{library}/#{procedure}"
+        end
+
+        def host # :nodoc:
+          @host_header || uri.host
+        end
+
+        # This method adds New Relic request headers to a given request made to an
+        # external API and checks to see if a host header is used for the request.
+        # If a host header is used, it updates the segment name to match the host
+        # header.
+        #
+        # @param [NewRelic::Agent::HTTPClients::AbstractRequest] request the request
+        # object (must belong to a subclass of NewRelic::Agent::HTTPClients::AbstractRequest)
+        #
+        # @api public
+        def add_request_headers(request)
+          process_host_header(request)
+          synthetics_header = transaction&.raw_synthetics_header
+          synthetics_info_header = transaction&.raw_synthetics_info_header
+          insert_synthetics_header(request, synthetics_header, synthetics_info_header) if synthetics_header
+
+          return unless record_metrics?
+
+          transaction.distributed_tracer.insert_headers(request)
+        rescue => e
+          NewRelic::Agent.logger.error('Error in add_request_headers', e)
+        end
+
+        # This method extracts app data from an external response if present. If
+        # a valid cross-app ID is found, the name of the segment is updated to
+        # reflect the cross-process ID and transaction name.
+        #
+        # @param [Hash] response a hash of response headers
+        #
+        # @api public
+        def read_response_headers(response)
+          return unless record_metrics? && CrossAppTracing.cross_app_enabled?
+          return unless CrossAppTracing.response_has_crossapp_header?(response)
+
+          unless data = CrossAppTracing.extract_appdata(response)
+            NewRelic::Agent.logger.debug("Couldn't extract_appdata from external segment response")
+            return
+          end
+
+          if CrossAppTracing.valid_cross_app_id?(data[0])
+            @app_data = data
+            update_segment_name
+          else
+            NewRelic::Agent.logger.debug('External segment response has invalid cross_app_id')
+          end
+        rescue => e
+          NewRelic::Agent.logger.error('Error in read_response_headers', e)
+        end
+
+        def cross_app_request? # :nodoc:
+          !!@app_data
+        end
+
+        def cross_process_id # :nodoc:
+          @app_data && @app_data[0]
+        end
+
+        def transaction_guid # :nodoc:
+          @app_data && @app_data[5]
+        end
+
+        def cross_process_transaction_name # :nodoc:
+          @app_data && @app_data[1]
+        end
+
+        # Obtain an obfuscated +String+ suitable for delivery across public networks that identifies this application
+        # and transaction to another application which is also running a New Relic agent. This +String+ can be processed
+        # by +process_request_metadata+ on the receiving application.
+        #
+        # @return [String] obfuscated request metadata to send
+        #
+        # @api public
+        #
+        def get_request_metadata
+          NewRelic::Agent.record_api_supportability_metric(:get_request_metadata)
+          return unless CrossAppTracing.cross_app_enabled?
+
+          if transaction
+
+            # build hash of CAT metadata
+            #
+            rmd = {
+              NewRelicID: NewRelic::Agent.config[:cross_process_id],
+              NewRelicTransaction: [
+                transaction.guid,
+                false,
+                transaction.distributed_tracer.cat_trip_id,
+                transaction.distributed_tracer.cat_path_hash
+              ]
+            }
+
+            # flag cross app in the state so transaction knows to add bits to payload
+            #
+            transaction.distributed_tracer.is_cross_app_caller = true
+
+            # add Synthetics header if we have it
+            #
+            rmd[:NewRelicSynthetics] = transaction.raw_synthetics_header if transaction.raw_synthetics_header
+
+            # obfuscate the generated request metadata JSON
+            #
+            obfuscator.obfuscate(::JSON.dump(rmd))
+
+          end
+        rescue => e
+          NewRelic::Agent.logger.error('error during get_request_metadata', e)
+        end
+
+        # Process obfuscated +String+ sent from a called application that is also running a New Relic agent and
+        # save information in current transaction for inclusion in a trace. This +String+ is generated by
+        # +get_response_metadata+ on the receiving application.
+        #
+        # @param response_metadata [String] received obfuscated response metadata
+        #
+        # @api public
+        #
+        def process_response_metadata(response_metadata)
+          NewRelic::Agent.record_api_supportability_metric(:process_response_metadata)
+          if transaction
+            app_data = ::JSON.parse(obfuscator.deobfuscate(response_metadata))[APP_DATA_KEY]
+
+            # validate cross app id
+            #
+            if Array === app_data and CrossAppTracing.trusted_valid_cross_app_id?(app_data[0])
+              @app_data = app_data
+              update_segment_name
+            else
+              NewRelic::Agent.logger.error('error processing response metadata: invalid/non-trusted ID')
+            end
+          end
+
+          nil
+        rescue => e
+          NewRelic::Agent.logger.error('error during process_response_metadata', e)
+        end
+
+        def record_metrics
+          add_unscoped_metrics
+          super
+        end
+
+        def process_response_headers(response) # :nodoc:
+          set_http_status_code(response)
+          read_response_headers(response)
+        end
+
+        private
+
+        # Only sets the http_status_code if response.status_code is non-empty value
+        def set_http_status_code(response)
+          if response.respond_to?(:status_code)
+            @http_status_code = response.status_code if response.has_status_code?
+          else
+            NewRelic::Agent.logger.warn("Cannot extract HTTP Status Code from response #{response.class.to_s}")
+            NewRelic::Agent.record_metric("#{name}/#{MISSING_STATUS_CODE}", 1)
+          end
+        end
+
+        def insert_synthetics_header(request, header, info)
+          request[NR_SYNTHETICS_HEADER] = header
+          request[NR_SYNTHETICS_INFO_HEADER] = info if info
+        end
+
+        def segment_complete
+          params[:uri] = uri.to_s
+          if cross_app_request?
+            params[:transaction_guid] = transaction_guid
+          end
+
+          super
+        end
+
+        def process_host_header(request)
+          if @host_header = request.host_from_header
+            update_segment_name
+          end
+        end
+
+        def add_unscoped_metrics
+          @unscoped_metrics = [EXTERNAL_ALL,
+            "External/#{host}/all",
+            suffixed_rollup_metric]
+
+          if cross_app_request?
+            @unscoped_metrics << "ExternalApp/#{host}/#{cross_process_id}/all"
+          end
+        end
+
+        def suffixed_rollup_metric
+          if Transaction.recording_web_transaction?
+            EXTERNAL_ALL_WEB
+          else
+            EXTERNAL_ALL_OTHER
+          end
+        end
+
+        def update_segment_name
+          if @app_data
+            @name = "ExternalTransaction/#{host}/#{cross_process_id}/#{cross_process_transaction_name}"
+          else
+            @name = "External/#{host}/#{library}/#{procedure}"
+          end
+        end
+
+        def obfuscator
+          CrossAppTracing.obfuscator
+        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
+          aggregator.record(priority: priority) do
+            SpanEventPrimitive.for_external_request_segment(self)
+          end
+        end
+      end
+    end
+  end
+end