newrelic_rpm 6.8.0.360 → 8.13.1

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

@@ -1,43 +1,67 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
-require 'new_relic/agent/distributed_trace_payload'
-require 'new_relic/agent/distributed_trace_intrinsics'
-require 'new_relic/agent/distributed_trace_metrics'
+require 'new_relic/agent/distributed_tracing/distributed_trace_payload'
+require 'new_relic/agent/distributed_tracing/distributed_trace_attributes'
+require 'new_relic/agent/distributed_tracing/distributed_trace_metrics'
 
 module NewRelic
   module Agent
     class Transaction
       module DistributedTracing
         attr_accessor :distributed_trace_payload
+        attr_writer :distributed_trace_payload_created
+
+        SUPPORTABILITY_DISTRIBUTED_TRACE = "Supportability/DistributedTrace"
+        CREATE_PREFIX = "#{SUPPORTABILITY_DISTRIBUTED_TRACE}/CreatePayload"
+        ACCEPT_PREFIX = "#{SUPPORTABILITY_DISTRIBUTED_TRACE}/AcceptPayload"
+        IGNORE_PREFIX = "#{ACCEPT_PREFIX}/Ignored"
+
+        CREATE_SUCCESS_METRIC = "#{CREATE_PREFIX}/Success"
+        CREATE_EXCEPTION_METRIC = "#{CREATE_PREFIX}/Exception"
+        ACCEPT_SUCCESS_METRIC = "#{ACCEPT_PREFIX}/Success"
+        ACCEPT_EXCEPTION_METRIC = "#{ACCEPT_PREFIX}/Exception"
+        ACCEPT_PARSE_EXCEPTION_METRIC = "#{ACCEPT_PREFIX}/ParseException"
+
+        IGNORE_ACCEPT_AFTER_CREATE_METRIC = "#{IGNORE_PREFIX}/CreateBeforeAccept"
+        IGNORE_MULTIPLE_ACCEPT_METRIC = "#{IGNORE_PREFIX}/Multiple"
+        IGNORE_ACCEPT_NULL_METRIC = "#{IGNORE_PREFIX}/Null"
+        IGNORE_ACCEPT_MAJOR_VERSION_METRIC = "#{IGNORE_PREFIX}/MajorVersion"
+        IGNORE_ACCEPT_UNTRUSTED_ACCOUNT_METRIC = "#{IGNORE_PREFIX}/UntrustedAccount"
+
+        LBRACE = "{"
+        NULL_PAYLOAD = 'null'
+
+        NEWRELIC_TRACE_KEY = "HTTP_NEWRELIC"
+
+        def accept_distributed_tracing_incoming_request(request)
+          return unless Agent.config[:'distributed_tracing.enabled']
+          return unless payload = request[NEWRELIC_TRACE_KEY]
+
+          accept_distributed_trace_payload(payload)
+        end
 
-        SUPPORTABILITY_CREATE_PAYLOAD_SUCCESS   = "Supportability/DistributedTrace/CreatePayload/Success".freeze
-        SUPPORTABILITY_CREATE_PAYLOAD_EXCEPTION = "Supportability/DistributedTrace/CreatePayload/Exception".freeze
+        def distributed_trace_payload_created?
+          @distributed_trace_payload_created ||= false
+        end
 
         def create_distributed_trace_payload
-          unless Agent.config[:'distributed_tracing.enabled'] && (Agent.config[:'distributed_tracing.format'] == NR_FORMAT)
-            NewRelic::Agent.logger.warn "Not configured to create New Relic distributed trace payload"
-            return
-          end
-          self.distributed_trace_payload_created = true
-          payload = DistributedTracePayload.for_transaction self
-          NewRelic::Agent.increment_metric SUPPORTABILITY_CREATE_PAYLOAD_SUCCESS
+          return unless Agent.config[:'distributed_tracing.enabled']
+
+          @distributed_trace_payload_created = true
+          payload = DistributedTracePayload.for_transaction(transaction)
+          NewRelic::Agent.increment_metric(CREATE_SUCCESS_METRIC)
           payload
         rescue => e
-          NewRelic::Agent.increment_metric SUPPORTABILITY_CREATE_PAYLOAD_EXCEPTION
-          NewRelic::Agent.logger.warn "Failed to create distributed trace payload", e
+          NewRelic::Agent.increment_metric(CREATE_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn("Failed to create distributed trace payload", e)
           nil
         end
 
-        SUPPORTABILITY_ACCEPT_PAYLOAD_SUCCESS   = "Supportability/DistributedTrace/AcceptPayload/Success".freeze
-        SUPPORTABILITY_ACCEPT_PAYLOAD_EXCEPTION = "Supportability/DistributedTrace/AcceptPayload/Exception".freeze
+        def accept_distributed_trace_payload(payload)
+          return unless Agent.config[:'distributed_tracing.enabled']
 
-        def accept_distributed_trace_payload payload
-          unless Agent.config[:'distributed_tracing.enabled'] && (Agent.config[:'distributed_tracing.format'] == NR_FORMAT)
-            NewRelic::Agent.logger.warn "Not configured to accept New Relic distributed trace payload"
-            return
-          end
           return false if check_payload_ignored(payload)
           return false unless check_payload_present(payload)
           return false unless payload = decode_payload(payload)
@@ -47,135 +71,102 @@ module NewRelic
 
           assign_payload_and_sampling_params(payload)
 
-          NewRelic::Agent.increment_metric SUPPORTABILITY_ACCEPT_PAYLOAD_SUCCESS
+          NewRelic::Agent.increment_metric(ACCEPT_SUCCESS_METRIC)
           true
         rescue => e
-          NewRelic::Agent.increment_metric SUPPORTABILITY_ACCEPT_PAYLOAD_EXCEPTION
-          NewRelic::Agent.logger.warn "Failed to accept distributed trace payload", e
+          NewRelic::Agent.increment_metric(ACCEPT_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn("Failed to accept distributed trace payload", e)
           false
         end
 
-        def distributed_trace_payload_created?
-          @distributed_trace_payload_created ||=  false
-        end
-
-        attr_writer :distributed_trace_payload_created
-
-        def append_distributed_trace_info transaction_payload
-          return unless Agent.config[:'distributed_tracing.enabled']
-          DistributedTraceIntrinsics.copy_from_transaction \
-            self,
-            distributed_trace_payload,
-            transaction_payload
-        end
-
-        NR_FORMAT = "newrelic".freeze
-
-        def nr_distributed_tracing_enabled?
-          Agent.config[:'distributed_tracing.enabled'] && (Agent.config[:'distributed_tracing.format'] == NR_FORMAT) && Agent.instance.connected?
-        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 distributed_trace_payload
-            NewRelic::Agent.increment_metric SUPPORTABILITY_MULTIPLE_ACCEPT_PAYLOAD
+            NewRelic::Agent.increment_metric(IGNORE_MULTIPLE_ACCEPT_METRIC)
             return true
           elsif distributed_trace_payload_created?
-            NewRelic::Agent.increment_metric SUPPORTABILITY_CREATE_BEFORE_ACCEPT_PAYLOAD
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_AFTER_CREATE_METRIC)
             return true
           end
           false
         end
 
-        NULL_PAYLOAD = 'null'.freeze
-
         def check_payload_present(payload)
           # We might be passed a Ruby `nil` object _or_ the JSON "null"
           if payload.nil? || payload == NULL_PAYLOAD
-            NewRelic::Agent.increment_metric SUPPORTABILITY_PAYLOAD_ACCEPT_IGNORED_NULL
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_NULL_METRIC)
             return nil
           end
 
           payload
         end
 
-        SUPPORTABILITY_PAYLOAD_ACCEPT_IGNORED_PARSE_EXCEPTION = "Supportability/DistributedTrace/AcceptPayload/ParseException".freeze
-        LBRACE = "{".freeze
-
         def decode_payload(payload)
-          decoded = if payload.start_with? LBRACE
-            DistributedTracePayload.from_json payload
+          decoded = if payload.start_with?(LBRACE)
+            DistributedTracePayload.from_json(payload)
           else
-            DistributedTracePayload.from_http_safe payload
+            DistributedTracePayload.from_http_safe(payload)
           end
 
           return nil unless check_payload_present(decoded)
 
           decoded
         rescue => e
-          NewRelic::Agent.increment_metric SUPPORTABILITY_PAYLOAD_ACCEPT_IGNORED_PARSE_EXCEPTION
-          NewRelic::Agent.logger.warn "Error parsing distributed trace payload", e
+          NewRelic::Agent.increment_metric(ACCEPT_PARSE_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn("Error parsing distributed trace payload", e)
           nil
         end
 
         def check_required_fields_present(payload)
           if \
             !payload.version.nil? &&
-            !payload.parent_account_id.nil? &&
-            !payload.parent_app_id.nil? &&
-            !payload.parent_type.nil? &&
-            (!payload.transaction_id.nil? || !payload.id.nil?) &&
-            !payload.trace_id.nil? &&
-            !payload.timestamp.nil?
+                !payload.parent_account_id.nil? &&
+                !payload.parent_app_id.nil? &&
+                !payload.parent_type.nil? &&
+                (!payload.transaction_id.nil? || !payload.id.nil?) &&
+                !payload.trace_id.nil? &&
+                !payload.timestamp.nil?
 
             true
           else
-            NewRelic::Agent.increment_metric SUPPORTABILITY_PAYLOAD_ACCEPT_IGNORED_PARSE_EXCEPTION
+            NewRelic::Agent.increment_metric(ACCEPT_PARSE_EXCEPTION_METRIC)
             false
           end
         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
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_MAJOR_VERSION_METRIC)
             false
           end
         end
 
-        SUPPORTABILITY_PAYLOAD_ACCEPT_UNTRUSTED_ACCOUNT = "Supportability/DistributedTrace/AcceptPayload/Ignored/UntrustedAccount".freeze
-
         def check_trusted_account(payload)
           compare_key = payload.trusted_account_key || payload.parent_account_id
           unless compare_key == NewRelic::Agent.config[:trusted_account_key]
-            NewRelic::Agent.increment_metric SUPPORTABILITY_PAYLOAD_ACCEPT_UNTRUSTED_ACCOUNT
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_UNTRUSTED_ACCOUNT_METRIC)
             return false
           end
           true
         end
 
         def assign_payload_and_sampling_params(payload)
-          self.distributed_trace_payload = payload
-          @trace_id = payload.trace_id
-          @parent_transaction_id = payload.transaction_id
-          @parent_span_id = payload.id
+          @distributed_trace_payload = payload
+          return if transaction.distributed_tracer.trace_context_header_data
+
+          transaction.trace_id = payload.trace_id
+          transaction.distributed_tracer.parent_transaction_id = payload.transaction_id
+          transaction.parent_span_id = payload.id
 
           unless payload.sampled.nil?
-            self.sampled = payload.sampled
-            self.priority = payload.priority if payload.priority
+            transaction.sampled = payload.sampled
+            transaction.priority = payload.priority if payload.priority
           end
         end
       end
     end
   end
 end
-

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

@@ -1,6 +1,6 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/transaction/segment'
 require 'new_relic/agent/http_clients/uri_util'
@@ -8,23 +8,30 @@ 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'
+        APP_DATA_KEY = 'NewRelicAppData'
 
-        NR_SYNTHETICS_HEADER = 'X-NewRelic-Synthetics'.freeze
+        EXTERNAL_ALL = "External/all"
+        EXTERNAL_ALL_WEB = "External/allWeb"
+        EXTERNAL_ALL_OTHER = "External/allOther"
+        MISSING_STATUS_CODE = "MissingHTTPStatusCode"
 
+        attr_reader :library, :uri, :procedure, :http_status_code
+        attr_writer :record_agent_attributes
 
-        def initialize library, uri, procedure, start_time = nil # :nodoc:
+        def initialize(library, uri, procedure, start_time = nil) # :nodoc:
           @library = library
-          @uri = HTTPClients::URIUtil.parse_and_normalize_url(uri)
+          @uri = HTTPClients::URIUtil.obfuscated_uri(uri)
           @procedure = procedure
           @host_header = nil
           @app_data = nil
+          @http_status_code = nil
+          @record_agent_attributes = false
           super(nil, nil, start_time)
         end
 
@@ -36,6 +43,14 @@ module NewRelic
           @host_header || uri.host
         end
 
+        # By default external request segments only have errors and the http
+        # url recorded as agent attributes. To have all the agent attributes
+        # recorded, use the attr_writer like so `segment.record_agent_attributes = true`
+        # See: SpanEventPrimitive#for_external_request_segment
+        def record_agent_attributes?
+          @record_agent_attributes
+        end
+
         # 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
@@ -45,16 +60,16 @@ module NewRelic
         # object (must belong to a subclass of NewRelic::Agent::HTTPClients::AbstractRequest)
         #
         # @api public
-        def add_request_headers request
-          process_host_header request
+        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
+          insert_synthetics_header(request, synthetics_header) if synthetics_header
 
           return unless record_metrics?
 
-          insert_context_propagation_headers request
+          transaction.distributed_tracer.insert_headers(request)
         rescue => e
-          NewRelic::Agent.logger.error "Error in add_request_headers", e
+          NewRelic::Agent.logger.error("Error in add_request_headers", e)
         end
 
         # This method extracts app data from an external response if present. If
@@ -64,11 +79,12 @@ module NewRelic
         # @param [Hash] response a hash of response headers
         #
         # @api public
-        def read_response_headers response
+        def read_response_headers(response)
           return unless record_metrics? && CrossAppTracing.cross_app_enabled?
           return unless CrossAppTracing.response_has_crossapp_header?(response)
+
           unless data = CrossAppTracing.extract_appdata(response)
-            NewRelic::Agent.logger.debug "Couldn't extract_appdata from external segment response"
+            NewRelic::Agent.logger.debug("Couldn't extract_appdata from external segment response")
             return
           end
 
@@ -76,10 +92,10 @@ module NewRelic
             @app_data = data
             update_segment_name
           else
-            NewRelic::Agent.logger.debug "External segment response has invalid cross_app_id"
+            NewRelic::Agent.logger.debug("External segment response has invalid cross_app_id")
           end
         rescue => e
-          NewRelic::Agent.logger.error "Error in read_response_headers", e
+          NewRelic::Agent.logger.error("Error in read_response_headers", e)
         end
 
         def cross_app_request? # :nodoc:
@@ -98,10 +114,6 @@ module NewRelic
           @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.
@@ -123,14 +135,14 @@ module NewRelic
               NewRelicTransaction: [
                 transaction.guid,
                 false,
-                transaction.cat_trip_id,
-                transaction.cat_path_hash
+                transaction.distributed_tracer.cat_trip_id,
+                transaction.distributed_tracer.cat_path_hash
               ]
             }
 
-            # flag cross app in the state so transaction knows to add bits to paylaod
+            # flag cross app in the state so transaction knows to add bits to payload
             #
-            transaction.is_cross_app_caller = true
+            transaction.distributed_tracer.is_cross_app_caller = true
 
             # add Synthetics header if we have it
             #
@@ -138,11 +150,11 @@ module NewRelic
 
             # obfuscate the generated request metadata JSON
             #
-            obfuscator.obfuscate ::JSON.dump(rmd)
+            obfuscator.obfuscate(::JSON.dump(rmd))
 
           end
         rescue => e
-          NewRelic::Agent.logger.error "error during get_request_metadata", 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
@@ -153,24 +165,24 @@ module NewRelic
         #
         # @api public
         #
-        def process_response_metadata response_metadata
+        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]
+            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"
+              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
+          NewRelic::Agent.logger.error("error during process_response_metadata", e)
         end
 
         def record_metrics
@@ -178,14 +190,29 @@ module NewRelic
           super
         end
 
+        def process_response_headers(response) # :nodoc:
+          set_http_status_code(response)
+          read_response_headers(response)
+        end
+
         private
 
-        def insert_synthetics_header request, header
+        # Only sets the http_status_code if response.status_code is non-empty value
+        def set_http_status_code(response)
+          if response.respond_to?(:status_code)
+            @http_status_code = response.status_code if response.has_status_code?
+          else
+            NewRelic::Agent.logger.warn("Cannot extract HTTP Status Code from response #{response.class.to_s}")
+            NewRelic::Agent.record_metric("#{name}/#{MISSING_STATUS_CODE}", 1)
+          end
+        end
+
+        def insert_synthetics_header(request, header)
           request[NR_SYNTHETICS_HEADER] = header
         end
 
         def segment_complete
-          params[:uri] = HTTPClients::URIUtil.filter_uri(uri)
+          params[:uri] = uri.to_s
           if cross_app_request?
             params[:transaction_guid] = transaction_guid
           end
@@ -193,61 +220,22 @@ module NewRelic
           super
         end
 
-        def process_host_header request
+        def process_host_header(request)
           if @host_header = request.host_from_header
             update_segment_name
           end
         end
 
-        def insert_context_propagation_headers request
-          return unless transaction
-
-          if transaction.trace_context_enabled?
-            insert_trace_context_headers request
-          elsif transaction.nr_distributed_tracing_enabled?
-            insert_distributed_trace_header request
-          elsif CrossAppTracing.cross_app_enabled?
-            insert_cross_app_header request
-          end
-        end
-
-
-        def insert_cross_app_header request
-          transaction.is_cross_app_caller = true
-          txn_guid = transaction.guid
-          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
-        end
-
-        NEWRELIC_TRACE_HEADER = "newrelic".freeze
-
-        def insert_distributed_trace_header request
-          payload = transaction.create_distributed_trace_payload
-          request[NEWRELIC_TRACE_HEADER] = payload.http_safe if payload
-        end
-
-        def insert_trace_context_headers request
-          transaction.insert_trace_context carrier: request
-        end
-
-        EXTERNAL_ALL = "External/all".freeze
-
         def add_unscoped_metrics
-          @unscoped_metrics = [ EXTERNAL_ALL,
+          @unscoped_metrics = [EXTERNAL_ALL,
             "External/#{host}/all",
-            suffixed_rollup_metric
-          ]
+            suffixed_rollup_metric]
 
           if cross_app_request?
             @unscoped_metrics << "ExternalApp/#{host}/#{cross_process_id}/all"
           end
         end
 
-        EXTERNAL_ALL_WEB = "External/allWeb".freeze
-        EXTERNAL_ALL_OTHER = "External/allOther".freeze
-
         def suffixed_rollup_metric
           if Transaction.recording_web_transaction?
             EXTERNAL_ALL_WEB
@@ -269,9 +257,11 @@ module NewRelic
         end
 
         def record_span_event
-          aggregator = ::NewRelic::Agent.agent.span_event_aggregator
-          priority   = transaction.priority
+          # don't record a span event if the transaction is ignored
+          return if transaction.ignore?
 
+          aggregator = ::NewRelic::Agent.agent.span_event_aggregator
+          priority = transaction.priority
           aggregator.record(priority: priority) do
             SpanEventPrimitive.for_external_request_segment(self)
           end

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

@@ -1,24 +1,24 @@
-# 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/transaction/segment'
-require 'new_relic/agent/cross_app_tracing'
+require 'new_relic/agent/distributed_tracing/cross_app_tracing'
 
 module NewRelic
   module Agent
     class Transaction
       class MessageBrokerSegment < Segment
-        CONSUME  = 'Consume'.freeze
+        CONSUME = 'Consume'.freeze
         EXCHANGE = 'Exchange'.freeze
-        NAMED    = 'Named/'.freeze
-        PRODUCE  = 'Produce'.freeze
-        QUEUE    = 'Queue'.freeze
-        PURGE    = 'Purge'.freeze
-        SLASH    = '/'.freeze
-        TEMP     = 'Temp'.freeze
-        TOPIC    = 'Topic'.freeze
-        UNKNOWN  = 'Unknown'.freeze
+        NAMED = 'Named/'.freeze
+        PRODUCE = 'Produce'.freeze
+        QUEUE = 'Queue'.freeze
+        PURGE = 'Purge'.freeze
+        SLASH = '/'.freeze
+        TEMP = 'Temp'.freeze
+        TOPIC = 'Topic'.freeze
+        UNKNOWN = 'Unknown'.freeze
 
         DESTINATION_TYPES = [
           :exchange,
@@ -36,35 +36,29 @@ module NewRelic
         }
 
         TYPES = {
-          exchange:        EXCHANGE,
+          exchange: EXCHANGE,
           temporary_queue: QUEUE,
-          queue:           QUEUE,
+          queue: QUEUE,
           temporary_topic: TOPIC,
-          topic:           TOPIC,
-          unknown:         EXCHANGE
+          topic: TOPIC,
+          unknown: EXCHANGE
         }
 
         METRIC_PREFIX = 'MessageBroker/'.freeze
 
         attr_reader :action,
-                    :destination_name,
-                    :destination_type,
-                    :library,
-                    :headers
-
-        def initialize action: nil,
-                       library: nil,
-                       destination_type: nil,
-                       destination_name: nil,
-                       headers: nil,
-                       parameters: nil,
-                       start_time: nil
-
-          # ruby 2.0.0 does not support required kwargs
-          raise ArgumentError, 'missing required argument: action' if action.nil?
-          raise ArgumentError, 'missing required argument: library' if library.nil?
-          raise ArgumentError, 'missing required argument: destination_type' if destination_type.nil?
-          raise ArgumentError, 'missing required argument: destination_name' if destination_name.nil?
+          :destination_name,
+          :destination_type,
+          :library,
+          :headers
+
+        def initialize(action:,
+          library:,
+          destination_type:,
+          destination_name:,
+          headers: nil,
+          parameters: nil,
+          start_time: nil)
 
           @action = action
           @library = library
@@ -72,11 +66,12 @@ module NewRelic
           @destination_name = destination_name
           @headers = headers
           super(nil, nil, start_time)
-          params.merge! parameters if parameters
+          params.merge!(parameters) if parameters
         end
 
         def name
           return @name if @name
+
           @name = METRIC_PREFIX + library
           @name << SLASH << TYPES[destination_type] << SLASH << ACTIONS[action] << SLASH
 
@@ -89,21 +84,14 @@ module NewRelic
           @name
         end
 
-        NEWRELIC_TRACE_KEY = "newrelic".freeze
-
-        def insert_distributed_trace_header
-          return unless Agent.config[:'distributed_tracing.enabled']
-          payload = transaction.create_distributed_trace_payload
-          headers[NEWRELIC_TRACE_KEY] = payload.http_safe if payload
-        end
-
         def transaction_assigned
           if headers && transaction && action == :produce && record_metrics?
-            insert_distributed_trace_header
-            transaction.add_message_cat_headers headers if CrossAppTracing.cross_app_enabled?
+            transaction.distributed_tracer.insert_distributed_trace_header(headers)
+            transaction.distributed_tracer.insert_cat_headers(headers)
+            transaction.distributed_tracer.log_request_headers(headers)
           end
         rescue => e
-          NewRelic::Agent.logger.error "Error during message header processing", e
+          NewRelic::Agent.logger.error("Error during message header processing", e)
         end
       end
     end