newrelic_rpm 3.12.1.298 → 3.13.0.299

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

@@ -79,5 +79,14 @@ module NewRelic::Agent::Configuration
       HighSecuritySource.new(local_settings)
     end
 
+    def test_forces_redis_argument_recording_off
+      local_settings = {
+        :'transaction_tracer.record_redis_arguments' => true
+      }
+
+      source = HighSecuritySource.new(local_settings)
+
+      assert_equal(false, source[:'transaction_tracer.record_redis_arguments'])
+    end
   end
 end

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

@@ -13,9 +13,7 @@ module NewRelic::Agent::Database
 
     def self.create_input_statements(raw_query, dialects)
       dialects.map do |dialect|
-        NewRelic::Agent::Database::Statement.new(raw_query).tap do |s|
-          s.adapter = DIALECT_MAP[dialect]
-        end
+        NewRelic::Agent::Database::Statement.new(raw_query, {:adapter => DIALECT_MAP[dialect]})
       end
     end
 

data/test/new_relic/agent/datastores/redis_test.rb

@@ -0,0 +1,128 @@
+# 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 'new_relic/agent/datastores/redis'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+
+class NewRelic::Agent::Datastores::RedisTest < Minitest::Test
+  def test_format_command
+    expected = "set \"foo\" \"bar\""
+
+    with_config(:'transaction_tracer.record_redis_arguments' => true) do
+      result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'foo', 'bar'])
+      assert_equal expected, result
+    end
+  end
+
+  def test_format_command_truncates_long_arguments
+    key = "namespace.other_namespace.different_namespace.why.would.you.do.this.key"
+    expected_key = "namespace.other_namespace.dif...ace.why.would.you.do.this.key"
+
+    expected = "set \"#{expected_key}\" \"redoctober\""
+
+    with_config(:'transaction_tracer.record_redis_arguments' => true) do
+      result = NewRelic::Agent::Datastores::Redis.format_command([:set, key, 'redoctober'])
+      assert_equal expected, result
+    end
+  end
+
+  def test_format_command_truncates_long_commands
+    key = "key"
+    command = [:set] + Array.new(NewRelic::Agent::Datastores::Redis::MAXIMUM_COMMAND_LENGTH, key)
+
+    with_config(:'transaction_tracer.record_redis_arguments' => true) do
+      result = NewRelic::Agent::Datastores::Redis.format_command(command)
+      assert result.length <= NewRelic::Agent::Datastores::Redis::MAXIMUM_COMMAND_LENGTH
+    end
+  end
+
+  def test_format_command_with_record_arguments_false
+    with_config(:'transaction_tracer.record_redis_arguments' => false) do
+      result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'foo', 'bar'])
+      assert_equal nil, result
+    end
+  end
+
+  def test_format_command_in_pipeline
+    expected = "set \"foo\" \"bar\""
+
+    with_config(:'transaction_tracer.record_redis_arguments' => true) do
+      result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'foo', 'bar'])
+      assert_equal expected, result
+    end
+  end
+
+  def test_append_command_in_pipeline_with_record_arguments_false
+    expected = "set ?"
+
+    with_config(:'transaction_tracer.record_redis_arguments' => false) do
+      result = ""
+      NewRelic::Agent::Datastores::Redis.append_pipeline_command(result, [:set, 'foo', 'bar'])
+      assert_equal expected, result
+    end
+  end
+
+  def test_append_command_in_pipeline_with_record_arguments_and_no_args
+    expected = "multi"
+
+    with_config(:'transaction_tracer.record_redis_arguments' => true) do
+      result = ""
+      NewRelic::Agent::Datastores::Redis.append_pipeline_command(result, [:multi])
+      assert_equal expected, result
+    end
+  end
+
+  def test_append_command_in_pipeline_with_record_arguments_false_and_no_args
+    expected = "multi"
+
+    with_config(:'transaction_tracer.record_redis_arguments' => false) do
+      result = ""
+      NewRelic::Agent::Datastores::Redis.append_pipeline_command(result, [:multi])
+      assert_equal expected, result
+    end
+  end
+
+  def test_format_pipeline_commands_truncates_long_commands
+    pipeline = NewRelic::Agent::Datastores::Redis::MAXIMUM_COMMAND_LENGTH.times.map do
+      [:set, "0123456789"]
+    end
+
+    with_config(:'transaction_tracer.record_redis_arguments' => true) do
+      result = NewRelic::Agent::Datastores::Redis.format_pipeline_commands(pipeline)
+      assert NewRelic::Agent::Datastores::Redis::MAXIMUM_COMMAND_LENGTH, result.length
+      assert result.end_with?("012345...")
+    end
+  end
+
+  def test_format_command_with_non_string_argument
+    expected = "set \"key\" true"
+
+    with_config(:'transaction_tracer.record_redis_arguments' => true) do
+      result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'key', true])
+      assert_equal expected, result
+    end
+  end
+
+  if !NewRelic::LanguageSupport.rubinius? && RUBY_VERSION != "1.8.7"
+    def test_format_command_handles_binary_strings
+      binary_string = (0..255).to_a.pack("c*")
+      expected = 'set "key" <binary data>'
+
+      with_config(:'transaction_tracer.record_redis_arguments' => true) do
+        result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'key', binary_string])
+        assert_equal expected, result
+      end
+    end
+
+    def test_format_command_in_pipeline_handles_binary_strings
+      binary_string = (0..255).to_a.pack("c*")
+      expected = 'set "key" <binary data>'
+
+      with_config(:'transaction_tracer.record_redis_arguments' => true) do
+        result = NewRelic::Agent::Datastores::Redis.format_command([:set, 'key', binary_string])
+        assert_equal expected, result
+      end
+    end
+  end
+end

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

@@ -87,7 +87,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest < Minitest::T
     assert_equal('Datastore/statement/ActiveRecord/NewRelic::Agent::Instrumentation::ActiveRecordSubscriberTest::Order/find',
                  last_node.metric_name)
     assert_equal('SELECT * FROM sandwiches',
-                 last_node.params[:sql])
+                 last_node.params[:sql].sql)
   end
 
   def test_creates_slow_sql_node

data/test/new_relic/agent/sql_sampler_test.rb

@@ -30,7 +30,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
   def populate_container(sampler, n)
     n.times do |i|
       sampler.on_start_transaction(@state, nil)
-      sampler.notice_sql("SELECT * FROM test#{i}", "Database/test/select", nil, 1, @state)
+      sampler.notice_sql("SELECT * FROM test#{i}", "Database/test/select", {}, 1, @state)
       sampler.on_finishing_transaction(@state, 'txn')
     end
   end
@@ -76,9 +76,9 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     data.set_transaction_info("/c/a", 'guid')
     data.set_transaction_name("WebTransaction/Controller/c/a")
     data.sql_data.concat [
-      NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5),
-      NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2),
-      NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)
+      NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test"), "Database/test/select", 1.5),
+      NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test"), "Database/test/select", 1.2),
+      NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test2"), "Database/test2/select", 1.1)
     ]
     @sampler.save_slow_sql data
 
@@ -86,13 +86,13 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
   end
 
   def test_sql_aggregation
-    sql_trace = NewRelic::Agent::SqlTrace.new("select * from test",
-            NewRelic::Agent::SlowSql.new("select * from test",
-                "Database/test/select", {}, 1.2),
-        "tx_name", "uri")
+    query = "select * from test"
+    slow_sql = NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new(query), "Database/test/select", 1.2)
 
-    sql_trace.aggregate NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5), "slowest_tx_name", "slow_uri"
-    sql_trace.aggregate NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.1), "other_tx_name", "uri2"
+    sql_trace = NewRelic::Agent::SqlTrace.new(query, slow_sql, "tx_name", "uri")
+
+    sql_trace.aggregate NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new(query), "Database/test/select", 1.5), "slowest_tx_name", "slow_uri"
+    sql_trace.aggregate NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new(query), "Database/test/select", 1.1), "other_tx_name", "uri2"
 
     assert_equal 3, sql_trace.call_count
     assert_equal "slowest_tx_name", sql_trace.path
@@ -104,9 +104,9 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     data = NewRelic::Agent::TransactionSqlData.new
     data.set_transaction_info("/c/a", 'guid')
     data.set_transaction_name("WebTransaction/Controller/c/a")
-    data.sql_data.concat [NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5),
-                          NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2),
-                          NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)]
+    data.sql_data.concat [NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test"), "Database/test/select", 1.5),
+                          NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test"), "Database/test/select", 1.2),
+                          NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test2"), "Database/test2/select", 1.1)]
     @sampler.save_slow_sql data
 
     sql_traces = @sampler.harvest!
@@ -118,8 +118,8 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     data.set_transaction_info("/c/a", 'guid')
     data.set_transaction_name("WebTransaction/Controller/c/a")
     15.times do |i|
-      data.sql_data << NewRelic::Agent::SlowSql.new("select * from test#{(i+97).chr}",
-                                                    "Database/test#{(i+97).chr}/select", {}, i)
+      statement = NewRelic::Agent::Database::Statement.new("select * from test#{(i+97).chr}")
+      data.sql_data << NewRelic::Agent::SlowSql.new(statement, "Database/test#{(i+97).chr}/select", i)
     end
 
     @sampler.save_slow_sql data
@@ -134,9 +134,9 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     data.set_transaction_info("/c/a", 'guid')
     data.set_transaction_name("WebTransaction/Controller/c/a")
     queries = [
-               NewRelic::Agent::SlowSql.new("select  * from test where foo in (1, 2)  ", "Database/test/select", {}, 1.5),
-               NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2, 3 ,4,  5,6, 'snausage')", "Database/test/select", {}, 1.2),
-               NewRelic::Agent::SlowSql.new("select * from test2 where foo in (1,2)", "Database/test2/select", {}, 1.1)
+               NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select  * from test where foo in (1, 2)  "), "Database/test/select", 1.5),
+               NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test where foo in (1,2, 3 ,4,  5,6, 'snausage')"), "Database/test/select", 1.2),
+               NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test2 where foo in (1,2)"), "Database/test2/select", 1.1)
               ]
     data.sql_data.concat(queries)
     @sampler.save_slow_sql data
@@ -157,15 +157,12 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     explainer = NewRelic::Agent::Instrumentation::ActiveRecord::EXPLAINER
     config = { :adapter => 'mysql' }
     queries = [
-               NewRelic::Agent::SlowSql.new("select * from test",
-                                            "Database/test/select", config,
-                                            1.5, nil, explainer),
-               NewRelic::Agent::SlowSql.new("select * from test",
-                                            "Database/test/select", config,
-                                            1.2, nil, explainer),
-               NewRelic::Agent::SlowSql.new("select * from test2",
-                                            "Database/test2/select", config,
-                                            1.1, nil, explainer)
+               NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test", config, explainer),
+                                            "Database/test/select", 1.5),
+               NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test", config, explainer),
+                                            "Database/test/select", 1.2),
+               NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test2", config, explainer),
+                                            "Database/test2/select", 1.1)
               ]
     data.sql_data.concat(queries)
     @sampler.save_slow_sql data
@@ -196,8 +193,8 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
       data.set_transaction_info("/c/a", 'guid')
       data.set_transaction_name("WebTransaction/Controller/c/a")
       queries = [
-                 NewRelic::Agent::SlowSql.new("select * from test",
-                                              "Database/test/select", {}, 1.5)
+                 NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test"),
+                                              "Database/test/select", 1.5)
                 ]
       data.sql_data.concat(queries)
       @sampler.save_slow_sql data
@@ -227,9 +224,10 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
   end
 
   def test_sql_id_fits_in_a_mysql_int_11
+    statement = NewRelic::Agent::Database::Statement.new("select * from test")
     sql_trace = NewRelic::Agent::SqlTrace.new("select * from test",
-            NewRelic::Agent::SlowSql.new("select * from test",
-                "Database/test/select", {}, 1.2),
+            NewRelic::Agent::SlowSql.new(statement,
+                "Database/test/select", 1.2),
         "tx_name", "uri")
 
     assert(-2147483648 <= sql_trace.sql_id, "sql_id too small")
@@ -241,10 +239,10 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
       data = NewRelic::Agent::TransactionSqlData.new
       data.set_transaction_info("/c/a", 'guid')
       data.set_transaction_name("WebTransaction/Controller/c/a")
-      data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test where foo = 'bar'",
-                                                         "Database/test/select", {}, 1.5),
-                            NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2,3,4,5)",
-                                                         "Database/test/select", {}, 1.2)])
+      data.sql_data.concat([NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test where foo = 'bar'"),
+                                                         "Database/test/select", 1.5),
+                            NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test where foo in (1,2,3,4,5)"),
+                                                         "Database/test/select", 1.2)])
       @sampler.save_slow_sql(data)
       sql_traces = @sampler.harvest!.sort_by(&:total_call_time).reverse
 
@@ -262,10 +260,10 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
       data = NewRelic::Agent::TransactionSqlData.new
       data.set_transaction_info("/c/a", 'guid')
       data.set_transaction_name("WebTransaction/Controller/c/a")
-      data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test where foo = 'bar'",
-                                                         "Database/test/select", {}, 1.5),
-                            NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2,3,4,5)",
-                                                         "Database/test/select", {}, 1.2)])
+      data.sql_data.concat([NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test where foo = 'bar'"),
+                                                         "Database/test/select", 1.5),
+                            NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test where foo in (1,2,3,4,5)"),
+                                                         "Database/test/select", 1.2)])
       @sampler.save_slow_sql(data)
       sql_traces = @sampler.harvest!.sort_by(&:total_call_time).reverse
 
@@ -274,6 +272,19 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     end
   end
 
+  def test_does_not_over_obfuscate_queries_for_postgres
+    with_config(:'transaction_tracer.record_sql' => 'obfuscated') do
+      sampler = NewRelic::Agent.agent.sql_sampler
+
+      in_transaction do
+        sql = %Q[INSERT INTO "items" ("name", "price") VALUES ('continuum transfunctioner', 100000) RETURNING "id"]
+        sampler.notice_sql sql, "Database/test/insert", {:adapter => "postgres"}, 1.23
+      end
+      sql_traces = sampler.harvest!
+      assert_equal(%Q[INSERT INTO "items" ("name", "price") VALUES (?, ?) RETURNING "id"], sql_traces[0].sql)
+    end
+  end
+
   def test_takes_slowest_samples
     data = NewRelic::Agent::TransactionSqlData.new
     data.set_transaction_info("/c/a", 'guid')
@@ -282,7 +293,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     count = NewRelic::Agent::SqlSampler::MAX_SAMPLES * 2
     durations = (0...count).to_a.shuffle
     durations.each do |i|
-      data.sql_data << NewRelic::Agent::SlowSql.new("SELECT * FROM table#{i}", "Database/table#{i}/select", {}, i)
+      data.sql_data << NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("SELECT * FROM table#{i}"), "Database/table#{i}/select", i)
     end
 
     @sampler.save_slow_sql(data)
@@ -298,9 +309,8 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     with_config(:'transaction_tracer.explain_enabled' => false) do
       data = NewRelic::Agent::TransactionSqlData.new
       explainer = NewRelic::Agent::Instrumentation::ActiveRecord::EXPLAINER
-      data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test",
-                                                         "Database/test/select",
-                                                         {}, 1.5, nil, explainer)])
+      data.sql_data.concat([NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test", {}, explainer),
+                                                         "Database/test/select", 1.5)])
       @sampler.save_slow_sql(data)
       sql_traces = @sampler.harvest!
 
@@ -313,9 +323,8 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
       data = NewRelic::Agent::TransactionSqlData.new
       data.set_transaction_info("/c/a", 'guid')
       data.set_transaction_name("WebTransaction/Controller/c/a")
-      data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test",
-                                                         "Database/test/select",
-                                                         {}, 1.5)])
+      data.sql_data.concat([NewRelic::Agent::SlowSql.new(NewRelic::Agent::Database::Statement.new("select * from test"),
+                                                         "Database/test/select", 1.5)])
       @sampler.save_slow_sql(data)
       sql_traces = @sampler.harvest!
 
@@ -336,7 +345,8 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
   end
 
   def test_to_collector_array_with_bad_values
-    slow = NewRelic::Agent::SlowSql.new("query", "transaction", {}, Rational(12, 1))
+    statement = NewRelic::Agent::Database::Statement.new("query")
+    slow = NewRelic::Agent::SlowSql.new(statement, "transaction", Rational(12, 1))
     trace = NewRelic::Agent::SqlTrace.new("query", slow, "path", "uri")
     trace.call_count = Rational(10, 1)
     trace.instance_variable_set(:@sql_id, "1234")
@@ -357,7 +367,8 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
 
   def test_merge_without_existing_trace
     query = "select * from test"
-    slow_sql = NewRelic::Agent::SlowSql.new(query, "Database/test/select", {}, 1)
+    statement = NewRelic::Agent::Database::Statement.new(query, {})
+    slow_sql = NewRelic::Agent::SlowSql.new(statement, "Database/test/select", 1)
     trace = NewRelic::Agent::SqlTrace.new(query, slow_sql, "txn_name", "uri")
 
     @sampler.merge!([trace])
@@ -366,9 +377,9 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
 
   def test_merge_with_existing_trace
     query = "select * from test"
-
-    slow_sql0 = NewRelic::Agent::SlowSql.new(query, "Database/test/select", {}, 1)
-    slow_sql1 = NewRelic::Agent::SlowSql.new(query, "Database/test/select", {}, 2)
+    statement = NewRelic::Agent::Database::Statement.new(query, {})
+    slow_sql0 = NewRelic::Agent::SlowSql.new(statement, "Database/test/select", 1)
+    slow_sql1 = NewRelic::Agent::SlowSql.new(statement, "Database/test/select", 2)
 
     trace0 = NewRelic::Agent::SqlTrace.new(query, slow_sql0, "txn_name", "uri")
     trace1 = NewRelic::Agent::SqlTrace.new(query, slow_sql1, "txn_name", "uri")
@@ -393,7 +404,8 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
 
     count = NewRelic::Agent::SqlSampler::MAX_SAMPLES + 1
     count.times do |i|
-      data.sql_data << NewRelic::Agent::SlowSql.new("SELECT * FROM table#{i}", "Database/table#{i}/select", {}, i)
+      statement = NewRelic::Agent::Database::Statement.new("SELECT * FROM table#{i}", {})
+      data.sql_data << NewRelic::Agent::SlowSql.new(statement, "Database/table#{i}/select", i)
     end
 
     @sampler.save_slow_sql(data)

data/test/new_relic/agent/transaction/trace_node_test.rb

@@ -340,7 +340,7 @@ class NewRelic::Agent::Transaction::TraceNodeTest < Minitest::Test
   def test_obfuscated_sql
     sql = 'select * from table where id = 1'
     s = NewRelic::Agent::Transaction::TraceNode.new(Time.now, 'Custom/test/metric')
-    s[:sql] = sql
+    s[:sql] = NewRelic::Agent::Database::Statement.new(sql)
     assert_equal('select * from table where id = ?', s.obfuscated_sql)
   end
 

data/test/new_relic/agent/transaction/trace_test.rb

@@ -214,7 +214,7 @@ class NewRelic::Agent::Transaction::TraceTest < Minitest::Test
     NewRelic::Agent::Database.stubs(:record_sql_method).returns :raw
 
     node = @trace.create_node(0.0, 'has_sql')
-    node[:sql] = "select * from pelicans where name = '1337807';"
+    node[:sql] = NewRelic::Agent::Database::Statement.new "select * from pelicans where name = '1337807';"
     @trace.root_node.add_called_node(node)
 
     @trace.prepare_sql_for_transmission!

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -186,7 +186,12 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
   def test_notice_sql_recording_sql
     @state.record_sql = true
     builder = @sampler.tl_builder
-    @sampler.expects(:notice_extra_data).with(builder, 'some sql', 1.0, :sql)
+    @sampler.expects(:notice_extra_data).with do |sample_builder, message, duration, key|
+      sample_builder == builder &&
+      message.sql == 'some sql' &&
+      duration == 1.0 &&
+      key == :sql
+    end
     @sampler.notice_sql('some sql', {:config => 'a config'}, 1.0, @state)
   end
 
@@ -574,7 +579,7 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
 
     sql = node[:sql]
 
-    assert sql.length <= 16384
+    assert sql.sql.length <= 16384
   end
 
   def test_node_obfuscated
@@ -587,7 +592,7 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
 
     node = @sampler.send(:tl_builder).current_node
 
-    assert_equal orig_sql, node[:sql]
+    assert_equal orig_sql, node[:sql].sql
     assert_equal "SELECT * from Jim where id=?", node.obfuscated_sql
     @sampler.notice_pop_frame(@state, "foo")
   end
@@ -607,7 +612,7 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
       expected_sql = "SELECT * FROM sandwiches WHERE bread = 'challah'"
       deepest_node = find_last_transaction_node(@sampler.last_sample)
       assert_equal([], deepest_node.called_nodes)
-      assert_equal(expected_sql, deepest_node[:sql])
+      assert_equal(expected_sql, deepest_node[:sql].sql)
     end
   end
 
@@ -642,13 +647,6 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
     end
   end
 
-  def test_build_database_statement_uses_adapter_from_connection_config
-    config = { :adapter => 'GumbyDB' }
-    sql = "SELECT * FROM \"horses\" WHERE \"name\" = 'pokey'"
-    statement = @sampler.build_database_statement(sql, config, Proc.new {})
-    assert_equal 'GumbyDB', statement.adapter
-  end
-
   def test_harvest_prepare_samples
     samples = [mock('TT0'), mock('TT1')]
     samples[0].expects(:prepare_to_send!)