newrelic_rpm 3.6.0.83 → 3.6.1.85.beta

data/test/new_relic/agent/stats_engine/samplers_test.rb

@@ -37,23 +37,35 @@ class NewRelic::Agent::StatsEngine::SamplersTest < Test::Unit::TestCase
     end
   end
 
-  def test_cpu
-    s = NewRelic::Agent::Samplers::CpuSampler.new
-    # need to set this instance value to prevent it skipping a 'too
-    # fast' poll time
-    s.stats_engine = @stats_engine
-    s.instance_eval { @last_time = Time.now - 1.1 }
-    s.poll
-    s.instance_eval { @last_time = Time.now - 1.1 }
+  def test_cpu_sampler_records_user_and_system_time
+    timeinfo0 = mock
+    timeinfo0.stubs(:utime).returns(10.0)
+    timeinfo0.stubs(:stime).returns(5.0)
+
+    timeinfo1 = mock
+    timeinfo1.stubs(:utime).returns(14.0) # +5s
+    timeinfo1.stubs(:stime).returns(7.0)  # +2s
+
+    elapsed = 10
+
+    freeze_time
+    Process.stubs(:times).returns(timeinfo0, timeinfo1)
+    NewRelic::Agent::SystemInfo.stubs(:processor_count).returns(4)
+
+    s = NewRelic::Agent::Samplers::CpuSampler.new # this calls poll
+    advance_time(elapsed)
     s.poll
 
-    systemtime_stats = s.stats_engine.get_stats_no_scope("CPU/System Time")
-    usertime_stats = s.stats_engine.get_stats_no_scope("CPU/User Time")
-    assert_equal 2, systemtime_stats.call_count
-    assert_equal 2, usertime_stats.call_count
-    assert usertime_stats.total_call_time >= 0, "user cpu greater/equal to 0: #{usertime_stats.total_call_time}"
-    assert systemtime_stats.total_call_time >= 0, "system cpu greater/equal to 0: #{systemtime_stats.total_call_time}"
+    assert_metrics_recorded({
+      'CPU/User Time'   => { :call_count => 1, :total_call_time => 4.0 },
+      'CPU/System Time' => { :call_count => 1, :total_call_time => 2.0 },
+      # (4s user time)   / ((10s elapsed time) * 4 cpus) = 0.1
+      'CPU/User/Utilization'   => { :call_count => 1, :total_call_time => 0.1 },
+      # (2s system time) / ((10s elapsed time) * 4 cpus) = 0.05
+      'CPU/System/Utilization' => { :call_count => 1, :total_call_time => 0.05 }
+    })
   end
+
   def test_memory__default
     s = NewRelic::Agent::Samplers::MemorySampler.new
     s.stats_engine = @stats_engine
@@ -64,6 +76,7 @@ class NewRelic::Agent::StatsEngine::SamplersTest < Test::Unit::TestCase
     assert_equal(3, stats.call_count)
     assert stats.total_call_time > 0.5, "cpu greater than 0.5 ms: #{stats.total_call_time}"
   end
+
   def test_memory__linux
     return if RUBY_PLATFORM =~ /darwin/
     NewRelic::Agent::Samplers::MemorySampler.any_instance.stubs(:platform).returns 'linux'
@@ -76,6 +89,7 @@ class NewRelic::Agent::StatsEngine::SamplersTest < Test::Unit::TestCase
     assert_equal 3, stats.call_count
     assert stats.total_call_time > 0.5, "cpu greater than 0.5 ms: #{stats.total_call_time}"
   end
+
   def test_memory__solaris
     return if defined? JRuby
     NewRelic::Agent::Samplers::MemorySampler.any_instance.stubs(:platform).returns 'solaris'
@@ -87,6 +101,7 @@ class NewRelic::Agent::StatsEngine::SamplersTest < Test::Unit::TestCase
     assert_equal 1, stats.call_count
     assert_equal 999, stats.total_call_time
   end
+
   def test_memory__windows
     return if defined? JRuby
     NewRelic::Agent::Samplers::MemorySampler.any_instance.stubs(:platform).returns 'win32'
@@ -94,6 +109,7 @@ class NewRelic::Agent::StatsEngine::SamplersTest < Test::Unit::TestCase
       NewRelic::Agent::Samplers::MemorySampler.new
     end
   end
+
   def test_load_samplers
     @stats_engine.expects(:add_harvest_sampler).at_least_once unless defined? JRuby
     @stats_engine.expects(:add_sampler).never
@@ -101,6 +117,7 @@ class NewRelic::Agent::StatsEngine::SamplersTest < Test::Unit::TestCase
     sampler_count = 4
     assert_equal sampler_count, NewRelic::Agent::Sampler.sampler_classes.size, NewRelic::Agent::Sampler.sampler_classes.inspect
   end
+
   def test_memory__is_supported
     NewRelic::Agent::Samplers::MemorySampler.stubs(:platform).returns 'windows'
     assert !NewRelic::Agent::Samplers::MemorySampler.supported_on_this_platform? || defined? JRuby

data/test/new_relic/agent/stats_engine_test.rb

@@ -21,11 +21,11 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
   end
 
   def test_scope
-    @engine.push_scope "scope1"
-    assert @engine.peek_scope.name == "scope1"
+    @engine.push_scope(:scope1)
+    assert_equal 1, @engine.scope_stack.size
 
-    expected = @engine.push_scope "scope2"
-    @engine.pop_scope expected, 0
+    expected = @engine.push_scope(:scope2)
+    @engine.pop_scope(expected, "name 2")
 
     scoped = @engine.get_stats "a"
     scoped.trace_call 3
@@ -40,32 +40,30 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
   def test_scope__overlap
     NewRelic::Agent.instance.stubs(:stats_engine).returns(@engine)
 
-    @engine.scope_name = 'orlando'
-    self.class.trace_execution_scoped('disney', :deduct_call_time_from_parent => false) { sleep 0.1 }
-    orlando_disney = @engine.get_stats 'disney'
+    in_transaction('orlando') do
+      self.class.trace_execution_scoped('disney', :deduct_call_time_from_parent => false) { sleep 0.1 }
+    end
+    orlando_disney = @engine.lookup_stats('disney', 'orlando')
 
-    @engine.scope_name = 'anaheim'
-    self.class.trace_execution_scoped('disney', :deduct_call_time_from_parent => false) { sleep 0.1 }
-    anaheim_disney = @engine.get_stats 'disney'
+    in_transaction('anaheim') do
+      self.class.trace_execution_scoped('disney', :deduct_call_time_from_parent => false) { sleep 0.11 }
+    end
+    anaheim_disney = @engine.lookup_stats('disney', 'anaheim')
 
-    disney = @engine.get_stats_no_scope "disney"
+    disney = @engine.lookup_stats("disney")
 
     assert_not_same orlando_disney, anaheim_disney
     assert_not_equal orlando_disney, anaheim_disney
     assert_equal 1, orlando_disney.call_count
     assert_equal 1, anaheim_disney.call_count
-    assert_same disney, orlando_disney.unscoped_stats
-    assert_same disney, anaheim_disney.unscoped_stats
     assert_equal 2, disney.call_count
     assert_equal disney.total_call_time, orlando_disney.total_call_time + anaheim_disney.total_call_time
-
   end
 
   def test_simplethrowcase(depth=0)
-
     fail "doh" if depth == 10
 
-    scope = @engine.push_scope "scope#{depth}"
+    scope = @engine.push_scope(:"scope#{depth}")
 
     begin
       test_simplethrowcase(depth+1)
@@ -74,90 +72,85 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
         raise e
       end
     ensure
-      @engine.pop_scope scope, 0
+      @engine.pop_scope(scope, "name #{depth}")
     end
 
     if depth == 0
-      assert @engine.peek_scope.nil?
+      assert @engine.scope_stack.empty?
     end
   end
 
 
   def test_scope_failure
-    scope1 = @engine.push_scope "scope1"
-    @engine.push_scope "scope2"
-
-    begin
-      @engine.pop_scope scope1
-      fail "Didn't throw when scope push/pop mismatched"
-    rescue
-      # success
+    scope1 = @engine.push_scope(:scope1)
+    scope2 = @engine.push_scope(:scope2)
+    assert_raises(RuntimeError) do
+      @engine.pop_scope(scope1, "name 1")
     end
   end
 
   def test_children_time
     t1 = Time.now
 
-    expected1 = @engine.push_scope "a"
+    expected1 = @engine.push_scope(:a)
     sleep 0.001
     t2 = Time.now
 
-    expected2 = @engine.push_scope "b"
+    expected2 = @engine.push_scope(:b)
     sleep 0.002
     t3 = Time.now
 
-    expected = @engine.push_scope "c"
+    expected = @engine.push_scope(:c)
     sleep 0.003
-    scope = @engine.pop_scope expected, Time.now - t3
+    scope = @engine.pop_scope(expected, "metric c")
 
     t4 = Time.now
 
     check_time_approximate 0, scope.children_time
-    check_time_approximate 0.003, @engine.peek_scope.children_time
 
     sleep 0.001
     t5 = Time.now
 
-    expected = @engine.push_scope "d"
+    expected = @engine.push_scope(:d)
     sleep 0.002
-    scope = @engine.pop_scope expected, Time.now - t5
+    scope = @engine.pop_scope(expected, "metric d")
 
     t6 = Time.now
 
     check_time_approximate 0, scope.children_time
 
-    scope = @engine.pop_scope expected2, Time.now - t2
-    assert_equal scope.name, 'b'
+    scope = @engine.pop_scope(expected2, "metric b")
+    assert_equal 'metric b', scope.name
 
-    check_time_approximate (t4 - t3) + (t6 - t5), scope.children_time
+    check_time_approximate((t4 - t3) + (t6 - t5), scope.children_time)
 
-    scope = @engine.pop_scope expected1, Time.now - t1
-    assert_equal scope.name, 'a'
+    scope = @engine.pop_scope(expected1, "metric a")
+    assert_equal scope.name, 'metric a'
 
-    check_time_approximate (t6 - t2), scope.children_time
+    check_time_approximate((t6 - t2), scope.children_time)
   end
 
   def test_simple_start_transaction
-    assert @engine.peek_scope.nil?
-    scope = @engine.push_scope "scope"
+    assert @engine.scope_stack.empty?
+    scope = @engine.push_scope :tag
     @engine.start_transaction
-    assert !@engine.peek_scope.nil?
-    @engine.pop_scope scope, 0.01
-    assert @engine.peek_scope.nil?
+    assert !@engine.scope_stack.empty?
+    @engine.pop_scope(scope, "name")
+    assert @engine.scope_stack.empty?
     @engine.end_transaction
-    assert @engine.peek_scope.nil?
+    assert @engine.scope_stack.empty?
   end
 
 
   # test for when the scope stack contains an element only used for tts and not metrics
   def test_simple_tt_only_scope
-    scope1 = @engine.push_scope "a", 0, true
-    scope2 = @engine.push_scope "b", 10, false
-    scope3 = @engine.push_scope "c", 20, true
+    scope1 = @engine.push_scope(:a, 0, true)
+    scope2 = @engine.push_scope(:b, 10, false)
+    scope3 = @engine.push_scope(:c, 20, true)
 
-    @engine.pop_scope scope3, 10
-    @engine.pop_scope scope2, 10
-    @engine.pop_scope scope1, 10
+    @engine.pop_scope(scope3, "name a", 30)
+    @engine.pop_scope(scope2, "name b", 20)
+    @engine.pop_scope(scope1, "name c", 10)
 
     assert_equal 0, scope3.children_time
     assert_equal 10, scope2.children_time
@@ -165,15 +158,15 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
   end
 
   def test_double_tt_only_scope
-    scope1 = @engine.push_scope "a", 0, true
-    scope2 = @engine.push_scope "b", 10, false
-    scope3 = @engine.push_scope "c", 20, false
-    scope4 = @engine.push_scope "d", 30, true
-
-    @engine.pop_scope scope4, 10
-    @engine.pop_scope scope3, 10
-    @engine.pop_scope scope2, 10
-    @engine.pop_scope scope1, 10
+    scope1 = @engine.push_scope(:a, 0, true)
+    scope2 = @engine.push_scope(:b, 10, false)
+    scope3 = @engine.push_scope(:c, 20, false)
+    scope4 = @engine.push_scope(:d, 30, true)
+
+    @engine.pop_scope(scope4, "name d", 40)
+    @engine.pop_scope(scope3, "name c", 30)
+    @engine.pop_scope(scope2, "name b", 20)
+    @engine.pop_scope(scope1, "name a", 10)
 
     assert_equal 0, scope4.children_time.round
     assert_equal 10, scope3.children_time.round

data/test/new_relic/agent/thread_test.rb

@@ -24,24 +24,24 @@ class ThreadTest < Test::Unit::TestCase
 
   def test_bucket_thread_as_request
     t = ::Thread.new {}
-    frame = NewRelic::Agent::Instrumentation::MetricFrame.new
-    frame.request = "has a request"
-    t[:newrelic_metric_frame] = frame
+    txn = NewRelic::Agent::Transaction.new
+    txn.request = "has a request"
+    t[:newrelic_transaction] = txn
 
     assert_equal :request, NewRelic::Agent::AgentThread.bucket_thread(t, DONT_CARE)
   end
 
   def test_bucket_thread_as_background
     t = ::Thread.new {}
-    frame = NewRelic::Agent::Instrumentation::MetricFrame.new
-    t[:newrelic_metric_frame] = frame
+    txn = NewRelic::Agent::Transaction.new
+    t[:newrelic_transaction] = txn
 
     assert_equal :background, NewRelic::Agent::AgentThread.bucket_thread(t, DONT_CARE)
   end
 
-  def test_bucket_thread_as_other_if_nil_frame
+  def test_bucket_thread_as_other_if_nil_txn
     t = ::Thread.new {}
-    t[:newrelic_metric_frame] = nil
+    t[:newrelic_transaction] = nil
 
     assert_equal :other, NewRelic::Agent::AgentThread.bucket_thread(t, DONT_CARE)
   end

data/test/new_relic/agent/transaction/pop_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/transaction/pop'
+class NewRelic::Agent::Transaction::PopTest < Test::Unit::TestCase
+  include NewRelic::Agent::Transaction::Pop
+
+  attr_reader :agent
+  attr_reader :transaction_sampler
+  attr_reader :sql_sampler
+
+  def setup
+    @transaction_type_stack = []
+    @agent = mock('agent')
+    @transaction_sampler = mock('transaction sampler')
+    @sql_sampler = mock('sql sampler')
+  end
+
+  def teardown
+    Thread.current[:newrelic_transaction] = nil
+  end
+
+  def test_log_underflow
+    expects_logging(:error, regexp_matches(/Underflow in transaction: /))
+    log_underflow
+  end
+
+  def test_record_transaction_cpu_positive
+    self.expects(:cpu_burn).once.returns(1.0)
+    transaction_sampler.expects(:notice_transaction_cpu_time).with(1.0)
+    record_transaction_cpu
+  end
+
+  def test_record_transaction_cpu_negative
+    self.expects(:cpu_burn).once.returns(nil)
+    # should not be called for the nil case
+    transaction_sampler.expects(:notice_transaction_cpu_time).never
+    record_transaction_cpu
+  end
+
+  def test_normal_cpu_burn_positive
+    @process_cpu_start = 3
+    self.expects(:process_cpu).returns(4)
+    assert_equal 1, normal_cpu_burn
+  end
+
+  def test_normal_cpu_burn_negative
+    @process_cpu_start = nil
+    self.expects(:process_cpu).never
+    assert_equal nil, normal_cpu_burn
+  end
+
+  # def test_jruby_cpu_burn_positive
+  #   @jruby_cpu_start = 3
+  #   self.expects(:jruby_cpu_time).returns(4)
+  #   self.expects(:record_jruby_cpu_burn).with(1)
+  #   assert_equal 1, jruby_cpu_burn
+  # end
+
+  def test_jruby_cpu_burn_negative
+    @jruby_cpu_start = nil
+    self.expects(:jruby_cpu_time).never
+    self.expects(:record_jruby_cpu_burn).never
+    assert_equal nil, jruby_cpu_burn
+  end
+
+  def test_record_jruby_cpu_burn
+    NewRelic::Agent.get_stats_no_scope(NewRelic::Metrics::USER_TIME).expects(:record_data_point).with(1.0)
+    record_jruby_cpu_burn(1.0)
+  end
+
+  def test_cpu_burn_normal
+    self.expects(:normal_cpu_burn).returns(1)
+    self.expects(:jruby_cpu_burn).never
+    assert_equal 1, cpu_burn
+  end
+
+  def test_cpu_burn_jruby
+    self.expects(:normal_cpu_burn).returns(nil)
+    self.expects(:jruby_cpu_burn).returns(2)
+    assert_equal 2, cpu_burn
+  end
+
+  def test_traced
+    NewRelic::Agent.expects(:is_execution_traced?)
+    traced?
+  end
+
+  def test_current_stack_metric
+    self.expects(:metric_name)
+    current_stack_metric
+  end
+end
+

data/test/new_relic/agent/transaction_info_test.rb

@@ -61,9 +61,9 @@ class NewRelic::Agent::TransactionInfoTest < Test::Unit::TestCase
       :apdex_t => 2.0 }
 
     with_config(config, :do_not_cast => true) do
-      txn_info.transaction_name = 'Controller/foo/bar'
+      txn_info.transaction = stub(:name => 'Controller/foo/bar')
       assert_equal 1.5, txn_info.apdex_t
-      txn_info.transaction_name = 'Controller/some/other/txn'
+      txn_info.transaction = stub(:name => 'Controller/some/other')
       assert_equal 2.0, txn_info.apdex_t
     end
   end
@@ -74,9 +74,9 @@ class NewRelic::Agent::TransactionInfoTest < Test::Unit::TestCase
       :apdex_t => 2.0 }
 
     with_config(config, :do_not_cast => true) do
-      txn_info.transaction_name = 'Controller/foo/bar'
+      txn_info.transaction = stub(:name => 'Controller/foo/bar')
       assert_equal 6.0, txn_info.transaction_trace_threshold
-      txn_info.transaction_name = 'Controller/some/other/txn'
+      txn_info.transaction = stub(:name => 'Controller/some/other')
       assert_equal 8.0, txn_info.transaction_trace_threshold
     end
   end
@@ -90,21 +90,10 @@ class NewRelic::Agent::TransactionInfoTest < Test::Unit::TestCase
     }
 
     with_config(config, :do_not_cast => true) do
-      txn_info.transaction_name = 'Controller/foo/bar'
+      txn_info.transaction = stub(:name => 'Controller/foo/bar')
       assert_equal 4.0, txn_info.transaction_trace_threshold
-      txn_info.transaction_name = 'Controller/some/other/txn'
+      txn_info.transaction = stub(:name => 'Controller/some/other')
       assert_equal 4.0, txn_info.transaction_trace_threshold
     end
   end
-
-  def test_transaction_name
-    NewRelic::Agent::TransactionInfo.reset
-    txn = NewRelic::Agent::TransactionInfo.get
-    assert_equal(NewRelic::Agent::TransactionInfo::DEFAULT_TRANSACTION_NAME,
-      txn.transaction_name)
-    assert_equal(false, txn.transaction_name_set?)
-    txn.transaction_name = "foobar"
-    assert_equal("foobar", txn.transaction_name)
-    assert_equal(true, txn.transaction_name_set?)
-  end
 end

data/test/new_relic/agent/transaction_sample_builder_test.rb

@@ -13,7 +13,7 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
   # if it doesn't the core app tests will break.  Not strictly necessary but
   # we'll enforce it with this test for now.
   def test_trace_entry_returns_segment
-    segment = @builder.trace_entry("/Foo/Bar", Time.now)
+    segment = @builder.trace_entry(Time.now)
     assert segment, "Segment should not be nil"
     assert segment.is_a?(NewRelic::TransactionSample::Segment), "Segment should not be a #{segment.class.name}"
   end
@@ -129,19 +129,7 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
       assert_nil segment.metric_name =~ /Rails\/Application Code Loading/
     end
   end
-  def test_unbalanced_handling
-    assert_raise RuntimeError do
-      build_segment("a") do
-        begin
-          build_segment("aa") do
-            build_segment("aaa") do
-              raise "a problem"
-            end
-          end
-          rescue; end
-      end
-    end
-  end
+
   def test_marshal
     build_segment "a" do
       build_segment "ab"
@@ -213,10 +201,14 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
     assert s.exit_timestamp >= s.entry_timestamp
 
     children = s.called_segments
-    last_segment = s
+    parent = s
     children.each do |child|
-      assert child.metric_name > last_segment.metric_name if check_names
-      assert child.entry_timestamp >= last_segment.entry_timestamp
+      if check_names
+        assert(child.metric_name > parent.metric_name,
+               "#{child.metric_name} !> #{parent.metric_name}")
+      end
+      assert(child.entry_timestamp >= parent.entry_timestamp,
+             "#{child.entry_timestamp} !>= #{parent.entry_timestamp}")
       last_metric = child
 
       validate_segment(child, check_names)
@@ -224,7 +216,7 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
   end
 
   def build_segment(metric, time = 0, &proc)
-    @builder.trace_entry(metric, Time.now.to_f)
+    @builder.trace_entry(Time.now.to_f)
     proc.call if proc
     @builder.trace_exit(metric, Time.now.to_f)
   end