newrelic_rpm 4.6.0.338 → 4.7.0.339

data/lib/new_relic/agent/method_tracer_helpers.rb

@@ -17,7 +17,11 @@ module NewRelic
         first_name   = metric_names.shift
         return yield unless first_name
 
-        segment = NewRelic::Agent::Transaction.start_segment first_name, metric_names
+        segment = NewRelic::Agent::Transaction.start_segment(
+          name: first_name,
+          unscoped_metrics: metric_names
+        )
+
         if options[:metric] == false
           segment.record_metrics = false
         end

data/lib/new_relic/agent/range_extensions.rb

@@ -0,0 +1,47 @@
+# 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.
+
+module NewRelic
+  module Agent
+    module RangeExtensions
+      module_function
+
+      def intersects? r1, r2
+        r1.include?(r2.begin) || r2.include?(r1.begin)
+      end
+
+      def merge r1, r2
+        return unless intersects? r1, r2
+        range_min = r1.begin < r2.begin ? r1.begin : r2.begin
+        range_max = r1.end > r2.end ? r1.end : r2.end
+        range_min..range_max
+      end
+
+      # Takes an array of ranges and a range which it will
+      # merge into an existing range if they intersect, otherwise
+      # it will append this range to the end the array.
+      def merge_or_append range, ranges
+        ranges.each_with_index do |r, i|
+          if merged = merge(r, range)
+            ranges[i] = merged
+            return ranges
+          end
+        end
+        ranges.push range
+      end
+
+      # Computes the amount of overlap between range and an array of ranges.
+      # For efficiency, it assumes that range intersects with each of the
+      # ranges in the ranges array.
+      def compute_overlap range, ranges
+        ranges.inject(0) do |memo, other|
+          next memo unless intersects? range, other
+          lower_bound = range.begin > other.begin ? range.begin : other.begin
+          upper_bound = range.end < other.end ? range.end : other.end
+          memo += upper_bound - lower_bound
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction.rb

@@ -459,7 +459,12 @@ module NewRelic
         end
 
         @nesting_max_depth += 1
-        segment = self.class.start_segment name, summary_metrics
+
+        segment = self.class.start_segment(
+          name: name,
+          unscoped_metrics: summary_metrics
+        )
+
         frame_stack.push segment
         segment
       end
@@ -546,12 +551,13 @@ module NewRelic
         assign_agent_attributes
         assign_intrinsics(state)
 
-        segments.each { |s| s.finalize }
+        finalize_segments
 
         @transaction_trace = transaction_sampler.on_finishing_transaction(state, self, end_time)
         sql_sampler.on_finishing_transaction(state, @frozen_name)
 
         record_summary_metrics(outermost_node_name, end_time)
+        record_total_time_metrics
         record_apdex(state, end_time) unless ignore_apdex?
         record_queue_time
         record_client_application_metric state

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

@@ -2,40 +2,58 @@
 # 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/range_extensions'
+
 module NewRelic
   module Agent
     class Transaction
       class AbstractSegment
+        # This class is the base class for all segments. It is reponsible for
+        # timing, naming, and defining lifecycle callbacks. One of the more
+        # complex responsibilites of this class is computing exclusive duration.
+        # One of the reasons for this complexity is that exclusive time will be
+        # computed using time ranges or by recording an aggregate value for
+        # a segments children time. The reason for this is that computing
+        # exclusive duration using time ranges is expensive and it's only
+        # necessary if a segment's children run concurrently, or a segment ends
+        # after it's parent. We will use the optimized exclusive duration
+        # calculation in all other cases.
+        #
         attr_reader :start_time, :end_time, :duration, :exclusive_duration
         attr_accessor :name, :parent, :children_time, :transaction
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
 
         def initialize name=nil, start_time=nil
           @name = name
-          @children_time = 0.0
-          @record_metrics = true
-          @record_scoped_metric = true
           @transaction = nil
           @parent = nil
-          @record_on_finish = false
           @params = nil
           @start_time = start_time if start_time
+          @end_time = nil
+          @duration = 0.0
+          @exclusive_duration = 0.0
+          @children_time = 0.0
+          @children_time_ranges = nil
+          @active_children = 0
+          @range_recorded = false
+          @concurrent_children = false
+          @record_metrics = true
+          @record_scoped_metric = true
+          @record_on_finish = false
         end
 
         def start
           @start_time ||= Time.now
+          return unless transaction
+          parent.child_start self if parent
         end
 
         def finish
           @end_time = Time.now
           @duration = end_time.to_f - start_time.to_f
-          @exclusive_duration = duration - children_time
-          if transaction
-            record_metrics if record_metrics? && record_on_finish?
-            segment_complete
-            parent.child_complete self if parent
-            transaction.segment_complete self
-          end
+          return unless transaction
+          run_complete_callbacks
+          finalize if record_on_finish?
         rescue => e
           NewRelic::Agent.logger.error "Exception finishing segment: #{name}", e
         end
@@ -57,13 +75,8 @@ module NewRelic
         end
 
         def finalize
-          unless finished?
-            finish
-            NewRelic::Agent.logger.warn "Segment: #{name} was unfinished at " \
-              "the end of transaction. Timing information for " \
-              "#{transaction.best_name} may be inaccurate."
-            # @todo: we should record a supportability metric here
-          end
+          force_finish unless finished?
+          record_exclusive_duration
           record_metrics if record_metrics?
         end
 
@@ -75,6 +88,22 @@ module NewRelic
           !!@params
         end
 
+        def time_range
+          @start_time.to_f .. @end_time.to_f
+        end
+
+        def children_time_ranges
+          @children_time_ranges ||= []
+        end
+
+        def children_time_ranges?
+          !!@children_time_ranges
+        end
+
+        def concurrent_children?
+          @concurrent_children
+        end
+
         INSPECT_IGNORE = [:@transaction, :@transaction_state].freeze
 
         def inspect
@@ -86,23 +115,103 @@ module NewRelic
 
         protected
 
-        def record_metrics
-          raise NotImplementedError, "Subclasses must implement record_metrics"
+        attr_writer :range_recorded
+
+        def range_recorded?
+          @range_recorded
+        end
+
+        def child_start segment
+          @active_children += 1
+          @concurrent_children = @concurrent_children || @active_children > 1
+
+          transaction.async = true if @concurrent_children
         end
 
         def child_complete segment
-          if segment.record_metrics?
-            self.children_time += segment.duration
-          else
-            self.children_time += segment.children_time
+          @active_children -= 1
+          record_child_time segment
+
+          if finished?
+            transaction.async = true
+            parent.descendant_complete self, segment
+          end
+        end
+
+        # When a child segment completes after its parent, we need to propagate
+        # the information about the descendant further up the tree so that
+        # ancestors can properly account for exclusive time. Once we've reached
+        # an ancestor whose end time is greater than or equal to the descendant's
+        # we can stop the propagation. We pass along the direct child so we can
+        # make any corrections needed for exclusive time calculation.
+
+        def descendant_complete child, descendant
+          RangeExtensions.merge_or_append descendant.time_range,
+                                            children_time_ranges
+          # If this child's time was previously added to this segment's
+          # aggregate children time, we need to re-record it using a time range
+          # for proper exclusive time calculation
+          unless child.range_recorded?
+            self.children_time -= child.duration
+            record_child_time_as_range child
+          end
+
+          if parent && finished? && descendant.end_time >= end_time
+            parent.descendant_complete self, descendant
           end
         end
 
         private
 
+        def force_finish
+          finish
+          NewRelic::Agent.logger.warn "Segment: #{name} was unfinished at " \
+            "the end of transaction. Timing information for this segment's" \
+            "parent #{parent.name} in #{transaction.best_name} may be inaccurate."
+        end
+
+        def run_complete_callbacks
+          segment_complete
+          parent.child_complete self if parent
+          transaction.segment_complete self
+        end
+
+        def record_metrics
+          raise NotImplementedError, "Subclasses must implement record_metrics"
+        end
+
         # callback for subclasses to override
         def segment_complete
-          raise NotImplementedError
+        end
+
+        def record_child_time child
+          if concurrent_children? || finished? && end_time < child.end_time
+            record_child_time_as_range child
+          else
+            record_child_time_as_number child
+          end
+        end
+
+        def record_child_time_as_range child
+          RangeExtensions.merge_or_append child.time_range,
+                                          children_time_ranges
+          child.range_recorded = true
+        end
+
+        def record_child_time_as_number child
+          self.children_time += child.duration
+        end
+
+        def record_exclusive_duration
+          overlapping_duration = if children_time_ranges?
+            RangeExtensions.compute_overlap time_range, children_time_ranges
+          else
+            0.0
+          end
+
+          @exclusive_duration = duration - children_time - overlapping_duration
+          transaction.total_time += @exclusive_duration
+          params[:exclusive_duration_millis] = @exclusive_duration * 1000 if transaction.async?
         end
 
         def metric_cache

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

@@ -17,7 +17,8 @@ module NewRelic
         attr_reader :product, :operation, :collection, :sql_statement, :nosql_statement, :host, :port_path_or_id
         attr_accessor :database_name
 
-        def initialize product, operation, collection = nil, host = nil, port_path_or_id = nil, database_name = nil
+
+        def initialize product, operation, collection = nil, host = nil, port_path_or_id = nil, database_name = nil, start_time = nil
           @product = product
           @operation = operation
           @collection = collection
@@ -25,7 +26,9 @@ module NewRelic
           @nosql_statement = nil
           set_instance_info host, port_path_or_id
           @database_name = database_name ? database_name.to_s : nil
-          super Datastores::MetricHelper.scoped_metric_for(product, operation, collection)
+          super Datastores::MetricHelper.scoped_metric_for(product, operation, collection),
+                nil,
+                start_time
         end
 
         def set_instance_info host = nil, port_path_or_id = nil

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

@@ -18,13 +18,14 @@ module NewRelic
 
         NR_SYNTHETICS_HEADER = 'X-NewRelic-Synthetics'.freeze
 
-        def initialize library, uri, procedure # :nodoc:
+
+        def initialize library, uri, procedure, start_time = nil # :nodoc:
           @library = library
           @uri = HTTPClients::URIUtil.parse_and_normalize_url(uri)
           @procedure = procedure
           @host_header = nil
           @app_data = nil
-          super()
+          super(nil, nil, start_time)
         end
 
         def name # :nodoc:

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

@@ -46,9 +46,6 @@ module NewRelic
             @unscoped_metrics = metric
           end
         end
-
-        def segment_complete
-        end
       end
     end
   end

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

@@ -12,24 +12,51 @@ module NewRelic
     class Transaction
       module Tracing
         module ClassMethods
-          def start_segment name, unscoped_metrics=nil
-            segment = Segment.new name, unscoped_metrics
-            start_and_add_segment segment
+          def start_segment(name:nil,
+                            unscoped_metrics:nil,
+                            start_time: nil,
+                            parent: nil)
+
+            # ruby 2.0.0 does not support required kwargs
+            raise ArgumentError, 'missing required argument: name' if name.nil?
+
+            segment = Segment.new name, unscoped_metrics, start_time
+
+            start_and_add_segment segment, parent
           end
 
           UNKNOWN_PRODUCT = "Unknown".freeze
           UNKNOWN_OPERATION = "other".freeze
 
-          def start_datastore_segment product=nil, operation=nil, collection=nil, host=nil, port_path_or_id=nil, database_name=nil
+          def start_datastore_segment(product: nil,
+                                      operation: nil,
+                                      collection: nil,
+                                      host: nil,
+                                      port_path_or_id: nil,
+                                      database_name: nil,
+                                      start_time: nil,
+                                      parent: nil)
+
             product ||= UNKNOWN_PRODUCT
             operation ||= UNKNOWN_OPERATION
+
             segment = DatastoreSegment.new product, operation, collection, host, port_path_or_id, database_name
-            start_and_add_segment segment
+            start_and_add_segment segment, parent
           end
 
-          def start_external_request_segment library, uri, procedure
-            segment = ExternalRequestSegment.new library, uri, procedure
-            start_and_add_segment segment
+          def start_external_request_segment(library: nil,
+                                             uri: nil,
+                                             procedure: nil,
+                                             start_time: nil,
+                                             parent: nil)
+
+            # ruby 2.0.0 does not support required kwargs
+            raise ArgumentError, 'missing required argument: library' if library.nil?
+            raise ArgumentError, 'missing required argument: uri' if uri.nil?
+            raise ArgumentError, 'missing required argument: procedure' if procedure.nil?
+
+            segment = ExternalRequestSegment.new library, uri, procedure, start_time
+            start_and_add_segment segment, parent
           end
 
           # @api private
@@ -40,7 +67,8 @@ module NewRelic
                                            destination_name: nil,
                                            headers: nil,
                                            parameters: nil,
-                                           start_time: nil)
+                                           start_time: nil,
+                                           parent: nil)
 
             # ruby 2.0.0 does not support required kwargs
             raise ArgumentError, 'missing required argument: action' if action.nil?
@@ -57,24 +85,20 @@ module NewRelic
               parameters: parameters,
               start_time: start_time
             )
-            start_and_add_segment segment
+            start_and_add_segment segment, parent
           end
 
           private
 
-          def start_and_add_segment segment
-            segment.start
-            add_segment segment
-            segment
-          end
-
-          def add_segment segment
+          def start_and_add_segment segment, parent = nil
             state = NewRelic::Agent::TransactionState.tl_get
             if (txn = state.current_transaction) && state.is_execution_traced?
-              txn.add_segment segment
+              txn.add_segment segment, parent
             else
               segment.record_metrics = false
             end
+            segment.start
+            segment
           end
         end
 
@@ -84,9 +108,21 @@ module NewRelic
 
         attr_reader :current_segment
 
-        def add_segment segment
+        def async?
+          @async ||= false
+        end
+
+        attr_writer :async
+
+        def total_time
+          @total_time ||= 0.0
+        end
+
+        attr_writer :total_time
+
+        def add_segment segment, parent = nil
           segment.transaction = self
-          segment.parent = current_segment
+          segment.parent = parent || current_segment
           @current_segment = segment
           if @segments.length < segment_limit
             @segments << segment
@@ -103,6 +139,27 @@ module NewRelic
         def segment_limit
           Agent.config[:'transaction_tracer.limit_segments']
         end
+
+        private
+
+        def finalize_segments
+          segments.each { |s| s.finalize }
+        end
+
+
+        WEB_TRANSACTION_TOTAL_TIME   = "WebTransactionTotalTime".freeze
+        OTHER_TRANSACTION_TOTAL_TIME = "OtherTransactionTotalTime".freeze
+
+        def record_total_time_metrics
+          total_time_metric = if recording_web_transaction?
+            WEB_TRANSACTION_TOTAL_TIME
+          else
+            OTHER_TRANSACTION_TOTAL_TIME
+          end
+
+          @metrics.record_unscoped total_time_metric, total_time
+          @metrics.record_unscoped "#{total_time_metric}/#{@frozen_name}", total_time
+        end
       end
     end
   end