newrelic_rpm 3.7.2.190.beta → 3.7.2.192

data/test/multiverse/suites/mongo/mongo_unsupported_version_test.rb

@@ -8,15 +8,16 @@ require 'new_relic/agent/datastores/mongo'
 require File.join(File.dirname(__FILE__), '..', '..', '..', 'agent_helper')
 
 if !NewRelic::Agent::Datastores::Mongo.is_supported_version?
+  require File.join(File.dirname(__FILE__), 'helpers', 'mongo_server')
 
-  class NewRelic::Agent::Instrumentation::MongoInstrumentationTest < MiniTest::Unit::TestCase
+  class NewRelic::Agent::Instrumentation::MongoUnsupportedVersionTest < MiniTest::Unit::TestCase
     include Mongo
 
     def setup
-      @client = Mongo::Connection.new(ENV["MONGO_HOST"], ENV["MONGO_PORT"].to_i)
-      @database_name = 'multiverse'
+      @client = Mongo::Connection.new($mongo.host, $mongo.port)
+      @database_name = "multiverse"
       @database = @client.db(@database_name)
-      @collection_name = 'tribbles'
+      @collection_name = "tribbles-#{SecureRandom.hex(16)}"
       @collection = @database.collection(@collection_name)
 
       @tribble = {'name' => 'soterios johnson'}
@@ -26,6 +27,7 @@ if !NewRelic::Agent::Datastores::Mongo.is_supported_version?
 
     def teardown
       NewRelic::Agent.drop_buffered_data
+      @database.drop_collection(@collection_name)
     end
 
     def test_records_metrics_for_insert

data/test/multiverse/suites/rails/ignore_test.rb

@@ -24,10 +24,11 @@ class IgnoredController < ApplicationController
 end
 
 class IgnoredActionsTest < ActionDispatch::IntegrationTest
-
   include MultiverseHelpers
 
-  setup_and_teardown_agent
+  setup_and_teardown_agent(:cross_process_id => "boo",
+                           :encoding_key => "\0",
+                           :trusted_account_ids => [1])
 
   def after_setup
     # Make sure we've got a blank slate for doing easier metric comparisons
@@ -45,4 +46,8 @@ class IgnoredActionsTest < ActionDispatch::IntegrationTest
     assert_metrics_not_recorded(["Apdex"])
   end
 
+  def test_should_not_write_cat_response_headers_for_ignored_transactions
+    get 'ignored/action_to_ignore', nil, {'X-NewRelic-ID' => Base64.encode64('1#234')}
+    assert_nil @response.headers["X-NewRelic-App-Data"]
+  end
 end

data/test/multiverse/suites/sequel/database.rb

@@ -14,6 +14,28 @@ if !defined?(DB)
     defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
   end
 
+  def create_tables(db)
+    db.create_table( :authors ) do
+      primary_key :id
+      string :name
+      string :login
+    end
+
+    db.create_table( :posts ) do
+      primary_key :id
+      string :title
+      string :content
+      time :created_at
+    end
+
+    db.create_table( :users ) do
+      primary_key :uid
+      string :login
+      string :firstname
+      string :lastname
+    end
+  end
+
   # Use an in-memory SQLite database
   if (jruby?)
     DB = Sequel.connect('jdbc:sqlite::memory:')
@@ -21,28 +43,10 @@ if !defined?(DB)
     DB = Sequel.sqlite
   end
 
-  # Create tables and model classes for testing
-  DB.create_table( :authors ) do
-    primary_key :id
-    string :name
-    string :login
-  end
-  class Author < Sequel::Model; end
+  create_tables(DB)
 
-  DB.create_table( :posts ) do
-    primary_key :id
-    string :title
-    string :content
-    time :created_at
-  end
+  class Author < Sequel::Model; end
   class Post < Sequel::Model; end
-
-  DB.create_table( :users ) do
-    primary_key :uid
-    string :login
-    string :firstname
-    string :lastname
-  end
   class User < Sequel::Model; end
 
   # Version 4.0 of Sequel moved update_except off to a plugin

data/test/multiverse/suites/sequel/sequel_instrumentation_test.rb

@@ -210,6 +210,22 @@ class NewRelic::Agent::Instrumentation::SequelInstrumentationTest < MiniTest::Un
     end
   end
 
+  def test_no_explain_plans_with_single_threaded_connection
+    connect_opts = DB.opts
+    single_threaded_db = Sequel.connect(connect_opts.merge(:single_threaded => true))
+    create_tables(single_threaded_db)
+    model_class = Class.new(Sequel::Model(single_threaded_db[:posts]))
+
+    with_config(:'transaction_tracer.explain_threshold' => -0.01,
+                :'transaction_tracer.record_sql' => 'raw') do
+      segment = last_segment_for do
+        model_class[11]
+      end
+      assert_match %r{select \* from `posts` where `id` = 11}i, segment.params[:sql]
+      assert_equal([], segment.params[:explain_plan], "Should not capture explain plan with single-threaded connection pool")
+    end
+  end
+
   def test_queries_can_get_explain_plan_with_obfuscated_sql
     config = {
       :'transaction_tracer.explain_threshold' => -0.01,

data/test/new_relic/agent/cross_app_monitor_test.rb

@@ -41,7 +41,6 @@ module NewRelic::Agent
 
       NewRelic::Agent.config.apply_config( @config )
       @monitor.on_finished_configuring
-      NewRelic::Agent::TransactionState.get.request_guid = TRANSACTION_GUID
     end
 
     def teardown
@@ -195,7 +194,10 @@ module NewRelic::Agent
     def when_request_runs(request=for_id(REQUEST_CROSS_APP_ID))
       event_listener = NewRelic::Agent.instance.events
       event_listener.notify(:before_call, request)
-      event_listener.notify(:start_transaction, 'a name')
+      in_transaction('transaction') do
+        # nothing
+      end
+      NewRelic::Agent::TransactionState.get.request_guid = TRANSACTION_GUID
       event_listener.notify(:after_call, request, [200, @response, ''])
     end
 

data/test/new_relic/agent/datastores/mongo/metric_generator_test.rb

@@ -9,7 +9,7 @@ class NewRelic::Agent::Datastores::Mongo::MetricGeneratorTest < MiniTest::Unit::
   include ::NewRelic::TestHelpers::MongoMetricBuilder
 
   def setup
-    @payload = { :collection => 'tribbles' }
+    @payload = { :collection => 'tribbles', :database => 'enterprise' }
   end
 
   def test_generate_metrics_for_includes_all_web_for_web_requests
@@ -40,4 +40,30 @@ class NewRelic::Agent::Datastores::Mongo::MetricGeneratorTest < MiniTest::Unit::
     refute metrics.include? 'Datastore/allWeb'
   end
 
+  def test_generate_metrics_for_is_graceful_if_exceptions_are_raised
+    NewRelic::Agent::Datastores::Mongo::MetricTranslator.stubs(:metrics_for).raises("Booom")
+    metrics = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_metrics_for(:insert, @payload)
+
+    assert_empty metrics
+  end
+
+  def test_generate_instance_metric_for_returns_instance_metric_for_given_attributes
+    result = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_instance_metric_for('host', 'port', 'database')
+    assert_equal 'Datastore/instance/MongoDB/host:port/database', result
+  end
+
+  def test_generate_metrics_for_does_not_include_instance_metric_without_host
+    result = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_instance_metric_for(nil, 'port', 'database')
+    assert_nil result
+  end
+
+  def test_generate_metrics_for_does_not_include_instance_metric_without_port
+    result = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_instance_metric_for('host', nil, 'database')
+    assert_nil result
+  end
+
+  def test_generate_metrics_for_does_not_include_instance_metric_without_database_name
+    result = NewRelic::Agent::Datastores::Mongo::MetricGenerator.generate_instance_metric_for('host', 'port', nil)
+    assert_nil result
+  end
 end

data/test/new_relic/agent/datastores/mongo/metric_translator_test.rb

@@ -21,17 +21,23 @@ class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < MiniTest::Unit:
   end
 
   def test_build_metrics_includes_web
-    expected = 'Datastore/allWeb'
     metrics = build_test_metrics('test')
-
-    assert metrics.include? expected
+    assert_includes metrics, 'Datastore/allWeb'
   end
 
   def test_build_metrics_includes_other
-    expected = 'Datastore/allOther'
     metrics = build_test_metrics('test', :other)
+    assert_includes metrics, 'Datastore/allOther'
+  end
+
+  def test_build_metrics_includes_activerecord_all_on_web
+    metrics = build_test_metrics('test', :web)
+    assert_includes metrics, 'ActiveRecord/all'
+  end
 
-    assert metrics.include? expected
+  def test_build_metrics_doesnt_include_activerecord_all_on_other
+    metrics = build_test_metrics('test', :other)
+    assert_not_includes metrics, 'ActiveRecord/all'
   end
 
   def test_metrics_for_find
@@ -263,7 +269,7 @@ class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < MiniTest::Unit:
                 :limit      => -1,
                 :selector   => { :ismaster => 1 } }
 
-    @collection_name = "1"
+    @collection_name = "$cmd"
 
     metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
     expected = build_test_metrics(:ismaster)
@@ -289,13 +295,17 @@ class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < MiniTest::Unit:
                 :limit => -1,
                 :selector => { :mongomongomongo => @collection_name } }
 
-    @collection_name = "UnknownCollection"
+    @collection_name = "$cmd"
 
     metrics = NewRelic::Agent::Datastores::Mongo::MetricTranslator.metrics_for(:find, payload)
-    expected = build_test_metrics(:UnknownCommand)
+    expected = build_test_metrics(:mongomongomongo)
 
     assert_equal expected, metrics
-    assert_metrics_recorded(["Supportability/Mongo/UnknownCommand"])
+    assert_metrics_recorded(["Supportability/Mongo/UnknownCollection"])
   end
 
+  def test_instance_metric
+    metric = NewRelic::Agent::Datastores::Mongo::MetricTranslator.instance_metric('localhost', '27017', @database_name)
+    assert_equal 'Datastore/instance/MongoDB/localhost:27017/multiverse', metric
+  end
 end

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

@@ -78,499 +78,503 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < MiniTe
     end
   end
 
-  #def test_metric_names_jruby
-  #  # 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)
-  #  expected = %W[
-  #    ActiveRecord/all
-  #    ActiveRecord/find
-  #    ActiveRecord/ActiveRecordFixtures::Order/find
-  #    Database/SQL/insert
-  #    RemoteService/sql/#{adapter}/localhost
-  #  ]
-
-  #  if NewRelic::Control.instance.rails_version < '2.1.0'
-  #    expected += %W[ActiveRecord/save ActiveRecord/ActiveRecordFixtures::Order/save]
-  #  end
-
-  #  assert_calls_metrics(*expected) do
-  #    m = ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
-  #    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)
-  #  # zero because jruby uses a different mysql adapter
-  #  check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/create", 0)
-  #end
-
-  #def test_metric_names_sqlite
-  #  # 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? || !isSqlite? || defined?(JRuby)
-
-  #  expected = %W[
-  #    ActiveRecord/all
-  #    ActiveRecord/find
-  #    ActiveRecord/ActiveRecordFixtures::Order/find
-  #    ActiveRecord/create
-  #    ActiveRecord/ActiveRecordFixtures::Order/create]
-
-  #  if NewRelic::Control.instance.rails_version < '2.1.0'
-  #    expected += %W[ActiveRecord/save ActiveRecord/ActiveRecordFixtures::Order/save]
-  #  end
-
-  #  assert_calls_metrics(*expected) do
-  #    m = ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
-  #    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)
-  #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 defined?(JRuby) || isSqlite?
-
-  #  expected = %W[
-  #    ActiveRecord/all
-  #    ActiveRecord/find
-  #    ActiveRecord/create
-  #    ActiveRecord/ActiveRecordFixtures::Order/find
-  #    ActiveRecord/ActiveRecordFixtures::Order/create
-  #    Database/SQL/other
-  #    RemoteService/sql/#{adapter}/localhost]
-
-  #  if NewRelic::Control.instance.rails_version < '2.1.0'
-  #    expected += ['ActiveRecord/save',
-  #                 'ActiveRecord/ActiveRecordFixtures::Order/save']
-  #  end
-
-  #  if NewRelic::Control.instance.rails_version >= '3.0.0'
-  #    expected << 'Database/SQL/insert'
-  #  end
-
-  #  if NewRelic::Control.instance.rails_version >= '4.0'
-  #    expected << 'Database/SQL/update'
-  #  end
-
-  #  assert_calls_metrics(*expected) do
-  #    m = ActiveRecordFixtures::Order.create :id => 1, :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)
-  #  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
-  #  return unless defined?(JRuby)
-  #  return if rails3?
-
-  #  expected_metrics = %W[
-  #  ActiveRecord/all
-  #  ActiveRecord/destroy
-  #  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/#{adapter}/localhost
-  #  ]
-
-  #  assert_calls_metrics(*expected_metrics) do
-  #    m = ActiveRecordFixtures::Order.create :name => 'jeff'
-  #    m = ActiveRecordFixtures::Order.find(m.id)
-  #    s = m.shipments.create
-  #    m.shipments.to_a
-  #    m.destroy
-  #  end
-
-  #  metrics = NewRelic::Agent.instance.stats_engine.metrics
-
-  #  compare_metrics expected_metrics, metrics
-
-  #  check_metric_time('ActiveRecord/all', NewRelic::Agent.get_stats("ActiveRecord/all").total_exclusive_time, 0)
-  #  check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/find", 1)
-  #  check_metric_count("ActiveRecord/ActiveRecordFixtures::Shipment/find", 1)
-  #  check_metric_count("Database/SQL/insert", 3)
-  #  check_metric_count("Database/SQL/delete", 1)
-  #end
-
-  #def test_join_metrics_sqlite
-  #  return if (defined?(Rails) && Rails::VERSION::MAJOR.to_i == 3)
-  #  return if defined?(JRuby)
-  #  return unless isSqlite?
-
-  #  expected_metrics = %W[
-  #  ActiveRecord/all
-  #  ActiveRecord/destroy
-  #  ActiveRecord/ActiveRecordFixtures::Order/destroy
-  #  Database/SQL/insert
-  #  Database/SQL/delete
-  #  ActiveRecord/find
-  #  ActiveRecord/ActiveRecordFixtures::Order/find
-  #  ActiveRecord/ActiveRecordFixtures::Shipment/find
-  #  ActiveRecord/create
-  #  ActiveRecord/ActiveRecordFixtures::Shipment/create
-  #  ActiveRecord/ActiveRecordFixtures::Order/create
-  #  ]
-
-  #  assert_calls_metrics(*expected_metrics) do
-  #    m = ActiveRecordFixtures::Order.create :name => 'jeff'
-  #    m = ActiveRecordFixtures::Order.find(m.id)
-  #    s = m.shipments.create
-  #    m.shipments.to_a
-  #    m.destroy
-  #  end
-
-  #  metrics = NewRelic::Agent.instance.stats_engine.metrics
-  #  compare_metrics expected_metrics, metrics
-  #  if !(defined?(RUBY_DESCRIPTION) && RUBY_DESCRIPTION =~ /Enterprise Edition/)
-  #    check_metric_time('ActiveRecord/all', NewRelic::Agent.get_stats("ActiveRecord/all").total_exclusive_time, 0)
-  #  end
-  #  check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/find", 1)
-  #  check_metric_count("ActiveRecord/ActiveRecordFixtures::Shipment/find", 1)
-  #  check_metric_count("Database/SQL/insert", 3)
-  #  check_metric_count("Database/SQL/delete", 1)
-  #end
-
-  #def test_join_metrics_standard
-  #  return if (defined?(Rails) && Rails::VERSION::MAJOR.to_i >= 3)
-  #  return if defined?(JRuby) || isSqlite?
-
-  #  expected_metrics = %W[
-  #  ActiveRecord/all
-  #  RemoteService/sql/#{adapter}/localhost
-  #  ActiveRecord/destroy
-  #  ActiveRecord/ActiveRecordFixtures::Order/destroy
-  #  Database/SQL/insert
-  #  Database/SQL/delete
-  #  ActiveRecord/find
-  #  ActiveRecord/ActiveRecordFixtures::Order/find
-  #  ActiveRecord/ActiveRecordFixtures::Shipment/find
-  #  Database/SQL/other
-  #  Database/SQL/show
-  #  ActiveRecord/create
-  #  ActiveRecord/ActiveRecordFixtures::Shipment/create
-  #  ActiveRecord/ActiveRecordFixtures::Order/create
-  #  ]
-
-  #  assert_calls_metrics(*expected_metrics) do
-  #    m = ActiveRecordFixtures::Order.create :name => 'jeff'
-  #    m = ActiveRecordFixtures::Order.find(m.id)
-  #    s = m.shipments.create
-  #    m.shipments.to_a
-  #    m.destroy
-  #  end
-
-  #  metrics = NewRelic::Agent.instance.stats_engine.metrics
-
-  #  compare_metrics expected_metrics, metrics
-  #  if !(defined?(RUBY_DESCRIPTION) && RUBY_DESCRIPTION =~ /Enterprise Edition/)
-  #    check_metric_time('ActiveRecord/all', NewRelic::Agent.get_stats("ActiveRecord/all").total_exclusive_time, 0)
-  #  end
-  #  check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/find", 1)
-  #  check_metric_count("ActiveRecord/ActiveRecordFixtures::Shipment/find", 1)
-  #  check_metric_count("Database/SQL/insert", 1)
-  #  check_metric_count("Database/SQL/delete", 1)
-  #end
-
-  #def test_direct_sql
-  #  assert_nil NewRelic::Agent::Transaction.current
-  #  assert_equal 0, NewRelic::Agent.instance.stats_engine.metrics.size, NewRelic::Agent.instance.stats_engine.metrics.inspect
-
-  #  expected_metrics = %W[
-  #  ActiveRecord/all
-  #  Database/SQL/select
-  #  RemoteService/sql/#{adapter}/localhost
-  #  ]
-
-  #  assert_calls_unscoped_metrics(*expected_metrics) do
-  #    ActiveRecordFixtures::Order.connection.select_rows "select * from #{ActiveRecordFixtures::Order.table_name}"
-  #  end
-
-  #  metrics = NewRelic::Agent.instance.stats_engine.metrics
-  #  compare_metrics(expected_metrics, metrics)
-
-  #  check_unscoped_metric_count('Database/SQL/select', 1)
-
-  #end
-
-  #def test_other_sql
-  #  expected_metrics = %W[
-  #  ActiveRecord/all
-  #  Database/SQL/other
-  #  RemoteService/sql/#{adapter}/localhost
-  #  ]
-  #  assert_calls_unscoped_metrics(*expected_metrics) do
-  #    ActiveRecordFixtures::Order.connection.execute "begin"
-  #  end
-
-  #  metrics = NewRelic::Agent.instance.stats_engine.metrics
-
-  #  compare_metrics expected_metrics, metrics
-  #  check_unscoped_metric_count('Database/SQL/other', 1)
-  #end
-
-  #def test_show_sql
-  #  return if isSqlite?
-  #  return if isPostgres?
-
-  #  expected_metrics = %W[ActiveRecord/all Database/SQL/show RemoteService/sql/#{adapter}/localhost]
-  #  assert_calls_metrics(*expected_metrics) do
-  #    ActiveRecordFixtures::Order.connection.execute "show tables"
-  #  end
-  #  metrics = NewRelic::Agent.instance.stats_engine.metrics
-  #  compare_metrics expected_metrics, metrics
-  #  check_unscoped_metric_count('Database/SQL/show', 1)
-  #end
-
-  #def test_blocked_instrumentation
-  #  ActiveRecordFixtures::Order.add_delay
-  #  NewRelic::Agent.disable_all_tracing do
-  #    perform_action_with_newrelic_trace :name => 'bogosity' do
-  #      all_finder(ActiveRecordFixtures::Order)
-  #    end
-  #  end
-  #  assert_nil NewRelic::Agent.instance.transaction_sampler.last_sample
-  #  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
-  #    all_finder(ActiveRecordFixtures::Order)
-  #  end
-
-  #  # that's a mouthful. perhaps we should ponder our API.
-  #  segment = last_segment(NewRelic::Agent.instance.transaction_sampler.last_sample)
-  #  regex = /^SELECT (["`]?#{ActiveRecordFixtures::Order.table_name}["`]?.)?\* FROM ["`]?#{ActiveRecordFixtures::Order.table_name}["`]?$/
-  #  assert_match regex, segment.params[:sql].strip
-  #end
-
-  #def test_prepare_to_send
-  #  with_config(:'transaction_tracer.explain_enabled' => true,
-  #              :'transaction_tracer.explain_threshold' => 0.0) do
-  #    perform_action_with_newrelic_trace :name => 'bogosity' do
-  #      ActiveRecordFixtures::Order.add_delay
-  #      all_finder(ActiveRecordFixtures::Order)
-  #    end
-  #    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-  #    refute_nil sample
-
-  #    includes_gc = false
-  #    sample.each_segment {|s| includes_gc ||= s.metric_name =~ /GC/ }
-
-  #    sql_segment = last_segment(sample)
-  #    refute_nil sql_segment, sample.to_s
-  #    assert_match /^SELECT /, sql_segment.params[:sql]
-  #    assert sql_segment.duration > 0.0, "Segment duration must be greater than zero."
-  #    sample = sample.prepare_to_send!
-  #    sql_segment = last_segment(sample)
-  #    assert_match /^SELECT /, sql_segment.params[:sql]
-  #    explanations = sql_segment.params[:explain_plan]
-  #    if (isMysql? || isPostgres?) && !NewRelic::LanguageSupport.using_engine?('jruby')
-  #      refute_nil explanations, "No explains in segment: #{sql_segment}"
-  #      assert_equal(2, explanations.size,
-  #                   "No explains in segment: #{sql_segment}")
-  #    end
-  #  end
-  #end
-
-  #def test_transaction_mysql
-  #  return unless isMysql? && !defined?(JRuby)
-
-  #  with_config(:record_sql => :obfuscated,
-  #              :'transaction_tracer.explain_enabled' => true,
-  #              :'transaction_tracer.explain_threshold' => 0.0) do
-  #    ActiveRecordFixtures.setup
-  #    sample = NewRelic::Agent.instance.transaction_sampler.reset!
-  #    perform_action_with_newrelic_trace :name => 'bogosity' do
-  #      ActiveRecordFixtures::Order.add_delay
-  #      all_finder(ActiveRecordFixtures::Order)
-  #    end
-
-  #    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-  #    sample = sample.prepare_to_send!
-  #    segment = last_segment(sample)
-  #    explanation = segment.params[:explain_plan]
-  #    refute_nil explanation, "No explains in segment: #{segment}"
-  #    assert_equal 2, explanation.size,"No explains in segment: #{segment}"
-
-  #    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
-  #  end
-  #end
-
-  #def test_transaction_postgres
-  #  return unless isPostgres?
-
-  #  with_config(:record_sql => :obfuscated,
-  #              :'transaction_tracer.explain_enabled' => true,
-  #              :'transaction_tracer.explain_threshold' => 0.0) do
-  #    # note that our current test builds do not use postgres, this is
-  #    # here strictly for troubleshooting, not CI builds
-  #    sample = NewRelic::Agent.instance.transaction_sampler.reset!
-  #    perform_action_with_newrelic_trace :name => 'bogosity' do
-  #      ActiveRecordFixtures::Order.add_delay
-  #      all_finder(ActiveRecordFixtures::Order)
-  #    end
-
-  #    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-
-  #    sample = sample.prepare_to_send!
-  #    segment = last_segment(sample)
-  #    explanations = segment.params[:explain_plan]
-
-  #    refute_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("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
-  #  end
-  #end
-
-  #def test_transaction_other
-  #  return if isMysql? || isPostgres?
-
-  #  with_config(:record_sql => :obfuscated,
-  #              :'transaction_tracer.explain_enabled' => true,
-  #              :'transaction_tracer.explain_threshold' => 0.0) do
-  #    sample = NewRelic::Agent.instance.transaction_sampler.reset!
-  #    perform_action_with_newrelic_trace :name => 'bogosity' do
-  #      ActiveRecordFixtures::Order.add_delay
-  #      all_finder(ActiveRecordFixtures::Order)
-  #    end
-
-  #    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-
-  #    sample = sample.prepare_to_send!
-  #    segment = last_segment(sample)
-
-  #    s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
-  #    assert_equal 1, s.call_count
-  #  end
-  #end
-
-  ## 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
-  #    if NewRelic::Control.instance.rails_version >= NewRelic::VersionNumber.new("4")
-  #      scope :jeffs, lambda { where(:name => 'Jeff') }
-  #    elsif NewRelic::Control.instance.rails_version >= NewRelic::VersionNumber.new("3.1")
-  #      scope :jeffs, :conditions => { :name => 'Jeff' }
-  #    else
-  #      named_scope :jeffs, :conditions => { :name => 'Jeff' }
-  #    end
-  #  end
-  #  def test_named_scope
-  #    ActiveRecordFixtures::Order.create :name => 'Jeff'
-
-  #    find_metric = "ActiveRecord/ActiveRecordFixtures::Order/find"
-
-  #    check_metric_count(find_metric, 0)
-  #    assert_calls_metrics(find_metric) do
-  #      if NewRelic::Control.instance.rails_version >= "4"
-  #        x = ActiveRecordFixtures::Order.jeffs.load
-  #      else
-  #        x = ActiveRecordFixtures::Order.jeffs.find(:all)
-  #      end
-  #    end
-  #    check_metric_count(find_metric, 1)
-  #  end
-  #end
-
-  ## This is to make sure the all metric is recorded for exceptional cases
-  #def test_error_handling
-  #  # have the AR select throw an error
-  #  ActiveRecordFixtures::Order.connection.stubs(:log_info).with do | sql, x, y |
-  #    raise "Error" if sql =~ /select/
-  #    true
-  #  end
-
-  #  in_web_transaction do
-  #    begin
-  #      ActiveRecordFixtures::Order.connection.select_rows "select * from #{ActiveRecordFixtures::Order.table_name}"
-  #    rescue RuntimeError => e
-  #      # catch only the error we raise above
-  #      raise unless e.message == 'Error'
-  #    end
-  #  end
-
-  #  assert_metrics_recorded(
-  #    'ActiveRecord/all' => { :call_count => 1 },
-  #    'Database/SQL/select' => { :call_count => 1 }
-  #  )
-
-  #  if !NewRelic::LanguageSupport.using_engine?('jruby')
-  #    assert_metrics_recorded("RemoteService/sql/#{adapter}/localhost" => { :call_count => 1 })
-  #  end
-  #end
-
-  #def test_rescue_handling
-  #  # Not sure why we get a transaction error with sqlite
-  #  return if isSqlite?
-
-  #  begin
-  #    ActiveRecordFixtures::Order.transaction do
-  #      raise ActiveRecord::ActiveRecordError.new('preserve-me!')
-  #    end
-  #  rescue ActiveRecord::ActiveRecordError => e
-  #    assert_equal 'preserve-me!', e.message
-  #  end
-  #end
-
-  #def test_remote_service_metric_respects_dynamic_connection_config
-  #  return unless isMysql? && !NewRelic::LanguageSupport.using_engine?('jruby')
-
-  #  ActiveRecordFixtures::Shipment.connection.execute('SHOW TABLES');
-  #  assert_metrics_recorded(["RemoteService/sql/#{adapter}/localhost"])
-
-  #  config = ActiveRecordFixtures::Shipment.connection.instance_eval { @config }
-  #  config[:host] = '127.0.0.1'
-  #  connection = ActiveRecordFixtures::Shipment.establish_connection(config)
-
-  #  ActiveRecordFixtures::Shipment.connection.execute('SHOW TABLES');
-  #  assert_metrics_recorded(["RemoteService/sql/#{adapter}/127.0.0.1"])
-
-  #  config[:host] = 'localhost'
-  #  ActiveRecordFixtures::Shipment.establish_connection(config)
-  #end
+  def test_metric_names_jruby
+    # 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)
+    expected = %W[
+      ActiveRecord/all
+      ActiveRecord/find
+      ActiveRecord/ActiveRecordFixtures::Order/find
+      Database/SQL/insert
+      RemoteService/sql/#{adapter}/localhost
+    ]
+
+    if NewRelic::Control.instance.rails_version < '2.1.0'
+      expected += %W[ActiveRecord/save ActiveRecord/ActiveRecordFixtures::Order/save]
+    end
+
+    assert_calls_metrics(*expected) do
+      m = ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
+      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)
+    # zero because jruby uses a different mysql adapter
+    check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/create", 0)
+  end
+
+  def test_metric_names_sqlite
+    # 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? || !isSqlite? || defined?(JRuby)
+
+    expected = %W[
+      ActiveRecord/all
+      ActiveRecord/find
+      ActiveRecord/ActiveRecordFixtures::Order/find
+      ActiveRecord/create
+      ActiveRecord/ActiveRecordFixtures::Order/create]
+
+    if NewRelic::Control.instance.rails_version < '2.1.0'
+      expected += %W[ActiveRecord/save ActiveRecord/ActiveRecordFixtures::Order/save]
+    end
+
+    assert_calls_metrics(*expected) do
+      m = ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
+      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)
+  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 defined?(JRuby) || isSqlite?
+
+    expected = %W[
+      ActiveRecord/all
+      ActiveRecord/find
+      ActiveRecord/create
+      ActiveRecord/ActiveRecordFixtures::Order/find
+      ActiveRecord/ActiveRecordFixtures::Order/create
+      Database/SQL/other
+      Database/SQL/show
+      RemoteService/sql/#{adapter}/localhost]
+
+    if NewRelic::Control.instance.rails_version < '2.1.0'
+      expected += ['ActiveRecord/save',
+                   'ActiveRecord/ActiveRecordFixtures::Order/save']
+    end
+
+    if NewRelic::Control.instance.rails_version >= '3.0.0'
+      expected << 'Database/SQL/insert'
+    end
+
+    if NewRelic::Control.instance.rails_version >= '4.0'
+      expected << 'Database/SQL/update'
+    end
+
+    assert_calls_metrics(*expected) do
+      m = ActiveRecordFixtures::Order.create :id => 1, :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)
+    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
+    return unless defined?(JRuby)
+    return if rails3?
+
+    expected_metrics = %W[
+    ActiveRecord/all
+    ActiveRecord/destroy
+    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/#{adapter}/localhost
+    ]
+
+    assert_calls_metrics(*expected_metrics) do
+      m = ActiveRecordFixtures::Order.create :name => 'jeff'
+      m = ActiveRecordFixtures::Order.find(m.id)
+      s = m.shipments.create
+      m.shipments.to_a
+      m.destroy
+    end
+
+    metrics = NewRelic::Agent.instance.stats_engine.metrics
+
+    compare_metrics expected_metrics, metrics
+
+    check_metric_time('ActiveRecord/all', NewRelic::Agent.get_stats("ActiveRecord/all").total_exclusive_time, 0)
+    check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/find", 1)
+    check_metric_count("ActiveRecord/ActiveRecordFixtures::Shipment/find", 1)
+    check_metric_count("Database/SQL/insert", 3)
+    check_metric_count("Database/SQL/delete", 1)
+  end
+
+  def test_join_metrics_sqlite
+    return if (defined?(Rails) && Rails::VERSION::MAJOR.to_i == 3)
+    return if defined?(JRuby)
+    return unless isSqlite?
+
+    expected_metrics = %W[
+    ActiveRecord/all
+    ActiveRecord/destroy
+    ActiveRecord/ActiveRecordFixtures::Order/destroy
+    Database/SQL/insert
+    Database/SQL/delete
+    ActiveRecord/find
+    ActiveRecord/ActiveRecordFixtures::Order/find
+    ActiveRecord/ActiveRecordFixtures::Shipment/find
+    ActiveRecord/create
+    ActiveRecord/ActiveRecordFixtures::Shipment/create
+    ActiveRecord/ActiveRecordFixtures::Order/create
+    ]
+
+    assert_calls_metrics(*expected_metrics) do
+      m = ActiveRecordFixtures::Order.create :name => 'jeff'
+      m = ActiveRecordFixtures::Order.find(m.id)
+      s = m.shipments.create
+      m.shipments.to_a
+      m.destroy
+    end
+
+    metrics = NewRelic::Agent.instance.stats_engine.metrics
+    compare_metrics expected_metrics, metrics
+    if !(defined?(RUBY_DESCRIPTION) && RUBY_DESCRIPTION =~ /Enterprise Edition/)
+      check_metric_time('ActiveRecord/all', NewRelic::Agent.get_stats("ActiveRecord/all").total_exclusive_time, 0)
+    end
+    check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/find", 1)
+    check_metric_count("ActiveRecord/ActiveRecordFixtures::Shipment/find", 1)
+    check_metric_count("Database/SQL/insert", 3)
+    check_metric_count("Database/SQL/delete", 1)
+  end
+
+  def test_join_metrics_standard
+    return if (defined?(Rails) && Rails::VERSION::MAJOR.to_i >= 3)
+    return if defined?(JRuby) || isSqlite?
+
+    expected_metrics = %W[
+    ActiveRecord/all
+    RemoteService/sql/#{adapter}/localhost
+    ActiveRecord/destroy
+    ActiveRecord/ActiveRecordFixtures::Order/destroy
+    Database/SQL/insert
+    Database/SQL/delete
+    ActiveRecord/find
+    ActiveRecord/ActiveRecordFixtures::Order/find
+    ActiveRecord/ActiveRecordFixtures::Shipment/find
+    Database/SQL/other
+    Database/SQL/show
+    ActiveRecord/create
+    ActiveRecord/ActiveRecordFixtures::Shipment/create
+    ActiveRecord/ActiveRecordFixtures::Order/create
+    ]
+
+    assert_calls_metrics(*expected_metrics) do
+      m = ActiveRecordFixtures::Order.create :name => 'jeff'
+      m = ActiveRecordFixtures::Order.find(m.id)
+      s = m.shipments.create
+      m.shipments.to_a
+      m.destroy
+    end
+
+    metrics = NewRelic::Agent.instance.stats_engine.metrics
+
+    compare_metrics expected_metrics, metrics
+    if !(defined?(RUBY_DESCRIPTION) && RUBY_DESCRIPTION =~ /Enterprise Edition/)
+      check_metric_time('ActiveRecord/all', NewRelic::Agent.get_stats("ActiveRecord/all").total_exclusive_time, 0)
+    end
+    check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/find", 1)
+    check_metric_count("ActiveRecord/ActiveRecordFixtures::Shipment/find", 1)
+    check_metric_count("Database/SQL/insert", 1)
+    check_metric_count("Database/SQL/delete", 1)
+  end
+
+  def test_direct_sql
+    assert_nil NewRelic::Agent::Transaction.current
+    assert_equal 0, NewRelic::Agent.instance.stats_engine.metrics.size, NewRelic::Agent.instance.stats_engine.metrics.inspect
+
+    expected_metrics = %W[
+    ActiveRecord/all
+    Database/SQL/select
+    RemoteService/sql/#{adapter}/localhost
+    ]
+
+    assert_calls_unscoped_metrics(*expected_metrics) do
+      ActiveRecordFixtures::Order.connection.select_rows "select * from #{ActiveRecordFixtures::Order.table_name}"
+    end
+
+    metrics = NewRelic::Agent.instance.stats_engine.metrics
+    compare_metrics(expected_metrics, metrics)
+
+    check_unscoped_metric_count('Database/SQL/select', 1)
+
+  end
+
+  def test_other_sql
+    expected_metrics = %W[
+    ActiveRecord/all
+    Database/SQL/other
+    RemoteService/sql/#{adapter}/localhost
+    ]
+    assert_calls_unscoped_metrics(*expected_metrics) do
+      ActiveRecordFixtures::Order.connection.execute "begin"
+    end
+
+    metrics = NewRelic::Agent.instance.stats_engine.metrics
+
+    compare_metrics expected_metrics, metrics
+    check_unscoped_metric_count('Database/SQL/other', 1)
+  ensure
+    # Make sure we get the transaction closed up for other tests
+    ActiveRecordFixtures::Order.connection.execute "commit"
+  end
+
+  def test_show_sql
+    return if isSqlite?
+    return if isPostgres?
+
+    expected_metrics = %W[ActiveRecord/all Database/SQL/show RemoteService/sql/#{adapter}/localhost]
+    assert_calls_metrics(*expected_metrics) do
+      ActiveRecordFixtures::Order.connection.execute "show tables"
+    end
+    metrics = NewRelic::Agent.instance.stats_engine.metrics
+    compare_metrics expected_metrics, metrics
+    check_unscoped_metric_count('Database/SQL/show', 1)
+  end
+
+  def test_blocked_instrumentation
+    ActiveRecordFixtures::Order.add_delay
+    NewRelic::Agent.disable_all_tracing do
+      perform_action_with_newrelic_trace :name => 'bogosity' do
+        all_finder(ActiveRecordFixtures::Order)
+      end
+    end
+    assert_nil NewRelic::Agent.instance.transaction_sampler.last_sample
+    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
+      all_finder(ActiveRecordFixtures::Order)
+    end
+
+    # that's a mouthful. perhaps we should ponder our API.
+    segment = last_segment(NewRelic::Agent.instance.transaction_sampler.last_sample)
+    regex = /^SELECT (["`]?#{ActiveRecordFixtures::Order.table_name}["`]?.)?\* FROM ["`]?#{ActiveRecordFixtures::Order.table_name}["`]?$/
+    assert_match regex, segment.params[:sql].strip
+  end
+
+  def test_prepare_to_send
+    with_config(:'transaction_tracer.explain_enabled' => true,
+                :'transaction_tracer.explain_threshold' => 0.0) do
+      perform_action_with_newrelic_trace :name => 'bogosity' do
+        ActiveRecordFixtures::Order.add_delay
+        all_finder(ActiveRecordFixtures::Order)
+      end
+      sample = NewRelic::Agent.instance.transaction_sampler.last_sample
+      refute_nil sample
+
+      includes_gc = false
+      sample.each_segment {|s| includes_gc ||= s.metric_name =~ /GC/ }
+
+      sql_segment = last_segment(sample)
+      refute_nil sql_segment, sample.to_s
+      assert_match /^SELECT /, sql_segment.params[:sql]
+      assert sql_segment.duration > 0.0, "Segment duration must be greater than zero."
+      sample = sample.prepare_to_send!
+      sql_segment = last_segment(sample)
+      assert_match /^SELECT /, sql_segment.params[:sql]
+      explanations = sql_segment.params[:explain_plan]
+      if (isMysql? || isPostgres?) && !NewRelic::LanguageSupport.using_engine?('jruby')
+        refute_nil explanations, "No explains in segment: #{sql_segment}"
+        assert_equal(2, explanations.size,
+                     "No explains in segment: #{sql_segment}")
+      end
+    end
+  end
+
+  def test_transaction_mysql
+    return unless isMysql? && !defined?(JRuby)
+
+    with_config(:record_sql => :obfuscated,
+                :'transaction_tracer.explain_enabled' => true,
+                :'transaction_tracer.explain_threshold' => 0.0) do
+      ActiveRecordFixtures.setup
+      sample = NewRelic::Agent.instance.transaction_sampler.reset!
+      perform_action_with_newrelic_trace :name => 'bogosity' do
+        ActiveRecordFixtures::Order.add_delay
+        all_finder(ActiveRecordFixtures::Order)
+      end
+
+      sample = NewRelic::Agent.instance.transaction_sampler.last_sample
+      sample = sample.prepare_to_send!
+      segment = last_segment(sample)
+      explanation = segment.params[:explain_plan]
+      refute_nil explanation, "No explains in segment: #{segment}"
+      assert_equal 2, explanation.size,"No explains in segment: #{segment}"
+
+      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
+    end
+  end
+
+  def test_transaction_postgres
+    return unless isPostgres?
+
+    with_config(:record_sql => :obfuscated,
+                :'transaction_tracer.explain_enabled' => true,
+                :'transaction_tracer.explain_threshold' => 0.0) do
+      # note that our current test builds do not use postgres, this is
+      # here strictly for troubleshooting, not CI builds
+      sample = NewRelic::Agent.instance.transaction_sampler.reset!
+      perform_action_with_newrelic_trace :name => 'bogosity' do
+        ActiveRecordFixtures::Order.add_delay
+        all_finder(ActiveRecordFixtures::Order)
+      end
+
+      sample = NewRelic::Agent.instance.transaction_sampler.last_sample
+
+      sample = sample.prepare_to_send!
+      segment = last_segment(sample)
+      explanations = segment.params[:explain_plan]
+
+      refute_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("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
+    end
+  end
+
+  def test_transaction_other
+    return if isMysql? || isPostgres?
+
+    with_config(:record_sql => :obfuscated,
+                :'transaction_tracer.explain_enabled' => true,
+                :'transaction_tracer.explain_threshold' => 0.0) do
+      sample = NewRelic::Agent.instance.transaction_sampler.reset!
+      perform_action_with_newrelic_trace :name => 'bogosity' do
+        ActiveRecordFixtures::Order.add_delay
+        all_finder(ActiveRecordFixtures::Order)
+      end
+
+      sample = NewRelic::Agent.instance.transaction_sampler.last_sample
+
+      sample = sample.prepare_to_send!
+      segment = last_segment(sample)
+
+      s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
+      assert_equal 1, s.call_count
+    end
+  end
+
+  # 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
+      if NewRelic::Control.instance.rails_version >= NewRelic::VersionNumber.new("4")
+        scope :jeffs, lambda { where(:name => 'Jeff') }
+      elsif NewRelic::Control.instance.rails_version >= NewRelic::VersionNumber.new("3.1")
+        scope :jeffs, :conditions => { :name => 'Jeff' }
+      else
+        named_scope :jeffs, :conditions => { :name => 'Jeff' }
+      end
+    end
+    def test_named_scope
+      ActiveRecordFixtures::Order.create :name => 'Jeff'
+
+      find_metric = "ActiveRecord/ActiveRecordFixtures::Order/find"
+
+      check_metric_count(find_metric, 0)
+      assert_calls_metrics(find_metric) do
+        if NewRelic::Control.instance.rails_version >= "4"
+          x = ActiveRecordFixtures::Order.jeffs.load
+        else
+          x = ActiveRecordFixtures::Order.jeffs.find(:all)
+        end
+      end
+      check_metric_count(find_metric, 1)
+    end
+  end
+
+  # This is to make sure the all metric is recorded for exceptional cases
+  def test_error_handling
+    # have the AR select throw an error
+    ActiveRecordFixtures::Order.connection.stubs(:log_info).with do | sql, x, y |
+      raise "Error" if sql =~ /select/
+      true
+    end
+
+    in_web_transaction do
+      begin
+        ActiveRecordFixtures::Order.connection.select_rows "select * from #{ActiveRecordFixtures::Order.table_name}"
+      rescue RuntimeError => e
+        # catch only the error we raise above
+        raise unless e.message == 'Error'
+      end
+    end
+
+    assert_metrics_recorded(
+      'ActiveRecord/all' => { :call_count => 1 },
+      'Database/SQL/select' => { :call_count => 1 }
+    )
+
+    if !NewRelic::LanguageSupport.using_engine?('jruby')
+      assert_metrics_recorded("RemoteService/sql/#{adapter}/localhost" => { :call_count => 1 })
+    end
+  end
+
+  def test_rescue_handling
+    # Not sure why we get a transaction error with sqlite
+    return if isSqlite?
+
+    begin
+      ActiveRecordFixtures::Order.transaction do
+        raise ActiveRecord::ActiveRecordError.new('preserve-me!')
+      end
+    rescue ActiveRecord::ActiveRecordError => e
+      assert_equal 'preserve-me!', e.message
+    end
+  end
+
+  def test_remote_service_metric_respects_dynamic_connection_config
+    return unless isMysql? && !NewRelic::LanguageSupport.using_engine?('jruby')
+
+    ActiveRecordFixtures::Shipment.connection.execute('SHOW TABLES');
+    assert_metrics_recorded(["RemoteService/sql/#{adapter}/localhost"])
+
+    config = ActiveRecordFixtures::Shipment.connection.instance_eval { @config }
+    config[:host] = '127.0.0.1'
+    connection = ActiveRecordFixtures::Shipment.establish_connection(config)
+
+    ActiveRecordFixtures::Shipment.connection.execute('SHOW TABLES');
+    assert_metrics_recorded(["RemoteService/sql/#{adapter}/127.0.0.1"])
+
+    config[:host] = 'localhost'
+    ActiveRecordFixtures::Shipment.establish_connection(config)
+  end
 
   private