ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

data/test/new_relic/agent/database_test.rb

@@ -0,0 +1,161 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..',
+                                   'test_helper'))
+require 'new_relic/agent/database'
+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')
+    sql = 'SELECT foo'
+    connection = mock('connection')
+    plan = {
+      "select_type"=>"SIMPLE", "key_len"=>nil, "table"=>"blogs", "id"=>"1",
+      "possible_keys"=>nil, "type"=>"ALL", "Extra"=>"", "rows"=>"2",
+      "ref"=>nil, "key"=>nil
+    }
+    result = mock('explain plan')
+    result.expects(:each_hash).yields(plan)
+    # two rows, two columns
+    connection.expects(:execute).with('EXPLAIN SELECT foo').returns(result)
+    NewRelic::Agent::Database.expects(:get_connection).with(config).returns(connection)
+
+    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)    
+  end
+
+  def test_explain_sql_one_select_with_pg_connection
+    config = {:adapter => 'postgresql'}
+    config.default('val')
+    sql = 'select count(id) from blogs limit 1'
+    connection = mock('connection')
+    plan = [{"QUERY PLAN"=>"Limit  (cost=11.75..11.76 rows=1 width=4)"},
+            {"QUERY PLAN"=>"  ->  Aggregate  (cost=11.75..11.76 rows=1 width=4)"},
+            {"QUERY PLAN"=>"        ->  Seq Scan on blogs  (cost=0.00..11.40 rows=140 width=4)"}]
+    connection.expects(:execute).returns(plan)
+    NewRelic::Agent::Database.expects(:get_connection).with(config).returns(connection)
+    assert_equal([['QUERY PLAN'],
+                  [["Limit  (cost=11.75..11.76 rows=1 width=4)"],
+                   ["  ->  Aggregate  (cost=11.75..11.76 rows=1 width=4)"],
+                   ["        ->  Seq Scan on blogs  (cost=0.00..11.40 rows=140 width=4)"]]],
+                 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
+
+  def test_explain_sql_no_connection_config
+    assert_equal(nil, NewRelic::Agent::Database.explain_sql('select foo', nil))
+  end
+
+  def test_explain_sql_non_select
+    assert_equal([], NewRelic::Agent::Database.explain_sql('foo',
+                                                           mock('config')))
+  end
+
+  def test_explain_sql_one_select_no_connection
+    # NB this test raises an error in the log, much as it might if a
+    # user supplied a config that was not valid. This is generally
+    # expected behavior - the get_connection method shouldn't allow
+    # errors to percolate up.
+    config = mock('config')
+    config.stubs(:[]).returns(nil)
+    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(?,?, ? , ?, ?)",
+                 NewRelic::Agent::Database.obfuscate_sql(insert))
+    select = %q[SELECT `table`.`column` FROM `table` WHERE `table`.`column` = 'value' AND `table`.`other_column` = "other value" LIMIT 1]
+    assert_equal(%q[SELECT `table`.`column` FROM `table` WHERE `table`.`column` = ? AND `table`.`other_column` = ? LIMIT ?],
+                 NewRelic::Agent::Database.obfuscate_sql(select))
+  end
+
+  def test_obfuscation_postgresql_basic
+    insert = NewRelic::Agent::Database::Statement.new(%q[INSERT INTO "X" values('test',0, 1 , 2, 'test')])
+    insert.adapter = :postgresql
+    assert_equal('INSERT INTO "X" values(?,?, ? , ?, ?)',
+                 NewRelic::Agent::Database.obfuscate_sql(insert))
+    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))  
+  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(?, ?,?, ? , ?, ?, ?)",
+                 NewRelic::Agent::Database.obfuscate_sql(insert))
+  end
+
+  def test_obfuscation_mysql_integers_in_identifiers
+    select = %q[SELECT * FROM `table_007` LIMIT 1]
+    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
+    assert_equal(%q[SELECT * FROM "table_007" LIMIT ?],
+                 NewRelic::Agent::Database.obfuscate_sql(select))
+  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
+  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_test.rb

@@ -3,12 +3,12 @@ ENV['SKIP_RAILS'] = 'true'
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 
 class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
-
   def setup
     super
     @error_collector = NewRelic::Agent::ErrorCollector.new
     @error_collector.stubs(:enabled).returns(true)
   end
+  
   def test_empty
     @error_collector.harvest_errors([])
     @error_collector.notice_error(nil, :metric=> 'path', :request_params => {:x => 'y'})
@@ -26,10 +26,10 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     assert_equal '', err.params[:request_referer]
     assert_equal 'path', err.path
     assert_equal 'Error', err.exception_class
-
   end
+  
   def test_simple
-    @error_collector.notice_error(Exception.new("message"), :uri => '/myurl/', :metric => 'path', :referer => 'test_referer', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :uri => '/myurl/', :metric => 'path', :referer => 'test_referer', :request_params => {:x => 'y'})
 
     old_errors = []
     errors = @error_collector.harvest_errors(old_errors)
@@ -42,7 +42,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     assert err.params[:request_uri] == '/myurl/'
     assert err.params[:request_referer] == "test_referer"
     assert err.path == 'path'
-    assert err.exception_class == 'Exception'
+    assert err.exception_class == 'StandardError'
 
     # the collector should now return an empty array since nothing
     # has been added since its last harvest
@@ -53,7 +53,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   def test_long_message
     #yes, times 500. it's a 5000 byte string. Assuming strings are
     #still 1 byte / char.
-    @error_collector.notice_error(Exception.new("1234567890" * 500), :uri => '/myurl/', :metric => 'path', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("1234567890" * 500), :uri => '/myurl/', :metric => 'path', :request_params => {:x => 'y'})
 
     old_errors = []
     errors = @error_collector.harvest_errors(old_errors)
@@ -66,13 +66,13 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   end
 
   def test_collect_failover
-    @error_collector.notice_error(Exception.new("message"), :metric => 'first', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :metric => 'first', :request_params => {:x => 'y'})
 
     errors = @error_collector.harvest_errors([])
 
-    @error_collector.notice_error(Exception.new("message"), :metric => 'second', :request_params => {:x => 'y'})
-    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'})
-    @error_collector.notice_error(Exception.new("message"), :metric => 'last', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :metric => 'second', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :metric => 'last', :request_params => {:x => 'y'})
 
     errors = @error_collector.harvest_errors(errors)
 
@@ -80,8 +80,8 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     assert_equal 'first', errors.first.path
     assert_equal 'last', errors.last.path
 
-    @error_collector.notice_error(Exception.new("message"), :metric => 'first', :request_params => {:x => 'y'})
-    @error_collector.notice_error(Exception.new("message"), :metric => 'last', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :metric => 'first', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :metric => 'last', :request_params => {:x => 'y'})
 
     errors = @error_collector.harvest_errors(nil)
     assert_equal 2, errors.length
@@ -95,7 +95,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
 
     silence_stream(::STDOUT) do
      (max_q_length + 5).times do |n|
-        @error_collector.notice_error(Exception.new("exception #{n}"), :metric => "path", :request_params => {:x => n})
+        @error_collector.notice_error(StandardError.new("exception #{n}"), :metric => "path", :request_params => {:x => n})
       end
     end
 
@@ -120,13 +120,13 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     [1.1, '1.1'],
     ['hi', 'hi'],
     [:hi, :hi],
-    [Exception.new("test"), "#<Exception>"],
+    [StandardError.new("test"), "#<StandardError>"],
     [TestClass.new, "#<NewRelic::Agent::ErrorCollectorTest::TestClass>"]
     ]
 
 
     types.each do |test|
-      @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => test[0]})
+      @error_collector.notice_error(StandardError.new("message"), :metric => 'path', :request_params => {:x => test[0]})
 
       assert_equal test[1], @error_collector.harvest_errors([])[0].params[:request_params][:x]
     end
@@ -144,22 +144,46 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   end
 
   def test_exclude_block
-    @error_collector.ignore_error_filter do |e|
-      if e.is_a? IOError
-        nil
-      else
-        e
-      end
-    end
-
+    NewRelic::Agent.logger.expects(:error).never
+    @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
+  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)"))
 
+    old_errors = []
     errors = @error_collector.harvest_errors([])
 
-    assert_equal 0, errors.length
+    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
   end
 
   private
+  
+  def wrapped_filter_proc
+    Proc.new do |e|
+      if e.is_a? IOError
+        return nil
+      else
+        return e
+      end
+    end
+  end
+  
   def silence_stream(*args)
     super
   rescue NoMethodError

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

@@ -1,19 +1,16 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+
 class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::Unit::TestCase
   require 'active_record_fixtures'
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
-  @@setup = false
   def setup
     super
-    unless @@setup
-      NewRelic::Agent.manual_start
-      @setup = true
-    end
+    NewRelic::Agent.manual_start
     ActiveRecordFixtures.setup
     NewRelic::Agent.instance.transaction_sampler.reset!
     NewRelic::Agent.instance.stats_engine.clear_stats
-  rescue Exception => e
+  rescue => e
     puts e
     puts e.backtrace.join("\n")
   end
@@ -35,7 +32,6 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
   def test_finder
     ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
-
     find_metric = "ActiveRecord/ActiveRecordFixtures::Order/find"
 
     assert_calls_metrics(find_metric) do
@@ -44,13 +40,20 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
       ActiveRecordFixtures::Order.find_all_by_name "jeff"
       check_metric_count(find_metric, 2)
     end
+  end
 
-    return if NewRelic::Control.instance.rails_version < "2.3.4"
+  def test_exists
+    return if NewRelic::Control.instance.rails_version < "2.3.4" ||
+      NewRelic::Control.instance.rails_version >= "3.0.7"
+
+    ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
+
+    find_metric = "ActiveRecord/ActiveRecordFixtures::Order/find"    
 
     assert_calls_metrics(find_metric) do
       ActiveRecordFixtures::Order.exists?(["name=?", 'jeff'])
+      check_metric_count(find_metric, 1)
     end
-    check_metric_count(find_metric, 3)
   end
 
   # multiple duplicate find calls should only cause metric trigger on the first
@@ -83,7 +86,9 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
       ActiveRecord/all
       ActiveRecord/find
       ActiveRecord/ActiveRecordFixtures::Order/find
-      Database/SQL/insert]
+      Database/SQL/insert
+      RemoteService/sql/mysql/localhost
+    ]
 
     if NewRelic::Control.instance.rails_version < '2.1.0'
       expected += %W[ActiveRecord/save ActiveRecord/ActiveRecordFixtures::Order/save]
@@ -132,36 +137,43 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/create", 1)
   end
 
-
   def test_metric_names_standard
     # fails due to a bug in rails 3 - log does not provide the correct
     # transaction type - it returns 'SQL' instead of 'Foo Create', for example.
-    return if rails3? || defined?(JRuby) || isSqlite?
-
+    return if defined?(JRuby) || isSqlite?
+    
     expected = %W[
       ActiveRecord/all
       ActiveRecord/find
-      ActiveRecord/ActiveRecordFixtures::Order/find
       ActiveRecord/create
+      ActiveRecord/ActiveRecordFixtures::Order/find
+      ActiveRecord/ActiveRecordFixtures::Order/create
       Database/SQL/other
-      ActiveRecord/ActiveRecordFixtures::Order/create]
+      RemoteService/sql/mysql/localhost]
 
     if NewRelic::Control.instance.rails_version < '2.1.0'
-      expected += %W[ActiveRecord/save ActiveRecord/ActiveRecordFixtures::Order/save]
+      expected += ['ActiveRecord/save',
+                   'ActiveRecord/ActiveRecordFixtures::Order/save']
+    elsif NewRelic::Control.instance.rails_version >= '3.0.0'
+      expected << 'Database/SQL/insert'
     end
 
     assert_calls_metrics(*expected) do
-      m = ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
+      m = ActiveRecordFixtures::Order.create :id => 0, :name => 'donkey'
       m = ActiveRecordFixtures::Order.find(m.id)
       m.id = 999
       m.save!
     end
 
     metrics = NewRelic::Agent.instance.stats_engine.metrics
-
+        
     compare_metrics expected, metrics
     check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/find", 1)
-    check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/create", 1)
+    if NewRelic::Control.instance.rails_version < '3.0.0'
+      check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/create", 1)
+    else
+      check_metric_count("Database/SQL/insert", 1)
+    end
   end
 
   def test_join_metrics_jruby
@@ -174,9 +186,11 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     ActiveRecord/ActiveRecordFixtures::Order/destroy
     Database/SQL/insert
     Database/SQL/delete
+    Database/SQL/show
     ActiveRecord/find
     ActiveRecord/ActiveRecordFixtures::Order/find
     ActiveRecord/ActiveRecordFixtures::Shipment/find
+    RemoteService/sql/mysql/localhost
     ]
 
     assert_calls_metrics(*expected_metrics) do
@@ -242,6 +256,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
     expected_metrics = %W[
     ActiveRecord/all
+    RemoteService/sql/mysql/localhost
     ActiveRecord/destroy
     ActiveRecord/ActiveRecordFixtures::Order/destroy
     Database/SQL/insert
@@ -284,6 +299,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     expected_metrics = %W[
     ActiveRecord/all
     Database/SQL/select
+    RemoteService/sql/mysql/localhost
     ]
 
     assert_calls_unscoped_metrics(*expected_metrics) do
@@ -301,6 +317,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     expected_metrics = %W[
     ActiveRecord/all
     Database/SQL/other
+    RemoteService/sql/mysql/localhost
     ]
     assert_calls_unscoped_metrics(*expected_metrics) do
       ActiveRecordFixtures::Order.connection.execute "begin"
@@ -314,8 +331,9 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
   def test_show_sql
     return if isSqlite?
+    return if isPostgres?
 
-    expected_metrics = %W[ActiveRecord/all Database/SQL/show]
+    expected_metrics = %W[ActiveRecord/all Database/SQL/show RemoteService/sql/mysql/localhost]
 
     assert_calls_metrics(*expected_metrics) do
       ActiveRecordFixtures::Order.connection.execute "show tables"
@@ -336,6 +354,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     metrics = NewRelic::Agent.instance.stats_engine.metrics
     compare_metrics [], metrics
   end
+  
   def test_run_explains
     perform_action_with_newrelic_trace :name => 'bogosity' do
       ActiveRecordFixtures::Order.add_delay
@@ -343,10 +362,12 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     end
 
     # that's a mouthful. perhaps we should ponder our API.
-    segment = NewRelic::Agent.instance.transaction_sampler.last_sample.root_segment.called_segments.first.called_segments.first.called_segments.first
+    segment = NewRelic::Agent.instance.transaction_sampler.last_sample \
+      .root_segment.called_segments[0].called_segments[0].called_segments[0]
     regex = /^SELECT (["`]?#{ActiveRecordFixtures::Order.table_name}["`]?.)?\* FROM ["`]?#{ActiveRecordFixtures::Order.table_name}["`]?$/
     assert_match regex, segment.params[:sql].strip
   end
+  
   def test_prepare_to_send
     perform_action_with_newrelic_trace :name => 'bogosity' do
       ActiveRecordFixtures::Order.add_delay
@@ -367,11 +388,11 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     sample = sample.prepare_to_send(:record_sql => :raw, :explain_sql => 0.0)
     sql_segment = sample.root_segment.called_segments.first.called_segments.first.called_segments.first
     assert_match /^SELECT /, sql_segment.params[:sql]
-    explanations = sql_segment.params[:explanation]
+    explanations = sql_segment.params[:explain_plan]
     if isMysql? || isPostgres?
       assert_not_nil explanations, "No explains in segment: #{sql_segment}"
-      assert_equal 1, explanations.size,"No explains in segment: #{sql_segment}"
-      assert_equal 1, explanations.first.size
+      assert_equal(2, explanations.size,
+                   "No explains in segment: #{sql_segment}")
     end
   end
 
@@ -388,14 +409,17 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
     sample = sample.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.0)
     segment = sample.root_segment.called_segments.first.called_segments.first.called_segments.first
-    explanations = segment.params[:explanation]
-    assert_not_nil explanations, "No explains in segment: #{segment}"
-    assert_equal 1, explanations.size,"No explains in segment: #{segment}"
-    assert_equal 1, explanations.first.size, "should be one row of explanation"
+    explanation = segment.params[:explain_plan]
+    assert_not_nil explanation, "No explains in segment: #{segment}"
+    assert_equal 2, explanation.size,"No explains in segment: #{segment}"
 
-    row = explanations.first.first
-    assert_equal 10, row.size
-    assert_equal ['1', 'SIMPLE', ActiveRecordFixtures::Order.table_name], row[0..2]
+    assert_equal 10, explanation[0].size
+    ['id', 'select_type', 'table'].each do |c|
+      assert explanation[0].include?(c)
+    end
+    ['1', 'SIMPLE', ActiveRecordFixtures::Order.table_name].each do |c|
+      assert explanation[1][0].include?(c)
+    end
 
     s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
     assert_equal 1, s.call_count
@@ -415,16 +439,14 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
     sample = sample.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.0)
     segment = sample.root_segment.called_segments.first.called_segments.first.called_segments.first
-    explanations = segment.params[:explanation]
+    explanations = segment.params[:explain_plan]
 
     assert_not_nil explanations, "No explains in segment: #{segment}"
     assert_equal 1, explanations.size,"No explains in segment: #{segment}"
     assert_equal 1, explanations.first.size
 
-    assert_equal Array, explanations.class
-    assert_equal Array, explanations[0].class
-    assert_equal Array, explanations[0][0].class
-    assert_match /Seq Scan on test_data/, explanations[0][0].join(";")
+    assert_equal("Explain Plan", explanations[0][0])
+    assert_match /Seq Scan on test_data/, explanations[0][1].join(";")
 
     s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
     assert_equal 1, s.call_count
@@ -450,7 +472,11 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
   # These are only valid for rails 2.1 and later
   if NewRelic::Control.instance.rails_version >= NewRelic::VersionNumber.new("2.1.0")
     ActiveRecordFixtures::Order.class_eval do
-      named_scope :jeffs, :conditions => { :name => 'Jeff' }
+      if NewRelic::Control.instance.rails_version < NewRelic::VersionNumber.new("3.1")
+        named_scope :jeffs, :conditions => { :name => 'Jeff' }
+      else
+        scope :jeffs, :conditions => { :name => 'Jeff' }
+      end      
     end
     def test_named_scope
       ActiveRecordFixtures::Order.create :name => 'Jeff'
@@ -473,7 +499,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
       true
     end
 
-    expected_metrics = %W[ActiveRecord/all Database/SQL/select]
+    expected_metrics = %W[ActiveRecord/all Database/SQL/select RemoteService/sql/mysql/localhost]
 
     assert_calls_metrics(*expected_metrics) do
       begin
@@ -487,6 +513,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)
   end
 
   def test_rescue_handling
@@ -501,22 +528,49 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
       assert_equal 'preserve-me!', e.message
     end
   end
-
+  
+  def test_remote_service_metric_respects_dynamic_connection_config
+    return unless isMysql?
+
+#     puts NewRelic::Agent::Database.config.inspect
+    
+    ActiveRecordFixtures::Shipment.connection.execute('SHOW TABLES');
+    assert(NewRelic::Agent.get_stats('RemoteService/sql/mysql/localhost').call_count != 0)
+
+    config = ActiveRecordFixtures::Shipment.connection.instance_eval { @config }    
+    config[:host] = '127.0.0.1'
+    connection = ActiveRecordFixtures::Shipment.establish_connection(config)
+    
+#     puts ActiveRecord::Base.connection.instance_eval { @config }.inspect
+#     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)
+
+    config[:host] = 'localhost'
+    ActiveRecordFixtures::Shipment.establish_connection(config)
+
+#     raise NewRelic::Agent.instance.stats_engine.inspect
+  end
+  
   private
 
   def rails3?
     (defined?(Rails) && Rails.respond_to?(:version) && Rails.version.to_i == 3)
   end
 
+  def rails_env
+    rails3? ? ::Rails.env : RAILS_ENV
+  end
+
   def isPostgres?
-    ActiveRecordFixtures::Order.configurations[RAILS_ENV]['adapter'] =~ /postgres/i
+    ActiveRecordFixtures::Order.configurations[rails_env]['adapter'] =~ /postgres/i
   end
   def isMysql?
     ActiveRecordFixtures::Order.connection.class.name =~ /mysql/i
   end
 
   def isSqlite?
-    ActiveRecord::Base.configurations[RAILS_ENV]['adapter'] =~ /sqlite/i
+    ActiveRecord::Base.configurations[rails_env]['adapter'] =~ /sqlite/i
   end
-
 end