newrelic_rpm 3.6.0.83 → 3.6.1.85.beta

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

@@ -3,158 +3,9 @@
 # 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__), '..', '..', '..', 'test_contexts'))
 
 class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::TestCase
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-  extend TestContexts
-  attr_accessor :agent
-
-  with_running_agent do
-
-    should "run" do
-      run_task_inner 0
-      stat_names = %w[Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0
-                    HttpDispatcher
-                    Apdex Apdex/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0].sort
-      expected_but_missing = stat_names - @agent.stats_engine.metrics
-      assert_equal 0, expected_but_missing.size, @agent.stats_engine.metrics.map  { |n|
-        stat = @agent.stats_engine.get_stats_no_scope(n)
-      "#{'%-26s' % n}: #{stat.call_count} calls"
-      }.join("\n  ") + "\nmissing: #{expected_but_missing.inspect}"
-      assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
-    end
-
-    should "run_recursive" do
-      run_task_inner(3)
-      assert_equal 1, @agent.stats_engine.lookup_stats(
-                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
-                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1').call_count
-      assert_equal 1, @agent.stats_engine.lookup_stats(
-                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1',
-                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2').call_count
-      assert_equal 1, @agent.stats_engine.lookup_stats(
-                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2',
-                          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_3').call_count
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1').call_count
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2').call_count
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_3').call_count
-      assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
-    end
-
-    should "run_nested" do
-      run_task_outer(3)
-      @agent.stats_engine.metrics.sort.each do |n|
-        stat = @agent.stats_engine.get_stats_no_scope(n)
-      end
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task').call_count
-      assert_equal 2, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
-    end
-
-    should "reentrancy" do
-      assert_equal 0, NewRelic::Agent::BusyCalculator.busy_count
-      run_task_inner(1)
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1').call_count
-      compare_metrics %w[
-      Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0:Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1
-      Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0
-      Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1
-      ], @agent.stats_engine.metrics.grep(/^Controller/)
-    end
-
-    should "transaction" do
-      assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
-      assert_nil @agent.transaction_sampler.last_sample
-      assert_equal @agent.transaction_sampler, @agent.stats_engine.instance_variable_get("@transaction_sampler")
-      run_task_outer(10)
-      assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
-      @agent.stats_engine.metrics.sort.each do |n|
-        stat = @agent.stats_engine.get_stats_no_scope(n)
-      end
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task').call_count
-      assert_equal 0, @agent.stats_engine.get_stats_no_scope('Controller').call_count
-      assert_equal 2, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0').call_count
-      assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
-      sample = @agent.transaction_sampler.last_sample
-      assert_not_nil sample
-      assert_not_nil sample.params[:custom_params][:cpu_time], "cpu time nil: \n#{sample}"
-      assert sample.params[:custom_params][:cpu_time] >= 0, "cpu time: #{sample.params[:cpu_time]},\n#{sample}"
-      assert_equal '10', sample.params[:request_params][:level]
-    end
-
-    should "abort" do
-      @acct = 'Redrocks'
-      perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
-        self.class.inspect
-        NewRelic::Agent.abort_transaction!
-      end
-      # We record the controller metric still, but abort any transaction recording.
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/hello').call_count
-      assert_nil @agent.transaction_sampler.last_sample
-    end
-    should "block" do
-      assert_equal @agent, NewRelic::Agent.instance
-      @acct = 'Redrocks'
-      perform_action_with_newrelic_trace(:name => 'hello', :force => true, :params => { :account => @acct}) do
-        self.class.inspect
-      end
-      @agent.stats_engine.metrics.sort.each do |n|
-        stat = @agent.stats_engine.get_stats_no_scope(n)
-      end
-      assert_equal @agent, NewRelic::Agent.instance
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/hello').call_count
-      sample = @agent.transaction_sampler.last_sample
-      assert_not_nil sample
-      assert_equal 'Redrocks', sample.params[:request_params][:account]
-
-    end
-
-    should "error_handling" do
-      @agent.error_collector.ignore_error_filter
-      @agent.error_collector.harvest_errors([])
-      @agent.error_collector.expects(:notice_error).once
-      assert_equal @agent.error_collector, NewRelic::Agent.instance.error_collector
-      assert_raise RuntimeError do
-        run_task_exception
-      end
-    end
-
-    should "custom_params" do
-      @agent.error_collector.stubs(:enabled).returns(true)
-      @agent.error_collector.ignore_error_filter
-      @agent.error_collector.harvest_errors([])
-      assert_equal @agent.error_collector, NewRelic::Agent.instance.error_collector
-      assert_raise RuntimeError do
-        run_task_exception
-      end
-      errors = @agent.error_collector.harvest_errors([])
-      assert_equal 1, errors.size
-      error = errors.first
-      assert_equal "Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/run_task_exception", error.path
-      assert_not_nil error.params[:stack_trace]
-      assert_not_nil error.params[:custom_params]
-    end
-
-    should "instrument_bg" do
-      run_background_job
-      stat_names = %w[OtherTransaction/Background/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/run_background_job
-                    OtherTransaction/Background/all
-                    OtherTransaction/all].sort
-
-      expected_but_missing = stat_names - @agent.stats_engine.metrics
-      assert_equal 0, expected_but_missing.size, @agent.stats_engine.metrics.map  { |n|
-        stat = @agent.stats_engine.get_stats_no_scope(n)
-      "#{'%-26s' % n}: #{stat.call_count} calls"
-      }.join("\n  ") + "\nmissing: #{expected_but_missing.inspect}"
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/all').call_count
-      assert_equal 1, @agent.stats_engine.get_stats_no_scope('OtherTransaction/Background/all').call_count
-    end
-  end
-
-  private
 
   def run_task_inner(n)
     return if n == 0
@@ -181,6 +32,139 @@ class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::Te
   add_transaction_tracer :run_task_exception
   add_transaction_tracer :run_task_inner, :name => 'inner_task_#{args[0]}'
   add_transaction_tracer :run_task_outer, :name => 'outer_task', :params => '{ :level => args[0] }'
-  # Eventually we need th change this to :category => :task
-  add_transaction_tracer :run_background_job, :category => 'OtherTransaction/Background'
+  add_transaction_tracer :run_background_job, :category => :task
+
+  def setup
+    @agent = NewRelic::Agent.instance
+    @agent.transaction_sampler.reset!
+    @agent.stats_engine.clear_stats
+  end
+
+  #
+  # Tests
+  #
+
+  def test_should_run
+    run_task_inner(0)
+    assert_metrics_recorded_exclusive([
+      'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
+      'Apdex/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
+      'HttpDispatcher',
+      'Apdex'
+    ])
+  end
+
+  def test_should_handle_single_recursive_invocation
+    run_task_inner(1)
+    assert_metrics_recorded_exclusive(
+      [
+        [
+          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
+          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1'
+        ],
+        'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
+        'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1'
+      ],
+      :filter => /^Controller/
+    )
+  end
+
+  def test_should_handle_recursive_task_invocations
+    run_task_inner(3)
+    assert_metrics_recorded_exclusive(
+      [
+        [
+          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
+          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1'
+        ],
+        [
+          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1',
+          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2'
+        ],
+        [
+          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2',
+          'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_3'
+        ],
+        'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0',
+        'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_1',
+        'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_2',
+        'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_3'
+      ],
+      :filter => /^Controller/
+    )
+  end
+
+  def test_should_handle_nested_task_invocations
+    run_task_outer(3)
+    assert_metrics_recorded({
+      'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task'   => { :call_count => 1 },
+      'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0' => { :call_count => 2 }
+    })
+  end
+
+  def test_transaction
+    run_task_outer(10)
+
+    assert_equal 0, @agent.transaction_sampler.scope_depth, "existing unfinished sample"
+    assert_metrics_recorded({
+      'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/outer_task'   => { :call_count => 1 },
+      'Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/inner_task_0' => { :call_count => 2 }
+    })
+    assert_metrics_not_recorded(['Controller'])
+
+    sample = @agent.transaction_sampler.last_sample
+    assert_not_nil(sample)
+    assert_not_nil(sample.params[:custom_params][:cpu_time], "cpu time nil: \n#{sample}")
+    assert((sample.params[:custom_params][:cpu_time] >= 0), "cpu time: #{sample.params[:cpu_time]},\n#{sample}")
+    assert_equal('10', sample.params[:request_params][:level])
+  end
+
+  def test_abort_transaction
+    perform_action_with_newrelic_trace(:name => 'hello', :force => true) do
+      self.class.inspect
+      NewRelic::Agent.abort_transaction!
+    end
+    # We record the controller metric still, but abort any transaction recording.
+    assert_metrics_recorded(['Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/hello'])
+    assert_nil(@agent.transaction_sampler.last_sample)
+  end
+
+  def test_perform_action_with_newrelic_trace_saves_params
+    account = 'Redrocks'
+    perform_action_with_newrelic_trace(:name => 'hello', :force => true,
+      :params => { :account => account }) do
+      self.class.inspect
+    end
+
+    assert_metrics_recorded(['Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/hello'])
+    sample = @agent.transaction_sampler.last_sample
+    assert_not_nil(sample)
+    assert_equal(account, sample.params[:request_params][:account])
+  end
+
+  def test_errors_are_noticed_and_not_swallowed
+    @agent.error_collector.expects(:notice_error).once
+    assert_raise(RuntimeError) { run_task_exception }
+  end
+
+  def test_error_collector_captures_custom_params
+    @agent.error_collector.harvest_errors([])
+    run_task_exception rescue nil
+    errors = @agent.error_collector.harvest_errors([])
+
+    assert_equal(1, errors.size)
+    error = errors.first
+    assert_equal("Controller/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/run_task_exception", error.path)
+    assert_not_nil(error.params[:stack_trace])
+    assert_not_nil(error.params[:custom_params])
+  end
+
+  def test_instrument_background_job
+    run_background_job
+    assert_metrics_recorded([
+      'OtherTransaction/Background/NewRelic::Agent::Instrumentation::TaskInstrumentationTest/run_background_job',
+      'OtherTransaction/Background/all',
+      'OtherTransaction/all'
+    ])
+  end
 end

data/test/new_relic/agent/method_tracer/instance_methods/trace_execution_scoped_test.rb

@@ -7,6 +7,10 @@ class NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScopedTest <
   require 'new_relic/agent/method_tracer'
   include NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScoped
 
+  def setup
+    NewRelic::Agent.agent.stats_engine.clear_stats
+  end
+
   def test_trace_disabled_negative
     self.expects(:traced?).returns(false)
     options = {:force => false}
@@ -51,36 +55,117 @@ class NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScopedTest <
     assert_equal NewRelic::Agent.instance, agent_instance
   end
 
-  def test_get_metric_specs_with_metric_option
-    first_name = 'foo'
-    other_names = ['bar', 'baz']
-    opts = {:metric => true}
+  def test_metric_recording_outside_transaction
+    trace_execution_scoped(['foo']) do
+      # meh
+    end
+    assert_metrics_recorded_exclusive(
+      'foo' => { :call_count => 1 }
+    )
+  end
 
-    specs = get_metric_specs(first_name, other_names, 'scope', opts)
+  def test_metric_recording_in_root_transaction
+    options = { :transaction => true }
+    self.stubs(:has_parent?).returns(false)
 
-    expected_specs = [
-      NewRelic::MetricSpec.new('foo', 'scope'),
-      NewRelic::MetricSpec.new('foo'),
-      NewRelic::MetricSpec.new('bar'),
-      NewRelic::MetricSpec.new('baz')
-    ]
+    in_transaction('outer') do
+      trace_execution_scoped(['foo', 'bar'], options) do
+        # erm
+      end
+    end
 
-    assert_equal(expected_specs.sort, specs.sort)
+    expected_values = { :call_count => 1 }
+    assert_metrics_recorded_exclusive(
+      'foo' => expected_values,
+      'bar' => expected_values
+    )
   end
 
-  def test_get_metric_stats_without_metric_option
-    first_name = 'foo'
-    other_names = ['bar', 'baz']
-    opts = {:metric => false}
+  def test_metric_recording_in_non_root_transaction
+    options = { :transaction => true }
+    self.stubs(:has_parent?).returns(true)
+    in_transaction('outer') do
+      in_transaction('inner') do
+        trace_execution_scoped(['inner', 'bar'], options) do
+          # erm
+        end
+      end
+    end
+
+    expected_values = { :call_count => 1 }
+    assert_metrics_recorded_exclusive(
+      'inner'            => expected_values,
+      ['inner', 'outer'] => expected_values,
+      'bar'              => expected_values
+    )
+  end
 
-    specs = get_metric_specs(first_name, other_names, 'scope', opts)
+  def test_metric_recording_in_root_non_transaction
+    options = { :transaction => false }
+    self.stubs(:has_parent?).returns(false)
 
-    expected_specs = [
-      NewRelic::MetricSpec.new('bar'),
-      NewRelic::MetricSpec.new('baz')
-    ]
+    in_transaction('outer') do
+      trace_execution_scoped(['foo', 'bar'], options) do
+        # erm
+      end
+    end
 
-    assert_equal(expected_specs.sort, specs.sort)
+    expected_values = { :call_count => 1 }
+    assert_metrics_recorded_exclusive(
+      'foo'            => expected_values,
+      ['foo', 'outer'] => expected_values,
+      'bar'            => expected_values
+    )
+  end
+
+  def test_metric_recording_in_non_root_non_transaction
+    options = { :transaction => false }
+    self.stubs(:has_parent?).returns(false)
+
+    in_transaction('outer') do
+      trace_execution_scoped(['foo', 'bar'], options) do
+        # erm
+      end
+    end
+
+    expected_values = { :call_count => 1 }
+    assert_metrics_recorded_exclusive(
+      'foo'            => expected_values,
+      ['foo', 'outer'] => expected_values,
+      'bar'            => expected_values
+    )
+  end
+
+  def test_metric_recording_without_metric_option
+    options = { :metric => false, :transaction => true }
+    self.stubs(:has_parent?).returns(false)
+
+    in_transaction('outer') do
+      trace_execution_scoped(['foo', 'bar'], options) do
+        # erm
+      end
+    end
+
+    expected_values = { :call_count => 1 }
+    assert_metrics_recorded_exclusive(
+      'bar' => expected_values
+    )
+  end
+
+  def test_metric_recording_with_scoped_metric_only_option
+    options = { :transaction => false, :scoped_metric_only => true }
+    self.stubs(:has_parent?).returns(false)
+
+    in_transaction('outer') do
+      trace_execution_scoped(['foo', 'bar'], options) do
+        # erm
+      end
+    end
+
+    expected_values = { :call_count => 1 }
+    assert_metrics_recorded_exclusive(
+      ['foo', 'outer'] => expected_values
+    )
   end
 
   def test_set_if_nil
@@ -116,7 +201,7 @@ class NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScopedTest <
 
   def test_log_errors_base
     ran = false
-    log_errors("name", "metric") do
+    log_errors("name") do
       ran = true
     end
     assert ran, "should run the contents of the block"
@@ -124,7 +209,7 @@ class NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScopedTest <
 
   def test_log_errors_with_return
     ran = false
-    return_val = log_errors('name', 'metric') do
+    return_val = log_errors('name') do
       ran = true
       'happy trees'
     end
@@ -135,41 +220,56 @@ class NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScopedTest <
 
   def test_log_errors_with_error
     expects_logging(:error, 
-      includes("Caught exception in name. Metric name = metric"),
+      includes("Caught exception in name."),
       instance_of(RuntimeError))
 
-    log_errors("name", "metric") do
+    log_errors("name") do
       raise "should not propagate out of block"
     end
   end
 
   def test_trace_execution_scoped_header
     options = {:force => false, :deduct_call_time_from_parent => false}
-    self.expects(:log_errors).with('trace_execution_scoped header', 'foo').yields
+    self.expects(:log_errors).with('trace_execution_scoped header').yields
     self.expects(:push_flag!).with(false)
     fakestats = mocked_object('stat_engine')
-    fakestats.expects(:push_scope).with('foo', 1.0, false)
-    trace_execution_scoped_header('foo', options, 1.0)
-  end
-
-  def test_trace_execution_scoped_footer
-    t0 = 1.0
-    t1 = 2.0
-    metric = 'foo'
-    metric_specs = [NewRelic::MetricSpec.new('foo'), NewRelic::MetricSpec.new('bar')]
-    stats = [NewRelic::Agent::Stats.new, NewRelic::Agent::Stats.new]
-    expected_scope = 'an expected scope'
-    engine = mocked_object('stat_engine')
-    scope = mock('scope')
-    engine.expects(:pop_scope).with('an expected scope', 1.0, 2.0).returns(scope)
-    engine.expects(:record_metrics).with(metric_specs).multiple_yields(*stats)
-    stats[0].expects(:record_data_point).with(1.0, 0.5)
-    stats[1].expects(:record_data_point).with(1.0, 0.5)
-    scope.expects(:children_time).returns(0.5)
-    self.expects(:pop_flag!).with(false)
-    self.expects(:log_errors).with('trace_method_execution footer', 'foo').yields
-
-    trace_execution_scoped_footer(t0, metric, metric_specs, expected_scope, false, t1)
+    fakestats.expects(:push_scope).with(:method_tracer, 1.0, false)
+    trace_execution_scoped_header(options, 1.0)
+  end
+
+  def test_trace_execution_scoped_calculates_exclusive_time
+    freeze_time
+    in_transaction('txn') do
+      trace_execution_scoped(['parent']) do
+        advance_time(10)
+        trace_execution_scoped(['child']) do
+          advance_time(10)
+        end
+      end
+    end
+
+    assert_metrics_recorded_exclusive(
+      'parent' => { :call_count => 1, :total_call_time => 20, :total_exclusive_time => 10 },
+      ['parent', 'txn'] => { :call_count => 1, :total_call_time => 20, :total_exclusive_time => 10 },
+      'child'  => { :call_count => 1, :total_call_time => 10, :total_exclusive_time => 10 },
+      ['child', 'txn']  => { :call_count => 1, :total_call_time => 10, :total_exclusive_time => 10 }
+    )
+  end
+
+  def test_force_flag_enables_metric_recording_in_ignored_transaction
+    NewRelic::Agent.instance.push_trace_execution_flag(false)
+    in_transaction('txn') do
+      trace_execution_scoped(['foo'], :force => true) do
+        # whatever, man
+      end
+    end
+
+    assert_metrics_recorded_exclusive(
+      'foo'          => { :call_count => 1 },
+      ['foo', 'txn'] => { :call_count => 1 }
+    )
+  ensure
+    NewRelic::Agent.instance.pop_trace_execution_flag()
   end
 
   def test_trace_execution_scoped_disabled
@@ -186,47 +286,19 @@ class NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScopedTest <
     assert_equal 1172, value, 'should return contents of block'
   end
 
-  def test_trace_execution_scoped_default
-    passed_in_opts = {}
-    opts_after_correction = {:metric => true, :deduct_call_time_from_parent => true}
-    specs = [
-      NewRelic::MetricSpec.new('metric'),
-      NewRelic::MetricSpec.new('array')
-    ]
-    self.expects(:trace_disabled?).returns(false)
-    self.expects(:get_metric_specs).with('metric', ['array'], nil, opts_after_correction).returns(specs)
-    self.expects(:trace_execution_scoped_header).with('metric', opts_after_correction).returns(['start_time', 'expected_scope'])
-    self.expects(:trace_execution_scoped_footer).with('start_time', 'metric', specs, 'expected_scope', nil)
-    ran = false
-    value = trace_execution_scoped(['metric', 'array'], passed_in_opts) do
-      ran = true
+  def test_trace_execution_scope_runs_passed_block_and_returns_its_value
+    value = trace_execution_scoped(['metric', 'array'], {}) do
       1172
     end
-
-    assert ran, 'should run contents of the block'
     assert_equal 1172, value, 'should return the contents of the block'
   end
 
-  def test_trace_execution_scoped_with_error
-    passed_in_opts = {}
-    opts_after_correction = {:metric => true, :deduct_call_time_from_parent => true}
-    specs = [
-      NewRelic::MetricSpec.new('metric'),
-      NewRelic::MetricSpec.new('array')
-    ]
-    self.expects(:trace_disabled?).returns(false)
-    self.expects(:get_metric_specs).with('metric', ['array'], nil, opts_after_correction).returns(specs)
-    self.expects(:trace_execution_scoped_header).with('metric', opts_after_correction).returns(['start_time', 'expected_scope'])
-    self.expects(:trace_execution_scoped_footer).with('start_time', 'metric', specs, 'expected_scope', nil)
-    ran = false
+  def test_trace_execution_scoped_does_not_swallow_errors
     assert_raises(RuntimeError) do
-      trace_execution_scoped(['metric', 'array'], passed_in_opts) do
-        ran = true
+      trace_execution_scoped(['metric', 'array'], {}) do
         raise 'raising a test error'
       end
     end
-
-    assert ran, 'should run contents of the block'
   end
 
   private