newrelic_rpm 3.15.1.316 → 3.15.2.317

data/lib/new_relic/version.rb

@@ -12,7 +12,7 @@ module NewRelic
 
     MAJOR = 3
     MINOR = 15
-    TINY  = 1
+    TINY  = 2
 
     begin
       require File.join(File.dirname(__FILE__), 'build')

data/newrelic_rpm.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.version = NewRelic::VERSION::STRING
   s.required_ruby_version = '>= 1.8.7'
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
-  s.authors = [ "Tim Krajcar", "Matthew Wear", "Katherine Wu", "Karl Sandwich" ]
+  s.authors = [ "Tim Krajcar", "Matthew Wear", "Katherine Wu", "Karl Sandwich", "Caito Scherr" ]
   s.date = Time.now.strftime('%Y-%m-%d')
   s.licenses    = ['New Relic', 'MIT', 'Ruby']
   s.description = <<-EOS

data/test/environments/lib/environments/runner.rb

@@ -97,7 +97,7 @@ module Environments
       bundling = `cd #{dir} && bundle install --local`
       unless $?.success?
         puts "Failed local bundle, trying again with full bundle..."
-        bundling = `cd #{dir} && bundle install`
+        bundling = `cd #{dir} && bundle install --retry 3`
       end
 
       bundling = red(bundling) unless $?.success?

data/test/environments/rails40/Gemfile

@@ -4,6 +4,15 @@ gem 'rake', '< 11'
 
 gem 'rails', '~>4.0.13'
 
+# mime-types 2.99.1 and 3.x introduce mime-types-data
+# mime-types-data requires Ruby version >= 2.0
+# mime-types 2.99 requires Ruby version >= 1.9.3
+if RUBY_VERSION < '1.9.3'
+  gem 'mime-types', '1.25.1'
+elsif RUBY_VERSION < '2'
+  gem 'mime-types', '< 3'
+end
+
 # Do not automatically require minitest, since this will break with rbx-2.2.5.
 # rbx-2.2.5 helpfully bundles minitest-5.3.0.
 # Our tests don't work with minitest-5.3.0.

data/test/environments/rails41/Gemfile

@@ -4,6 +4,15 @@ gem 'rake', '< 11'
 
 gem 'rails', '~>4.1.10'
 
+# mime-types 2.99.1 and 3.x introduce mime-types-data
+# mime-types-data requires Ruby version >= 2.0
+# mime-types 2.99 requires Ruby version >= 1.9.3
+if RUBY_VERSION < '1.9.3'
+  gem 'mime-types', '1.25.1'
+elsif RUBY_VERSION < '2'
+  gem 'mime-types', '< 3'
+end
+
 gem 'minitest', '5.2.3'
 gem 'mocha', :require => false
 gem 'rack'

data/test/environments/rails42/Gemfile

@@ -4,6 +4,15 @@ gem 'rake', '< 11'
 
 gem 'rails', '~>4.2.1'
 
+# mime-types 2.99.1 and 3.x introduce mime-types-data
+# mime-types-data requires Ruby version >= 2.0
+# mime-types 2.99 requires Ruby version >= 1.9.3
+if RUBY_VERSION < '1.9.3'
+  gem 'mime-types', '1.25.1'
+elsif RUBY_VERSION < '2'
+  gem 'mime-types', '< 3'
+end
+
 gem 'minitest', '5.2.3'
 gem 'mocha', :require => false
 gem 'rack'

data/test/multiverse/lib/multiverse/suite.rb

@@ -173,6 +173,7 @@ module Multiverse
         f.print gemfile_text
         f.puts newrelic_gemfile_line unless gemfile_text =~ /^\s*gem .newrelic_rpm./
         f.puts jruby_openssl_line unless gemfile_text =~ /^\s*gem .jruby-openssl./ || (defined?(JRUBY_VERSION) && JRUBY_VERSION > '1.7')
+        f.puts mime_types_line unless gemfile_text =~ /^\s*gem .mime-types[^_-]./
         f.puts minitest_line unless gemfile_text =~ /^\s*gem .minitest[^_]./
         f.puts rake_line unless gemfile_text =~ /^\s*gem .rake[^_]./ || suite == 'rake'
         if RUBY_VERSION == "1.8.7"
@@ -219,6 +220,17 @@ module Multiverse
       "gem 'jruby-openssl', '~> 0.9.10', :require => false, :platforms => [:jruby]"
     end
 
+    # mime-types got a new dependency after 2.99 that breaks compatibility with ruby < 2.0
+    def mime_types_line
+      if RUBY_VERSION <= '1.9.3'
+        "gem 'mime-types', '1.25.1'"
+      elsif RUBY_VERSION < '2'
+        "gem 'mime-types', '2.99'"
+      else
+        ''
+      end
+    end
+
     def minitest_line
       "gem 'minitest', '~> 4.7.5', :require => false"
     end

data/test/multiverse/suites/agent_only/harvest_timestamps_test.rb

@@ -63,37 +63,6 @@ class HarvestTimestampsTest < Minitest::Test
     end
   end
 
-  def test_timestamps_updated_even_if_filling_metric_id_cache_fails
-    t0 = freeze_time.to_f
-
-    simulate_fork
-    NewRelic::Agent.after_fork
-
-    # Induce a failure in filling the metric ID cache by handing back a bogus
-    # response to the first metric_data post.
-    $collector.stub('metric_data', [[[[]]]], 200)
-    t1 = advance_time(10).to_f
-    trigger_metric_data_post
-    first_post = last_metric_data_post
-
-    $collector.reset
-    t2 = advance_time(10).to_f
-    trigger_metric_data_post
-    second_post = last_metric_data_post
-
-    if RUBY_VERSION == '1.8.7'
-      # 1.8 + JSON is finicky about comparing floats.
-      # If the timestamps are within 0.001 seconds, it's Good Enough.
-      assert_in_delta(t0, first_post[1], 0.001)
-      assert_in_delta(t1, first_post[2], 0.001)
-      assert_in_delta(t1, second_post[1], 0.001)
-      assert_in_delta(t2, second_post[2], 0.001)
-    else
-      assert_equal([t0, t1], first_post[1..2])
-      assert_equal([t1, t2], second_post[1..2])
-    end
-  end
-
   def trigger_metric_data_post
     NewRelic::Agent.agent.send(:transmit_data)
   end

data/test/multiverse/suites/grape/Envfile

@@ -2,7 +2,7 @@ suite_condition("Grape is only supported for versions >= 1.9.3") do
   RUBY_VERSION >= '1.9.3'
 end
 
-versions = %w(0.14.0 0.13.0 0.12.0 0.11.0 0.10.0 0.9.0 0.8.0 0.7.0 0.6.1 0.5.0 0.4.1 0.3.2 0.2.6 0.2.0 0.1.5)
+versions = %w(0.16.1 0.15.0 0.14.0 0.13.0 0.12.0 0.11.0 0.10.0 0.9.0 0.8.0 0.7.0 0.6.1 0.5.0 0.4.1 0.3.2 0.2.6 0.2.0 0.1.5)
 
 versions.each do |version|
   gemfile <<-RB

data/test/multiverse/suites/mongo/Envfile

@@ -1,4 +1,7 @@
 if RUBY_VERSION >= '1.9.3'
+  gemfile <<-RB
+    gem 'mongo', '~>2.2.0'
+  RB
   gemfile <<-RB
     gem 'mongo', '~>2.1.0'
   RB

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

@@ -270,12 +270,13 @@ if NewRelic::Agent::Datastores::Mongo.is_supported_version? &&
               :collection => @collection_name,
               'insert' => @collection_name,
               :operation  => :insert,
-              'writeConcern' => { :w => 1 },
               'ordered' => true
             }
 
             result = node.params[:statement]
-
+            # the writeConcern is added by some, but not all versions of the mongo driver,
+            # we don't care if it's present or not, just that the statement is noticed
+            result.delete('writeConcern')
             assert_equal expected, result
           end
 

data/test/multiverse/suites/padrino/Envfile

@@ -1,3 +1,11 @@
+if RUBY_VERSION >= '1.9.3' # padrino v0.12.0 dropped support for ruby 1.8.7 and requres ruby 1.9.3 or greater
+gemfile <<-RB
+  gem 'activesupport', '~> 3'
+  gem 'padrino', '~> 0.13.0'
+  gem 'rack-test', :require => 'rack/test'
+RB
+end
+
 if RUBY_VERSION > '1.8.7' # padrino-core 0.11.0 requires http_router 0.11.0 which has syntax errors in 1.8.7.
 gemfile <<-RB
   gem 'activesupport', '~> 3'

data/test/multiverse/suites/typhoeus/Envfile

@@ -31,6 +31,13 @@ gemfile <<-RB
   # Compatibility issues with ethon 0.5.12 https://github.com/typhoeus/ethon/issues/51
   gem 'ethon', '0.5.11'
 
+  # ethon 0.5.11 requires mime-types ~> 1.18
+  # normally, this wouldn't be a problem, but
+  # we have other checks to work around other
+  # mime-type dependency issues, so we need
+  # to specify it here.
+  gem 'mime-types', '~> 1.18'
+
   gem 'typhoeus', '~> 0.5.4'
   gem 'rack'
   gem 'json', :platforms => [:rbx, :mri_18]
@@ -41,6 +48,13 @@ gemfile <<-RB
   # Compatibility issues with ethon 0.5.12 https://github.com/typhoeus/ethon/issues/51
   gem 'ethon', '0.5.11'
 
+  # ethon 0.5.11 requires mime-types ~> 1.18
+  # normally, this wouldn't be a problem, but
+  # we have other checks to work around other
+  # mime-type dependency issues, so we need
+  # to specify it here.
+  gem 'mime-types', '~> 1.18'
+
   gem 'typhoeus', '0.5.3'
   gem 'rack'
   gem 'json', :platforms => [:rbx, :mri_18]
@@ -51,6 +65,13 @@ gemfile <<-RB
   # Compatibility issues with ethon 0.5.12 https://github.com/typhoeus/ethon/issues/51
   gem 'ethon', '0.5.11'
 
+  # ethon 0.5.11 requires mime-types ~> 1.18
+  # normally, this wouldn't be a problem, but
+  # we have other checks to work around other
+  # mime-type dependency issues, so we need
+  # to specify it here.
+  gem 'mime-types', '~> 1.18'
+
   gem 'typhoeus', '0.5.2'
   gem 'rack'
   gem 'json', :platforms => [:rbx, :mri_18]

data/test/new_relic/agent/database_test.rb

@@ -6,85 +6,113 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', '..',
                                    'test_helper'))
 require 'new_relic/agent/database'
 class NewRelic::Agent::DatabaseTest < Minitest::Test
-  def setup
-    @explainer = NewRelic::Agent::Instrumentation::ActiveRecord::EXPLAINER
-  end
-
   def teardown
     NewRelic::Agent::Database::Obfuscator.instance.reset
   end
 
   def test_adapter_from_config_string
     config = { :adapter => 'mysql' }
-    assert_equal('mysql', NewRelic::Agent::Database.adapter_from_config(config))
+    statement = NewRelic::Agent::Database::Statement.new('some query', config)
+    assert_equal(:mysql, statement.adapter)
   end
 
   def test_adapter_from_config_symbol
     config = { :adapter => :mysql }
-    assert_equal('mysql', NewRelic::Agent::Database.adapter_from_config(config))
+    statement = NewRelic::Agent::Database::Statement.new('some query', config)
+    assert_equal(:mysql, statement.adapter)
   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))
+    statement = NewRelic::Agent::Database::Statement.new('some query', config)
+    assert_equal(:postgres, statement.adapter)
   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))
+    statement = NewRelic::Agent::Database::Statement.new('some query', config)
+    assert_equal(:mysql, statement.adapter)
   end
 
   def test_adapter_from_config_uri_jdbc_sqlite
     config = { :uri => "jdbc:sqlite::memory" }
-    assert_equal('sqlite', NewRelic::Agent::Database.adapter_from_config(config))
+    statement = NewRelic::Agent::Database::Statement.new('some query', config)
+    assert_equal(:sqlite, statement.adapter)
+  end
+
+  # An ActiveRecord::Result is what you get back when executing a
+  # query using exec_query on the connection, which is what we're
+  # doing now for explain plans in AR4 instrumentation
+  def test_explain_sql_with_mysql2_activerecord_result
+    return unless defined?(::ActiveRecord::Result)
+    config = {:adapter => 'mysql2'}
+    sql = 'SELECT * FROM spells where id=1'
+
+    columns = ["id", "select_type", "table", "type", "possible_keys", "key", "key_len", "ref", "rows", "Extra"]
+    rows = [["1", "SIMPLE", "spells", "const", "PRIMARY", "PRIMARY", "4", "const", "1", ""]]
+    activerecord_result = ::ActiveRecord::Result.new(columns, rows)
+    explainer = lambda { |statement| activerecord_result}
+
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, explainer)
+    result = NewRelic::Agent::Database.explain_sql(statement)
+
+    assert_equal([columns, rows], result)
+  end
+
+  def test_explain_sql_obfuscates_for_postgres_activerecord_result
+    return unless defined?(::ActiveRecord::Result)
+    config = {:adapter => 'postgres'}
+    sql = "SELECT * FROM blogs WHERE blogs.id=1234 AND blogs.title='sensitive text'"
+
+    columns = ["stuffs"]
+    rows = [[" 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)"]]
+    activerecord_result = ::ActiveRecord::Result.new(columns, rows)
+    explainer = lambda { |statement| activerecord_result}
+
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, explainer)
+    expected_result = [['QUERY PLAN'],
+                       [[" Index Scan using blogs_pkey on blogs  (cost=0.00..8.27 rows=1 width=540)"],
+                        ["   Index Cond: ?"],
+                        ["   Filter: ?"]
+                      ]]
+
+    with_config(:'transaction_tracer.record_sql' => 'obfuscated') do
+      result = NewRelic::Agent::Database.explain_sql(statement)
+      assert_equal(expected_result, result)
+    end
   end
 
-  def test_explain_sql_select_with_mysql_connection
+  # The following tests in the format _with_##_explain_result go
+  # through the different kinds of results when using an explainer
+  # that calls .execute on the connection
+
+  def test_explain_sql_select_with_mysql_explain_result
     config = {:adapter => 'mysql'}
-    config.default('val')
     sql = 'SELECT foo'
-    connection = mock('mysql connection')
+
     plan = {
       "select_type"=>"SIMPLE", "key_len"=>nil, "table"=>"blogs", "id"=>"1",
       "possible_keys"=>nil, "type"=>"ALL", "Extra"=>"", "rows"=>"2",
       "ref"=>nil, "key"=>nil
     }
-    result = mock('explain plan')
-    result.expects(:each_hash).yields(plan)
-    # two rows, two columns
-    connection.expects(:execute).with('EXPLAIN SELECT foo').returns(result)
-    NewRelic::Agent::Database.stubs(:get_connection).returns(connection)
-    result = NewRelic::Agent::Database.explain_sql(sql, config, @explainer)
-    assert_equal(plan.keys.sort, result[0].sort)
-    assert_equal(plan.values.compact.sort, result[1][0].compact.sort)
-  end
+    explainer_result = mock('explain plan')
+    explainer_result.expects(:each_hash).yields(plan)
+    explainer = lambda { |statement| explainer_result}
 
-  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")
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, explainer)
+    result = NewRelic::Agent::Database.explain_sql(statement)
+    expected_result = [["select_type", "key_len", "table", "id", "possible_keys", "type",
+                        "Extra", "rows", "ref", "key"],
+                       [["SIMPLE", nil, "blogs", "1", nil, "ALL", "", "2", nil, nil]]]
 
-    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])
+    assert_equal(expected_result[0].sort, result[0].sort, "Headers don't match")
+    assert_equal(expected_result[1][0].compact.sort, result[1][0].compact.sort, "Values don't match")
   end
 
-  def test_explain_sql_select_with_mysql_connection_sequel
-    config = { :adapter => 'mysql' }
-    config.default('val')
+  def test_explain_sql_select_with_sequel
+    config = { :adapter => 'mysql2' }
     sql = 'SELECT * FROM items'
 
     # Sequel returns explain plans to us as one giant preformatted string rather
@@ -96,114 +124,124 @@ class NewRelic::Agent::DatabaseTest < Minitest::Test
       "| 1|SIMPLE     |items|ALL |             |   |       |   |   3|     |",
       "+--+-----------+-----+----+-------------+---+-------+---+----+-----+"
     ].join("\n")
+    explainer = lambda { |statement| plan_string}
+
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, explainer)
+    result = NewRelic::Agent::Database.explain_sql(statement)
 
-    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
+  def test_explain_sql_select_with_mysql2_explain_result
     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 ]
+    explainer_result = mock('explain plan')
+    explainer_result.expects(:fields).returns(plan_fields)
+    explainer_result.expects(:each).yields(plan_row)
+    explainer = lambda { |statement| explainer_result}
 
-    result = mock('explain plan')
-    result.expects(:fields).returns(plan_fields)
-    result.expects(:each).yields(plan_row)
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, explainer)
+    result = NewRelic::Agent::Database.explain_sql(statement)
+    expected_result = [["select_type", "key_len", "table", "id", "possible_keys", "type",
+                        "Extra", "rows", "ref","key"],
+                       [["SIMPLE", nil, "blogs", "1", nil, "ALL", "", "2", nil, nil]]]
 
-    # 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)
+    assert_equal(expected_result[0].sort, result[0].sort, "Headers don't match")
+    assert_equal(expected_result[1][0].compact.sort, result[1][0].compact.sort, "Values don't match")
   end
 
-  def test_explain_sql_one_select_with_pg_connection
+  def test_explain_sql_one_select_with_pg_explain_result
     config = {:adapter => 'postgresql'}
-    config.default('val')
     sql = 'select count(id) from blogs limit 1'
-    connection = stub('pg connection', :disconnect! => true)
+
     plan = [{"QUERY PLAN"=>"Limit  (cost=11.75..11.76 rows=1 width=4)"},
             {"QUERY PLAN"=>"  ->  Aggregate  (cost=11.75..11.76 rows=1 width=4)"},
             {"QUERY PLAN"=>"        ->  Seq Scan on blogs  (cost=0.00..11.40 rows=140 width=4)"}]
-    connection.expects(:execute).returns(plan)
-    NewRelic::Agent::Database.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))
+    explainer = lambda { |statement| plan}
+
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, explainer)
+    result = NewRelic::Agent::Database.explain_sql(statement)
+    expected_result = [['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)"]
+                       ]]
+
+    assert_equal expected_result, result
   end
 
-  def test_explain_sql_one_select_with_pg_connection_string
+  def test_explain_sql_one_select_with_pg_explain_string_result
     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)"
+    explainer = lambda { |statement| plan}
+
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, explainer)
+    result = NewRelic::Agent::Database.explain_sql(statement)
+    expected_result = [['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)"]
+                       ]]
 
-    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))
+    assert_equal expected_result, result
   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)
+    explainer = lambda { |statement| plan}
+
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, explainer)
+    expected_result = [['QUERY PLAN'],
+                       [[" Index Scan using blogs_pkey on blogs  (cost=0.00..8.27 rows=1 width=540)"],
+                        ["   Index Cond: ?"],
+                        ["   Filter: ?"]
+                      ]]
+
     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))
+      result = NewRelic::Agent::Database.explain_sql(statement)
+      assert_equal expected_result, result
     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)
+    explainer = lambda { |statement| plan}
+
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, explainer)
+    expected_result = [['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)"]
+                      ]]
+
     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))
+      result = NewRelic::Agent::Database.explain_sql(statement)
+      assert_equal expected_result, result
     end
   end
 
-  def test_explain_sql_select_with_sqlite_connection
+  def test_explain_sql_select_with_sqlite_explain_string_result
     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},
@@ -212,9 +250,10 @@ class NewRelic::Agent::DatabaseTest < Minitest::Test
       {"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)
+    explainer = lambda { |statement| plan}
+
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, explainer)
+    result = NewRelic::Agent::Database.explain_sql(statement)
 
     expected_headers = %w[addr opcode p1 p2 p3 p4 p5 comment]
     expected_values  = plan.map do |row|
@@ -225,68 +264,96 @@ class NewRelic::Agent::DatabaseTest < Minitest::Test
     assert_equal(expected_values, result[1])
   end
 
-  def test_dont_collect_explain_for_parameterized_query
+  def test_explain_sql_select_with_sqlite3_explain_string_result
+    config = {:adapter => 'sqlite3'}
+    sql = 'SELECT foo'
+
+    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}
+    ]
+    explainer = lambda { |statement| plan}
+
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, explainer)
+    result = NewRelic::Agent::Database.explain_sql(statement)
+
+    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_explain_sql_no_sql
+    statement = NewRelic::Agent::Database::Statement.new('', nil)
+    assert_equal(nil, NewRelic::Agent::Database.explain_sql(statement))
+  end
+
+  def test_explain_sql_non_select
+    statement = NewRelic::Agent::Database::Statement.new('foo', mock('config'), mock('explainer'))
+    assert_equal([], NewRelic::Agent::Database.explain_sql(statement))
+  end
+
+  def test_dont_collect_explain_for_truncated_query
     config = {:adapter => 'postgresql'}
-    config.default('val')
-    connection = mock('param connection')
-    connection.expects(:execute).never
-    NewRelic::Agent::Database.stubs(:get_connection).with(config).returns(connection)
-    expects_logging(:debug, 'Unable to collect explain plan for parameterized query.')
+    sql = 'SELECT * FROM table WHERE id IN (1,2,3,4,5...'
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, mock('explainer'))
+
+    expects_logging(:debug, 'Unable to collect explain plan for truncated query.')
+    assert_equal [], NewRelic::Agent::Database.explain_sql(statement)
+  end
 
+  def test_dont_collect_explain_for_parameterized_query
+    config = {:adapter => 'postgresql'}
     sql = 'SELECT * FROM table WHERE id = $1'
-    assert_equal [], NewRelic::Agent::Database.explain_sql(sql, config, @explainer)
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, mock('explainer'))
+
+    expects_logging(:debug, 'Unable to collect explain plan for parameter-less parameterized query.')
+    assert_equal [], NewRelic::Agent::Database.explain_sql(statement)
   end
 
   def test_do_collect_explain_for_parameter_looking_literal
     config = {:adapter => 'postgresql'}
-    config.default('val')
-    connection = mock('literal connection')
-    plan = [{"QUERY PLAN"=>"Some Jazz"}]
     sql = "SELECT * FROM table WHERE id = 'noise $11'"
-    confirm_sql = Proc.new {|query| query.include?(sql) }
-    connection.expects(:execute).with(&confirm_sql).returns(plan)
-    NewRelic::Agent::Database.stubs(:get_connection).with(config).returns(connection)
+    plan = [{"QUERY PLAN"=>"Some Jazz"}]
+    explainer = lambda { |statement| plan}
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, explainer)
 
     assert_equal([['QUERY PLAN'], [["Some Jazz"]]],
-                 NewRelic::Agent::Database.explain_sql(sql, config, @explainer))
+                 NewRelic::Agent::Database.explain_sql(statement))
   end
 
-  def test_dont_collect_explain_for_truncated_query
+  def test_do_collect_explain_for_parameterized_query_with_binds
     config = {:adapter => 'postgresql'}
-    config.default('val')
-    connection = mock('truncated connection')
-    connection.expects(:execute).never
-    NewRelic::Agent::Database.stubs(:get_connection).with(config).returns(connection)
-    expects_logging(:debug, 'Unable to collect explain plan for truncated query.')
+    sql = 'SELECT * FROM table WHERE id = $1'
+    # binds objects don't actually look like this, just need non-blank for test
+    binds = "values for the parameters"
+    plan = [{"QUERY PLAN"=>"Some Jazz"}]
+    explainer = lambda { |statement| plan}
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, explainer, binds)
 
-    sql = 'SELECT * FROM table WHERE id IN (1,2,3,4,5...'
-    assert_equal [], NewRelic::Agent::Database.explain_sql(sql, config, @explainer)
+    assert_equal([['QUERY PLAN'], [["Some Jazz"]]],
+                 NewRelic::Agent::Database.explain_sql(statement))
   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, @explainer)
-  end
+    statement = NewRelic::Agent::Database::Statement.new(sql, config, mock('explainer'))
 
-  def test_explain_sql_no_sql
-    assert_equal(nil, NewRelic::Agent::Database.explain_sql(nil, nil))
+    expects_logging(:debug, "Not collecting explain plan because an unknown connection adapter ('dorkdb') was used.")
+    assert_equal [], NewRelic::Agent::Database.explain_sql(statement)
   end
 
   def test_explain_sql_no_connection_config
-    assert_equal(nil, NewRelic::Agent::Database.explain_sql('select foo', nil))
-  end
-
-  def test_explain_sql_non_select
-    assert_equal([], NewRelic::Agent::Database.explain_sql('foo',
-                                                           mock('config'),
-                                                           @explainer))
+    statement = NewRelic::Agent::Database::Statement.new('select foo', nil)
+    assert_equal(nil, NewRelic::Agent::Database.explain_sql(statement))
   end
 
   def test_explain_sql_one_select_no_connection
@@ -296,7 +363,12 @@ class NewRelic::Agent::DatabaseTest < Minitest::Test
     # errors to percolate up.
     config = mock('config')
     config.stubs(:[]).returns(nil)
-    assert_equal([], NewRelic::Agent::Database.explain_sql('SELECT', config, @explainer))
+
+    # if you have an invalid config or no connection, the explainer returns nil
+    explainer = lambda { |statement| nil}
+    statement = NewRelic::Agent::Database::Statement.new('SELECT', config, explainer)
+
+    assert_equal([], NewRelic::Agent::Database.explain_sql(statement))
   end
 
   # See SqlObfuscationTest, which uses cross agent tests for the basic SQL