newrelic_rpm 3.6.7.159 → 3.6.8.164

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

@@ -26,6 +26,10 @@ class FakeThread
     thread[:scrubbed_backtrace] || thread.backtrace
   end
 
+  def alive?
+    true
+  end
+
   def key?(key)
     @locals.key?(key)
   end

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

@@ -4,16 +4,18 @@
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
 
+require 'new_relic/agent/threading/backtrace_service'
 require 'new_relic/agent/threading/thread_profile'
 require 'new_relic/agent/threading/threaded_test_case'
 
-if NewRelic::Agent::Commands::ThreadProfiler.is_supported?
+if NewRelic::Agent::Threading::BacktraceService.is_supported?
 
   module NewRelic::Agent::Threading
-    class ThreadProfileTest < ThreadedTestCase
+    class ThreadProfileTest < Test::Unit::TestCase
+      include ThreadedTestCase
 
       def setup
-        super
+        setup_fake_threads
 
         @single_trace = [
           "irb.rb:69:in `catch'",
@@ -21,286 +23,208 @@ if NewRelic::Agent::Commands::ThreadProfiler.is_supported?
           "irb:12:in `<main>'"
         ]
 
-        @profile = ThreadProfile.new(create_agent_command)
+        @profile = ThreadProfile.new
 
         # Run the worker_loop for the thread profile based on two iterations
         # This takes time fussiness out of the equation and keeps the tests stable
         @profile.instance_variable_set(:@worker_loop, NewRelic::Agent::WorkerLoop.new(:limit => 2))
       end
 
-      # Running Tests
-      def test_profiler_collects_backtrace_from_every_thread
-        FakeThread.list << FakeThread.new
-        FakeThread.list << FakeThread.new
-
-        @profile.run
-
-        assert_equal 2, @profile.poll_count
-        assert_equal 4, @profile.sample_count
+      def teardown
+        teardown_fake_threads
       end
 
-      def test_profiler_collects_into_request_bucket
-        FakeThread.list << FakeThread.new(
-          :bucket => :request,
-          :backtrace => @single_trace)
-
-          @profile.run
-
-          assert_equal 1, @profile.traces[:request].size
+      def target_for_shared_client_tests
+        @profile
       end
 
-      def test_profiler_collects_into_background_bucket
-        FakeThread.list << FakeThread.new(
-          :bucket => :background,
-          :backtrace => @single_trace)
+      def test_prune_tree
+        @profile.aggregate(@single_trace, :request, Thread.current)
 
-          @profile.run
+        @profile.truncate_to_node_count!(1)
 
-          assert_equal 1, @profile.traces[:background].size
+        assert_equal 0, @profile.traces[:request].children.first.children.size
       end
 
-      def test_profiler_collects_into_other_bucket
-        FakeThread.list << FakeThread.new(
-          :bucket => :other,
-          :backtrace => @single_trace)
+      def test_prune_keeps_highest_counts
+        @profile.aggregate(@single_trace, :request, Thread.current)
+        @profile.aggregate(@single_trace, :other, Thread.current)
+        @profile.aggregate(@single_trace, :other, Thread.current)
 
-          @profile.run
+        @profile.truncate_to_node_count!(1)
 
-          assert_equal 1, @profile.traces[:other].size
+        assert_empty @profile.traces[:request]
+        assert_equal 1, @profile.traces[:other].children.size
+        assert_equal [], @profile.traces[:other].children.first.children
       end
 
-      def test_profiler_collects_into_agent_bucket
-        FakeThread.list << FakeThread.new(
-          :bucket => :agent,
-          :backtrace => @single_trace)
+      def test_prune_keeps_highest_count_then_depths
+        @profile.aggregate(@single_trace, :request, Thread.current)
+        @profile.aggregate(@single_trace, :other, Thread.current)
 
-          @profile.run
+        @profile.truncate_to_node_count!(2)
 
-          assert_equal 1, @profile.traces[:agent].size
+        assert_equal 1, @profile.traces[:request].children.size
+        assert_equal 1, @profile.traces[:other].children.size
+        assert_equal [], @profile.traces[:request].children.first.children
+        assert_equal [], @profile.traces[:other].children.first.children
       end
 
-      def test_profiler_ignores_agent_threads_when_told_to
-        FakeThread.list << FakeThread.new(
-          :bucket => :ignore,
-          :backtrace => @single_trace)
-
-          @profile.run
-
-          @profile.traces.each do |key, trace|
-            assert trace.empty?, "Trace :#{key} should have been empty"
-          end
-      end
+      def build_well_known_trace(args={})
+        @profile = ThreadProfile.new(args)
 
-      def test_profiler_tries_to_scrub_backtraces
-        FakeThread.list << FakeThread.new(
-          :bucket => :agent,
-          :backtrace => @single_trace,
-          :scrubbed_backtrace => @single_trace[0..0])
+        thread = stub
+        trace = ["thread_profiler.py:1:in `<module>'"]
+        10.times { @profile.aggregate(trace, :other, thread) }
 
-          @profile.run
+        thread = stub
+        trace = [
+          "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:489:in `__bootstrap'",
+          "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:512:in `__bootstrap_inner'",
+          "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:480:in `run'",
+          "thread_profiler.py:76:in `_profiler_loop'",
+          "thread_profiler.py:103:in `_run_profiler'",
+          "thread_profiler.py:165:in `collect_thread_stacks'"
+        ]
+        10.times { @profile.aggregate(trace, :agent, thread) }
 
-          assert_equal [], @profile.traces[:agent].first.children
+        @profile.increment_poll_count
       end
 
-      def test_profile_can_be_stopped
-        # Can't easily stop in middle of processing since FakeThread's synchronous
-        # Mark to bail immediately, then see we didn't record anything
-        @profile.stop
-
-        @profile.run
-
-        assert_not_nil @profile.stop_time
-        assert_equal true, @profile.finished?
+      WELL_KNOWN_TRACE_ENCODED = "eJy9klFPwjAUhf/LfW7WDQTUGBPUiYkGdAxelqXZRpGGrm1uS8xi/O924JQX\n9Un7dm77ndN7c19hlt7FCZxnWQZug7xYMYN6LSTHwDRA4KLWq53kl0CinEQh\nCUmW5zmBJH5axPPUk16MJ/E0/cGk0lLyyrGPS+uKamu943DQeX5HMtypz5In\nwv6vRCeZ1NoAGQ2PCDpvrOM1fRAlFtjQWyxq/qJxa+lj4zZaBeuuQpccrdDK\n0l4wolKU1OxftOoQLNTzIdL/EcjJafjnQYyVWjvrsDBMKNVOZBD1/jO27fPs\naBG+DoGr8fX9JJktpjftVry9A9unzGo=\n"
 
-        assert_equal 0, @profile.poll_count
-        @profile.traces.each do |key, trace|
-          assert_equal [], trace, "Trace for :#{key} should have been empty"
-        end
-      end
+      def test_to_collector_array
+        build_well_known_trace('profile_id' => 333)
+        @profile.stubs(:created_at).returns(1350403938892.524)
+        @profile.finished_at = 1350403939904.375
 
-      def test_profiler_tracks_time
-        @profile.run
+        expected = [
+          333,
+          1350403938892.524,
+          1350403939904.375,
+          1,
+          WELL_KNOWN_TRACE_ENCODED,
+          2,
+          0
+        ]
 
-        assert_not_nil @profile.start_time
-        assert_not_nil @profile.stop_time
+        assert_equal expected, @profile.to_collector_array(encoder)
       end
 
-      def test_finished
-        assert !@profile.finished?
-
-        @profile.run.join
+      def test_to_collector_array_with_xray_session_id
+        build_well_known_trace('profile_id' => -1, 'x_ray_id' => 4242)
+        @profile.stubs(:created_at).returns(1350403938892.524)
+        @profile.finished_at = 1350403939904.375
 
-        assert @profile.finished?
-      end
-
-      # Parsing and Aggregation Tests
-      def test_parse_backtrace
-        trace = [
-          "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/1.9.1/irb.rb:69:in `catch'",
-          "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/1.9.1/irb.rb:69:in `start'",
-          "/Users/jclark/.rbenv/versions/1.9.3/bin/irb:12:in `<main>'"
+        expected = [
+          -1,
+          1350403938892.524,
+          1350403939904.375,
+          20,
+          WELL_KNOWN_TRACE_ENCODED,
+          2,
+          0,
+          4242
         ]
 
-        result = ThreadProfile.parse_backtrace(trace)
-        assert_equal({ :method => 'catch',
-                     :file => '/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/1.9.1/irb.rb',
-                     :line_no => 69 }, result[0])
-        assert_equal({ :method => 'start',
-                     :file => '/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/1.9.1/irb.rb',
-                     :line_no => 69 }, result[1])
-        assert_equal({ :method => '<main>',
-                     :file => '/Users/jclark/.rbenv/versions/1.9.3/bin/irb',
-                     :line_no => 12 }, result[2])
-      end
-
-      def test_aggregate_empty_trace
-        result = @profile.aggregate([])
-        assert_nil result
-      end
-
-      def test_aggregate_nil_trace
-        result = @profile.aggregate(nil)
-        assert_nil result
+        assert_equal expected, @profile.to_collector_array(encoder)
       end
 
-      def test_aggregate_builds_tree_from_first_trace
-        result = @profile.aggregate(@single_trace)
+      def test_to_collector_array_with_bad_values
+        build_well_known_trace(:profile_id => -1)
+        @profile.stubs(:created_at).returns('')
+        @profile.finished_at = nil
+        @profile.instance_variable_set(:@poll_count, Rational(10, 1))
+        @profile.instance_variable_set(:@backtrace_count, nil)
+        @profile.instance_variable_set(:@unique_threads, nil)
 
-        tree = BacktraceNode.new(@single_trace[-1])
-        child = BacktraceNode.new(@single_trace[-2], tree)
-        BacktraceNode.new(@single_trace[-3], child)
+        expected = [
+          -1,
+          0.0,
+          0.0,
+          10,
+          WELL_KNOWN_TRACE_ENCODED,
+          0,
+          0
+        ]
 
-        assert_equal tree, result
+        assert_equal expected, @profile.to_collector_array(encoder)
       end
 
-      def test_aggregate_builds_tree_from_overlapping_traces
-        result = @profile.aggregate(@single_trace)
-        result = @profile.aggregate(@single_trace, [result])
-
-        tree = BacktraceNode.new(@single_trace[-1])
-        tree.runnable_count += 1
-        child = BacktraceNode.new(@single_trace[-2], tree)
-        child.runnable_count += 1
-        grand = BacktraceNode.new(@single_trace[-3], child)
-        grand.runnable_count += 1
+      def test_aggregate_should_increment_only_backtrace_count
+        backtrace_count = @profile.backtrace_count
+        failure_count = @profile.failure_count
+        @profile.aggregate(@single_trace, :request, Thread.current)
 
-        assert_equal tree, result
+        assert_equal backtrace_count + 1, @profile.backtrace_count
+        assert_equal failure_count, @profile.failure_count
       end
 
-      def test_aggregate_builds_tree_from_diverging_traces
-        other_trace = [
-          "irb.rb:69:in `catch'",
-          "chunky_bacon.rb:42:in `start'",
-          "irb:12:in `<main>'"
-        ]
+      def test_aggregate_increments_only_the_failure_count_with_nil_backtrace
+        backtrace_count = @profile.backtrace_count
+        failure_count = @profile.failure_count
+        @profile.aggregate(nil, :request, Thread.current)
 
-        result = @profile.aggregate(@single_trace)
-        result = @profile.aggregate(@single_trace, [result])
+        assert_equal backtrace_count, @profile.backtrace_count
+        assert_equal failure_count + 1, @profile.failure_count
+      end
 
-        tree = BacktraceNode.new(@single_trace[-1])
-        tree.runnable_count += 1
+      def test_aggregate_updates_created_at_timestamp
+        expected = freeze_time
+        @profile = ThreadProfile.new
 
-        child = BacktraceNode.new(@single_trace[-2], tree)
-        grand = BacktraceNode.new(@single_trace[-3], child)
+        @profile.aggregate(@single_trace, :request, Thread.current)
+        t0 = @profile.created_at
 
-        other_child = BacktraceNode.new(other_trace[-2], tree)
-        other_grand = BacktraceNode.new(other_trace[-3], other_child)
+        advance_time(5.0)
+        @profile.aggregate(@single_trace, :request, Thread.current)
 
-        assert_equal tree, result
+        assert_equal expected, t0
+        assert_equal expected, @profile.created_at
       end
 
-      def test_prune_tree
-        @profile.aggregate(@single_trace)
+      def test_aggregate_keeps_unique_thread_count
+        thread0 = stub
+        thread1 = stub
 
-        t = @profile.prune!(1)
+        @profile.aggregate(@single_trace, :request, thread0)
+        @profile.aggregate(@single_trace, :request, thread0)
+        @profile.aggregate(@single_trace, :request, thread1)
 
-        assert_equal 0, @profile.traces[:request].first.children.size
+        assert_equal 2, @profile.unique_thread_count
       end
 
-      def test_prune_keeps_highest_counts
-        @profile.aggregate(@single_trace, @profile.traces[:request])
-        @profile.aggregate(@single_trace, @profile.traces[:other])
-        @profile.aggregate(@single_trace, @profile.traces[:other])
+      SAMPLE_COUNT_POSITION = 3
 
-        @profile.prune!(1)
+      def test_sample_count_for_thread_profiling
+        profile = ThreadProfile.new('x_ray_id' => nil)
+        profile.increment_poll_count
 
-        assert_equal [], @profile.traces[:request]
-        assert_equal 1, @profile.traces[:other].size
-        assert_equal [], @profile.traces[:other][0].children
+        result = profile.to_collector_array(encoder)
+        assert_equal 1, result[SAMPLE_COUNT_POSITION]
       end
 
-      def test_prune_keeps_highest_count_then_depths
-        @profile.aggregate(@single_trace, @profile.traces[:request])
-        @profile.aggregate(@single_trace, @profile.traces[:other])
-
-        @profile.prune!(2)
+      def test_sample_count_for_xrays
+        profile = ThreadProfile.new('x_ray_id' => 123)
+        profile.aggregate(@single_trace, :request, Thread.current)
 
-        assert_equal 1, @profile.traces[:request].size
-        assert_equal 1, @profile.traces[:other].size
-        assert_equal [], @profile.traces[:request][0].children
-        assert_equal [], @profile.traces[:other][0].children
+        result = profile.to_collector_array(encoder)
+        assert_equal 1, result[SAMPLE_COUNT_POSITION]
       end
 
-      def build_well_known_trace
-        trace = ["thread_profiler.py:1:in `<module>'"]
-        10.times { @profile.aggregate(trace, @profile.traces[:other]) }
-
-        trace = [
-          "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:489:in `__bootstrap'",
-          "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:512:in `__bootstrap_inner'",
-          "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:480:in `run'",
-          "thread_profiler.py:76:in `_profiler_loop'",
-          "thread_profiler.py:103:in `_run_profiler'",
-          "thread_profiler.py:165:in `collect_thread_stacks'"]
-          10.times { @profile.aggregate(trace, @profile.traces[:agent]) }
+      def test_empty
+        profile = ThreadProfile.new
+        assert profile.empty?
       end
 
-      WELL_KNOWN_TRACE_ENCODED = "eJy9klFPwjAUhf/LfW7WDQTUGBPUiYkGdAxelqXZRpGGrm1uS8xi/O924JQX\n9Un7dm77ndN7c19hlt7FCZxnWQZug7xYMYN6LSTHwDRA4KLWq53kl0CinEQh\nCUmW5zmBJH5axPPUk16MJ/E0/cGk0lLyyrGPS+uKamu943DQeX5HMtypz5In\nwv6vRCeZ1NoAGQ2PCDpvrOM1fRAlFtjQWyxq/qJxa+lj4zZaBeuuQpccrdDK\n0l4wolKU1OxftOoQLNTzIdL/EcjJafjnQYyVWjvrsDBMKNVOZBD1/jO27fPs\naBG+DoGr8fX9JJktpjftVry9A9unzGo=\n"
-
-      def test_to_collector_array
-        @profile.instance_variable_set(:@profile_id, "-1")
-        @profile.instance_variable_set(:@start_time, 1350403938892.524)
-        @profile.instance_variable_set(:@stop_time, 1350403939904.375)
-        @profile.instance_variable_set(:@poll_count, 10)
-        @profile.instance_variable_set(:@sample_count, 2)
-
-        build_well_known_trace
-
-        expected = [[
-          -1,
-          1350403938892.524,
-          1350403939904.375,
-          10,
-          WELL_KNOWN_TRACE_ENCODED,
-          2,
-          0
-        ]]
-
-        marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-        assert_equal expected, @profile.to_collector_array(marshaller.default_encoder)
+      def test_not_empty
+        profile = ThreadProfile.new
+        profile.aggregate([], :request, Thread.current)
+        assert_false profile.empty?
       end
 
-      def test_to_collector_array_with_bad_values
-        @profile.instance_variable_set(:@profile_id, "-1")
-        @profile.instance_variable_set(:@start_time, "")
-        @profile.instance_variable_set(:@stop_time, nil)
-        @profile.instance_variable_set(:@poll_count, Rational(10, 1))
-        @profile.instance_variable_set(:@sample_count, nil)
-
-        build_well_known_trace
-
-        expected = [[
-          -1,
-          0.0,
-          0.0,
-          10,
-          WELL_KNOWN_TRACE_ENCODED,
-          0,
-          0
-        ]]
-
-        marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
-        assert_equal expected, @profile.to_collector_array(marshaller.default_encoder)
+      def encoder
+        NewRelic::Agent::NewRelicService::JsonMarshaller.new.default_encoder
       end
     end