wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/test/new_relic/agent/configuration/manager_test.rb

@@ -0,0 +1,204 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/configuration/manager'
+require 'new_relic/agent/configuration/mask_defaults'
+
+module NewRelic::Agent::Configuration
+  class ManagerTest < Test::Unit::TestCase
+    def setup
+      @manager = NewRelic::Agent::Configuration::Manager.new
+    end
+
+    def test_should_use_indifferent_access
+      config = NewRelic::Agent::Configuration::DottedHash.new('string' => 'string', :symbol => 'symbol')
+      @manager.apply_config(config)
+      assert_equal 'string', @manager[:string]
+      assert_equal 'symbol', @manager['symbol']
+      @manager.remove_config(config)
+    end
+
+    def test_should_apply_config_sources_in_order
+      config0 = {
+        :foo => 'default foo',
+        :bar => 'default bar',
+        :baz => 'default baz'
+      }
+      @manager.apply_config(config0)
+      config1 = { :foo => 'real foo' }
+      @manager.apply_config(config1)
+      config2 = { :foo => 'wrong foo', :bar => 'real bar' }
+      @manager.apply_config(config2, 1)
+
+      assert_equal 'real foo', @manager['foo']
+      assert_equal 'real bar', @manager['bar']
+      assert_equal 'default baz', @manager['baz']
+
+      @manager.remove_config(config0)
+      @manager.remove_config(config1)
+      @manager.remove_config(config2)
+    end
+
+    def test_identifying_config_source
+      hash_source = {:foo => 'foo', :bar => 'default'}
+      @manager.apply_config(hash_source)
+      test_source = TestSource.new
+      test_source[:bar] = 'bar'
+      test_source[:baz] = 'baz'
+      @manager.apply_config(test_source)
+
+      assert_not_equal test_source, @manager.source(:foo)
+      assert_equal test_source, @manager.source(:bar)
+      assert_equal test_source, @manager.source(:baz)
+
+      @manager.remove_config(hash_source)
+      @manager.remove_config(test_source)
+    end
+
+    def test_callable_value_for_config_should_return_computed_value
+      source = {
+        :foo          => 'bar',
+        :simple_value => Proc.new { '666' },
+        :reference    => Proc.new { self['foo'] }
+      }
+      @manager.apply_config(source)
+
+      assert_equal 'bar', @manager[:foo]
+      assert_equal '666', @manager[:simple_value]
+      assert_equal 'bar', @manager[:reference]
+
+      @manager.remove_config(source)
+    end
+
+    def test_should_not_apply_removed_sources
+      test_source = TestSource.new
+      @manager.apply_config(test_source)
+      @manager.remove_config(test_source)
+
+      assert_equal nil, @manager['test_config_accessor']
+    end
+
+    def test_should_read_license_key_from_env
+      ENV['NEWRELIC_LICENSE_KEY'] = 'right'
+      manager = NewRelic::Agent::Configuration::Manager.new
+      manager.apply_config({:license_key => 'wrong'}, 1)
+
+      assert_equal 'right', manager['license_key']
+    end
+
+    def test_config_values_should_be_memoized
+      @manager.apply_config(:setting => 'correct value')
+      assert_equal 'correct value', @manager[:setting]
+
+      @manager.config_stack.unshift(:setting => 'wrong value')
+      assert_equal 'correct value', @manager[:setting]
+    end
+
+    def test_dotted_hash_to_hash_is_plain_hash
+      dotted = NewRelic::Agent::Configuration::DottedHash.new({})
+      assert_equal(::Hash, dotted.to_hash.class)
+    end
+
+    def test_to_collector_hash
+      @manager.instance_variable_set(:@config_stack, [])
+      @manager.apply_config(:eins => Proc.new { self[:one] })
+      @manager.apply_config(:one => 1)
+      @manager.apply_config(:two => 2)
+      @manager.apply_config(:nested => {:madness => 'test'})
+      @manager.apply_config(:'nested.madness' => 'test')
+
+      assert_equal({ :eins => 1, :one => 1, :two => 2, :'nested.madness' => 'test' },
+                   @manager.to_collector_hash)
+    end
+
+    # Necessary to keep the pruby marshaller happy
+    def test_to_collector_hash_returns_bare_hash
+      @manager.instance_variable_set(:@config_stack, [])
+      @manager.apply_config(:eins => Proc.new { self[:one] })
+
+      assert_equal(::Hash, @manager.to_collector_hash.class)
+    end
+
+    def test_config_masks
+      NewRelic::Agent::Configuration::MASK_DEFAULTS[:boo] = Proc.new { true }
+
+      @manager.apply_config(:boo => 1)
+
+      assert_equal false, @manager.to_collector_hash.has_key?(:boo)
+    end
+
+    def test_config_masks_conditionally
+      NewRelic::Agent::Configuration::MASK_DEFAULTS[:boo] = Proc.new { false }
+
+      @manager.apply_config(:boo => 1)
+
+      assert @manager.to_collector_hash.has_key?(:boo)
+    end
+
+    def test_config_masks_thread_profiler
+      supported = NewRelic::Agent::ThreadProfiler.is_supported?
+      reported_config = @manager.to_collector_hash
+
+      if supported
+        assert_not_nil reported_config[:'thread_profiler.enabled']
+      else
+        assert_equal nil, reported_config[:'thread_profiler.enabled']
+      end
+    end
+
+    def test_replacing_a_layer_by_class
+      old_config = NewRelic::Agent::Configuration::ManualSource.new(:test => 'wrong')
+      @manager.apply_config(old_config, 1)
+      new_config = NewRelic::Agent::Configuration::ManualSource.new(:test => 'right')
+      @manager.replace_or_add_config(new_config)
+
+      assert_equal 'right', @manager[:test]
+      assert_equal 3, @manager.config_stack.size
+      assert_equal 1, @manager.config_stack.map{|s| s.class} \
+        .index(NewRelic::Agent::Configuration::ManualSource)
+    end
+
+    def test_registering_a_callback
+      observed_value = 'old'
+      @manager.apply_config(:test => 'original')
+
+      @manager.register_callback(:test) do |value|
+        observed_value = value
+      end
+      assert_equal 'original', observed_value
+
+      @manager.apply_config(:test => 'new')
+      assert_equal 'new', observed_value
+    end
+
+    def test_callback_not_called_if_no_change
+      @manager.apply_config(:test => true, :other => false)
+      @manager.register_callback(:test) do |value|
+        state = 'wrong'
+      end
+      state = 'right'
+      config = {:test => true}
+      @manager.apply_config(config)
+      @manager.remove_config(config)
+
+      assert_equal 'right', state
+    end
+
+    def test_should_log_when_applying
+      expects_logging(:debug, anything, includes("asdf"))
+      @manager.apply_config(:test => "asdf")
+    end
+
+    def test_should_log_when_removing
+      config = { :test => "asdf" }
+      @manager.apply_config(config)
+
+      expects_logging(:debug, anything, Not(includes("asdf")))
+      @manager.remove_config(config)
+    end
+
+    class TestSource < ::Hash
+      def test_config_accessor
+        'some value'
+      end
+    end
+  end
+end

data/test/new_relic/agent/configuration/server_source_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/configuration/server_source'
+
+module NewRelic::Agent::Configuration
+  class ServerSourceTest < Test::Unit::TestCase
+    def setup
+      config = {
+        'agent_config' => {
+          'slow_sql.enabled'                         => true,
+          'transaction_tracer.transaction_threshold' => 'apdex_f',
+          'transaction_tracer.record_sql'            => 'raw',
+          'error_collector.enabled'                  => true
+        },
+        'apdex_t'                                  => 1.0,
+        'collect_errors'                           => false,
+        'collect_traces'                           => true
+      }
+      @source = ServerSource.new(config)
+    end
+
+    def test_should_set_apdex_t
+      assert_equal 1.0, @source[:apdex_t]
+    end
+
+    def test_should_set_agent_config_values
+      assert_equal 'raw', @source[:'transaction_tracer.record_sql']
+    end
+
+    def test_should_not_dot_the_agent_config_sub_hash
+      assert_nil @source[:'agent_config.slow_sql.enabled']
+    end
+
+    def test_should_enable_tracer_as_configured
+      assert @source[:'slow_sql.enabled']
+    end
+
+    def test_should_disable_tracer_as_configured
+      assert !@source[:'error_collector.enabled']
+    end
+
+    def test_should_ignore_apdex_f_setting_for_transaction_threshold
+      assert_equal nil, @source[:'transaction_tracer.transaction_threshold']
+    end
+  end
+end

data/test/new_relic/agent/configuration/yaml_source_test.rb

@@ -0,0 +1,75 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/configuration/yaml_source'
+
+module NewRelic::Agent::Configuration
+  class YamlSourceTest < Test::Unit::TestCase
+    def setup
+      test_yml_path = File.expand_path(File.join(File.dirname(__FILE__),
+                                                 '..','..','..',
+                                                 'config','newrelic.yml'))
+      @source = YamlSource.new(test_yml_path, 'test')
+    end
+
+    def test_should_load_given_yaml_file
+      assert_equal '127.0.0.1', @source[:api_host]
+    end
+
+    def test_should_apply_erb_transformations
+      assert_equal 'heyheyhey', @source[:erb_value]
+      assert_equal '', @source[:message]
+      assert_equal '', @source[:license_key]
+    end
+
+    def test_config_booleans
+      assert_equal true, @source[:tval]
+      assert_equal false, @source[:fval]
+      assert_nil @source[:not_in_yaml_val]
+      assert_equal true, @source[:yval]
+      assert_equal 'sure', @source[:sval]
+    end
+
+    def test_appnames
+      assert_equal %w[a b c], @source[:app_name]
+    end
+
+    def test_should_load_the_config_for_the_correct_env
+      assert_not_equal 'the.wrong.host', @source[:host]
+    end
+
+    def test_should_convert_to_dot_notation
+      assert_equal 'raw', @source[:'transaction_tracer.record_sql']
+    end
+
+    def test_should_ignore_apdex_f_setting_for_transaction_threshold
+      assert_equal nil, @source[:'transaction_tracer.transaction_threshold']
+    end
+
+    def test_should_correctly_handle_floats
+      assert_equal 1.1, @source[:apdex_t]
+    end
+
+    def test_should_log_if_no_file_is_found
+      expects_logging(:error, any_parameters)
+      source = YamlSource.new('no_such_file.yml', 'test')
+    end
+
+    def test_should_not_fail_to_log_missing_file_during_startup
+      without_logger do
+        ::NewRelic::Agent::StartupLogger.any_instance.expects(:error)
+        source = YamlSource.new('no_such_file.yml', 'test')
+      end
+    end
+
+    def test_should_not_fail_to_log_invalid_file_during_startup
+      without_logger do
+        ::NewRelic::Agent::StartupLogger.any_instance.expects(:error)
+
+        File.stubs(:exists?).returns(true)
+        File.stubs(:read).raises(StandardError.new("boo"))
+
+        source = YamlSource.new('fake.yml', 'test')
+      end
+    end
+
+  end
+end

data/test/new_relic/agent/cross_process_monitoring_test.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+module NewRelic::Agent
+  class CrossProcessMonitoringTest < Test::Unit::TestCase
+    AGENT_CROSS_PROCESS_ID = "qwerty"
+    REQUEST_CROSS_PROCESS_ID = "asdf"
+
+    def setup
+      NewRelic::Agent.instance.stubs(:cross_process_id).returns(AGENT_CROSS_PROCESS_ID)
+      NewRelic::Agent.instance.stubs(:cross_process_encoding_bytes).returns([0])
+
+      @request_with_id = stub(:env => {'X-NewRelic-ID' => REQUEST_CROSS_PROCESS_ID})
+      @empty_request = stub(:env => {})
+
+      @response = {}
+    end
+
+    def test_adds_response_header
+      timings = stub(
+        :transaction_name => "transaction",
+        :queue_time_in_millis => 1000,
+        :app_time_in_millis => 2000)
+
+      NewRelic::Agent::BrowserMonitoring.stubs(:timings).returns(timings)
+
+      CrossProcessMonitoring.insert_response_header(@request_with_id, @response)
+
+      assert unpacked_response.include?("transaction")
+      assert unpacked_response.include?("1000")
+      assert unpacked_response.include?("2000")
+      assert unpacked_response.include?(AGENT_CROSS_PROCESS_ID)
+    end
+
+    def test_doesnt_add_header_if_no_id_in_request
+      CrossProcessMonitoring.insert_response_header(@empty_request, @response)
+      assert_nil response_app_data
+    end
+
+    def test_doesnt_add_header_if_no_id_on_agent
+      NewRelic::Agent.instance.stubs(:cross_process_id).returns(nil)
+
+      CrossProcessMonitoring.insert_response_header(@request_with_id, @response)
+      assert_nil response_app_data
+    end
+
+    def test_doesnt_add_header_if_config_disabled
+      with_config(:'cross_process.enabled' => false) do
+        CrossProcessMonitoring.insert_response_header(@request_with_id, @response)
+        assert_nil response_app_data
+      end
+    end
+
+    def test_finds_id_from_headers
+      %w{X-NewRelic-ID HTTP_X_NEWRELIC_ID X_NEWRELIC_ID}.each do |key|
+        request = stub(:env => { key => REQUEST_CROSS_PROCESS_ID })
+
+        assert_equal(
+          REQUEST_CROSS_PROCESS_ID, \
+          CrossProcessMonitoring.id_from_request(request),
+          "Failed to find header on key #{key}")
+      end
+    end
+
+    def test_doesnt_find_id_in_headers
+      request = stub(:env => {})
+      assert_nil CrossProcessMonitoring.id_from_request(request)
+    end
+
+    def response_app_data
+      @response['X-NewRelic-App-Data']
+    end
+
+    def unpacked_response
+      response_app_data.unpack("m0").first
+    end
+  end
+end

data/test/new_relic/agent/database_test.rb

@@ -73,17 +73,6 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     assert_equal([], NewRelic::Agent::Database.explain_sql('SELECT', config))
   end  
   
-  def test_handle_exception_in_explain
-    fake_error = StandardError.new('a message')
-    NewRelic::Control.instance.log.expects(:error).with('Error getting query plan: a message')
-    # backtrace can be basically any string, just should get logged
-    NewRelic::Control.instance.log.expects(:debug).with(instance_of(String))
-    
-    NewRelic::Agent::Database.handle_exception_in_explain do
-      raise(fake_error)
-    end
-  end
-  
   def test_obfuscation_mysql_basic
     insert = %q[INSERT INTO `X` values("test",0, 1 , 2, 'test')]
     assert_equal("INSERT INTO `X` values(?,?, ? , ?, ?)",
@@ -146,4 +135,16 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
 
     NewRelic::Agent::Database::Obfuscator.instance.reset
   end
+
+  def test_close_connections_closes_all_held_db_connections
+    foo_connection = mock('foo connection')
+    bar_connection = mock('bar connection')
+    NewRelic::Agent::Database::ConnectionManager.instance.instance_eval do
+      @connections = { :foo => foo_connection, :bar => bar_connection }      
+    end
+    foo_connection.expects(:disconnect!)
+    bar_connection.expects(:disconnect!)
+    
+    NewRelic::Agent::Database.close_connections
+  end
 end

data/test/new_relic/agent/error_collector/notice_error_test.rb

@@ -57,47 +57,51 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
   end
 
   def test_request_params_from_opts_positive
-    fake_control = mock('control')
-    self.expects(:control).returns(fake_control)
-    fake_control.expects(:capture_params).returns(true)
-    val = {:request_params => 'foo'}
-    assert_equal('foo', request_params_from_opts(val))
-    assert_equal({}, val, "should delete request_params key from hash")
+    with_config(:capture_params => true) do
+      val = {:request_params => 'foo'}
+      assert_equal('foo', request_params_from_opts(val))
+      assert_equal({}, val, "should delete request_params key from hash")
+    end
   end
 
   def test_request_params_from_opts_negative
-    fake_control = mock('control')
-    self.expects(:control).returns(fake_control)
-    fake_control.expects(:capture_params).returns(false)
-    val = {:request_params => 'foo'}
-    assert_equal(nil, request_params_from_opts(val))
-    assert_equal({}, val, "should delete request_params key from hash")
+    with_config(:capture_params => false) do
+      val = {:request_params => 'foo'}
+      assert_equal(nil, request_params_from_opts(val))
+      assert_equal({}, val, "should delete request_params key from hash")
+    end
   end
 
   def test_normalized_request_and_custom_params_base
     self.expects(:normalize_params).with(nil).returns(nil)
     self.expects(:normalize_params).with({}).returns({})
-    fake_control = mock('control')
-    self.expects(:control).returns(fake_control)
-    fake_control.expects(:capture_params).returns(true)
-    assert_equal({:request_params => nil, :custom_params => {}}, normalized_request_and_custom_params({}))
+    with_config(:capture_params => true) do
+      assert_equal({:request_params => nil, :custom_params => {}},
+                   normalized_request_and_custom_params({}))
+    end
   end
 
   def test_extract_source_base
-    @capture_source = true
-    self.expects(:sense_method).with(nil, 'source_extract')
-    assert_equal(nil, extract_source(nil))
+    with_config(:'error_collector.capture_source' => true) do
+      error_collector = NewRelic::Agent::ErrorCollector.new
+      error_collector.expects(:sense_method).with(nil, 'source_extract')
+      assert_equal(nil, error_collector.extract_source(nil))
+    end
   end
 
   def test_extract_source_disabled
-    @capture_source = false
-    assert_equal(nil, extract_source(mock('exception')))
+    with_config(:'error_collector.capture_source' => false) do
+      error_collector = NewRelic::Agent::ErrorCollector.new
+      assert_equal(nil, error_collector.extract_source(mock('exception')))
+    end
   end
 
   def test_extract_source_with_source
-    self.expects(:sense_method).with('happy', 'source_extract').returns('THE SOURCE')
-    @capture_source = true
-    assert_equal('THE SOURCE', extract_source('happy'))
+    with_config(:'error_collector.capture_source' => true) do
+      error_collector = NewRelic::Agent::ErrorCollector.new
+      error_collector.expects(:sense_method).with('happy', 'source_extract').returns('THE SOURCE')
+      assert_equal('THE SOURCE', error_collector.extract_source('happy'))
+    end
   end
 
   def test_extract_stack_trace
@@ -122,9 +126,7 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
 
   def test_over_queue_limit_positive
     @errors = %w(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21)
-    fake_log = mock('log')
-    self.expects(:log).returns(fake_log)
-    fake_log.expects(:warn).with('The error reporting queue has reached 20. The error detail for this and subsequent errors will not be transmitted to New Relic until the queued errors have been sent: hooray')
+    expects_logging(:warn, includes('The error reporting queue has reached 20'))
     assert over_queue_limit?('hooray')
   end
 
@@ -160,53 +162,56 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
 
   def test_should_exit_notice_error_disabled
     error = mocked_error
-    @enabled = false
-    assert should_exit_notice_error?(error)
+    with_error_collector_config(:'error_collector.enabled' => false) do |error_collector|
+      assert error_collector.should_exit_notice_error?(error)
+    end
   end
 
   def test_should_exit_notice_error_nil
     error = nil
-    @enabled = true
-    self.expects(:error_is_ignored?).with(error).returns(false)
-    # we increment it for the case that someone calls
-    # NewRelic::Agent.notice_error(foo) # foo is nil
-    # (which is probably not a good idea but is the existing api)
-    self.expects(:increment_error_count!)
-    assert should_exit_notice_error?(error)
+    with_error_collector_config(:'error_collector.enabled' => true) do |error_collector|
+      error_collector.expects(:error_is_ignored?).with(error).returns(false)
+      # we increment it for the case that someone calls
+      # NewRelic::Agent.notice_error(foo) # foo is nil
+      # (which is probably not a good idea but is the existing api)
+      error_collector.expects(:increment_error_count!)
+      assert error_collector.should_exit_notice_error?(error)
+    end
   end
 
   def test_should_exit_notice_error_positive
     error = mocked_error
-    @enabled = true
-    self.expects(:error_is_ignored?).with(error).returns(true)
-    assert should_exit_notice_error?(error)
+    with_error_collector_config(:'error_collector.enabled' => true) do |error_collector|
+      error_collector.expects(:error_is_ignored?).with(error).returns(true)
+      assert error_collector.should_exit_notice_error?(error)
+    end
   end
 
   def test_should_exit_notice_error_negative
     error = mocked_error
-    @enabled = true
-    self.expects(:error_is_ignored?).with(error).returns(false)
-    self.expects(:increment_error_count!)
-    assert !should_exit_notice_error?(error)
+    with_error_collector_config(:'error_collector.enabled' => true) do |error_collector|
+      error_collector.expects(:error_is_ignored?).with(error).returns(false)
+      error_collector.expects(:increment_error_count!)
+      assert !error_collector.should_exit_notice_error?(error)
+    end
   end
 
   def test_filtered_error_positive
-    @ignore = {'an_error' => true}
-    error = mocked_error
-    error_class = mock('error class')
-    error.expects(:class).returns(error_class)
-    error_class.expects(:name).returns('an_error')
-    assert filtered_error?(error)
+    with_error_collector_config(:'error_collector.ignore_errors' => 'an_error') do |error_collector|
+      error = mocked_error
+      error_class = mock('error class')
+      error.expects(:class).returns(error_class)
+      error_class.expects(:name).returns('an_error')
+      assert error_collector.filtered_error?(error)
+    end
   end
 
   def test_filtered_error_negative
-    @ignore = {}
     error = mocked_error
     error_class = mock('error class')
     error.expects(:class).returns(error_class)
     error_class.expects(:name).returns('an_error')
-    self.expects(:filtered_by_error_filter?).with(error).returns(false)
-    assert !filtered_error?(error)
+    assert !NewRelic::Agent::ErrorCollector.new.filtered_error?(error)
   end
 
   def test_filtered_by_error_filter_empty
@@ -251,7 +256,13 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
 
   def mocked_control
     fake_control = mock('control')
-    self.stubs(:control).returns(fake_control)
+    NewRelic::Control.stubs(:instance).returns(fake_control)
     fake_control
   end
+
+  def with_error_collector_config(config)
+    with_config(config) do
+      yield NewRelic::Agent::ErrorCollector.new
+    end
+  end
 end