newrelic_rpm 4.8.0.341 → 6.13.1

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

@@ -0,0 +1,248 @@
+# -*- ruby -*-
+# 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 'json'
+
+module NewRelic
+  module Agent
+    module CrossAppTracing
+      # The cross app response header for "outgoing" calls
+      NR_APPDATA_HEADER = 'X-NewRelic-App-Data'
+
+      # The cross app id header for "outgoing" calls
+      NR_ID_HEADER = 'X-NewRelic-ID'
+
+      # The cross app transaction header for "outgoing" calls
+      NR_TXN_HEADER = 'X-NewRelic-Transaction'
+
+      NR_MESSAGE_BROKER_ID_HEADER  = 'NewRelicID'
+      NR_MESSAGE_BROKER_TXN_HEADER = 'NewRelicTransaction'
+      NR_MESSAGE_BROKER_SYNTHETICS_HEADER = 'NewRelicSynthetics'
+
+      attr_accessor :is_cross_app_caller, :cross_app_payload, :cat_path_hashes
+
+      def is_cross_app_caller?
+        @is_cross_app_caller ||= false
+      end
+
+      def is_cross_app_callee?
+        cross_app_payload != nil
+      end
+
+      def is_cross_app?
+        is_cross_app_caller? || is_cross_app_callee?
+      end
+
+      def cat_trip_id
+        cross_app_payload && cross_app_payload.referring_trip_id || transaction.guid
+      end
+
+      def cross_app_monitor
+        NewRelic::Agent.instance.monitors.cross_app_monitor
+      end
+
+      def cat_path_hash
+        referring_path_hash = cat_referring_path_hash || '0'
+        seed = referring_path_hash.to_i(16)
+        result = cross_app_monitor.path_hash(transaction.best_name, seed)
+        record_cat_path_hash(result)
+        result
+      end
+
+      def insert_cross_app_header request
+        return unless CrossAppTracing.cross_app_enabled?
+        @is_cross_app_caller = true
+        txn_guid  = transaction.guid
+        trip_id   = cat_trip_id
+        path_hash = cat_path_hash
+
+        insert_request_headers request, txn_guid, trip_id, path_hash
+      end
+
+      def add_message_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
+
+      def record_cross_app_metrics
+        if (id = cross_app_payload && cross_app_payload.id)
+          app_time_in_seconds = [Time.now.to_f - transaction.start_time.to_f, 0.0].max
+          NewRelic::Agent.record_metric "ClientApplication/#{id}/all", app_time_in_seconds
+        end
+      end
+
+      def assign_cross_app_intrinsics
+        transaction.attributes.add_intrinsic_attribute(:trip_id, cat_trip_id)
+        transaction.attributes.add_intrinsic_attribute(:path_hash, cat_path_hash)
+      end
+
+      private
+
+      def insert_message_headers headers, txn_guid, trip_id, path_hash, synthetics_header
+        headers[NR_MESSAGE_BROKER_ID_HEADER]  = obfuscator.obfuscate(Agent.config[:cross_process_id])
+        headers[NR_MESSAGE_BROKER_TXN_HEADER] = obfuscator.obfuscate(::JSON.dump([txn_guid, false, trip_id, path_hash]))
+        headers[NR_MESSAGE_BROKER_SYNTHETICS_HEADER] = synthetics_header if synthetics_header
+      end
+
+      def record_cat_path_hash(hash)
+        @cat_path_hashes ||= []
+        if @cat_path_hashes.size < 10 && !@cat_path_hashes.include?(hash)
+          @cat_path_hashes << hash
+        end
+      end
+
+      def cat_referring_path_hash
+        cross_app_payload && cross_app_payload.referring_path_hash
+      end
+
+      def append_cat_info(payload)
+        if (referring_guid = cross_app_payload && cross_app_payload.referring_guid)
+          payload[:referring_transaction_guid] = referring_guid
+        end
+
+        return unless transaction.include_guid?
+        payload[:guid] = transaction.guid
+
+        return unless is_cross_app?
+        trip_id             = cat_trip_id
+        path_hash           = cat_path_hash
+        referring_path_hash = cat_referring_path_hash
+
+        payload[:cat_trip_id]             = trip_id             if trip_id
+        payload[:cat_referring_path_hash] = referring_path_hash if referring_path_hash
+
+        if path_hash
+          payload[:cat_path_hash] = path_hash
+
+          alternate_path_hashes = cat_path_hashes - [path_hash]
+          unless alternate_path_hashes.empty?
+            payload[:cat_alternate_path_hashes] = alternate_path_hashes
+          end
+        end
+      end
+
+      ###############
+      module_function
+      ###############
+
+      def cross_app_enabled?
+        valid_cross_process_id? &&
+          valid_encoding_key? &&
+          cross_application_tracer_enabled?
+      end
+
+      def valid_cross_process_id?
+        if Agent.config[:cross_process_id] && Agent.config[:cross_process_id].length > 0
+          true
+        else
+          NewRelic::Agent.logger.debug "No cross_process_id configured"
+          false
+        end
+      end
+
+      def valid_encoding_key?
+        if Agent.config[:encoding_key] && Agent.config[:encoding_key].length > 0
+          true
+        else
+          NewRelic::Agent.logger.debug "No encoding_key set"
+          false
+        end
+      end
+
+      def cross_application_tracer_enabled?
+        !NewRelic::Agent.config[:"distributed_tracing.enabled"] &&
+          (NewRelic::Agent.config[:"cross_application_tracer.enabled"] ||
+           NewRelic::Agent.config[:cross_application_tracing])
+      end
+
+      def obfuscator
+        @obfuscator ||= NewRelic::Agent::Obfuscator.new(Agent.config[:encoding_key])
+      end
+
+      def insert_request_headers request, txn_guid, trip_id, path_hash
+        cross_app_id = NewRelic::Agent.config[:cross_process_id]
+        txn_data  = ::JSON.dump([txn_guid, false, trip_id, path_hash])
+
+        request[NR_ID_HEADER]  = obfuscator.obfuscate(cross_app_id)
+        request[NR_TXN_HEADER] = obfuscator.obfuscate(txn_data)
+      end
+
+      def response_has_crossapp_header?(response)
+        if !!response[NR_APPDATA_HEADER]
+          true
+        else
+          NewRelic::Agent.logger.debug "No #{NR_APPDATA_HEADER} header"
+          false
+        end
+      end
+
+      # Extract x-process application data from the specified +response+ and return
+      # it as an array of the form:
+      #
+      #  [
+      #    <cross app ID>,
+      #    <transaction name>,
+      #    <queue time in seconds>,
+      #    <response time in seconds>,
+      #    <request content length in bytes>,
+      #    <transaction GUID>
+      #  ]
+      def extract_appdata(response)
+        appdata = response[NR_APPDATA_HEADER]
+
+        decoded_appdata = obfuscator.deobfuscate(appdata)
+        decoded_appdata.set_encoding(::Encoding::UTF_8) if
+          decoded_appdata.respond_to?(:set_encoding)
+
+        ::JSON.load(decoded_appdata)
+      end
+
+      def valid_cross_app_id?(xp_id)
+        !!(xp_id =~ /\A\d+#\d+\z/)
+      end
+
+      def message_has_crossapp_request_header? headers
+        !!headers[NR_MESSAGE_BROKER_ID_HEADER]
+      end
+
+      def reject_messaging_cat_headers headers
+        headers.reject {|k,_| k == NR_MESSAGE_BROKER_ID_HEADER || k == NR_MESSAGE_BROKER_TXN_HEADER}
+      end
+
+      def trusts? id
+        split_id = id.match(/(\d+)#\d+/)
+        return false if split_id.nil?
+
+        NewRelic::Agent.config[:trusted_account_ids].include? split_id.captures.first.to_i
+      end
+
+      def trusted_valid_cross_app_id? id
+        valid_cross_app_id?(id) && trusts?(id)
+      end
+
+      # From inbound request headers
+      def assign_intrinsic_transaction_attributes state
+        # We expect to get the before call to set the id (if we have it) before
+        # this, and then write our custom parameter when the transaction starts
+        return unless (txn = state.current_transaction)
+        return unless (payload = txn.distributed_tracer.cross_app_payload)
+
+        if (cross_app_id = payload.id)
+          txn.attributes.add_intrinsic_attribute(:client_cross_process_id, cross_app_id)
+        end
+
+        if (referring_guid = payload.referring_guid)
+          txn.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# 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
+
+module NewRelic
+  module Agent
+    module DistributedTraceAttributes
+      extend self
+
+      # Intrinsic Keys
+      INTRINSIC_KEYS = [
+        PARENT_TYPE_KEY                = "parent.type",
+        PARENT_APP_KEY                 = "parent.app",
+        PARENT_ACCOUNT_ID_KEY          = "parent.account",
+        PARENT_TRANSPORT_TYPE_KEY      = "parent.transportType",
+        PARENT_TRANSPORT_DURATION_KEY  = "parent.transportDuration",
+        GUID_KEY                       = "guid",
+        TRACE_ID_KEY                   = "traceId",
+        PARENT_TRANSACTION_ID_KEY      = "parentId",
+        PARENT_SPAN_ID_KEY             = "parentSpanId",
+        SAMPLED_KEY                    = "sampled",
+      ].freeze
+
+      # This method extracts intrinsics from the transaction_payload and
+      # inserts them into the specified destination.
+      def copy_to_hash transaction_payload, destination
+        return unless enabled?
+        INTRINSIC_KEYS.each do |key|
+          value = transaction_payload[key]
+          destination[key] = value unless value.nil?
+        end
+      end
+
+      # This method extracts intrinsics from the transaction_payload and
+      # inserts them as intrinsics in the specified transaction_attributes
+      def copy_to_attributes transaction_payload, destination
+        return unless enabled?
+        INTRINSIC_KEYS.each do |key|
+          next unless transaction_payload.key? key
+          destination.add_intrinsic_attribute key, transaction_payload[key]
+        end
+      end
+
+      # This method takes all distributed tracing intrinsics from the transaction
+      # and the trace_payload, and populates them into the destination
+      def copy_from_transaction transaction, trace_payload, destination
+        destination[GUID_KEY] = transaction.guid
+        destination[SAMPLED_KEY] = transaction.sampled?
+        destination[TRACE_ID_KEY] = transaction.trace_id
+
+        if transaction.parent_span_id
+          destination[PARENT_SPAN_ID_KEY] = transaction.parent_span_id
+        end
+
+        copy_parent_attributes transaction, trace_payload, destination
+      end
+
+      def copy_parent_attributes transaction, trace_payload, destination
+        transport_type = transaction.distributed_tracer.caller_transport_type
+        destination[PARENT_TRANSPORT_TYPE_KEY] = DistributedTraceTransportType.from transport_type
+
+        if trace_payload
+          destination[PARENT_TYPE_KEY] = trace_payload.parent_type
+          destination[PARENT_APP_KEY] = trace_payload.parent_app_id
+          destination[PARENT_ACCOUNT_ID_KEY] = trace_payload.parent_account_id
+
+          destination[PARENT_TRANSPORT_DURATION_KEY] = transaction.calculate_transport_duration trace_payload
+
+          if parent_transaction_id = transaction.distributed_tracer.parent_transaction_id
+            destination[PARENT_TRANSACTION_ID_KEY] = parent_transaction_id
+          end
+        end
+      end
+
+      private
+
+      def enabled?
+        return Agent.config[:'distributed_tracing.enabled']
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# 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
+
+module NewRelic
+  module Agent
+    module DistributedTraceMetrics
+      extend self
+
+      ALL_SUFFIX = "all"
+      ALL_WEB_SUFFIX = "allWeb"
+      ALL_OTHER_SUFFIX = "allOther"
+
+      UNKNOWN_CALLER_PREFIX = "%s/Unknown/Unknown/Unknown/%s"
+
+      def transaction_type_suffix
+        if Transaction.recording_web_transaction?
+          ALL_WEB_SUFFIX
+        else
+          ALL_OTHER_SUFFIX
+        end
+      end
+
+      def record_metrics_for_transaction transaction
+        return unless Agent.config[:'distributed_tracing.enabled']
+        dt = transaction.distributed_tracer
+        payload = dt.distributed_trace_payload || dt.trace_state_payload
+
+        record_caller_by_duration_metrics transaction, payload
+        record_transport_duration_metrics transaction, payload
+        record_errors_by_caller_metrics transaction, payload
+      end
+
+      def prefix_for_metric name, transaction, payload
+        if payload
+          "#{name}/" \
+          "#{payload.parent_type}/" \
+          "#{payload.parent_account_id}/" \
+          "#{payload.parent_app_id}/" \
+          "#{transaction.distributed_tracer.caller_transport_type}"
+        else
+          UNKNOWN_CALLER_PREFIX % [name, transaction.distributed_tracer.caller_transport_type]
+        end
+      end
+
+      def record_caller_by_duration_metrics transaction, payload
+        prefix = prefix_for_metric "DurationByCaller", transaction, payload
+        record_unscoped_metric transaction, prefix, transaction.duration
+      end
+
+      def record_transport_duration_metrics transaction, payload
+        return unless payload
+
+        prefix = prefix_for_metric "TransportDuration", transaction, payload
+        duration = transaction.calculate_transport_duration payload
+        record_unscoped_metric transaction, prefix, duration
+      end
+
+      def record_errors_by_caller_metrics transaction, payload
+        return unless transaction.exceptions.size > 0
+
+        prefix = prefix_for_metric "ErrorsByCaller", transaction, payload
+        record_unscoped_metric transaction, prefix, 1
+      end
+
+      private
+
+      def record_unscoped_metric transaction, prefix, duration
+        transaction.metrics.record_unscoped "#{prefix}/#{ALL_SUFFIX}", duration
+        transaction.metrics.record_unscoped "#{prefix}/#{transaction_type_suffix}", duration
+      end
+    end
+  end
+end

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

@@ -0,0 +1,165 @@
+# 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 'json'
+require 'base64'
+
+module NewRelic
+  module Agent
+    #
+    # This class contains properties related to distributed traces.
+    # To obtain an instance, call
+    # {DistributedTracing#create_distributed_trace_payload}
+    #
+    # @api public
+    class DistributedTracePayload
+      extend Coerce
+
+      VERSION     = [0, 1].freeze
+      PARENT_TYPE = "App"
+      POUND       = '#'
+
+      # Key names for serialization
+      VERSION_KEY           = 'v'
+      DATA_KEY              = 'd'
+      PARENT_TYPE_KEY       = 'ty'
+      PARENT_ACCOUNT_ID_KEY = 'ac'
+      PARENT_APP_KEY        = 'ap'
+      TRUSTED_ACCOUNT_KEY   = 'tk'
+      ID_KEY                = 'id'
+      TX_KEY                = 'tx'
+      TRACE_ID_KEY          = 'tr'
+      SAMPLED_KEY           = 'sa'
+      TIMESTAMP_KEY         = 'ti'
+      PRIORITY_KEY          = 'pr'
+
+      class << self
+
+        def for_transaction transaction
+          return nil unless connected?
+
+          payload = new
+          payload.version = VERSION
+          payload.parent_type = PARENT_TYPE
+          payload.parent_account_id = Agent.config[:account_id]
+          payload.parent_app_id = Agent.config[:primary_application_id]
+
+          assign_trusted_account_key(payload, payload.parent_account_id)
+
+          payload.id = current_segment_id(transaction)
+          payload.transaction_id = transaction.guid
+          payload.timestamp = (Time.now.to_f * 1000).round
+          payload.trace_id = transaction.trace_id
+          payload.sampled = transaction.sampled?
+          payload.priority = transaction.priority
+
+          payload
+        end
+
+        def from_json serialized_payload
+          raw_payload = JSON.parse serialized_payload
+          return raw_payload if raw_payload.nil?
+          payload_data = raw_payload[DATA_KEY]
+
+          payload = new
+          payload.version             = raw_payload[VERSION_KEY]
+          payload.parent_type         = payload_data[PARENT_TYPE_KEY]
+          payload.parent_account_id   = payload_data[PARENT_ACCOUNT_ID_KEY]
+          payload.parent_app_id       = payload_data[PARENT_APP_KEY]
+          payload.trusted_account_key = payload_data[TRUSTED_ACCOUNT_KEY]
+          payload.timestamp           = payload_data[TIMESTAMP_KEY]
+          payload.id                  = payload_data[ID_KEY]
+          payload.transaction_id      = payload_data[TX_KEY]
+          payload.trace_id            = payload_data[TRACE_ID_KEY]
+          payload.sampled             = payload_data[SAMPLED_KEY]
+          payload.priority            = payload_data[PRIORITY_KEY]
+
+          payload
+        end
+
+        def from_http_safe http_safe_payload
+          decoded_payload = Base64.strict_decode64 http_safe_payload
+          from_json decoded_payload
+        end
+
+        def major_version_matches?(payload)
+          payload.version[0] == VERSION[0]
+        end
+
+        private
+
+        def assign_trusted_account_key payload, account_id
+          trusted_account_key = Agent.config[:trusted_account_key]
+
+          if account_id != trusted_account_key
+            payload.trusted_account_key = trusted_account_key
+          end
+        end
+
+        def current_segment_id(transaction)
+          if Agent.config[:'span_events.enabled'] && transaction.current_segment
+            transaction.current_segment.guid
+          end
+        end
+
+        def connected?
+          Agent.instance.connected?
+        end
+      end
+
+      attr_accessor :version,
+                    :parent_type,
+                    :parent_account_id,
+                    :parent_app_id,
+                    :trusted_account_key,
+                    :id,
+                    :transaction_id,
+                    :trace_id,
+                    :sampled,
+                    :priority,
+                    :timestamp
+
+      alias_method :sampled?, :sampled
+
+      # Represent this payload as a raw JSON string.
+      #
+      # @return [String] Payload translated to JSON
+      #
+      # @api public
+      def text
+        result = {
+          VERSION_KEY => version
+        }
+
+        result[DATA_KEY] = {
+          PARENT_TYPE_KEY       => parent_type,
+          PARENT_ACCOUNT_ID_KEY => parent_account_id,
+          PARENT_APP_KEY        => parent_app_id,
+          TX_KEY                => transaction_id,
+          TRACE_ID_KEY          => trace_id,
+          SAMPLED_KEY           => sampled,
+          PRIORITY_KEY          => priority,
+          TIMESTAMP_KEY         => timestamp,
+        }
+
+        result[DATA_KEY][ID_KEY]              = id if id
+        result[DATA_KEY][TRUSTED_ACCOUNT_KEY] = trusted_account_key if trusted_account_key
+
+        JSON.dump(result)
+      end
+
+      # Encode this payload as a string suitable for passing via an
+      # HTTP header.
+      #
+      # @return [String] Payload translated to JSON and encoded for
+      #                  inclusion in headers
+      #
+      # @api public
+      def http_safe
+        Base64.strict_encode64 text
+      end
+    end
+  end
+end