newrelic_rpm 4.5.0.337 → 4.6.0.338

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

@@ -37,12 +37,13 @@ module NewRelic
             transaction.segment_complete self
           end
         rescue => e
-          # This rescue block was added for the benefit of this test:
-          # test/multiverse/suites/bare/standalone_instrumentation_test.rb
-          # See the top of the test for details.
           NewRelic::Agent.logger.error "Exception finishing segment: #{name}", e
         end
 
+        def finished?
+          !!@end_time
+        end
+
         def record_metrics?
           @record_metrics
         end
@@ -55,8 +56,15 @@ module NewRelic
           @record_on_finish
         end
 
-        def record_metrics
-          raise NotImplementedError, "Subclasses must implement record_metrics"
+        def finalize
+          unless finished?
+            finish
+            NewRelic::Agent.logger.warn "Segment: #{name} was unfinished at " \
+              "the end of transaction. Timing information for " \
+              "#{transaction.best_name} may be inaccurate."
+            # @todo: we should record a supportability metric here
+          end
+          record_metrics if record_metrics?
         end
 
         def params
@@ -78,6 +86,10 @@ module NewRelic
 
         protected
 
+        def record_metrics
+          raise NotImplementedError, "Subclasses must implement record_metrics"
+        end
+
         def child_complete segment
           if segment.record_metrics?
             self.children_time += segment.duration

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

@@ -0,0 +1,121 @@
+# 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.
+
+require 'new_relic/agent/distributed_trace_payload'
+
+module NewRelic
+  module Agent
+    class Transaction
+      module DistributedTracing
+        attr_accessor :distributed_trace_payload
+
+        def distributed_trace?
+          !!distributed_trace_payload
+        end
+
+        def create_distributed_trace_payload url = nil
+          return unless Agent.config[:'distributed_tracing.enabled']
+          self.order += 1
+          DistributedTracePayload.for_transaction self, url
+        end
+
+        LBRACE = "{".freeze
+
+        def accept_distributed_trace_payload transport_type, payload
+          return unless Agent.config[:'distributed_tracing.enabled']
+          if distributed_trace_payload
+            NewRelic::Agent.increment_metric "Supportability/DistributedTracing/AcceptFailure/PayloadAlreadyAccepted"
+            return false
+          elsif self.order > 0
+            NewRelic::Agent.increment_metric "Supportability/DistributedTracing/AcceptFailure/CreateDistributedTracePayload-before-AcceptDistributedTracePayload"
+            return false
+          elsif name_frozen?
+            NewRelic::Agent.increment_metric "Supportability/DistributedTracing/AcceptFailure/BrowserAgentInjected"
+            return false
+          end
+
+          payload = if payload.start_with? LBRACE
+            DistributedTracePayload.from_json payload
+          else
+            DistributedTracePayload.from_http_safe payload
+          end
+
+          payload.caller_transport_type = transport_type
+          self.distributed_trace_payload = payload
+
+          self.sampled = payload.sampled unless payload.sampled.nil?
+
+          true
+        rescue => e
+          NewRelic::Agent.increment_metric "Supportability/DistributedTracing/AcceptFailure/Unknown"
+          NewRelic::Agent.logger.warn "Failed to accept distributed trace payload", e
+          false
+        end
+
+        def distributed_tracing_trip_id
+          if distributed_trace_payload
+            distributed_trace_payload.trip_id
+          else
+            guid
+          end
+        end
+
+        def parent_ids
+          if distributed_trace_payload &&
+               distributed_trace_payload.parent_ids &&
+               distributed_trace_payload.parent_ids.last != guid
+            inbound_ids = distributed_trace_payload.parent_ids.dup
+            inbound_ids.push guid
+            if inbound_ids.size > 3
+              inbound_ids.shift
+            end
+            inbound_ids
+          else
+            [guid]
+          end
+        end
+
+        def depth
+          if distributed_trace_payload
+            distributed_trace_payload.depth
+          else
+            1
+          end
+        end
+
+        def order
+          @order ||= 0
+        end
+
+        attr_writer :order
+
+        def append_distributed_tracing_info payload
+          return unless Agent.config[:'distributed_tracing.enabled']
+          if distributed_trace_payload
+            distributed_trace_payload.assign_intrinsics self, payload
+          elsif order > 0
+            DistributedTracePayload.assign_initial_intrinsics self, payload
+          end
+        end
+
+        def assign_distributed_tracing_intrinsics
+          return unless Agent.config[:'distributed_tracing.enabled']
+          DistributedTracePayload::INTRINSIC_KEYS.each do |key|
+            next unless value = @payload[key]
+            attributes.add_intrinsic_attribute key, value
+          end
+          nil
+        end
+
+        # This method returns transport_duration in seconds. Transport duration
+        # is stored in milliseconds on the payload, but it's needed in seconds
+        # for metrics and intrinsics.
+        def transport_duration
+          return unless distributed_trace_payload
+          (start_time.to_f * 1000 - distributed_trace_payload.timestamp) / 1000
+        end
+      end
+    end
+  end
+end

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

@@ -8,12 +8,17 @@ 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
         attr_reader :library, :uri, :procedure
 
         NR_SYNTHETICS_HEADER = 'X-NewRelic-Synthetics'.freeze
 
-        def initialize library, uri, procedure
+        def initialize library, uri, procedure # :nodoc:
           @library = library
           @uri = HTTPClients::URIUtil.parse_and_normalize_url(uri)
           @procedure = procedure
@@ -22,20 +27,25 @@ module NewRelic
           super()
         end
 
-        def name
+        def name # :nodoc:
           @name ||= "External/#{host}/#{library}/#{procedure}"
         end
 
-        def host
+        def host # :nodoc:
           @host_header || uri.host
         end
 
-        # This method will add NewRelic headers for cross application tracing and
-        # will check to see if a host header is used for the request. If a host
-        # header is used it will update the segment name to reflect the host header.
+        # 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 && transaction.raw_synthetics_header
           insert_synthetics_header request, synthetics_header if synthetics_header
 
@@ -43,14 +53,22 @@ module NewRelic
 
           transaction_state.is_cross_app_caller = true
           txn_guid = transaction_state.request_guid
-          trip_id   = transaction && transaction.cat_trip_id(transaction_state)
-          path_hash = transaction && transaction.cat_path_hash(transaction_state)
+          trip_id   = transaction && transaction.cat_trip_id
+          path_hash = transaction && transaction.cat_path_hash
 
           CrossAppTracing.insert_request_headers request, txn_guid, trip_id, path_hash
+          insert_distributed_trace_header 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)
@@ -69,22 +87,103 @@ module NewRelic
           NewRelic::Agent.logger.error "Error in read_response_headers", e
         end
 
-        def cross_app_request?
+        def cross_app_request? # :nodoc:
           !!@app_data
         end
 
-        def cross_process_id
+        def cross_process_id # :nodoc:
           @app_data && @app_data[0]
         end
 
-        def transaction_guid
+        def transaction_guid # :nodoc:
           @app_data && @app_data[5]
         end
 
-        def cross_process_transaction_name
+        def cross_process_transaction_name # :nodoc:
           @app_data && @app_data[1]
         end
 
+        EXTERNAL_TRANSACTION_PREFIX = 'ExternalTransaction/'.freeze
+        SLASH = '/'.freeze
+        APP_DATA_KEY = 'NewRelicAppData'.freeze
+
+        # 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.cat_trip_id,
+                transaction.cat_path_hash
+              ]
+            }
+
+            # flag cross app in the state so transaction knows to add bits to paylaod
+            #
+            transaction.state.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
+          record_distributed_tracing_metrics if Agent.config[:'distributed_tracing.enabled']
+          super
+        end
+
         private
 
         def insert_synthetics_header request, header
@@ -106,19 +205,25 @@ module NewRelic
           end
         end
 
+        X_NEWRELIC_TRACE_HEADER = "X-NewRelic-Trace".freeze
+
+        def insert_distributed_trace_header request
+          return unless Agent.config[:'distributed_tracing.enabled']
+          payload = transaction.create_distributed_trace_payload uri
+          request[X_NEWRELIC_TRACE_HEADER] = payload.http_safe
+        end
+
         EXTERNAL_ALL = "External/all".freeze
 
-        def unscoped_metrics
-          metrics = [ EXTERNAL_ALL,
+        def add_unscoped_metrics
+          @unscoped_metrics = [ EXTERNAL_ALL,
             "External/#{host}/all",
             suffixed_rollup_metric
           ]
 
           if cross_app_request?
-            metrics << "ExternalApp/#{host}/#{cross_process_id}/all"
+            @unscoped_metrics << "ExternalApp/#{host}/#{cross_process_id}/all"
           end
-
-          metrics
         end
 
         EXTERNAL_ALL_WEB = "External/allWeb".freeze
@@ -132,6 +237,61 @@ module NewRelic
           end
         end
 
+        ALL_SUFFIX = "all".freeze
+        ALL_WEB_SUFFIX = "allWeb".freeze
+        ALL_OTHER_SUFFIX = "allOther".freeze
+
+        def transaction_type_suffix
+          if Transaction.recording_web_transaction?
+            ALL_WEB_SUFFIX
+          else
+            ALL_OTHER_SUFFIX
+          end
+        end
+
+        def record_distributed_tracing_metrics
+          add_caller_by_duration_metrics
+          record_transport_duration_metrics
+          record_errors_by_caller_metrics
+        end
+
+        DURATION_BY_CALLER_UNKOWN_PREFIX = "DurationByCaller/Unknown/Unknown/Unknown/Unknown".freeze
+
+        def add_caller_by_duration_metrics
+          prefix = if transaction.distributed_trace?
+            payload = transaction.distributed_trace_payload
+            "DurationByCaller/#{payload.caller_type}/#{payload.caller_account_id}/#{payload.caller_app_id}/transport"
+          else
+            DURATION_BY_CALLER_UNKOWN_PREFIX
+          end
+
+          @unscoped_metrics << "#{prefix}/#{ALL_SUFFIX}"
+          @unscoped_metrics << "#{prefix}/#{transaction_type_suffix}"
+        end
+
+        def record_transport_duration_metrics
+          return unless transaction.distributed_trace?
+          payload = transaction.distributed_trace_payload
+          prefix = "TransportDuration/#{payload.caller_type}/#{payload.caller_account_id}/#{payload.caller_app_id}/transport"
+          metric_cache.record_unscoped "#{prefix}/#{ALL_SUFFIX}", transaction.transport_duration
+          metric_cache.record_unscoped "#{prefix}/#{transaction_type_suffix}", transaction.transport_duration
+        end
+
+        ERRORS_BY_CALLER_UNKOWN_PREFIX = "ErrorsByCaller/Unknown/Unknown/Unknown/Unknown".freeze
+
+        def record_errors_by_caller_metrics
+          return unless transaction.exceptions.size > 0
+          prefix = if transaction.distributed_trace?
+            payload = transaction.distributed_trace_payload
+            "ErrorsByCaller/#{payload.caller_type}/#{payload.caller_account_id}/#{payload.caller_app_id}/transport"
+          else
+            ERRORS_BY_CALLER_UNKOWN_PREFIX
+          end
+
+          NewRelic::Agent.increment_metric "#{prefix}/#{ALL_SUFFIX}"
+          NewRelic::Agent.increment_metric "#{prefix}/#{transaction_type_suffix}"
+        end
+
         def update_segment_name
           if @app_data
             @name = "ExternalTransaction/#{host}/#{cross_process_id}/#{cross_process_transaction_name}"
@@ -139,6 +299,10 @@ module NewRelic
             @name = "External/#{host}/#{library}/#{procedure}"
           end
         end
+
+        def obfuscator
+          CrossAppTracing.obfuscator
+        end
       end
     end
   end