newrelic_rpm 5.7.0.350 → 9.0.0

data/lib/new_relic/agent/distributed_tracing.rb

@@ -1,8 +1,14 @@
-# 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,54 +20,129 @@ 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
-      # request, so that the downstream service can participate in a
-      # distributed trace.
+      # 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.
       #
-      # @return [DistributedTracePayload] Payload for the current
-      #                                   transaction, or +nil+ if we
-      #                                   could not create the payload
+      # @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 create_distributed_trace_payload
-        if transaction = Transaction.tl_current
-          transaction.create_distributed_trace_payload
+      #
+      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 create_distributed_trace_payload', e
+        NewRelic::Agent.logger.error('error during insert_distributed_trace_headers', e)
         nil
       end
 
-      # Decode a JSON string containing distributed trace properties
-      # (e.g., calling application, priority) and apply them to the
-      # current transaction.  You can use it to receive distributed
-      # tracing information protocols the agent does not already
-      # support.
+      # 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.
       #
-      # This method will fail if you call it after calling
-      # {#create_distributed_trace_payload}.
+      #                                   either as a JSON string or as a
+      #                                   header-friendly string returned from
+      #                                   {DistributedTracePayload#http_safe}
       #
-      # @param payload [String] Incoming distributed trace payload,
-      #                         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 nil
+      # @return {Transaction} if successful, +nil+ otherwise
       #
       # @api public
-      def accept_distributed_trace_payload payload
-        if transaction = Transaction.tl_current
-          transaction.accept_distributed_trace_payload(payload)
+      #
+      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
-        nil
+
+        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_payload', 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.
+# frozen_string_literal: true
 
 # This module was extracted from NewRelic::JSONWrapper
 
@@ -19,12 +19,14 @@ module NewRelic
           normalize_string(object.to_s)
         when Array
           return object if object.empty?
+
           object.map { |x| normalize_object(x) }
         when Hash
           return object if object.empty?
+
           hash = {}
           object.each_pair do |k, v|
-            k = normalize_string(k)      if k.is_a?(String)
+            k = normalize_string(k) if k.is_a?(String)
             k = normalize_string(k.to_s) if k.is_a?(Symbol)
             hash[k] = normalize_object(v)
           end

data/lib/new_relic/agent/error_collector.rb

@@ -1,6 +1,7 @@
-# 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/error_trace_aggregator'
 require 'new_relic/agent/error_event_aggregator'
 
@@ -18,28 +19,22 @@ 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
-
-        # lookup of exception class names to ignore.  Hash for fast access
-        @ignore = {}
+        @error_event_aggregator = ErrorEventAggregator.new(events)
 
-        initialize_ignored_errors(Agent.config[:'error_collector.ignore_errors'])
+        @error_filter = NewRelic::Agent::ErrorFilter.new
 
-        Agent.config.register_callback(:'error_collector.ignore_errors') do |ignore_errors|
-          initialize_ignored_errors(ignore_errors)
+        %w[
+          ignore_classes ignore_messages ignore_status_codes
+          expected_classes expected_messages expected_status_codes
+        ].each do |w|
+          Agent.config.register_callback(:"error_collector.#{w}") do |value|
+            @error_filter.load_from_config(w, value)
+          end
         end
       end
 
-
-      def initialize_ignored_errors(ignore_errors)
-        @ignore.clear
-        ignore_errors = ignore_errors.split(",") if ignore_errors.is_a? String
-        ignore_errors.each { |error| error.strip! }
-        ignore(ignore_errors)
-      end
-
       def enabled?
         error_trace_aggregator.enabled? || error_event_aggregator.enabled?
       end
@@ -68,39 +63,48 @@ module NewRelic
         if block
           define_method(:ignore_filter_proc, &block)
         elsif method_defined?(:ignore_filter_proc)
-          remove_method :ignore_filter_proc
+          remove_method(:ignore_filter_proc)
         end
         @ignore_filter
       end
 
       def self.ignore_error_filter
-        @ignore_filter
+        defined?(@ignore_filter) ? @ignore_filter : nil
       end
 
-      # errors is an array of Exception Class Names
-      #
       def ignore(errors)
-        errors.each do |error|
-          @ignore[error] = true
-          ::NewRelic::Agent.logger.debug("Ignoring errors of type '#{error}'")
-        end
+        @error_filter.ignore(errors)
+      end
+
+      def ignore?(ex, status_code = nil)
+        @error_filter.ignore?(ex, status_code)
+      end
+
+      def expect(errors)
+        @error_filter.expect(errors)
+      end
+
+      def expected?(ex, status_code = nil)
+        @error_filter.expected?(ex, status_code)
+      end
+
+      def load_error_filters
+        @error_filter.load_all
+      end
+
+      def reset_error_filters
+        @error_filter.reset
       end
 
       # Checks the provided error against the error filter, if there
       # is an error filter
-      def filtered_by_error_filter?(error)
+      def ignored_by_filter_proc?(error)
         respond_to?(:ignore_filter_proc) && !ignore_filter_proc(error)
       end
 
-      # Checks the array of error names and the error filter against
-      # the provided error
-      def filtered_error?(error)
-        @ignore[error.class.name] || filtered_by_error_filter?(error)
-      end
-
       # an error is ignored if it is nil or if it is filtered
-      def error_is_ignored?(error)
-        error && filtered_error?(error)
+      def error_is_ignored?(error, status_code = nil)
+        error && (@error_filter.ignore?(error, status_code) || ignored_by_filter_proc?(error))
       rescue => e
         NewRelic::Agent.logger.error("Error '#{error}' will NOT be ignored. Exception '#{e}' while determining whether to ignore or not.", e)
         false
@@ -117,14 +121,25 @@ 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
@@ -154,10 +169,10 @@ module NewRelic
       end
 
       # Increments a statistic that tracks total error rate
-      def increment_error_count!(state, exception, options={})
+      def increment_error_count!(state, exception, options = {})
         txn = state.current_transaction
 
-        metric_names  = aggregated_metric_names(txn)
+        metric_names = aggregated_metric_names(txn)
         blamed_metric = blamed_metric_name(txn, options)
         metric_names << blamed_metric if blamed_metric
 
@@ -167,11 +182,18 @@ module NewRelic
         end
       end
 
-      def skip_notice_error?(exception)
+      def increment_expected_error_count!(state, exception)
+        stats_engine = NewRelic::Agent.agent.stats_engine
+        stats_engine.record_unscoped_metrics(state, ['ErrorsExpected/all']) do |stats|
+          stats.increment_count
+        end
+      end
+
+      def skip_notice_error?(exception, status_code = nil)
         disabled? ||
-          error_is_ignored?(exception) ||
           exception.nil? ||
-          exception_tagged?(exception)
+          exception_tagged_with?(EXCEPTION_TAG_IVAR, exception) ||
+          error_is_ignored?(exception, status_code)
       end
 
       # calls a method on an object, if it responds to it - used for
@@ -184,36 +206,52 @@ module NewRelic
       # extracts a stack trace from the exception for debugging purposes
       def extract_stack_trace(exception)
         actual_exception = if defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR < 5
-                             sense_method(exception, :original_exception) || exception
-                           else
-                             exception
-                           end
+          sense_method(exception, :original_exception) || exception
+        else
+          exception
+        end
         sense_method(actual_exception, :backtrace) || '<no stack trace>'
       end
 
-      # See NewRelic::Agent.notice_error for options and commentary
-      def notice_error(exception, options={}) #THREAD_LOCAL_ACCESS
+      def notice_segment_error(segment, exception, options = {})
         return if skip_notice_error?(exception)
 
-        tag_exception(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
 
-        state = ::NewRelic::Agent::TransactionState.tl_get
+      # See NewRelic::Agent.notice_error for options and commentary
+      def notice_error(exception, options = {}, span_id = nil)
+        state = ::NewRelic::Agent::Tracer.state
+        transaction = state.current_transaction
+        status_code = transaction ? transaction.http_response_code : nil
+
+        return if skip_notice_error?(exception, status_code)
+
+        tag_exception(exception)
 
-        unless options[:expected]
+        if options[:expected] || @error_filter.expected?(exception, status_code)
+          increment_expected_error_count!(state, exception)
+        else
           increment_error_count!(state, exception, options)
         end
 
         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)
         nil
       end
 
-      def truncate_trace(trace, keep_frames=nil)
+      def truncate_trace(trace, keep_frames = nil)
         keep_frames ||= Agent.config[:'error_collector.max_backtrace_frames']
         return trace if !keep_frames || trace.length < keep_frames || trace.length == 0
 
@@ -227,21 +265,19 @@ 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)
+        noticed_error.attributes = options.delete(:attributes)
 
-        noticed_error.file_name   = sense_method(exception, :file_name)
+        noticed_error.file_name = sense_method(exception, :file_name)
         noticed_error.line_number = sense_method(exception, :line_number)
         noticed_error.stack_trace = truncate_trace(extract_stack_trace(exception))
 
-        noticed_error.expected = !! options.delete(:expected)
+        noticed_error.expected = !!options.delete(:expected) || expected?(exception)
 
         noticed_error.attributes_from_notice_error = options.delete(:custom_params) || {}
 

data/lib/new_relic/agent/error_event_aggregator.rb

@@ -1,7 +1,7 @@
 # -*- ruby -*-
-# 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/event_aggregator'
 require 'new_relic/agent/transaction_error_primitive'
@@ -10,20 +10,22 @@ require 'new_relic/agent/priority_sampled_buffer'
 module NewRelic
   module Agent
     class ErrorEventAggregator < EventAggregator
+      include NewRelic::Coerce
 
       named :ErrorEventAggregator
       capacity_key :'error_collector.max_event_samples_stored'
-      enabled_key :'error_collector.capture_events'
+      enabled_keys :'error_collector.enabled',
+        :'error_collector.capture_events'
       buffer_class PrioritySampledBuffer
 
-      def record noticed_error, transaction_payload = nil
+      def record(noticed_error, transaction_payload = nil, span_id = nil)
         return unless enabled?
 
-        priority = (transaction_payload && transaction_payload[:priority]) || rand.round(6)
+        priority = float!((transaction_payload && transaction_payload[:priority]) || rand)
 
         @lock.synchronize do
           @buffer.append(priority: priority) do
-            create_event(noticed_error, transaction_payload)
+            create_event(noticed_error, transaction_payload, span_id)
           end
           notify_if_full
         end
@@ -31,8 +33,8 @@ module NewRelic
 
       private
 
-      def create_event noticed_error, transaction_payload
-        TransactionErrorPrimitive.create noticed_error, transaction_payload
+      def create_event(noticed_error, transaction_payload, span_id)
+        TransactionErrorPrimitive.create(noticed_error, transaction_payload, span_id)
       end
     end
   end