newrelic_rpm 6.13.1 → 7.2.0

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

@@ -23,7 +23,7 @@ module NewRelic
         end
 
         def has_key?(key)
-          @cache.has_key?[key]
+          @cache.has_key? key
         end
 
         def keys
@@ -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
@@ -345,7 +345,7 @@ module NewRelic
         end
 
         def reset_cache
-          @cache = Hash.new {|hash,key| hash[key] = self.fetch(key) }
+          @cache = Hash.new { |hash,key| hash[key] = self.fetch(key) }
         end
 
         def log_config(direction, source)

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

@@ -0,0 +1,33 @@
+# 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
+    class DatabaseAdapter
+      VERSIONS = {
+        '6.1.0' => proc { ActiveRecord::Base.connection_db_config.configuration_hash[:adapter] },
+        '4.0.0' => proc { ActiveRecord::Base.connection_config[:adapter] },
+        '3.0.0' => proc { |env| ActiveRecord::Base.configurations[env]['adapter'] }
+      }
+
+      def self.value
+        return unless defined? ActiveRecord::Base
+        new(::NewRelic::Control.instance.env, ActiveRecord::VERSION::STRING).value
+      end
+
+      attr_reader :env, :version
+
+      def initialize(env, version)
+        @env = env
+        @version = Gem::Version.new(version)
+      end
+
+      def value
+        match = VERSIONS.keys.find { |key| version >= Gem::Version.new(key) }
+        return unless match
+        VERSIONS[match].call(env)
+      end
+    end
+  end
+end

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

@@ -6,11 +6,7 @@ module NewRelic
   module Agent
     module Datastores
       module Redis
-        MULTI_OPERATION = 'multi'
-        PIPELINE_OPERATION = 'pipeline'
         BINARY_DATA_PLACEHOLDER = "<binary data>"
-        PRODUCT_NAME = 'Redis'
-        CONNECT = 'connect'
 
         MAXIMUM_COMMAND_LENGTH = 1000
         MAXIMUM_ARGUMENT_LENGTH = 64

data/lib/new_relic/agent/distributed_tracing.rb

@@ -24,72 +24,6 @@ module NewRelic
       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.
-      #
-      # @return [DistributedTracePayload] Payload for the current
-      #                                   transaction, or +nil+ if we
-      #                                   could not create the payload
-      #
-      # @api public
-      #
-      # @deprecated See {#create_distributed_trace_headers} instead.
-      #
-      def 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
-      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.
-      #
-      # This method will fail if you call it after calling
-      # {#create_distributed_trace_payload}.
-      #
-      # @param payload [String] Incoming distributed trace payload,
-      #                         either as a JSON string or as a
-      #                         header-friendly string returned from
-      #                         {DistributedTracePayload#http_safe}
-      #
-      # @return nil
-      #
-      # @api public
-      #
-      # @deprecated See {#accept_distributed_trace_headers} instead
-      #
-      def 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.

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

@@ -52,14 +52,14 @@ module NewRelic
         result
       end
 
-      def insert_cross_app_header request
+      def insert_cross_app_header headers
         return unless CrossAppTracing.cross_app_enabled?
         @is_cross_app_caller = true
         txn_guid  = transaction.guid
         trip_id   = cat_trip_id
         path_hash = cat_path_hash
 
-        insert_request_headers request, txn_guid, trip_id, path_hash
+        insert_request_headers headers, txn_guid, trip_id, path_hash
       end
 
       def add_message_cat_headers headers

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