newrelic_rpm 3.7.2.195 → 3.7.3.199

data/lib/new_relic/control/profiling.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-module NewRelic
-  class Control
-    module Profiling
-
-      # A flag used in dev mode to indicate if profiling is available
-      def profiling?
-        @profiling
-      end
-
-      def profiling_available?
-        @profiling_available ||=
-          begin
-            require 'ruby-prof'
-            true
-          rescue LoadError; end
-      end
-      # Set the flag for capturing profiles in dev mode.  If RubyProf is not
-      # loaded a true value is ignored.
-      def profiling=(val)
-        @profiling = profiling_available? && val && defined?(RubyProf)
-      end
-    end
-    include Profiling
-  end
-end

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

@@ -1,648 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-if defined?(::Rails)
-
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
-
-class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < MiniTest::Unit::TestCase
-  require 'active_record_fixtures'
-  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-  # the db adapter library the tests are running under (e.g. sqlite3)
-  def adapter
-    if ActiveRecord::Base.respond_to?(:connection_config)
-      ActiveRecord::Base.connection_config[:adapter]
-    else
-      # old versions of rails are usually tested against mysql
-      'mysql'
-    end
-  end
-
-  def setup
-    super
-    NewRelic::Agent.manual_start
-    ActiveRecord::Base.establish_connection unless ActiveRecord::Base.connection.active?
-    ActiveRecordFixtures.setup
-    NewRelic::Agent.instance.transaction_sampler.reset!
-    NewRelic::Agent.instance.stats_engine.clear_stats
-  rescue => e
-    puts e
-    puts e.backtrace.join("\n")
-  end
-
-  def teardown
-    super
-    NewRelic::Agent::TransactionState.reset
-    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
-      all_finder(ActiveRecordFixtures::Order)
-      check_metric_count(find_metric, 1)
-      if NewRelic::Control.instance.rails_version >= "4"
-        ActiveRecordFixtures::Order.where(:name =>  "jeff").load
-      else
-        ActiveRecordFixtures::Order.find_all_by_name "jeff"
-      end
-      check_metric_count(find_metric, 2)
-    end
-  end
-
-  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
-  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
-
-  def rails3?
-    (defined?(Rails) && Rails::VERSION::MAJOR.to_i >= 3)
-  end
-
-  def rails_env
-    rails3? ? ::Rails.env : RAILS_ENV
-  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
-
-  def all_finder(relation)
-    if defined?(::ActiveRecord::VERSION)
-      if ::ActiveRecord::VERSION::MAJOR.to_i >= 4
-        relation.all.load
-      elsif ::ActiveRecord::VERSION::MAJOR.to_i >= 3
-        relation.all
-      else
-        relation.find(:all)
-      end
-    else
-      relation.find(:all)
-    end
-  end
-
-  def last_segment(txn_sample)
-    last = nil
-    txn_sample.root_segment.each_segment do |segment|
-      last = segment
-    end
-    last
-  end
-end
-
-
-class ActiveRecordQueryEncodingTest < MiniTest::Unit::TestCase
-
-  class DatabaseAdapter
-    # we patch in here
-    def log(*args)
-    end
-    include ::NewRelic::Agent::Instrumentation::ActiveRecord
-  end
-
-  def test_should_not_bomb_out_if_a_query_is_in_an_invalid_encoding
-    # Contains invalid UTF8 Byte
-    query = "select ICS95095010000000000083320000BS01030000004100+\xFF00000000000000000"
-    if RUBY_VERSION >= '1.9'
-      # Force the query to an invalid encoding
-      query.force_encoding 'UTF-8'
-      assert_equal false, query.valid_encoding?
-    end
-    db = DatabaseAdapter.new
-    db.send(:log, query)
-  end
-end
-
-else
-  puts "Skipping tests in #{__FILE__} because Rails is unavailable"
-end