newrelic_rpm 3.6.6.147 → 3.6.7.152

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

@@ -0,0 +1,107 @@
+# 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/threading/agent_thread'
+
+module NewRelic::Agent::Threading
+  class AgentThreadTest < Test::Unit::TestCase
+
+    def test_sets_label
+      t = AgentThread.new("labelled") {}
+      assert_equal "labelled", t[:newrelic_label]
+    end
+
+    def test_bucket_thread_as_agent_when_profiling
+      t = AgentThread.new("labelled") {}
+      assert_equal :agent, AgentThread.bucket_thread(t, true)
+    end
+
+    def test_bucket_thread_as_agent_when_not_profiling
+      t = AgentThread.new("labelled") {}
+      assert_equal :ignore, AgentThread.bucket_thread(t, false)
+    end
+
+    def test_bucket_thread_as_request
+      t = ::Thread.new {
+        txn = NewRelic::Agent::Transaction.new
+        txn.request = "has a request"
+
+        NewRelic::Agent::TransactionState.get.current_transaction_stack = [txn]
+      }.join
+
+      assert_equal :request, AgentThread.bucket_thread(t, DONT_CARE)
+    end
+
+    def test_bucket_thread_as_background
+      t = ::Thread.new {
+        txn = NewRelic::Agent::Transaction.new
+        NewRelic::Agent::TransactionState.get.current_transaction_stack = [txn]
+      }.join
+
+      assert_equal :background, AgentThread.bucket_thread(t, DONT_CARE)
+    end
+
+    def test_bucket_thread_as_other_empty_txn_stack
+      t = ::Thread.new {
+        NewRelic::Agent::TransactionState.get.current_transaction_stack = []
+      }.join
+
+      assert_equal :other, AgentThread.bucket_thread(t, DONT_CARE)
+    end
+
+    def test_bucket_thread_as_other_no_txn_stack
+      t = ::Thread.new {
+        NewRelic::Agent::TransactionState.get.current_transaction_stack = nil
+      }.join
+
+      assert_equal :other, AgentThread.bucket_thread(t, DONT_CARE)
+    end
+
+    def test_bucket_thread_as_other
+      t = ::Thread.new {}
+      assert_equal :other, AgentThread.bucket_thread(t, DONT_CARE)
+    end
+
+    def test_runs_block
+      called = false
+
+      t = AgentThread.new("labelled") { called = true }
+      t.join
+
+      assert called
+    end
+
+    TRACE = [
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/eventmachine-0.12.10/lib/eventmachine.rb:100:in `catch'",
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/newrelic_rpm-3.5.3.452.dev/lib/new_relic/agent/agent.rb:200:in `start_worker_thread'",
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/gems/1.9.1/gems/thin-1.5.0/lib/thin/backends/base.rb:300:in `block (3 levels) in run'",
+    ]
+
+    def test_scrubs_backtrace_when_not_profiling_agent_code
+      result = AgentThread.scrub_backtrace(stub(:backtrace => TRACE), false)
+      assert_equal [TRACE[0], TRACE[2]], result
+    end
+
+    def test_doesnt_scrub_backtrace_when_profiling_agent_code
+      result = AgentThread.scrub_backtrace(stub(:backtrace => TRACE), true)
+      assert_equal TRACE, result
+    end
+
+    def test_scrub_backtrace_handles_errors_during_backtrace
+      dummy_thread = stub
+      dummy_thread.stubs(:backtrace).raises(StandardError.new('nah'))
+      assert_nothing_raised do
+        AgentThread.scrub_backtrace(dummy_thread, true)
+      end
+    end
+
+    def test_scrub_backtrace_handles_nil_backtrace
+      bt = AgentThread.scrub_backtrace(stub(:backtrace => nil), false)
+      assert_nil(bt)
+    end
+
+    DONT_CARE = true
+  end
+end

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

@@ -0,0 +1,96 @@
+# 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/threading/backtrace_node'
+
+module NewRelic::Agent::Threading
+  class BacktraceNodeTest < Test::Unit::TestCase
+    SINGLE_LINE = "irb.rb:69:in `catch'"
+
+    def test_single_node_converts_to_array
+      line = "irb.rb:69:in `catch'"
+      node = BacktraceNode.new(line)
+
+      assert_equal([
+                   ["irb.rb", "catch", 69],
+                   0, 0,
+                   []],
+                   node.to_array)
+    end
+
+    def test_multiple_nodes_converts_to_array
+      line = "irb.rb:69:in `catch'"
+      child_line = "bacon.rb:42:in `yum'"
+      node = BacktraceNode.new(line)
+      child = BacktraceNode.new(child_line, node)
+
+      assert_equal([
+                   ["irb.rb", "catch", 69],
+                   0, 0,
+                   [
+                     [
+                       ['bacon.rb', 'yum', 42],
+                       0,0,
+                       []
+      ]
+      ]],
+        node.to_array)
+    end
+
+    def test_gracefully_handle_bad_values_in_to_array
+      node = BacktraceNode.new(SINGLE_LINE)
+      node.instance_variable_set(:@line_no, "blarg")
+      node.runnable_count = Rational(10, 1)
+
+      assert_equal([
+                   ["irb.rb", "catch", 0],
+                   10, 0,
+                   []],
+                   node.to_array)
+    end
+
+    def test_add_child_twice
+      parent = BacktraceNode.new(SINGLE_LINE)
+      child = BacktraceNode.new(SINGLE_LINE)
+
+      parent.add_child(child)
+      parent.add_child(child)
+
+      assert_equal 1, parent.children.size
+    end
+
+    def test_prune_keeps_children
+      parent = BacktraceNode.new(SINGLE_LINE)
+      child = BacktraceNode.new(SINGLE_LINE, parent)
+
+      parent.prune!
+
+      assert_equal [child], parent.children
+    end
+
+    def test_prune_removes_children
+      parent = BacktraceNode.new(SINGLE_LINE)
+      child = BacktraceNode.new(SINGLE_LINE, parent)
+
+      child.to_prune = true
+      parent.prune!
+
+      assert_equal [], parent.children
+    end
+
+    def test_prune_removes_grandchildren
+      parent = BacktraceNode.new(SINGLE_LINE)
+      child = BacktraceNode.new(SINGLE_LINE, parent)
+      grandchild = BacktraceNode.new(SINGLE_LINE, child)
+
+      grandchild.to_prune = true
+      parent.prune!
+
+      assert_equal [child], parent.children
+      assert_equal [], child.children
+    end
+
+  end
+end

data/test/new_relic/agent/{threaded_test.rb → threading/fake_thread.rb}

@@ -2,31 +2,6 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-class ThreadedTest < Test::Unit::TestCase
-  def setup
-    @original_thread_class = NewRelic::Agent::AgentThread
-    swap_thread_class(FakeThread)
-  end
-
-  def teardown
-    swap_thread_class(@original_thread_class)
-    @original_thread_class = nil
-
-    FakeThread.list.clear
-  end
-
-  def default_test
-    # no-op to keep quiet....
-  end
-
-  private
-
-  def swap_thread_class(klass)
-    NewRelic::Agent.send(:remove_const, "AgentThread") if NewRelic::Agent.const_defined?("AgentThread")
-    NewRelic::Agent.const_set("AgentThread", klass)
-  end
-end
-
 class FakeThread
   @@list = []
 

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

@@ -0,0 +1,308 @@
+# 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/threading/thread_profile'
+require 'new_relic/agent/threading/threaded_test_case'
+
+if NewRelic::Agent::Commands::ThreadProfiler.is_supported?
+
+  module NewRelic::Agent::Threading
+    class ThreadProfileTest < ThreadedTestCase
+
+      def setup
+        super
+
+        @single_trace = [
+          "irb.rb:69:in `catch'",
+          "irb.rb:69:in `start'",
+          "irb:12:in `<main>'"
+        ]
+
+        @profile = ThreadProfile.new(create_agent_command)
+
+        # 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
+      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
+      end
+
+      def test_profiler_collects_into_background_bucket
+        FakeThread.list << FakeThread.new(
+          :bucket => :background,
+          :backtrace => @single_trace)
+
+          @profile.run
+
+          assert_equal 1, @profile.traces[:background].size
+      end
+
+      def test_profiler_collects_into_other_bucket
+        FakeThread.list << FakeThread.new(
+          :bucket => :other,
+          :backtrace => @single_trace)
+
+          @profile.run
+
+          assert_equal 1, @profile.traces[:other].size
+      end
+
+      def test_profiler_collects_into_agent_bucket
+        FakeThread.list << FakeThread.new(
+          :bucket => :agent,
+          :backtrace => @single_trace)
+
+          @profile.run
+
+          assert_equal 1, @profile.traces[:agent].size
+      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 test_profiler_tries_to_scrub_backtraces
+        FakeThread.list << FakeThread.new(
+          :bucket => :agent,
+          :backtrace => @single_trace,
+          :scrubbed_backtrace => @single_trace[0..0])
+
+          @profile.run
+
+          assert_equal [], @profile.traces[:agent].first.children
+      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?
+
+        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_profiler_tracks_time
+        @profile.run
+
+        assert_not_nil @profile.start_time
+        assert_not_nil @profile.stop_time
+      end
+
+      def test_finished
+        assert !@profile.finished?
+
+        @profile.run.join
+
+        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>'"
+        ]
+
+        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
+      end
+
+      def test_aggregate_builds_tree_from_first_trace
+        result = @profile.aggregate(@single_trace)
+
+        tree = BacktraceNode.new(@single_trace[-1])
+        child = BacktraceNode.new(@single_trace[-2], tree)
+        BacktraceNode.new(@single_trace[-3], child)
+
+        assert_equal tree, result
+      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
+
+        assert_equal tree, result
+      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>'"
+        ]
+
+        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)
+        grand = BacktraceNode.new(@single_trace[-3], child)
+
+        other_child = BacktraceNode.new(other_trace[-2], tree)
+        other_grand = BacktraceNode.new(other_trace[-3], other_child)
+
+        assert_equal tree, result
+      end
+
+      def test_prune_tree
+        @profile.aggregate(@single_trace)
+
+        t = @profile.prune!(1)
+
+        assert_equal 0, @profile.traces[:request].first.children.size
+      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])
+
+        @profile.prune!(1)
+
+        assert_equal [], @profile.traces[:request]
+        assert_equal 1, @profile.traces[:other].size
+        assert_equal [], @profile.traces[:other][0].children
+      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)
+
+        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
+      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]) }
+      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)
+      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)
+      end
+    end
+
+  end
+end