newrelic_rpm 6.2.0.354 → 6.15.0

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

@@ -0,0 +1,126 @@
+# 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.
+
+require 'new_relic/coerce'
+
+module NewRelic
+  module Agent
+    class TraceContextPayload
+      VERSION = 0
+      PARENT_TYPE = 0
+      DELIMITER = "-".freeze
+      SUPPORTABILITY_PARSE_EXCEPTION = "Supportability/TraceContext/Parse/Exception".freeze
+
+      TRUE_CHAR = '1'.freeze
+      FALSE_CHAR = '0'.freeze
+
+      PARENT_TYPES = %w(App Browser Mobile).map(&:freeze).freeze
+
+      class << self
+        def create version: VERSION,
+                   parent_type: PARENT_TYPE,
+                   parent_account_id: nil,
+                   parent_app_id: nil,
+                   id: nil,
+                   transaction_id: nil,
+                   sampled: nil,
+                   priority: nil,
+                   timestamp: now_ms
+
+          new version, parent_type, parent_account_id, parent_app_id, id,
+              transaction_id, sampled, priority, timestamp
+        end
+
+        include NewRelic::Coerce
+
+        def from_s payload_string
+          attrs = payload_string.split(DELIMITER)
+
+          payload = create \
+            version: int!(attrs[0]),
+            parent_type: int!(attrs[1]),
+            parent_account_id: attrs[2],
+            parent_app_id: attrs[3],
+            id: value_or_nil(attrs[4]),
+            transaction_id: value_or_nil(attrs[5]),
+            sampled: value_or_nil(attrs[6]) ? boolean_int!(attrs[6]) == 1 : nil,
+            priority: float!(attrs[7]),
+            timestamp: int!(attrs[8])
+          handle_invalid_payload message: 'payload missing attributes' unless payload.valid?
+          payload
+        rescue => e
+          handle_invalid_payload error: e
+          raise
+        end
+
+        private
+
+        def now_ms
+          (Time.now.to_f * 1000).round
+        end
+
+        def handle_invalid_payload error: nil, message: nil
+          NewRelic::Agent.increment_metric SUPPORTABILITY_PARSE_EXCEPTION
+          if error
+            NewRelic::Agent.logger.warn "Error parsing trace context payload", error
+          elsif message
+            NewRelic::Agent.logger.warn "Error parsing trace context payload: #{message}"
+          end
+        end
+      end
+
+      attr_accessor :version,
+                    :parent_type_id,
+                    :parent_account_id,
+                    :parent_app_id,
+                    :id,
+                    :transaction_id,
+                    :sampled,
+                    :priority,
+                    :timestamp
+
+      alias_method :sampled?, :sampled
+
+      def initialize version, parent_type_id, parent_account_id, parent_app_id,
+                     id, transaction_id, sampled, priority, timestamp
+        @version = version
+        @parent_type_id = parent_type_id
+        @parent_account_id = parent_account_id
+        @parent_app_id = parent_app_id
+        @id = id
+        @transaction_id = transaction_id
+        @sampled = sampled
+        @priority = priority
+        @timestamp = timestamp
+      end
+
+      def parent_type
+        @parent_type_string ||= PARENT_TYPES[@parent_type_id]
+      end
+
+      def valid?
+        version \
+          && parent_type_id \
+          && !parent_account_id.empty? \
+          && !parent_app_id.empty? \
+          && timestamp
+      rescue
+        false
+      end
+
+      def to_s
+        result = version.to_s
+        result << DELIMITER << parent_type_id.to_s
+        result << DELIMITER << parent_account_id
+        result << DELIMITER << parent_app_id
+        result << DELIMITER << (id || NewRelic::EMPTY_STR)
+        result << DELIMITER << (transaction_id || NewRelic::EMPTY_STR)
+        result << DELIMITER << (sampled ? TRUE_CHAR : FALSE_CHAR)
+        result << DELIMITER << sprintf("%.6f", priority)
+        result << DELIMITER << timestamp.to_s
+        result
+      end
+    end
+  end
+end

data/lib/new_relic/agent/distributed_tracing.rb

@@ -1,8 +1,15 @@
 # encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
-require 'new_relic/agent/distributed_trace_payload'
+require_relative 'distributed_tracing/cross_app_payload'
+require_relative 'distributed_tracing/cross_app_tracing'
+
+require_relative 'distributed_tracing/distributed_trace_transport_type'
+require_relative 'distributed_tracing/distributed_trace_payload'
+
+require_relative 'distributed_tracing/trace_context'
 
 module NewRelic
   module Agent
@@ -14,8 +21,9 @@ module NewRelic
     #
     # @api public
     module DistributedTracing
+      extend NewRelic::SupportabilityHelper
       extend self
-
+      
       # Create a payload object containing the current transaction's
       # tracing properties (e.g., duration, priority).  You can use
       # this object to generate headers to inject into a network
@@ -27,10 +35,19 @@ module NewRelic
       #                                   could not create the payload
       #
       # @api public
+      #
+      # @deprecated See {#create_distributed_trace_headers} instead.
+      #
       def create_distributed_trace_payload
-        if transaction = Transaction.tl_current
-          transaction.create_distributed_trace_payload
+        Deprecator.deprecate :create_distributed_trace_payload, :create_distributed_trace_headers
+
+        unless Agent.config[:'distributed_tracing.enabled']
+          NewRelic::Agent.logger.warn "Not configured to create New Relic distributed trace payload"
+          return nil
         end
+
+        return unless transaction = Transaction.tl_current
+        transaction.distributed_tracer.create_distributed_trace_payload
       rescue => e
         NewRelic::Agent.logger.error 'error during create_distributed_trace_payload', e
         nil
@@ -53,15 +70,147 @@ module NewRelic
       # @return nil
       #
       # @api public
+      #
+      # @deprecated See {#accept_distributed_trace_headers} instead
+      #
       def accept_distributed_trace_payload payload
-        if transaction = Transaction.tl_current
-          transaction.accept_distributed_trace_payload(payload)
+        Deprecator.deprecate :accept_distributed_trace_payload, :accept_distributed_trace_headers
+
+        unless Agent.config[:'distributed_tracing.enabled']
+          NewRelic::Agent.logger.warn "Not configured to accept New Relic distributed trace payload"
+          return nil
         end
+
+        return unless transaction = Transaction.tl_current
+        transaction.distributed_tracer.accept_distributed_trace_payload(payload)
         nil
       rescue => e
         NewRelic::Agent.logger.error 'error during accept_distributed_trace_payload', e
         nil
       end
+
+
+      # Adds the Distributed Trace headers so that the downstream service can participate in a
+      # distributed trace. This method should be called every time an outbound call is made
+      # since the header payload contains a timestamp.
+      #
+      # Distributed Tracing must be enabled to use this method.
+      #
+      # +insert_distributed_trace_headers+ always inserts W3C trace context headers and inserts
+      # New Relic distributed tracing header by default. New Relic headers may be suppressed by
+      # setting +exclude_new_relic_header+ to +true+ in your configuration file.
+      #
+      # @param headers           [Hash]     Is a Hash to which the distributed trace headers 
+      #                                     will be inserted.
+      #
+      # @return           {Transaction}     The transaction the headers were inserted from,
+      #                                     or +nil+ if headers were not inserted.
+      #
+      # @api public
+      #
+      def insert_distributed_trace_headers headers={}
+        record_api_supportability_metric(:insert_distributed_trace_headers)
+
+        unless Agent.config[:'distributed_tracing.enabled']
+          NewRelic::Agent.logger.warn "Not configured to insert distributed trace headers"
+          return nil
+        end
+
+        return unless valid_api_argument_class? headers, "headers", Hash
+
+        return unless transaction = Transaction.tl_current
+
+        transaction.distributed_tracer.insert_headers headers
+        transaction
+      rescue => e
+        NewRelic::Agent.logger.error 'error during insert_distributed_trace_headers', e
+        nil
+      end
+
+      # Accepts distributed tracing headers from any source that has been packaged 
+      # as a Ruby Hash, thereby allowing the user to manually inject distributed
+      # tracing headers.  It is optimized to process +HTTP_TRACEPARENT+, +HTTP_TRACESTATE+, 
+      # and +HTTP_NEWRELIC+ as the given Hash keys.  which is the most common scenario 
+      # from Rack middleware in most Ruby applications.  However, the Hash keys are 
+      # case-insensitive and the "HTTP_" prefixes may also be omitted.
+      #
+      # Calling this method is not necessary in a typical HTTP trace as
+      # distributed tracing is already handled by the agent.
+      #
+      # When used, invoke this method as early as possible in a transaction's life-cycle
+      # as calling after the headers are already created will have no effect.
+      #
+      # This method accepts both W3C trace context and New Relic distributed tracing headers.
+      # When both are present, only the W3C headers are utilized.  When W3C trace context 
+      # headers are present, New Relic headers are ignored regardless if W3C trace context
+      # headers are valid and parsable.  
+      #
+      # @param headers         [Hash]     Incoming distributed trace headers as a Ruby 
+      #                                   Hash object.  Hash keys are expected to be one of
+      #                                   +TRACEPARENT+, +TRACESTATE+, +NEWRELIC+ and are 
+      #                                   case-insensitive, with or without "HTTP_" prefixes.
+      #
+      #                                   either as a JSON string or as a
+      #                                   header-friendly string returned from
+      #                                   {DistributedTracePayload#http_safe}
+      #
+      # @param transport_Type  [String]   May be one of:  +HTTP+, +HTTPS+, +Kafka+, +JMS+,
+      #                                   +IronMQ+, +AMQP+, +Queue+, +Other+.  Values are
+      #                                   case sensitive.  All other values result in +Unknown+
+      #
+      # @return {Transaction} if successful, +nil+ otherwise
+      #
+      # @api public
+      #
+      def accept_distributed_trace_headers headers, transport_type = NewRelic::HTTP
+        record_api_supportability_metric(:accept_distributed_trace_headers)
+
+        unless Agent.config[:'distributed_tracing.enabled']
+          NewRelic::Agent.logger.warn "Not configured to accept distributed trace headers"
+          return nil
+        end
+
+        return unless valid_api_argument_class? headers, "headers", Hash
+        return unless valid_api_argument_class? transport_type, "transport_type", String
+
+        return unless transaction = Transaction.tl_current
+
+        # assume we have Rack conforming keys when transport_type is HTTP(S)
+        # otherwise, fish for key/value pairs regardless of prefix and case-sensitivity.
+        hdr = if transport_type.start_with? NewRelic::HTTP
+          headers
+        else 
+          # start with the most common case first
+          hdr = {
+            NewRelic::HTTP_TRACEPARENT_KEY => headers[NewRelic::TRACEPARENT_KEY],
+            NewRelic::HTTP_TRACESTATE_KEY => headers[NewRelic::TRACESTATE_KEY], 
+            NewRelic::HTTP_NEWRELIC_KEY => headers[NewRelic::NEWRELIC_KEY]
+          } 
+          
+          # when not found, search for any casing for trace context headers, ignoring potential prefixes
+          hdr[NewRelic::HTTP_TRACEPARENT_KEY] ||= variant_key_value headers, NewRelic::TRACEPARENT_KEY
+          hdr[NewRelic::HTTP_TRACESTATE_KEY] ||= variant_key_value headers, NewRelic::TRACESTATE_KEY
+          hdr[NewRelic::HTTP_NEWRELIC_KEY] ||= variant_key_value headers, NewRelic::CANDIDATE_NEWRELIC_KEYS
+          hdr
+        end
+
+        transaction.distributed_tracer.accept_incoming_request hdr, transport_type
+        transaction
+      rescue => e
+        NewRelic::Agent.logger.error 'error during accept_distributed_trace_headers', e
+        nil
+      end
+    
+      private
+
+      def has_variant_key? key, variants
+        key.to_s.downcase.end_with?(*Array(variants))
+      end
+
+      def variant_key_value headers, variants
+        (headers.detect{|k, v| has_variant_key?(k, variants)} || NewRelic::EMPTY_ARRAY)[1]
+      end
+
     end
   end
 end

data/lib/new_relic/agent/encoding_normalizer.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.
 
 # This module was extracted from NewRelic::JSONWrapper
 

data/lib/new_relic/agent/error_collector.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.
 require 'new_relic/agent/error_trace_aggregator'
 require 'new_relic/agent/error_event_aggregator'
 
@@ -18,9 +18,9 @@ module NewRelic
       attr_reader :error_trace_aggregator, :error_event_aggregator
 
       # Returns a new error collector
-      def initialize
+      def initialize events
         @error_trace_aggregator = ErrorTraceAggregator.new(MAX_ERROR_QUEUE_LENGTH)
-        @error_event_aggregator = ErrorEventAggregator.new
+        @error_event_aggregator = ErrorEventAggregator.new events
 
         # lookup of exception class names to ignore.  Hash for fast access
         @ignore = {}
@@ -32,7 +32,6 @@ module NewRelic
         end
       end
 
-
       def initialize_ignored_errors(ignore_errors)
         @ignore.clear
         ignore_errors = ignore_errors.split(",") if ignore_errors.is_a? String
@@ -74,7 +73,7 @@ module NewRelic
       end
 
       def self.ignore_error_filter
-        @ignore_filter
+        defined?(@ignore_filter) ? @ignore_filter : nil
       end
 
       # errors is an array of Exception Class Names
@@ -117,14 +116,22 @@ module NewRelic
         NewRelic::LanguageSupport.jruby? && exception.respond_to?(:java_class)
       end
 
-      def exception_tagged?(exception)
+      def exception_tagged_with?(ivar, exception)
         return false if exception_is_java_object?(exception)
-        exception.instance_variable_defined?(EXCEPTION_TAG_IVAR)
+        exception.instance_variable_defined?(ivar)
+      end
+
+      def tag_exception_using(ivar, exception)
+        return if exception_is_java_object?(exception) || exception.frozen?
+        begin
+          exception.instance_variable_set(ivar, true)
+        rescue => e
+          NewRelic::Agent.logger.warn("Failed to tag exception: #{exception}: ", e)
+        end
       end
 
       def tag_exception(exception)
-        return if exception_is_java_object?(exception)
-        return if exception.frozen?
+        return if exception_is_java_object?(exception) || exception.frozen?
         begin
           exception.instance_variable_set(EXCEPTION_TAG_IVAR, true)
         rescue => e
@@ -169,9 +176,9 @@ module NewRelic
 
       def skip_notice_error?(exception)
         disabled? ||
-          error_is_ignored?(exception) ||
-          exception.nil? ||
-          exception_tagged?(exception)
+        error_is_ignored?(exception) ||
+        exception.nil? ||
+        exception_tagged_with?(EXCEPTION_TAG_IVAR, exception)
       end
 
       # calls a method on an object, if it responds to it - used for
@@ -191,8 +198,18 @@ module NewRelic
         sense_method(actual_exception, :backtrace) || '<no stack trace>'
       end
 
+      def notice_segment_error(segment, exception, options={})
+        return if skip_notice_error?(exception)
+
+        segment.set_noticed_error create_noticed_error(exception, options)
+        exception
+      rescue => e
+        ::NewRelic::Agent.logger.warn("Failure when capturing segment error '#{exception}':", e)
+        nil
+      end
+
       # See NewRelic::Agent.notice_error for options and commentary
-      def notice_error(exception, options={}) #THREAD_LOCAL_ACCESS
+      def notice_error(exception, options={}, span_id=nil)
         return if skip_notice_error?(exception)
 
         tag_exception(exception)
@@ -205,8 +222,10 @@ module NewRelic
 
         noticed_error = create_noticed_error(exception, options)
         error_trace_aggregator.add_to_error_queue(noticed_error)
-        payload = state.current_transaction ? state.current_transaction.payload : nil
-        error_event_aggregator.record(noticed_error, payload)
+        transaction = state.current_transaction
+        payload = transaction ? transaction.payload : nil
+        span_id ||= (transaction && transaction.current_segment) ? transaction.current_segment.guid : nil
+        error_event_aggregator.record(noticed_error, payload, span_id)
         exception
       rescue => e
         ::NewRelic::Agent.logger.warn("Failure when capturing error '#{exception}':", e)
@@ -227,13 +246,11 @@ module NewRelic
         truncated_trace
       end
 
-      EMPTY_STRING = ''.freeze
-
       def create_noticed_error(exception, options)
-        error_metric = options.delete(:metric) || EMPTY_STRING
+        error_metric = options.delete(:metric) || NewRelic::EMPTY_STR
 
         noticed_error = NewRelic::NoticedError.new(error_metric, exception)
-        noticed_error.request_uri = options.delete(:uri) || EMPTY_STRING
+        noticed_error.request_uri = options.delete(:uri) || NewRelic::EMPTY_STR
         noticed_error.request_port = options.delete(:port)
         noticed_error.attributes  = options.delete(:attributes)