newrelic_rpm 3.6.0.83 → 3.6.1.85.beta

data/test/new_relic/agent/method_tracer_test.rb

@@ -39,8 +39,7 @@ module NewRelic
   module Agent
     extend self
     def module_method_to_be_traced (x, testcase)
-      testcase.assert x == "x"
-      testcase.assert testcase.stats_engine.peek_scope.name == "x"
+      testcase.assert_equal 'x',  x
     end
   end
 end
@@ -91,32 +90,38 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     assert_equal '12345', TestModuleWithLog.other_method
   end
 
-  def test_basic
+  def test_trace_execution_scoped_records_metric_data
     metric = "hello"
     t1 = Time.now
-    self.class.trace_execution_scoped metric do
+    self.class.trace_execution_scoped(metric) do
       sleep 0.05
-      assert metric == @stats_engine.peek_scope.name
     end
     elapsed = Time.now - t1
 
     stats = @stats_engine.get_stats(metric)
     check_time stats.total_call_time, elapsed
-    assert stats.call_count == 1
+    assert_equal 1, stats.call_count
+  end
+
+  def test_trace_execution_scoped_pushes_transaction_scope
+    self.class.trace_execution_scoped('yeap') do
+      'ptoo'
+    end
+    assert_equal 'yeap',  @scope_listener.scopes.last
   end
 
   def test_basic__original_api
     metric = "hello"
     t1 = Time.now
-    self.class.trace_method_execution metric, true, true, true do
+    self.class.trace_method_execution(metric, true, true, true) do
       sleep 0.05
-      assert metric == @stats_engine.peek_scope.name
     end
     elapsed = Time.now - t1
 
     stats = @stats_engine.get_stats(metric)
     check_time stats.total_call_time, elapsed
-    assert stats.call_count == 1
+    assert_equal 1, stats.call_count
+    assert_equal metric,  @scope_listener.scopes.last
   end
 
   METRIC = "metric"
@@ -137,7 +142,8 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
 
     stats = @stats_engine.get_stats(METRIC)
     check_time stats.total_call_time, elapsed
-    assert stats.call_count == 1
+    assert_equal 1, stats.call_count
+    assert_equal METRIC, @scope_listener.scopes.last
   end
 
   def test_add_method_tracer__default
@@ -172,10 +178,9 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
   end
 
   def test_tt_only
+    assert @scope_listener.scopes.empty?
 
-    assert_nil @scope_listener.scope["c2"]
     self.class.add_method_tracer :method_c1, "c1", :push_scope => true
-
     self.class.add_method_tracer :method_c2, "c2", :metric => false
     self.class.add_method_tracer :method_c3, "c3", :push_scope => false
 
@@ -185,7 +190,7 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     assert_nil @stats_engine.lookup_stats("c2")
     assert_not_nil @stats_engine.lookup_stats("c3")
 
-    assert_not_nil @scope_listener.scope["c2"]
+    assert_equal ['c2', 'c1'], @scope_listener.scopes
   end
 
   def test_nested_scope_tracer
@@ -220,7 +225,10 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
 
     stats = @stats_engine.get_stats(METRIC)
     check_time stats.total_call_time, elapsed
-    assert stats.call_count == 1
+    assert_equal 1, stats.call_count
+    assert_equal METRIC, @scope_listener.scopes.last
+    assert(METRIC != @scope_listener.scopes[-2],
+           'duplicate scope detected when redundant tracer is present')
   end
 
   def test_add_tracer_with_dynamic_metric
@@ -241,7 +249,8 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
 
     stats = @stats_engine.get_stats(expected_metric)
     check_time stats.total_call_time, elapsed
-    assert stats.call_count == 1
+    assert_equal 1, stats.call_count
+    assert_equal expected_metric, @scope_listener.scopes.last
   end
 
   def test_trace_method_with_block
@@ -249,14 +258,15 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
 
     t1 = Time.now
     method_with_block(1,2,3,true,METRIC) do |scope|
-      assert scope == METRIC
+      assert_equal METRIC, scope
       sleep 0.1 # pad the test a bit to increase the margin of error
     end
     elapsed = Time.now - t1
 
     stats = @stats_engine.get_stats(METRIC)
     check_time stats.total_call_time, elapsed
-    assert stats.call_count == 1
+    assert_equal 1, stats.call_count
+    assert_equal METRIC, @scope_listener.scopes.last
   end
 
   def test_trace_module_method
@@ -278,15 +288,17 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
   end
 
   def self.static_method(x, testcase, is_traced)
-    testcase.assert x == "x"
-    testcase.assert((testcase.stats_engine.peek_scope.name == "x") == is_traced)
+    testcase.assert_equal 'x',  x
   end
 
   def trace_trace_static_method
     self.add_method_tracer :static_method, '#{args[0]}'
     self.class.static_method "x", self, true
+    assert_equal 'x', @scope_listener.scopes.last
+    @scope_listener = NewRelic::Agent::MockScopeListener.new
     self.remove_method_tracer :static_method, '#{args[0]}'
     self.class.static_method "x", self, false
+    assert_nil @scope_listener.scopes.last
   end
 
   def test_multiple_metrics__scoped
@@ -299,7 +311,9 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
       assert_equal 1, m.call_count
       assert_equal elapsed, m.total_call_time
     end
+    assert_equal 'first', @scope_listener.scopes.last
   end
+
   def test_multiple_metrics__unscoped
     metrics = %w[first second third]
     self.class.trace_execution_unscoped metrics do
@@ -310,23 +324,24 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
       assert_equal 1, m.call_count
       assert_equal elapsed, m.total_call_time
     end
+    assert @scope_listener.scopes.empty?
   end
+
   def test_exception
     begin
       metric = "hey"
-      self.class.trace_execution_scoped metric do
-        assert @stats_engine.peek_scope.name == metric
+      self.class.trace_execution_scoped(metric) do
         throw StandardError.new
       end
 
       assert false # should never get here
     rescue StandardError
       # make sure the scope gets popped
-      assert @stats_engine.peek_scope == nil
+      assert_equal metric, @scope_listener.scopes.last
     end
 
     stats = @stats_engine.get_stats metric
-    assert stats.call_count == 1
+    assert_equal 1, stats.call_count
   end
 
   def test_add_multiple_tracers
@@ -338,6 +353,8 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     method_to_be_traced 1,2,3,true,nil
     self.class.remove_method_tracer :method_to_be_traced, 'XX'
     method_to_be_traced 1,2,3,false,'XX'
+
+    assert_equal ['YY'], @scope_listener.scopes
   end
 
   def trace_no_push_scope
@@ -345,6 +362,8 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     method_to_be_traced 1,2,3,true,nil
     self.class.remove_method_tracer :method_to_be_traced, 'X'
     method_to_be_traced 1,2,3,false,'X'
+
+    assert_nil @scope_listener.scopes
   end
 
   def check_time(t1, t2)
@@ -358,12 +377,6 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     assert x == 1
     assert y == 2
     assert z == 3
-    scope_name = @stats_engine.peek_scope ? @stats_engine.peek_scope.name : nil
-    if is_traced
-      assert_equal expected_metric, scope_name
-    else
-      assert_not_equal expected_metric, scope_name
-    end
   end
 
   def method_with_block(x, y, z, is_traced, expected_metric, &block)
@@ -371,10 +384,6 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     assert x == 1
     assert y == 2
     assert z == 3
-    block.call(@stats_engine.peek_scope.name)
-
-    scope_name = @stats_engine.peek_scope ? @stats_engine.peek_scope.name : nil
-    assert((expected_metric == scope_name) == is_traced)
   end
 
   def method_c1

data/test/new_relic/agent/mock_scope_listener.rb

@@ -5,20 +5,20 @@
 
 class NewRelic::Agent::MockScopeListener
 
-  attr_reader :scope
+  attr_reader :scopes
 
   def initialize
-    @scope = {}
+    @scopes = []
   end
 
   def notice_first_scope_push(time)
   end
 
-  def notice_push_scope(scope, time)
-    @scope[scope] = true
+  def notice_push_scope(time)
   end
 
   def notice_pop_scope(scope, time)
+    @scopes << scope
   end
 
   def notice_scope_empty(time)

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -7,6 +7,8 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_hel
 require 'new_relic/agent/pipe_channel_manager'
 
 class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
+  include TransactionSampleTestHelper
+
   def setup
     @test_config = { :developer_mode => true }
     NewRelic::Agent.config.apply_config(@test_config)
@@ -54,7 +56,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
 
     def test_listener_merges_transaction_traces
       sampler = NewRelic::Agent.agent.transaction_sampler
-      TransactionSampleTestHelper.run_sample_trace_on(sampler)
+      run_sample_trace_on(sampler)
       NewRelic::Agent.agent.merge_data_from([nil, [sampler.samples], nil])
 
       assert_equal(1, NewRelic::Agent.agent.unsent_traces_size)
@@ -64,7 +66,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
       pid = Process.fork do
         NewRelic::Agent.after_fork
         new_sampler = NewRelic::Agent::TransactionSampler.new
-        sample = TransactionSampleTestHelper.run_sample_trace_on(new_sampler)
+        sample = run_sample_trace_on(new_sampler)
         new_sampler.store_force_persist(sample)
         with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
           listener.pipes[667].write(:transaction_traces => new_sampler.harvest([]))

data/test/new_relic/agent/rpm_agent_test.rb

@@ -4,116 +4,113 @@
 
 ENV['SKIP_RAILS'] = 'true'
 require File.expand_path('../../../test_helper', __FILE__)
-require File.expand_path('../../../test_contexts', __FILE__)
 
 class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::TestCase
-  extend TestContexts
-
-  attr_reader :agent
+  def setup
+    NewRelic::Agent.manual_start
+    @agent = NewRelic::Agent.instance
+  end
 
-  with_running_agent do
-    # Fake out the agent to think mongrel is running
+  def teardown
+    NewRelic::Agent.instance.shutdown
+  end
 
-    should "agent_setup" do
-      assert NewRelic::Agent.instance.class == NewRelic::Agent::Agent
-      assert_raise RuntimeError do
-        NewRelic::Control.instance.init_plugin :agent_enabled => false
-      end
+  def test_agent_setup
+    assert(NewRelic::Agent.instance.class == NewRelic::Agent::Agent)
+    assert_raise(RuntimeError) do
+      NewRelic::Control.instance.init_plugin(:agent_enabled => false)
     end
+  end
 
-    should "public_apis" do
-      assert_raise RuntimeError do
-        NewRelic::Agent.set_sql_obfuscator(:unknown) do |sql|
-          puts sql
-        end
-      end
-
-      ignore_called = false
-      NewRelic::Agent.ignore_error_filter do |e|
-        ignore_called = true
-        nil
-      end
-      NewRelic::Agent.notice_error(StandardError.new("message"), :request_params => {:x => "y"})
-      assert ignore_called
-      NewRelic::Agent.instance.error_collector.instance_variable_set '@ignore_filter', nil
+  def test_public_apis
+    assert_raise(RuntimeError) do
+      NewRelic::Agent.set_sql_obfuscator(:unknown) { |sql| puts sql }
     end
 
-    should "startup_shutdown" do
-      with_config(:agent_enabled => true) do
-        @agent = NewRelic::Agent::ShimAgent.instance
-        @agent.shutdown
-        assert (not @agent.started?)
-        @agent.start
-        assert !@agent.started?
-        # this installs the real agent:
-        NewRelic::Agent.manual_start
-        @agent = NewRelic::Agent.instance
-        assert @agent != NewRelic::Agent::ShimAgent.instance
-        assert @agent.started?
-        @agent.shutdown
-        assert !@agent.started?
-        @agent.start
-        assert @agent.started?
-        NewRelic::Agent.shutdown
-      end
+    ignore_called = false
+    NewRelic::Agent.ignore_error_filter do |e|
+      ignore_called = true
+      nil
     end
+    NewRelic::Agent.notice_error(StandardError.new("message"), :request_params => {:x => "y"})
+    assert(ignore_called)
+  end
 
-    should "manual_start" do
-      NewRelic::Agent.instance.expects(:connect).once
-      NewRelic::Agent.instance.expects(:start_worker_thread).once
-      NewRelic::Agent.instance.instance_variable_set '@started', nil
-      NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
+  def test_startup_shutdown
+    with_config(:agent_enabled => true) do
+      @agent = NewRelic::Agent::ShimAgent.instance
+      @agent.shutdown
+      assert (not @agent.started?)
+      @agent.start
+      assert !@agent.started?
+      # this installs the real agent:
+      NewRelic::Agent.manual_start
+      @agent = NewRelic::Agent.instance
+      assert @agent != NewRelic::Agent::ShimAgent.instance
+      assert @agent.started?
+      @agent.shutdown
+      assert !@agent.started?
+      @agent.start
+      assert @agent.started?
       NewRelic::Agent.shutdown
     end
+  end
 
-    should "post_fork_handler" do
-      NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
-      NewRelic::Agent.after_fork
-      NewRelic::Agent.after_fork
-      NewRelic::Agent.shutdown
-    end
-    should "manual_overrides" do
-      NewRelic::Agent.manual_start :app_name => "testjobs", :dispatcher_instance_id => "mailer"
-      assert_equal "testjobs", NewRelic::Agent.config.app_names[0]
-      assert_equal "mailer", NewRelic::Control.instance.local_env.dispatcher_instance_id
-      NewRelic::Agent.shutdown
-    end
+  def test_manual_start
+    NewRelic::Agent.instance.expects(:connect).once
+    NewRelic::Agent.instance.expects(:start_worker_thread).once
+    NewRelic::Agent.instance.instance_variable_set '@started', nil
+    NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
+    NewRelic::Agent.shutdown
+  end
 
-    should "restart" do
-      NewRelic::Agent.manual_start :app_name => "noapp", :dispatcher_instance_id => ""
-      NewRelic::Agent.manual_start :app_name => "testjobs", :dispatcher_instance_id => "mailer"
-      assert_equal "testjobs", NewRelic::Agent.config.app_names[0]
-      assert_equal "mailer", NewRelic::Control.instance.local_env.dispatcher_instance_id
-      NewRelic::Agent.shutdown
-    end
+  def test_post_fork_handler
+    NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
+    NewRelic::Agent.after_fork
+    NewRelic::Agent.after_fork
+    NewRelic::Agent.shutdown
+  end
+
+  def test_manual_overrides
+    NewRelic::Agent.manual_start :app_name => "testjobs", :dispatcher_instance_id => "mailer"
+    assert_equal "testjobs", NewRelic::Agent.config.app_names[0]
+    assert_equal "mailer", NewRelic::Control.instance.local_env.dispatcher_instance_id
+    NewRelic::Agent.shutdown
+  end
+
+  def test_agent_restart
+    NewRelic::Agent.manual_start :app_name => "noapp", :dispatcher_instance_id => ""
+    NewRelic::Agent.manual_start :app_name => "testjobs", :dispatcher_instance_id => "mailer"
+    assert_equal "testjobs", NewRelic::Agent.config.app_names[0]
+    assert_equal "mailer", NewRelic::Control.instance.local_env.dispatcher_instance_id
+    NewRelic::Agent.shutdown
+  end
 
-    should "set_record_sql" do
-      @agent.set_record_sql(false)
-      assert !NewRelic::Agent.is_sql_recorded?
+  def test_set_record_sql
+    @agent.set_record_sql(false)
+    assert !NewRelic::Agent.is_sql_recorded?
+    NewRelic::Agent.disable_sql_recording do
+      assert_equal false, NewRelic::Agent.is_sql_recorded?
       NewRelic::Agent.disable_sql_recording do
         assert_equal false, NewRelic::Agent.is_sql_recorded?
-        NewRelic::Agent.disable_sql_recording do
-          assert_equal false, NewRelic::Agent.is_sql_recorded?
-        end
-        assert_equal false, NewRelic::Agent.is_sql_recorded?
       end
-      assert !NewRelic::Agent.is_sql_recorded?
-      @agent.set_record_sql(nil)
+      assert_equal false, NewRelic::Agent.is_sql_recorded?
     end
+    assert !NewRelic::Agent.is_sql_recorded?
+    @agent.set_record_sql(nil)
+  end
 
-    should "version" do
-      assert_match /\d\.\d+\.\d+/, NewRelic::VERSION::STRING
-    end
+  def test_agent_version_string
+    assert_match /\d\.\d+\.\d+/, NewRelic::VERSION::STRING
+  end
 
-    context "with transaction api" do
-      should "reject empty arguments" do
-        assert_raises RuntimeError do
-          NewRelic::Agent.record_transaction 0.5
-        end
-      end
-      should "record a transaction" do
-        NewRelic::Agent.record_transaction 0.5, 'uri' => "/users/create?foo=bar"
-      end
+  def test_record_transaction_should_reject_empty_arguments
+    assert_raises RuntimeError do
+      NewRelic::Agent.record_transaction 0.5
     end
   end
+
+  def test_record_transaction
+    NewRelic::Agent.record_transaction 0.5, 'uri' => "/users/create?foo=bar"
+  end
 end

data/test/new_relic/agent/sql_sampler_test.rb

@@ -18,7 +18,7 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     assert_nil @sampler.transaction_data
     @sampler.notice_first_scope_push nil
     assert_not_nil @sampler.transaction_data
-    @sampler.notice_scope_empty
+    @sampler.notice_scope_empty('txn')
     assert_nil @sampler.transaction_data
   end
 
@@ -46,8 +46,8 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
 
   def test_harvest_slow_sql
     data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
-                              'guid')
+    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),
@@ -75,8 +75,8 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
 
   def test_harvest
     data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
-                              'guid')
+    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)]
@@ -88,7 +88,8 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
 
   def test_harvest_should_not_take_more_than_10
     data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {}, 'guid')
+    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)
@@ -103,8 +104,8 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
 
   def test_harvest_should_aggregate_similar_queries
     data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
-                              'guid')
+    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),
@@ -124,8 +125,8 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
      .returns([{"header0" => 'bar0', "header1" => 'bar1', "header2" => 'bar2'}])
 
     data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
-                              'guid')
+    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("select * from test", "Database/test/select", {}, 1.2),
@@ -148,9 +149,8 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     txn_sampler = NewRelic::Agent::TransactionSampler.new
     NewRelic::Agent.instance.stats_engine.transaction_sampler = txn_sampler
     txn_sampler.start_builder(Time.now)
-    txn_sampler.notice_transaction('a path', 'a uri', {:some => :params})
     @sampler.create_transaction_data
-    @sampler.notice_transaction('a path', 'a uri', {:some => :params})
+    @sampler.notice_transaction('a uri', {:some => :params})
 
     assert_equal(NewRelic::Agent.instance.transaction_sampler.builder.sample.guid,
                  NewRelic::Agent.instance.sql_sampler.transaction_data.guid)
@@ -159,9 +159,8 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
   def test_should_not_collect_explain_plans_when_disabled
     with_config(:'transaction_tracer.explain_enabled' => false) do
       data = NewRelic::Agent::TransactionSqlData.new
-      data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
-                                'guid')
-
+      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)
@@ -186,8 +185,8 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
   def test_sends_obfuscated_queries_when_configured
     with_config(:'transaction_tracer.record_sql' => 'obfuscated') do
       data = NewRelic::Agent::TransactionSqlData.new
-      data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
-                                'guid')
+      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)",
@@ -203,8 +202,8 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
   def test_to_collector_array
     with_config(:'transaction_tracer.explain_enabled' => false) do
       data = NewRelic::Agent::TransactionSqlData.new
-      data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
-                                'guid')
+      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/test/new_relic/agent/stats_engine/gc_profiler_test.rb

@@ -69,15 +69,12 @@ class NewRelic::Agent::StatsEngine::GCProfilerTest < Test::Unit::TestCase
       return true # no need to test if we're not collecting GC metrics
     end
 
+    with_config(:'transaction_tracer.enabled' => true) do
+      in_transaction { }
+    end
+
     engine = NewRelic::Agent.instance.stats_engine
-    tracer = NewRelic::Agent::TransactionSampler.new
-    tracer.instance_variable_set(:@last_sample,
-                                 NewRelic::TransactionSample.new)
-    engine.transaction_sampler = tracer
-    engine.start_transaction
-    scope = engine.push_scope "scope"
-    engine.pop_scope scope, 0.01
-    engine.end_transaction
+    tracer = NewRelic::Agent.instance.transaction_sampler
 
     gc_stats = engine.get_stats('GC/cumulative')
     assert_equal 2, gc_stats.call_count

data/test/new_relic/agent/stats_engine/metric_stats_test.rb

@@ -117,8 +117,9 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
   end
 
   def test_record_metrics_unscoped_metrics_only_by_default
-    @engine.stubs(:scope_name).returns('scopey')
-    @engine.record_metrics('foo', 42)
+    in_transaction('scopey') do
+      @engine.record_metrics('foo', 42)
+    end
     unscoped_stats = @engine.get_stats('foo', false)
     scoped_stats = @engine.get_stats('foo', true, true, 'scopey')
     assert_equal(1, unscoped_stats.call_count)
@@ -126,12 +127,13 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
   end
 
   def test_record_metrics_records_to_scoped_metric_if_requested
-    @engine.stubs(:scope_name).returns('scopey')
-    @engine.record_metrics('foo', 42, :scoped => true)
+    in_transaction('scopey') do
+      @engine.record_metrics('foo', 42, :scoped => true)
+    end
     unscoped_stats = @engine.get_stats('foo', false)
     scoped_stats = @engine.get_stats('foo', true, true, 'scopey')
-    assert_equal(1, unscoped_stats.call_count)
-    assert_equal(1, scoped_stats.call_count)
+    assert_equal(1, unscoped_stats.call_count, 'missing unscoped metric')
+    assert_equal(1, scoped_stats.call_count, 'missing scoped metric')
   end
 
   def test_record_metrics_elides_scoped_metric_if_not_in_transaction
@@ -144,8 +146,9 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
   end
 
   def test_record_metrics_accepts_explicit_scope
-    @engine.stubs(:scope_name).returns('scopey')
-    @engine.record_metrics('foo', 42, :scoped => true, :scope => 'not scopey')
+    in_transaction('scopey') do
+      @engine.record_metrics('foo', 42, :scoped => true, :scope => 'not scopey')
+    end
     unscoped_stats = @engine.get_stats('foo', false)
     scoped_stats_scopey = @engine.get_stats('foo', true, true, 'scopey')
     scoped_stats_not_scopey = @engine.get_stats('foo', true, true, 'not scopey')
@@ -181,4 +184,13 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
     assert_equal(nthreads * iterations, stats_m1.call_count)
     assert_equal(nthreads * iterations, stats_m2.call_count)
   end
+
+  def test_transaction_stats_are_tracked_separately
+    in_transaction do
+      @engine.record_metrics('foo', 1)
+      assert_nil @engine.lookup_stats('foo')
+    end
+
+    assert_equal 1, @engine.lookup_stats('foo').call_count
+  end
 end