newrelic_rpm 5.7.0.350 → 9.0.0

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

@@ -0,0 +1,168 @@
+# 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
+
+module NewRelic
+  module Agent
+    class Transaction
+      module TraceContext
+        include NewRelic::Coerce
+
+        module AccountHelpers
+          extend self
+
+          def trace_state_entry_key
+            @trace_state_entry_key ||= if Agent.config[:trusted_account_key]
+              "#{Agent.config[:trusted_account_key]}@nr".freeze
+            elsif Agent.config[:account_id]
+              "#{Agent.config[:account_id]}@nr".freeze
+            end
+          end
+        end
+
+        SUPPORTABILITY_PREFIX = "Supportability/TraceContext"
+        CREATE_PREFIX = "#{SUPPORTABILITY_PREFIX}/Create"
+        ACCEPT_PREFIX = "#{SUPPORTABILITY_PREFIX}/Accept"
+        TRACESTATE_PREFIX = "#{SUPPORTABILITY_PREFIX}/TraceState"
+
+        CREATE_SUCCESS_METRIC = "#{CREATE_PREFIX}/Success"
+        CREATE_EXCEPTION_METRIC = "#{CREATE_PREFIX}/Exception"
+
+        ACCEPT_SUCCESS_METRIC = "#{ACCEPT_PREFIX}/Success"
+        ACCEPT_EXCEPTION_METRIC = "#{ACCEPT_PREFIX}/Exception"
+        IGNORE_MULTIPLE_ACCEPT_METRIC = "#{ACCEPT_PREFIX}/Ignored/Multiple"
+        IGNORE_ACCEPT_AFTER_CREATE_METRIC = "#{ACCEPT_PREFIX}/Ignored/CreateBeforeAccept"
+
+        NO_NR_ENTRY_TRACESTATE_METRIC = "#{TRACESTATE_PREFIX}/NoNrEntry"
+        INVALID_TRACESTATE_PAYLOAD_METRIC = "#{TRACESTATE_PREFIX}/InvalidNrEntry"
+
+        attr_accessor :trace_context_header_data
+        attr_reader :trace_state_payload
+
+        def trace_parent_header_present?(request)
+          request[NewRelic::HTTP_TRACEPARENT_KEY]
+        end
+
+        def accept_trace_context_incoming_request(request)
+          header_data = NewRelic::Agent::DistributedTracing::TraceContext.parse(
+            format: NewRelic::FORMAT_RACK,
+            carrier: request,
+            trace_state_entry_key: AccountHelpers.trace_state_entry_key
+          )
+          return if header_data.nil?
+
+          accept_trace_context(header_data)
+        end
+        private :accept_trace_context_incoming_request
+
+        def insert_trace_context_header(header, format = NewRelic::FORMAT_NON_RACK)
+          return unless Agent.config[:'distributed_tracing.enabled']
+
+          NewRelic::Agent::DistributedTracing::TraceContext.insert( \
+            format: format,
+            carrier: header,
+            trace_id: transaction.trace_id.rjust(32, '0').downcase,
+            parent_id: transaction.current_segment.guid,
+            trace_flags: transaction.sampled? ? 0x1 : 0x0,
+            trace_state: create_trace_state
+          )
+
+          @trace_context_inserted = true
+
+          NewRelic::Agent.increment_metric(CREATE_SUCCESS_METRIC)
+          true
+        rescue Exception => e
+          NewRelic::Agent.increment_metric(CREATE_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn("Failed to create trace context payload", e)
+          false
+        end
+
+        def create_trace_state
+          entry_key = AccountHelpers.trace_state_entry_key.dup
+          payload = create_trace_state_payload
+
+          if payload
+            entry = NewRelic::Agent::DistributedTracing::TraceContext.create_trace_state_entry( \
+              entry_key,
+              payload.to_s
+            )
+          else
+            entry = NewRelic::EMPTY_STR
+          end
+
+          trace_context_header_data ? trace_context_header_data.trace_state(entry) : entry
+        end
+
+        def create_trace_state_payload
+          unless Agent.config[:'distributed_tracing.enabled']
+            NewRelic::Agent.logger.warn("Not configured to create WC3 trace context payload")
+            return
+          end
+
+          span_guid = Agent.config[:'span_events.enabled'] ? transaction.current_segment.guid : nil
+          transaction_guid = Agent.config[:'transaction_events.enabled'] ? transaction.guid : nil
+
+          TraceContextPayload.create( \
+            parent_account_id: Agent.config[:account_id],
+            parent_app_id: Agent.config[:primary_application_id],
+            transaction_id: transaction_guid,
+            sampled: transaction.sampled?,
+            priority: float!(transaction.priority, NewRelic::PRIORITY_PRECISION),
+            id: span_guid
+          )
+        end
+
+        def assign_trace_state_payload
+          payload = @trace_context_header_data.trace_state_payload
+          unless payload
+            NewRelic::Agent.increment_metric(NO_NR_ENTRY_TRACESTATE_METRIC)
+            return false
+          end
+          unless payload.valid?
+            NewRelic::Agent.increment_metric(INVALID_TRACESTATE_PAYLOAD_METRIC)
+            return false
+          end
+          @trace_state_payload = payload
+        end
+
+        def accept_trace_context(header_data)
+          return if ignore_trace_context?
+
+          @trace_context_header_data = header_data
+          transaction.trace_id = header_data.trace_id
+          transaction.parent_span_id = header_data.parent_id
+
+          return false unless payload = assign_trace_state_payload
+
+          transaction.distributed_tracer.parent_transaction_id = payload.transaction_id
+
+          unless payload.sampled.nil?
+            transaction.sampled = payload.sampled
+            transaction.priority = payload.priority if payload.priority
+          end
+          NewRelic::Agent.increment_metric(ACCEPT_SUCCESS_METRIC)
+          true
+        rescue => e
+          NewRelic::Agent.increment_metric(ACCEPT_EXCEPTION_METRIC)
+          NewRelic::Agent.logger.warn("Failed to accept trace context payload", e)
+          false
+        end
+
+        def ignore_trace_context?
+          if trace_context_header_data
+            NewRelic::Agent.increment_metric(IGNORE_MULTIPLE_ACCEPT_METRIC)
+            return true
+          elsif trace_context_inserted?
+            NewRelic::Agent.increment_metric(IGNORE_ACCEPT_AFTER_CREATE_METRIC)
+            return true
+          end
+          false
+        end
+
+        def trace_context_inserted?
+          @trace_context_inserted ||= false
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction/trace_node.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
 
 module NewRelic
   module Agent
@@ -17,15 +17,21 @@ module NewRelic
 
         UNKNOWN_NODE_NAME = '<unknown>'.freeze
 
-        def initialize(metric_name, relative_start, relative_end=nil, params=nil, parent=nil)
+        def initialize(metric_name, relative_start, relative_end = nil, params = nil, parent = nil)
           @entry_timestamp = relative_start
-          @metric_name     = metric_name || UNKNOWN_NODE_NAME
-          @exit_timestamp  = relative_end
-          @children        = nil
-          @params          = params.select do |p|
-            NewRelic::Agent.instance.attribute_filter.allows_key? p, AttributeFilter::DST_TRANSACTION_SEGMENTS
-          end if params
-          @parent_node     = parent
+          @metric_name = metric_name || UNKNOWN_NODE_NAME
+          @exit_timestamp = relative_end
+          @children = nil
+          @params = select_allowed_params(params)
+          @parent_node = parent
+        end
+
+        def select_allowed_params(params)
+          return unless params
+
+          params.select do |p|
+            NewRelic::Agent.instance.attribute_filter.allows_key?(p, AttributeFilter::DST_TRANSACTION_SEGMENTS)
+          end
         end
 
         # sets the final timestamp on a node to indicate the exit
@@ -38,47 +44,44 @@ module NewRelic
           to_debug_str(0)
         end
 
-        EMPTY_HASH = {}.freeze
-        EMPTY_ARRAY = [].freeze
-
         def to_array
-          params = @params ? @params : EMPTY_HASH
-          [ NewRelic::Helper.time_to_millis(@entry_timestamp),
+          params = @params || NewRelic::EMPTY_HASH
+          [NewRelic::Helper.time_to_millis(@entry_timestamp),
             NewRelic::Helper.time_to_millis(@exit_timestamp),
             NewRelic::Coerce.string(@metric_name),
-            params ] +
-            [ (@children ? @children.map{|s| s.to_array} : EMPTY_ARRAY) ]
+            params] +
+            [(@children ? @children.map { |s| s.to_array } : NewRelic::EMPTY_ARRAY)]
         end
 
         def path_string
-          "#{metric_name}[#{children.collect {|node| node.path_string }.join('')}]"
+          "#{metric_name}[#{children.collect { |node| node.path_string }.join('')}]"
         end
 
         def to_s_compact
-          str = ""
+          str = String.new('')
           str << metric_name
           if children.any?
-            str << "{#{children.map { | cs | cs.to_s_compact }.join(",")}}"
+            str << "{#{children.map { |cs| cs.to_s_compact }.join(',')}}"
           end
           str
         end
 
         def to_debug_str(depth)
-          tab = "  " * depth
+          tab = String.new('  ') * depth
           s = tab.clone
-          s << ">> #{'%3i ms' % (@entry_timestamp*1000)} [#{self.class.name.split("::").last}] #{metric_name} \n"
+          s << ">> #{'%3i ms' % (@entry_timestamp * 1000)} [#{self.class.name.split("::").last}] #{metric_name} \n"
           unless params.empty?
-            params.each do |k,v|
+            params.each do |k, v|
               s << "#{tab}    -#{'%-16s' % k}: #{v.to_s[0..80]}\n"
             end
           end
           children.each do |cs|
             s << cs.to_debug_str(depth + 1)
           end
-          s << tab + "<< "
+          s << tab + '<< '
           s << case @exit_timestamp
           when nil then ' n/a'
-          when Numeric then '%3i ms' % (@exit_timestamp*1000)
+          when Numeric then '%3i ms' % (@exit_timestamp * 1000)
           else @exit_timestamp.to_s
           end
           s << " #{metric_name}\n"
@@ -108,7 +111,7 @@ module NewRelic
 
         def count_nodes
           count = 1
-          children.each { | node | count  += node.count_nodes }
+          children.each { |node| count += node.count_nodes }
           count
         end
 
@@ -131,7 +134,7 @@ module NewRelic
         # call the provided block for this node and each
         # of the called nodes
         def each_node(&block)
-          block.call self
+          yield(self)
 
           if @children
             @children.each do |node|
@@ -143,7 +146,7 @@ module NewRelic
         # call the provided block for this node and each
         # of the called nodes while keeping track of nested nodes
         def each_node_with_nest_tracking(&block)
-          summary = block.call self
+          summary = yield(self)
           summary.current_nest_count += 1 if summary
 
           if @children

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

@@ -1,112 +1,12 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'new_relic/agent/transaction/segment'
-require 'new_relic/agent/transaction/datastore_segment'
-require 'new_relic/agent/transaction/external_request_segment'
-require 'new_relic/agent/transaction/message_broker_segment'
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     class Transaction
       module Tracing
-        module ClassMethods
-          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,
-                                      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, parent
-          end
-
-          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
-          #
-          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?
-
-            segment = MessageBrokerSegment.new(
-              action: action,
-              library: library,
-              destination_type: destination_type,
-              destination_name: destination_name,
-              headers: headers,
-              parameters: parameters,
-              start_time: start_time
-            )
-            start_and_add_segment segment, parent
-          end
-
-          private
-
-          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, parent
-            else
-              segment.record_metrics = false
-            end
-            segment.start
-            segment
-          end
-        end
-
-        def self.included base
-          base.extend ClassMethods
-        end
-
-        attr_reader :current_segment
+        attr_reader :current_segment_by_thread
 
         def async?
           @async ||= false
@@ -120,10 +20,10 @@ module NewRelic
 
         attr_writer :total_time
 
-        def add_segment segment, parent = nil
+        def add_segment(segment, parent = nil)
           segment.transaction = self
           segment.parent = parent || current_segment
-          @current_segment = segment
+          set_current_segment(segment)
           if @segments.length < segment_limit
             @segments << segment
           else
@@ -133,8 +33,13 @@ module NewRelic
           segment.transaction_assigned
         end
 
-        def segment_complete segment
-          @current_segment = segment.parent
+        def segment_complete(segment)
+          # if parent was in another thread, remove the current_segment entry for this thread
+          if segment.parent && segment.parent.starting_segment_key != NewRelic::Agent::Tracer.current_segment_key
+            remove_current_segment_by_thread_id(NewRelic::Agent::Tracer.current_segment_key)
+          else
+            set_current_segment(segment.parent)
+          end
         end
 
         def segment_limit
@@ -147,8 +52,7 @@ module NewRelic
           segments.each { |s| s.finalize }
         end
 
-
-        WEB_TRANSACTION_TOTAL_TIME   = "WebTransactionTotalTime".freeze
+        WEB_TRANSACTION_TOTAL_TIME = "WebTransactionTotalTime".freeze
         OTHER_TRANSACTION_TOTAL_TIME = "OtherTransactionTotalTime".freeze
 
         def record_total_time_metrics
@@ -158,8 +62,8 @@ module NewRelic
             OTHER_TRANSACTION_TOTAL_TIME
           end
 
-          @metrics.record_unscoped total_time_metric, total_time
-          @metrics.record_unscoped "#{total_time_metric}/#{@frozen_name}", total_time
+          @metrics.record_unscoped(total_time_metric, total_time)
+          @metrics.record_unscoped("#{total_time_metric}/#{@frozen_name}", total_time)
         end
       end
     end

data/lib/new_relic/agent/transaction/transaction_sample_buffer.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
 
 module NewRelic
   module Agent
@@ -9,7 +9,6 @@ module NewRelic
         attr_reader :samples
 
         SINGLE_BUFFER_MAX = 20
-        NO_SAMPLES = [].freeze
 
         def initialize
           @samples = []
@@ -35,6 +34,7 @@ module NewRelic
 
         def store(sample)
           return unless enabled?
+
           if allow_sample?(sample)
             add_sample(sample)
             truncate_samples_if_needed
@@ -43,6 +43,7 @@ module NewRelic
 
         def store_previous(previous_samples)
           return unless enabled?
+
           previous_samples.each do |sample|
             add_sample(sample) if allow_sample?(sample)
           end
@@ -71,7 +72,7 @@ module NewRelic
         # A typical buffer should NOT override this method (although we do for
         # odd things like dev-mode)
         def max_capacity
-          capacity > SINGLE_BUFFER_MAX ? SINGLE_BUFFER_MAX : capacity
+          [capacity, SINGLE_BUFFER_MAX].min
         end
 
         # Our default truncation strategy is to keep max_capacity
@@ -81,7 +82,7 @@ module NewRelic
         # This doesn't use the more convenient #last and #sort_by to avoid
         # additional array allocations (and abundant alliteration)
         def truncate_samples
-          @samples.sort!{|a,b| a.duration <=> b.duration}
+          @samples.sort! { |a, b| a.duration <=> b.duration }
           @samples.slice!(0..-(max_capacity + 1))
         end
 
@@ -98,7 +99,6 @@ module NewRelic
         def add_sample(sample)
           @samples << sample
         end
-
       end
     end
   end