newrelic_rpm 6.6.0.358 → 6.11.0

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

@@ -0,0 +1,80 @@
+# 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.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module DistributedTraceIntrinsics
+      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
+        transport_type = transaction.distributed_tracer.caller_transport_type
+        destination[PARENT_TRANSPORT_TYPE_KEY] = DistributedTraceTransportType.from transport_type
+
+        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
+
+        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/rpm/blob/master/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_trace_payload.rb → distributed_tracing/distributed_trace_payload.rb}

@@ -1,9 +1,10 @@
 # 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.
+# frozen_string_literal: true
+
 require 'json'
 require 'base64'
-require 'set'
 
 module NewRelic
   module Agent
@@ -14,52 +15,25 @@ module NewRelic
     #
     # @api public
     class DistributedTracePayload
-      VERSION =[0, 1].freeze
-      PARENT_TYPE = "App".freeze
-      POUND = '#'.freeze
+      extend Coerce 
+
+      VERSION     = [0, 1].freeze
+      PARENT_TYPE = "App"
+      POUND       = '#'
 
       # Key names for serialization
-      VERSION_KEY                = 'v'.freeze
-      DATA_KEY                   = 'd'.freeze
-      PARENT_TYPE_KEY            = 'ty'.freeze
-      PARENT_ACCOUNT_ID_KEY      = 'ac'.freeze
-      PARENT_APP_KEY             = 'ap'.freeze
-      TRUSTED_ACCOUNT_KEY        = 'tk'.freeze
-      ID_KEY                     = 'id'.freeze
-      TX_KEY                     = 'tx'.freeze
-      TRACE_ID_KEY               = 'tr'.freeze
-      SAMPLED_KEY                = 'sa'.freeze
-      TIMESTAMP_KEY              = 'ti'.freeze
-      PRIORITY_KEY               = 'pr'.freeze
-
-      # Intrinsic Keys
-      PARENT_TYPE_INTRINSIC_KEY                = "parent.type".freeze
-      PARENT_APP_INTRINSIC_KEY                 = "parent.app".freeze
-      PARENT_ACCOUNT_ID_INTRINSIC_KEY          = "parent.account".freeze
-      PARENT_TRANSPORT_TYPE_INTRINSIC_KEY      = "parent.transportType".freeze
-      PARENT_TRANSPORT_DURATION_INTRINSIC_KEY  = "parent.transportDuration".freeze
-      GUID_INTRINSIC_KEY                       = "guid".freeze
-      TRACE_ID_INTRINSIC_KEY                   = "traceId".freeze
-      PARENT_ID_INTRINSIC_KEY                  = "parentId".freeze
-      PARENT_SPAN_ID_INTRINSIC_KEY             = "parentSpanId".freeze
-      SAMPLED_INTRINSIC_KEY                    = "sampled".freeze
-      COMMA                                    = ",".freeze
-
-      INTRINSIC_KEYS = [
-        PARENT_TYPE_INTRINSIC_KEY,
-        PARENT_APP_INTRINSIC_KEY,
-        PARENT_ACCOUNT_ID_INTRINSIC_KEY,
-        PARENT_TRANSPORT_TYPE_INTRINSIC_KEY,
-        PARENT_TRANSPORT_DURATION_INTRINSIC_KEY,
-        GUID_INTRINSIC_KEY,
-        TRACE_ID_INTRINSIC_KEY,
-        PARENT_ID_INTRINSIC_KEY,
-        PARENT_SPAN_ID_INTRINSIC_KEY,
-        SAMPLED_INTRINSIC_KEY
-      ].freeze
-
-      # Intrinsic Values
-      PARENT_TRANSPORT_TYPE_UNKNOWN = 'Unknown'.freeze
+      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
 
@@ -110,24 +84,12 @@ module NewRelic
           from_json decoded_payload
         end
 
-        def assign_initial_intrinsics transaction, transaction_payload
-          transaction_payload[GUID_INTRINSIC_KEY] = transaction.guid
-          transaction_payload[TRACE_ID_INTRINSIC_KEY] = transaction.trace_id
-          transaction_payload[SAMPLED_INTRINSIC_KEY] = transaction.sampled?
-        end
-
         def major_version_matches?(payload)
           payload.version[0] == VERSION[0]
         end
 
         private
 
-        # We use the presence of the account_id and primary_application in the
-        # config to tell if we have connected yet.
-        def connected?
-          Agent.config[:account_id] && Agent.config[:primary_application_id]
-        end
-
         def assign_trusted_account_key payload, account_id
           trusted_account_key = Agent.config[:trusted_account_key]
 
@@ -142,6 +104,10 @@ module NewRelic
             transaction.current_segment.guid
           end
         end
+
+        def connected?
+          Agent.instance.connected?
+        end
       end
 
       attr_accessor :version,
@@ -158,16 +124,6 @@ module NewRelic
 
       alias_method :sampled?, :sampled
 
-      attr_reader :caller_transport_type
-
-      def caller_transport_type=(type)
-        @caller_transport_type = valid_transport_type_for(type)
-      end
-
-      def initialize
-        @caller_transport_type = PARENT_TRANSPORT_TYPE_UNKNOWN
-      end
-
       # Represent this payload as a raw JSON string.
       #
       # @return [String] Payload translated to JSON
@@ -205,38 +161,6 @@ module NewRelic
       def http_safe
         Base64.strict_encode64 text
       end
-
-      def assign_intrinsics transaction, transaction_payload
-        transaction_payload[PARENT_TYPE_INTRINSIC_KEY] = parent_type
-        transaction_payload[PARENT_APP_INTRINSIC_KEY] = parent_app_id
-        transaction_payload[PARENT_ACCOUNT_ID_INTRINSIC_KEY] = parent_account_id
-        transaction_payload[PARENT_TRANSPORT_TYPE_INTRINSIC_KEY] = caller_transport_type
-        transaction_payload[PARENT_TRANSPORT_DURATION_INTRINSIC_KEY] = transaction.transport_duration
-        transaction_payload[GUID_INTRINSIC_KEY] = transaction.guid
-        transaction_payload[TRACE_ID_INTRINSIC_KEY] = trace_id
-        transaction_payload[PARENT_ID_INTRINSIC_KEY] = transaction.parent_id if transaction.parent_id
-        transaction_payload[PARENT_SPAN_ID_INTRINSIC_KEY] = id if id
-        transaction_payload[SAMPLED_INTRINSIC_KEY] = transaction.sampled?
-      end
-
-      private
-
-      ALLOWABLE_TRANSPORT_TYPES = Set.new(%w[
-        Unknown
-        HTTP
-        HTTPS
-        Kafka
-        JMS
-        IronMQ
-        AMQP
-        Queue
-        Other
-      ]).freeze
-
-      def valid_transport_type_for(value)
-        return value if ALLOWABLE_TRANSPORT_TYPES.include?(value)
-        PARENT_TRANSPORT_TYPE_UNKNOWN
-      end
     end
   end
 end

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

@@ -0,0 +1,39 @@
+# 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.
+# 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

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

@@ -0,0 +1,246 @@
+# 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.
+# frozen_string_literal: true
+
+require_relative 'trace_context_payload'
+
+module NewRelic
+  module Agent
+    module DistributedTracing
+      class TraceContext
+        VERSION = 0x0
+
+        COMMA             = ','
+        EQUALS            = '='
+        INVALID_TRACE_ID  = ('0' * 32)
+        INVALID_PARENT_ID = ('0' * 16)
+        INVALID_VERSION   = 'ff'
+
+        TRACE_ID_KEY          = 'trace_id'
+        TRACE_FLAGS_KEY       = 'trace_flags'
+        PARENT_ID_KEY         = 'parent_id'
+        VERSION_KEY           = 'version'
+        UNDEFINED_FIELDS_KEY  = 'undefined_fields'
+
+        TP_VERSION          = "(?<#{VERSION_KEY}>[a-f\\d]{2})"
+        TP_TRACE_ID         = "(?<#{TRACE_ID_KEY}>[a-f\\d]{32})"
+        TP_PARENT_ID        = "(?<#{PARENT_ID_KEY}>[a-f\\d]{16})"
+        TP_TRACE_FLAGS      = "(?<#{TRACE_FLAGS_KEY}>\\d{2})"
+        TP_UNDEFINED_FIELDS = "(?<#{UNDEFINED_FIELDS_KEY}>-[a-zA-Z\\d-]*)"
+        TRACE_PARENT_REGEX  = /\A#{TP_VERSION}-#{TP_TRACE_ID}-#{TP_PARENT_ID}-#{TP_TRACE_FLAGS}#{TP_UNDEFINED_FIELDS}?\z/
+
+        TRACE_PARENT_FORMAT_STRING = "%02x-%s-%s-%02x"
+
+        MAX_TRACE_STATE_SIZE = 512 # bytes
+        MAX_TRACE_STATE_ENTRY_SIZE = 128 # bytes
+
+        SUPPORTABILITY_TRACE_PARENT_PARSE_EXCEPTION = "Supportability/TraceContext/TraceParent/Parse/Exception"
+        SUPPORTABILITY_TRACE_STATE_PARSE_EXCEPTION  = "Supportability/TraceContext/TraceState/Parse/Exception"
+        SUPPORTABILITY_TRACE_STATE_INVALID_NR_ENTRY = "Supportability/TraceContext/TraceState/InvalidNrEntry"
+
+        class << self
+          def insert format: NewRelic::FORMAT_NON_RACK,
+                     carrier: nil,
+                     parent_id: nil,
+                     trace_id: nil,
+                     trace_flags: nil,
+                     trace_state: nil
+
+            trace_parent_header = trace_parent_header_for_format format
+            carrier[trace_parent_header] = format_trace_parent \
+              trace_id: trace_id,
+              parent_id: parent_id,
+              trace_flags: trace_flags
+
+            trace_state_header = trace_state_header_for_format format
+            carrier[trace_state_header] = trace_state if trace_state && !trace_state.empty?
+          end
+
+          def parse format: NewRelic::FORMAT_NON_RACK,
+                    carrier: nil,
+                    trace_state_entry_key: nil
+            trace_parent = extract_traceparent(format, carrier)
+            unless trace_parent_valid? trace_parent
+              NewRelic::Agent.increment_metric SUPPORTABILITY_TRACE_PARENT_PARSE_EXCEPTION
+              return nil
+            end
+
+            begin
+              if header_data = extract_tracestate(format, carrier, trace_state_entry_key)
+                header_data.trace_parent = trace_parent
+                header_data
+              end
+            rescue Exception
+              NewRelic::Agent.increment_metric SUPPORTABILITY_TRACE_STATE_PARSE_EXCEPTION
+              return nil
+            end
+          end
+
+          def create_trace_state_entry entry_key, payload
+            "#{entry_key}=#{payload}".dup
+          end
+
+          private
+
+          def format_trace_parent trace_id: nil,
+                                  parent_id: nil,
+                                  trace_flags: nil
+            sprintf TRACE_PARENT_FORMAT_STRING,
+                    VERSION,
+                    trace_id,
+                    parent_id,
+                    trace_flags
+          end
+
+          def extract_traceparent format, carrier
+            header_name = trace_parent_header_for_format format
+            return unless header = carrier[header_name]
+            if matchdata = header.match(TRACE_PARENT_REGEX)
+              TRACE_PARENT_REGEX.named_captures.inject({}) do |hash, (name, (index))|
+                hash[name] = matchdata[index]
+                hash
+              end
+            end
+          end
+
+          def trace_parent_valid? trace_parent
+            return false if trace_parent.nil?
+            return false if trace_parent[TRACE_ID_KEY] == INVALID_TRACE_ID
+            return false if trace_parent[PARENT_ID_KEY] == INVALID_PARENT_ID
+            return false if trace_parent[VERSION_KEY] == INVALID_VERSION
+            return false if trace_parent[VERSION_KEY].to_i(16) == VERSION && !trace_parent[UNDEFINED_FIELDS_KEY].nil?
+
+            true
+          end
+
+          def trace_parent_header_for_format format
+            if format == NewRelic::FORMAT_RACK
+              NewRelic::HTTP_TRACEPARENT_KEY
+            else
+              NewRelic::TRACEPARENT_KEY
+            end
+          end
+
+          def trace_state_header_for_format format
+            if format == NewRelic::FORMAT_RACK
+              NewRelic::HTTP_TRACESTATE_KEY
+            else
+              NewRelic::TRACESTATE_KEY
+            end
+          end
+
+          def extract_tracestate format, carrier, trace_state_entry_key
+            header_name = trace_state_header_for_format format
+            header = carrier[header_name]
+            return HeaderData.create if header.nil? || header.empty?
+
+            payload = nil
+            trace_state_size = 0
+            trace_state_vendors = String.new
+            trace_state = header.split(COMMA).map(&:strip)
+            trace_state.reject! do |entry|
+              if entry == NewRelic::EMPTY_STR
+                false
+              else
+                vendor_id = entry.slice 0, entry.index(EQUALS)
+                if vendor_id == trace_state_entry_key
+                  payload = entry.slice! trace_state_entry_key.size + 1, entry.size
+                  true
+                else
+                  trace_state_size += entry.size
+                  trace_state_vendors << vendor_id << COMMA
+                  false
+                end
+              end
+            end
+
+            trace_state_vendors.chomp! COMMA
+
+            HeaderData.create trace_state_payload: payload ? decode_payload(payload) : nil,
+                        trace_state_entries: trace_state,
+                        trace_state_size: trace_state_size,
+                        trace_state_vendors: trace_state_vendors
+          end
+
+          def decode_payload payload
+            TraceContextPayload.from_s payload
+          rescue
+            if payload
+              NewRelic::Agent.increment_metric SUPPORTABILITY_TRACE_STATE_INVALID_NR_ENTRY
+            end
+            return nil
+          end
+        end
+
+        class HeaderData
+          class << self
+            def create trace_parent: nil,
+                       trace_state_payload: nil,
+                       trace_state_entries: nil,
+                       trace_state_size: 0,
+                       trace_state_vendors: nil
+              new trace_parent, \
+                  trace_state_payload, \
+                  trace_state_entries, \
+                  trace_state_size, \
+                  trace_state_vendors
+            end
+          end
+
+          def initialize trace_parent, trace_state_payload, trace_state_entries, trace_state_size, trace_state_vendors
+            @trace_parent = trace_parent
+            @trace_state = nil
+            @trace_state_entries = trace_state_entries
+            @trace_state_payload = trace_state_payload
+            @trace_state_size = trace_state_size
+            @trace_state_vendors = trace_state_vendors
+          end
+
+          attr_accessor :trace_parent, :trace_state_payload, :trace_state_vendors
+
+          def trace_state trace_state_entry
+            @trace_state ||= join_trace_state trace_state_entry.size
+            @trace_state_entries = nil
+
+            trace_state_entry << @trace_state
+          end
+
+          def trace_id
+            @trace_parent[TRACE_ID_KEY]
+          end
+
+          def parent_id
+            @trace_parent[PARENT_ID_KEY]
+          end
+
+          private
+
+          def join_trace_state trace_state_entry_size
+            return @trace_state || NewRelic::EMPTY_STR if @trace_state_entries.nil? || @trace_state_entries.empty?
+
+            max_size = MAX_TRACE_STATE_SIZE - trace_state_entry_size
+            return @trace_state_entries.join(COMMA).prepend(COMMA) if @trace_state_size < max_size
+
+            joined_trace_state = ''.dup
+
+            used_size = 0
+
+            @trace_state_entries.each do |entry|
+              entry_size = entry.size + 1
+              break if used_size + entry_size > max_size
+              next if entry_size > MAX_TRACE_STATE_ENTRY_SIZE
+
+              joined_trace_state << COMMA << entry
+              used_size += entry_size
+            end
+
+            joined_trace_state
+          end
+
+        end
+
+      end
+    end
+  end
+end