ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

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,56 @@
+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
+      NewRelic::Control.instance.log.expects(:error)
+      source = YamlSource.new('no_such_file.yml', 'test')
+    end
+  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
@@ -160,53 +164,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 +258,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

data/test/new_relic/agent/error_collector_test.rb

@@ -143,6 +143,18 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     assert_equal 0, errors.length
   end
 
+  def test_exclude_later_config_changes
+    @error_collector.notice_error(IOError.new("message"))
+
+    NewRelic::Agent.config.apply_config(:'error_collector.ignore_errors' => "IOError")
+    @error_collector.notice_error(IOError.new("message"))
+
+    errors = @error_collector.harvest_errors([])
+
+    assert_equal 1, errors.length
+
+  end
+
   def test_exclude_block
     NewRelic::Agent.logger.expects(:error).never
     @error_collector.ignore_error_filter &wrapped_filter_proc
@@ -156,20 +168,18 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   end
 
   def test_obfuscates_error_messages_when_high_security_is_set
-    NewRelic::Control.instance['high_security'] = true
-    
-    @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo = 'bar'"))
-    @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo in (1,2,3,4,5)"))
+    with_config(:high_security => true) do
+      @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo = 'bar'"))
+      @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo in (1,2,3,4,5)"))
 
-    old_errors = []
-    errors = @error_collector.harvest_errors([])
+      old_errors = []
+      errors = @error_collector.harvest_errors([])
 
-    assert_equal('YO SQL BAD: serect * flom test where foo = ?',
-                 errors[0].message)
-    assert_equal('YO SQL BAD: serect * flom test where foo in (?,?,?,?,?)',
-                 errors[1].message)
-    
-    NewRelic::Control.instance['high_security'] = nil
+      assert_equal('YO SQL BAD: serect * flom test where foo = ?',
+                   errors[0].message)
+      assert_equal('YO SQL BAD: serect * flom test where foo in (?,?,?,?,?)',
+                   errors[1].message)
+    end
   end
 
   private

data/test/new_relic/agent/instrumentation/active_record_instrumentation_test.rb

@@ -4,6 +4,16 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   require 'active_record_fixtures'
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
+  # the db adapter library the tests are running under (e.g. sqlite3)
+  def adapter
+    if ActiveRecord::Base.respond_to?(:connection_config)
+      ActiveRecord::Base.connection_config[:adapter]
+    else
+      # old versions of rails are usually tested against mysql
+      'mysql'
+    end
+  end
+
   def setup
     super
     NewRelic::Agent.manual_start
@@ -87,7 +97,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
       ActiveRecord/find
       ActiveRecord/ActiveRecordFixtures::Order/find
       Database/SQL/insert
-      RemoteService/sql/mysql/localhost
+      RemoteService/sql/#{adapter}/localhost
     ]
 
     if NewRelic::Control.instance.rails_version < '2.1.0'
@@ -149,7 +159,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
       ActiveRecord/ActiveRecordFixtures::Order/find
       ActiveRecord/ActiveRecordFixtures::Order/create
       Database/SQL/other
-      RemoteService/sql/mysql/localhost]
+      RemoteService/sql/#{adapter}/localhost]
 
     if NewRelic::Control.instance.rails_version < '2.1.0'
       expected += ['ActiveRecord/save',
@@ -190,7 +200,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     ActiveRecord/find
     ActiveRecord/ActiveRecordFixtures::Order/find
     ActiveRecord/ActiveRecordFixtures::Shipment/find
-    RemoteService/sql/mysql/localhost
+    RemoteService/sql/#{adapter}/localhost
     ]
 
     assert_calls_metrics(*expected_metrics) do
@@ -256,7 +266,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
     expected_metrics = %W[
     ActiveRecord/all
-    RemoteService/sql/mysql/localhost
+    RemoteService/sql/#{adapter}/localhost
     ActiveRecord/destroy
     ActiveRecord/ActiveRecordFixtures::Order/destroy
     Database/SQL/insert
@@ -299,7 +309,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     expected_metrics = %W[
     ActiveRecord/all
     Database/SQL/select
-    RemoteService/sql/mysql/localhost
+    RemoteService/sql/#{adapter}/localhost
     ]
 
     assert_calls_unscoped_metrics(*expected_metrics) do
@@ -317,7 +327,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     expected_metrics = %W[
     ActiveRecord/all
     Database/SQL/other
-    RemoteService/sql/mysql/localhost
+    RemoteService/sql/#{adapter}/localhost
     ]
     assert_calls_unscoped_metrics(*expected_metrics) do
       ActiveRecordFixtures::Order.connection.execute "begin"
@@ -333,7 +343,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     return if isSqlite?
     return if isPostgres?
 
-    expected_metrics = %W[ActiveRecord/all Database/SQL/show RemoteService/sql/mysql/localhost]
+    expected_metrics = %W[ActiveRecord/all Database/SQL/show RemoteService/sql/#{adapter}/localhost]
 
     assert_calls_metrics(*expected_metrics) do
       ActiveRecordFixtures::Order.connection.execute "show tables"
@@ -499,7 +509,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
       true
     end
 
-    expected_metrics = %W[ActiveRecord/all Database/SQL/select RemoteService/sql/mysql/localhost]
+    expected_metrics = %W[ActiveRecord/all Database/SQL/select RemoteService/sql/#{adapter}/localhost]
 
     assert_calls_metrics(*expected_metrics) do
       begin
@@ -513,7 +523,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     compare_metrics expected_metrics, metrics
     check_metric_count('Database/SQL/select', 1)
     check_metric_count('ActiveRecord/all', 1)
-    check_metric_count('RemoteService/sql/mysql/localhost', 1)
+    check_metric_count("RemoteService/sql/#{adapter}/localhost", 1)
   end
 
   def test_rescue_handling
@@ -535,7 +545,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 #     puts NewRelic::Agent::Database.config.inspect
     
     ActiveRecordFixtures::Shipment.connection.execute('SHOW TABLES');
-    assert(NewRelic::Agent.get_stats('RemoteService/sql/mysql/localhost').call_count != 0)
+    assert(NewRelic::Agent.get_stats("RemoteService/sql/#{adapter}/localhost").call_count != 0)
 
     config = ActiveRecordFixtures::Shipment.connection.instance_eval { @config }    
     config[:host] = '127.0.0.1'
@@ -545,7 +555,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 #     puts NewRelic::Agent::Database.config.inspect
     
     ActiveRecordFixtures::Shipment.connection.execute('SHOW TABLES');
-    assert(NewRelic::Agent.get_stats('RemoteService/sql/mysql/127.0.0.1').call_count != 0)
+    assert(NewRelic::Agent.get_stats("RemoteService/sql/#{adapter}/127.0.0.1").call_count != 0)
 
     config[:host] = 'localhost'
     ActiveRecordFixtures::Shipment.establish_connection(config)

data/test/new_relic/agent/instrumentation/metric_frame_test.rb

@@ -47,4 +47,10 @@ class NewRelic::Agent::Instrumentation::MetricFrameTest < Test::Unit::TestCase
     assert_equal "/", f.uri
     assert_nil f.referer
   end
+
+  def test_queue_time
+    f.apdex_start = 1000
+    f.start = 1500
+    assert_equal 500, f.queue_time
+  end
 end

data/test/new_relic/agent/instrumentation/task_instrumentation_test.rb

@@ -77,8 +77,8 @@ class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::Te
       assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
       sample = @agent.transaction_sampler.last_sample
       assert_not_nil sample
-      assert_not_nil sample.params[:cpu_time], "cpu time nil: \n#{sample}"
-      assert sample.params[:cpu_time] >= 0, "cpu time: #{sample.params[:cpu_time]},\n#{sample}"
+      assert_not_nil sample.params[:custom_params][:cpu_time], "cpu time nil: \n#{sample}"
+      assert sample.params[:custom_params][:cpu_time] >= 0, "cpu time: #{sample.params[:cpu_time]},\n#{sample}"
       assert_equal '10', sample.params[:request_params][:level]
     end