newrelic_rpm 3.8.1.221 → 3.9.0.229

data/test/new_relic/agent/transaction_interrobang_test.rb

@@ -25,7 +25,7 @@ class TransactionInterrobangTest < Minitest::Test
     assert_equal "say what?", interrogate?
   end
 
-  def test_aliase_method_ending_in_exclamation_makr
+  def test_alias_method_ending_in_exclamation_mark
     assert_respond_to self, :mutate!
     assert_respond_to self, :mutate_with_newrelic_transaction_trace!
     assert_equal "oh yeah!",mutate!

data/test/new_relic/agent/transaction_metrics_test.rb

@@ -0,0 +1,113 @@
+# 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/transaction_metrics'
+
+class TransactionMetricsTest < Minitest::Test
+  def setup
+    @metrics = NewRelic::Agent::TransactionMetrics.new
+  end
+
+  def test_record_scoped_should_record_a_scoped_metric
+    @metrics.record_scoped('foo', 42, 12)
+    assert_scoped_metrics(@metrics, ['foo'], {
+      :call_count           => 1,
+      :total_call_time      => 42,
+      :total_exclusive_time => 12
+    })
+    assert_unscoped_metrics(@metrics, [])
+  end
+
+  def test_record_scoped_should_take_multiple_metrics
+    @metrics.record_scoped(['foo', 'bar'], 42, 12)
+    assert_scoped_metrics(@metrics, ['foo', 'bar'], {
+      :call_count           => 1,
+      :total_call_time      => 42,
+      :total_exclusive_time => 12
+    })
+    assert_unscoped_metrics(@metrics, [])
+  end
+
+  def test_record_scoped_should_take_a_block
+    @metrics.record_scoped('foo') do |stats|
+      stats.call_count           = 3
+      stats.total_call_time      = 2
+      stats.total_exclusive_time = 1
+    end
+    assert_scoped_metrics(@metrics, ['foo'], {
+      :call_count           => 3,
+      :total_call_time      => 2,
+      :total_exclusive_time => 1
+    })
+    assert_unscoped_metrics(@metrics, [])
+  end
+
+  def test_record_unscoped_should_record_an_unscoped_metric
+    @metrics.record_unscoped('foo', 42, 12)
+    assert_unscoped_metrics(@metrics, ['foo'], {
+      :call_count           => 1,
+      :total_call_time      => 42,
+      :total_exclusive_time => 12
+    })
+    assert_scoped_metrics(@metrics, [])
+  end
+
+  def test_record_unscoped_should_take_multiple_metrics
+    @metrics.record_unscoped(['foo', 'bar'], 42, 12)
+    assert_unscoped_metrics(@metrics, ['foo', 'bar'], {
+      :call_count           => 1,
+      :total_call_time      => 42,
+      :total_exclusive_time => 12
+    })
+    assert_scoped_metrics(@metrics, [])
+  end
+
+  def test_record_unscoped_should_take_a_block
+    @metrics.record_unscoped('foo') do |stats|
+      stats.call_count           = 3
+      stats.total_call_time      = 2
+      stats.total_exclusive_time = 1
+    end
+    assert_unscoped_metrics(@metrics, ['foo'], {
+      :call_count           => 3,
+      :total_call_time      => 2,
+      :total_exclusive_time => 1
+    })
+    assert_scoped_metrics(@metrics, [])
+  end
+
+  def test_square_brackets_look_up_unscoped_metrics
+    @metrics.record_unscoped('foo', 42, 12)
+    @metrics.record_scoped('foo', 2, 1)
+    assert_equal(42, @metrics['foo'].total_call_time)
+  end
+
+  def test_has_key_checks_for_unscoped_metric_presence
+    refute @metrics.has_key?('foo')
+  end
+
+  def assert_unscoped_metrics(txn_metrics, expected_metric_names, expected_attrs={})
+    assert_scoped_or_unscoped_metrics(:unscoped, txn_metrics, expected_metric_names, expected_attrs)
+  end
+
+  def assert_scoped_metrics(txn_metrics, expected_metric_names, expected_attrs={})
+    assert_scoped_or_unscoped_metrics(:scoped, txn_metrics, expected_metric_names, expected_attrs)
+  end
+
+  def assert_scoped_or_unscoped_metrics(type, txn_metrics, expected_metric_names, expected_attrs)
+    names     = []
+    all_stats = []
+
+    txn_metrics.send("each_#{type}") do |name, stats|
+      names     << name
+      all_stats << stats
+    end
+
+    assert_equal(expected_metric_names.sort, names.sort)
+    names.zip(all_stats).each do |(name, stats)|
+      assert_stats_has_values(stats, name, expected_attrs)
+    end
+  end
+end

data/test/new_relic/agent/transaction_sample_builder_test.rb

@@ -61,66 +61,6 @@ class NewRelic::Agent::TransationSampleBuilderTest < Minitest::Test
     end
   end
 
-  # this is really a test for transaction sample
-  def test_omit_segments_with
-    build_segment "Controller/my_controller/index" do
-      advance_time 0.010
-
-      build_segment "Rails/Application Code Loading" do
-        advance_time 0.020
-
-        build_segment "foo/bar" do
-          advance_time 0.010
-        end
-      end
-
-      build_segment "a" do
-        build_segment "ab"
-        advance_time 0.010
-      end
-      build_segment "b" do
-        build_segment "ba"
-        advance_time 0.05
-        build_segment "bb"
-        build_segment "bc" do
-          build_segment "bca"
-          advance_time 0.05
-        end
-      end
-      build_segment "c"
-    end
-    @builder.finish_trace(Time.now.to_f)
-
-    validate_builder false
-
-    sample = @builder.sample
-
-    should_be_a_copy = sample.omit_segments_with('OMIT NOTHING')
-    validate_segment should_be_a_copy.root_segment, false
-
-    assert_equal sample.params, should_be_a_copy.params
-    assert_equal(sample.root_segment.to_debug_str(0),
-                 should_be_a_copy.root_segment.to_debug_str(0))
-
-    without_code_loading = sample.omit_segments_with('Rails/Application Code Loading')
-    validate_segment without_code_loading.root_segment, false
-
-    # after we take out code loading, the delta should be approximately
-    # 30 milliseconds
-    delta = (sample.duration - without_code_loading.duration) * 1000
-
-    # Need to allow substantial headroom on the upper bound to prevent
-    # spurious errors.
-    assert delta >= 28, "delta #{delta} should be between 28 and 100"
-    # disable this test for a couple days:
-    assert delta <= 100, "delta #{delta} should be between 28 and 100"
-
-    # ensure none of the segments have this regex
-    without_code_loading.each_segment do |segment|
-      assert_nil segment.metric_name =~ /Rails\/Application Code Loading/
-    end
-  end
-
   def test_marshal
     build_segment "a" do
       build_segment "ab"
@@ -239,7 +179,7 @@ class NewRelic::Agent::TransationSampleBuilderTest < Minitest::Test
 
     in_transaction do
       with_config(config, :do_not_cast => true) do
-        NewRelic::Agent::TransactionState.get.current_transaction.stubs(:apdex_t).returns(1.5)
+        NewRelic::Agent::TransactionState.tl_get.current_transaction.stubs(:apdex_t).returns(1.5)
         assert_equal 4.0, @builder.transaction_trace_threshold
       end
     end

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -26,7 +26,8 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
   end
 
   def setup
-    NewRelic::Agent::TransactionState.clear
+    NewRelic::Agent::TransactionState.tl_clear_for_testing
+    @state = NewRelic::Agent::TransactionState.tl_get
     agent = NewRelic::Agent.instance
     stats_engine = NewRelic::Agent::StatsEngine.new
     agent.stubs(:stats_engine).returns(stats_engine)
@@ -34,13 +35,14 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
     @old_sampler = NewRelic::Agent.instance.transaction_sampler
     NewRelic::Agent.instance.instance_variable_set(:@transaction_sampler, @sampler)
     @test_config = { :'transaction_tracer.enabled' => true }
-    NewRelic::Agent.config.apply_config(@test_config)
-    @txn = stub('txn', :best_name => '/path', :custom_parameters => {}, :guid => 'a guid')
+    NewRelic::Agent.config.add_config_for_testing(@test_config)
+    @txn = stub('txn', :best_name => '/path', :guid => 'a guid',
+                :custom_parameters => {}, :filtered_params => {})
   end
 
   def teardown
     super
-    NewRelic::Agent::TransactionState.clear
+    NewRelic::Agent::TransactionState.tl_clear_for_testing
     NewRelic::Agent.config.remove_config(@test_config)
     NewRelic::Agent.instance.instance_variable_set(:@transaction_sampler, @old_sampler)
   end
@@ -63,165 +65,111 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
   # Tests
 
   def test_on_start_transaction_default
-    @sampler.expects(:start_builder).with(100.0)
-    @sampler.on_start_transaction(Time.at(100))
+    @sampler.expects(:start_builder).with(@state, 100.0)
+    @sampler.on_start_transaction(@state, Time.at(100))
   end
 
   def test_on_start_transaction_disabled
     with_config(:'transaction_tracer.enabled' => false,
                 :developer_mode => false) do
       @sampler.expects(:start_builder).never
-      @sampler.on_start_transaction(Time.at(100))
+      @sampler.on_start_transaction(@state, Time.at(100))
     end
   end
 
   def test_notice_push_frame_no_builder
-    @sampler.expects(:builder)
-    assert_equal(nil, @sampler.notice_push_frame())
-  end
-
-  def test_notice_push_frame_with_builder
-    with_config(:developer_mode => false) do
-      builder = mock('builder')
-      builder.expects(:trace_entry).with(100.0)
-      @sampler.expects(:builder).returns(builder).twice
-      @sampler.notice_push_frame(Time.at(100))
-    end
+    assert_equal(nil, @sampler.notice_push_frame(@state))
   end
 
   def test_notice_pop_frame_no_builder
-    @sampler.expects(:builder).returns(nil)
-    assert_equal(nil, @sampler.notice_pop_frame('a frame', Time.at(100)))
+    assert_equal(nil, @sampler.notice_pop_frame(@state, 'a frame', Time.at(100)))
   end
 
   def test_notice_pop_frame_with_finished_sample
     builder = mock('builder')
-    sample = mock('sample')
+    sample  = mock('sample')
     builder.expects(:sample).returns(sample)
     sample.expects(:finished).returns(true)
-    @sampler.expects(:builder).returns(builder).twice
+    @state.expects(:transaction_sample_builder).returns(builder)
 
     assert_raises(RuntimeError) do
-      @sampler.notice_pop_frame('a frame', Time.at(100))
+      @sampler.notice_pop_frame(@state, 'a frame', Time.at(100))
     end
   end
 
-  def test_notice_pop_frame_builder_delegation
-    builder = mock('builder')
-    builder.expects(:trace_exit).with('a frame', 100.0)
-    sample = mock('sample')
-    builder.expects(:sample).returns(sample)
-    sample.expects(:finished).returns(false)
-    @sampler.expects(:builder).returns(builder).times(3)
-
-    @sampler.notice_pop_frame('a frame', Time.at(100))
-  end
-
   def test_on_finishing_transaction_no_builder
-    @sampler.expects(:builder).returns(nil)
-    assert_equal(nil, @sampler.on_finishing_transaction(@txn))
-  end
-
-  def test_on_finishing_transaction_ignored_transaction
-    builder = mock('builder')
-    # the builder should be cached, so only called once
-    @sampler.expects(:builder).returns(builder).once
-
-    builder.expects(:finish_trace).with(100.0, {})
-
-    @sampler.expects(:clear_builder)
-
-    builder.expects(:ignored?).returns(true)
-    builder.expects(:set_transaction_name).returns(true)
-
-    assert_equal(nil, @sampler.on_finishing_transaction(@txn, Time.at(100)))
+    @state.transaction_sample_builder = nil
+    assert_equal(nil, @sampler.on_finishing_transaction(@state, @txn))
   end
 
-  def test_on_finishing_transaction_with_builder
-    builder = mock('builder')
-    @sampler.stubs(:builder).returns(builder)
-
-    builder.expects(:finish_trace).with(100.0, {})
-    @sampler.expects(:clear_builder)
-
-    builder.expects(:ignored?).returns(false)
-    builder.expects(:set_transaction_info).returns(true)
-    builder.expects(:set_transaction_name).returns(true)
-
-    sample = mock('sample')
-    sample.expects(:guid=)
-    builder.expects(:sample).returns(sample)
-    @sampler.expects(:store_sample).with(sample)
-
-    @sampler.on_start_transaction(Time.now, nil, {})
-    @sampler.on_finishing_transaction(@txn, Time.at(100))
+  def test_captures_correct_transaction_duration
+    freeze_time
+    in_transaction do |txn|
+      advance_time(10.0)
+    end
 
-    assert_equal(sample, @sampler.instance_variable_get('@last_sample'))
+    assert_equal(10.0, @sampler.last_sample.duration)
   end
 
   def test_on_finishing_transaction_passes_guid_along
-    builder = stub_everything('builder')
-    @sampler.stubs(:builder).returns(builder)
-
-    @txn.stubs(:guid).returns('a guid')
-
-    sample = stub_everything('sample')
-    sample.expects(:guid=).with(@txn.guid)
-    builder.stubs(:sample).returns(sample)
+    in_transaction do |txn|
+      txn.stubs(:guid).returns('a guid')
+    end
 
-    @sampler.on_start_transaction(Time.now, nil, {})
-    @sampler.on_finishing_transaction(@txn, Time.at(100))
+    assert_equal('a guid', @sampler.last_sample.guid)
   end
 
   def test_ignore_transaction_no_builder
-    @sampler.expects(:builder).returns(nil).once
-    @sampler.ignore_transaction
+    ret = @sampler.ignore_transaction(@state)
+    assert_nil ret
   end
 
   def test_ignore_transaction_with_builder
-    builder = mock('builder')
-    builder.expects(:ignore_transaction)
-    @sampler.expects(:builder).returns(builder).twice
-    @sampler.ignore_transaction
+    in_transaction do
+      @sampler.ignore_transaction(@state)
+    end
+
+    assert_nil(@sampler.last_sample)
   end
 
-  def test_notice_transaction_cpu_time_no_builder
-    @sampler.expects(:builder).returns(nil).once
-    @sampler.notice_transaction_cpu_time(0.0)
+  def test_notice_transaction_cpu_time_no_builder_does_not_crash
+    @state.transaction_sample_builder = nil
+    @sampler.notice_transaction_cpu_time(@state, 0.0)
   end
 
-  def test_notice_transaction_cpu_time_with_builder
-    cpu_time = mock('cpu_time')
-    builder = mock('builder')
-    @sampler.expects(:builder).returns(builder).twice
-    builder.expects(:set_transaction_cpu_time).with(cpu_time)
+  def test_records_cpu_time_on_transaction_samples
+    in_transaction do |txn|
+      txn.stubs(:cpu_burn).returns(42)
+    end
 
-    @sampler.notice_transaction_cpu_time(cpu_time)
+    assert_equal(42, @sampler.last_sample.params[:custom_params][:cpu_time])
   end
 
   def test_notice_extra_data_no_builder
-    @sampler.expects(:builder).returns(nil).once
-    @sampler.send(:notice_extra_data, nil, nil, nil)
+    ret = @sampler.send(:notice_extra_data, nil, nil, nil, nil)
+    assert_nil ret
   end
 
   def test_notice_extra_data_no_segment
-    builder = mock('builder')
-    @sampler.expects(:builder).returns(builder).twice
-    builder.expects(:current_segment).returns(nil)
-    @sampler.send(:notice_extra_data, nil, nil, nil)
+    mock_builder = mock('builder')
+    @sampler.expects(:tl_builder).returns(mock_builder).once
+    mock_builder.expects(:current_segment).returns(nil)
+    builder = @sampler.tl_builder
+    @sampler.send(:notice_extra_data, builder, nil, nil, nil)
   end
 
   def test_notice_extra_data_with_segment_no_old_message_no_config_key
     key = :a_key
-    builder = mock('builder')
+    mock_builder = mock('builder')
     segment = mock('segment')
-    @sampler.expects(:builder).returns(builder).twice
-    builder.expects(:current_segment).returns(segment)
+    @sampler.expects(:tl_builder).returns(mock_builder).once
+    mock_builder.expects(:current_segment).returns(segment)
     NewRelic::Agent::TransactionSampler.expects(:truncate_message) \
       .with('a message').returns('truncated_message')
     segment.expects(:[]=).with(key, 'truncated_message')
     @sampler.expects(:append_backtrace).with(segment, 1.0)
-    @sampler.send(:notice_extra_data, 'a message', 1.0, key)
+    builder = @sampler.tl_builder
+    @sampler.send(:notice_extra_data, builder, 'a message', 1.0, key)
   end
 
   def test_append_backtrace_under_duration
@@ -243,24 +191,28 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
   end
 
   def test_notice_sql_recording_sql
-    NewRelic::Agent::TransactionState.get.record_sql = true
-    @sampler.expects(:notice_extra_data).with('some sql', 1.0, :sql)
-    @sampler.notice_sql('some sql', {:config => 'a config'}, 1.0)
+    @state.record_sql = true
+    builder = @sampler.tl_builder
+    @sampler.expects(:notice_extra_data).with(builder, 'some sql', 1.0, :sql)
+    @sampler.notice_sql('some sql', {:config => 'a config'}, 1.0, @state)
   end
 
   def test_notice_sql_not_recording
-    NewRelic::Agent::TransactionState.get.record_sql = false
-    @sampler.expects(:notice_extra_data).with('some sql', 1.0, :sql).never # <--- important
-    @sampler.notice_sql('some sql', {:config => 'a config'}, 1.0)
+    @state.record_sql = false
+    builder = @sampler.tl_builder
+    @sampler.expects(:notice_extra_data).with(builder, 'some sql', 1.0, :sql).never # <--- important
+    @sampler.notice_sql('some sql', {:config => 'a config'}, 1.0, @state)
   end
 
   def test_notice_nosql
-    @sampler.expects(:notice_extra_data).with('a key', 1.0, :key)
+    builder = @sampler.tl_builder
+    @sampler.expects(:notice_extra_data).with(builder, 'a key', 1.0, :key)
     @sampler.notice_nosql('a key', 1.0)
   end
 
   def test_notice_nosql_statement
-    @sampler.expects(:notice_extra_data).with('query data', 1.0, :statement)
+    builder = @sampler.tl_builder
+    @sampler.expects(:notice_extra_data).with(builder, 'query data', 1.0, :statement)
     @sampler.notice_nosql_statement('query data', 1.0)
   end
 
@@ -450,42 +402,36 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
   end
 
   def test_start_builder_default
-    NewRelic::Agent.expects(:is_execution_traced?).returns(true)
-    @sampler.send(:start_builder)
-    assert(NewRelic::Agent::TransactionState.get.transaction_sample_builder \
-             .is_a?(NewRelic::Agent::TransactionSampleBuilder),
+    @state.expects(:is_execution_traced?).returns(true)
+    @sampler.send(:start_builder, @state)
+    assert(@state.transaction_sample_builder.is_a?(NewRelic::Agent::TransactionSampleBuilder),
            "should set up a new builder by default")
   end
 
   def test_start_builder_disabled
-    NewRelic::Agent::TransactionState.get.transaction_sample_builder = 'not nil.'
+    @state.transaction_sample_builder = 'not nil.'
     with_config(:'transaction_tracer.enabled' => false,
                 :developer_mode => false) do
-      @sampler.send(:start_builder)
-      assert_equal(nil, NewRelic::Agent::TransactionState.get.transaction_sample_builder,
+      @sampler.send(:start_builder, @state)
+      assert_equal(nil, @state.transaction_sample_builder,
                    "should clear the transaction builder when disabled")
     end
   end
 
   def test_start_builder_dont_replace_existing_builder
     fake_builder = mock('transaction sample builder')
-    NewRelic::Agent::TransactionState.get.transaction_sample_builder = fake_builder
-    @sampler.send(:start_builder)
-    assert_equal(fake_builder, NewRelic::Agent::TransactionState.get.transaction_sample_builder,
+    @state.transaction_sample_builder = fake_builder
+    @sampler.send(:start_builder, @state)
+    assert_equal(fake_builder, @state.transaction_sample_builder,
                  "should not overwrite an existing transaction sample builder")
-    NewRelic::Agent::TransactionState.get.transaction_sample_builder = nil
+    @state.transaction_sample_builder = nil
   end
 
   def test_builder
-    NewRelic::Agent::TransactionState.get.transaction_sample_builder = 'shamalamadingdong, brother.'
-    assert_equal('shamalamadingdong, brother.', @sampler.send(:builder),
+    @state.transaction_sample_builder = 'shamalamadingdong, brother.'
+    assert_equal('shamalamadingdong, brother.', @sampler.send(:tl_builder),
                  'should return the value from the thread local variable')
-    NewRelic::Agent::TransactionState.get.transaction_sample_builder = nil
-  end
-
-  def test_clear_builder
-    NewRelic::Agent::TransactionState.get.transaction_sample_builder = 'shamalamadingdong, brother.'
-    assert_equal(nil, @sampler.send(:clear_builder), 'should clear the thread local variable')
+    @state.transaction_sample_builder = nil
   end
 
   # Tests below this line are functional tests for the sampler, not
@@ -495,19 +441,19 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
 
   def test_sample_tree
     with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
-      @sampler.on_start_transaction(Time.now, nil, {})
-      @sampler.notice_push_frame
+      @sampler.on_start_transaction(@state, Time.now, nil)
+      @sampler.notice_push_frame(@state)
 
-      @sampler.notice_push_frame
-      @sampler.notice_pop_frame "b"
+      @sampler.notice_push_frame(@state)
+      @sampler.notice_pop_frame(@state, "b")
 
-      @sampler.notice_push_frame
-      @sampler.notice_push_frame
-      @sampler.notice_pop_frame "d"
-      @sampler.notice_pop_frame "c"
+      @sampler.notice_push_frame(@state)
+      @sampler.notice_push_frame(@state)
+      @sampler.notice_pop_frame(@state, "d")
+      @sampler.notice_pop_frame(@state, "c")
 
-      @sampler.notice_pop_frame "a"
-      @sampler.on_finishing_transaction(@txn)
+      @sampler.notice_pop_frame(@state, "a")
+      @sampler.on_finishing_transaction(@state, @txn)
       sample = @sampler.harvest!.first
       assert_equal "ROOT{a{b,c{d}}}", sample.to_s_compact
     end
@@ -520,19 +466,19 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
     MockGCStats.mock_values = [0,0,0,1,0,0,1,0,0,0,0,0,0,0,0]
 
     with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
-      @sampler.on_start_transaction(Time.now, nil, {})
-      @sampler.notice_push_frame
+      @sampler.on_start_transaction(@state, Time.now, nil)
+      @sampler.notice_push_frame(@state)
 
-      @sampler.notice_push_frame
-      @sampler.notice_pop_frame "b"
+      @sampler.notice_push_frame(@state)
+      @sampler.notice_pop_frame(@state, "b")
 
-      @sampler.notice_push_frame
-      @sampler.notice_push_frame
-      @sampler.notice_pop_frame "d"
-      @sampler.notice_pop_frame "c"
+      @sampler.notice_push_frame(@state)
+      @sampler.notice_push_frame(@state)
+      @sampler.notice_pop_frame(@state, "d")
+      @sampler.notice_pop_frame(@state, "c")
 
-      @sampler.notice_pop_frame "a"
-      @sampler.on_finishing_transaction(@txn)
+      @sampler.notice_pop_frame(@state, "a")
+      @sampler.on_finishing_transaction(@state, @txn)
 
       sample = @sampler.harvest!.first
       assert_equal "ROOT{a{b,c{d}}}", sample.to_s_compact
@@ -589,36 +535,37 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
     threads = []
 
     5.times do
-      t = Thread.new(@sampler) do |the_sampler|
-        @sampler = the_sampler
+      threads << Thread.new do
         10.times do
-          run_sample_trace { sleep 0.0001 }
+          # Important that this uses the actual thread-local, not the shared
+          # @state variable used in other non-threaded tests
+          run_sample_trace(Time.now.to_f, nil, NewRelic::Agent::TransactionState.tl_get) do
+            sleep 0.0001
+          end
         end
       end
-
-      threads << t
     end
     threads.each {|t| t.join }
   end
 
   def test_sample_with_parallel_paths
     with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
-      @sampler.on_start_transaction(Time.now, nil, {})
-      @sampler.notice_push_frame
+      @sampler.on_start_transaction(@state, Time.now, nil)
+      @sampler.notice_push_frame(@state)
 
-      assert_equal 1, @sampler.builder.scope_depth
+      assert_equal 1, @sampler.tl_builder.scope_depth
 
-      @sampler.notice_pop_frame "a"
-      @sampler.on_finishing_transaction(@txn)
+      @sampler.notice_pop_frame(@state, "a")
+      @sampler.on_finishing_transaction(@state, @txn)
 
-      assert_nil @sampler.builder
+      assert_nil @sampler.tl_builder
 
-      @sampler.on_start_transaction(Time.now, nil, {})
-      @sampler.notice_push_frame
-      @sampler.notice_pop_frame "a"
-      @sampler.on_finishing_transaction(@txn)
+      @sampler.on_start_transaction(@state, Time.now, nil)
+      @sampler.notice_push_frame(@state)
+      @sampler.notice_pop_frame(@state, "a")
+      @sampler.on_finishing_transaction(@state, @txn)
 
-      assert_nil @sampler.builder
+      assert_nil @sampler.tl_builder
 
       assert_equal "ROOT{a}", @sampler.last_sample.to_s_compact
     end
@@ -626,13 +573,13 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
 
   def test_double_traced_method_stack_empty
     with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
-      @sampler.on_start_transaction(Time.now, nil, {})
-      @sampler.notice_push_frame
-      @sampler.notice_pop_frame "a"
-      @sampler.on_finishing_transaction(@txn)
-      @sampler.on_finishing_transaction(@txn)
-      @sampler.on_finishing_transaction(@txn)
-      @sampler.on_finishing_transaction(@txn)
+      @sampler.on_start_transaction(@state, Time.now, nil)
+      @sampler.notice_push_frame(@state)
+      @sampler.notice_pop_frame(@state, "a")
+      @sampler.on_finishing_transaction(@state, @txn)
+      @sampler.on_finishing_transaction(@state, @txn)
+      @sampler.on_finishing_transaction(@state, @txn)
+      @sampler.on_finishing_transaction(@state, @txn)
 
       refute_nil @sampler.harvest![0]
     end
@@ -640,22 +587,22 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
 
 
   def test_record_sql_off
-    @sampler.on_start_transaction Time.now.to_f
+    @sampler.on_start_transaction(@state, Time.now.to_f)
 
-    NewRelic::Agent::TransactionState.get.record_sql = false
+    @state.record_sql = false
 
-    @sampler.notice_sql("test", {}, 0)
+    @sampler.notice_sql("test", {}, 0, @state)
 
-    segment = @sampler.send(:builder).current_segment
+    segment = @sampler.send(:tl_builder).current_segment
 
     assert_nil segment[:sql]
   end
 
   def test_stack_trace_sql
     with_config(:'transaction_tracer.stack_trace_threshold' => 0) do
-      @sampler.on_start_transaction Time.now.to_f
-      @sampler.notice_sql("test", {}, 1)
-      segment = @sampler.send(:builder).current_segment
+      @sampler.on_start_transaction(@state, Time.now.to_f)
+      @sampler.notice_sql("test", {}, 1, @state)
+      segment = @sampler.send(:tl_builder).current_segment
 
       assert segment[:sql]
       assert segment[:backtrace]
@@ -665,19 +612,19 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
   def test_stack_trace_scope
     with_config(:'transaction_tracer.stack_trace_threshold' => 0) do
       t = Time.now
-      @sampler.on_start_transaction t.to_f
-      @sampler.notice_push_frame((t+1).to_f)
+      @sampler.on_start_transaction(@state, t.to_f)
+      @sampler.notice_push_frame(@state, (t+1).to_f)
 
-      segment = @sampler.send(:builder).current_segment
+      segment = @sampler.send(:tl_builder).current_segment
       assert segment[:backtrace]
     end
   end
 
   def test_nil_stacktrace
     with_config(:'transaction_tracer.stack_trace_threshold' => 2) do
-      @sampler.on_start_transaction Time.now.to_f
-      @sampler.notice_sql("test", {}, 1)
-      segment = @sampler.send(:builder).current_segment
+      @sampler.on_start_transaction(@state, Time.now.to_f)
+      @sampler.notice_sql("test", {}, 1, @state)
+      segment = @sampler.send(:tl_builder).current_segment
 
       assert segment[:sql]
       assert_nil segment[:backtrace]
@@ -685,17 +632,17 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
   end
 
   def test_big_sql
-    @sampler.on_start_transaction Time.now.to_f
+    @sampler.on_start_transaction(@state, Time.now.to_f)
 
     sql = "SADJKHASDHASD KAJSDH ASKDH ASKDHASDK JASHD KASJDH ASKDJHSAKDJHAS DKJHSADKJSAH DKJASHD SAKJDH SAKDJHS"
 
     len = 0
     while len <= 16384
-      @sampler.notice_sql(sql, {}, 0)
+      @sampler.notice_sql(sql, {}, 0, @state)
       len += sql.length
     end
 
-    segment = @sampler.send(:builder).current_segment
+    segment = @sampler.send(:tl_builder).current_segment
 
     sql = segment[:sql]
 
@@ -703,26 +650,27 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
   end
 
   def test_segment_obfuscated
-    @sampler.on_start_transaction Time.now.to_f
-    @sampler.notice_push_frame
+    @sampler.on_start_transaction(@state, Time.now.to_f)
+    @sampler.notice_push_frame(@state)
 
     orig_sql = "SELECT * from Jim where id=66"
 
-    @sampler.notice_sql(orig_sql, {}, 0)
+    @sampler.notice_sql(orig_sql, {}, 0, @state)
 
-    segment = @sampler.send(:builder).current_segment
+    segment = @sampler.send(:tl_builder).current_segment
 
     assert_equal orig_sql, segment[:sql]
     assert_equal "SELECT * from Jim where id=?", segment.obfuscated_sql
-    @sampler.notice_pop_frame "foo"
+    @sampler.notice_pop_frame(@state, "foo")
   end
 
   def test_param_capture
     [true, false].each do |capture|
       with_config(:capture_params => capture) do
         tt = with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
-          @sampler.on_start_transaction(Time.now, nil, :param => 'hi')
-          @sampler.on_finishing_transaction(@txn)
+          @sampler.on_start_transaction(@state, Time.now, nil)
+          @txn.filtered_params[:param] = 'hi'
+          @sampler.on_finishing_transaction(@state, @txn)
           @sampler.harvest![0]
         end
 
@@ -734,12 +682,12 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
   def test_should_not_collect_segments_beyond_limit
     with_config(:'transaction_tracer.limit_segments' => 3) do
       run_sample_trace do
-        @sampler.notice_push_frame
-        @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'challah'", {}, 0)
-        @sampler.notice_push_frame
-        @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'semolina'", {}, 0)
-        @sampler.notice_pop_frame "a11"
-        @sampler.notice_pop_frame "a1"
+        @sampler.notice_push_frame(@state)
+        @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'challah'", {}, 0, @state)
+        @sampler.notice_push_frame(@state)
+        @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'semolina'", {}, 0, @state)
+        @sampler.notice_pop_frame(@state, "a11")
+        @sampler.notice_pop_frame(@state, "a1")
       end
       assert_equal 3, @sampler.last_sample.count_segments
 
@@ -751,17 +699,17 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
   end
 
   def test_renaming_current_segment_midflight
-    @sampler.start_builder
-    segment = @sampler.notice_push_frame
+    @sampler.start_builder(@state)
+    segment = @sampler.notice_push_frame(@state)
     segment.metric_name = 'External/www.google.com/Net::HTTP/GET'
-    @sampler.notice_pop_frame( 'External/www.google.com/Net::HTTP/GET' )
+    @sampler.notice_pop_frame(@state, 'External/www.google.com/Net::HTTP/GET')
   end
 
   def test_adding_segment_parameters
-    @sampler.start_builder
-    @sampler.notice_push_frame
-    @sampler.add_segment_parameters( :transaction_guid => '97612F92E6194080' )
-    assert_equal '97612F92E6194080', @sampler.builder.current_segment[:transaction_guid]
+    @sampler.start_builder(@state)
+    @sampler.notice_push_frame(@state)
+    @sampler.add_segment_parameters(:transaction_guid => '97612F92E6194080')
+    assert_equal '97612F92E6194080', @sampler.tl_builder.current_segment[:transaction_guid]
   end
 
   def test_large_transaction_trace_harvest
@@ -840,7 +788,7 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
     include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
     def run(n)
       n.times do
-        perform_action_with_newrelic_trace("smile") do
+        perform_action_with_newrelic_trace(:name => 'smile') do
         end
       end
     end
@@ -902,27 +850,27 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
   end
 
   def run_long_sample_trace(n)
-    @sampler.on_start_transaction(Time.now, nil, {})
+    @sampler.on_start_transaction(@state, Time.now, nil)
     n.times do |i|
-      @sampler.notice_push_frame
+      @sampler.notice_push_frame(@state)
       yield if block_given?
-      @sampler.notice_pop_frame "node#{i}"
+      @sampler.notice_pop_frame(@state, "node#{i}")
     end
-    @sampler.on_finishing_transaction(@txn, Time.now.to_f)
+    @sampler.on_finishing_transaction(@state, @txn, Time.now.to_f)
   end
 
-  def run_sample_trace(start = Time.now.to_f, stop = nil)
-    @sampler.on_start_transaction(start, nil, {})
-    @sampler.notice_push_frame
-    @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'wheat'", {}, 0)
-    @sampler.notice_push_frame
-    @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'white'", {}, 0)
+  def run_sample_trace(start = Time.now.to_f, stop = nil, state = @state)
+    @sampler.on_start_transaction(state, start, nil)
+    @sampler.notice_push_frame(state)
+    @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'wheat'", {}, 0, state)
+    @sampler.notice_push_frame(state)
+    @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'white'", {}, 0, state)
     yield if block_given?
-    @sampler.notice_pop_frame "ab"
-    @sampler.notice_push_frame
-    @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'french'", {}, 0)
-    @sampler.notice_pop_frame "ac"
-    @sampler.notice_pop_frame "a"
-    @sampler.on_finishing_transaction(@txn, (stop || Time.now.to_f))
+    @sampler.notice_pop_frame(state, "ab")
+    @sampler.notice_push_frame(state)
+    @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'french'", {}, 0, state)
+    @sampler.notice_pop_frame(state, "ac")
+    @sampler.notice_pop_frame(state, "a")
+    @sampler.on_finishing_transaction(state, @txn, (stop || Time.now.to_f))
   end
 end