newrelic_rpm 3.9.4.245 → 3.9.5.251

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

@@ -88,6 +88,36 @@ module NewRelic::Agent::Threading
       assert called
     end
 
+    def test_standard_error_is_caught
+      expects_logging(:error, includes("exited"), any_parameters)
+
+      t = AgentThread.create("fail") { raise "O_o" }
+      t.join
+
+      assert_thread_completed(t)
+    end
+
+    def test_exception_is_reraised
+      expects_logging(:error, includes("exited"), any_parameters)
+
+      assert_raises(Exception) do
+        begin
+          t = AgentThread.create("fail") { raise Exception.new }
+          t.join
+        ensure
+          assert_thread_died_from_exception(t)
+        end
+      end
+    end
+
+    def assert_thread_completed(t)
+      assert_equal false, t.status
+    end
+
+    def assert_thread_died_from_exception(t)
+      assert_equal nil, t.status
+    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'",

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

@@ -10,7 +10,7 @@ module NewRelic::Agent::Threading
     SINGLE_LINE = "irb.rb:69:in `catch'"
 
     def setup
-      @node = BacktraceNode.new(nil)
+      @node = BacktraceRoot.new
       @single_trace = [
         "irb.rb:69:in `catch'",
         "irb.rb:69:in `start'",
@@ -36,22 +36,29 @@ module NewRelic::Agent::Threading
       node
     end
 
+    def convert_nodes_to_array(nodes)
+      nodes.each {|n| n.mark_for_array_conversion }
+      nodes.each {|n| n.complete_array_conversion }
+    end
+
     def test_single_node_converts_to_array
       line = "irb.rb:69:in `catch'"
       node = BacktraceNode.new(line)
+      convert_nodes_to_array([node])
 
       assert_equal([
                    ["irb.rb", "catch", 69],
                    0, 0,
                    []],
-                   node.to_array)
+                   node.as_array)
     end
 
     def test_multiple_nodes_converts_to_array
       line = "irb.rb:69:in `catch'"
       child_line = "bacon.rb:42:in `yum'"
       node = create_node(line)
-      create_node(child_line, node)
+      child_node = create_node(child_line, node)
+      convert_nodes_to_array([node, child_node])
 
       assert_equal([
                    ["irb.rb", "catch", 69],
@@ -63,19 +70,20 @@ module NewRelic::Agent::Threading
                        []
       ]
       ]],
-        node.to_array)
+        node.as_array)
     end
 
     def test_gracefully_handle_bad_values_in_to_array
       node = BacktraceNode.new(SINGLE_LINE)
       node.stubs(:parse_backtrace_frame).returns(["irb.rb", "catch", "blarg"])
       node.runnable_count = Rational(10, 1)
+      convert_nodes_to_array([node])
 
       assert_equal([
                    ["irb.rb", "catch", 0],
                    10, 0,
                    []],
-                   node.to_array)
+                   node.as_array)
     end
 
     def test_add_child_twice
@@ -88,44 +96,10 @@ module NewRelic::Agent::Threading
       assert_equal 1, parent.children.size
     end
 
-    def test_prune_keeps_children
-      parent = create_node(SINGLE_LINE)
-      child = create_node(SINGLE_LINE, parent)
-
-      parent.prune!([])
-
-      assert_equal [child], parent.children
-    end
-
-    def test_prune_removes_children
-      parent = create_node(SINGLE_LINE)
-      child = create_node(SINGLE_LINE, parent)
-
-      parent.prune!([child])
-
-      assert_equal [], parent.children
-    end
-
-    def test_prune_removes_grandchildren
-      parent = create_node(SINGLE_LINE)
-      child = create_node(SINGLE_LINE, parent)
-      grandchild = create_node(SINGLE_LINE, child)
-
-      parent.prune!([grandchild])
-
-      assert_equal [child], parent.children
-      assert_equal [], child.children
-    end
-
-    def test_aggregate_empty_trace
-      @node.aggregate([])
-      assert @node.empty?
-    end
-
     def test_aggregate_builds_tree_from_first_trace
       @node.aggregate(@single_trace)
 
-      root = BacktraceNode.new(nil)
+      root = BacktraceRoot.new
       tree = create_node(@single_trace[-1], root, 1)
       child = create_node(@single_trace[-2], tree, 1)
       create_node(@single_trace[-3], child, 1)
@@ -137,7 +111,7 @@ module NewRelic::Agent::Threading
       @node.aggregate(@single_trace)
       @node.aggregate(@single_trace)
 
-      root = BacktraceNode.new(nil)
+      root = BacktraceRoot.new
       tree = create_node(@single_trace[-1], root, 2)
       child = create_node(@single_trace[-2], tree, 2)
       create_node(@single_trace[-3], child, 2)
@@ -161,7 +135,7 @@ module NewRelic::Agent::Threading
       @node.aggregate(backtrace1)
       @node.aggregate(backtrace2)
 
-      root = BacktraceNode.new(nil)
+      root = BacktraceRoot.new
 
       tree = create_node(backtrace1.last, root, 2)
 
@@ -178,12 +152,21 @@ module NewRelic::Agent::Threading
       @node.aggregate(@single_trace)
       @node.aggregate(@single_trace)
 
-      root = BacktraceNode.new(nil)
+      root = BacktraceRoot.new
       tree = create_node(@single_trace[-1], root, 2)
       child = create_node(@single_trace[-2], tree, 2)
       create_node(@single_trace[-3], child, 2)
 
       assert_backtrace_trees_equal(root, @node)
-    end 
+    end
+
+    def test_aggregate_limits_recorded_depth
+      deep_backtrace = (0..2000).to_a.map { |i| "foo.rb:#{i}:in `foo'" }
+
+      root = BacktraceRoot.new
+      root.aggregate(deep_backtrace)
+
+      assert_equal(MAX_THREAD_PROFILE_DEPTH, root.flattened.size)
+    end
   end
 end

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

@@ -41,33 +41,30 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def test_prune_tree
         @profile.aggregate(@single_trace, :request, Thread.current)
 
-        @profile.truncate_to_node_count!(1)
+        @profile.convert_N_trace_nodes_to_arrays(1)
 
-        assert_equal 0, @profile.traces[:request].children.first.children.size
+        assert_equal 1, count_backtrace_nodes(@profile.traces[:request])
       end
 
       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.aggregate(@single_trace, :other  , Thread.current)
+        @profile.aggregate(@single_trace, :other  , Thread.current)
 
-        @profile.truncate_to_node_count!(1)
+        @profile.convert_N_trace_nodes_to_arrays(1)
 
-        assert_empty @profile.traces[:request]
-        assert_equal 1, @profile.traces[:other].children.size
-        assert_equal [], @profile.traces[:other].children.first.children
+        assert_equal 0, count_backtrace_nodes(@profile.traces[:request])
+        assert_equal 1, count_backtrace_nodes(@profile.traces[:other  ])
       end
 
       def test_prune_keeps_highest_count_then_depths
         @profile.aggregate(@single_trace, :request, Thread.current)
-        @profile.aggregate(@single_trace, :other, Thread.current)
+        @profile.aggregate(@single_trace, :other  , Thread.current)
 
-        @profile.truncate_to_node_count!(2)
+        @profile.convert_N_trace_nodes_to_arrays(2)
 
-        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
+        assert_equal 1, count_backtrace_nodes(@profile.traces[:request])
+        assert_equal 1, count_backtrace_nodes(@profile.traces[:other  ])
       end
 
       def build_well_known_trace(args={})
@@ -245,6 +242,30 @@ if NewRelic::Agent::Threading::BacktraceService.is_supported?
       def encoder
         NewRelic::Agent::NewRelicService::JsonMarshaller.new.default_encoder
       end
+
+      def count_backtrace_nodes(bt_node)
+        trees = bt_node.as_array
+
+        count = 0
+
+        trees.each do |tree|
+          count += rec_count_tree_nodes(tree)
+        end
+
+        count
+      end
+
+      def rec_count_tree_nodes(tree)
+        count = 1 # 1 for this node
+
+        children = tree[3]
+
+        children.each do |child|
+          count += rec_count_tree_nodes(child)
+        end
+
+        count
+      end
     end
 
   end

data/test/new_relic/agent/transaction_test.rb

@@ -253,17 +253,20 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
   end
 
   def test_end_applies_transaction_name_rules
-    in_transaction('Controller/foo/1/bar/22') do |txn|
-      rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
-                                                    'replacement'      => '*',
-                                                    'replace_all'      => true)
-      NewRelic::Agent.instance.transaction_rules << rule
-      NewRelic::Agent::Transaction.tl_current.freeze_name_and_execute_if_not_ignored
-      assert_equal 'Controller/foo/*/bar/*', txn.best_name
+    rules = [
+      {
+        'match_expression' => '[0-9]+',
+        'replacement'      => '*',
+        'replace_all'      => true
+      }
+    ]
+
+    with_transaction_renaming_rules(rules) do
+      in_transaction('Controller/foo/1/bar/22') do |txn|
+        NewRelic::Agent::Transaction.tl_current.freeze_name_and_execute_if_not_ignored
+        assert_equal 'Controller/foo/*/bar/*', txn.best_name
+      end
     end
-  ensure
-    NewRelic::Agent.instance.instance_variable_set(:@transaction_rules,
-                                              NewRelic::Agent::RulesEngine.new)
   end
 
   def test_end_fires_a_transaction_finished_event

data/test/new_relic/environment_report_test.rb

@@ -61,13 +61,13 @@ class EnvironmentReportTest < Minitest::Test
 
   def test_gathers_system_info
     NewRelic::Agent::SystemInfo.stubs({
-      :processor_count    => 8,
-      :processor_arch     => 'x86_64',
-      :os_version         => 'WiggleOS 1.1.1',
-      :ruby_os_identifier => 'wiggleos'
+      :num_logical_processors => 8,
+      :processor_arch         => 'x86_64',
+      :os_version             => 'WiggleOS 1.1.1',
+      :ruby_os_identifier     => 'wiggleos'
     })
     report = ::NewRelic::EnvironmentReport.new
-    assert_equal(8, report['Processors'])
+    assert_equal(8, report['Logical Processors'])
     assert_equal('x86_64', report['Arch'])
     assert_equal('WiggleOS 1.1.1', report['OS version'])
     assert_equal('wiggleos', report['OS'])
@@ -83,7 +83,8 @@ class EnvironmentReportTest < Minitest::Test
       "Ruby patchlevel",
       'JRuby version',
       'Java VM version',
-      'Processors',
+      'Logical Processors',
+      'Physical Cores',
       'Database adapter',
       'Framework',
       'Dispatcher',

data/test/new_relic/fake_collector.rb

@@ -142,10 +142,13 @@ module NewRelic
           puts body
         end
 
+        query_params = req.GET
+
         @agent_data << AgentPost.create(:action       => method,
                                         :body         => body,
                                         :run_id       => run_id,
-                                        :format       => format)
+                                        :format       => format,
+                                        :query_params => query_params)
       end
       res.finish
     end
@@ -172,12 +175,13 @@ module NewRelic
     end
 
     class AgentPost
-      attr_accessor :action, :body, :run_id, :format
+      attr_accessor :action, :body, :run_id, :format, :query_params
       def initialize(opts={})
-        @action = opts[:action]
-        @body   = opts[:body]
-        @run_id = opts[:run_id]
-        @format = opts[:format]
+        @action       = opts[:action]
+        @body         = opts[:body]
+        @run_id       = opts[:run_id]
+        @format       = opts[:format]
+        @query_params = opts[:query_params]
       end
 
       def self.create(opts={})

data/test/new_relic/multiverse_helpers.rb

@@ -33,14 +33,13 @@ module MultiverseHelpers
 
   def setup_agent(opts = {}, &block)
     setup_collector
-    make_sure_agent_reconnects(opts)
 
     # Give caller a shot to setup before we start
     # Don't just yield, as that won't necessary have the intended receiver
     # (the test case instance itself)
     self.instance_exec($collector, &block) if block_given? && self.respond_to?(:instance_exec)
 
-    NewRelic::Agent.manual_start(opts)
+    trigger_agent_reconnect(opts)
   end
 
   def teardown_agent
@@ -76,7 +75,7 @@ module MultiverseHelpers
     teardown_agent
   end
 
-  def make_sure_agent_reconnects(opts)
+  def trigger_agent_reconnect(opts={})
     # Clean-up if others don't (or we're first test after auto-loading of agent)
     if NewRelic::Agent.instance.started?
       NewRelic::Agent.shutdown
@@ -87,15 +86,9 @@ module MultiverseHelpers
     NewRelic::Agent.instance.instance_variable_set(:@connect_state, :pending)
 
     # Almost always want a test to force a new connect when setting up
-    default_options(opts,
-                    :sync_startup => true,
-                    :force_reconnect => true)
-  end
+    defaults = { :sync_startup => true, :force_reconnect => true }
 
-  def default_options(options, defaults={})
-    defaults.each do |(k, v)|
-      options.merge!({k => v}) unless options.key?(k)
-    end
+    NewRelic::Agent.manual_start(defaults.merge(opts))
   end
 
   #

data/test/new_relic/rack/agent_hooks_test.rb

@@ -23,7 +23,7 @@ class AgentHooksTest < Minitest::Test
   end
 
   def test_after_call
-    result = stub
+    result = [stub, stub, stub]
     @app.stubs(:call).returns(result)
 
     NewRelic::Agent.instance.events.expects(:notify).with(:start_transaction)

data/test/performance/lib/performance/baseline_compare_reporter.rb

@@ -58,22 +58,39 @@ module Performance
         delta = new_result.elapsed - old_result.elapsed
         percent_delta = delta / old_result.elapsed * 100.0
 
+        allocations_before = old_result.measurements[:allocations]
+        allocations_after  = new_result.measurements[:allocations]
+        if allocations_before && allocations_after
+          allocations_delta  = allocations_after - allocations_before
+          allocations_delta_percent = allocations_delta.to_f / allocations_before * 100
+        else
+          allocations_delta_percent = 0
+        end
+
         rows << [
           identifier,
           old_result.elapsed,
           new_result.elapsed,
-          percent_delta
+          percent_delta,
+          allocations_before,
+          allocations_after,
+          allocations_delta_percent
         ]
       end
 
+      format_percent_delta = Proc.new { |v|
+        prefix = v > 0 ? "+" : ""
+        sprintf("#{prefix}%.1f%%", v)
+      } 
+
       table = Table.new(rows) do
         column :name
-        column :before, "%.2f s"
-        column :after,  "%.2f s"
-        column :delta do |v|
-          prefix = v > 0 ? "+" : ''
-          sprintf("#{prefix}%.1f%%", v)
-        end
+        column :before,        "%.2f s"
+        column :after,         "%.2f s"
+        column :delta,         &format_percent_delta
+        column :allocs_before
+        column :allocs_after
+        column :allocs_delta,  &format_percent_delta
       end
 
       puts table.render