newrelic_rpm 8.15.0 → 9.6.0

data/lib/new_relic/agent/agent_helpers/startup.rb

@@ -14,7 +14,7 @@ module NewRelic
         # Check whether we have already started, which is an error condition
         def already_started?
           if started?
-            ::NewRelic::Agent.logger.error("Agent Started Already!")
+            ::NewRelic::Agent.logger.error('Agent Started Already!')
             true
           end
         end
@@ -87,15 +87,15 @@ module NewRelic
         end
 
         def log_app_name
-          ::NewRelic::Agent.logger.info("Application: #{Agent.config[:app_name].join(", ")}")
+          ::NewRelic::Agent.logger.info("Application: #{Agent.config[:app_name].join(', ')}")
         end
 
         def log_ignore_url_regexes
           regexes = NewRelic::Agent.config[:'rules.ignore_url_regexes']
 
           unless regexes.empty?
-            ::NewRelic::Agent.logger.info("Ignoring URLs that match the following regexes: " \
-              "#{regexes.map(&:inspect).join(", ")}.")
+            ::NewRelic::Agent.logger.info('Ignoring URLs that match the following regexes: ' \
+              "#{regexes.map(&:inspect).join(', ')}.")
           end
         end
 
@@ -138,10 +138,10 @@ module NewRelic
           if Agent.config[:license_key] && Agent.config[:license_key].length > 0
             true
           else
-            ::NewRelic::Agent.logger.warn("No license key found. " +
-              "This often means your newrelic.yml file was not found, or it lacks a section for the running " \
+            ::NewRelic::Agent.logger.warn('No license key found. ' +
+              'This often means your newrelic.yml file was not found, or it lacks a section for the running ' \
               "environment, '#{NewRelic::Control.instance.env}'. You may also want to try linting your newrelic.yml " \
-              "to ensure it is valid YML.")
+              'to ensure it is valid YML.')
             false
           end
         end
@@ -169,21 +169,21 @@ module NewRelic
           return false if already_started? || disabled?
 
           if defer_for_delayed_job?
-            ::NewRelic::Agent.logger.debug("Deferring startup for DelayedJob")
+            ::NewRelic::Agent.logger.debug('Deferring startup for DelayedJob')
             return false
           end
 
           if defer_for_resque?
-            ::NewRelic::Agent.logger.debug("Deferring startup for Resque in case it daemonizes")
+            ::NewRelic::Agent.logger.debug('Deferring startup for Resque in case it daemonizes')
             return false
           end
 
           unless app_name_configured?
-            NewRelic::Agent.logger.error("No application name configured.",
-              "The Agent cannot start without at least one. Please check your ",
-              "newrelic.yml and ensure that it is valid and has at least one ",
+            NewRelic::Agent.logger.error('No application name configured.',
+              'The Agent cannot start without at least one. Please check your ',
+              'newrelic.yml and ensure that it is valid and has at least one ',
               "value set for app_name in the #{NewRelic::Control.instance.env} ",
-              "environment.")
+              'environment.')
             return false
           end
 

data/lib/new_relic/agent/agent_helpers/transmit.rb

@@ -6,27 +6,27 @@ module NewRelic
   module Agent
     module AgentHelpers
       module Transmit
-        TRANSACTION_EVENT = "TransactionEvent".freeze
+        TRANSACTION_EVENT = 'TransactionEvent'.freeze
         def transmit_analytic_event_data
           transmit_single_data_type(:harvest_and_send_analytic_event_data, TRANSACTION_EVENT)
         end
 
-        CUSTOM_EVENT = "CustomEvent".freeze
+        CUSTOM_EVENT = 'CustomEvent'.freeze
         def transmit_custom_event_data
           transmit_single_data_type(:harvest_and_send_custom_event_data, CUSTOM_EVENT)
         end
 
-        ERROR_EVENT = "ErrorEvent".freeze
+        ERROR_EVENT = 'ErrorEvent'.freeze
         def transmit_error_event_data
           transmit_single_data_type(:harvest_and_send_error_event_data, ERROR_EVENT)
         end
 
-        SPAN_EVENT = "SpanEvent".freeze
+        SPAN_EVENT = 'SpanEvent'.freeze
         def transmit_span_event_data
           transmit_single_data_type(:harvest_and_send_span_event_data, SPAN_EVENT)
         end
 
-        LOG_EVENT = "LogEvent".freeze
+        LOG_EVENT = 'LogEvent'.freeze
         def transmit_log_event_data
           transmit_single_data_type(:harvest_and_send_log_event_data, LOG_EVENT)
         end
@@ -47,7 +47,7 @@ module NewRelic
 
         def transmit_data
           now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          ::NewRelic::Agent.logger.debug("Sending data to New Relic Service")
+          ::NewRelic::Agent.logger.debug('Sending data to New Relic Service')
 
           @events.notify(:before_harvest)
           @service.session do # use http keep-alive

data/lib/new_relic/agent/agent_logger.rb

@@ -13,7 +13,7 @@ module NewRelic
     class AgentLogger
       include LogOnce
 
-      def initialize(root = "", override_logger = nil)
+      def initialize(root = '', override_logger = nil)
         @already_logged_lock = Mutex.new
         clear_already_logged
         create_log(root, override_logger)
@@ -53,13 +53,13 @@ module NewRelic
       # default behavior of backtraces logged at debug, use one of the methods
       # above and pass an Exception as one of the args.
       def log_exception(level, e, backtrace_level = level)
-        @log.send(level, "%p: %s" % [e.class, e.message])
+        @log.send(level, '%p: %s' % [e.class, e.message])
         @log.send(backtrace_level) do
           backtrace = backtrace_from_exception(e)
           if backtrace
             "Debugging backtrace:\n" + backtrace.join("\n  ")
           else
-            "No backtrace available."
+            'No backtrace available.'
           end
         end
       end
@@ -150,11 +150,11 @@ module NewRelic
       end
 
       LOG_LEVELS = {
-        "debug" => ::Logger::DEBUG,
-        "info" => ::Logger::INFO,
-        "warn" => ::Logger::WARN,
-        "error" => ::Logger::ERROR,
-        "fatal" => ::Logger::FATAL
+        'debug' => ::Logger::DEBUG,
+        'info' => ::Logger::INFO,
+        'warn' => ::Logger::WARN,
+        'error' => ::Logger::ERROR,
+        'fatal' => ::Logger::FATAL
       }
 
       def self.log_level_for(level)
@@ -165,7 +165,7 @@ module NewRelic
         @hostname = NewRelic::Agent::Hostname.get
         @prefix = wants_stdout? ? '** [NewRelic]' : ''
         @log.formatter = proc do |severity, timestamp, progname, msg|
-          "#{@prefix}[#{timestamp.strftime("%F %H:%M:%S %z")} #{@hostname} (#{$$})] #{severity} : #{msg}\n"
+          "#{@prefix}[#{timestamp.strftime('%F %H:%M:%S %z')} #{@hostname} (#{$$})] #{severity} : #{msg}\n"
         end
       end
 

data/lib/new_relic/agent/attribute_filter.rb

@@ -124,8 +124,6 @@ module NewRelic
 
       def prep_capture_params_rules(config)
         build_rule(['request.parameters.*'], include_destinations_for_capture_params(config[:capture_params]), true)
-        build_rule(['job.resque.args.*'], include_destinations_for_capture_params(config[:'resque.capture_params']), true)
-        build_rule(['job.sidekiq.args.*'], include_destinations_for_capture_params(config[:'sidekiq.capture_params']), true)
       end
 
       def prep_datastore_rules(config)
@@ -275,8 +273,8 @@ module NewRelic
       attr_reader :attribute_name, :destinations, :is_include, :wildcard
 
       def initialize(attribute_name, destinations, is_include)
-        @attribute_name = attribute_name.sub(/\*$/, "")
-        @wildcard = attribute_name.end_with?("*")
+        @attribute_name = attribute_name.sub(/\*$/, '')
+        @wildcard = attribute_name.end_with?('*')
         @is_include = is_include
         @destinations = is_include ? destinations : ~destinations
       end

data/lib/new_relic/agent/attribute_pre_filtering.rb

@@ -0,0 +1,109 @@
+# 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
+    module AttributePreFiltering
+      module_function
+
+      PRE_FILTER_KEYS = %i[include exclude].freeze
+      DISCARDED = :nr_discarded
+
+      def formulate_regexp_union(option)
+        return if NewRelic::Agent.config[option].empty?
+
+        Regexp.union(NewRelic::Agent.config[option].map { |p| string_to_regexp(p) }.uniq.compact).freeze
+      rescue StandardError => e
+        NewRelic::Agent.logger.warn("Failed to formulate a Regexp union from the '#{option}' configuration option " +
+                                    "- #{e.class}: #{e.message}")
+      end
+
+      def string_to_regexp(str)
+        Regexp.new(str)
+      rescue StandardError => e
+        NewRelic::Agent.logger.warn("Failed to initialize Regexp from string '#{str}' - #{e.class}: #{e.message}")
+      end
+
+      # attribute filtering suppresses data that has already been flattened
+      # and coerced (serialized as text) via #flatten_and_coerce, and is
+      # restricted to basic text matching with a single optional wildcard.
+      # pre filtering operates on raw Ruby objects beforehand and uses full
+      # Ruby regex syntax
+      def pre_filter(values = [], options = {})
+        return values unless !options.empty? && PRE_FILTER_KEYS.any? { |k| options.key?(k) }
+
+        # if there's a prefix in play for (non-pre) attribute filtration and
+        # attribute filtration won't allow that prefix, then don't even bother
+        # with pre filtration that could only result in values that would be
+        # blocked
+        if options.key?(:attribute_namespace) &&
+            !NewRelic::Agent.instance.attribute_filter.might_allow_prefix?(options[:attribute_namespace])
+          return values
+        end
+
+        values.each_with_object([]) do |element, filtered|
+          object = pre_filter_object(element, options)
+          filtered << object unless discarded?(object)
+        end
+      end
+
+      def pre_filter_object(object, options)
+        if object.is_a?(Hash)
+          pre_filter_hash(object, options)
+        elsif object.is_a?(Array)
+          pre_filter_array(object, options)
+        else
+          pre_filter_scalar(object, options)
+        end
+      end
+
+      def pre_filter_hash(hash, options)
+        filtered_hash = hash.each_with_object({}) do |(key, value), filtered|
+          filtered_key = pre_filter_object(key, options)
+          next if discarded?(filtered_key)
+
+          # If the key is permitted, skip include filtration for the value
+          # but still apply exclude filtration
+          if options.key?(:exclude)
+            exclude_only = options.dup
+            exclude_only.delete(:include)
+            filtered_value = pre_filter_object(value, exclude_only)
+            next if discarded?(filtered_value)
+          else
+            filtered_value = value
+          end
+
+          filtered[filtered_key] = filtered_value
+        end
+
+        filtered_hash.empty? && !hash.empty? ? DISCARDED : filtered_hash
+      end
+
+      def pre_filter_array(array, options)
+        filtered_array = array.each_with_object([]) do |element, filtered|
+          filtered_element = pre_filter_object(element, options)
+          next if discarded?(filtered_element)
+
+          filtered.push(filtered_element)
+        end
+
+        filtered_array.empty? && !array.empty? ? DISCARDED : filtered_array
+      end
+
+      def pre_filter_scalar(scalar, options)
+        return DISCARDED if options.key?(:include) && !scalar.to_s.match?(options[:include])
+        return DISCARDED if options.key?(:exclude) && scalar.to_s.match?(options[:exclude])
+
+        scalar
+      end
+
+      # `nil`, empty enumerable objects, and `false` are all valid in their
+      # own right as application data, so pre-filtering uses a special value
+      # to indicate that filtered out data has been discarded
+      def discarded?(object)
+        object == DISCARDED
+      end
+    end
+  end
+end

data/lib/new_relic/agent/attribute_processing.rb

@@ -7,8 +7,8 @@ module NewRelic
     module AttributeProcessing
       module_function
 
-      EMPTY_HASH_STRING_LITERAL = "{}".freeze
-      EMPTY_ARRAY_STRING_LITERAL = "[]".freeze
+      EMPTY_HASH_STRING_LITERAL = '{}'.freeze
+      EMPTY_ARRAY_STRING_LITERAL = '[]'.freeze
 
       def flatten_and_coerce(object, prefix = nil, result = {}, &blk)
         if object.is_a?(Hash)

data/lib/new_relic/agent/audit_logger.rb

@@ -32,9 +32,9 @@ module NewRelic
 
         @log.info("REQUEST HEADERS: #{headers}")
       rescue StandardError, SystemStackError, SystemCallError => e
-        ::NewRelic::Agent.logger.warn("Failed writing request headers to audit log", e)
+        ::NewRelic::Agent.logger.warn('Failed writing request headers to audit log', e)
       rescue Exception => e
-        ::NewRelic::Agent.logger.warn("Failed writing request headers to audit log with exception. Re-raising in case of interrupt.", e)
+        ::NewRelic::Agent.logger.warn('Failed writing request headers to audit log with exception. Re-raising in case of interrupt.', e)
         raise
       end
 
@@ -50,9 +50,9 @@ module NewRelic
         @log.info("REQUEST: #{uri}")
         @log.info("REQUEST BODY: #{request_body}")
       rescue StandardError, SystemStackError, SystemCallError => e
-        ::NewRelic::Agent.logger.warn("Failed writing to audit log", e)
+        ::NewRelic::Agent.logger.warn('Failed writing to audit log', e)
       rescue Exception => e
-        ::NewRelic::Agent.logger.warn("Failed writing to audit log with exception. Re-raising in case of interrupt.", e)
+        ::NewRelic::Agent.logger.warn('Failed writing to audit log with exception. Re-raising in case of interrupt.', e)
         raise
       end
 
@@ -64,7 +64,7 @@ module NewRelic
         if wants_stdout?
           # Using $stdout global for easier reassignment in testing
           @log = ::Logger.new($stdout)
-          ::NewRelic::Agent.logger.info("Audit log enabled to STDOUT")
+          ::NewRelic::Agent.logger.info('Audit log enabled to STDOUT')
         elsif path = ensure_log_path
           @log = ::Logger.new(path)
           ::NewRelic::Agent.logger.info("Audit log enabled at '#{path}'")

data/lib/new_relic/agent/autostart.rb

@@ -28,7 +28,7 @@ module NewRelic
           !in_denylisted_rake_task?
       end
 
-      COMMA = ",".freeze
+      COMMA = ','.freeze
 
       def denylisted_constants?
         denylisted?(NewRelic::Agent.config[:'autostart.denylisted_constants']) do |name|

data/lib/new_relic/agent/commands/agent_command.rb

@@ -10,8 +10,8 @@ module NewRelic
 
         def initialize(raw_collector_command)
           @id = raw_collector_command[0]
-          @name = raw_collector_command[1]["name"]
-          @arguments = raw_collector_command[1]["arguments"]
+          @name = raw_collector_command[1]['name']
+          @arguments = raw_collector_command[1]['arguments']
         end
       end
     end

data/lib/new_relic/agent/commands/agent_command_router.rb

@@ -29,7 +29,8 @@ module NewRelic
           @handlers['start_profiler'] = proc { |cmd| thread_profiler_session.handle_start_command(cmd) }
           @handlers['stop_profiler'] = proc { |cmd| thread_profiler_session.handle_stop_command(cmd) }
 
-          if event_listener
+          # the following statement needs else branch coverage
+          if event_listener # rubocop:disable Style/SafeNavigation
             event_listener.subscribe(:before_shutdown, &method(:on_before_shutdown))
           end
         end
@@ -77,10 +78,10 @@ module NewRelic
 
         def log_profiles(profiles)
           if profiles.empty?
-            ::NewRelic::Agent.logger.debug("No thread profiles with data found to send.")
+            ::NewRelic::Agent.logger.debug('No thread profiles with data found to send.')
           else
             profile_descriptions = profiles.map { |p| p.to_log_description }
-            ::NewRelic::Agent.logger.debug("Sending thread profiles [#{profile_descriptions.join(", ")}]")
+            ::NewRelic::Agent.logger.debug("Sending thread profiles [#{profile_descriptions.join(', ')}]")
           end
         end
 
@@ -114,7 +115,7 @@ module NewRelic
         end
 
         SUCCESS_RESULT = NewRelic::EMPTY_HASH
-        ERROR_KEY = "error"
+        ERROR_KEY = 'error'
 
         def success
           SUCCESS_RESULT

data/lib/new_relic/agent/commands/thread_profiler_session.rb

@@ -25,12 +25,12 @@ module NewRelic
         end
 
         def handle_stop_command(agent_command)
-          report_data = agent_command.arguments.fetch("report_data", true)
+          report_data = agent_command.arguments.fetch('report_data', true)
           stop(report_data)
         end
 
         def start(agent_command)
-          NewRelic::Agent.logger.debug("Starting Thread Profiler.")
+          NewRelic::Agent.logger.debug('Starting Thread Profiler.')
           profile = @backtrace_service.subscribe(
             NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS,
             agent_command.arguments
@@ -43,7 +43,7 @@ module NewRelic
         def stop(report_data)
           return unless running?
 
-          NewRelic::Agent.logger.debug("Stopping Thread Profiler.")
+          NewRelic::Agent.logger.debug('Stopping Thread Profiler.')
           @finished_profile = @backtrace_service.harvest(NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
           @backtrace_service.unsubscribe(NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
           @finished_profile = nil if !report_data
@@ -51,7 +51,7 @@ module NewRelic
 
         def harvest
           NewRelic::Agent.logger.debug(
-            "Harvesting from Thread Profiler #{@finished_profile.to_log_description unless @finished_profile.nil?}"
+            "Harvesting from Thread Profiler #{@finished_profile&.to_log_description}"
           )
           profile = @finished_profile
           @backtrace_service.profile_agent_code = false
@@ -89,9 +89,9 @@ module NewRelic
         end
 
         def raise_unsupported_error
-          msg = <<-EOF
-Thread profiling is not supported for Resque processes. If you did not intend to
-profile a Resque process, profiling again might select an appropriate agent.
+          msg = <<~EOF
+            Thread profiling is not supported for Resque processes. If you did not intend to
+            profile a Resque process, profiling again might select an appropriate agent.
           EOF
           raise_command_error(msg)
         end
@@ -102,7 +102,7 @@ profile a Resque process, profiling again might select an appropriate agent.
         end
 
         def raise_already_started_error
-          msg = "Profile already in progress. Ignoring agent command to start another."
+          msg = 'Profile already in progress. Ignoring agent command to start another.'
           raise_command_error(msg)
         end
       end