newrelic_rpm 6.15.0 → 8.13.1

data/lib/new_relic/agent/tracer.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/transaction'
 require 'new_relic/agent/transaction/segment'
@@ -86,9 +86,9 @@ module NewRelic
         #
         # @api public
         def in_transaction(name: nil,
-                           partial_name: nil,
-                           category: nil,
-                           options: {})
+          partial_name: nil,
+          category:,
+          options: {})
 
           finishable = start_transaction_or_segment(
             name: name,
@@ -130,15 +130,11 @@ module NewRelic
         #
         # @api public
         def start_transaction_or_segment(name: nil,
-                                         partial_name: nil,
-                                         category: nil,
-                                         options: {})
-          if name.nil? && partial_name.nil?
-            raise ArgumentError, 'missing required argument: name or partial_name'
-          end
-          if category.nil?
-            raise ArgumentError, 'missing required argument: category'
-          end
+          partial_name: nil,
+          category:,
+          options: {})
+
+          raise ArgumentError, 'missing required argument: name or partial_name' if name.nil? && partial_name.nil?
 
           if name
             options[:transaction_name] = name
@@ -154,7 +150,6 @@ module NewRelic
           else
             Transaction.start_new_transaction(state, category, options)
           end
-
         rescue ArgumentError
           raise
         rescue => exception
@@ -163,16 +158,12 @@ module NewRelic
 
         # Takes name or partial_name and a category.
         # Returns a transaction instance or nil
-        def start_transaction(name: nil,
-                              partial_name: nil,
-                              category: nil,
-                              **options)
-          if name.nil? && partial_name.nil?
-            raise ArgumentError, 'missing required argument: name or partial_name'
-          end
-          if category.nil?
-            raise ArgumentError, 'missing required argument: category'
-          end
+        def start_transaction(category:,
+          name: nil,
+          partial_name: nil,
+          **options)
+
+          raise ArgumentError, 'missing required argument: name or partial_name' if name.nil? && partial_name.nil?
 
           return current_transaction if current_transaction
 
@@ -186,8 +177,8 @@ module NewRelic
           end
 
           Transaction.start_new_transaction(state,
-                                            category,
-                                            options)
+            category,
+            options)
         rescue ArgumentError
           raise
         rescue => exception
@@ -196,11 +187,13 @@ module NewRelic
 
         def create_distributed_trace_payload
           return unless txn = current_transaction
+
           txn.distributed_tracer.create_distributed_trace_payload
         end
 
         def accept_distributed_trace_payload(payload)
           return unless txn = current_transaction
+
           txn.distributed_tracer.accept_distributed_trace_payload(payload)
         end
 
@@ -211,6 +204,7 @@ module NewRelic
         # @api public
         def current_segment
           return unless txn = current_transaction
+
           txn.current_segment
         end
 
@@ -238,17 +232,13 @@ module NewRelic
         #   +finish+ on it at the end of the code you're tracing
         #
         # @api public
-        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 = Transaction::Segment.new name, unscoped_metrics, start_time
-          start_and_add_segment segment, parent
+        def start_segment(name:,
+          unscoped_metrics: nil,
+          start_time: nil,
+          parent: nil)
 
+          segment = Transaction::Segment.new(name, unscoped_metrics, start_time)
+          start_and_add_segment(segment, parent)
         rescue ArgumentError
           raise
         rescue => exception
@@ -294,20 +284,19 @@ module NewRelic
         #
         # @api public
         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)
+          operation: nil,
+          collection: nil,
+          host: nil,
+          port_path_or_id: nil,
+          database_name: nil,
+          start_time: nil,
+          parent: nil)
 
           product ||= UNKNOWN
           operation ||= OTHER
 
-          segment = Transaction::DatastoreSegment.new product, operation, collection, host, port_path_or_id, database_name
-          start_and_add_segment segment, parent
-
+          segment = Transaction::DatastoreSegment.new(product, operation, collection, host, port_path_or_id, database_name)
+          start_and_add_segment(segment, parent)
         rescue ArgumentError
           raise
         rescue => exception
@@ -341,20 +330,14 @@ module NewRelic
         #   you're tracing
         #
         # @api public
-        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 = Transaction::ExternalRequestSegment.new library, uri, procedure, start_time
-          start_and_add_segment segment, parent
-
+        def start_external_request_segment(library:,
+          uri:,
+          procedure:,
+          start_time: nil,
+          parent: nil)
+
+          segment = Transaction::ExternalRequestSegment.new(library, uri, procedure, start_time)
+          start_and_add_segment(segment, parent)
         rescue ArgumentError
           raise
         rescue => exception
@@ -363,34 +346,29 @@ module NewRelic
 
         # Will potentially capture and notice an error at the
         # segment that was executing when error occurred.
-        # if passed +segment+ is something that doesn't 
+        # if passed +segment+ is something that doesn't
         # respond to +notice_segment_error+ then this method
         # is effectively just a yield to the given &block
-        def capture_segment_error segment
+        def capture_segment_error(segment)
           return unless block_given?
+
           yield
         rescue => exception
           if segment && segment.is_a?(Transaction::AbstractSegment)
-            segment.notice_error exception
+            segment.notice_error(exception)
           end
           raise
         end
 
         # For New Relic internal use only.
-        def start_message_broker_segment(action: nil,
-                                         library: nil,
-                                         destination_type: nil,
-                                         destination_name: nil,
-                                         headers: nil,
-                                         parameters: nil,
-                                         start_time: nil,
-                                         parent: 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?
+        def start_message_broker_segment(action:,
+          library:,
+          destination_type:,
+          destination_name:,
+          headers: nil,
+          parameters: nil,
+          start_time: nil,
+          parent: nil)
 
           segment = Transaction::MessageBrokerSegment.new(
             action: action,
@@ -401,8 +379,7 @@ module NewRelic
             parameters: parameters,
             start_time: start_time
           )
-          start_and_add_segment segment, parent
-
+          start_and_add_segment(segment, parent)
         rescue ArgumentError
           raise
         rescue => exception
@@ -432,13 +409,28 @@ module NewRelic
 
         alias_method :tl_clear, :clear_state
 
+        def thread_block_with_current_transaction(*args, &block)
+          current_txn = ::Thread.current[:newrelic_tracer_state].current_transaction if ::Thread.current[:newrelic_tracer_state] && ::Thread.current[:newrelic_tracer_state].is_execution_traced?
+          proc do
+            begin
+              if current_txn
+                NewRelic::Agent::Tracer.state.current_transaction = current_txn
+                segment = NewRelic::Agent::Tracer.start_segment(name: "Ruby/Thread/#{::Thread.current.object_id}")
+              end
+              yield(*args) if block.respond_to?(:call)
+            ensure
+              segment.finish if segment
+            end
+          end
+        end
+
         private
 
-        def start_and_add_segment segment, parent = nil
+        def start_and_add_segment(segment, parent = nil)
           tracer_state = state
           if (txn = tracer_state.current_transaction) &&
-            tracer_state.tracing_enabled?
-            txn.add_segment segment, parent
+              tracer_state.tracing_enabled?
+            txn.add_segment(segment, parent)
           else
             segment.record_metrics = false
           end
@@ -455,7 +447,6 @@ module NewRelic
       # This is THE location to store thread local information during a transaction
       # Need a new piece of data? Add a method here, NOT a new thread local variable.
       class State
-
         def initialize
           @untraced = []
           @current_transaction = nil
@@ -463,7 +454,7 @@ module NewRelic
         end
 
         # This starts the timer for the transaction.
-        def reset(transaction=nil)
+        def reset(transaction = nil)
           # We purposefully don't reset @untraced or @record_sql
           # since those are managed by NewRelic::Agent.disable_* calls explicitly
           # and (more importantly) outside the scope of a transaction
@@ -473,7 +464,7 @@ module NewRelic
         end
 
         # Current transaction stack
-        attr_reader :current_transaction
+        attr_accessor :current_transaction
 
         # Execution tracing on current thread
         attr_accessor :untraced

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

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/range_extensions'
 require 'new_relic/agent/guid_generator'
@@ -9,9 +9,9 @@ module NewRelic
   module Agent
     class Transaction
       class AbstractSegment
-        # This class is the base class for all segments. It is reponsible for
+        # This class is the base class for all segments. It is responsible for
         # timing, naming, and defining lifecycle callbacks. One of the more
-        # complex responsibilites of this class is computing exclusive duration.
+        # complex responsibilities 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
@@ -20,13 +20,14 @@ module NewRelic
         # after its parent. We will use the optimized exclusive duration
         # calculation in all other cases.
         #
-        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid
+        attr_reader :start_time, :end_time, :duration, :exclusive_duration, :guid, :starting_thread_id
         attr_accessor :name, :parent, :children_time, :transaction, :transaction_name
         attr_writer :record_metrics, :record_scoped_metric, :record_on_finish
         attr_reader :noticed_error
 
-        def initialize name=nil, start_time=nil
+        def initialize(name = nil, start_time = nil)
           @name = name
+          @starting_thread_id = ::Thread.current.object_id
           @transaction_name = nil
           @transaction = nil
           @guid = NewRelic::Agent::GuidGenerator.generate_guid
@@ -36,8 +37,8 @@ module NewRelic
           @end_time = nil
           @duration = 0.0
           @exclusive_duration = 0.0
+          @children_timings = []
           @children_time = 0.0
-          @children_time_ranges = nil
           @active_children = 0
           @range_recorded = false
           @concurrent_children = false
@@ -45,22 +46,29 @@ module NewRelic
           @record_scoped_metric = true
           @record_on_finish = false
           @noticed_error = nil
+          @code_filepath = nil
+          @code_function = nil
+          @code_lineno = nil
+          @code_namespace = nil
         end
 
         def start
-          @start_time ||= Time.now
+          @start_time ||= Process.clock_gettime(Process::CLOCK_REALTIME)
           return unless transaction
-          parent.child_start self if parent
+
+          parent.child_start(self) if parent
         end
 
         def finish
-          @end_time = Time.now
-          @duration = end_time.to_f - start_time.to_f
+          @end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
+          @duration = end_time - start_time
+
           return unless transaction
+
           run_complete_callbacks
           finalize if record_on_finish?
         rescue => e
-          NewRelic::Agent.logger.error "Exception finishing segment: #{name}", e
+          NewRelic::Agent.logger.error("Exception finishing segment: #{name}", e)
         end
 
         def finished?
@@ -94,21 +102,71 @@ module NewRelic
         end
 
         def time_range
-          @start_time.to_f .. @end_time.to_f
+          @start_time.to_f..@end_time.to_f
+        end
+
+        def timings_overlap?(timing1, timing2)
+          (timing1.first >= timing2.first && timing1.first <= timing2.last) ||
+            (timing2.first >= timing1.first && timing2.first <= timing1.last)
         end
 
+        def merge_timings(timing1, timing2)
+          [(timing1.first < timing2.first ? timing1.first : timing2.first),
+            (timing1.last > timing2.last ? timing1.last : timing2.last)]
+        end
+
+        # @children_timings is an array of array, with each inner array
+        # holding exactly 2 values, a child segment's start time and finish
+        # time (in that order). When it's time to record, these timings are
+        # converted into an array of range objects (using the same start and
+        # end values as the original array). Any two range objects that
+        # intersect and merged into a larger range. This checking for a
+        # intersections and merging of ranges is expensive, so the operation
+        # is only done at recording time.
         def children_time_ranges
-          @children_time_ranges ||= []
+          @children_time_ranges ||= begin
+            overlapped = @children_timings.each_with_object([]) do |timing, timings|
+              i = timings.index { |t| timings_overlap?(t, timing) }
+              if i
+                timings[i] = merge_timings(timing, timings[i])
+              else
+                timings << timing
+              end
+            end
+            overlapped.map { |t| Range.new(t.first, t.last) }
+          end
         end
 
         def children_time_ranges?
-          !!@children_time_ranges
+          !@children_timings.empty?
         end
 
         def concurrent_children?
           @concurrent_children
         end
 
+        def code_information=(info = {})
+          return unless info[:filepath]
+
+          @code_filepath = info[:filepath]
+          @code_function = info[:function]
+          @code_lineno = info[:lineno]
+          @code_namespace = info[:namespace]
+        end
+
+        def all_code_information_present?
+          @code_filepath && @code_function && @code_lineno && @code_namespace
+        end
+
+        def code_attributes
+          return ::NewRelic::EMPTY_HASH unless all_code_information_present?
+
+          @code_attributes ||= {'code.filepath' => @code_filepath,
+                                'code.function' => @code_function,
+                                'code.lineno' => @code_lineno,
+                                'code.namespace' => @code_namespace}
+        end
+
         INSPECT_IGNORE = [:@transaction, :@transaction_state].freeze
 
         def inspect
@@ -122,27 +180,30 @@ module NewRelic
         def transaction_assigned
         end
 
-        def set_noticed_error noticed_error
+        def set_noticed_error(noticed_error)
           if @noticed_error
-            NewRelic::Agent.logger.debug \
+            NewRelic::Agent.logger.debug( \
               "Segment: #{name} overwriting previously noticed " \
               "error: #{@noticed_error.inspect} with: #{noticed_error.inspect}"
+            )
           end
           @noticed_error = noticed_error
         end
 
-        def notice_error exception, options={}
+        def notice_error(exception, options = {})
           if Agent.config[:high_security]
-            NewRelic::Agent.logger.debug \
+            NewRelic::Agent.logger.debug( \
               "Segment: #{name} ignores notice_error for " \
               "error: #{exception.inspect} because :high_security is enabled"
+            )
           else
-            NewRelic::Agent.instance.error_collector.notice_segment_error self, exception, options
+            NewRelic::Agent.instance.error_collector.notice_segment_error(self, exception, options)
           end
         end
 
         def noticed_error_attributes
           return unless @noticed_error
+
           @noticed_error.attributes_from_notice_error
         end
 
@@ -154,16 +215,16 @@ module NewRelic
           @range_recorded
         end
 
-        def child_start segment
+        def child_start(segment)
           @active_children += 1
-          @concurrent_children = @concurrent_children || @active_children > 1
+          @concurrent_children ||= @active_children > 1
 
           transaction.async = true if @concurrent_children
         end
 
-        def child_complete segment
+        def child_complete(segment)
           @active_children -= 1
-          record_child_time segment
+          record_child_time(segment)
 
           if finished?
             transaction.async = true
@@ -177,36 +238,39 @@ module NewRelic
         # 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)
+          add_child_timing(descendant)
 
-        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
+            record_child_time_as_range(child)
           end
 
           if parent && finished? && descendant.end_time >= end_time
-            parent.descendant_complete self, descendant
+            parent.descendant_complete(self, descendant)
           end
         end
 
         private
 
+        def add_child_timing(segment)
+          @children_timings << [segment.start_time, segment.end_time]
+        end
+
         def force_finish
           finish
-          NewRelic::Agent.logger.warn "Segment: #{name} was unfinished at " \
+          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."
+            "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
+          parent.child_complete(self) if parent
+          transaction.segment_complete(self)
         end
 
         def record_metrics
@@ -217,27 +281,26 @@ module NewRelic
         def segment_complete
         end
 
-        def record_child_time child
+        def record_child_time(child)
           if concurrent_children? || finished? && end_time < child.end_time
-            record_child_time_as_range child
+            record_child_time_as_range(child)
           else
-            record_child_time_as_number child
+            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
+        def record_child_time_as_range(child)
+          add_child_timing(child)
           child.range_recorded = true
         end
 
-        def record_child_time_as_number child
+        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
+            RangeExtensions.compute_overlap(time_range, children_time_ranges)
           else
             0.0
           end