newrelic_rpm 3.12.0.288 → 9.10.2

data/lib/new_relic/agent/transaction.rb

@@ -1,12 +1,17 @@
-# 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_timings'
 require 'new_relic/agent/instrumentation/queue_time'
 require 'new_relic/agent/transaction_metrics'
 require 'new_relic/agent/method_tracer_helpers'
-require 'new_relic/agent/transaction/attributes'
+require 'new_relic/agent/attributes'
+require 'new_relic/agent/transaction/request_attributes'
+require 'new_relic/agent/transaction/tracing'
+require 'new_relic/agent/transaction/distributed_tracer'
+require 'new_relic/agent/transaction_time_aggregator'
+require 'new_relic/agent/deprecator'
+require 'new_relic/agent/guid_generator'
 
 module NewRelic
   module Agent
@@ -15,28 +20,39 @@ module NewRelic
     #
     # @api public
     class Transaction
+      include Tracing
 
       # for nested transactions
-      SUBTRANSACTION_PREFIX        = 'Nested/'.freeze
-      CONTROLLER_PREFIX            = 'Controller/'.freeze
-      MIDDLEWARE_PREFIX            = 'Middleware/Rack/'.freeze
-      TASK_PREFIX                  = 'OtherTransaction/Background/'.freeze
-      RACK_PREFIX                  = 'Controller/Rack/'.freeze
-      SINATRA_PREFIX               = 'Controller/Sinatra/'.freeze
-      GRAPE_PREFIX                 = 'Controller/Grape/'.freeze
-      OTHER_TRANSACTION_PREFIX     = 'OtherTransaction/'.freeze
-
-      CONTROLLER_MIDDLEWARE_PREFIX = 'Controller/Middleware/Rack'.freeze
-
-      NESTED_TRACE_STOP_OPTIONS    = { :metric => true }.freeze
-      WEB_TRANSACTION_CATEGORIES   = [:controller, :uri, :rack, :sinatra, :grape, :middleware].freeze
-      TRANSACTION_NAMING_SOURCES   = [:child, :api].freeze
-
-      MIDDLEWARE_SUMMARY_METRICS   = ['Middleware/all'.freeze].freeze
-      EMPTY_SUMMARY_METRICS        = [].freeze
-
-      TRACE_OPTIONS_SCOPED         = { :metric => true, :scoped_metric => true }.freeze
-      TRACE_OPTIONS_UNSCOPED       = { :metric => true, :scoped_metric => false }.freeze
+      NESTED_TRANSACTION_PREFIX = 'Nested/'
+      CONTROLLER_PREFIX = 'Controller/'
+      MIDDLEWARE_PREFIX = 'Middleware/Rack/'
+      OTHER_TRANSACTION_PREFIX = 'OtherTransaction/'
+      TASK_PREFIX = "#{OTHER_TRANSACTION_PREFIX}Background/"
+      RAKE_PREFIX = "#{OTHER_TRANSACTION_PREFIX}Rake/"
+      MESSAGE_PREFIX = "#{OTHER_TRANSACTION_PREFIX}Message/"
+      RACK_PREFIX = "#{CONTROLLER_PREFIX}Rack/"
+      RODA_PREFIX = "#{CONTROLLER_PREFIX}Roda/"
+      SINATRA_PREFIX = "#{CONTROLLER_PREFIX}Sinatra/"
+      GRAPE_PREFIX = "#{CONTROLLER_PREFIX}Grape/"
+      ACTION_CABLE_PREFIX = "#{CONTROLLER_PREFIX}ActionCable/"
+
+      WEB_TRANSACTION_CATEGORIES = %i[action_cable controller grape middleware rack roda sinatra web uri].freeze
+
+      MIDDLEWARE_SUMMARY_METRICS = ['Middleware/all'].freeze
+      WEB_SUMMARY_METRIC = 'HttpDispatcher'
+      OTHER_SUMMARY_METRIC = "#{OTHER_TRANSACTION_PREFIX}all"
+      QUEUE_TIME_METRIC = 'WebFrontend/QueueTime'
+
+      APDEX_S = 'S'
+      APDEX_T = 'T'
+      APDEX_F = 'F'
+      APDEX_ALL_METRIC = 'ApdexAll'
+      APDEX_METRIC = 'Apdex'
+      APDEX_OTHER_METRIC = 'ApdexOther'
+      APDEX_TXN_METRIC_PREFIX = 'Apdex/'
+      APDEX_OTHER_TXN_METRIC_PREFIX = 'ApdexOther/Transaction/'
+
+      JRUBY_CPU_TIME_ERROR = 'Error calculating JRuby CPU Time'
 
       # A Time instance for the start time, never nil
       attr_accessor :start_time
@@ -47,151 +63,86 @@ module NewRelic
       attr_accessor :apdex_start
 
       attr_accessor :exceptions,
-                    :filtered_params,
-                    :jruby_cpu_start,
-                    :process_cpu_start,
-                    :http_response_code
+        :filtered_params,
+        :jruby_cpu_start,
+        :process_cpu_start,
+        :http_response_code,
+        :response_content_length,
+        :response_content_type,
+        :parent_span_id
 
       attr_reader :guid,
-                  :metrics,
-                  :gc_start_snapshot,
-                  :category,
-                  :frame_stack,
-                  :cat_path_hashes,
-                  :attributes,
-                  :request_path,
-                  :referer
+        :metrics,
+        :logs,
+        :gc_start_snapshot,
+        :category,
+        :attributes,
+        :payload,
+        :nesting_max_depth,
+        :segments,
+        :end_time,
+        :duration
+
+      attr_writer :sampled,
+        :priority
 
       # Populated with the trace sample once this transaction is completed.
       attr_reader :transaction_trace
 
       # Fields for tracking synthetics requests
-      attr_accessor :raw_synthetics_header, :synthetics_payload
+      attr_accessor :raw_synthetics_header, :synthetics_payload, :synthetics_info_payload, :raw_synthetics_info_header
 
       # Return the currently active transaction, or nil.
       def self.tl_current
-        TransactionState.tl_get.current_transaction
+        Tracer.current_transaction
       end
 
-      def self.set_default_transaction_name(name, category = nil, node_name = nil) #THREAD_LOCAL_ACCESS
-        txn  = tl_current
-        name = txn.make_transaction_name(name, category)
-        txn.name_last_frame(node_name || name)
+      def self.set_default_transaction_name(partial_name, category = nil) # THREAD_LOCAL_ACCESS
+        txn = tl_current
+        name = name_from_partial(partial_name, category || txn.category)
         txn.set_default_transaction_name(name, category)
       end
 
-      def self.set_overriding_transaction_name(name, category = nil) #THREAD_LOCAL_ACCESS
+      def self.set_overriding_transaction_name(partial_name, category = nil) # THREAD_LOCAL_ACCESS
         txn = tl_current
         return unless txn
 
-        name = txn.make_transaction_name(name, category)
-
-        txn.name_last_frame(name)
+        name = name_from_partial(partial_name, category || txn.category)
         txn.set_overriding_transaction_name(name, category)
       end
 
-      def self.wrap(state, name, category, options = {})
-        Transaction.start(state, category, options.merge(:transaction_name => name))
-
-        begin
-          # We shouldn't raise from Transaction.start, but only wrap the yield
-          # to be absolutely sure we don't report agent problems as app errors
-          yield
-        rescue => e
-          Transaction.notice_error(e)
-          raise e
-        ensure
-          Transaction.stop(state)
-        end
-      end
-
-      def self.start(state, category, options)
-        category ||= :controller
-        txn = state.current_transaction
-
-        if txn
-          txn.create_nested_frame(state, category, options)
-        else
-          txn = start_new_transaction(state, category, options)
-        end
-
-        txn
-      rescue => e
-        NewRelic::Agent.logger.error("Exception during Transaction.start", e)
-        nil
+      def self.name_from_partial(partial_name, category)
+        namer = Instrumentation::ControllerInstrumentation::TransactionNamer
+        "#{namer.prefix_for_category(self, category)}#{partial_name}"
       end
 
       def self.start_new_transaction(state, category, options)
         txn = Transaction.new(category, options)
         state.reset(txn)
-        txn.start(state)
+        txn.start(options)
         txn
       end
 
-      FAILED_TO_STOP_MESSAGE = "Failed during Transaction.stop because there is no current transaction"
-
-      def self.stop(state, end_time=Time.now)
-        txn = state.current_transaction
-
-        if txn.nil?
-          NewRelic::Agent.logger.error(FAILED_TO_STOP_MESSAGE)
-          return
-        end
-
-        nested_frame = txn.frame_stack.pop
-
-        if txn.frame_stack.empty?
-          txn.stop(state, end_time, nested_frame)
-          state.reset
-        else
-          nested_name = nested_transaction_name(nested_frame.name)
-
-          if nested_name.start_with?(MIDDLEWARE_PREFIX)
-            summary_metrics = MIDDLEWARE_SUMMARY_METRICS
-          else
-            summary_metrics = EMPTY_SUMMARY_METRICS
-          end
-
-          NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_footer(
-            state,
-            nested_frame.start_time.to_f,
-            nested_name,
-            summary_metrics,
-            nested_frame,
-            NESTED_TRACE_STOP_OPTIONS,
-            end_time.to_f)
-        end
-
-        :transaction_stopped
-      rescue => e
-        state.reset
-        NewRelic::Agent.logger.error("Exception during Transaction.stop", e)
-        nil
-      end
-
       def self.nested_transaction_name(name)
-        if name.start_with?(CONTROLLER_PREFIX) || name.start_with?(OTHER_TRANSACTION_PREFIX)
-          "#{SUBTRANSACTION_PREFIX}#{name}"
+        if name.start_with?(CONTROLLER_PREFIX, OTHER_TRANSACTION_PREFIX)
+          "#{NESTED_TRANSACTION_PREFIX}#{name}"
         else
           name
         end
       end
 
-      # Indicate that you don't want to keep the currently saved transaction
-      # information
-      def self.abort_transaction! #THREAD_LOCAL_ACCESS
-        state = NewRelic::Agent::TransactionState.tl_get
-        txn = state.current_transaction
-        txn.abort_transaction!(state) if txn
+      # discards the currently saved transaction information
+      def self.abort_transaction!
+        if txn = Tracer.current_transaction
+          txn.abort_transaction!
+        end
       end
 
       # See NewRelic::Agent.notice_error for options and commentary
-      def self.notice_error(e, options={}) #THREAD_LOCAL_ACCESS
-        state = NewRelic::Agent::TransactionState.tl_get
-        txn = state.current_transaction
-        if txn
+      def self.notice_error(e, options = {})
+        if txn = Tracer.current_transaction
           txn.notice_error(e, options)
-        else
+        elsif NewRelic::Agent.instance
           NewRelic::Agent.instance.error_collector.notice_error(e, options)
         end
       end
@@ -201,9 +152,11 @@ module NewRelic
       #
       # @api public
       #
-      def self.recording_web_transaction? #THREAD_LOCAL_ACCESS
+      def self.recording_web_transaction? # THREAD_LOCAL_ACCESS
+        NewRelic::Agent.record_api_supportability_metric(:recording_web_transaction?)
+
         txn = tl_current
-        txn && txn.recording_web_transaction?
+        txn&.recording_web_transaction?
       end
 
       def self.apdex_bucket(duration, failed, apdex_t)
@@ -212,7 +165,7 @@ module NewRelic
           :apdex_f
         when duration <= apdex_t
           :apdex_s
-        when duration <= 4 * apdex_t
+        when duration <= apdex_t * 4
           :apdex_t
         else
           :apdex_f
@@ -223,24 +176,27 @@ module NewRelic
         if txn = tl_current
           txn.add_agent_attribute(key, value, default_destinations)
         else
-          NewRelic::Agent.logger.debug "Attempted to add agent attribute: #{key} without transaction"
+          NewRelic::Agent.logger.debug("Attempted to add agent attribute: #{key} without transaction")
         end
       end
 
       def add_agent_attribute(key, value, default_destinations)
         @attributes.add_agent_attribute(key, value, default_destinations)
+        # the following line needs else branch coverage
+        current_segment.add_agent_attribute(key, value) if current_segment # rubocop:disable Style/SafeNavigation
       end
 
       def self.merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
         if txn = tl_current
           txn.merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
         else
-          NewRelic::Agent.logger.debug "Attempted to merge untrusted attributes without transaction"
+          NewRelic::Agent.logger.debug('Attempted to merge untrusted attributes without transaction')
         end
       end
 
       def merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
         @attributes.merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
+        current_segment&.merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
       end
 
       @@java_classes_loaded = false
@@ -248,23 +204,28 @@ module NewRelic
       if defined? JRuby
         begin
           require 'java'
-          java_import 'java.lang.management.ManagementFactory'
-          java_import 'com.sun.management.OperatingSystemMXBean'
+          java_import('java.lang.management.ManagementFactory')
+          java_import('com.sun.management.OperatingSystemMXBean')
           @@java_classes_loaded = true
         rescue
         end
       end
 
-      def initialize(category, options)
-        @frame_stack = []
-        @has_children = false
+      def initialize(category, options) # rubocop:disable Metrics/AbcSize
+        @nesting_max_depth = 0
+        @current_segment_by_thread = {}
+        @current_segment_lock = Mutex.new
+        @segments = []
 
         self.default_name = options[:transaction_name]
-        @overridden_name    = nil
-        @frozen_name      = nil
+        @overridden_name = nil
+        @frozen_name = nil
 
         @category = category
-        @start_time = Time.now
+        @start_time = Process.clock_gettime(Process::CLOCK_REALTIME)
+        @end_time = nil
+        @duration = nil
+
         @apdex_start = options[:apdex_start_time] || @start_time
         @jruby_cpu_start = jruby_cpu_time
         @process_cpu_start = process_cpu
@@ -273,24 +234,95 @@ module NewRelic
 
         @exceptions = {}
         @metrics = TransactionMetrics.new
-        @guid = generate_guid
-        @cat_path_hashes = nil
+        @logs = PrioritySampledBuffer.new(NewRelic::Agent.instance.log_event_aggregator.capacity)
+        @guid = NewRelic::Agent::GuidGenerator.generate_guid
 
         @ignore_this_transaction = false
-        @ignore_apdex = false
-        @ignore_enduser = false
+        @ignore_apdex = options.fetch(:ignore_apdex, false)
+        @ignore_enduser = options.fetch(:ignore_enduser, false)
+        @ignore_trace = false
+
+        @sampled = nil
+        @priority = nil
+
+        @starting_thread_id = Thread.current.object_id
+        @starting_segment_key = current_segment_key
 
         @attributes = Attributes.new(NewRelic::Agent.instance.attribute_filter)
 
         merge_request_parameters(@filtered_params)
 
         if request = options[:request]
-          @request_path = path_from_request(request)
-          @referer = referer_from_request(request)
+          @request_attributes = RequestAttributes.new(request)
+        else
+          @request_attributes = nil
         end
       end
 
-      # This transaction-local hash may be used as temprory storage by
+      def state
+        NewRelic::Agent::Tracer.state
+      end
+
+      def current_segment_key
+        Tracer.current_segment_key
+      end
+
+      def parent_segment_key
+        (::Fiber.current.nr_parent_key if ::Fiber.current.respond_to?(:nr_parent_key)) || (::Thread.current.nr_parent_key if ::Thread.current.respond_to?(:nr_parent_key))
+      end
+
+      def current_segment
+        current_segment_by_thread[current_segment_key] ||
+          current_segment_by_thread[parent_segment_key] ||
+          current_segment_by_thread[@starting_segment_key]
+      end
+
+      def set_current_segment(new_segment)
+        @current_segment_lock.synchronize { current_segment_by_thread[current_segment_key] = new_segment }
+      end
+
+      def remove_current_segment_by_thread_id(id)
+        @current_segment_lock.synchronize { current_segment_by_thread.delete(id) }
+      end
+
+      def distributed_tracer
+        @distributed_tracer ||= DistributedTracer.new(self)
+      end
+
+      def sampled?
+        return false unless Agent.config[:'distributed_tracing.enabled']
+
+        if @sampled.nil?
+          @sampled = NewRelic::Agent.instance.adaptive_sampler.sampled?
+        end
+        @sampled
+      end
+
+      def trace_id
+        @trace_id ||= NewRelic::Agent::GuidGenerator.generate_guid(32)
+      end
+
+      def trace_id=(value)
+        @trace_id = value
+      end
+
+      def priority
+        @priority ||= (sampled? ? rand + 1.0 : rand).round(NewRelic::PRIORITY_PRECISION)
+      end
+
+      def referer
+        @request_attributes&.referer
+      end
+
+      def request_path
+        @request_attributes&.request_path
+      end
+
+      def request_port
+        @request_attributes&.port
+      end
+
+      # This transaction-local hash may be used as temporary storage by
       # instrumentation that needs to pass data from one instrumentation point
       # to another.
       #
@@ -308,10 +340,6 @@ module NewRelic
         @instrumentation_state ||= {}
       end
 
-      def noticed_error_ids
-        @noticed_error_ids ||= []
-      end
-
       def overridden_name=(name)
         @overridden_name = Helper.correctly_encoded(name)
       end
@@ -320,30 +348,13 @@ module NewRelic
         @default_name = Helper.correctly_encoded(name)
       end
 
-      def create_nested_frame(state, category, options)
-        @has_children = true
-        if options[:filtered_params] && !options[:filtered_params].empty?
-          @filtered_params = options[:filtered_params]
-          merge_request_parameters(options[:filtered_params])
-        end
-
-        frame_stack.push NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_header(state, Time.now.to_f)
-        name_last_frame(options[:transaction_name])
-
-        set_default_transaction_name(options[:transaction_name], category)
-      end
-
       def merge_request_parameters(params)
         merge_untrusted_agent_attributes(params, :'request.parameters', AttributeFilter::DST_NONE)
       end
 
-      def make_transaction_name(name, category=nil)
-        namer = Instrumentation::ControllerInstrumentation::TransactionNamer
-        "#{namer.prefix_for_category(self, category)}#{name}"
-      end
-
       def set_default_transaction_name(name, category)
         return log_frozen_name(name) if name_frozen?
+
         if influences_transaction_name?(category)
           self.default_name = name
           @category = category if category
@@ -352,14 +363,9 @@ module NewRelic
 
       def set_overriding_transaction_name(name, category)
         return log_frozen_name(name) if name_frozen?
-        if influences_transaction_name?(category)
-          self.overridden_name = name
-          @category = category if category
-        end
-      end
 
-      def name_last_frame(name)
-        frame_stack.last.name = name
+        self.overridden_name = name
+        @category = category if category
       end
 
       def log_frozen_name(name)
@@ -368,17 +374,19 @@ module NewRelic
       end
 
       def influences_transaction_name?(category)
-        !category || frame_stack.size == 1 || similar_category?(category)
+        !category || nesting_max_depth == 1 || similar_category?(category)
       end
 
       def best_name
-        @frozen_name  || @overridden_name ||
-          @default_name || NewRelic::Agent::UNKNOWN_METRIC
+        @frozen_name ||
+          @overridden_name ||
+          @default_name ||
+          NewRelic::Agent::UNKNOWN_METRIC
       end
 
-      def name_set?
-        (@overridden_name || @default_name) ? true : false
-      end
+      # For common interface with Trace
+      alias_method :transaction_name, :best_name
+      # End common interface
 
       def promoted_transaction_name(name)
         if name.start_with?(MIDDLEWARE_PREFIX)
@@ -411,27 +419,85 @@ module NewRelic
         @frozen_name ? true : false
       end
 
-      def start(state)
+      def start(options = {})
         return if !state.is_execution_traced?
 
-        transaction_sampler.on_start_transaction(state, start_time)
-        sql_sampler.on_start_transaction(state, start_time, request_path)
+        sql_sampler.on_start_transaction(state, request_path)
         NewRelic::Agent.instance.events.notify(:start_transaction)
-        NewRelic::Agent::BusyCalculator.dispatcher_start(start_time)
+        NewRelic::Agent::TransactionTimeAggregator.transaction_start(start_time)
+
+        ignore! if user_defined_rules_ignore?
+
+        create_initial_segment(options)
+        Segment.merge_untrusted_agent_attributes( \
+          @filtered_params,
+          :'request.parameters',
+          AttributeFilter::DST_SPAN_EVENTS
+        )
+      end
+
+      def initial_segment
+        segments.first
+      end
+
+      def finished?
+        initial_segment&.finished?
+      end
+
+      def create_initial_segment(options = {})
+        segment = create_segment(@default_name, options)
+        segment.record_scoped_metric = false
+      end
+
+      def create_segment(name, options = {})
+        summary_metrics = nil
 
-        frame_stack.push NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_header(state, start_time.to_f)
-        name_last_frame @default_name
+        if name.start_with?(MIDDLEWARE_PREFIX)
+          summary_metrics = MIDDLEWARE_SUMMARY_METRICS
+        end
+
+        @nesting_max_depth += 1
+
+        segment = Tracer.start_segment(
+          name: name,
+          unscoped_metrics: summary_metrics
+        )
+
+        # #code_information will glean the code info out of the options hash
+        # if it exists or noop otherwise
+        segment.code_information = options
+
+        segment
+      end
+
+      def create_nested_segment(category, options)
+        if options[:filtered_params] && !options[:filtered_params].empty?
+          @filtered_params = options[:filtered_params]
+          merge_request_parameters(options[:filtered_params])
+        end
+
+        @ignore_apdex = options[:ignore_apdex] if options.key?(:ignore_apdex)
+        @ignore_enduser = options[:ignore_enduser] if options.key?(:ignore_enduser)
+
+        nest_initial_segment if segments.length == 1
+        nested_name = self.class.nested_transaction_name(options[:transaction_name])
+
+        segment = create_segment(nested_name, options)
+        set_default_transaction_name(options[:transaction_name], category)
+        segment
+      end
+
+      def nest_initial_segment
+        self.initial_segment.name = self.class.nested_transaction_name(initial_segment.name)
+        initial_segment.record_scoped_metric = true
       end
 
       # Call this to ensure that the current transaction trace is not saved
       # To fully ignore all metrics and errors, use ignore! instead.
-      def abort_transaction!(state)
+      def abort_transaction!
         @ignore_trace = true
       end
 
-      WEB_SUMMARY_METRIC   = 'HttpDispatcher'.freeze
-      OTHER_SUMMARY_METRIC = 'OtherTransaction/all'.freeze
-
       def summary_metrics
         if @frozen_name.start_with?(CONTROLLER_PREFIX)
           [WEB_SUMMARY_METRIC]
@@ -453,83 +519,98 @@ module NewRelic
         name.start_with?(MIDDLEWARE_PREFIX)
       end
 
-      def stop(state, end_time, outermost_frame)
-        return if !state.is_execution_traced?
-        freeze_name_and_execute_if_not_ignored
-        ignore! if user_defined_rules_ignore?
+      def finish
+        return unless state.is_execution_traced? && initial_segment
 
-        if @has_children
-          name = Transaction.nested_transaction_name(outermost_frame.name)
-          trace_options = TRACE_OPTIONS_SCOPED
-        else
-          name = @frozen_name
-          trace_options = TRACE_OPTIONS_UNSCOPED
-        end
+        @end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
+        @duration = @end_time - @start_time
+        freeze_name_and_execute_if_not_ignored
 
-        # These metrics are recorded here instead of in record_summary_metrics
-        # in order to capture the exclusive time associated with the outer-most
-        # TT node.
-        if needs_middleware_summary_metrics?(name)
-          summary_metrics_with_exclusive_time = MIDDLEWARE_SUMMARY_METRICS
-        else
-          summary_metrics_with_exclusive_time = EMPTY_SUMMARY_METRICS
+        if nesting_max_depth == 1
+          initial_segment.name = @frozen_name
         end
 
-        NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped_footer(
-          state,
-          start_time.to_f,
-          name,
-          summary_metrics_with_exclusive_time,
-          outermost_frame,
-          trace_options,
-          end_time.to_f)
+        initial_segment.transaction_name = @frozen_name
+        assign_segment_dt_attributes
+        assign_agent_attributes
+        initial_segment.finish
 
-        NewRelic::Agent::BusyCalculator.dispatcher_finish(end_time)
+        NewRelic::Agent::TransactionTimeAggregator.transaction_stop(@end_time, @starting_thread_id)
 
-        commit!(state, end_time, name) unless @ignore_this_transaction
+        commit!(initial_segment.name) unless @ignore_this_transaction
+      rescue => e
+        NewRelic::Agent.logger.error('Exception during Transaction#finish', e)
+        nil
+      ensure
+        state.reset
       end
 
       def user_defined_rules_ignore?
-        return unless request_path
-        return if (rules = NewRelic::Agent.config[:"rules.ignore_url_regexes"]).empty?
+        return false unless request_path
+        return false if (rules = NewRelic::Agent.config[:"rules.ignore_url_regexes"]).empty?
 
         rules.any? do |rule|
           request_path.match(rule)
         end
       end
 
-      def commit!(state, end_time, outermost_node_name)
-        assign_agent_attributes
-        assign_intrinsics(state)
+      def commit!(outermost_node_name)
+        generate_payload
+        assign_intrinsics
+
+        finalize_segments
 
-        @transaction_trace = transaction_sampler.on_finishing_transaction(state, self, end_time)
+        @transaction_trace = transaction_sampler.on_finishing_transaction(self)
         sql_sampler.on_finishing_transaction(state, @frozen_name)
 
-        record_summary_metrics(outermost_node_name, end_time)
-        record_apdex(state, end_time) unless ignore_apdex?
+        record_summary_metrics(outermost_node_name)
+        record_total_time_metrics
+        record_apdex unless ignore_apdex?
         record_queue_time
+        distributed_tracer.record_metrics
 
         record_exceptions
+        record_transaction_event
+        record_log_events
         merge_metrics
+        send_transaction_finished_event
+      end
 
-        send_transaction_finished_event(state, start_time, end_time)
+      def assign_segment_dt_attributes
+        dt_payload = distributed_tracer.trace_state_payload || distributed_tracer.distributed_trace_payload
+        parent_attributes = {}
+        DistributedTraceAttributes.copy_parent_attributes(self, dt_payload, parent_attributes)
+        parent_attributes.each { |k, v| initial_segment.add_agent_attribute(k, v) }
       end
 
       def assign_agent_attributes
-        if referer
-          add_agent_attribute(:'request.headers.referer', referer,
-                              NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR)
-        end
+        default_destinations = AttributeFilter::DST_TRANSACTION_TRACER |
+          AttributeFilter::DST_TRANSACTION_EVENTS |
+          AttributeFilter::DST_ERROR_COLLECTOR
 
         if http_response_code
-          add_agent_attribute(:httpResponseCode, http_response_code,
-                              NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER|
-                              NewRelic::Agent::AttributeFilter::DST_TRANSACTION_EVENTS|
-                              NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR)
+          add_agent_attribute(:'http.statusCode', http_response_code, default_destinations)
+        end
+
+        if response_content_length
+          add_agent_attribute(:'response.headers.contentLength', response_content_length.to_i, default_destinations)
+        end
+
+        if response_content_type
+          add_agent_attribute(:'response.headers.contentType', response_content_type, default_destinations)
+        end
+
+        @request_attributes&.assign_agent_attributes(self)
+
+        display_host = Agent.config[:'process_host.display_name']
+        unless display_host == NewRelic::Agent::Hostname.get
+          add_agent_attribute(:'host.displayName', display_host, default_destinations)
         end
       end
 
-      def assign_intrinsics(state)
+      def assign_intrinsics
+        attributes.add_intrinsic_attribute(:priority, priority)
+
         if gc_time = calculate_gc_time
           attributes.add_intrinsic_attribute(:gc_time, gc_time)
         end
@@ -542,11 +623,21 @@ module NewRelic
           attributes.add_intrinsic_attribute(:synthetics_resource_id, synthetics_resource_id)
           attributes.add_intrinsic_attribute(:synthetics_job_id, synthetics_job_id)
           attributes.add_intrinsic_attribute(:synthetics_monitor_id, synthetics_monitor_id)
+          attributes.add_intrinsic_attribute(:synthetics_type, synthetics_info('type'))
+          attributes.add_intrinsic_attribute(:synthetics_initiator, synthetics_info('initiator'))
+
+          synthetics_additional_attributes do |key, value|
+            attributes.add_intrinsic_attribute(key, value)
+          end
         end
 
-        if state.is_cross_app?
-          attributes.add_intrinsic_attribute(:trip_id, cat_trip_id(state))
-          attributes.add_intrinsic_attribute(:path_hash, cat_path_hash(state))
+        distributed_tracer.assign_intrinsics
+      end
+
+      def synthetics_additional_attributes(&block)
+        synthetics_info('attributes')&.each do |k, v|
+          new_key = "synthetics_#{NewRelic::LanguageSupport.snakeize(k.to_s)}".to_sym
+          yield(new_key, v.to_s)
         end
       end
 
@@ -555,68 +646,53 @@ module NewRelic
         NewRelic::Agent::StatsEngine::GCProfiler.record_delta(gc_start_snapshot, gc_stop_snapshot)
       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 calculate_transport_duration(distributed_trace_payload)
+        return unless distributed_trace_payload
+
+        duration = start_time - (distributed_trace_payload.timestamp / 1000.0)
+        [duration, 0].max
+      end
+
       # The summary metrics recorded by this method all end up with a duration
       # equal to the transaction itself, and an exclusive time of zero.
-      def record_summary_metrics(outermost_node_name, end_time)
+      def record_summary_metrics(outermost_node_name)
         metrics = summary_metrics
         metrics << @frozen_name unless @frozen_name == outermost_node_name
-        @metrics.record_unscoped(metrics, end_time.to_f - start_time.to_f, 0)
+        @metrics.record_unscoped(metrics, duration, 0)
       end
 
       # This event is fired when the transaction is fully completed. The metric
       # values and sampler can't be successfully modified from this event.
-      def send_transaction_finished_event(state, start_time, end_time)
-        duration = end_time.to_f - start_time.to_f
-        payload = {
-          :name                 => @frozen_name,
-          :bucket               => recording_web_transaction? ? :request : :background,
-          :start_timestamp      => start_time.to_f,
-          :duration             => duration,
-          :metrics              => @metrics,
-          :attributes           => @attributes,
-        }
-        append_cat_info(state, duration, payload)
-        append_apdex_perf_zone(duration, payload)
-        append_synthetics_to(state, payload)
-        append_referring_transaction_guid_to(state, payload)
-        append_http_response_code(payload)
-
+      def send_transaction_finished_event
         agent.events.notify(:transaction_finished, payload)
       end
 
-      def append_http_response_code(payload)
-        payload[:http_response_code] = http_response_code if http_response_code
-      end
-
-      def include_guid?(state, duration)
-        state.is_cross_app? || is_synthetics_request?
-      end
-
-      def cat_trip_id(state)
-        NewRelic::Agent.instance.cross_app_monitor.client_referring_transaction_trip_id(state) || guid
-      end
+      def generate_payload
+        @payload = {
+          :name => @frozen_name,
+          :bucket => recording_web_transaction? ? :request : :background,
+          :start_timestamp => start_time,
+          :duration => duration,
+          :metrics => @metrics,
+          :attributes => @attributes,
+          :error => false,
+          :priority => priority
+        }
 
-      def cat_path_hash(state)
-        referring_path_hash = cat_referring_path_hash(state) || '0'
-        seed = referring_path_hash.to_i(16)
-        result = NewRelic::Agent.instance.cross_app_monitor.path_hash(best_name, seed)
-        record_cat_path_hash(result)
-        result
+        distributed_tracer.append_payload(@payload)
+        append_apdex_perf_zone(@payload)
+        append_synthetics_to(@payload)
       end
 
-      def record_cat_path_hash(hash)
-        @cat_path_hashes ||= []
-        if @cat_path_hashes.size < 10 && !@cat_path_hashes.include?(hash)
-          @cat_path_hashes << hash
-        end
-      end
-
-      def cat_referring_path_hash(state)
-        NewRelic::Agent.instance.cross_app_monitor.client_referring_transaction_path_hash(state)
+      def include_guid?
+        distributed_tracer.is_cross_app? || is_synthetics_request?
       end
 
       def is_synthetics_request?
-        synthetics_payload != nil && raw_synthetics_header != nil
+        !synthetics_payload.nil? && !raw_synthetics_header.nil?
       end
 
       def synthetics_version
@@ -644,11 +720,11 @@ module NewRelic
         info[4]
       end
 
-      APDEX_S = 'S'.freeze
-      APDEX_T = 'T'.freeze
-      APDEX_F = 'F'.freeze
+      def synthetics_info(key)
+        synthetics_info_payload[key] if synthetics_info_payload
+      end
 
-      def append_apdex_perf_zone(duration, payload)
+      def append_apdex_perf_zone(payload)
         if recording_web_transaction?
           bucket = apdex_bucket(duration, apdex_t)
         elsif background_apdex_t = transaction_specific_apdex_t
@@ -661,45 +737,21 @@ module NewRelic
         when :apdex_s then APDEX_S
         when :apdex_t then APDEX_T
         when :apdex_f then APDEX_F
-        else nil
         end
         payload[:apdex_perf_zone] = bucket_str if bucket_str
       end
 
-      def append_cat_info(state, duration, payload)
-        return unless include_guid?(state, duration)
-        payload[:guid] = guid
-
-        return unless state.is_cross_app?
-        trip_id             = cat_trip_id(state)
-        path_hash           = cat_path_hash(state)
-        referring_path_hash = cat_referring_path_hash(state)
-
-        payload[:cat_trip_id]             = trip_id             if trip_id
-        payload[:cat_referring_path_hash] = referring_path_hash if referring_path_hash
-
-        if path_hash
-          payload[:cat_path_hash] = path_hash
-
-          alternate_path_hashes = cat_path_hashes - [path_hash]
-          unless alternate_path_hashes.empty?
-            payload[:cat_alternate_path_hashes] = alternate_path_hashes
-          end
-        end
-      end
-
-      def append_synthetics_to(state, payload)
+      def append_synthetics_to(payload)
         return unless is_synthetics_request?
 
         payload[:synthetics_resource_id] = synthetics_resource_id
-        payload[:synthetics_job_id]      = synthetics_job_id
-        payload[:synthetics_monitor_id]  = synthetics_monitor_id
-      end
+        payload[:synthetics_job_id] = synthetics_job_id
+        payload[:synthetics_monitor_id] = synthetics_monitor_id
+        payload[:synthetics_type] = synthetics_info('type')
+        payload[:synthetics_initiator] = synthetics_info('initiator')
 
-      def append_referring_transaction_guid_to(state, payload)
-        referring_guid = NewRelic::Agent.instance.cross_app_monitor.client_referring_transaction_guid(state)
-        if referring_guid
-          payload[:referring_transaction_guid] = referring_guid
+        synthetics_additional_attributes do |key, value|
+          payload[key] = value
         end
       end
 
@@ -708,25 +760,45 @@ module NewRelic
       end
 
       def record_exceptions
+        error_recorded = false
         @exceptions.each do |exception, options|
-          options[:uri]      ||= request_path if request_path
-          options[:metric]     = best_name
-          options[:attributes] = @attributes
-
-          agent.error_collector.notice_error(exception, options)
+          error_recorded = record_exception(exception, options, error_recorded)
         end
+        payload&.[]=(:error, error_recorded)
+      end
+
+      def record_exception(exception, options, error_recorded)
+        options[:uri] ||= request_path if request_path
+        options[:port] = request_port if request_port
+        options[:metric] = best_name
+        options[:attributes] = @attributes
+
+        span_id = options.delete(:span_id)
+        !!agent.error_collector.notice_error(exception, options, span_id) || error_recorded
       end
 
       # Do not call this.  Invoke the class method instead.
-      def notice_error(error, options={}) # :nodoc:
+      def notice_error(error, options = {}) # :nodoc:
+        # Only the last error is kept
+        if current_segment
+          current_segment.notice_error(error, expected: options[:expected])
+          options[:span_id] = current_segment.guid
+        end
+
         if @exceptions[error]
-          @exceptions[error].merge! options
+          @exceptions[error].merge!(options)
         else
           @exceptions[error] = options
         end
       end
 
-      QUEUE_TIME_METRIC = 'WebFrontend/QueueTime'.freeze
+      def record_transaction_event
+        agent.transaction_event_recorder.record(payload)
+      end
+
+      def record_log_events
+        agent.log_event_aggregator.record_batch(self, @logs.to_a)
+      end
 
       def queue_time
         @apdex_start ? @start_time - @apdex_start : 0
@@ -743,47 +815,36 @@ module NewRelic
         end
       end
 
-      APDEX_ALL_METRIC   = 'ApdexAll'.freeze
-
-      APDEX_METRIC       = 'Apdex'.freeze
-      APDEX_OTHER_METRIC = 'ApdexOther'.freeze
-
-      APDEX_TXN_METRIC_PREFIX       = 'Apdex/'.freeze
-      APDEX_OTHER_TXN_METRIC_PREFIX = 'ApdexOther/Transaction/'.freeze
-
-      def had_error?
-        @exceptions.each do |exception, _|
-          return true unless NewRelic::Agent.instance.error_collector.error_is_ignored?(exception)
+      def had_error_affecting_apdex?
+        @exceptions.each.any? do |exception, options|
+          NewRelic::Agent.instance.error_collector.error_affects_apdex?(exception, options)
         end
-        false
       end
 
       def apdex_bucket(duration, current_apdex_t)
-        self.class.apdex_bucket(duration, had_error?, current_apdex_t)
+        self.class.apdex_bucket(duration, had_error_affecting_apdex?, current_apdex_t)
       end
 
-      def record_apdex(state, end_time=Time.now)
+      def record_apdex
         return unless state.is_execution_traced?
 
         freeze_name_and_execute_if_not_ignored do
-          total_duration  = end_time - apdex_start
-          action_duration = end_time - start_time
-
           if recording_web_transaction?
-            record_apdex_metrics(APDEX_METRIC, APDEX_TXN_METRIC_PREFIX,
-                                 total_duration, action_duration, apdex_t)
+            record_apdex_metrics(APDEX_METRIC, APDEX_TXN_METRIC_PREFIX, apdex_t)
           else
-            record_apdex_metrics(APDEX_OTHER_METRIC, APDEX_OTHER_TXN_METRIC_PREFIX,
-                                 total_duration, action_duration, transaction_specific_apdex_t)
+            record_apdex_metrics(APDEX_OTHER_METRIC,
+              APDEX_OTHER_TXN_METRIC_PREFIX,
+              transaction_specific_apdex_t)
           end
         end
       end
 
-      def record_apdex_metrics(rollup_metric, transaction_prefix, total_duration, action_duration, current_apdex_t)
+      def record_apdex_metrics(rollup_metric, transaction_prefix, current_apdex_t)
         return unless current_apdex_t
 
+        total_duration = end_time - apdex_start
         apdex_bucket_global = apdex_bucket(total_duration, current_apdex_t)
-        apdex_bucket_txn    = apdex_bucket(action_duration, current_apdex_t)
+        apdex_bucket_txn = apdex_bucket(duration, current_apdex_t)
 
         @metrics.record_unscoped(rollup_metric, apdex_bucket_global, current_apdex_t)
         @metrics.record_unscoped(APDEX_ALL_METRIC, apdex_bucket_global, current_apdex_t)
@@ -800,7 +861,16 @@ module NewRelic
         Agent.config[key] && Agent.config[key][best_name]
       end
 
-      def with_database_metric_name(model, method)
+      def threshold
+        source_class = Agent.config.source(:'transaction_tracer.transaction_threshold').class
+        if source_class == Configuration::DefaultSource
+          apdex_t * 4
+        else
+          Agent.config[:'transaction_tracer.transaction_threshold']
+        end
+      end
+
+      def with_database_metric_name(model, method, product = nil)
         previous = self.instrumentation_state[:datastore_override]
         model_name = case model
                      when Class
@@ -809,8 +879,8 @@ module NewRelic
                        model
                      else
                        model.to_s
-                     end
-        self.instrumentation_state[:datastore_override] = [method, model_name]
+        end
+        self.instrumentation_state[:datastore_override] = [method, model_name, product]
         yield
       ensure
         self.instrumentation_state[:datastore_override] = previous
@@ -820,8 +890,9 @@ module NewRelic
         attributes.merge_custom_attributes(p)
       end
 
-      alias_method :set_user_attributes, :add_custom_attributes
-      alias_method :add_custom_parameters, :add_custom_attributes
+      def add_log_event(event)
+        logs.append(event: event)
+      end
 
       def recording_web_transaction?
         web_category?(@category)
@@ -841,11 +912,13 @@ module NewRelic
 
       def normal_cpu_burn
         return unless @process_cpu_start
+
         process_cpu - @process_cpu_start
       end
 
       def jruby_cpu_burn
         return unless @jruby_cpu_start
+
         jruby_cpu_time - @jruby_cpu_start
       end
 
@@ -881,19 +954,21 @@ module NewRelic
 
       def process_cpu
         return nil if defined? JRuby
+
         p = Process.times
         p.stime + p.utime
       end
 
-      JRUBY_CPU_TIME_ERROR = "Error calculating JRuby CPU Time".freeze
       def jruby_cpu_time
         return nil unless @@java_classes_loaded
+
         threadMBean = Java::JavaLangManagement::ManagementFactory.getThreadMXBean()
 
         return nil unless threadMBean.isCurrentThreadCpuTimeSupported
-        java_utime = threadMBean.getCurrentThreadUserTime()  # ns
 
-        -1 == java_utime ? 0.0 : java_utime/1e9
+        java_utime = threadMBean.getCurrentThreadUserTime() # ns
+
+        -1 == java_utime ? 0.0 : java_utime / 1e9
       rescue => e
         ::NewRelic::Agent.logger.log_once(:warn, :jruby_cpu_time, JRUBY_CPU_TIME_ERROR, e)
         ::NewRelic::Agent.logger.debug(JRUBY_CPU_TIME_ERROR, e)
@@ -911,39 +986,6 @@ module NewRelic
       def sql_sampler
         agent.sql_sampler
       end
-
-      HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
-      GUID_LENGTH = 16
-
-      # generate a random 64 bit uuid
-      def generate_guid
-        guid = ''
-        GUID_LENGTH.times do |a|
-          guid << HEX_DIGITS[rand(16)]
-        end
-        guid
-      end
-
-      # Make a safe attempt to get the referer from a request object, generally successful when
-      # it's a Rack request.
-      def referer_from_request(req)
-        if req && req.respond_to?(:referer) && req.referer
-          HTTPClients::URIUtil.strip_query_string(req.referer.to_s)
-        end
-      end
-
-      # In practice we expect req to be a Rack::Request or ActionController::AbstractRequest
-      # (for older Rails versions).  But anything that responds to path can be passed to
-      # perform_action_with_newrelic_trace.
-      #
-      # We don't expect the path to include a query string, however older test helpers for
-      # rails construct the PATH_INFO enviroment variable improperly and we're generally
-      # being defensive.
-      def path_from_request(req)
-        path = req.path
-        path = HTTPClients::URIUtil.strip_query_string(path)
-        path.empty? ? "/" : path
-      end
     end
   end
 end