newrelic_rpm 3.12.0.288 → 9.10.2

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

@@ -0,0 +1,253 @@
+# 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&.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(headers)
+        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(headers, 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&.id)
+          app_time_in_seconds = [
+            Process.clock_gettime(Process::CLOCK_REALTIME) - transaction.start_time,
+            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&.referring_path_hash
+      end
+
+      def append_cat_info(payload)
+        if (referring_guid = 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"]
+      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 @@
+# 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 @@
+# 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,159 @@
+# 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 'new_relic/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'
+
+      # 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 Agent.instance.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 = Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
+          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 = NewRelic::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
+      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
+        NewRelic::Base64.strict_encode64(text)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# 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 DistributedTraceTransportType
+      extend self
+
+      ALLOWABLE_TRANSPORT_TYPES = [
+        NewRelic::UNKNOWN,
+        NewRelic::HTTP,
+        NewRelic::HTTPS,
+        'Kafka',
+        'JMS',
+        'IronMQ',
+        'AMQP',
+        'Queue',
+        'Other'
+      ].freeze
+
+      URL_SCHEMES = {
+        'http' => NewRelic::HTTP,
+        'https' => NewRelic::HTTPS
+      }.freeze
+
+      RACK_URL_SCHEME = 'rack.url_scheme'
+
+      def from(value)
+        ALLOWABLE_TRANSPORT_TYPES.include?(value) ? value : NewRelic::UNKNOWN
+      end
+
+      def for_rack_request(request)
+        URL_SCHEMES[request[RACK_URL_SCHEME]]
+      end
+    end
+  end
+end