newrelic_rpm 4.8.0.341 → 5.1.0.344

data/lib/new_relic/agent/instrumentation/resque.rb

@@ -22,52 +22,33 @@ DependencyDetection.defer do
   end
 
   executes do
-    module Resque
-      module Plugins
-        module NewRelicInstrumentation
-          include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    module ::Resque
+      class Job
+        include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
-          def around_perform_with_monitoring(*args)
-            begin
-              perform_action_with_newrelic_trace(
-                :name => 'perform',
-                :class_name => self.name,
-                :category => 'OtherTransaction/ResqueJob') do
+        alias_method :perform_without_instrumentation, :perform
 
-                NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(args, :'job.resque.args',
-                  NewRelic::Agent::AttributeFilter::DST_NONE)
+        def perform
+          begin
+            perform_action_with_newrelic_trace(
+              :name => 'perform',
+              :class_name => self.payload_class,
+              :category => 'OtherTransaction/ResqueJob') do
 
-                yield(*args)
-              end
-            ensure
-              NewRelic::Agent.agent.flush_pipe_data
-            end
-          end
-        end
-      end
-    end
+              NewRelic::Agent::Transaction.merge_untrusted_agent_attributes(
+                args,
+                :'job.resque.args',
+                NewRelic::Agent::AttributeFilter::DST_NONE)
 
-    module NewRelic
-      module Agent
-        module Instrumentation
-          module ResqueInstrumentationInstaller
-            def payload_class
-              klass = super
-              klass.instance_eval do
-                extend ::Resque::Plugins::NewRelicInstrumentation
-              end
+              perform_without_instrumentation
             end
+          ensure
+            NewRelic::Agent.agent.flush_pipe_data
           end
         end
       end
     end
 
-    ::Resque::Job.class_eval do
-      def self.new(*args)
-        super(*args).extend NewRelic::Agent::Instrumentation::ResqueInstrumentationInstaller
-      end
-    end
-
     if NewRelic::LanguageSupport.can_fork?
       ::Resque.before_first_fork do
         NewRelic::Agent.manual_start(:dispatcher   => :resque,

data/lib/new_relic/agent/instrumentation/sequel.rb

@@ -39,7 +39,6 @@ DependencyDetection.defer do
       end
 
       Sequel::Model.plugin :newrelic_instrumentation
-
     else
 
       NewRelic::Agent.logger.info "Sequel instrumentation requires at least version 3.37.0."

data/lib/new_relic/agent/javascript_instrumentor.rb

@@ -104,7 +104,7 @@ module NewRelic
       end
 
       def browser_timing_loader
-        html_safe_if_needed("\n<script type=\"text/javascript\">#{Agent.config[:js_agent_loader]}</script>")
+        html_safe_if_needed("\n<script>#{Agent.config[:js_agent_loader]}</script>")
       end
 
       def browser_timing_config(state)
@@ -114,7 +114,7 @@ module NewRelic
         txn.freeze_name_and_execute_if_not_ignored do
           data = data_for_js_agent(state)
           json = ::JSON.dump(data)
-          return html_safe_if_needed("\n<script type=\"text/javascript\">window.NREUM||(NREUM={});NREUM.info=#{json}</script>")
+          return html_safe_if_needed("\n<script>window.NREUM||(NREUM={});NREUM.info=#{json}</script>")
         end
 
         ''

data/lib/new_relic/agent/messaging.rb

@@ -364,7 +364,17 @@ module NewRelic
         transaction_name
       end
 
+      NEWRELIC_TRACE_KEY      = "NewRelicTrace".freeze
+      RABBITMQ_TRANSPORT_TYPE = "RabbitMQ".freeze
+
       def consume_message_headers headers, transaction, state
+        if Agent.config[:'distributed_tracing.enabled']
+          payload = headers[NEWRELIC_TRACE_KEY]
+          if transaction.accept_distributed_trace_payload payload
+            transaction.distributed_trace_payload.caller_transport_type = RABBITMQ_TRANSPORT_TYPE
+          end
+        end
+
         if CrossAppTracing.cross_app_enabled? && CrossAppTracing.message_has_crossapp_request_header?(headers)
           decode_id headers[CrossAppTracing::NR_MESSAGE_BROKER_ID_HEADER], state
           decode_txn_info headers[CrossAppTracing::NR_MESSAGE_BROKER_TXN_HEADER], state

data/lib/new_relic/agent/method_tracer.rb

@@ -291,7 +291,27 @@ module NewRelic
         #
         # @api public
         #
-        def add_method_tracer(method_name, metric_name_code=nil, options = {})
+        def add_method_tracer(method_name, metric_name_code = nil, options = {})
+          ::NewRelic::Agent.add_or_defer_method_tracer(self, method_name, metric_name_code, options)
+        end
+
+        # For tests only because tracers must be removed in reverse-order
+        # from when they were added, or else other tracers that were added to the same method
+        # may get removed as well.
+        def remove_method_tracer(method_name, metric_name_code) # :nodoc:
+          return unless Agent.config[:agent_enabled]
+          if method_defined? "#{_traced_method_name(method_name, metric_name_code)}"
+            alias_method method_name, "#{_untraced_method_name(method_name, metric_name_code)}"
+            undef_method "#{_traced_method_name(method_name, metric_name_code)}"
+            ::NewRelic::Agent.logger.debug("removed method tracer #{method_name} #{metric_name_code}\n")
+          else
+            raise "No tracer for '#{metric_name_code}' on method '#{method_name}'"
+          end
+        end
+
+        private
+
+        def _add_method_tracer_now(method_name, metric_name_code, options)
           NewRelic::Agent.record_api_supportability_metric(:add_method_tracer)
 
           return unless newrelic_method_exists?(method_name)
@@ -308,24 +328,9 @@ module NewRelic
           send visibility, method_name
           send visibility, _traced_method_name(method_name, metric_name_code)
           ::NewRelic::Agent.logger.debug("Traced method: class = #{derived_class_name},"+
-                    "method = #{method_name}, "+
-                    "metric = '#{metric_name_code}'")
-        end
-
-        # For tests only because tracers must be removed in reverse-order
-        # from when they were added, or else other tracers that were added to the same method
-        # may get removed as well.
-        def remove_method_tracer(method_name, metric_name_code) # :nodoc:
-          return unless Agent.config[:agent_enabled]
-          if method_defined? "#{_traced_method_name(method_name, metric_name_code)}"
-            alias_method method_name, "#{_untraced_method_name(method_name, metric_name_code)}"
-            undef_method "#{_traced_method_name(method_name, metric_name_code)}"
-            ::NewRelic::Agent.logger.debug("removed method tracer #{method_name} #{metric_name_code}\n")
-          else
-            raise "No tracer for '#{metric_name_code}' on method '#{method_name}'"
-          end
+                                         "method = #{method_name}, "+
+                                         "metric = '#{metric_name_code}'")
         end
-        private
 
         # given a method and a metric, this method returns the
         # untraced alias of the method name

data/lib/new_relic/agent/new_relic_service.rb

@@ -15,7 +15,8 @@ module NewRelic
       # Specifies the version of the agent's communication protocol with
       # the NewRelic hosted site.
 
-      PROTOCOL_VERSION = 14
+      PROTOCOL_VERSION = 15
+
       # 1f147a42: v10 (tag 3.5.3.17)
       # cf0d1ff1: v9 (tag 3.5.0)
       # 14105: v8 (tag 2.10.3)
@@ -30,8 +31,8 @@ module NewRelic
       # underlying TCP connection may be in a bad state.
       CONNECTION_ERRORS = [Timeout::Error, EOFError, SystemCallError, SocketError].freeze
 
-      attr_accessor :request_timeout, :agent_id
-      attr_reader :collector, :marshaller
+      attr_accessor :request_timeout
+      attr_reader :collector, :marshaller, :agent_id
 
       def initialize(license_key=nil, collector=control.server)
         @license_key = license_key
@@ -41,18 +42,12 @@ module NewRelic
         @in_session = nil
         @agent_id = nil
         @shared_tcp_connection = nil
+        reset_remote_method_uris
 
         @audit_logger = ::NewRelic::Agent::AuditLogger.new
         Agent.config.register_callback(:'audit_log.enabled') do |enabled|
           @audit_logger.enabled = enabled
         end
-        Agent.config.register_callback(:ssl) do |ssl|
-          if !ssl
-            ::NewRelic::Agent.logger.warn("Agent is configured not to use SSL when communicating with New Relic's servers")
-          else
-            ::NewRelic::Agent.logger.debug("Agent is configured to use SSL")
-          end
-        end
 
         Agent.config.register_callback(:marshaller) do |marshaller|
           if marshaller != 'json'
@@ -63,17 +58,26 @@ module NewRelic
         end
       end
 
+      def agent_id=(id)
+        # Remote URIs have the agent run ID in them, so we need to
+        # clear out our cached values whenever the run ID changes.
+        #
+        reset_remote_method_uris
+
+        @agent_id = id
+      end
+
       def connect(settings={})
-        if host = get_redirect_host
+        if host = preconnect
           @collector = NewRelic::Control.instance.server_from_host(host)
         end
         response = invoke_remote(:connect, [settings])
-        @agent_id = response['agent_run_id']
+        self.agent_id = response['agent_run_id']
         response
       end
 
-      def get_redirect_host
-        invoke_remote(:get_redirect_host)
+      def preconnect
+        invoke_remote(:preconnect)
       end
 
       def shutdown(time)
@@ -261,8 +265,7 @@ module NewRelic
         conn.verify_mode = OpenSSL::SSL::VERIFY_PEER
         conn.cert_store  = ssl_cert_store
       rescue StandardError, LoadError
-        msg = "Agent is configured to use SSL, but SSL is not available in the environment. "
-        msg << "Either disable SSL in the agent configuration, or install SSL support."
+        msg = "SSL is not available in the environment; please install SSL support."
         raise UnrecoverableAgentException.new(msg)
       end
 
@@ -296,7 +299,7 @@ module NewRelic
           conn = Net::HTTP.new(@collector.name, @collector.port)
         end
 
-        setup_connection_for_ssl(conn) if Agent.config[:ssl]
+        setup_connection_for_ssl(conn)
         setup_connection_timeouts(conn)
 
         ::NewRelic::Agent.logger.debug("Created net/http handle to #{conn.address}:#{conn.port}")
@@ -335,11 +338,28 @@ module NewRelic
         NewRelic::Control.instance
       end
 
-      # The path on the server that we should post our data to
-      def remote_method_uri(method, format)
-        params = {'run_id' => @agent_id, 'marshal_format' => format}
-        uri = "/agent_listener/#{PROTOCOL_VERSION}/#{license_key}/#{method}"
-        uri << '?' + params.map do |k,v|
+      def remote_method_uri(method)
+        @remote_method_uris[method]
+      end
+
+      def reset_remote_method_uris
+        @remote_method_uris = Hash.new do |hash, remote_method|
+          hash[remote_method] = generate_remote_method_uri(remote_method)
+        end
+      end
+
+      def generate_remote_method_uri(method)
+        params = {
+          'protocol_version' => PROTOCOL_VERSION,
+          'license_key'      => license_key,
+          'run_id'           => @agent_id,
+          'method'           => method,
+          'marshal_format'   => 'json', # Other formats are explicitly
+                                        # ruled out; see the initializer
+        }
+
+        uri = "/agent_listener/invoke_raw_method?"
+        uri << params.map do |k,v|
           next unless v
           "#{k}=#{v}"
         end.compact.join('&')
@@ -368,7 +388,7 @@ module NewRelic
         data, encoding = compress_request_if_needed(data)
         size = data.size
 
-        uri = remote_method_uri(method, @marshaller.format)
+        uri = remote_method_uri(method)
         full_uri = "#{@collector}#{uri}"
 
         @audit_logger.log_request(full_uri, payload, @marshaller)

data/lib/new_relic/agent/priority_sampled_buffer.rb

@@ -0,0 +1,68 @@
+# 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/heap'
+
+module NewRelic
+  module Agent
+    class PrioritySampledBuffer < SampledBuffer
+      PRIORITY_KEY = "priority".freeze
+
+      attr_reader :seen_lifetime, :captured_lifetime
+
+      def initialize(capacity)
+        super
+        @captured_lifetime = 0
+        @seen_lifetime     = 0
+      end
+
+      # expects priority and a block, or an event as a hash with a `priority` key.
+      def append(priority: nil, event: nil, &blk)
+        increment_seen
+
+        if @seen == @capacity
+          @items = Heap.new(@items) { |x| priority_for(x) }
+        end
+
+        if full?
+          priority ||= priority_for(event)
+          if priority_for(@items[0]) < priority
+            @items[0] = event || blk.call
+            @items.fix(0)
+          end
+        else
+          @items << (event || blk.call)
+          @captured_lifetime += 1
+        end
+      end
+
+      alias_method :append_event, :append
+
+      def capacity=(new_capacity)
+        @capacity = new_capacity
+        old_items = @items.to_a
+        old_seen  = @seen
+        reset!
+        old_items.each { |i| append(event: i) }
+        @seen     = old_seen
+      end
+
+      def to_a
+        @items.to_a.dup
+      end
+
+      private
+
+      def increment_seen
+        @seen += 1
+        @seen_lifetime += 1
+      end
+
+      def priority_for(event)
+        event[0][PRIORITY_KEY]
+      end
+    end
+  end
+end
+

data/lib/new_relic/agent/supported_versions.rb

@@ -11,7 +11,7 @@ module NewRelic
       {
         :type        => :ruby,
         :name        => "MRI",
-        :supported   => ["2.0.0", "~>2.1.0", "~>2.2.0", "~>2.3.0", "~>2.4.0"],
+        :supported   => ["2.0.0", "~>2.1.0", "~>2.2.0", "~>2.3.0", "~>2.4.0", "~>2.5.0"],
         :deprecated  => ["1.8.6", "1.8.7", "1.9.2", "1.9.3"],
         :url         => "https://www.ruby-lang.org",
         :feed        => "https://www.ruby-lang.org/en/feeds/news.rss",

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

@@ -57,6 +57,7 @@ module NewRelic
         end
 
         def merge_custom_attributes(other)
+          return unless Agent.config[:'custom_attributes.enabled']
           return if other.empty?
           AttributeProcessing.flatten_and_coerce(other) do |k, v|
             add_custom_attribute(k, v)

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

@@ -14,92 +14,79 @@ module NewRelic
           !!distributed_trace_payload
         end
 
-        def create_distributed_trace_payload url = nil
+        SUPPORTABILITY_CREATE_PAYLOAD_SUCCESS   = "Supportability/DistributedTrace/CreatePayload/Success".freeze
+        SUPPORTABILITY_CREATE_PAYLOAD_EXCEPTION = "Supportability/DistributedTrace/CreatePayload/Exception".freeze
+
+        def create_distributed_trace_payload
           return unless Agent.config[:'distributed_tracing.enabled']
-          self.order += 1
-          DistributedTracePayload.for_transaction self, url
+          self.distributed_trace_payload_created = true
+          payload = DistributedTracePayload.for_transaction self
+          NewRelic::Agent.increment_metric SUPPORTABILITY_CREATE_PAYLOAD_SUCCESS
+          payload
+        rescue => e
+          NewRelic::Agent.increment_metric SUPPORTABILITY_CREATE_PAYLOAD_EXCEPTION
+          NewRelic::Agent.logger.warn "Failed to create distributed trace payload", e
+          nil
         end
 
-        LBRACE = "{".freeze
+        SUPPORTABILITY_ACCEPT_PAYLOAD_SUCCESS   = "Supportability/DistributedTrace/AcceptPayload/Success".freeze
+        SUPPORTABILITY_ACCEPT_PAYLOAD_EXCEPTION = "Supportability/DistributedTrace/AcceptPayload/Exception".freeze
 
-        def accept_distributed_trace_payload transport_type, payload
+        def accept_distributed_trace_payload 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
+          return false if check_payload_ignored(payload)
+          return false unless payload = decode_payload(payload)
+          return false unless check_valid_version(payload)
+          return false unless check_trusted_account(payload)
 
-          self.sampled = payload.sampled unless payload.sampled.nil?
+          assign_payload_and_sampling_params(payload)
 
+          NewRelic::Agent.increment_metric SUPPORTABILITY_ACCEPT_PAYLOAD_SUCCESS
           true
         rescue => e
-          NewRelic::Agent.increment_metric "Supportability/DistributedTracing/AcceptFailure/Unknown"
+          NewRelic::Agent.increment_metric SUPPORTABILITY_ACCEPT_PAYLOAD_EXCEPTION
           NewRelic::Agent.logger.warn "Failed to accept distributed trace payload", e
           false
         end
 
-        def distributed_tracing_trip_id
+        def trace_id
           if distributed_trace_payload
-            distributed_trace_payload.trip_id
+            distributed_trace_payload.trace_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
+        def parent_id
+          # The payload comes from our parent transaction, so its ID
+          # is our parent ID.
+          #
+          distributed_trace_payload && distributed_trace_payload.id
         end
 
-        def depth
-          if distributed_trace_payload
-            distributed_trace_payload.depth
-          else
-            1
-          end
+        def grandparent_id
+          # The payload comes from our parent transaction, so its
+          # parent ID is our grandparent ID.
+          #
+          distributed_trace_payload && distributed_trace_payload.parent_id
         end
 
-        def order
-          @order ||= 0
+        def distributed_trace_payload_created?
+          @distributed_trace_payload_created ||=  false
         end
 
-        attr_writer :order
+        attr_writer :distributed_trace_payload_created
 
-        def append_distributed_tracing_info payload
+        def append_distributed_trace_info transaction_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
+            distributed_trace_payload.assign_intrinsics self, transaction_payload
+          elsif distributed_trace_payload_created?
+            DistributedTracePayload.assign_intrinsics_for_first_trace self, transaction_payload
           end
         end
 
-        def assign_distributed_tracing_intrinsics
+        def assign_distributed_trace_intrinsics
           return unless Agent.config[:'distributed_tracing.enabled']
           DistributedTracePayload::INTRINSIC_KEYS.each do |key|
             next unless value = @payload[key]
@@ -115,7 +102,138 @@ module NewRelic
           return unless distributed_trace_payload
           (start_time.to_f * 1000 - distributed_trace_payload.timestamp) / 1000
         end
+
+        private
+
+        SUPPORTABILITY_CREATE_BEFORE_ACCEPT_PAYLOAD   = "Supportability/DistributedTrace/AcceptPayload/Ignored/CreateBeforeAccept".freeze
+        SUPPORTABILITY_MULTIPLE_ACCEPT_PAYLOAD        = "Supportability/DistributedTrace/AcceptPayload/Ignored/Multiple".freeze
+        SUPPORTABILITY_PAYLOAD_ACCEPT_IGNORED_NULL    = "Supportability/DistributedTrace/AcceptPayload/Ignored/Null".freeze
+        SUPPORTABILITY_PAYLOAD_ACCEPT_IGNORED_BROWSER = "Supportability/DistributedTrace/AcceptPayload/Ignored/BrowserAgentInjected".freeze
+
+        def check_payload_ignored(payload)
+          if payload.nil?
+            NewRelic::Agent.increment_metric SUPPORTABILITY_PAYLOAD_ACCEPT_IGNORED_NULL
+            return true
+          elsif distributed_trace_payload
+            NewRelic::Agent.increment_metric SUPPORTABILITY_MULTIPLE_ACCEPT_PAYLOAD
+            return true
+          elsif distributed_trace_payload_created?
+            NewRelic::Agent.increment_metric SUPPORTABILITY_CREATE_BEFORE_ACCEPT_PAYLOAD
+            return true
+          end
+          false
+        end
+
+        SUPPORTABILITY_PAYLOAD_ACCEPT_IGNORED_PARSE_EXCEPTION = "Supportability/DistributedTrace/AcceptPayload/ParseException".freeze
+        LBRACE = "{".freeze
+
+        def decode_payload(payload)
+          if payload.start_with? LBRACE
+            DistributedTracePayload.from_json payload
+          else
+            DistributedTracePayload.from_http_safe payload
+          end
+        rescue => e
+          NewRelic::Agent.increment_metric SUPPORTABILITY_PAYLOAD_ACCEPT_IGNORED_PARSE_EXCEPTION
+          NewRelic::Agent.logger.warn "Error parsing distributed trace payload", e
+          nil
+        end
+
+        SUPPORTABILITY_PAYLOAD_ACCEPT_IGNORED_MAJOR_VERSION = "Supportability/DistributedTrace/AcceptPayload/Ignored/MajorVersion".freeze
+
+        def check_valid_version(payload)
+          if DistributedTracePayload.major_version_matches?(payload)
+            true
+          else
+            NewRelic::Agent.increment_metric SUPPORTABILITY_PAYLOAD_ACCEPT_IGNORED_MAJOR_VERSION
+            false
+          end
+        end
+
+        SUPPORTABILITY_PAYLOAD_ACCEPT_UNTRUSTED_ACCOUNT = "Supportability/DistributedTrace/AcceptPayload/Ignored/UntrustedAccount".freeze
+
+        def check_trusted_account(payload)
+          trusted_account_ids = NewRelic::Agent.config[:trusted_account_ids]
+          trusted = trusted_account_ids.include?(payload.parent_account_id.to_i)
+
+          unless trusted
+            NewRelic::Agent.increment_metric SUPPORTABILITY_PAYLOAD_ACCEPT_UNTRUSTED_ACCOUNT
+            return false
+          end
+
+          true
+        end
+
+        def assign_payload_and_sampling_params(payload)
+          self.distributed_trace_payload = payload
+
+          unless payload.sampled.nil?
+            self.sampled = payload.sampled
+            self.priority = payload.priority if payload.priority
+          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
+          return unless Agent.config[:'distributed_tracing.enabled']
+
+          record_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 record_caller_by_duration_metrics
+          prefix = if distributed_trace?
+            payload = distributed_trace_payload
+            "DurationByCaller/#{payload.parent_type}/#{payload.parent_account_id}/#{payload.parent_app_id}/#{payload.caller_transport_type}"
+          else
+            DURATION_BY_CALLER_UNKOWN_PREFIX
+          end
+
+          metrics.record_unscoped "#{prefix}/#{ALL_SUFFIX}",              duration
+          metrics.record_unscoped "#{prefix}/#{transaction_type_suffix}", duration
+        end
+
+        def record_transport_duration_metrics
+          return unless distributed_trace?
+
+          payload = distributed_trace_payload
+          prefix = "TransportDuration/#{payload.parent_type}/#{payload.parent_account_id}/#{payload.parent_app_id}/#{payload.caller_transport_type}"
+
+          metrics.record_unscoped "#{prefix}/#{ALL_SUFFIX}",              transport_duration
+          metrics.record_unscoped "#{prefix}/#{transaction_type_suffix}", transport_duration
+        end
+
+        ERRORS_BY_CALLER_UNKOWN_PREFIX = "ErrorsByCaller/Unknown/Unknown/Unknown/Unknown".freeze
+
+        def record_errors_by_caller_metrics
+          return unless exceptions.size > 0
+
+          prefix = if distributed_trace?
+            payload = distributed_trace_payload
+            "ErrorsByCaller/#{payload.parent_type}/#{payload.parent_account_id}/#{payload.parent_app_id}/#{payload.caller_transport_type}"
+          else
+            ERRORS_BY_CALLER_UNKOWN_PREFIX
+          end
+
+          metrics.record_unscoped "#{prefix}/#{ALL_SUFFIX}",              1
+          metrics.record_unscoped "#{prefix}/#{transaction_type_suffix}", 1
+        end
       end
     end
   end
 end
+