wd_newrelic_rpm 3.3.4.1

data/test/new_relic/control/class_methods_test.rb

@@ -0,0 +1,62 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'new_relic/control/class_methods'
+
+class BaseClassMethods
+  # stub class to enable testing of the module
+  include NewRelic::Control::ClassMethods
+end
+
+class NewRelic::Control::ClassMethodsTest < Test::Unit::TestCase
+  def setup
+    @base = ::BaseClassMethods.new
+    super
+  end
+
+  def test_instance
+    assert_equal(nil, @base.instance_variable_get('@instance'), 'instance should start out nil')
+    @base.expects(:new_instance).returns('a new instance')
+    assert_equal('a new instance', @base.instance, "should return the result from the #new_instance call")
+  end
+
+  def test_new_instance_non_test
+    local_env = mock('local env')
+    @base.expects(:local_env).returns(local_env).at_least_once
+    local_env.expects(:framework).returns('nontest').twice
+    mock_klass = mock('klass')
+    mock_klass.expects(:new).with(local_env)
+    @base.expects(:load_framework_class).with('nontest').returns(mock_klass)
+    @base.new_instance
+  end
+  
+  def test_new_instance_test_framework
+    local_env = mock('local env')
+    local_env.expects(:framework).returns(:test)
+    @base.expects(:local_env).returns(local_env)
+    @base.expects(:load_test_framework)
+    @base.new_instance
+  end
+
+  def test_load_test_framework
+    local_env = mock('local env')
+    # a loose requirement here because the tests will *all* break if
+    # this does not work.
+    NewRelic::Control::Frameworks::Test.expects(:new).with(local_env, instance_of(String))
+    @base.expects(:local_env).returns(local_env)
+    @base.load_test_framework
+  end
+
+  def test_load_framework_class_existing
+    %w[rails rails3 sinatra ruby merb external].each do |type|
+      @base.load_framework_class(type)
+    end
+  end
+  
+  def test_load_framework_class_missing
+    # this is used to allow other people to insert frameworks without
+    # having the file in our agent, i.e. define your own
+    # NewRelic::Control::Framework::FooBar
+    assert_raise(NameError) do
+      @base.load_framework_class('missing')
+    end
+  end
+end

data/test/new_relic/control/configuration_test.rb

@@ -0,0 +1,84 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'/../../test_helper'))
+
+class NewRelic::Control::ConfigurationTest < Test::Unit::TestCase
+  require 'new_relic/control/configuration'
+  include NewRelic::Control::Configuration
+  
+  def setup
+    # The log stuff is memoized so let's clear it each time.
+    NewRelic::Control.instance.instance_variable_set '@log_path', nil
+    NewRelic::Control.instance.instance_variable_set '@log_file', nil
+    @root = ::Rails::VERSION::MAJOR == 3 ? Rails.root : RAILS_ROOT
+  end
+  
+  def teardown
+    NewRelic::Control.instance.settings.delete('log_file_path')
+  end
+  
+  def test_license_key_defaults_to_env_variable
+    ENV['NEWRELIC_LICENSE_KEY'] = nil
+    self.expects(:fetch).with('license_key', nil)
+    license_key
+
+    ENV['NEWRELIC_LICENSE_KEY'] = "a string"
+    self.expects(:fetch).with('license_key', 'a string')
+    license_key
+  end
+  
+  def test_log_path_uses_default_if_not_set
+    NewRelic::Control.instance.setup_log
+    assert_equal(File.expand_path("log/newrelic_agent.log"),
+                 NewRelic::Control.instance.log_file)
+  end
+
+  def test_log_file_path_uses_given_value
+    Dir.stubs(:mkdir).returns(true)
+    NewRelic::Control.instance['log_file_path'] = 'lerg'
+    NewRelic::Control.instance.setup_log
+    assert_match(/\/lerg\/newrelic_agent.log/,
+                 NewRelic::Control.instance.log_file)
+    NewRelic::Control.instance.settings.delete('log_file_path') # = nil    
+  end
+
+  def test_server_side_config_ignores_yaml
+    settings.merge! 'ssl' => false, 'transaction_tracer' => {'enabled' => true, 'stack_trace_threshold' => 1.0}, 'error_collector' => {'enabled' => true, 'ignore_errors' => 'ActiveRecord::RecordNotFound'}, 'capture_params' => false
+    merge_server_side_config 'transaction_tracer.enabled' => false, 'error_collector.enabled' => false
+    assert_equal({'ssl' => false, 'transaction_tracer' => {'enabled' => false}, 'error_collector' => {'enabled' => false}}, settings)
+  end
+
+  def test_install_browser_monitoring
+    require(File.expand_path(File.join(File.dirname(__FILE__),
+                         '/../../../lib/new_relic/rack/browser_monitoring')))
+    middleware = stub('middleware config')
+    config = stub('rails config', :middleware => middleware)
+    middleware.expects(:use).with(NewRelic::Rack::BrowserMonitoring)
+    NewRelic::Control.instance['browser_monitoring'] = { 'auto_instrument' => true }
+    NewRelic::Control.instance.instance_eval { @browser_monitoring_installed = false }
+
+    NewRelic::Control.instance.install_browser_monitoring(config)
+  end
+
+  def test_install_browser_monitoring_should_not_install_when_not_configured
+    middleware = stub('middleware config')
+    config = stub('rails config', :middleware => middleware)
+    middleware.expects(:use).never
+    NewRelic::Control.instance['browser_monitoring'] = { 'auto_instrument' => false }
+    NewRelic::Control.instance.instance_eval { @browser_monitoring_installed = false }
+    
+    NewRelic::Control.instance.install_browser_monitoring(config)
+
+    NewRelic::Control.instance['browser_monitoring'] = { 'auto_instrument' => true }
+  end
+
+  def test_data_serialization_default_off
+    DependencyDetection.send(:class_variable_set, '@@items', [])
+    assert NewRelic::Control.instance.disable_serialization?
+  end
+
+  def test_data_serialization_default_on_when_using_resque
+    DependencyDetection.defer { @name = :resque }
+    DependencyDetection.dependency_by_name(:resque).executed!
+    assert !NewRelic::Control.instance.disable_serialization?
+    DependencyDetection.send(:class_variable_set, '@@items', [])
+  end
+end

data/test/new_relic/control/logging_methods_test.rb

@@ -0,0 +1,185 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+require 'new_relic/control/logging_methods'
+require 'fileutils'
+
+class BaseLoggingMethods
+  # stub class to enable testing of the module
+  include NewRelic::Control::LoggingMethods
+  include NewRelic::Control::Configuration
+  def root; "."; end
+end
+
+class NewRelic::Control::LoggingMethodsTest < Test::Unit::TestCase
+  def setup
+    @base = BaseLoggingMethods.new
+    @base.settings['log_file_path'] = 'log/'
+    @base.settings['log_file_name'] = 'newrelic_agent.log'
+    super
+  end
+
+  def test_log_basic
+    mock_logger = mock('logger')
+    @base.instance_eval { @log = mock_logger }
+    assert_equal mock_logger, @base.log
+  end
+
+  def test_log_no_log
+    log = @base.log
+    assert_equal Logger, log.class
+    assert_equal Logger::INFO, log.level
+    # have to root around in the logger for the logdev
+    assert_equal STDOUT, log.instance_eval { @logdev }.dev
+  end
+
+  def test_logbang_basic
+    @base.expects(:should_log?).returns(true)
+    @base.expects(:to_stdout).with('whee')
+    @base.instance_eval { @log = nil }
+    @base.log!('whee')
+  end
+
+  def test_logbang_should_not_log
+    @base.expects(:should_log?).returns(false)
+    @base.stubs(:to_stdout)
+    assert_equal nil, @base.log!('whee')
+  end
+
+  def test_logbang_with_log
+    @base.expects(:should_log?).returns(true)
+    @base.expects(:to_stdout).with('whee')
+    fake_logger = mock('log')
+    fake_logger.expects(:send).with(:info, 'whee')
+    @base.instance_eval { @log = fake_logger }
+    @base.log!('whee')
+  end
+
+  def test_should_log_no_settings
+    @base.instance_eval { @settings = nil }
+    assert !@base.should_log?
+  end
+
+  def test_should_log_agent_disabled
+    @base.instance_eval { @settings = true }
+    @base.expects(:agent_enabled?).returns(false)
+    assert !@base.should_log?
+  end
+
+  def test_should_log_agent_enabled
+    @base.instance_eval { @settings = true }
+    @base.expects(:agent_enabled?).returns(true)
+    assert @base.should_log?
+  end
+
+  def test_set_log_level_base
+    fake_logger = mock('logger')
+    # bad configuration
+    @base.expects(:fetch).with('log_level', 'info').returns('whee')
+    fake_logger.expects(:level=).with(Logger::INFO)
+    assert_equal fake_logger, @base.set_log_level!(fake_logger)
+  end
+
+  def test_set_log_level_with_each_level
+    fake_logger = mock('logger')
+    %w[debug info warn error fatal].each do |level|
+      @base.expects(:fetch).with('log_level', 'info').returns(level)
+      fake_logger.expects(:level=).with(Logger.const_get(level.upcase))
+      assert_equal fake_logger, @base.set_log_level!(fake_logger)
+    end
+  end
+
+  def test_set_log_format
+    fake_logger = Object.new
+    assert !fake_logger.respond_to?(:format_message)
+    assert_equal fake_logger, @base.set_log_format!(fake_logger)
+    assert fake_logger.respond_to?(:format_message)
+  end
+
+  def test_setup_log_existing_file
+    fake_logger = mock('logger')
+    Logger.expects(:new).with('logpath/logfilename').returns(fake_logger)
+    @base.expects(:log_path).returns('logpath').at_least_once
+    @base.expects(:log_file_name).returns('logfilename')
+    @base.expects(:set_log_format!).with(fake_logger)
+    @base.expects(:set_log_level!).with(fake_logger)
+    assert_equal fake_logger, @base.setup_log
+    assert_equal fake_logger, @base.instance_eval { @log }
+    assert_equal 'logpath/logfilename', @base.instance_eval { @log_file }
+  end
+
+  def test_to_stdout
+    STDOUT.expects(:puts).with('** [NewRelic] whee')
+    @base.to_stdout('whee')
+  end
+
+  def test_log_path_exists
+    @base.instance_eval { @log_path = 'logpath' }
+    assert_equal 'logpath', @base.log_path
+  end
+
+  def test_log_path_path_exists
+    @base.settings['log_file_path'] = 'log'
+    assert File.directory?('log')
+    assert_equal File.expand_path('log'), @base.log_path
+  end
+
+  def test_log_path_path_created
+    path = File.expand_path('tmp/log_path_test')
+    @base.instance_eval { @log_path = nil }
+    @base.settings['log_file_path'] = 'tmp/log_path_test'
+    assert !File.directory?(path) || FileUtils.rmdir(path)
+    @base.expects(:log!).never
+    assert_equal path, @base.log_path
+    assert File.directory?(path)
+  end
+
+  def test_log_path_path_unable_to_create
+    path = File.expand_path('tmp/log_path_test')
+    @base.instance_eval { @log_path = nil }
+    @base.settings['log_file_path'] = 'tmp/log_path_test'
+    assert !File.directory?(path) || FileUtils.rmdir(path)
+    @base.expects(:log!).with("Error creating log directory tmp/log_path_test, using standard out for logging.", :warn)
+    Dir.expects(:mkdir).with(path).raises('cannot make directory bro!').twice # once for the relative directory, once for the directory relative to Rails.root
+    assert_nil @base.log_path
+    assert !File.directory?(path)
+    assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev    
+  end
+
+  def test_log_file_name
+    @base.expects(:fetch).with('log_file_name', 'newrelic_agent.log').returns('log_file_name')
+    assert_equal 'log_file_name', @base.log_file_name
+  end
+
+  def test_log_to_stdout_when_log_file_path_set_to_STDOUT
+    @base.stubs(:fetch).returns('whatever')
+    @base.expects(:fetch).with('log_file_path', 'log').returns('STDOUT')
+    Dir.expects(:mkdir).never
+    @base.setup_log
+    assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev    
+  end
+
+  def test_logs_to_stdout_include_newrelic_prefix
+    @base.stubs(:fetch).returns('whatever')
+    @base.expects(:fetch).with('log_file_path', 'log').returns('STDOUT')
+    STDOUT.expects(:write).with(regexp_matches(/\*\* \[NewRelic\].*whee/))
+    @base.setup_log
+    @base.log.info('whee')
+  end
+
+  def test_set_stdout_destination_from_NEW_RELIC_LOG_env_var
+    @base.stubs(:fetch).returns('whatever')
+    ENV['NEW_RELIC_LOG'] = 'stdout'
+    Dir.expects(:mkdir).never
+    @base.setup_log
+    assert_equal STDOUT, @base.log.instance_eval { @logdev }.dev
+    ENV['NEW_RELIC_LOG'] = nil
+  end
+
+  def test_set_file_destination_from_NEW_RELIC_LOG_env_var
+    @base.stubs(:fetch).returns('whatever')
+    ENV['NEW_RELIC_LOG'] = 'log/file.log'
+    @base.setup_log
+    assert_equal 'log', File.basename(@base.log_path)
+    assert_equal 'file.log', @base.log_file_name
+    ENV['NEW_RELIC_LOG'] = nil    
+  end
+end

data/test/new_relic/control_test.rb

@@ -0,0 +1,256 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'/../test_helper'))
+class NewRelic::ControlTest < Test::Unit::TestCase
+
+  attr_reader :control
+
+  def setup
+    NewRelic::Agent.manual_start(:dispatcher_instance_id => 'test')
+    @control =  NewRelic::Control.instance
+    raise 'oh geez, wrong class' unless NewRelic::Control.instance.is_a?(::NewRelic::Control::Frameworks::Test)
+  end
+
+  def shutdown
+    NewRelic::Agent.shutdown
+  end
+
+  def test_cert_file_path
+    assert @control.cert_file_path
+    assert_equal File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'cert', 'cacert.pem')), @control.cert_file_path
+  end
+  
+  # This test does not actually use the ruby agent in any way - it's
+  # testing that the CA file we ship actually validates our server's
+  # certificate. It's used for customers who enable verify_certificate
+  def test_cert_file
+    return if ::RUBY_VERSION == '1.9.3'
+    require 'socket'
+    require 'openssl'
+
+    s   = TCPSocket.new 'collector.newrelic.com', 443
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.ca_file = @control.cert_file_path
+    ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    s   = OpenSSL::SSL::SSLSocket.new s, ctx
+    s.connect
+    # should not raise an error
+  end
+  
+  # see above, but for staging, as well. This allows us to test new
+  # certificates in a non-customer-facing place before setting them
+  # live.
+  def test_staging_cert_file
+    return if ::RUBY_VERSION == '1.9.3'
+    require 'socket'
+    require 'openssl'
+
+    s   = TCPSocket.new 'staging-collector.newrelic.com', 443
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.ca_file = @control.cert_file_path
+    ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    s   = OpenSSL::SSL::SSLSocket.new s, ctx
+    s.connect
+    # should not raise an error
+  end
+
+  def test_monitor_mode
+    assert ! @control.monitor_mode?
+    @control.settings.delete 'enabled'
+    @control.settings.delete 'monitor_mode'
+    assert !@control.monitor_mode?
+    @control['enabled'] = false
+    assert ! @control.monitor_mode?
+    @control['enabled'] = true
+    assert @control.monitor_mode?
+    @control['monitor_mode'] = nil
+    assert !@control.monitor_mode?
+    @control['monitor_mode'] = false
+    assert !@control.monitor_mode?
+    @control['monitor_mode'] = true
+    assert @control.monitor_mode?
+  ensure
+    @control['enabled'] = false
+    @control['monitor_mode'] = false
+  end
+
+  def test_test_config
+    if defined?(Rails) && Rails::VERSION::MAJOR.to_i == 3
+      assert_equal :rails3, control.app
+    elsif defined?(Rails)
+      assert_equal :rails, control.app
+    else
+      assert_equal :test, control.app
+    end
+    assert_equal :test, control.framework
+    assert_match /test/i, control.dispatcher_instance_id
+    assert("" == control.dispatcher.to_s, "Expected dispatcher to be empty, but was #{control.dispatcher.to_s}")
+    assert !control['enabled']
+    assert_equal false, control['monitor_mode']
+    control.local_env
+  end
+
+  def test_root
+    assert File.directory?(NewRelic::Control.newrelic_root), NewRelic::Control.newrelic_root
+    if defined?(Rails)
+      assert File.directory?(File.join(NewRelic::Control.newrelic_root, "lib")), NewRelic::Control.newrelic_root +  "/lib"
+    end
+  end
+
+  def test_info
+    props = NewRelic::Control.instance.local_env.snapshot
+    if defined?(Rails)
+      assert_match /jdbc|postgres|mysql|sqlite/, props.assoc('Database adapter').last, props.inspect
+    end
+  end
+
+  def test_resolve_ip
+    assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    assert_equal nil, control.send(:convert_to_ip_address, 'q1239988737.us')
+    # This will fail if you don't have a valid, accessible, DNS server
+    assert_equal '204.93.223.153', control.send(:convert_to_ip_address, 'collector.newrelic.com')
+  end
+
+  class FakeResolv
+    def self.getaddress(host)
+      raise 'deliberately broken'
+    end
+  end
+
+  def test_resolve_ip_with_broken_dns
+    # Here be dragons: disable the ruby DNS lookup methods we use so
+    # that it will actually fail to resolve.
+    old_resolv = Resolv
+    old_ipsocket = IPSocket
+    Object.instance_eval { remove_const :Resolv}
+    Object.instance_eval {remove_const:'IPSocket' }
+    assert_equal(nil, control.send(:convert_to_ip_address, 'collector.newrelic.com'), "DNS is down, should be no IP for server")
+
+    Object.instance_eval {const_set('Resolv', old_resolv); const_set('IPSocket', old_ipsocket)}
+    # these are here to make sure that the constant tomfoolery above
+    # has not broket the system unduly
+    assert_equal old_resolv, Resolv
+    assert_equal old_ipsocket, IPSocket
+  end
+
+  def test_config_yaml_erb
+    assert_equal 'heyheyhey', control['erb_value']
+    assert_equal '', control['message']
+    assert_equal '', control['license_key']
+  end
+
+  def test_appnames
+    assert_equal %w[a b c], NewRelic::Control.instance.app_names
+  end
+
+  def test_config_booleans
+    assert_equal control['tval'], true
+    assert_equal control['fval'], false
+    assert_nil control['not_in_yaml_val']
+    assert_equal control['yval'], true
+    assert_equal control['sval'], 'sure'
+  end
+
+  def test_config_apdex
+    assert_equal 1.1, control.apdex_t
+  end
+
+#  def test_transaction_threshold
+#    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
+#    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+#  end
+
+  def test_log_file_name
+    NewRelic::Control.instance.setup_log
+    assert_match /newrelic_agent.log$/, control.instance_variable_get('@log_file')
+  end
+
+#  def test_transaction_threshold__apdex
+#    forced_start
+#    assert_equal 'Apdex_f', c['transaction_tracer']['transaction_threshold']
+#    assert_equal 4.4, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+#  end
+
+  def test_transaction_threshold__default
+    forced_start :transaction_tracer => { :transaction_threshold => nil}
+    assert_nil control['transaction_tracer']['transaction_threshold']
+    assert_equal 2.0, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+  end
+
+  def test_transaction_threshold__override
+    forced_start :transaction_tracer => { :transaction_threshold => 1}
+    assert_equal 1, control['transaction_tracer']['transaction_threshold']
+    assert_equal 1, NewRelic::Agent::Agent.instance.instance_variable_get('@slowest_transaction_threshold')
+  end
+
+  def test_transaction_tracer_disabled
+    forced_start(:transaction_tracer => { :enabled => false },
+                 :developer_mode => false, :monitor_mode => true)
+    NewRelic::Agent::Agent.instance.check_transaction_sampler_status
+    
+    assert(!NewRelic::Agent::Agent.instance.transaction_sampler.enabled?,
+           'transaction tracer enabled when config calls for disabled')
+    
+    @control['developer_mode'] = true
+    @control['monitor_mode'] = false
+  end
+  
+  def test_sql_tracer_disabled
+    forced_start(:slow_sql => { :enabled => false }, :monitor_mode => true)
+    NewRelic::Agent::Agent.instance.check_sql_sampler_status
+    
+    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+           'sql tracer enabled when config calls for disabled')
+    
+    @control['monitor_mode'] = false
+  end
+  
+  def test_sql_tracer_disabled_with_record_sql_false
+    forced_start(:slow_sql => { :enabled => true, :record_sql => 'off' })
+    NewRelic::Agent::Agent.instance.check_sql_sampler_status
+    
+    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+           'sql tracer enabled when config calls for disabled')
+  end
+
+  def test_sql_tracer_disabled_when_tt_disabled
+    forced_start(:transaction_tracer => { :enabled => false },
+                 :slow_sql => { :enabled => true },
+                 :developer_mode => false, :monitor_mode => true)
+    NewRelic::Agent::Agent.instance.check_sql_sampler_status
+    
+    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+           'sql enabled when transaction tracer disabled')
+    
+    @control['developer_mode'] = true
+    @control['monitor_mode'] = false    
+  end
+
+  def test_sql_tracer_disabled_when_tt_disabled_by_server
+    forced_start(:slow_sql => { :enabled => true },
+                 :transaction_tracer => { :enabled => true },
+                 :monitor_mode => true)
+    NewRelic::Agent::Agent.instance.check_sql_sampler_status
+    NewRelic::Agent::Agent.instance.finish_setup('collect_traces' => false)    
+    
+    assert(!NewRelic::Agent::Agent.instance.sql_sampler.enabled?,
+           'sql enabled when tracing disabled by server')
+    
+    @control['monitor_mode'] = false        
+  end
+
+  def test_merging_options
+    NewRelic::Control.send :public, :merge_options
+    @control.merge_options :api_port => 66, :transaction_tracer => { :explain_threshold => 2.0 }
+    assert_equal 66, NewRelic::Control.instance['api_port']
+    assert_equal 2.0, NewRelic::Control.instance['transaction_tracer']['explain_threshold']
+    assert_equal 'raw', NewRelic::Control.instance['transaction_tracer']['record_sql']
+  end
+
+  private
+
+  def forced_start overrides = {}
+    NewRelic::Agent.manual_start overrides
+    # This is to force the agent to start again.
+    NewRelic::Agent.instance.stubs(:started?).returns(nil)
+    NewRelic::Agent.instance.start
+  end
+end