newrelic_rpm 7.1.0 → 7.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 768b946a5433cf79422bbbc2cda40878a70a6aad22a159e5eb0dcdb351aa9e6d
-  data.tar.gz: efa504f22c2029103d7ccba6940a47b77d12ef4f1d13fbff2da34d9ba7443c1a
+  metadata.gz: e364456c599b5484bd0b031f9bc19fd1ec634954c6c060eee1ac85c38adfed78
+  data.tar.gz: aaaaa6a31504b5aac1da40ac2c0d69fefbbae8525ce96ef38e7fc01460c618d9
 SHA512:
-  metadata.gz: d982762c9dadd2457e49a6ae480b39ad91d0484de4c8788cc0cb3ab3c677e001c57aa8047daaa0d1010b7a7b2b5b15c74790d60badecd81a3987bc4dc3a3d151
-  data.tar.gz: '079081d14361839642d5339bf1a2be928cded80310cfd951f43f2d2885c6fb71c3a6a713db6ae9e03e7bcf9e244c4a8cf48d1e132a7ba47f928b4bff974426d6'
+  metadata.gz: c8a7d6825a9d05a99d45bffb9fc537f5630f9e8077cd939970f28b17e85991fa80443752bc05560b5fcea7f3a47058e68eb96621f66a0e3b2989206a0aa66ebd
+  data.tar.gz: 2586902aac108d89c355eccae23acf6b88a72c18abdc773ef4938f3a5aaf17568821e2890bd2ecc4e56695d3798f1f74bdb136f2df3fc6002aacaa563fd329ea

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 # New Relic Ruby Agent Release Notes #
 
+  ## v7.2.0
+
+  * **Expected Errors and Ignore Errors**
+    This release adds support for configuration for expected/ignored errors by class name, status code, and message. The following configuration options are now available:
+    - `error_collector.ignore_classes`
+    - `error_collector.ignore_messages`
+    - `error_collector.ignore_status_codes`
+    - `error_collector.expected_classes`
+    - `error_collector.expected_messages`
+    - `error_collector.expected_status_codes`
+    For more details about expected and ignored errors, please see our [configuration documentation](https://docs.newrelic.com/docs/agents/ruby-agent/configuration/)
+
+  * **Bugfix: resolves "can't add a new key into hash during iteration" Errors**
+
+    Thanks to @wyhaines for this fix that prevents "can't add a new key into hash during iteration" errors from occuring when iterating over environment data.
+
+  * **Bugfix: kwarg support fixed for Rack middleware instrumentation**
+   
+    Thanks to @walro for submitting this fix. This fixes the rack instrumentation when using kwargs. 
+
+  * **Update known conflicts with use of Module#Prepend**
+
+    With our release of v7.0.0, we updated our instrumentation to use Module#Prepend by default, instead of method chaining. We have received reports of conflicts and added a check for these known conflicts. If a known conflict with prepend is detected while using the default value of 'auto' for gem instrumentation, the agent will instead install method chaining instrumentation in order to avoid this conflict. This check can be bypassed by setting the instrumentation method for the gem to 'prepend'.
+
+
   ## v7.1.0
 
   * **Add support for CSP nonces when using our API to insert the browser agent**

data/lib/new_relic/agent.rb

@@ -44,6 +44,7 @@ module NewRelic
     require 'new_relic/agent/sql_sampler'
     require 'new_relic/agent/commands/thread_profiler_session'
     require 'new_relic/agent/error_collector'
+    require 'new_relic/agent/error_filter'   
     require 'new_relic/agent/sampler'
     require 'new_relic/agent/database'
     require 'new_relic/agent/database_adapter'

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

@@ -1297,7 +1297,56 @@ module NewRelic
           :public => true,
           :type => String,
           :allowed_from_server => true,
-          :description => 'Specify a comma-delimited list of error classes that the agent should ignore.'
+          :dynamic_name => true,
+          :description => 'DEPRECATED; use `error_collector.ignore_classes` instead. Specify a comma-delimited list of error classes that the agent should ignore.'
+        },
+        :'error_collector.ignore_classes' => {
+          :default => [],
+          :public => true,
+          :type => Array,
+          :allowed_from_server => true,
+          :dynamic_name => true,
+          :description => 'A list of error classes that the agent should ignore. *Note: this setting cannot be set via environment variable.*'
+        },
+        :'error_collector.ignore_messages' => {
+          :default => {},
+          :public => true,
+          :type => Hash,
+          :allowed_from_server => true,
+          :dynamic_name => true,
+          :description => 'A map of error classes to a list of messages. When an error of one of the classes specified here occurs, if its error message contains one of the strings corresponding to it here, that error will be ignored. *Note: this setting cannot be set via environment variable.*'
+        },
+        :'error_collector.ignore_status_codes' => {
+          :default => '',
+          :public => true,
+          :type => String,
+          :allowed_from_server => true,
+          :dynamic_name => true,
+          :description => 'A comma separated list of status codes, possibly including ranges. Errors associated with these status codes, where applicable, will be ignored.'
+        },
+        :'error_collector.expected_classes' => {
+          :default => [],
+          :public => true,
+          :type => Array,
+          :allowed_from_server => true,
+          :dynamic_name => true,
+          :description => 'A list of error classes that the agent should treat as expected. *Note: this setting cannot be set via environment variable.*'
+        },
+        :'error_collector.expected_messages' => {
+          :default => {},
+          :public => true,
+          :type => Hash,
+          :allowed_from_server => true,
+          :dynamic_name => true,
+          :description => 'A map of error classes to a list of messages. When an error of one of the classes specified here occurs, if its error message contains one of the strings corresponding to it here, that error will be treated as expected. *Note: this setting cannot be set via environment variable.*'
+        },
+        :'error_collector.expected_status_codes' => {
+          :default => '',
+          :public => true,
+          :type => String,
+          :allowed_from_server => true,
+          :dynamic_name => true,
+          :description => 'A comma separated list of status codes, possibly including ranges. Errors associated with these status codes, where applicable, will be treated as expected.'
         },
         :'error_collector.max_backtrace_frames' => {
           :default => 50,

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/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/resque.rb

@@ -13,9 +13,9 @@ DependencyDetection.defer do
     defined?(::Resque::Job) && !NewRelic::Agent.config[:disable_resque]
   end
 
-  # Airbrake uses method chaining on Resque::Job
+  # Airbrake uses method chaining on Resque::Job on versions < 11.0.3
   conflicts_with_prepend do
-    defined?(::Airbrake)
+    defined?(::Airbrake) && defined?(::Airbrake::AIRBRAKE_VERSION) && ::Gem::Version.create(::Airbrake::AIRBRAKE_VERSION) < ::Gem::Version.create('11.0.3')
   end
 
   executes do

data/lib/new_relic/noticed_error.rb

@@ -33,7 +33,7 @@ class NewRelic::NoticedError
   ERROR_CLASS_KEY    = "#{ERROR_PREFIX_KEY}.class"
   ERROR_EXPECTED_KEY = "#{ERROR_PREFIX_KEY}.expected"
 
-  def initialize(path, exception, timestamp = Time.now)
+  def initialize(path, exception, timestamp = Time.now, expected = false)
     @exception_id = exception.object_id
     @path = path
 
@@ -58,7 +58,7 @@ class NewRelic::NoticedError
     @attributes_from_notice_error = nil
     @attributes = nil
     @timestamp = timestamp
-    @expected = false
+    @expected = expected
   end
 
   def ==(other)
@@ -104,7 +104,7 @@ class NewRelic::NoticedError
     params[:file_name]        = file_name   if file_name
     params[:line_number]      = line_number if line_number
     params[:stack_trace]      = stack_trace if stack_trace
-    params[:'error.expected'] = expected
+    params[ERROR_EXPECTED_KEY.to_sym] = expected
     params
   end
 

data/lib/new_relic/version.rb

@@ -11,7 +11,7 @@ module NewRelic
     end
 
     MAJOR = 7
-    MINOR = 1
+    MINOR = 2
     TINY  = 0
 
     begin

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: newrelic_rpm
 version: !ruby/object:Gem::Version
-  version: 7.1.0
+  version: 7.2.0
 platform: ruby
 authors:
 - Aaron Huntsman
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-06-03 00:00:00.000000000 Z
+date: 2021-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -276,6 +276,7 @@ files:
 - lib/new_relic/agent/encoding_normalizer.rb
 - lib/new_relic/agent/error_collector.rb
 - lib/new_relic/agent/error_event_aggregator.rb
+- lib/new_relic/agent/error_filter.rb
 - lib/new_relic/agent/error_trace_aggregator.rb
 - lib/new_relic/agent/event_aggregator.rb
 - lib/new_relic/agent/event_buffer.rb