newrelic_rpm 3.8.1.221 → 3.9.0.229

data/test/new_relic/agent/stats_engine_test.rb

@@ -23,7 +23,7 @@ class NewRelic::Agent::StatsEngineTest < Minitest::Test
 
   def populate_container(engine, n)
     n.times do |i|
-      engine.record_metrics("metric#{i}", i)
+      engine.tl_record_unscoped_metrics("metric#{i}", i)
     end
   end
 

data/test/new_relic/agent/stats_hash_test.rb

@@ -98,7 +98,7 @@ class NewRelic::Agent::StatsHashTest < Minitest::Test
     hash2 = NewRelic::Agent::StatsHash.new
     hash2.record(specs[0], 1)
     hash2.record(specs[1], 2)
-    hash2.record(specs[3], 3) # no scope
+    hash2.record(specs[3], 3)
 
     hash1.merge!(hash2)
 
@@ -120,6 +120,33 @@ class NewRelic::Agent::StatsHashTest < Minitest::Test
     assert_equal(t0.to_f, hash1.started_at)
   end
 
+  def test_merge_transaction_metrics
+    specs = [
+      NewRelic::MetricSpec.new('foo'),
+      NewRelic::MetricSpec.new('bar'),
+      NewRelic::MetricSpec.new('baz'),
+      NewRelic::MetricSpec.new('baz', 'a_scope')
+    ]
+
+    hash = NewRelic::Agent::StatsHash.new
+    hash.record(specs[0], 1)
+    hash.record(specs[1], 2)
+    hash.record(specs[2], 3)
+
+    txn_metrics = NewRelic::Agent::TransactionMetrics.new
+    txn_metrics.record_unscoped(specs[0].name, 1)
+    txn_metrics.record_unscoped(specs[1].name, 2)
+    txn_metrics.record_scoped(specs[3].name, 3)
+
+    hash.merge_transaction_metrics!(txn_metrics, 'a_scope')
+
+    assert_equal(4, hash.keys.size)
+    assert_equal(2, hash[specs[0]].call_count)
+    assert_equal(2, hash[specs[1]].call_count)
+    assert_equal(1, hash[specs[2]].call_count)
+    assert_equal(1, hash[specs[3]].call_count)
+  end
+
   def test_marshal_dump
     @hash.record('foo', 1)
     @hash.record('bar', 2)

data/test/new_relic/agent/stats_test.rb

@@ -61,7 +61,7 @@ class NewRelic::Agent::StatsTest < Minitest::Test
   def test_to_s
     s1 = NewRelic::Agent::Stats.new
     s1.trace_call 10
-    assert_equal("[ 1 calls 10.0000s]", s1.to_s)
+    assert_equal("[ 1 calls 10.0000s / 10.0000s ex]", s1.to_s)
   end
 
   def test_apdex_recording
@@ -117,17 +117,6 @@ class NewRelic::Agent::StatsTest < Minitest::Test
     validate s2, 1, 20, 20, 20, 10
   end
 
-  def test_merge_array
-    s1 = NewRelic::Agent::Stats.new
-    merges = []
-    merges << (NewRelic::Agent::Stats.new.trace_call 1)
-    merges << (NewRelic::Agent::Stats.new.trace_call 1)
-    merges << (NewRelic::Agent::Stats.new.trace_call 1)
-
-    s1.merge! merges
-    validate s1, 3, 3, 1, 1
-  end
-
   def test_freeze
     s1 = NewRelic::Agent::Stats.new
 

data/test/new_relic/agent/threading/agent_thread_test.rb

@@ -9,18 +9,21 @@ module NewRelic::Agent::Threading
   class AgentThreadTest < Minitest::Test
 
     def test_sets_label
-      t = AgentThread.new("labelled") {}
+      t = AgentThread.create("labelled") {}
       assert_equal "labelled", t[:newrelic_label]
+      t.join
     end
 
     def test_bucket_thread_as_agent_when_profiling
-      t = AgentThread.new("labelled") {}
+      t = AgentThread.create("labelled") {}
       assert_equal :agent, AgentThread.bucket_thread(t, true)
+      t.join
     end
 
     def test_bucket_thread_as_agent_when_not_profiling
-      t = AgentThread.new("labelled") {}
+      t = AgentThread.create("labelled") {}
       assert_equal :ignore, AgentThread.bucket_thread(t, false)
+      t.join
     end
 
     def test_bucket_thread_as_request
@@ -28,10 +31,15 @@ module NewRelic::Agent::Threading
       q1 = Queue.new
 
       t = Thread.new do
-        in_transaction do |txn|
-          txn.request = 'whatever'
+        begin
+          in_transaction do |txn|
+            txn.request = 'whatever'
+            q0.push 'unblock main thread'
+            q1.pop
+          end
+        rescue => e
           q0.push 'unblock main thread'
-          q1.pop
+          fail e
         end
       end
 
@@ -47,9 +55,14 @@ module NewRelic::Agent::Threading
       q1 = Queue.new
 
       t = ::Thread.new do
-        in_transaction do
+        begin
+          in_transaction do
+            q0.push 'unblock main thread'
+            q1.pop
+          end
+        rescue => e
           q0.push 'unblock main thread'
-          q1.pop
+          fail e
         end
       end
 
@@ -63,12 +76,13 @@ module NewRelic::Agent::Threading
     def test_bucket_thread_as_other
       t = ::Thread.new {}
       assert_equal :other, AgentThread.bucket_thread(t, DONT_CARE)
+      t.join
     end
 
     def test_runs_block
       called = false
 
-      t = AgentThread.new("labelled") { called = true }
+      t = AgentThread.create("labelled") { called = true }
       t.join
 
       assert called

data/test/new_relic/agent/threading/backtrace_service_test.rb

@@ -61,7 +61,7 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def test_stop_clears_buffered_backtraces
         fake_worker_loop(@service)
 
-        thread = fake_thread(:bucket => :request)
+        thread = fake_thread(:request)
 
         @service.subscribe('foo')
         @service.poll
@@ -121,10 +121,10 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def test_poll_forwards_backtraces_to_subscribed_profiles
         fake_worker_loop(@service)
 
-        bt0, bt1 = mock('bt0'), mock('bt1')
+        bt0, bt1 = ["bt0"], ["bt1"]
 
-        thread0 = fake_thread(:bucket => :request, :backtrace => bt0)
-        thread1 = fake_thread(:bucket => :differenter_request, :backtrace => bt1)
+        thread0 = fake_thread(:request, bt0)
+        thread1 = fake_thread(:differenter_request, bt1)
 
         profile = @service.subscribe(BacktraceService::ALL_TRANSACTIONS)
         profile.expects(:aggregate).with(bt0, :request, thread0)
@@ -136,7 +136,7 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def test_poll_does_not_forward_ignored_backtraces_to_profiles
         fake_worker_loop(@service)
 
-        fake_thread(:bucket => :ignore)
+        fake_thread(:ignore)
 
         profile = @service.subscribe(BacktraceService::ALL_TRANSACTIONS)
         profile.expects(:aggregate).never
@@ -146,13 +146,13 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
 
       def test_poll_scrubs_backtraces_before_forwarding_to_profiles
         fake_worker_loop(@service)
-        raw_backtrace = mock('raw')
-        scrubbed_backtrace = mock('scrubbed')
+        scrubbed_backtrace = []
 
-        thread = fake_thread(
-          :bucket => :agent,
-          :backtrace => raw_backtrace,
-          :scrubbed_backtrace => scrubbed_backtrace)
+        thread = fake_thread(:agent, ["trace"])
+
+        AgentThread.stubs(:scrub_backtrace).
+                    with(thread, any_parameters).
+                    returns(scrubbed_backtrace)
 
         profile = @service.subscribe(BacktraceService::ALL_TRANSACTIONS)
         profile.expects(:aggregate).with(scrubbed_backtrace, :agent, thread)
@@ -163,7 +163,7 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def test_poll_records_supportability_metrics
         fake_worker_loop(@service)
 
-        fake_thread(:bucket => :request)
+        fake_thread(:request)
 
         profile = @service.subscribe(BacktraceService::ALL_TRANSACTIONS)
         profile.stubs(:aggregate)
@@ -233,13 +233,13 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       end
 
       def test_sample_thread_does_not_backtrace_if_no_subscriptions
-        thread = fake_thread(:bucket => :request)
+        thread = fake_thread(:request)
         thread.expects(:backtrace).never
         @service.sample_thread(thread)
       end
 
       def test_sample_thread_does_not_backtrace_if_ignored
-        thread = fake_thread(:bucket => :ignore)
+        thread = fake_thread(:ignore)
         thread.expects(:backtrace).never
         @service.sample_thread(thread)
       end
@@ -248,7 +248,7 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
         fake_worker_loop(@service)
         @service.subscribe('foo')
 
-        thread = fake_thread(:bucket => :other)
+        thread = fake_thread(:other)
         thread.expects(:backtrace).never
         @service.sample_thread(thread)
       end
@@ -256,7 +256,7 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def test_on_transaction_finished_always_clears_buffer_for_current_thread
         fake_worker_loop(@service)
 
-        thread = fake_thread(:bucket => :request)
+        thread = fake_thread(:request)
         @service.subscribe('foo')
         @service.poll
 
@@ -267,7 +267,7 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def test_on_transaction_finished_aggregates_backtraces_to_subscribed_profile
         fake_worker_loop(@service)
 
-        thread = fake_thread(:bucket => :request)
+        thread = fake_thread(:request)
         profile = @service.subscribe('foo')
 
         t0 = Time.now
@@ -280,7 +280,7 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def test_on_transaction_finished_does_not_aggregate_backtraces_to_non_subscribed_profiles
         fake_worker_loop(@service)
 
-        thread = fake_thread(:bucket => :request)
+        thread = fake_thread(:request)
         profile = @service.subscribe('foo')
 
         t0 = Time.now
@@ -293,8 +293,8 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def test_on_transaction_finished_delivers_buffered_backtraces_for_correct_thread
         fake_worker_loop(@service)
 
-        thread0 = fake_thread(:bucket => :request)
-        thread1 = fake_thread(:bucket => :request)
+        thread0 = fake_thread(:request)
+        thread1 = fake_thread(:request)
 
         profile = @service.subscribe('foo')
 
@@ -311,7 +311,7 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def test_on_transaction_finished_only_delivers_backtraces_within_transaction_time_window
         fake_worker_loop(@service)
 
-        thread = fake_thread(:bucket => :request)
+        thread = fake_thread(:request)
 
         profile = @service.subscribe('foo')
 
@@ -328,7 +328,7 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def test_does_not_deliver_non_request_backtraces_to_subscribed_profiles
         fake_worker_loop(@service)
 
-        thread = fake_thread(:bucket => :other)
+        thread = fake_thread(:other)
 
         profile = @service.subscribe('foo')
 
@@ -342,7 +342,7 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def test_subscribe_sets_up_transaction_finished_subscription
         fake_worker_loop(@service)
 
-        Thread.current[:bucket] = :request
+        mark_bucket_for_thread(Thread.current, :request)
         FakeThread.list << Thread.current
 
         profile = @service.subscribe('foo')
@@ -352,8 +352,6 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
 
         profile.expects(:aggregate).once
         fake_transaction_finished('foo', t0.to_f, 1.0)
-      ensure
-        Thread.current[:bucket] = nil
       end
 
       def test_service_increments_profile_poll_counts
@@ -370,8 +368,8 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
 
       def test_poll_scrubs_dead_threads_from_buffer
         fake_worker_loop(@service)
-        thread0 = fake_thread(:bucket => :request)
-        thread1 = fake_thread(:bucket => :request)
+        thread0 = fake_thread(:request)
+        thread1 = fake_thread(:request)
 
         @service.subscribe('foo')
         @service.poll
@@ -492,14 +490,17 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
         dummy_loop
       end
 
-      def fake_thread(opts={})
-        defaults = {
-          :backtrace => mock('backtrace')
-        }
-        thread = FakeThread.new(defaults.merge(opts))
+      def fake_thread(bucket, backtrace=[])
+        thread = FakeThread.new(:backtrace => backtrace)
+        mark_bucket_for_thread(thread, bucket)
+
         FakeThread.list << thread
         thread
       end
+
+      def mark_bucket_for_thread(thread, bucket)
+        AgentThread.stubs(:bucket_thread).with(thread, any_parameters).returns(bucket)
+      end
     end
 
     # These tests do not use ThreadedTestCase as FakeThread is synchronous and

data/test/new_relic/agent/threading/fake_thread.rb

@@ -18,14 +18,6 @@ class FakeThread
     @@list
   end
 
-  def self.bucket_thread(thread, _)
-    thread[:bucket]
-  end
-
-  def self.scrub_backtrace(thread, _)
-    thread[:scrubbed_backtrace] || thread.backtrace
-  end
-
   def alive?
     true
   end
@@ -38,6 +30,10 @@ class FakeThread
     @locals[key]
   end
 
+  def []=(key, value)
+    @locals[key] = value
+  end
+
   def backtrace
     @locals[:backtrace] || []
   end

data/test/new_relic/agent/threading/threaded_test_case.rb

@@ -6,23 +6,13 @@ require 'new_relic/agent/threading/fake_thread'
 
 module ThreadedTestCase
   def setup_fake_threads
-    @original_thread_class = NewRelic::Agent::Threading::AgentThread
-    swap_thread_class(FakeThread)
+    @original_thread_class = NewRelic::Agent::Threading::AgentThread.backing_thread_class
+    NewRelic::Agent::Threading::AgentThread.backing_thread_class = FakeThread
+    FakeThread.list.clear
   end
 
   def teardown_fake_threads
-    swap_thread_class(@original_thread_class)
-    @original_thread_class = nil
-
+    NewRelic::Agent::Threading::AgentThread.backing_thread_class = @original_thread_class
     FakeThread.list.clear
   end
-
-  private
-
-  def swap_thread_class(klass)
-    if NewRelic::Agent::Threading.const_defined?("AgentThread")
-      NewRelic::Agent::Threading.send(:remove_const, "AgentThread")
-    end
-    NewRelic::Agent::Threading.const_set("AgentThread", klass)
-  end
 end

data/test/new_relic/agent/traced_method_stack_test.rb

@@ -14,11 +14,11 @@ class NewRelic::Agent::TracedMethodStackTest < Minitest::Test
     freeze_time
 
     in_transaction('orlando') do
-      self.class.trace_execution_scoped('disney', :deduct_call_time_from_parent => false) { advance_time(0.1) }
+      self.class.trace_execution_scoped('disney') { advance_time(0.1) }
     end
 
     in_transaction('anaheim') do
-      self.class.trace_execution_scoped('disney', :deduct_call_time_from_parent => false) { advance_time(0.11) }
+      self.class.trace_execution_scoped('disney') { advance_time(0.11) }
     end
 
     assert_metrics_recorded(
@@ -38,26 +38,30 @@ class NewRelic::Agent::TracedMethodStackTest < Minitest::Test
 
 
   def test_scope_failure
-    scope1 = @frame_stack.push_frame(:scope1)
-    scope2 = @frame_stack.push_frame(:scope2)
+    state = NewRelic::Agent::TransactionState.tl_get
+
+    scope1 = @frame_stack.push_frame(state, :scope1)
+    scope2 = @frame_stack.push_frame(state, :scope2)
     assert_raises(RuntimeError) do
-      @frame_stack.pop_frame(scope1, "name 1")
+      @frame_stack.pop_frame(state, scope1, "name 1", Time.now.to_f)
     end
   end
 
   def test_children_time
+    state = NewRelic::Agent::TransactionState.tl_get
+
     t1 = freeze_time
-    expected1 = @frame_stack.push_frame(:a)
+    expected1 = @frame_stack.push_frame(state, :a)
     advance_time(0.001)
     t2 = Time.now
 
-    expected2 = @frame_stack.push_frame(:b)
+    expected2 = @frame_stack.push_frame(state, :b)
     advance_time(0.002)
     t3 = Time.now
 
-    expected = @frame_stack.push_frame(:c)
+    expected = @frame_stack.push_frame(state, :c)
     advance_time(0.003)
-    scope = @frame_stack.pop_frame(expected, "metric c")
+    scope = @frame_stack.pop_frame(state, expected, "metric c", Time.now.to_f)
 
     t4 = Time.now
     assert_equal 0, scope.children_time
@@ -65,20 +69,20 @@ class NewRelic::Agent::TracedMethodStackTest < Minitest::Test
     advance_time(0.001)
     t5 = Time.now
 
-    expected = @frame_stack.push_frame(:d)
+    expected = @frame_stack.push_frame(state, :d)
     advance_time(0.002)
-    scope = @frame_stack.pop_frame(expected, "metric d")
+    scope = @frame_stack.pop_frame(state, expected, "metric d", Time.now.to_f)
 
     t6 = Time.now
 
     assert_equal 0, scope.children_time
 
-    scope = @frame_stack.pop_frame(expected2, "metric b")
+    scope = @frame_stack.pop_frame(state, expected2, "metric b", Time.now.to_f)
     assert_equal 'metric b', scope.name
 
     assert_in_delta((t4 - t3) + (t6 - t5), scope.children_time, 0.0001)
 
-    scope = @frame_stack.pop_frame(expected1, "metric a")
+    scope = @frame_stack.pop_frame(state, expected1, "metric a", Time.now.to_f)
     assert_equal scope.name, 'metric a'
 
     assert_in_delta((t6 - t2), scope.children_time, 0.0001)
@@ -87,13 +91,15 @@ class NewRelic::Agent::TracedMethodStackTest < Minitest::Test
 
   # test for when the scope stack contains an element only used for tts and not metrics
   def test_simple_tt_only_scope
-    node1 = @frame_stack.push_frame(:a, 0, true)
-    node2 = @frame_stack.push_frame(:b, 10, false)
-    node3 = @frame_stack.push_frame(:c, 20, true)
+    state = NewRelic::Agent::TransactionState.tl_get
 
-    @frame_stack.pop_frame(node3, "name a", 30)
-    @frame_stack.pop_frame(node2, "name b", 20)
-    @frame_stack.pop_frame(node1, "name c", 10)
+    node1 = @frame_stack.push_frame(state, :a, 0)
+    node2 = @frame_stack.push_frame(state, :b, 10)
+    node3 = @frame_stack.push_frame(state, :c, 20)
+
+    @frame_stack.pop_frame(state, node3, "name a", 30)
+    @frame_stack.pop_frame(state, node2, "name b", 20)
+    @frame_stack.pop_frame(state, node1, "name c", 10)
 
     assert_equal 0, node3.children_time
     assert_equal 10, node2.children_time
@@ -103,15 +109,17 @@ class NewRelic::Agent::TracedMethodStackTest < Minitest::Test
   end
 
   def test_double_tt_only_scope
-    node1 = @frame_stack.push_frame(:a,  0, true)
-    node2 = @frame_stack.push_frame(:b, 10, false)
-    node3 = @frame_stack.push_frame(:c, 20, false)
-    node4 = @frame_stack.push_frame(:d, 30, true)
+    state = NewRelic::Agent::TransactionState.tl_get
+
+    node1 = @frame_stack.push_frame(state, :a,  0)
+    node2 = @frame_stack.push_frame(state, :b, 10)
+    node3 = @frame_stack.push_frame(state, :c, 20)
+    node4 = @frame_stack.push_frame(state, :d, 30)
 
-    @frame_stack.pop_frame(node4, "name d", 40)
-    @frame_stack.pop_frame(node3, "name c", 30)
-    @frame_stack.pop_frame(node2, "name b", 20)
-    @frame_stack.pop_frame(node1, "name a", 10)
+    @frame_stack.pop_frame(state, node4, "name d", 40)
+    @frame_stack.pop_frame(state, node3, "name c", 30)
+    @frame_stack.pop_frame(state, node2, "name b", 20)
+    @frame_stack.pop_frame(state, node1, "name a", 10)
 
     assert_equal  0, node4.children_time.round
     assert_equal 10, node3.children_time.round
@@ -121,6 +129,14 @@ class NewRelic::Agent::TracedMethodStackTest < Minitest::Test
     assert @frame_stack.empty?
   end
 
+  def test_clear
+    state = NewRelic::Agent::TransactionState.tl_get
+
+    @frame_stack.push_frame(state, :a)
+    @frame_stack.clear
+    assert_empty @frame_stack
+  end
+
   def test_sampler_enabling
     assert_sampler_enabled_with(true,  :'transaction_tracer.enabled' => true,  :developer_mode => false)
     assert_sampler_enabled_with(true,  :'transaction_tracer.enabled' => false, :developer_mode => true)