Module: NewRelic::Agent::Agent::InstanceMethods::Connect

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

Overview

This module is an artifact of a refactoring of the connect method - all of its methods are used in that context, so it can be refactored at will. It should be fully tested

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#connect_attempts ⇒ Object

number of attempts we’ve made to contact the server



674
675
676
 
# File 'lib/new_relic/agent/agent.rb', line 674

def connect_attempts
  @connect_attempts
end

Instance Method Details

#add_rules_to_engine(rule_specifications, rules_engine) ⇒ Object 



812
813
814
815
816
817
 
# File 'lib/new_relic/agent/agent.rb', line 812

def add_rules_to_engine(rule_specifications, rules_engine)
  return unless rule_specifications && rule_specifications.any?
  rule_specifications.each do |rule_spec|
    rules_engine << NewRelic::Agent::RulesEngine::Rule.new(rule_spec)
  end
end

#apdex_f ⇒ Object

apdex_f is always 4 times the apdex_t



770
771
772
 
# File 'lib/new_relic/agent/agent.rb', line 770

def apdex_f
  (4 * Agent.config[:apdex_t]).to_f
end

#connect_retry_period ⇒ Object

Retry period is a minute for each failed attempt that we’ve made. This should probably do some sort of sane TCP backoff to prevent hammering the server, but a minute for each attempt seems to work reasonably well.



702
703
704
 
# File 'lib/new_relic/agent/agent.rb', line 702

def connect_retry_period
  [600, connect_attempts * 60].min
end

#connect_settings ⇒ Object

Initializes the hash of settings that we send to the server. Returns a literal hash containing the options



752
753
754
755
756
757
758
759
760
761
762
 
# File 'lib/new_relic/agent/agent.rb', line 752

def connect_settings
  {
    :pid => $$,
    :host => @local_host,
    :app_name => Agent.config.app_names,
    :language => 'ruby',
    :agent_version => NewRelic::VERSION::STRING,
    :environment => @environment_report,
    :settings => Agent.config.to_collector_hash,
  }
end

#connect_to_server ⇒ Object

Returns connect data passed back from the server



765
766
767
 
# File 'lib/new_relic/agent/agent.rb', line 765

def connect_to_server
  @service.connect(connect_settings)
end

#connected? ⇒ Boolean

Returns:

  • (Boolean) 


683
684
685
 
# File 'lib/new_relic/agent/agent.rb', line 683

def connected?
  @connect_state == :connected
end

#disconnect ⇒ Object

Disconnect just sets connected to false, which prevents the agent from trying to connect again



678
679
680
681
 
# File 'lib/new_relic/agent/agent.rb', line 678

def disconnect
  @connect_state = :disconnected
  true
end

#disconnected? ⇒ Boolean

Returns:

  • (Boolean) 


687
688
689
 
# File 'lib/new_relic/agent/agent.rb', line 687

def disconnected?
  @connect_state == :disconnected
end

#environment_for_connect ⇒ Object

Checks whether we should send environment info, and if so, returns the snapshot from the local environment. Generating the EnvironmentReport has the potential to trigger require calls in Rails environments, so this method should only be called synchronously from on the main thread.



746
747
748
 
# File 'lib/new_relic/agent/agent.rb', line 746

def environment_for_connect
  Agent.config[:send_environment_info] ? Array(EnvironmentReport.new) : []
end

#finish_setup(config_data) ⇒ Object

Takes a hash of configuration data returned from the server and uses it to set local variables and to initialize various parts of the agent that are configured separately.

Can accommodate most arbitrary data - anything extra is ignored unless we say to do something with it here.



787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
 
# File 'lib/new_relic/agent/agent.rb', line 787

def finish_setup(config_data)
  return if config_data == nil

  @service.agent_id = config_data['agent_run_id'] if @service

  if config_data['agent_config']
    ::NewRelic::Agent.logger.debug "Using config from server"
  end

  ::NewRelic::Agent.logger.debug "Server provided config: #{config_data.inspect}"
  server_config = NewRelic::Agent::Configuration::ServerSource.new(config_data, Agent.config)
  Agent.config.apply_config(server_config, 1)
  log_connection!(config_data) if @service

  add_rules_to_engine(config_data['transaction_name_rules'],
                      NewRelic::Agent.instance.transaction_rules)
  add_rules_to_engine(config_data['metric_name_rules'],
                      NewRelic::Agent.instance.metric_rules)

  # If you're adding something else here to respond to the server-side config,
  # use Agent.instance.events.subscribe(:finished_configuring) callback instead!

  @beacon_configuration = BeaconConfiguration.new
end

#generate_environment_report ⇒ Object 



737
738
739
 
# File 'lib/new_relic/agent/agent.rb', line 737

def generate_environment_report
  @environment_report = environment_for_connect
end

#handle_license_error(error) ⇒ Object

When the server sends us an error with the license key, we want to tell the user that something went wrong, and let them know where to go to get a valid license key

After this runs, it disconnects the agent so that it will no longer try to connect to the server, saving the application and the server load



724
725
726
727
728
729
 
# File 'lib/new_relic/agent/agent.rb', line 724

def handle_license_error(error)
  ::NewRelic::Agent.logger.error( \
    error.message, \
    "Visit NewRelic.com to obtain a valid license key, or to upgrade your account.")
  disconnect
end

#handle_unrecoverable_agent_error(error) ⇒ Object 



731
732
733
734
735
 
# File 'lib/new_relic/agent/agent.rb', line 731

def handle_unrecoverable_agent_error(error)
  ::NewRelic::Agent.logger.error(error.message)
  disconnect
  shutdown
end

#log_collector_messages(messages) ⇒ Object 



830
831
832
833
834
 
# File 'lib/new_relic/agent/agent.rb', line 830

def log_collector_messages(messages)
  messages.each do |message|
    ::NewRelic::Agent.logger.send(message['level'].downcase, message['message'])
  end
end

#log_connection!(config_data) ⇒ Object

Logs when we connect to the server, for debugging purposes

  • makes sure we know if an agent has not connected



821
822
823
824
825
826
827
828
 
# File 'lib/new_relic/agent/agent.rb', line 821

def log_connection!(config_data)
  ::NewRelic::Agent.logger.debug "Connected to NewRelic Service at #{@service.collector.name}"
  ::NewRelic::Agent.logger.debug "Agent Run       = #{@service.agent_id}."
  ::NewRelic::Agent.logger.debug "Connection data = #{config_data.inspect}"
  if config_data['messages'] && config_data['messages'].any?
    log_collector_messages(config_data['messages'])
  end
end

#log_error(error) ⇒ Object

When we have a problem connecting to the server, we need to tell the user what happened, since this is not an error we can handle gracefully.



713
714
715
 
# File 'lib/new_relic/agent/agent.rb', line 713

def log_error(error)
  ::NewRelic::Agent.logger.error "Error establishing connection with New Relic Service at #{control.server}:", error
end

#note_connect_failure ⇒ Object 



706
707
708
 
# File 'lib/new_relic/agent/agent.rb', line 706

def note_connect_failure
  self.connect_attempts += 1
end

#query_server_for_configuration ⇒ Object

Sets the collector host and connects to the server, then invokes the final configuration with the returned data



776
777
778
 
# File 'lib/new_relic/agent/agent.rb', line 776

def query_server_for_configuration
  finish_setup(connect_to_server)
end

#should_connect?(force = false) ⇒ Boolean

Don’t connect if we’re already connected, or if we tried to connect and were rejected with prejudice because of a license issue, unless we’re forced to by force_reconnect.

Returns:

  • (Boolean) 


694
695
696
 
# File 'lib/new_relic/agent/agent.rb', line 694

def should_connect?(force=false)
  force || (!connected? && !disconnected?)
end