ghazel-newrelic_rpm 3.1.0.1

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

@@ -0,0 +1,257 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
+  require 'new_relic/agent/error_collector'
+  include NewRelic::Agent::ErrorCollector::NoticeError
+
+  def test_error_params_from_options_mocked
+    options = {:initial => 'options'}
+    self.expects(:uri_ref_and_root).returns({:hi => 'there', :hello => 'bad'})
+    self.expects(:normalized_request_and_custom_params).with({:initial => 'options'}).returns({:hello => 'world'})
+    assert_equal({:hi => 'there', :hello => 'world'}, error_params_from_options(options))
+  end
+
+  module Winner
+    def winner
+      'yay'
+    end
+  end
+
+  def test_sense_method
+    object = Object.new
+    object.extend(Winner)
+    assert !sense_method(object, 'blab')
+    assert_equal 'yay', sense_method(object, 'winner')
+  end
+
+  def test_fetch_from_options
+    options = {:hello => 'world'}
+    assert_equal 'world', fetch_from_options(options, :hello, '')
+    assert_equal '', fetch_from_options(options, :none, '')
+    assert_equal({}, options)
+  end
+
+  def test_uri_ref_and_root_default
+    fake_control = mocked_control
+    fake_control.expects(:root).returns('rootbeer')
+    options = {}
+    assert_equal({:request_referer => '', :rails_root => 'rootbeer', :request_uri => ''}, uri_ref_and_root(options))
+  end
+
+  def test_uri_ref_and_root_values
+    fake_control = mocked_control
+    fake_control.expects(:root).returns('rootbeer')
+    options = {:uri => 'whee', :referer => 'bang'}
+    assert_equal({:request_referer => 'bang', :rails_root => 'rootbeer', :request_uri => 'whee'}, uri_ref_and_root(options))
+  end
+
+  def test_custom_params_from_opts_base
+    assert_equal({}, custom_params_from_opts({}))
+  end
+
+  def test_custom_params_from_opts_custom_params
+    assert_equal({:foo => 'bar'}, custom_params_from_opts({:custom_params => {:foo => 'bar'}}))
+  end
+
+  def test_custom_params_from_opts_merged_params
+    assert_equal({:foo => 'baz'}, custom_params_from_opts({:custom_params => {:foo => 'bar'}, :foo => 'baz'}))
+  end
+
+  def test_request_params_from_opts_positive
+    fake_control = mock('control')
+    self.expects(:control).returns(fake_control)
+    fake_control.expects(:capture_params).returns(true)
+    val = {:request_params => 'foo'}
+    assert_equal('foo', request_params_from_opts(val))
+    assert_equal({}, val, "should delete request_params key from hash")
+  end
+
+  def test_request_params_from_opts_negative
+    fake_control = mock('control')
+    self.expects(:control).returns(fake_control)
+    fake_control.expects(:capture_params).returns(false)
+    val = {:request_params => 'foo'}
+    assert_equal(nil, request_params_from_opts(val))
+    assert_equal({}, val, "should delete request_params key from hash")
+  end
+
+  def test_normalized_request_and_custom_params_base
+    self.expects(:normalize_params).with(nil).returns(nil)
+    self.expects(:normalize_params).with({}).returns({})
+    fake_control = mock('control')
+    self.expects(:control).returns(fake_control)
+    fake_control.expects(:capture_params).returns(true)
+    assert_equal({:request_params => nil, :custom_params => {}}, normalized_request_and_custom_params({}))
+  end
+
+  def test_extract_source_base
+    @capture_source = true
+    self.expects(:sense_method).with(nil, 'source_extract')
+    assert_equal(nil, extract_source(nil))
+  end
+
+  def test_extract_source_disabled
+    @capture_source = false
+    assert_equal(nil, extract_source(mock('exception')))
+  end
+
+  def test_extract_source_with_source
+    self.expects(:sense_method).with('happy', 'source_extract').returns('THE SOURCE')
+    @capture_source = true
+    assert_equal('THE SOURCE', extract_source('happy'))
+  end
+
+  def test_extract_stack_trace
+    exception = mock('exception')
+    self.expects(:sense_method).with(exception, 'original_exception')
+    self.expects(:sense_method).with(exception, 'backtrace')
+    assert_equal('<no stack trace>', extract_stack_trace(exception))
+  end
+
+  def test_extract_stack_trace_positive
+    orig = mock('original')
+    exception = mock('exception')
+    self.expects(:sense_method).with(exception, 'original_exception').returns(orig)
+    self.expects(:sense_method).with(orig, 'backtrace').returns('STACK STACK STACK')
+    assert_equal('STACK STACK STACK', extract_stack_trace(exception))
+  end
+
+  def test_over_queue_limit_negative
+    @errors = []
+    assert !over_queue_limit?(nil)
+  end
+
+  def test_over_queue_limit_positive
+    @errors = %w(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21)
+    fake_log = mock('log')
+    self.expects(:log).returns(fake_log)
+    fake_log.expects(:warn).with('The error reporting queue has reached 20. The error detail for this and subsequent errors will not be transmitted to New Relic until the queued errors have been sent: hooray')
+    assert over_queue_limit?('hooray')
+  end
+
+  def test_exception_info
+    exception = mock('exception')
+    self.expects(:sense_method).with(exception, 'file_name').returns('file_name')
+    self.expects(:sense_method).with(exception, 'line_number').returns('line_number')
+    self.expects(:extract_source).with(exception).returns('source')
+    self.expects(:extract_stack_trace).with(exception).returns('stack_trace')
+    assert_equal({:file_name => 'file_name', :line_number => 'line_number', :source => 'source', :stack_trace => 'stack_trace'},
+                 exception_info(exception))
+  end
+
+  def test_add_to_error_queue_positive
+    noticed_error = mock('noticed_error')
+    noticed_error.expects(:message).returns('a message')
+    @lock = Mutex.new
+    @errors = []
+    self.expects(:over_queue_limit?).with('a message').returns(false)
+    add_to_error_queue(noticed_error)
+    assert_equal([noticed_error], @errors)
+  end
+
+  def test_add_to_error_queue_negative
+    noticed_error = mock('noticed_error')
+    noticed_error.expects(:message).returns('a message')
+    @lock = Mutex.new
+    @errors = []
+    self.expects(:over_queue_limit?).with('a message').returns(true)
+    add_to_error_queue(noticed_error)
+    assert_equal([], @errors)
+  end
+
+  def test_should_exit_notice_error_disabled
+    error = mocked_error
+    @enabled = false
+    assert should_exit_notice_error?(error)
+  end
+
+  def test_should_exit_notice_error_nil
+    error = nil
+    @enabled = true
+    self.expects(:error_is_ignored?).with(error).returns(false)
+    # we increment it for the case that someone calls
+    # NewRelic::Agent.notice_error(foo) # foo is nil
+    # (which is probably not a good idea but is the existing api)
+    self.expects(:increment_error_count!)
+    assert should_exit_notice_error?(error)
+  end
+
+  def test_should_exit_notice_error_positive
+    error = mocked_error
+    @enabled = true
+    self.expects(:error_is_ignored?).with(error).returns(true)
+    assert should_exit_notice_error?(error)
+  end
+
+  def test_should_exit_notice_error_negative
+    error = mocked_error
+    @enabled = true
+    self.expects(:error_is_ignored?).with(error).returns(false)
+    self.expects(:increment_error_count!)
+    assert !should_exit_notice_error?(error)
+  end
+
+  def test_filtered_error_positive
+    @ignore = {'an_error' => true}
+    error = mocked_error
+    error_class = mock('error class')
+    error.expects(:class).returns(error_class)
+    error_class.expects(:name).returns('an_error')
+    assert filtered_error?(error)
+  end
+
+  def test_filtered_error_negative
+    @ignore = {}
+    error = mocked_error
+    error_class = mock('error class')
+    error.expects(:class).returns(error_class)
+    error_class.expects(:name).returns('an_error')
+    self.expects(:filtered_by_error_filter?).with(error).returns(false)
+    assert !filtered_error?(error)
+  end
+
+  def test_filtered_by_error_filter_empty
+    # should return right away when there's no filter
+    @ignore_filter = nil
+    assert !filtered_by_error_filter?(nil)
+  end
+
+  def test_filtered_by_error_filter_positive
+    error = mocked_error
+    @ignore_filter = lambda { |x| assert_equal error, x; false  }
+    assert filtered_by_error_filter?(error)
+  end
+
+  def test_filtered_by_error_filter_negative
+    error = mocked_error
+    @ignore_filter = lambda { |x| assert_equal error, x; true  }
+    assert !filtered_by_error_filter?(error)
+  end
+
+  def test_error_is_ignored_positive
+    error = mocked_error
+    self.expects(:filtered_error?).with(error).returns(true)
+    assert error_is_ignored?(error)
+  end
+
+  def test_error_is_ignored_negative
+    error = mocked_error
+    self.expects(:filtered_error?).with(error).returns(false)
+    assert !error_is_ignored?(error)
+  end
+
+  def test_error_is_ignored_no_error
+    assert !error_is_ignored?(nil), 'should not ignore nil'
+  end
+
+  private
+
+  def mocked_error
+    mock('error')
+  end
+
+  def mocked_control
+    fake_control = mock('control')
+    self.stubs(:control).returns(fake_control)
+    fake_control
+  end
+end

data/test/new_relic/agent/error_collector_test.rb

@@ -0,0 +1,168 @@
+# Run faster standalone
+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'})
+    errors = @error_collector.harvest_errors([])
+
+    assert_equal 0, errors.length
+
+    @error_collector.notice_error('Some error message', :metric=> 'path', :request_params => {:x => 'y'})
+    errors = @error_collector.harvest_errors([])
+
+    err = errors.first
+    assert_equal 'Some error message', err.message
+    assert_equal 'y', err.params[:request_params][:x]
+    assert_equal '', err.params[:request_uri]
+    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'})
+
+    old_errors = []
+    errors = @error_collector.harvest_errors(old_errors)
+
+    assert_equal errors.length, 1
+
+    err = errors.first
+    assert_equal 'message', err.message
+    assert_equal 'y', err.params[:request_params][:x]
+    assert err.params[:request_uri] == '/myurl/'
+    assert err.params[:request_referer] == "test_referer"
+    assert err.path == 'path'
+    assert err.exception_class == 'Exception'
+
+    # the collector should now return an empty array since nothing
+    # has been added since its last harvest
+    errors = @error_collector.harvest_errors(nil)
+    assert errors.length == 0
+  end
+
+  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'})
+
+    old_errors = []
+    errors = @error_collector.harvest_errors(old_errors)
+
+    assert_equal errors.length, 1
+
+    err = errors.first
+    assert_equal 4096, err.message.length
+    assert_equal ('1234567890' * 500)[0..4095], err.message
+  end
+
+  def test_collect_failover
+    @error_collector.notice_error(Exception.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'})
+
+    errors = @error_collector.harvest_errors(errors)
+
+    assert_equal 4, errors.length
+    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'})
+
+    errors = @error_collector.harvest_errors(nil)
+    assert_equal 2, errors.length
+    assert_equal 'first', errors.first.path
+    assert_equal 'last', errors.last.path
+  end
+
+  def test_queue_overflow
+
+    max_q_length = 20     # for some reason I can't read the constant in ErrorCollector
+
+    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})
+      end
+    end
+
+    errors = @error_collector.harvest_errors([])
+    assert errors.length == max_q_length
+    errors.each_index do |i|
+      err = errors.shift
+      assert_equal i.to_s, err.params[:request_params][:x], err.params.inspect
+    end
+  end
+
+  # Why would anyone undef these methods?
+  class TestClass
+    undef to_s
+    undef inspect
+  end
+
+
+  def test_supported_param_types
+
+    types = [[1, '1'],
+    [1.1, '1.1'],
+    ['hi', 'hi'],
+    [:hi, :hi],
+    [Exception.new("test"), "#<Exception>"],
+    [TestClass.new, "#<NewRelic::Agent::ErrorCollectorTest::TestClass>"]
+    ]
+
+
+    types.each do |test|
+      @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => test[0]})
+
+      assert_equal test[1], @error_collector.harvest_errors([])[0].params[:request_params][:x]
+    end
+  end
+
+
+  def test_exclude
+    @error_collector.ignore(["IOError"])
+
+    @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
+
+    errors = @error_collector.harvest_errors([])
+
+    assert_equal 0, errors.length
+  end
+
+  def test_exclude_block
+    @error_collector.ignore_error_filter do |e|
+      if e.is_a? IOError
+        nil
+      else
+        e
+      end
+    end
+
+    @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
+
+    errors = @error_collector.harvest_errors([])
+
+    assert_equal 0, errors.length
+  end
+
+  private
+  def silence_stream(*args)
+    super
+  rescue NoMethodError
+    yield
+  end
+end

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

@@ -0,0 +1,522 @@
+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
+    ActiveRecordFixtures.setup
+    NewRelic::Agent.instance.transaction_sampler.reset!
+    NewRelic::Agent.instance.stats_engine.clear_stats
+  rescue Exception => e
+    puts e
+    puts e.backtrace.join("\n")
+  end
+
+  def teardown
+    super
+    NewRelic::Agent.shutdown
+  end
+
+  #####################################################################
+  # Note: If these tests are failing, most likely the problem is that #
+  # the active record instrumentation is not loading for whichever    #
+  # version of rails you're testing at the moment.                    #
+  #####################################################################
+
+  def test_agent_setup
+    assert NewRelic::Agent.instance.class == NewRelic::Agent::Agent
+  end
+
+  def test_finder
+    ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
+
+    find_metric = "ActiveRecord/ActiveRecordFixtures::Order/find"
+
+    assert_calls_metrics(find_metric) do
+      ActiveRecordFixtures::Order.find(:all)
+      check_metric_count(find_metric, 1)
+      ActiveRecordFixtures::Order.find_all_by_name "jeff"
+      check_metric_count(find_metric, 2)
+    end
+
+    return if NewRelic::Control.instance.rails_version < "2.3.4"
+
+    assert_calls_metrics(find_metric) do
+      ActiveRecordFixtures::Order.exists?(["name=?", 'jeff'])
+    end
+    check_metric_count(find_metric, 3)
+  end
+
+  # multiple duplicate find calls should only cause metric trigger on the first
+  # call.  the others are ignored.
+  def test_query_cache
+    # Not sure why we get a transaction error with sqlite
+    return if isSqlite?
+
+    find_metric = "ActiveRecord/ActiveRecordFixtures::Order/find"
+    ActiveRecordFixtures::Order.cache do
+      m = ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
+      assert_calls_metrics(find_metric) do
+        ActiveRecordFixtures::Order.find(:all)
+      end
+
+      check_metric_count(find_metric, 1)
+
+      assert_calls_metrics(find_metric) do
+        10.times { ActiveRecordFixtures::Order.find m.id }
+      end
+      check_metric_count(find_metric, 2)
+    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]
+
+    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 rails3? || defined?(JRuby) || isSqlite?
+
+    expected = %W[
+      ActiveRecord/all
+      ActiveRecord/find
+      ActiveRecord/ActiveRecordFixtures::Order/find
+      ActiveRecord/create
+      Database/SQL/other
+      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_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
+    ActiveRecord/find
+    ActiveRecord/ActiveRecordFixtures::Order/find
+    ActiveRecord/ActiveRecordFixtures::Shipment/find
+    ]
+
+    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.respond_to?(:version) && Rails.version.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.respond_to?(:version) && Rails.version.to_i == 3)
+    return if defined?(JRuby) || 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
+    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::Instrumentation::MetricFrame.current
+    assert_nil NewRelic::Agent.instance.stats_engine.scope_name
+    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
+    ]
+
+    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
+    ]
+    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?
+
+    expected_metrics = %W[ActiveRecord/all Database/SQL/show]
+
+    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
+        ActiveRecordFixtures::Order.find(:all)
+      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
+      ActiveRecordFixtures::Order.find(:all)
+    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
+    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
+      ActiveRecordFixtures::Order.find(:all)
+    end
+    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
+    assert_not_nil sample
+
+    includes_gc = false
+    sample.each_segment {|s| includes_gc ||= s.metric_name =~ /GC/ }
+
+    assert_equal (includes_gc ? 4 : 3), sample.count_segments, sample.to_s
+
+    sql_segment = sample.root_segment.called_segments.first.called_segments.first.called_segments.first
+    assert_not_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(: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]
+    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
+    end
+  end
+
+  def test_transaction_mysql
+    return unless isMysql? && !defined?(JRuby)
+    ActiveRecordFixtures.setup
+    sample = NewRelic::Agent.instance.transaction_sampler.reset!
+    perform_action_with_newrelic_trace :name => 'bogosity' do
+      ActiveRecordFixtures::Order.add_delay
+      ActiveRecordFixtures::Order.find(:all)
+    end
+
+    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
+
+    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"
+
+    row = explanations.first.first
+    assert_equal 10, row.size
+    assert_equal ['1', 'SIMPLE', ActiveRecordFixtures::Order.table_name], row[0..2]
+
+    s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
+    assert_equal 1, s.call_count
+  end
+
+  def test_transaction_postgres
+    return unless isPostgres?
+    # 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
+      ActiveRecordFixtures::Order.find(:all)
+    end
+
+    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
+
+    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
+
+    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(";")
+
+    s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
+    assert_equal 1, s.call_count
+  end
+
+  def test_transaction_other
+    return if isMysql? || isPostgres?
+    sample = NewRelic::Agent.instance.transaction_sampler.reset!
+    perform_action_with_newrelic_trace :name => 'bogosity' do
+      ActiveRecordFixtures::Order.add_delay
+      ActiveRecordFixtures::Order.find(:all)
+    end
+
+    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
+
+    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
+
+    s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
+    assert_equal 1, s.call_count
+  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
+      named_scope :jeffs, :conditions => { :name => 'Jeff' }
+    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
+        x = ActiveRecordFixtures::Order.jeffs.find(:all)
+      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
+
+    expected_metrics = %W[ActiveRecord/all Database/SQL/select]
+
+    assert_calls_metrics(*expected_metrics) 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
+    metrics = NewRelic::Agent.instance.stats_engine.metrics
+    compare_metrics expected_metrics, metrics
+    check_metric_count('Database/SQL/select', 1)
+    check_metric_count('ActiveRecord/all', 1)
+  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
+
+  private
+
+  def rails3?
+    (defined?(Rails) && Rails.respond_to?(:version) && Rails.version.to_i == 3)
+  end
+
+  def isPostgres?
+    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
+  end
+
+end