wd_newrelic_rpm 3.5.6 → 3.5.8

data/test/new_relic/agent/database_test.rb

@@ -5,13 +5,13 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
   def teardown
     NewRelic::Agent::Database::Obfuscator.instance.reset
   end
-  
+
   def test_process_resultset
     resultset = [["column"]]
     assert_equal([nil, [["column"]]],
                  NewRelic::Agent::Database.process_resultset(resultset))
   end
-  
+
   def test_explain_sql_select_with_mysql_connection
     config = {:adapter => 'mysql'}
     config.default('val')
@@ -30,7 +30,7 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
 
     result = NewRelic::Agent::Database.explain_sql(sql, config)
     assert_equal(plan.keys.sort, result[0].sort)
-    assert_equal(plan.values.compact.sort, result[1][0].compact.sort)    
+    assert_equal(plan.values.compact.sort, result[1][0].compact.sort)
   end
 
   def test_explain_sql_one_select_with_pg_connection
@@ -50,6 +50,44 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
                  NewRelic::Agent::Database.explain_sql(sql, config))
   end
 
+  def test_dont_collect_explain_for_parameterized_query
+    config = {:adapter => 'postgresql'}
+    config.default('val')
+    connection = mock('connection')
+    connection.expects(:execute).never
+    NewRelic::Agent::Database.stubs(:get_connection).with(config).returns(connection)
+    expects_logging(:debug, 'Unable to collect explain plan for parameterized query.')
+
+    sql = 'SELECT * FROM table WHERE id = $1'
+    assert_equal [], NewRelic::Agent::Database.explain_sql(sql, config)
+  end
+
+  def test_do_collect_explain_for_parameter_looking_literal
+    config = {:adapter => 'postgresql'}
+    config.default('val')
+    connection = mock('connection')
+    plan = [{"QUERY PLAN"=>"Some Jazz"}]
+    connection.stubs(:execute).returns(plan)
+    NewRelic::Agent::Database.stubs(:get_connection).with(config).returns(connection)
+
+    sql = "SELECT * FROM table WHERE id = 'noise $11'"
+    assert_equal([['QUERY PLAN'], [["Some Jazz"]]],
+                 NewRelic::Agent::Database.explain_sql(sql, config))
+  end
+
+  def test_dont_collect_explain_for_truncated_query
+    config = {:adapter => 'postgresql'}
+    config.default('val')
+    connection = mock('connection')
+    connection.expects(:execute).never
+    NewRelic::Agent::Database.stubs(:get_connection).with(config).returns(connection)
+    expects_logging(:debug, 'Unable to collect explain plan for truncated query.')
+
+    sql = 'SELECT * FROM table WHERE id IN (1,2,3,4,5...'
+    assert_equal [], NewRelic::Agent::Database.explain_sql(sql, config)
+
+  end
+
   def test_explain_sql_no_sql
     assert_equal(nil, NewRelic::Agent::Database.explain_sql(nil, nil))
   end
@@ -71,8 +109,8 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     config = mock('config')
     config.stubs(:[]).returns(nil)
     assert_equal([], NewRelic::Agent::Database.explain_sql('SELECT', config))
-  end  
-  
+  end
+
   def test_obfuscation_mysql_basic
     insert = %q[INSERT INTO `X` values("test",0, 1 , 2, 'test')]
     assert_equal("INSERT INTO `X` values(?,?, ? , ?, ?)",
@@ -90,9 +128,9 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     select = NewRelic::Agent::Database::Statement.new(%q[SELECT "table"."column" FROM "table" WHERE "table"."column" = 'value' AND "table"."other_column" = 'other value' LIMIT 1])
     select.adapter = :postgresql
     assert_equal(%q[SELECT "table"."column" FROM "table" WHERE "table"."column" = ? AND "table"."other_column" = ? LIMIT ?],
-                 NewRelic::Agent::Database.obfuscate_sql(select))  
+                 NewRelic::Agent::Database.obfuscate_sql(select))
   end
-  
+
   def test_obfuscation_escaped_literals
     insert = %q[INSERT INTO X values('', 'jim''s ssn',0, 1 , 'jim''s son''s son', """jim''s"" hat", "\"jim''s secret\"")]
     assert_equal("INSERT INTO X values(?, ?,?, ? , ?, ?, ?)",
@@ -104,7 +142,7 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     assert_equal(%q[SELECT * FROM `table_007` LIMIT ?],
                  NewRelic::Agent::Database.obfuscate_sql(select))
   end
-  
+
   def test_obfuscation_postgresql_integers_in_identifiers
     select = NewRelic::Agent::Database::Statement.new(%q[SELECT * FROM "table_007" LIMIT 1])
     select.adapter = :postgresql
@@ -112,25 +150,31 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
                  NewRelic::Agent::Database.obfuscate_sql(select))
   end
 
+  def test_obfuscation_of_truncated_query
+    insert = "INSERT INTO data (blah) VALUES ('abcdefg..."
+    assert_equal("Query too large (over 16k characters) to safely obfuscate",
+                 NewRelic::Agent::Database.obfuscate_sql(insert))
+  end
+
   def test_sql_obfuscation_filters
     NewRelic::Agent::Database.set_sql_obfuscator(:replace) do |string|
       "1" + string
     end
-    
+
     sql = "SELECT * FROM TABLE 123 'jim'"
-    
+
     assert_equal "1" + sql, NewRelic::Agent::Database.obfuscate_sql(sql)
-    
+
     NewRelic::Agent::Database.set_sql_obfuscator(:before) do |string|
       "2" + string
     end
-    
+
     assert_equal "12" + sql, NewRelic::Agent::Database.obfuscate_sql(sql)
-    
+
     NewRelic::Agent::Database.set_sql_obfuscator(:after) do |string|
       string + "3"
     end
-    
+
     assert_equal "12" + sql + "3", NewRelic::Agent::Database.obfuscate_sql(sql)
 
     NewRelic::Agent::Database::Obfuscator.instance.reset
@@ -140,11 +184,11 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     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 }      
+      @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_test.rb

@@ -162,10 +162,10 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
 
   def test_exclude_block
     @error_collector.ignore_error_filter &wrapped_filter_proc
-        
+
     @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
     @error_collector.notice_error(StandardError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
-    
+
     errors = @error_collector.harvest_errors([])
 
     assert_equal 1, errors.length
@@ -192,6 +192,30 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     end
   end
 
+  def test_increment_error_count_record_summary_and_txn_metric
+    txn_info = NewRelic::Agent::TransactionInfo.new
+    txn_info.transaction_name = 'Controller/class/method'
+    NewRelic::Agent::TransactionInfo.stubs(:get).returns(txn_info)
+
+    stats_engine = NewRelic::Agent.instance.stats_engine
+    stats_engine.reset_stats
+    @error_collector.increment_error_count!(StandardError.new('Boo'))
+    assert_equal(1, stats_engine.get_stats('Errors/all').call_count,
+                 'Missing Errors/all metric')
+    assert_equal(1, stats_engine.get_stats('Errors/Controller/class/method').call_count,
+                 'Missing Errors/Controller/class/method metric')
+  end
+
+  def test_doesnt_increment_error_count_on_transaction_if_nameless
+    txn_info = NewRelic::Agent::TransactionInfo.new
+    NewRelic::Agent::TransactionInfo.stubs(:get).returns(txn_info)
+
+    stats_engine = NewRelic::Agent.instance.stats_engine
+    stats_engine.reset_stats
+    @error_collector.increment_error_count!(StandardError.new('Boo'))
+    assert_equal(0, stats_engine.get_stats('Errors/(unknown)').call_count)
+  end
+
   private
 
   def expects_error_count_increase(increase)
@@ -203,7 +227,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   def get_error_stats
     NewRelic::Agent.get_stats("Errors/all").call_count
   end
-  
+
   def wrapped_filter_proc
     Proc.new do |e|
       if e.is_a? IOError
@@ -213,7 +237,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
       end
     end
   end
-  
+
   def silence_stream(*args)
     super
   rescue NoMethodError

data/test/new_relic/agent/event_listener_test.rb

@@ -14,6 +14,24 @@ class EventListenerTest < Test::Unit::TestCase
     end
   end
 
+
+  #
+  # Helpers
+  #
+
+  def assert_was_called
+    assert @called, "Event wasn't called"
+  end
+
+  def assert_was_not_called
+    assert !@called, "Event was called"
+  end
+
+
+  #
+  # Tests
+  #
+
   def test_notifies
     @events.subscribe(:before_call, &@check_method)
     @events.notify(:before_call, :env => "env")
@@ -37,9 +55,12 @@ class EventListenerTest < Test::Unit::TestCase
     @events.subscribe(:my_event) {}
   end
 
+  def test_clear
+    @events.subscribe(:after_call, &@check_method)
+    @events.clear
+    @events.notify(:after_call)
 
-  def assert_was_called
-    assert @called, "Event wasn't called"
+    assert_was_not_called
   end
 
 end

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

@@ -45,7 +45,7 @@ module NewRelic::Agent::Instrumentation
       t = BrowserMonitoringTimings.new(1000, @transaction)
       original = t.app_time_in_seconds
 
-      Time.stubs(:now).returns(3000)
+      Time.stubs(:now).returns(Time.at(3000))
       later = t.app_time_in_seconds
 
       assert_equal original, later

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

@@ -5,30 +5,103 @@ class NewRelic::Agent::Instrumentation::ControllerInstrumentationTest < Test::Un
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
   end
 
+  def setup
+    @object = TestObject.new
+  end
+
   def test_detect_upstream_wait_basic
     start_time = Time.now
-    object = TestObject.new
     # should return the start time above by default
-    object.expects(:newrelic_request_headers).returns({:request => 'headers'}).twice
-    object.expects(:parse_frontend_headers).with({:request => 'headers'}).returns(start_time)
-    assert_equal(start_time, object.send(:_detect_upstream_wait, start_time))
+    @object.expects(:newrelic_request_headers).returns({:request => 'headers'}).twice
+    NewRelic::Agent::Instrumentation::QueueTime.expects(:parse_frontend_timestamp) \
+      .with({:request => 'headers'}, start_time).returns(start_time)
+    assert_equal(start_time, @object.send(:_detect_upstream_wait, start_time))
   end
 
   def test_detect_upstream_wait_with_upstream
     start_time = Time.now
     runs_at = start_time + 1
-    object = TestObject.new
-    object.expects(:newrelic_request_headers).returns(true).twice
-    object.expects(:parse_frontend_headers).returns(start_time)
-    assert_equal(start_time, object.send(:_detect_upstream_wait, runs_at))
+    @object = TestObject.new
+    @object.expects(:newrelic_request_headers).returns(true).twice
+    NewRelic::Agent::Instrumentation::QueueTime.expects(:parse_frontend_timestamp) \
+      .with(true, runs_at).returns(start_time)
+    assert_equal(start_time, @object.send(:_detect_upstream_wait, runs_at))
   end
 
   def test_detect_upstream_wait_swallows_errors
     start_time = Time.now
-    object = TestObject.new
     # should return the start time above when an error is raised
-    object.expects(:newrelic_request_headers).returns({:request => 'headers'}).twice
-    object.expects(:parse_frontend_headers).with({:request => 'headers'}).raises("an error")
-    assert_equal(start_time, object.send(:_detect_upstream_wait, start_time))
+    @object.expects(:newrelic_request_headers).returns({:request => 'headers'}).twice
+    NewRelic::Agent::Instrumentation::QueueTime.expects(:parse_frontend_timestamp) \
+      .with({:request => 'headers'}, start_time).raises("an error")
+    assert_equal(start_time, @object.send(:_detect_upstream_wait, start_time))
+  end
+
+  def test_transaction_name_calls_newrelic_metric_path
+    @object.stubs(:newrelic_metric_path).returns('some/wacky/path')
+    assert_equal('Controller/some/wacky/path', @object.send(:transaction_name))
+  end
+
+  def test_transaction_name_applies_category_and_path
+    assert_equal('Controller/metric/path',
+                 @object.send(:transaction_name,
+                              :category => :controller,
+                              :path => 'metric/path'))
+    assert_equal('OtherTransaction/Background/metric/path',
+                 @object.send(:transaction_name,
+                              :category => :task, :path => 'metric/path'))
+    assert_equal('Controller/Rack/metric/path',
+                 @object.send(:transaction_name,
+                              :category => :rack, :path => 'metric/path'))
+    assert_equal('Controller/metric/path',
+                 @object.send(:transaction_name,
+                              :category => :uri, :path => 'metric/path'))
+    assert_equal('Controller/Sinatra/metric/path',
+                 @object.send(:transaction_name,
+                              :category => :sinatra,
+                              :path => 'metric/path'))
+    assert_equal('Blarg/metric/path',
+                 @object.send(:transaction_name,
+                              :category => 'Blarg', :path => 'metric/path'))
+
+  end
+
+  def test_transaction_name_uses_class_name_if_path_not_specified
+    assert_equal('Controller/NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject',
+                 @object.send(:transaction_name, :category => :controller))
+  end
+
+  def test_transaction_name_applies_action_name_if_specified_and_not_path
+    assert_equal('Controller/NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject/action',
+                 @object.send(:transaction_name, :category => :controller,
+                              :name => 'action'))
+  end
+
+  def test_transaction_name_applies_name_rules
+    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
+                                                  'replacement'      => '*',
+                                                  'replace_all'      => true)
+    NewRelic::Agent.instance.transaction_rules << rule
+    assert_equal('foo/*/bar/*',
+                 @object.send(:transaction_name, :category => 'foo',
+                              :path => '1/bar/22'))
+  ensure
+    NewRelic::Agent.instance.instance_variable_set(:@transaction_rules,
+                                              NewRelic::Agent::RulesEngine.new)
+  end
+
+  def test_path_class_and_action
+    result = @object.send(:path_class_and_action, {})
+    assert_equal("NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject", result)
+  end
+
+  def test_path_class_and_action_with_name
+    result = @object.send(:path_class_and_action, :name => "test")
+    assert_equal("NewRelic::Agent::Instrumentation::ControllerInstrumentationTest::TestObject/test", result)
+  end
+
+  def test_path_class_and_action_with_overridden_class_name
+    result = @object.send(:path_class_and_action, :name => "perform", :class_name => 'Resque')
+    assert_equal("Resque/perform", result)
   end
 end

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

@@ -53,4 +53,99 @@ class NewRelic::Agent::Instrumentation::MetricFrameTest < Test::Unit::TestCase
     f.start = 1500
     assert_equal 500, f.queue_time
   end
+
+  def test_update_apdex_records_failed_when_specified
+    stats = NewRelic::Agent::Stats.new
+    NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.1, true)
+    assert_equal 0, stats.apdex_s
+    assert_equal 0, stats.apdex_t
+    assert_equal 1, stats.apdex_f
+  end
+
+  def test_update_apdex_records_satisfying
+    stats = NewRelic::Agent::Stats.new
+    with_config(:apdex_t => 1) do
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.5, false)
+    end
+    assert_equal 1, stats.apdex_s
+    assert_equal 0, stats.apdex_t
+    assert_equal 0, stats.apdex_f
+  end
+
+  def test_update_apdex_records_tolerating
+    stats = NewRelic::Agent::Stats.new
+    with_config(:apdex_t => 1) do
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 1.5, false)
+    end
+    assert_equal 0, stats.apdex_s
+    assert_equal 1, stats.apdex_t
+    assert_equal 0, stats.apdex_f
+  end
+
+  def test_update_apdex_records_failing
+    stats = NewRelic::Agent::Stats.new
+    with_config(:apdex_t => 1) do
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 4.5, false)
+    end
+    assert_equal 0, stats.apdex_s
+    assert_equal 0, stats.apdex_t
+    assert_equal 1, stats.apdex_f
+  end
+
+  def test_update_apdex_records_correct_apdex_for_key_transaction
+    txn_info = NewRelic::Agent::TransactionInfo.get
+    stats = NewRelic::Agent::Stats.new
+    config = {
+      :web_transactions_apdex => {
+        'Controller/slow/txn' => 4,
+        'Controller/fast/txn' => 0.1,
+      },
+      :apdex => 1
+    }
+
+    txn_info.transaction_name = 'Controller/slow/txn'
+    with_config(config, :do_not_cast => true) do
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 3.5, false)
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 5.5, false)
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 16.5, false)
+    end
+    assert_equal 1, stats.apdex_s
+    assert_equal 1, stats.apdex_t
+    assert_equal 1, stats.apdex_f
+
+    txn_info.transaction_name = 'Controller/fast/txn'
+    with_config(config, :do_not_cast => true) do
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.05, false)
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.2, false)
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.5, false)
+    end
+    assert_equal 2, stats.apdex_s
+    assert_equal 2, stats.apdex_t
+    assert_equal 2, stats.apdex_f
+
+    txn_info.transaction_name = 'Controller/other/txn'
+    with_config(config, :do_not_cast => true) do
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 0.5, false)
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 2, false)
+      NewRelic::Agent::Instrumentation::MetricFrame.update_apdex(stats, 5, false)
+    end
+    assert_equal 3, stats.apdex_s
+    assert_equal 3, stats.apdex_t
+    assert_equal 3, stats.apdex_f
+  end
+
+  def test_record_apdex_stores_apdex_t_in_min_and_max
+    stats_engine = NewRelic::Agent.instance.stats_engine
+    stats_engine.reset_stats
+    metric = stub(:apdex_metric_path => 'Apdex/Controller/some/txn')
+    NewRelic::Agent.instance.instance_variable_set(:@stats_engine, stats_engine)
+
+    with_config(:apdex_t => 2.5) do
+      NewRelic::Agent::Instrumentation::MetricFrame.record_apdex(metric, 1, 1, false)
+    end
+    assert_equal 2.5, stats_engine.lookup_stats('Apdex').min_call_time
+    assert_equal 2.5, stats_engine.lookup_stats('Apdex').max_call_time
+    assert_equal 2.5, stats_engine.lookup_stats('Apdex/Controller/some/txn').min_call_time
+    assert_equal 2.5, stats_engine.lookup_stats('Apdex/Controller/some/txn').max_call_time
+  end
 end