newrelic_rpm 3.12.0.288 → 9.10.2

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

@@ -0,0 +1,203 @@
+# 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 AgentHelpers
+      module Startup
+        # True if we have initialized and completed 'start'
+        def started?
+          @started
+        end
+
+        # Check whether we have already started, which is an error condition
+        def already_started?
+          if started?
+            ::NewRelic::Agent.logger.error('Agent Started Already!')
+            true
+          end
+        end
+
+        # Logs a bunch of data and starts the agent, if needed
+        def start
+          return unless agent_should_start?
+
+          log_startup
+          check_config_and_start_agent
+          log_version_and_pid
+
+          events.subscribe(:initial_configuration_complete) do
+            log_ignore_url_regexes
+          end
+        end
+
+        # Sanity-check the agent configuration and start the agent,
+        # setting up the worker thread and the exit handler to shut
+        # down the agent
+        def check_config_and_start_agent
+          return unless monitoring? && has_correct_license_key?
+          return if using_forking_dispatcher?
+
+          setup_and_start_agent
+        end
+
+        # This is the shared method between the main agent startup and the
+        # after_fork call restarting the thread in deferred dispatchers.
+        #
+        # Treatment of @started and env report is important to get right.
+        def setup_and_start_agent(options = {})
+          @started = true
+          @harvester.mark_started
+
+          unless in_resque_child_process?
+            install_exit_handler
+            environment_for_connect
+            @harvest_samplers.load_samplers unless Agent.config[:disable_samplers]
+          end
+
+          connect_in_foreground if Agent.config[:sync_startup]
+          start_worker_thread(options)
+        end
+
+        # Log startup information that we almost always want to know
+        def log_startup
+          log_environment
+          log_dispatcher
+          log_app_name
+        end
+
+        # Log the environment the app thinks it's running in.
+        # Useful in debugging, as this is the key for config YAML lookups.
+        def log_environment
+          ::NewRelic::Agent.logger.info("Environment: #{NewRelic::Control.instance.env}")
+        end
+
+        # Logs the dispatcher to the log file to assist with
+        # debugging. When no debugger is present, logs this fact to
+        # assist with proper dispatcher detection
+        def log_dispatcher
+          dispatcher_name = Agent.config[:dispatcher].to_s
+
+          if dispatcher_name.empty?
+            ::NewRelic::Agent.logger.info('No known dispatcher detected.')
+          else
+            ::NewRelic::Agent.logger.info("Dispatcher: #{dispatcher_name}")
+          end
+        end
+
+        def log_app_name
+          ::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(', ')}.")
+          end
+        end
+
+        # Classy logging of the agent version and the current pid,
+        # so we can disambiguate processes in the log file and make
+        # sure they're running a reasonable version
+        def log_version_and_pid
+          ::NewRelic::Agent.logger.debug("New Relic Ruby agent #{NewRelic::VERSION::STRING} initialized: pid = #{$$}")
+        end
+
+        # Logs the configured application names
+        def app_name_configured?
+          names = Agent.config[:app_name]
+          return names.respond_to?(:any?) && names.any?
+        end
+
+        # Connecting in the foreground blocks further startup of the
+        # agent until we have a connection - useful in cases where
+        # you're trying to log a very-short-running process and want
+        # to get statistics from before a server connection
+        # (typically 20 seconds) exists
+        def connect_in_foreground
+          NewRelic::Agent.disable_all_tracing { connect(:keep_retrying => false) }
+        end
+
+        # Warn the user if they have configured their agent not to
+        # send data, that way we can see this clearly in the log file
+        def monitoring?
+          return false if Agent.config[:'serverless_mode.enabled']
+
+          if Agent.config[:monitor_mode]
+            true
+          else
+            ::NewRelic::Agent.logger.warn('Agent configured not to send data in this environment.')
+            false
+          end
+        end
+
+        # Tell the user when the license key is missing so they can
+        # fix it by adding it to the file
+        def has_license_key?
+          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 ' \
+              "environment, '#{NewRelic::Control.instance.env}'. You may also want to try linting your newrelic.yml " \
+              'to ensure it is valid YML.')
+            false
+          end
+        end
+
+        def has_correct_license_key?
+          has_license_key? && correct_license_length
+        end
+
+        # A license key is an arbitrary 40 character string,
+        # usually looks something like a SHA1 hash
+        def correct_license_length
+          key = Agent.config[:license_key]
+
+          if key.length == 40
+            true
+          else
+            ::NewRelic::Agent.logger.error("Invalid license key: #{key}")
+            false
+          end
+        end
+
+        # Check to see if the agent should start, returning +true+ if it should.
+        def agent_should_start?
+          return false if already_started? || disabled?
+
+          if defer_for_delayed_job?
+            ::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')
+            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 ',
+              "value set for app_name in the #{NewRelic::Control.instance.env} ",
+              'environment.')
+            return false
+          end
+
+          return true
+        end
+
+        # The agent is disabled when it is not force enabled by the
+        # 'agent_enabled' option (e.g. in a manual start), or
+        # enabled normally through the configuration file
+        def disabled?
+          !Agent.config[:agent_enabled]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# 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 AgentHelpers
+      module Transmit
+        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
+        def transmit_custom_event_data
+          transmit_single_data_type(:harvest_and_send_custom_event_data, CUSTOM_EVENT)
+        end
+
+        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
+        def transmit_span_event_data
+          transmit_single_data_type(:harvest_and_send_span_event_data, SPAN_EVENT)
+        end
+
+        LOG_EVENT = 'LogEvent'.freeze
+        def transmit_log_event_data
+          transmit_single_data_type(:harvest_and_send_log_event_data, LOG_EVENT)
+        end
+
+        def transmit_single_data_type(harvest_method, supportability_name)
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+          msg = "Sending #{supportability_name} data to New Relic Service"
+          ::NewRelic::Agent.logger.debug(msg)
+
+          @service.session do # use http keep-alive
+            self.send(harvest_method)
+          end
+        ensure
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - now
+          NewRelic::Agent.record_metric("Supportability/#{supportability_name}Harvest", duration)
+        end
+
+        def transmit_data
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          ::NewRelic::Agent.logger.debug('Sending data to New Relic Service')
+
+          @events.notify(:before_harvest)
+          @service.session do # use http keep-alive
+            harvest_and_send_data_types
+
+            check_for_and_handle_agent_commands
+            harvest_and_send_for_agent_commands
+          end
+        ensure
+          NewRelic::Agent::Database.close_connections
+          duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - now
+          NewRelic::Agent.record_metric('Supportability/Harvest', duration)
+        end
+
+        def transmit_data_types
+          transmit_data
+          transmit_analytic_event_data
+          transmit_custom_event_data
+          transmit_error_event_data
+          transmit_span_event_data
+          transmit_log_event_data
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/agent_logger.rb

@@ -1,21 +1,25 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'thread'
 require 'logger'
 require 'new_relic/agent/hostname'
+require 'new_relic/agent/log_once'
+require 'new_relic/agent/instrumentation/logger/instrumentation'
 
 module NewRelic
   module Agent
     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)
         set_log_level!
         set_log_format!
+        disable_log_instrumentation!
 
         gather_startup_logs
       end
@@ -40,30 +44,6 @@ module NewRelic
         format_and_send(:debug, msgs, &blk)
       end
 
-      NUM_LOG_ONCE_KEYS = 1000
-
-      def log_once(level, key, *msgs)
-        @already_logged_lock.synchronize do
-          return if @already_logged.include?(key)
-
-          if @already_logged.size >= NUM_LOG_ONCE_KEYS && key.kind_of?(String)
-            # The reason for preventing too many keys in `logged` is for
-            # memory concerns.
-            # The reason for checking the type of the key is that we always want
-            # to allow symbols to log, since there are very few of them.
-            # The assumption here is that you would NEVER pass dynamically-created
-            # symbols, because you would never create symbols dynamically in the
-            # first place, as that would already be a memory leak in most Rubies,
-            # even if we didn't hang on to them all here.
-            return
-          end
-
-          @already_logged[key] = true
-        end
-
-        self.send(level, *msgs)
-      end
-
       def is_startup_logger?
         @log.is_a?(NullLogger)
       end
@@ -72,23 +52,29 @@ module NewRelic
       # the log level that the backtrace is logged at. If you just want the
       # 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 ])
+      def log_exception(level, e, backtrace_level = level)
+        @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
 
+      def log_formatter=(formatter)
+        @log.formatter = formatter
+      end
+
+      private
+
       def backtrace_from_exception(e)
         # We've seen that often the backtrace on a SystemStackError is bunk
         # so massage the caller instead at a known depth.
         #
-        # Tests keep us honest about minmum method depth our log calls add.
+        # Tests keep us honest about minimum method depth our log calls add.
         return caller.drop(5) if e.is_a?(SystemStackError)
 
         e.backtrace
@@ -97,11 +83,9 @@ module NewRelic
       # Allows for passing exceptions in explicitly, which format with backtrace
       def format_and_send(level, *msgs, &block)
         if block
-          if @log.send("#{level}?")
-            msgs = Array(block.call)
-          else
-            msgs = []
-          end
+          return unless @log.send("#{level}?")
+
+          msgs = Array(yield)
         end
 
         msgs.flatten.each do |item|
@@ -110,6 +94,7 @@ module NewRelic
           else @log.send(level, item)
           end
         end
+        nil
       end
 
       def create_log(root, override_logger)
@@ -146,19 +131,14 @@ module NewRelic
         @log = ::NewRelic::Agent::NullLogger.new
       end
 
-      def clear_already_logged
-        @already_logged_lock.synchronize do
-          @already_logged = {}
-        end
-      end
-
       def wants_stdout?
-        ::NewRelic::Agent.config[:log_file_path].upcase == "STDOUT"
+        ::NewRelic::Agent.config[:log_file_path].casecmp(NewRelic::STANDARD_OUT) == 0 ||
+          ::NewRelic::Agent.config[:'serverless_mode.enabled']
       end
 
       def find_or_create_file_path(path_setting, root)
-        for abs_path in [ File.expand_path(path_setting),
-                          File.expand_path(File.join(root, path_setting)) ] do
+        for abs_path in [File.expand_path(path_setting),
+          File.expand_path(File.join(root, path_setting))] do
           if File.directory?(abs_path) || (Dir.mkdir(abs_path) rescue nil)
             return abs_path[%r{^(.*?)/?$}]
           end
@@ -171,11 +151,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)
@@ -185,17 +165,22 @@ module NewRelic
       def set_log_format!
         @hostname = NewRelic::Agent::Hostname.get
         @prefix = wants_stdout? ? '** [NewRelic]' : ''
-        @log.formatter = Proc.new do |severity, timestamp, progname, msg|
-          "#{@prefix}[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{@hostname} (#{$$})] #{severity} : #{msg}\n"
+        @log.formatter = proc do |severity, timestamp, progname, msg|
+          "#{@prefix}[#{timestamp.strftime('%F %H:%M:%S %z')} #{@hostname} (#{$$})] #{severity} : #{msg}\n"
         end
       end
 
+      # Don't allow agent logs into agent log forwarding for now
+      def disable_log_instrumentation!
+        NewRelic::Agent::Instrumentation::Logger.mark_skip_instrumenting(@log)
+      end
+
       def gather_startup_logs
         StartupLogger.instance.dump(self)
       end
 
-      def log_formatter=(formatter)
-        @log.formatter = formatter
+      def self.format_fatal_error(message)
+        "** [NewRelic] FATAL : #{message}\n"
       end
     end
 

data/lib/new_relic/agent/attribute_filter.rb

@@ -1,8 +1,8 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
-# This class applies filtering rules as specified in the Agent Attributes
+# This class applies filtering rules as specified in the agent attributes
 # cross-agent spec.
 #
 # Instances of it are constructed by deriving a set of rules from the agent
@@ -44,7 +44,7 @@
 # 1. First, the names are compared lexicographically. This has the impact of
 #    forcing shorter (more general) rules towards the top of the list and longer
 #    (more specific) rules towards the bottom. This is important, because the
-#    Agent Attributes spec stipulates that the most specific rule for a given
+#    agent Attributes spec stipulates that the most specific rule for a given
 #    destination should take precedence. Since rules are applied top-to-bottom,
 #    this sorting guarantees that the most specific rule will be applied last.
 # 2. If the names are identical, we next examine the wildcard flag. Rules ending
@@ -66,49 +66,104 @@ module NewRelic
 
       DST_TRANSACTION_EVENTS = 1 << 0
       DST_TRANSACTION_TRACER = 1 << 1
-      DST_ERROR_COLLECTOR    = 1 << 2
+      DST_ERROR_COLLECTOR = 1 << 2
       DST_BROWSER_MONITORING = 1 << 3
-      DST_DEVELOPER_MODE     = 1 << 4
+      DST_SPAN_EVENTS = 1 << 4
+      DST_TRANSACTION_SEGMENTS = 1 << 5
 
-      DST_ALL = 0xF
+      DST_ALL = 0x3f
 
       attr_reader :rules
 
       def initialize(config)
-        @enabled_destinations = DST_NONE
+        prep_enabled_destinations(config)
+        prep_rules(config)
 
-        @enabled_destinations |= DST_TRANSACTION_TRACER if config[:'transaction_tracer.attributes.enabled']
-        @enabled_destinations |= DST_TRANSACTION_EVENTS if config[:'transaction_events.attributes.enabled']
-        @enabled_destinations |= DST_ERROR_COLLECTOR    if config[:'error_collector.attributes.enabled']
-        @enabled_destinations |= DST_BROWSER_MONITORING if config[:'browser_monitoring.attributes.enabled']
+        # We're ok to cache high security for fast lookup because the attribute
+        # filter is re-generated on any significant config change.
+        @high_security = config[:high_security]
+
+        setup_key_cache
+        cache_prefix_denylist
+      end
+
+      def prep_enabled_destinations(config)
+        @enabled_destinations = config[:'attributes.enabled'] ? enabled_destinations_for_attributes(config) : DST_NONE
+      end
 
-        @enabled_destinations = DST_NONE unless config[:'attributes.enabled']
+      def enabled_destinations_for_attributes(config)
+        destinations = DST_NONE
+        destinations |= DST_TRANSACTION_TRACER if config[:'transaction_tracer.attributes.enabled']
+        destinations |= DST_TRANSACTION_EVENTS if config[:'transaction_events.attributes.enabled']
+        destinations |= DST_ERROR_COLLECTOR if config[:'error_collector.attributes.enabled']
+        destinations |= DST_BROWSER_MONITORING if config[:'browser_monitoring.attributes.enabled']
+        destinations |= DST_SPAN_EVENTS if config[:'span_events.attributes.enabled']
+        destinations |= DST_TRANSACTION_SEGMENTS if config[:'transaction_segments.attributes.enabled']
+        destinations
+      end
 
+      def prep_rules(config)
         @rules = []
+        prep_attributes_exclude_rules(config)
+        prep_capture_params_rules(config)
+        prep_datastore_rules(config)
+        prep_attributes_include_rules(config)
+        build_uri_rule(config[:'attributes.exclude'])
+        @rules.sort!
+      end
 
+      def prep_attributes_exclude_rules(config)
         build_rule(config[:'attributes.exclude'], DST_ALL, false)
         build_rule(config[:'transaction_tracer.attributes.exclude'], DST_TRANSACTION_TRACER, false)
         build_rule(config[:'transaction_events.attributes.exclude'], DST_TRANSACTION_EVENTS, false)
-        build_rule(config[:'error_collector.attributes.exclude'],    DST_ERROR_COLLECTOR,    false)
+        build_rule(config[:'error_collector.attributes.exclude'], DST_ERROR_COLLECTOR, false)
         build_rule(config[:'browser_monitoring.attributes.exclude'], DST_BROWSER_MONITORING, false)
+        build_rule(config[:'span_events.attributes.exclude'], DST_SPAN_EVENTS, false)
+        build_rule(config[:'transaction_segments.attributes.exclude'], DST_TRANSACTION_SEGMENTS, false)
+      end
 
+      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)
+        build_rule(%w[host port_path_or_id], DST_TRANSACTION_SEGMENTS, config[:'datastore_tracer.instance_reporting.enabled'])
+        build_rule(['database_name'], DST_TRANSACTION_SEGMENTS, config[:'datastore_tracer.database_name_reporting.enabled'])
+      end
+
+      def prep_attributes_include_rules(config)
         build_rule(config[:'attributes.include'], DST_ALL, true)
         build_rule(config[:'transaction_tracer.attributes.include'], DST_TRANSACTION_TRACER, true)
         build_rule(config[:'transaction_events.attributes.include'], DST_TRANSACTION_EVENTS, true)
-        build_rule(config[:'error_collector.attributes.include'],    DST_ERROR_COLLECTOR,    true)
+        build_rule(config[:'error_collector.attributes.include'], DST_ERROR_COLLECTOR, true)
         build_rule(config[:'browser_monitoring.attributes.include'], DST_BROWSER_MONITORING, true)
+        build_rule(config[:'span_events.attributes.include'], DST_SPAN_EVENTS, true)
+        build_rule(config[:'transaction_segments.attributes.include'], DST_TRANSACTION_SEGMENTS, true)
+      end
 
-        @rules.sort!
-
-        # We're ok to cache high security for fast lookup because the attribute
-        # filter is re-generated on any significant config change.
-        @high_security = config[:high_security]
-
-        cache_prefix_blacklist
+      # Note the key_cache is a global cache, accessible by multiple threads,
+      # but is intentionally left unsynchronized for liveness. Writes will always
+      # involve writing the same boolean value for each key, so there is no
+      # worry of one value clobbering another. For reads, if a value hasn't been
+      # written to the cache yet, the worst that will happen is that it will run
+      # through the filter rules again. Both reads and writes will become
+      # eventually consistent.
+
+      def setup_key_cache
+        destinations = [
+          DST_TRANSACTION_EVENTS,
+          DST_TRANSACTION_TRACER,
+          DST_ERROR_COLLECTOR,
+          DST_BROWSER_MONITORING,
+          DST_SPAN_EVENTS,
+          DST_TRANSACTION_SEGMENTS,
+          DST_ALL
+        ]
+
+        @key_cache = destinations.inject({}) do |memo, destination|
+          memo[destination] = {}
+          memo
+        end
       end
 
       def include_destinations_for_capture_params(capturing)
@@ -126,10 +181,18 @@ module NewRelic
         end
       end
 
+      def build_uri_rule(excluded_attributes)
+        uri_aliases = %w[uri url request_uri request.uri http.url]
+
+        if (excluded_attributes & uri_aliases).size > 0
+          build_rule(uri_aliases - excluded_attributes, DST_ALL, false)
+        end
+      end
+
       def apply(attribute_name, default_destinations)
         return DST_NONE if @enabled_destinations == DST_NONE
 
-        destinations   = default_destinations
+        destinations = default_destinations
         attribute_name = attribute_name.to_s
 
         @rules.each do |rule|
@@ -149,6 +212,19 @@ module NewRelic
         allowed_destinations & requested_destination == requested_destination
       end
 
+      def allows_key?(key, destination)
+        return false unless destination & @enabled_destinations == destination
+
+        value = @key_cache[destination][key]
+
+        if value.nil?
+          allowed_destinations = apply(key, destination)
+          @key_cache[destination][key] = allows?(allowed_destinations, destination)
+        else
+          value
+        end
+      end
+
       def high_security?
         @high_security
       end
@@ -163,16 +239,16 @@ module NewRelic
       # arguments for Sidekiq and Resque in the common case, since none of
       # these attributes are captured by default.
       #
-      def cache_prefix_blacklist
-        @prefix_blacklist = {}
-        @prefix_blacklist[:'request.parameters'] = true unless might_allow_prefix_uncached?(:'request.parameters')
-        @prefix_blacklist[:'job.sidekiq.args']   = true unless might_allow_prefix_uncached?(:'job.sidekiq.args')
-        @prefix_blacklist[:'job.resque.args']    = true unless might_allow_prefix_uncached?(:'job.resque.args')
+      def cache_prefix_denylist
+        @prefix_denylist = {}
+        @prefix_denylist[:'request.parameters'] = true unless might_allow_prefix_uncached?(:'request.parameters')
+        @prefix_denylist[:'job.sidekiq.args'] = true unless might_allow_prefix_uncached?(:'job.sidekiq.args')
+        @prefix_denylist[:'job.resque.args'] = true unless might_allow_prefix_uncached?(:'job.resque.args')
       end
 
       # Note that the given prefix *must* be a Symbol
       def might_allow_prefix?(prefix)
-        !@prefix_blacklist.include?(prefix)
+        !@prefix_denylist.include?(prefix)
       end
 
       def might_allow_prefix_uncached?(prefix)
@@ -197,10 +273,10 @@ 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?("*")
-        @is_include     = is_include
-        @destinations   = is_include ? destinations : ~destinations
+        @attribute_name = attribute_name.sub(/\*$/, '')
+        @wildcard = attribute_name.end_with?(ASTERISK)
+        @is_include = is_include
+        @destinations = is_include ? destinations : ~destinations
       end
 
       # Rules are sorted from least specific to most specific