newrelic_rpm 7.0.0 → 7.2.0

data/lib/new_relic/agent/configuration/manager.rb

@@ -80,6 +80,7 @@ module NewRelic
           was_finished = finished_configuring?
 
           invoke_callbacks(:add, source)
+
           case source
           when SecurityPolicySource then @security_policy_source = source
           when HighSecuritySource   then @high_security_source   = source
@@ -159,7 +160,6 @@ module NewRelic
         def invoke_callbacks(direction, source)
           return unless source
           source.keys.each do |key|
-
             if @cache[key] != source[key]
               @callbacks[key].each do |proc|
                 if direction == :add

data/lib/new_relic/agent/connect/request_builder.rb

@@ -48,8 +48,10 @@ module NewRelic
           environment_report
         end
 
-        def environment_metadata
-          ENV.select {|k, v| k =~ /^NEW_RELIC_METADATA_/}
+        def environment_metadata 
+          env_copy = {}
+          ENV.keys.each {|k| env_copy[k] = ENV[k] if k =~ /^NEW_RELIC_METADATA_/}
+          env_copy
         end
 
         def local_host

data/lib/new_relic/agent/error_collector.rb

@@ -22,23 +22,18 @@ module NewRelic
         @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 = {}
-
-        initialize_ignored_errors(Agent.config[:'error_collector.ignore_errors'])
-
-        Agent.config.register_callback(:'error_collector.ignore_errors') do |ignore_errors|
-          initialize_ignored_errors(ignore_errors)
+        @error_filter = NewRelic::Agent::ErrorFilter.new
+
+        %w(
+          ignore_errors 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
@@ -76,30 +71,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
@@ -174,11 +178,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_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
@@ -210,13 +221,17 @@ module NewRelic
 
       # See NewRelic::Agent.notice_error for options and commentary
       def notice_error(exception, options={}, span_id=nil)
-        return if skip_notice_error?(exception)
+        state = ::NewRelic::Agent::Tracer.state
+        transaction = state.current_transaction
+        status_code = transaction ? transaction.http_response_code : nil
 
-        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
 
@@ -258,7 +273,7 @@ module NewRelic
         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_filter.rb

@@ -0,0 +1,167 @@
+# 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.
+
+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_errors 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.empty?
+
+        case setting.to_sym
+        when :ignore_errors, :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.keys.include?(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.keys.include?(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 errors.match(/^[\d\,\-]+$/)
+              @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 errors.match(/^[\d\,\-]+$/)
+              @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_errors, :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 = codes.is_a?(String) ? codes.split(',') : codes
+        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/instrumentation/active_record_subscriber.rb

@@ -84,8 +84,6 @@ module NewRelic
         end
 
         def active_record_config(payload)
-          return unless payload[:connection_id]
-
           # handle if the notification payload provides the AR connection
           # available in Rails 6+ & our ActiveRecordNotifications#log extension
           if payload[:connection]
@@ -93,8 +91,8 @@ module NewRelic
             return connection_config if connection_config
           end
 
+          return unless connection_id = payload[:connection_id]
           connection = nil
-          connection_id = payload[:connection_id]
 
           ::ActiveRecord::Base.connection_handler.connection_pool_list.each do |handler|
             connection = handler.connections.detect do |conn|

data/lib/new_relic/agent/instrumentation/controller_instrumentation.rb

@@ -179,6 +179,7 @@ module NewRelic
                   #{without_method_name}(*args, &block)
                  end
               end
+              ruby2_keywords(:#{with_method_name}) if respond_to?(:ruby2_keywords, true)
             EOC
 
             visibility = NewRelic::Helper.instance_method_visibility self, method

data/lib/new_relic/agent/instrumentation/net_http.rb

@@ -17,8 +17,13 @@ DependencyDetection.defer do
     require 'new_relic/agent/http_clients/net_http_wrappers'
   end
 
+  # Airbrake uses method chaining on Net::HTTP in versions < 10.0.2 (10.0.2 updated to prepend for Net:HTTP)
   conflicts_with_prepend do
-    defined?(::Airbrake)
+    defined?(::Airbrake) && defined?(::Airbrake::AIRBRAKE_VERSION) && ::Gem::Version.create(::Airbrake::AIRBRAKE_VERSION) < ::Gem::Version.create('10.0.2')
+  end
+
+  conflicts_with_prepend do
+    defined?(::ScoutApm)
   end
 
   conflicts_with_prepend do

data/lib/new_relic/agent/instrumentation/rack/chain.rb

@@ -31,7 +31,8 @@ module NewRelic::Agent::Instrumentation
             def use_with_newrelic(middleware_class, *args, &block)
               use_with_tracing(middleware_class) { |wrapped_class| use_without_newrelic(wrapped_class, *args, &block) }
             end
-    
+            ruby2_keywords(:use_with_newrelic) if respond_to?(:ruby2_keywords, true)
+
             alias_method :use_without_newrelic, :use
             alias_method :use, :use_with_newrelic
           end
@@ -54,4 +55,4 @@ module NewRelic::Agent::Instrumentation
       end
     end
   end
-end
+end

data/lib/new_relic/agent/instrumentation/rack/prepend.rb

@@ -31,6 +31,7 @@ module NewRelic::Agent::Instrumentation
       def use(middleware_class, *args, &blk)
         use_with_tracing(middleware_class) { |wrapped_class| super(wrapped_class, *args, &blk) }
       end
+      ruby2_keywords(:use) if respond_to?(:ruby2_keywords, true)
     end
   end
-end
+end

data/lib/new_relic/agent/instrumentation/redis.rb

@@ -18,6 +18,10 @@ DependencyDetection.defer do
     defined?(::Redis) && defined?(::Redis::VERSION)
   end
 
+  conflicts_with_prepend do
+    defined?(::PrometheusExporter)
+  end
+
   depends_on do
     NewRelic::Agent::Datastores::Redis.is_supported_version? &&
       NewRelic::Agent::Datastores::Redis.safe_from_third_party_gem?

data/lib/new_relic/agent/instrumentation/resque.rb

@@ -13,6 +13,11 @@ DependencyDetection.defer do
     defined?(::Resque::Job) && !NewRelic::Agent.config[:disable_resque]
   end
 
+  # Airbrake uses method chaining on Resque::Job on versions < 11.0.3
+  conflicts_with_prepend do
+    defined?(::Airbrake) && defined?(::Airbrake::AIRBRAKE_VERSION) && ::Gem::Version.create(::Airbrake::AIRBRAKE_VERSION) < ::Gem::Version.create('11.0.3')
+  end
+
   executes do
     ::NewRelic::Agent.logger.info 'Installing Resque instrumentation'
   end
@@ -32,7 +37,7 @@ DependencyDetection.defer do
       chain_instrument NewRelic::Agent::Instrumentation::Resque::Chain
     end
 
-    if NewRelic::LanguageSupport.can_fork?
+    if NewRelic::Agent::Instrumentation::Resque::Helper.resque_fork_per_job?
       ::Resque.before_first_fork do
         NewRelic::Agent.manual_start(:dispatcher   => :resque,
                                      :sync_startup => true,
@@ -40,9 +45,7 @@ DependencyDetection.defer do
       end
 
       ::Resque.before_fork do |job|
-        if ENV['FORK_PER_JOB'] != 'false'
-          NewRelic::Agent.register_report_channel(job.object_id)
-        end
+        NewRelic::Agent.register_report_channel(job.object_id)
       end
 
       ::Resque.after_fork do |job|
@@ -51,6 +54,12 @@ DependencyDetection.defer do
         NewRelic::Agent.after_fork(:report_to_channel => job.object_id,
                                    :report_instance_busy => false)
       end
+    else
+      ::Resque.before_first_fork do
+        NewRelic::Agent.manual_start(:dispatcher   => :resque,
+                                     :sync_startup => true,
+                                     :start_channel_listener => false)
+      end
     end
   end
 end