newrelic_rpm 3.7.0.174.beta → 3.7.0.177

data/test/new_relic/agent/memcache_instrumentation_test.rb

@@ -27,121 +27,123 @@ rescue Errno::ECONNREFUSED
 rescue Errno::ETIMEDOUT
 end
 
-class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
-  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+if memcached_ready
+  class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
 
-  def setup
-    NewRelic::Agent.manual_start
-    @engine = NewRelic::Agent.instance.stats_engine
+    def setup
+      NewRelic::Agent.manual_start
+      @engine = NewRelic::Agent.instance.stats_engine
 
-    case MEMCACHED_CLASS.name
-    when 'Memcached'
-      @cache = MEMCACHED_CLASS.new('localhost', :support_cas => true)
-    when 'Spymemcached'
-      @cache = MEMCACHED_CLASS.new('localhost:11211')
-    else
-      @cache = MEMCACHED_CLASS.new('localhost')
+      case MEMCACHED_CLASS.name
+      when 'Memcached'
+        @cache = MEMCACHED_CLASS.new('localhost', :support_cas => true)
+      when 'Spymemcached'
+        @cache = MEMCACHED_CLASS.new('localhost:11211')
+      else
+        @cache = MEMCACHED_CLASS.new('localhost')
+      end
+      @key = 'schluessel'
+      @cache.set('schluessel', 1)
     end
-    @key = 'schluessel'
-    @cache.set('schluessel', 1)
-  end
 
-  def teardown
-    if MEMCACHED_CLASS.name == 'Memcached'
-      @cache.flush
-    elsif MEMCACHED_CLASS.name == 'Spymemcached'
-      @cache.flush
-      @cache.instance_eval{ @client.shutdown }
-    else
-      @cache.flush_all
+    def teardown
+      if MEMCACHED_CLASS.name == 'Memcached'
+        @cache.flush
+      elsif MEMCACHED_CLASS.name == 'Spymemcached'
+        @cache.flush
+        @cache.instance_eval{ @client.shutdown }
+      else
+        @cache.flush_all
+      end
     end
-  end
 
-  def _call_test_method_in_web_transaction(method, *args)
-    @engine.clear_stats
-    perform_action_with_newrelic_trace(:name=>'action', :category => :controller) do
-      @cache.send(method.to_sym, *[@key, *args])
+    def _call_test_method_in_web_transaction(method, *args)
+      @engine.clear_stats
+      perform_action_with_newrelic_trace(:name=>'action', :category => :controller) do
+        @cache.send(method.to_sym, *[@key, *args])
+      end
     end
-  end
 
-  def _call_test_method_in_background_task(method, *args)
-    @engine.clear_stats
-    perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do
-      @cache.send(method.to_sym, *[@key, *args])
+    def _call_test_method_in_background_task(method, *args)
+      @engine.clear_stats
+      perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do
+        @cache.send(method.to_sym, *[@key, *args])
+      end
     end
-  end
 
-  def test_reads__web
-    commands = ['get']
-    commands << 'get_multi' unless MEMCACHED_CLASS.name == 'Spymemcached'
-    commands.each do |method|
-      if @cache.class.method_defined?(method)
-        _call_test_method_in_web_transaction(method)
-        compare_metrics ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"],
-        @engine.metrics.select{|m| m =~ /^memcache.*/i}
+    def test_reads__web
+      commands = ['get']
+      commands << 'get_multi' unless MEMCACHED_CLASS.name == 'Spymemcached'
+      commands.each do |method|
+        if @cache.class.method_defined?(method)
+          _call_test_method_in_web_transaction(method)
+          compare_metrics ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"],
+          @engine.metrics.select{|m| m =~ /^memcache.*/i}
+        end
       end
     end
-  end
 
-  def test_writes__web
-    %w[delete].each do |method|
-      if @cache.class.method_defined?(method)
-        _call_test_method_in_web_transaction(method)
-        expected_metrics = ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
-        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+    def test_writes__web
+      %w[delete].each do |method|
+        if @cache.class.method_defined?(method)
+          _call_test_method_in_web_transaction(method)
+          expected_metrics = ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
+          compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+        end
       end
-    end
 
-    %w[set add].each do |method|
-      @cache.delete(@key) rescue nil
-      if @cache.class.method_defined?(method)
-        expected_metrics = ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
-        _call_test_method_in_web_transaction(method, 'value')
-        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      %w[set add].each do |method|
+        @cache.delete(@key) rescue nil
+        if @cache.class.method_defined?(method)
+          expected_metrics = ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
+          _call_test_method_in_web_transaction(method, 'value')
+          compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+        end
       end
     end
-  end
 
-  def test_reads__background
-    commands = ['get']
-    commands << 'get_multi' unless MEMCACHED_CLASS.name == 'Spymemcached'
-    commands.each do |method|
-      if @cache.class.method_defined?(method)
-        _call_test_method_in_background_task(method)
-        compare_metrics ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"],
-        @engine.metrics.select{|m| m =~ /^memcache.*/i}
+    def test_reads__background
+      commands = ['get']
+      commands << 'get_multi' unless MEMCACHED_CLASS.name == 'Spymemcached'
+      commands.each do |method|
+        if @cache.class.method_defined?(method)
+          _call_test_method_in_background_task(method)
+          compare_metrics ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"],
+          @engine.metrics.select{|m| m =~ /^memcache.*/i}
+        end
       end
     end
-  end
 
-  def test_writes__background
-    %w[delete].each do |method|
-      expected_metrics = ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
-      if @cache.class.method_defined?(method)
-        _call_test_method_in_background_task(method)
-        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+    def test_writes__background
+      %w[delete].each do |method|
+        expected_metrics = ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+        if @cache.class.method_defined?(method)
+          _call_test_method_in_background_task(method)
+          compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+        end
       end
-    end
 
-    %w[set add].each do |method|
-      @cache.delete(@key) rescue nil
-      expected_metrics = ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
-      if @cache.class.method_defined?(method)
-        _call_test_method_in_background_task(method, 'value')
-        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      %w[set add].each do |method|
+        @cache.delete(@key) rescue nil
+        expected_metrics = ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+        if @cache.class.method_defined?(method)
+          _call_test_method_in_background_task(method, 'value')
+          compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+        end
       end
     end
-  end
 
-  def test_handles_cas
-    expected_metrics = ["Memcache/cas", "Memcache/allOther", "Memcache/cas:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
-    if @cache.class.method_defined?(:cas)
-      @engine.clear_stats
-      perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do
-        @cache.cas(@key) {|val| val += 2 }
+    def test_handles_cas
+      expected_metrics = ["Memcache/cas", "Memcache/allOther", "Memcache/cas:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+      if @cache.class.method_defined?(:cas)
+        @engine.clear_stats
+        perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do
+          @cache.cas(@key) {|val| val += 2 }
+        end
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+        assert_equal 3, @cache.get(@key)
       end
-      compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
-      assert_equal 3, @cache.get(@key)
     end
   end
-end if memcached_ready
+end

data/test/new_relic/agent/method_tracer_test.rb

@@ -212,7 +212,7 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     assert_equal 2, stats.call_count
     stats = @stats_engine.get_stats("thrower")
     assert_equal 6, stats.call_count
-    sample = @old_sampler.harvest
+    sample = @old_sampler.harvest!
     assert_not_nil sample
   end
 

data/test/new_relic/agent/obfuscator_test.rb

@@ -0,0 +1,77 @@
+# 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/obfuscator"
+
+class NewRelic::Agent::ObfuscatorTest < Test::Unit::TestCase
+
+  OBFUSCATION_KEY = (1..40).to_a.pack('c*')
+  RUM_KEY_LENGTH  = 13
+
+  def setup
+    @config = { :license_key => OBFUSCATION_KEY }
+    NewRelic::Agent.config.apply_config(@config)
+  end
+
+  def teardown
+    NewRelic::Agent.config.remove_config(@config)
+    @obfuscator = nil
+  end
+
+  def obfuscator(length=nil)
+    @obfuscator ||= NewRelic::Agent::Obfuscator.new(OBFUSCATION_KEY, length)
+  end
+
+  def test_obfuscate_basic
+    assert_encoded(RUM_KEY_LENGTH,
+                   'a happy piece of small text',
+                   'YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1')
+  end
+
+  def test_obfuscate_long_string
+    assert_encoded(RUM_KEY_LENGTH,
+                   'a happy piece of small text' * 5,
+                   'YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1YyNsZHZ3cSl6YmluZCJsYiV1amllZit4aHl2YiRtZ3d4cCp7ZWhiZyNrYyZ0ZWhmZyx5ZHp3ZSVuZnh5cyt8ZGRhZiRqYCd7ZGtnYC11Z3twZCZvaXl6cix9aGdgYSVpYSh6Z2pgYSF2Znxx')
+  end
+
+  def test_obfuscate_utf8
+    assert_encoded(RUM_KEY_LENGTH,
+                   "foooooééoooo - blah",
+                   "Z21sa2ppxKHKo2RjYm4iLiRnamZg")
+  end
+
+
+  def test_decoding_blank
+    obfuscator = NewRelic::Agent::Obfuscator.new('query')
+    assert_equal "", obfuscator.deobfuscate("")
+  end
+
+  def test_decoding_empty_key
+    obfuscator = NewRelic::Agent::Obfuscator.new("")
+    assert_equal "querty", obfuscator.encode('querty')
+  end
+
+  def test_encode_with_nil_uses_empty_key
+    obfuscator = NewRelic::Agent::Obfuscator.new(nil)
+    assert_equal "querty", obfuscator.encode('querty')
+  end
+
+  def test_encoding_functions_can_roundtrip_utf8_text
+    str = 'Анастасі́я Олексі́ївна Каме́нських'
+    obfuscator = NewRelic::Agent::Obfuscator.new('potap')
+    encoded = obfuscator.obfuscate(str)
+    decoded = obfuscator.deobfuscate(encoded)
+    decoded.force_encoding( 'utf-8' ) if decoded.respond_to?( :force_encoding )
+    assert_equal str, decoded
+  end
+
+  def assert_encoded(key_length, text, expected)
+    output = obfuscator(key_length).obfuscate(text)
+    assert_equal(expected, output)
+
+    unoutput = obfuscator.obfuscate(Base64.decode64(output))
+    assert_equal Base64.encode64(text).gsub("\n", ''), unoutput
+  end
+end

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -11,7 +11,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
 
   def setup
     @test_config = { :developer_mode => true }
-    NewRelic::Agent.agent.reset_stats
+    NewRelic::Agent.agent.drop_buffered_data
     NewRelic::Agent.config.apply_config(@test_config)
     NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
     NewRelic::Agent.manual_start
@@ -47,13 +47,13 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
         NewRelic::Agent.after_fork
         new_engine = NewRelic::Agent::StatsEngine.new
         new_engine.get_stats_no_scope(metric).record_data_point(2.0)
-        listener.pipes[666].write(:stats => new_engine.harvest)
+        listener.pipes[666].write(:stats => new_engine.harvest!)
       end
       Process.wait(pid)
       listener.stop
 
       assert_equal(3.0, engine.lookup_stats(metric).total_call_time)
-      engine.reset_stats
+      engine.reset!
     end
 
     def test_listener_merges_transaction_traces
@@ -66,7 +66,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
         NewRelic::Agent.after_fork
         with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
           sample = run_sample_trace_on(sampler)
-          listener.pipes[667].write(:transaction_traces => sampler.harvest)
+          listener.pipes[667].write(:transaction_traces => sampler.harvest!)
         end
       end
       Process.wait(pid)
@@ -93,7 +93,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
         new_sampler.notice_error(Exception.new("new message"), :uri => '/myurl/',
                                  :metric => 'path', :referer => 'test_referer',
                                  :request_params => {:x => 'y'})
-        listener.pipes[668].write(:error_traces => new_sampler.harvest_errors)
+        listener.pipes[668].write(:error_traces => new_sampler.harvest!)
       end
       Process.wait(pid)
       listener.stop

data/test/new_relic/agent/pipe_service_test.rb

@@ -102,7 +102,7 @@ class PipeServiceTest < Test::Unit::TestCase
   def generate_metric_data(metric_name, data=1.0)
     engine = NewRelic::Agent::StatsEngine.new
     engine.get_stats_no_scope(metric_name).record_data_point(data)
-    engine.harvest
+    engine.harvest!
   end
 
   def read_from_pipe

data/test/new_relic/agent/request_sampler_test.rb

@@ -4,6 +4,7 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 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/request_sampler'
 
 class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
@@ -14,6 +15,22 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
     @sampler = NewRelic::Agent::RequestSampler.new( @event_listener )
   end
 
+  # Helpers for DataContainerTests
+
+  def create_container
+    @sampler
+  end
+
+  def populate_container(sampler, n)
+    n.times do |i|
+      generate_request("whatever#{i}")
+    end
+  end
+
+  include NewRelic::DataContainerTests
+
+  # Tests
+
   def test_samples_on_transaction_finished_event
     with_sampler_config do
       generate_request
@@ -74,18 +91,11 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
     end
   end
 
-  def test_can_disable_sampling_for_analytics_transactions
-    with_sampler_config( :'analytics_events.transactions.enabled' => false ) do
-      generate_request
-      assert @sampler.samples.empty?
-    end
-  end
-
   def test_harvest_returns_previous_sample_list
     with_sampler_config do
       5.times { generate_request }
 
-      old_samples = @sampler.harvest
+      old_samples = @sampler.harvest!
 
       assert_equal 5, old_samples.size
       assert_equal 0, @sampler.samples.size
@@ -95,7 +105,7 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
   def test_merge_merges_samples_back_into_buffer
     with_sampler_config do
       5.times { generate_request }
-      old_samples = @sampler.harvest
+      old_samples = @sampler.harvest!
       5.times { generate_request }
 
       @sampler.merge!(old_samples)
@@ -106,7 +116,7 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
   def test_merge_abides_by_max_samples_limit
     with_sampler_config(:'analytics_events.max_samples_stored' => 5) do
       4.times { generate_request }
-      old_samples = @sampler.harvest
+      old_samples = @sampler.harvest!
       4.times { generate_request }
 
       @sampler.merge!(old_samples)
@@ -127,7 +137,7 @@ class NewRelic::Agent::RequestSamplerTest < Test::Unit::TestCase
       samples_before = @sampler.samples
       assert_equal 50, samples_before.size
 
-      @sampler.harvest
+      @sampler.harvest!
 
       150.times { generate_request('after') }
       samples_after = @sampler.samples

data/test/new_relic/agent/sql_sampler_test.rb

@@ -3,6 +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'))
+require File.expand_path(File.join(File.dirname(__FILE__),'..','data_container_tests'))
 
 class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
   def setup
@@ -14,6 +15,24 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     NewRelic::Agent::Database.stubs(:get_connection).returns(@connection)
   end
 
+  # Helpers for DataContainerTests
+
+  def create_container
+    NewRelic::Agent::SqlSampler.new
+  end
+
+  def populate_container(sampler, n)
+    n.times do |i|
+      sampler.notice_first_scope_push nil
+      sampler.notice_sql("SELECT * FROM test#{i}", "Database/test/select", nil, 1)
+      sampler.notice_scope_empty('txn')
+    end
+  end
+
+  include NewRelic::DataContainerTests
+
+  # Tests
+
   def test_notice_first_scope_push
     assert_nil @sampler.transaction_data
     @sampler.notice_first_scope_push nil
@@ -82,7 +101,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
                           NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)]
     @sampler.harvest_slow_sql data
 
-    sql_traces = @sampler.harvest
+    sql_traces = @sampler.harvest!
     assert_equal 2, sql_traces.size
   end
 
@@ -96,7 +115,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     end
 
     @sampler.harvest_slow_sql data
-    result = @sampler.harvest
+    result = @sampler.harvest!
 
     assert_equal(10, result.size)
     assert_equal(14, result.sort{|a,b| b.max_call_time <=> a.max_call_time}.first.total_call_time)
@@ -114,7 +133,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     data.sql_data.concat(queries)
     @sampler.harvest_slow_sql data
 
-    sql_traces = @sampler.harvest
+    sql_traces = @sampler.harvest!
     assert_equal 2, sql_traces.size
   end
 
@@ -141,7 +160,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
               ]
     data.sql_data.concat(queries)
     @sampler.harvest_slow_sql data
-    sql_traces = @sampler.harvest
+    sql_traces = @sampler.harvest!
     assert_equal(["header0", "header1", "header2"],
                  sql_traces[0].params[:explain_plan][0].sort)
     assert_equal(["header0", "header1", "header2"],
@@ -174,7 +193,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
                 ]
       data.sql_data.concat(queries)
       @sampler.harvest_slow_sql data
-      sql_traces = @sampler.harvest
+      sql_traces = @sampler.harvest!
       assert_equal(nil, sql_traces[0].params[:explain_plan])
     end
   end
@@ -199,7 +218,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
                             NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2,3,4,5)",
                                                          "Database/test/select", {}, 1.2)])
       @sampler.harvest_slow_sql(data)
-      sql_traces = @sampler.harvest
+      sql_traces = @sampler.harvest!
 
       assert_equal('select * from test where foo = ?', sql_traces[0].sql)
       assert_equal('select * from test where foo in (?,?,?,?,?)', sql_traces[1].sql)
@@ -214,7 +233,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
                                                          "Database/test/select",
                                                          {}, 1.5, &explainer)])
       @sampler.harvest_slow_sql(data)
-      sql_traces = @sampler.harvest
+      sql_traces = @sampler.harvest!
 
       assert_nothing_raised do
         Marshal.dump(sql_traces)
@@ -231,7 +250,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
                                                          "Database/test/select",
                                                          {}, 1.5)])
       @sampler.harvest_slow_sql(data)
-      sql_traces = @sampler.harvest
+      sql_traces = @sampler.harvest!
 
       params = RUBY_VERSION >= '1.9.2' ? "eJyrrgUAAXUA+Q==\n" : {}
       expected = [ 'WebTransaction/Controller/c/a', '/c/a', 526336943,
@@ -267,4 +286,29 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     assert_equal expected, trace.to_collector_array(marshaller.default_encoder)
   end
 
+  def test_merge_without_existing_trace
+    query = "select * from test"
+    slow_sql = NewRelic::Agent::SlowSql.new(query, "Database/test/select", {}, 1)
+    trace = NewRelic::Agent::SqlTrace.new(query, slow_sql, "txn_name", "uri")
+
+    @sampler.merge!([trace])
+    assert_equal(trace, @sampler.sql_traces[query])
+  end
+
+  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)
+
+    trace0 = NewRelic::Agent::SqlTrace.new(query, slow_sql0, "txn_name", "uri")
+    trace1 = NewRelic::Agent::SqlTrace.new(query, slow_sql1, "txn_name", "uri")
+
+    @sampler.merge!([trace0])
+    @sampler.merge!([trace1])
+
+    aggregated_trace = @sampler.sql_traces[query]
+    assert_equal(2, aggregated_trace.call_count)
+    assert_equal(3, aggregated_trace.total_call_time)
+  end
 end