Module: NewRelic::Agent::Agent::InstanceMethods::Start

Included in:
NewRelic::Agent::Agent::InstanceMethods
Defined in:
lib/new_relic/agent/agent.rb

Overview

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

Instance Method Summary collapse

Instance Method Details

#already_started? ⇒ Boolean

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

Returns:

  • (Boolean) 


306
307
308
309
310
311
 
# File 'lib/new_relic/agent/agent.rb', line 306

def already_started?
  if started?
    ::NewRelic::Agent.logger.error("Agent Started Already!")
    true
  end
end

#app_name_configured? ⇒ Boolean

Logs the configured application names

Returns:

  • (Boolean) 


347
348
349
350
 
# File 'lib/new_relic/agent/agent.rb', line 347

def app_name_configured?
  names = Agent.config.app_names
  return names.respond_to?(:any?) && names.any?
end

#check_config_and_start_agent ⇒ Object

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



465
466
467
468
469
470
471
472
 
# File 'lib/new_relic/agent/agent.rb', line 465

def check_config_and_start_agent
  return unless monitoring? && has_correct_license_key?
  return if using_forking_dispatcher?
  generate_environment_report
  connect_in_foreground if Agent.config[:sync_startup]
  start_worker_thread
  install_exit_handler
end

#connect_in_foreground ⇒ Object

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



357
358
359
 
# File 'lib/new_relic/agent/agent.rb', line 357

def connect_in_foreground
  NewRelic::Agent.disable_all_tracing { connect(:keep_retrying => false) }
end

#correct_license_length ⇒ Object

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



441
442
443
444
 
# File 'lib/new_relic/agent/agent.rb', line 441

def correct_license_length
  key = Agent.config[:license_key]
  log_unless((key.length == 40), :error, "Invalid license key: #{key}")
end

#defer_for_resque? ⇒ Boolean

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)

Returns:

  • (Boolean) 


457
458
459
460
 
# File 'lib/new_relic/agent/agent.rb', line 457

def defer_for_resque?
  NewRelic::Agent.config[:dispatcher] == :resque &&
    !NewRelic::Agent::PipeChannelManager.listener.started?
end

#disabled? ⇒ Boolean

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

Returns:

  • (Boolean) 


316
317
318
 
# File 'lib/new_relic/agent/agent.rb', line 316

def disabled?
  !Agent.config[:agent_enabled]
end

#has_correct_license_key? ⇒ Boolean

A correct license key exists and is of the proper length

Returns:

  • (Boolean) 


435
436
437
 
# File 'lib/new_relic/agent/agent.rb', line 435

def has_correct_license_key?
  has_license_key? && correct_license_length
end

#has_license_key? ⇒ Boolean

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

Returns:

  • (Boolean) 


428
429
430
431
432
 
# File 'lib/new_relic/agent/agent.rb', line 428

def has_license_key?
  log_unless(Agent.config[:license_key], :warn,
             "No license key found in newrelic.yml config. " +
             "This often means your newrelic.yml is missing a section for the running environment '#{NewRelic::Control.instance.env}'")
end

#install_exit_handler ⇒ Object

Installs our exit handler, which exploits the weird behavior of at_exit blocks to make sure it runs last, by doing an at_exit within an at_exit block.



378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
 
# File 'lib/new_relic/agent/agent.rb', line 378

def install_exit_handler
  if Agent.config[:send_data_on_exit] && !weird_ruby?
    at_exit do
      # Workaround for MRI 1.9 bug that loses exit codes in at_exit blocks.
      # This is necessary to get correct exit codes for the agent's
      # test suites.
      # http://bugs.ruby-lang.org/issues/5218
      if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION.match(/^1\.9/)
        exit_status = $!.status if $!.is_a?(SystemExit)
        shutdown
        exit exit_status if exit_status
      else
        shutdown
      end
    end
  end
end

#log_app_name ⇒ Object 



342
343
344
 
# File 'lib/new_relic/agent/agent.rb', line 342

def log_app_name
  ::NewRelic::Agent.logger.info "Application: #{Agent.config.app_names.join(", ")}"
end

#log_dispatcher ⇒ Object

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



336
337
338
339
340
 
# File 'lib/new_relic/agent/agent.rb', line 336

def log_dispatcher
  dispatcher_name = Agent.config[:dispatcher].to_s
  return if log_if(dispatcher_name.empty?, :info, "No known dispatcher detected.")
  ::NewRelic::Agent.logger.info "Dispatcher: #{dispatcher_name}"
end

#log_environment ⇒ Object

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



329
330
331
 
# File 'lib/new_relic/agent/agent.rb', line 329

def log_environment
  ::NewRelic::Agent.logger.info "Environment: #{NewRelic::Control.instance.env}"
end

#log_if(boolean, level, message) ⇒ Object

A helper method that logs a condition if that condition is true. Mentally cleaner than having every method set a local and log if it is true



406
407
408
409
 
# File 'lib/new_relic/agent/agent.rb', line 406

def log_if(boolean, level, message)
  ::NewRelic::Agent.logger.send(level, message) if boolean
  boolean
end

#log_startup ⇒ Object

Log startup information that we almost always want to know



321
322
323
324
325
 
# File 'lib/new_relic/agent/agent.rb', line 321

def log_startup
  log_environment
  log_dispatcher
  log_app_name
end

#log_unless(boolean, level, message) ⇒ Object

A helper method that logs a condition unless that condition is true. Mentally cleaner than having every method set a local and log unless it is true



414
415
416
417
 
# File 'lib/new_relic/agent/agent.rb', line 414

def log_unless(boolean, level, message)
  ::NewRelic::Agent.logger.send(level, message) unless boolean
  boolean
end

#log_version_and_pid ⇒ Object

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



399
400
401
 
# File 'lib/new_relic/agent/agent.rb', line 399

def log_version_and_pid
  ::NewRelic::Agent.logger.debug "New Relic Ruby Agent #{NewRelic::VERSION::STRING} Initialized: pid = #{$$}"
end

#monitoring? ⇒ Boolean

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

Returns:

  • (Boolean) 


421
422
423
424
 
# File 'lib/new_relic/agent/agent.rb', line 421

def monitoring?
  log_unless(Agent.config[:monitor_mode], :warn,
             "Agent configured not to send data in this environment.")
end

#using_forking_dispatcher? ⇒ Boolean

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 odd data

Returns:

  • (Boolean) 


449
450
451
452
 
# File 'lib/new_relic/agent/agent.rb', line 449

def using_forking_dispatcher?
  log_if([:passenger, :rainbows, :unicorn].include?(Agent.config[:dispatcher]),
         :info, "Connecting workers after forking.")
end

#using_sinatra? ⇒ Boolean

If we’re using sinatra, old versions run in an at_exit block so we should probably know that

Returns:

  • (Boolean) 


363
364
365
 
# File 'lib/new_relic/agent/agent.rb', line 363

def using_sinatra?
  defined?(Sinatra::Application)
end

#weird_ruby? ⇒ Boolean

we should not set an at_exit block if people are using these as they don’t do standard at_exit behavior per MRI/YARV

Returns:

  • (Boolean) 


369
370
371
372
373
 
# File 'lib/new_relic/agent/agent.rb', line 369

def weird_ruby?
  NewRelic::LanguageSupport.using_engine?('rbx') ||
    NewRelic::LanguageSupport.using_engine?('jruby') ||
    using_sinatra?
end