Module NewRelic::Agent::Agent::InstanceMethods::Start
In: lib/new_relic/agent/agent.rb

Herein lies the corpse of the former ‘start’ method. May its unmatched flog score rest in pieces.

Methods

already_started?   app_name_configured?   check_config_and_start_agent   connect_in_foreground   correct_license_length   defer_for_resque?   disabled?   has_correct_license_key?   has_license_key?   in_resque_child_process?   install_exit_handler   log_app_name   log_dispatcher   log_environment   log_ignore_url_regexes   log_startup   log_version_and_pid   monitoring?   need_exit_code_workaround?   setup_and_start_agent   should_install_exit_handler?   sinatra_classic_app?   using_forking_dispatcher?  

Public Instance methods

already_started?()

Check whether we have already started, which is an error condition

app_name_configured?()

Logs the configured application names

check_config_and_start_agent()

Sanity-check the agent configuration and start the agent, setting up the worker thread and the exit handler to shut down the agent

connect_in_foreground()

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

correct_license_length()

A license key is an arbitrary 40 character string, usually looks something like a SHA1 hash

defer_for_resque?()

Return true if we‘re using resque and it hasn‘t had a chance to (potentially) daemonize itself. This avoids hanging when there‘s a Thread started before Resque calls Process.daemon (Jira RUBY-857)

disabled?()

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

has_correct_license_key?()

A correct license key exists and is of the proper length

has_license_key?()

Tell the user when the license key is missing so they can fix it by adding it to the file

log_dispatcher()

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

log_environment()

Log the environment the app thinks it‘s running in. Useful in debugging, as this is the key for config YAML lookups.

log_startup()

Log startup information that we almost always want to know

log_version_and_pid()

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

monitoring?()

Warn the user if they have configured their agent not to send data, that way we can see this clearly in the log file

need_exit_code_workaround?()

There‘s an MRI 1.9 bug that loses exit codes in at_exit blocks. A workaround is necessary to get correct exit codes for the agent‘s test suites. bugs.ruby-lang.org/issues/5218

setup_and_start_agent(options={})

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.

sinatra_classic_app?()

This matters when the following three criteria are met:

  1. A Sinatra ‘classic’ application is being run
  2. The app is being run by executing the main file directly, rather than via a config.ru file.
  3. newrelic_rpm is required after sinatra

In this case, the entire application runs from an at_exit handler in Sinatra, and if we were to install ours, it would be executed before the one in Sinatra, meaning that we‘d shutdown the agent too early and never collect any data.

using_forking_dispatcher?()

If we‘re using a dispatcher that forks before serving requests, we need to wait until the children are forked before connecting, otherwise the parent process sends useless data

[Validate]