newrelic_rpm 6.15.0 → 9.7.1

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

@@ -0,0 +1,202 @@
+# 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?
+          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
+
+        # A correct license key exists and is of the proper length
+        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,23 +1,25 @@
-# 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.
+# 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
@@ -50,14 +52,14 @@ 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
@@ -72,7 +74,7 @@ module NewRelic
         # 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
@@ -81,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|
@@ -132,12 +132,12 @@ module NewRelic
       end
 
       def wants_stdout?
-        ::NewRelic::Agent.config[:log_file_path].upcase == "STDOUT"
+        ::NewRelic::Agent.config[:log_file_path].casecmp(NewRelic::STANDARD_OUT) == 0
       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
@@ -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)
@@ -164,19 +164,23 @@ 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("%F %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 self.format_fatal_error message
+      def self.format_fatal_error(message)
         "** [NewRelic] FATAL : #{message}\n"
       end
-
     end
 
     # In an effort to not lose messages during startup, we trap them in memory

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/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
@@ -64,64 +64,81 @@ module NewRelic
     class AttributeFilter
       DST_NONE = 0x0
 
-      DST_TRANSACTION_EVENTS   = 1 << 0
-      DST_TRANSACTION_TRACER   = 1 << 1
-      DST_ERROR_COLLECTOR      = 1 << 2
-      DST_BROWSER_MONITORING   = 1 << 3
-      DST_SPAN_EVENTS          = 1 << 4
+      DST_TRANSACTION_EVENTS = 1 << 0
+      DST_TRANSACTION_TRACER = 1 << 1
+      DST_ERROR_COLLECTOR = 1 << 2
+      DST_BROWSER_MONITORING = 1 << 3
+      DST_SPAN_EVENTS = 1 << 4
       DST_TRANSACTION_SEGMENTS = 1 << 5
 
-      DST_ALL                  = 0x3f
+      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']
-        @enabled_destinations |= DST_SPAN_EVENTS          if config[:'span_events.attributes.enabled']
-        @enabled_destinations |= DST_TRANSACTION_SEGMENTS if config[:'transaction_segments.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
 
-        @enabled_destinations = DST_NONE unless config[:'attributes.enabled']
+      def prep_enabled_destinations(config)
+        @enabled_destinations = config[:'attributes.enabled'] ? enabled_destinations_for_attributes(config) : DST_NONE
+      end
+
+      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[:'browser_monitoring.attributes.exclude'],   DST_BROWSER_MONITORING,   false)
-        build_rule(config[:'span_events.attributes.exclude'],          DST_SPAN_EVENTS,          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[:'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
 
-        build_rule(['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'])
+      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[:'browser_monitoring.attributes.include'],   DST_BROWSER_MONITORING,   true)
-        build_rule(config[:'span_events.attributes.include'],          DST_SPAN_EVENTS,          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[:'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)
-
-        build_uri_rule(config[:'attributes.exclude'])
-
-        @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]
-
-        setup_key_cache
-        cache_prefix_denylist
       end
 
       # Note the key_cache is a global cache, accessible by multiple threads,
@@ -165,7 +182,7 @@ module NewRelic
       end
 
       def build_uri_rule(excluded_attributes)
-        uri_aliases = %w(uri url request_uri request.uri http.url)
+        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)
@@ -175,7 +192,7 @@ module NewRelic
       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|
@@ -225,8 +242,8 @@ module NewRelic
       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')
+        @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
@@ -256,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