newrelic_rpm 3.7.2.195 → 3.7.3.199

data/test/new_relic/agent/configuration/server_source_test.rb

@@ -6,7 +6,7 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_h
 require 'new_relic/agent/configuration/server_source'
 
 module NewRelic::Agent::Configuration
-  class ServerSourceTest < MiniTest::Unit::TestCase
+  class ServerSourceTest < Minitest::Test
     def setup
       config = {
         'agent_config' => {

data/test/new_relic/agent/configuration/yaml_source_test.rb

@@ -6,7 +6,7 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_h
 require 'new_relic/agent/configuration/yaml_source'
 
 module NewRelic::Agent::Configuration
-  class YamlSourceTest < MiniTest::Unit::TestCase
+  class YamlSourceTest < Minitest::Test
     def setup
       @test_yml_path = File.expand_path(File.join(File.dirname(__FILE__),
                                                  '..','..','..',

data/test/new_relic/agent/cpu_sampler_test.rb

@@ -6,7 +6,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 require 'new_relic/agent/samplers/cpu_sampler'
 
-class NewRelic::Agent::Samplers::CpuSamplerTest < MiniTest::Unit::TestCase
+class NewRelic::Agent::Samplers::CpuSamplerTest < Minitest::Test
 
   def setup
     @original_jruby_version = JRUBY_VERSION if defined?(JRuby)

data/test/new_relic/agent/cross_app_monitor_test.rb

@@ -5,7 +5,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 
 module NewRelic::Agent
-  class CrossAppMonitorTest < MiniTest::Unit::TestCase
+  class CrossAppMonitorTest < Minitest::Test
     NEWRELIC_ID_HEADER        = NewRelic::Agent::CrossAppMonitor::NEWRELIC_ID_HEADER
     NEWRELIC_TXN_HEADER       = NewRelic::Agent::CrossAppMonitor::NEWRELIC_TXN_HEADER
 
@@ -195,9 +195,9 @@ module NewRelic::Agent
       event_listener = NewRelic::Agent.instance.events
       event_listener.notify(:before_call, request)
       in_transaction('transaction') do
-        # nothing
+        # Fake out our GUID for easier comparison in tests
+        NewRelic::Agent::Transaction.current.stubs(:guid).returns(TRANSACTION_GUID)
       end
-      NewRelic::Agent::TransactionState.get.request_guid = TRANSACTION_GUID
       event_listener.notify(:after_call, request, [200, @response, ''])
     end
 

data/test/new_relic/agent/cross_app_tracing_test.rb

@@ -7,7 +7,7 @@ require 'new_relic/agent/cross_app_tracing'
 
 module NewRelic
   module Agent
-    class CrossAppTracingTest < MiniTest::Unit::TestCase
+    class CrossAppTracingTest < Minitest::Test
 
       attr_reader :segment, :request, :response
 

data/test/new_relic/agent/database/postgres_explain_obfuscator_test.rb

@@ -0,0 +1,34 @@
+# 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.
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+require 'new_relic/agent/database/postgres_explain_obfuscator'
+
+module NewRelic::Agent::Database
+  class PostgresExplainObfuscatorTest < Minitest::Test
+    attr_reader :obfuscator
+
+    def self.input_files
+      fixture_dir = File.join(cross_agent_tests_dir, "postgres_explain_obfuscation")
+      Dir["#{fixture_dir}/*.explain.txt"]
+    end
+
+    def self.name_for_input_file(input_file)
+      File.basename(input_file, ".explain.txt")
+    end
+
+    input_files.each do |input_file|
+      define_method("test_#{name_for_input_file(input_file)}_explain_plan_obfuscation") do
+        explain             = File.read(input_file)
+        expected_obfuscated = File.read(obfuscated_filename(input_file))
+        actual_obfuscated   = PostgresExplainObfuscator.obfuscate(explain)
+        assert_equal(expected_obfuscated, actual_obfuscated)
+      end
+    end
+
+    def obfuscated_filename(query_file)
+      query_file.gsub(".explain.", ".colon_obfuscated.")
+    end
+  end
+end

data/test/new_relic/agent/database_test.rb

@@ -5,7 +5,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..',
                                    'test_helper'))
 require 'new_relic/agent/database'
-class NewRelic::Agent::DatabaseTest < MiniTest::Unit::TestCase
+class NewRelic::Agent::DatabaseTest < Minitest::Test
   def setup
     @explainer = NewRelic::Agent::Instrumentation::ActiveRecord::EXPLAINER
   end
@@ -14,10 +14,29 @@ class NewRelic::Agent::DatabaseTest < MiniTest::Unit::TestCase
     NewRelic::Agent::Database::Obfuscator.instance.reset
   end
 
-  def test_process_resultset
-    resultset = [["column"]]
-    assert_equal([nil, [["column"]]],
-                 NewRelic::Agent::Database.process_resultset(resultset))
+  def test_adapter_from_config_string
+    config = { :adapter => 'mysql' }
+    assert_equal('mysql', NewRelic::Agent::Database.adapter_from_config(config))
+  end
+
+  def test_adapter_from_config_symbol
+    config = { :adapter => :mysql }
+    assert_equal('mysql', NewRelic::Agent::Database.adapter_from_config(config))
+  end
+
+  def test_adapter_from_config_uri_jdbc_postgresql
+    config = { :uri=>"jdbc:postgresql://host/database?user=posgres" }
+    assert_equal('postgresql', NewRelic::Agent::Database.adapter_from_config(config))
+  end
+
+  def test_adapter_from_config_uri_jdbc_mysql
+    config = { :uri=>"jdbc:mysql://host/database" }
+    assert_equal('mysql', NewRelic::Agent::Database.adapter_from_config(config))
+  end
+
+  def test_adapter_from_config_uri_jdbc_sqlite
+    config = { :uri => "jdbc:sqlite::memory" }
+    assert_equal('sqlite', NewRelic::Agent::Database.adapter_from_config(config))
   end
 
   def test_explain_sql_select_with_mysql_connection
@@ -40,6 +59,73 @@ class NewRelic::Agent::DatabaseTest < MiniTest::Unit::TestCase
     assert_equal(plan.values.compact.sort, result[1][0].compact.sort)
   end
 
+  def test_explain_sql_select_with_mysql2_connection_sequel
+    config = { :adapter => 'mysql2' }
+    config.default('val')
+    sql = 'SELECT * FROM items'
+
+    # Sequel returns explain plans to us as one giant preformatted string rather
+    # than individual rows.
+    plan_string = [
+      "+--+-----------+-----+----+-------------+---+-------+---+----+-----+",
+      "|id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|",
+      "+--+-----------+-----+----+-------------+---+-------+---+----+-----+",
+      "| 1|SIMPLE     |items|ALL |             |   |       |   |   3|     |",
+      "+--+-----------+-----+----+-------------+---+-------+---+----+-----+"
+    ].join("\n")
+
+    connection = mock('mysql connection')
+    connection.expects(:execute).with('EXPLAIN SELECT * FROM items').returns(plan_string)
+    NewRelic::Agent::Database.stubs(:get_connection).returns(connection)
+    result = NewRelic::Agent::Database.explain_sql(sql, config, &@explainer)
+    assert_nil(result[0])
+    assert_equal([plan_string], result[1])
+  end
+
+  def test_explain_sql_select_with_mysql_connection_sequel
+    config = { :adapter => 'mysql' }
+    config.default('val')
+    sql = 'SELECT * FROM items'
+
+    # Sequel returns explain plans to us as one giant preformatted string rather
+    # than individual rows.
+    plan_string = [
+      "+--+-----------+-----+----+-------------+---+-------+---+----+-----+",
+      "|id|select_type|table|type|possible_keys|key|key_len|ref|rows|Extra|",
+      "+--+-----------+-----+----+-------------+---+-------+---+----+-----+",
+      "| 1|SIMPLE     |items|ALL |             |   |       |   |   3|     |",
+      "+--+-----------+-----+----+-------------+---+-------+---+----+-----+"
+    ].join("\n")
+
+    connection = mock('mysql connection')
+    connection.expects(:execute).with('EXPLAIN SELECT * FROM items').returns(plan_string)
+    NewRelic::Agent::Database.stubs(:get_connection).returns(connection)
+    result = NewRelic::Agent::Database.explain_sql(sql, config, &@explainer)
+    assert_nil(result[0])
+    assert_equal([plan_string], result[1])
+  end
+
+  def test_explain_sql_select_with_mysql2_connection
+    config = {:adapter => 'mysql2'}
+    config.default('val')
+    sql = 'SELECT foo'
+    connection = mock('mysql connection')
+
+    plan_fields = ["select_type", "key_len", "table", "id", "possible_keys", "type", "Extra", "rows", "ref", "key"]
+    plan_row =    ["SIMPLE",       nil,      "blogs", "1",   nil,            "ALL",  "",      "2",     nil,   nil ]
+
+    result = mock('explain plan')
+    result.expects(:fields).returns(plan_fields)
+    result.expects(:each).yields(plan_row)
+
+    # two rows, two columns
+    connection.expects(:execute).with('EXPLAIN SELECT foo').returns(result)
+    NewRelic::Agent::Database.stubs(:get_connection).returns(connection)
+    result = NewRelic::Agent::Database.explain_sql(sql, config, &@explainer)
+    assert_equal(plan_fields.sort, result[0].sort)
+    assert_equal(plan_row.compact.sort, result[1][0].compact.sort)
+  end
+
   def test_explain_sql_one_select_with_pg_connection
     config = {:adapter => 'postgresql'}
     config.default('val')
@@ -57,6 +143,88 @@ class NewRelic::Agent::DatabaseTest < MiniTest::Unit::TestCase
                  NewRelic::Agent::Database.explain_sql(sql, config, &@explainer))
   end
 
+  def test_explain_sql_one_select_with_pg_connection_string
+    config = {:adapter => 'postgresql'}
+    config.default('val')
+    sql = 'select count(id) from blogs limit 1'
+    connection = stub('pg connection', :disconnect! => true)
+    plan = "Limit  (cost=11.75..11.76 rows=1 width=4)
+  ->  Aggregate  (cost=11.75..11.76 rows=1 width=4)
+        ->  Seq Scan on blogs  (cost=0.00..11.40 rows=140 width=4)"
+
+    connection.expects(:execute).returns(plan)
+    NewRelic::Agent::Database.stubs(:get_connection).returns(connection)
+    assert_equal([['QUERY PLAN'],
+                  [["Limit  (cost=11.75..11.76 rows=1 width=4)"],
+                   ["  ->  Aggregate  (cost=11.75..11.76 rows=1 width=4)"],
+                   ["        ->  Seq Scan on blogs  (cost=0.00..11.40 rows=140 width=4)"]]],
+                 NewRelic::Agent::Database.explain_sql(sql, config, &@explainer))
+  end
+
+  def test_explain_sql_obfuscates_for_postgres
+    config = {:adapter => 'postgresql'}
+    config.default('val')
+    sql = "SELECT * FROM blogs WHERE blogs.id=1234 AND blogs.title='sensitive text'"
+    connection = stub('pg connection', :disconnect! => true)
+    plan = [{"QUERY PLAN"=>" Index Scan using blogs_pkey on blogs  (cost=0.00..8.27 rows=1 width=540)"},
+            {"QUERY PLAN"=>"   Index Cond: (id = 1234)"},
+            {"QUERY PLAN"=>"   Filter: ((title)::text = 'sensitive text'::text)"}]
+    connection.expects(:execute).returns(plan)
+    NewRelic::Agent::Database.stubs(:get_connection).returns(connection)
+    with_config(:'transaction_tracer.record_sql' => 'obfuscated') do
+      assert_equal([['QUERY PLAN'],
+                    [[" Index Scan using blogs_pkey on blogs  (cost=0.00..8.27 rows=1 width=540)"],
+                     ["   Index Cond: ?"],
+                     ["   Filter: ?"]]],
+                   NewRelic::Agent::Database.explain_sql(sql, config, &@explainer))
+    end
+  end
+
+  def test_explain_sql_does_not_obfuscate_if_record_sql_raw
+    config = {:adapter => 'postgresql'}
+    config.default('val')
+    sql = "SELECT * FROM blogs WHERE blogs.id=1234 AND blogs.title='sensitive text'"
+    connection = stub('pg connection', :disconnect! => true)
+    plan = [{"QUERY PLAN"=>" Index Scan using blogs_pkey on blogs  (cost=0.00..8.27 rows=1 width=540)"},
+            {"QUERY PLAN"=>"   Index Cond: (id = 1234)"},
+            {"QUERY PLAN"=>"   Filter: ((title)::text = 'sensitive text'::text)"}]
+    connection.expects(:execute).returns(plan)
+    NewRelic::Agent::Database.stubs(:get_connection).returns(connection)
+    with_config(:'transaction_tracer.record_sql' => 'raw') do
+      assert_equal([['QUERY PLAN'],
+                    [[" Index Scan using blogs_pkey on blogs  (cost=0.00..8.27 rows=1 width=540)"],
+                     ["   Index Cond: (id = 1234)"],
+                     ["   Filter: ((title)::text = 'sensitive text'::text)"]]],
+                   NewRelic::Agent::Database.explain_sql(sql, config, &@explainer))
+    end
+  end
+
+  def test_explain_sql_select_with_sqlite_connection
+    config = {:adapter => 'sqlite'}
+    config.default('val')
+    sql = 'SELECT foo'
+    connection = mock('sqlite connection')
+    plan = [
+      {"addr"=>0, "opcode"=>"Trace", "p1"=>0, "p2"=>0, "p3"=>0, "p4"=>"", "p5"=>"00", "comment"=>nil, 0=>0, 1=>"Trace", 2=>0, 3=>0, 4=>0, 5=>"", 6=>"00", 7=>nil},
+      {"addr"=>1, "opcode"=>"Goto",  "p1"=>0, "p2"=>5, "p3"=>0, "p4"=>"", "p5"=>"00", "comment"=>nil, 0=>1, 1=>"Goto",  2=>0, 3=>5, 4=>0, 5=>"", 6=>"00", 7=>nil},
+      {"addr"=>2, "opcode"=>"String8", "p1"=>0, "p2"=>1, "p3"=>0, "p4"=>"foo", "p5"=>"00", "comment"=>nil, 0=>2, 1=>"String8", 2=>0, 3=>1, 4=>0, 5=>"foo", 6=>"00", 7=>nil},
+      {"addr"=>3, "opcode"=>"ResultRow", "p1"=>1, "p2"=>1, "p3"=>0, "p4"=>"", "p5"=>"00", "comment"=>nil, 0=>3, 1=>"ResultRow", 2=>1, 3=>1, 4=>0, 5=>"", 6=>"00", 7=>nil},
+      {"addr"=>4, "opcode"=>"Halt", "p1"=>0, "p2"=>0, "p3"=>0, "p4"=>"", "p5"=>"00", "comment"=>nil, 0=>4, 1=>"Halt", 2=>0, 3=>0, 4=>0, 5=>"", 6=>"00", 7=>nil},
+      {"addr"=>5, "opcode"=>"Goto", "p1"=>0, "p2"=>2, "p3"=>0, "p4"=>"", "p5"=>"00", "comment"=>nil, 0=>5, 1=>"Goto", 2=>0, 3=>2, 4=>0, 5=>"", 6=>"00", 7=>nil}
+    ]
+    connection.expects(:execute).with('EXPLAIN SELECT foo').returns(plan)
+    NewRelic::Agent::Database.stubs(:get_connection).returns(connection)
+    result = NewRelic::Agent::Database.explain_sql(sql, config, &@explainer)
+
+    expected_headers = %w[addr opcode p1 p2 p3 p4 p5 comment]
+    expected_values  = plan.map do |row|
+      expected_headers.map { |h| row[h] }
+    end
+
+    assert_equal(expected_headers.sort, result[0].sort)
+    assert_equal(expected_values, result[1])
+  end
+
   def test_dont_collect_explain_for_parameterized_query
     config = {:adapter => 'postgresql'}
     config.default('val')
@@ -92,7 +260,18 @@ class NewRelic::Agent::DatabaseTest < MiniTest::Unit::TestCase
 
     sql = 'SELECT * FROM table WHERE id IN (1,2,3,4,5...'
     assert_equal [], NewRelic::Agent::Database.explain_sql(sql, config)
+  end
+
+  def test_dont_collect_explain_if_adapter_not_recognized
+    config = {:adapter => 'dorkdb'}
+    config.default('val')
+    connection = mock('connection')
+    connection.expects(:execute).never
+    NewRelic::Agent::Database.stubs(:get_connection).with(config).returns(connection)
+    expects_logging(:debug, "Not collecting explain plan because an unknown connection adapter ('dorkdb') was used.")
 
+    sql = 'SELECT * FROM table WHERE id IN (1,2,3,4,5)'
+    assert_equal [], NewRelic::Agent::Database.explain_sql(sql, config)
   end
 
   def test_explain_sql_no_sql
@@ -238,6 +417,14 @@ class NewRelic::Agent::DatabaseTest < MiniTest::Unit::TestCase
     assert_equal(expected_query, captured)
   end
 
+  sql_parsing_tests = load_cross_agent_test('sql_parsing')
+  sql_parsing_tests.each_with_index do |test_case, i|
+    define_method("test_sql_parsing_#{i}") do
+      result = NewRelic::Agent::Database.parse_operation_from_query(test_case['input'])
+      assert_equal(test_case['operation'], result)
+    end
+  end
+
   # Ruby 1.8 doesn't have String#encoding
   def encoding_from_string(str)
     if str.respond_to?(:encoding)

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

@@ -5,7 +5,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
 require 'new_relic/agent/datastores/mongo/metric_generator'
 
-class NewRelic::Agent::Datastores::Mongo::MetricGeneratorTest < MiniTest::Unit::TestCase
+class NewRelic::Agent::Datastores::Mongo::MetricGeneratorTest < Minitest::Test
   include ::NewRelic::TestHelpers::MongoMetricBuilder
 
   def setup

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

@@ -5,7 +5,7 @@
 require 'new_relic/agent/datastores/mongo/metric_translator'
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
 
-class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < MiniTest::Unit::TestCase
+class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < Minitest::Test
   include ::NewRelic::TestHelpers::MongoMetricBuilder
 
   def setup
@@ -30,6 +30,16 @@ class NewRelic::Agent::Datastores::Mongo::MetricTranslatorTest < MiniTest::Unit:
     assert_includes metrics, 'Datastore/allOther'
   end
 
+  def test_build_metrics_includes_all_for_web
+    metrics = build_test_metrics('test')
+    assert_includes metrics, 'Datastore/all'
+  end
+
+  def test_build_metrics_includes_all_for_other
+    metrics = build_test_metrics('test', :other)
+    assert_includes metrics, 'Datastore/all'
+  end
+
   def test_build_metrics_includes_activerecord_all_on_web
     metrics = build_test_metrics('test', :web)
     assert_includes metrics, 'ActiveRecord/all'

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

@@ -9,7 +9,7 @@ module NewRelic
   module Agent
     module Datastores
       module Mongo
-        class ObfuscatorTest < MiniTest::Unit::TestCase
+        class ObfuscatorTest < Minitest::Test
           def test_obfuscator_removes_values_from_statement
             selector = {
               'name'     => 'soterios johnson',

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

@@ -9,7 +9,7 @@ module NewRelic
   module Agent
     module Datastores
       module Mongo
-        class StatementFormatterTest < MiniTest::Unit::TestCase
+        class StatementFormatterTest < Minitest::Test
           DOC_STATEMENT = { :database   => "multiverse",
                             :collection => "tribbles",
                             :operation  => :insert,

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

@@ -3,7 +3,7 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
-class NewRelic::Agent::ErrorCollector::NoticeErrorTest < MiniTest::Unit::TestCase
+class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Minitest::Test
   require 'new_relic/agent/error_collector'
   include NewRelic::Agent::ErrorCollector::NoticeError
 

data/test/new_relic/agent/error_collector_test.rb

@@ -6,7 +6,7 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper
 require File.expand_path(File.join(File.dirname(__FILE__),'..','data_container_tests'))
 require 'new_relic/agent/internal_agent_error'
 
-class NewRelic::Agent::ErrorCollectorTest < MiniTest::Unit::TestCase
+class NewRelic::Agent::ErrorCollectorTest < Minitest::Test
   def setup
     @test_config = { :capture_params => true }
     NewRelic::Agent.config.apply_config(@test_config)

data/test/new_relic/agent/event_listener_test.rb

@@ -4,7 +4,7 @@
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 
-class EventListenerTest < MiniTest::Unit::TestCase
+class EventListenerTest < Minitest::Test
 
   def setup
     @events = NewRelic::Agent::EventListener.new

data/test/new_relic/agent/harvester_test.rb

@@ -7,7 +7,7 @@ require 'new_relic/agent/harvester'
 
 module NewRelic
   module Agent
-    class HarvesterTest < MiniTest::Unit::TestCase
+    class HarvesterTest < Minitest::Test
 
       attr_reader :harvester
       def setup

data/test/new_relic/agent/http_clients/uri_util_test.rb

@@ -5,7 +5,7 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
 require 'new_relic/agent/http_clients/uri_util'
 
-class URIUtilTest < MiniTest::Unit::TestCase
+class URIUtilTest < Minitest::Test
 
   def test_filter_uri
     assert_filtered("http://foo.com/bar/baz",

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

@@ -7,7 +7,7 @@ if defined?(::Rails)
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
 require 'new_relic/agent/instrumentation/action_controller_subscriber'
 
-class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < MiniTest::Unit::TestCase
+class NewRelic::Agent::Instrumentation::ActionControllerSubscriberTest < Minitest::Test
   class TestController
     include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 

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

@@ -7,7 +7,7 @@ if defined?(::Rails)
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
 require 'new_relic/agent/instrumentation/action_view_subscriber'
 
-class NewRelic::Agent::Instrumentation::ActionViewSubscriberTest < MiniTest::Unit::TestCase
+class NewRelic::Agent::Instrumentation::ActionViewSubscriberTest < Minitest::Test
   def setup
     @subscriber = NewRelic::Agent::Instrumentation::ActionViewSubscriber.new
     @stats_engine = NewRelic::Agent.instance.stats_engine