newrelic_rpm 6.15.0 → 9.7.1

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/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/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,27 +19,22 @@ module NewRelic
       attr_reader :error_trace_aggregator, :error_event_aggregator
 
       # Returns a new error collector
-      def initialize events
+      def initialize(events)
         @error_trace_aggregator = ErrorTraceAggregator.new(MAX_ERROR_QUEUE_LENGTH)
-        @error_event_aggregator = ErrorEventAggregator.new events
-
-        # 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
@@ -67,7 +63,7 @@ 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
@@ -76,30 +72,39 @@ module NewRelic
         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
@@ -118,11 +123,13 @@ module NewRelic
 
       def exception_tagged_with?(ivar, exception)
         return false if exception_is_java_object?(exception)
+
         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
@@ -132,6 +139,7 @@ module NewRelic
 
       def tag_exception(exception)
         return if exception_is_java_object?(exception) || exception.frozen?
+
         begin
           exception.instance_variable_set(EXCEPTION_TAG_IVAR, true)
         rescue => e
@@ -148,23 +156,23 @@ module NewRelic
       end
 
       def aggregated_metric_names(txn)
-        metric_names = ["Errors/all"]
+        metric_names = ['Errors/all']
         return metric_names unless txn
 
         if txn.recording_web_transaction?
-          metric_names << "Errors/allWeb"
+          metric_names << 'Errors/allWeb'
         else
-          metric_names << "Errors/allOther"
+          metric_names << 'Errors/allOther'
         end
 
         metric_names
       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
 
@@ -174,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_with?(EXCEPTION_TAG_IVAR, exception)
+          exception.nil? ||
+          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
@@ -191,17 +206,17 @@ 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
 
-      def notice_segment_error(segment, exception, options={})
+      def notice_segment_error(segment, exception, options = {})
         return if skip_notice_error?(exception)
 
-        segment.set_noticed_error create_noticed_error(exception, options)
+        segment.set_noticed_error(create_noticed_error(exception, options))
         exception
       rescue => e
         ::NewRelic::Agent.logger.warn("Failure when capturing segment error '#{exception}':", e)
@@ -209,22 +224,26 @@ module NewRelic
       end
 
       # See NewRelic::Agent.notice_error for options and commentary
-      def notice_error(exception, options={}, span_id=nil)
-        return if skip_notice_error?(exception)
+      def notice_error(exception, options = {}, span_id = nil)
+        state = ::NewRelic::Agent::Tracer.state
+        transaction = state.current_transaction
+        status_code = transaction&.http_response_code
 
-        tag_exception(exception)
+        return if skip_notice_error?(exception, status_code)
 
-        state = ::NewRelic::Agent::Tracer.state
+        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)
         transaction = state.current_transaction
-        payload = transaction ? transaction.payload : nil
-        span_id ||= (transaction && transaction.current_segment) ? transaction.current_segment.guid : nil
+        payload = transaction&.payload
+        span_id ||= transaction&.current_segment ? transaction.current_segment.guid : nil
         error_event_aggregator.record(noticed_error, payload, span_id)
         exception
       rescue => e
@@ -232,7 +251,7 @@ module NewRelic
         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
 
@@ -252,13 +271,13 @@ module NewRelic
         noticed_error = NewRelic::NoticedError.new(error_metric, exception)
         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) # rubocop:disable Style/DoubleNegation
 
         noticed_error.attributes_from_notice_error = options.delete(:custom_params) || {}
 
@@ -266,6 +285,8 @@ module NewRelic
         # get treated as custom attributes, so merge them into that hash.
         noticed_error.attributes_from_notice_error.merge!(options)
 
+        update_error_group_name(noticed_error, exception, options)
+
         noticed_error
       end
 
@@ -287,6 +308,32 @@ module NewRelic
         @error_event_aggregator.reset!
         nil
       end
+
+      private
+
+      def update_error_group_name(noticed_error, exception, options)
+        return unless error_group_callback
+
+        callback_hash = build_customer_callback_hash(noticed_error, exception, options)
+        result = error_group_callback.call(callback_hash)
+        noticed_error.error_group = result
+      rescue StandardError => e
+        NewRelic::Agent.logger.error("Failed to obtain error group from customer callback: #{e.class} - #{e.message}")
+      end
+
+      def build_customer_callback_hash(noticed_error, exception, options)
+        {error: exception,
+         customAttributes: noticed_error.custom_attributes,
+         'request.uri': noticed_error.request_uri,
+         'http.statusCode': noticed_error.agent_attributes[:'http.statusCode'],
+         'http.method': noticed_error.intrinsic_attributes[:'http.method'],
+         'error.expected': noticed_error.expected,
+         options: options}
+      end
+
+      def error_group_callback
+        NewRelic::Agent.error_group_callback
+      end
     end
   end
 end

data/lib/new_relic/agent/error_event_aggregator.rb

@@ -1,5 +1,4 @@
 # -*- ruby -*-
-# 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
@@ -16,10 +15,10 @@ module NewRelic
       named :ErrorEventAggregator
       capacity_key :'error_collector.max_event_samples_stored'
       enabled_keys :'error_collector.enabled',
-                   :'error_collector.capture_events'
+        :'error_collector.capture_events'
       buffer_class PrioritySampledBuffer
 
-      def record noticed_error, transaction_payload = nil, span_id = nil
+      def record(noticed_error, transaction_payload = nil, span_id = nil)
         return unless enabled?
 
         priority = float!((transaction_payload && transaction_payload[:priority]) || rand)
@@ -34,8 +33,8 @@ module NewRelic
 
       private
 
-      def create_event noticed_error, transaction_payload, span_id
-        TransactionErrorPrimitive.create noticed_error, transaction_payload, span_id
+      def create_event(noticed_error, transaction_payload, span_id)
+        TransactionErrorPrimitive.create(noticed_error, transaction_payload, span_id)
       end
     end
   end

data/lib/new_relic/agent/error_filter.rb

@@ -0,0 +1,174 @@
+# 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
+    # Handles loading of ignored and expected errors from the agent configuration, and
+    # determining at runtime whether an exception is ignored or expected.
+    class ErrorFilter
+      def initialize
+        reset
+      end
+
+      def reset
+        @ignore_classes, @expected_classes = [], []
+        @ignore_messages, @expected_messages = {}, {}
+        @ignore_status_codes, @expected_status_codes = [], []
+      end
+
+      def load_all
+        %i[
+          ignore_classes ignore_messages ignore_status_codes
+          expected_classes expected_messages expected_status_codes
+        ].each { |setting| load_from_config(setting) }
+      end
+
+      def load_from_config(setting, value = nil)
+        errors = nil
+        new_value = value || fetch_agent_config(setting.to_sym)
+
+        return if new_value.nil? || (new_value.respond_to?(:empty?) && new_value.empty?)
+
+        case setting.to_sym
+        when :ignore_classes
+          new_value = new_value.split(',').map!(&:strip) if new_value.is_a?(String)
+          errors = @ignore_classes = new_value
+        when :ignore_messages
+          errors = @ignore_messages = new_value || {}
+        when :ignore_status_codes
+          errors = @ignore_status_codes = parse_status_codes(new_value) || []
+        when :expected_classes
+          errors = @expected_classes = new_value || []
+        when :expected_messages
+          errors = @expected_messages = new_value || {}
+        when :expected_status_codes
+          errors = @expected_status_codes = parse_status_codes(new_value) || []
+        end
+        log_filter(setting, errors) if errors
+      end
+
+      def ignore?(ex, status_code = nil)
+        @ignore_classes.include?(ex.class.name) ||
+          (@ignore_messages.key?(ex.class.name) &&
+          @ignore_messages[ex.class.name].any? { |m| ex.message.include?(m) }) ||
+          @ignore_status_codes.include?(status_code.to_i)
+      end
+
+      def expected?(ex, status_code = nil)
+        @expected_classes.include?(ex.class.name) ||
+          (@expected_messages.key?(ex.class.name) &&
+          @expected_messages[ex.class.name].any? { |m| ex.message.include?(m) }) ||
+          @expected_status_codes.include?(status_code.to_i)
+      end
+
+      def fetch_agent_config(cfg)
+        NewRelic::Agent.config[:"error_collector.#{cfg}"]
+      end
+
+      # A generic method for adding ignore filters manually. This is kept for compatibility
+      # with the previous ErrorCollector#ignore method, and adds some flexibility for adding
+      # different ignore/expected error types by examining each argument.
+      def ignore(*args)
+        args.each do |errors|
+          case errors
+          when Array
+            errors.each { |e| ignore(e) }
+          when Integer
+            @ignore_status_codes << errors
+          when Hash
+            @ignore_messages.update(errors)
+            log_filter(:ignore_messages, errors)
+          when String
+            if /^[\d\,\-]+$/.match?(errors)
+              @ignore_status_codes |= parse_status_codes(errors)
+              log_filter(:ignore_status_codes, errors)
+            else
+              new_ignore_classes = errors.split(',').map!(&:strip)
+              @ignore_classes |= new_ignore_classes
+              log_filter(:ignore_classes, new_ignore_classes)
+            end
+          end
+        end
+      end
+
+      # See #ignore above.
+      def expect(*args)
+        args.each do |errors|
+          case errors
+          when Array
+            errors.each { |e| expect(e) }
+          when Integer
+            @expected_status_codes << errors
+          when Hash
+            @expected_messages.update(errors)
+            log_filter(:expected_messages, errors)
+          when String
+            if /^[\d\,\-]+$/.match?(errors)
+              @expected_status_codes |= parse_status_codes(errors)
+              log_filter(:expected_status_codes, errors)
+            else
+              new_expected_classes = errors.split(',').map!(&:strip)
+              @expected_classes |= new_expected_classes
+              log_filter(:expected_classes, new_expected_classes)
+            end
+          end
+        end
+      end
+
+      private
+
+      def log_filter(setting, errors)
+        case setting
+        when :ignore_classes
+          errors.each do |error|
+            ::NewRelic::Agent.logger.debug("Ignoring errors of type '#{error}'")
+          end
+        when :ignore_messages
+          errors.each do |error, messages|
+            ::NewRelic::Agent.logger.debug("Ignoring errors of type '#{error}' with messages: #{messages.join(',')}")
+          end
+        when :ignore_status_codes
+          ::NewRelic::Agent.logger.debug("Ignoring errors associated with status codes: #{errors}")
+        when :expected_classes
+          errors.each do |error|
+            ::NewRelic::Agent.logger.debug("Expecting errors of type '#{error}'")
+          end
+        when :expected_messages
+          errors.each do |error, messages|
+            ::NewRelic::Agent.logger.debug("Expecting errors of type '#{error}' with messages: #{messages.join(',')}")
+          end
+        when :expected_status_codes
+          ::NewRelic::Agent.logger.debug("Expecting errors associated with status codes: #{errors}")
+        end
+      end
+
+      def parse_status_codes(codes)
+        code_list = case codes
+          when String
+            codes.split(',')
+          when Integer
+            [codes]
+          else
+            codes
+        end
+        result = []
+        code_list.each do |code|
+          result << code && next if code.is_a?(Integer)
+
+          m = code.match(/(\d{3})(-\d{3})?/)
+          if m.nil? || m[1].nil?
+            ::NewRelic::Agent.logger.warn("Invalid HTTP status code: '#{code}'; ignoring config")
+            next
+          end
+          if m[2]
+            result += (m[1]..m[2].tr('-', '')).to_a.map(&:to_i)
+          else
+            result << m[1].to_i
+          end
+        end
+        result.uniq
+      end
+    end
+  end
+end

data/lib/new_relic/agent/error_trace_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/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -44,6 +44,7 @@ module NewRelic
       # floor after logging a warning.
       def add_to_error_queue(noticed_error)
         return unless enabled?
+
         @lock.synchronize do
           if !over_queue_limit?(noticed_error.message) && !@errors.include?(noticed_error)
             @errors << noticed_error
@@ -54,7 +55,7 @@ module NewRelic
       # checks the size of the error queue to make sure we are under
       # the maximum limit, and logs a warning if we are over the limit.
       def over_queue_limit?(message)
-        over_limit = (@errors.reject{|err| err.is_internal}.length >= @capacity)
+        over_limit = (@errors.count { |err| !err.is_internal } >= @capacity)
         if over_limit
           ::NewRelic::Agent.logger.warn("The error reporting queue has reached #{@capacity}. The error detail for this and subsequent errors will not be transmitted to New Relic until the queued errors have been sent: #{message}")
         end
@@ -80,19 +81,20 @@ module NewRelic
           # Already seen this class once? Bail!
           return if @errors.any? { |err| err.exception_class_name == exception.class.name }
 
-          trace = exception.backtrace || caller.dup
-          noticed_error = NewRelic::NoticedError.new("NewRelic/AgentError", exception)
-          noticed_error.stack_trace = trace
+          noticed_error = NewRelic::Agent.instance.error_collector.create_noticed_error(exception,
+            {metric: 'NewRelic/AgentError'})
+          noticed_error.stack_trace = caller.dup unless exception.backtrace
+
           @errors << noticed_error
         end
       rescue => e
-        NewRelic::Agent.logger.info("Unable to capture internal agent error due to an exception:", e)
+        NewRelic::Agent.logger.info('Unable to capture internal agent error due to an exception:', e)
       end
 
       def register_config_callbacks
         Agent.config.register_callback(:'error_collector.enabled') do |enabled|
           reset! if enabled == false
-          ::NewRelic::Agent.logger.debug "Error traces will #{enabled ? '' : 'not '}be sent to the New Relic service."
+          ::NewRelic::Agent.logger.debug("Error traces will #{enabled ? '' : 'not '}be sent to the New Relic service.")
         end
       end
     end