newrelic_rpm 6.6.0.358 → 6.11.0.365

data/lib/new_relic/agent/{cross_app_payload.rb → distributed_tracing/cross_app_payload.rb}

@@ -29,7 +29,8 @@ module NewRelic
           queue_time_in_seconds.to_f,
           app_time_in_seconds.to_f,
           content_length,
-          transaction.guid
+          transaction.guid,
+          false
         ]
       end
 

data/lib/new_relic/agent/{cross_app_tracing.rb → distributed_tracing/cross_app_tracing.rb}

@@ -2,6 +2,7 @@
 # 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'
 
@@ -9,23 +10,22 @@ module NewRelic
   module Agent
     module CrossAppTracing
       # The cross app response header for "outgoing" calls
-      NR_APPDATA_HEADER = 'X-NewRelic-App-Data'.freeze
+      NR_APPDATA_HEADER = 'X-NewRelic-App-Data'
 
       # The cross app id header for "outgoing" calls
-      NR_ID_HEADER = 'X-NewRelic-ID'.freeze
+      NR_ID_HEADER = 'X-NewRelic-ID'
 
       # The cross app transaction header for "outgoing" calls
-      NR_TXN_HEADER = 'X-NewRelic-Transaction'.freeze
+      NR_TXN_HEADER = 'X-NewRelic-Transaction'
 
-      NR_MESSAGE_BROKER_ID_HEADER  = 'NewRelicID'.freeze
-      NR_MESSAGE_BROKER_TXN_HEADER = 'NewRelicTransaction'.freeze
-      NR_MESSAGE_BROKER_SYNTHETICS_HEADER = 'NewRelicSynthetics'.freeze
+      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 unless defined? @is_cross_app_caller
-        @is_cross_app_caller
+        @is_cross_app_caller ||= false
       end
 
       def is_cross_app_callee?
@@ -37,28 +37,61 @@ module NewRelic
       end
 
       def cat_trip_id
-        cross_app_payload && cross_app_payload.referring_trip_id || guid
+        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 = NewRelic::Agent.instance.cross_app_monitor.path_hash(best_name, seed)
+        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
-        self.is_cross_app_caller = true
-        CrossAppTracing.insert_message_headers headers,
-                                               guid,
-                                               cat_trip_id,
-                                               cat_path_hash,
-                                               raw_synthetics_header
+        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)
@@ -75,8 +108,8 @@ module NewRelic
           payload[:referring_transaction_guid] = referring_guid
         end
 
-        return unless include_guid?
-        payload[:guid] = guid
+        return unless transaction.include_guid?
+        payload[:guid] = transaction.guid
 
         return unless is_cross_app?
         trip_id             = cat_trip_id
@@ -96,18 +129,6 @@ module NewRelic
         end
       end
 
-      def assign_cross_app_intrinsics
-        attributes.add_intrinsic_attribute(:trip_id, cat_trip_id)
-        attributes.add_intrinsic_attribute(:path_hash, cat_path_hash)
-      end
-
-      def record_cross_app_metrics
-        if (id = cross_app_payload && cross_app_payload.id)
-          app_time_in_seconds = [Time.now.to_f - @start_time.to_f, 0.0].max
-          NewRelic::Agent.record_metric "ClientApplication/#{id}/all", app_time_in_seconds
-        end
-      end
-
       ###############
       module_function
       ###############
@@ -119,7 +140,7 @@ module NewRelic
       end
 
       def valid_cross_process_id?
-        if NewRelic::Agent.config[:cross_process_id] && NewRelic::Agent.config[:cross_process_id].length > 0
+        if Agent.config[:cross_process_id] && Agent.config[:cross_process_id].length > 0
           true
         else
           NewRelic::Agent.logger.debug "No cross_process_id configured"
@@ -128,7 +149,7 @@ module NewRelic
       end
 
       def valid_encoding_key?
-        if NewRelic::Agent.config[:encoding_key] && NewRelic::Agent.config[:encoding_key].length > 0
+        if Agent.config[:encoding_key] && Agent.config[:encoding_key].length > 0
           true
         else
           NewRelic::Agent.logger.debug "No encoding_key set"
@@ -143,7 +164,7 @@ module NewRelic
       end
 
       def obfuscator
-        @obfuscator ||= NewRelic::Agent::Obfuscator.new(NewRelic::Agent.config[:encoding_key])
+        @obfuscator ||= NewRelic::Agent::Obfuscator.new(Agent.config[:encoding_key])
       end
 
       def insert_request_headers request, txn_guid, trip_id, path_hash
@@ -188,12 +209,6 @@ module NewRelic
         !!(xp_id =~ /\A\d+#\d+\z/)
       end
 
-      def insert_message_headers headers, txn_guid, trip_id, path_hash, synthetics_header
-        headers[NR_MESSAGE_BROKER_ID_HEADER]  = obfuscator.obfuscate(NewRelic::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 message_has_crossapp_request_header? headers
         !!headers[NR_MESSAGE_BROKER_ID_HEADER]
       end
@@ -217,15 +232,15 @@ module NewRelic
       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 (transaction       = state.current_transaction)
-        return unless (cross_app_payload = transaction.cross_app_payload)
+        return unless (txn = state.current_transaction)
+        return unless (payload = txn.distributed_tracer.cross_app_payload)
 
-        if (cross_app_id = cross_app_payload.id)
-          transaction.attributes.add_intrinsic_attribute(:client_cross_process_id, cross_app_id)
+        if (cross_app_id = payload.id)
+          txn.attributes.add_intrinsic_attribute(:client_cross_process_id, cross_app_id)
         end
 
-        if (referring_guid = cross_app_payload.referring_guid)
-          transaction.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
+        if (referring_guid = payload.referring_guid)
+          txn.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
         end
       end
     end

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]
 
@@ -137,11 +99,14 @@ module NewRelic
         end
 
         def current_segment_id(transaction)
-          if Agent.config[:'span_events.enabled'] && transaction.sampled? &&
-              transaction.current_segment
+          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,
@@ -158,16 +123,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 +160,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