newrelic_rpm 2.9.9 → 2.10.3

data/test/new_relic/agent/transaction_sample_builder_test.rb

@@ -106,9 +106,9 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
     
     # Need to allow substantial headroom on the upper bound to prevent 
     # spurious errors.
-    assert delta >= 30, "delta #{delta} should be between 30 and 100"
+    assert delta >= 28, "delta #{delta} should be between 28 and 100"
     # disable this test for a couple days:
-    assert delta <= 100, "delta #{delta} should be between 30 and 100"
+    assert delta <= 100, "delta #{delta} should be between 28 and 100"
     
     # ensure none of the segments have this regex
     without_code_loading.each_segment do |segment|

data/test/new_relic/agent/transaction_sample_test.rb

@@ -1,8 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
 require 'new_relic/agent/mock_ar_connection'
-##require 'new_relic/agent/testable_agent'
-##require 'new_relic/agent/transaction_sampler'
-##require 'new_relic/transaction_sample'
 require 'test/unit'
 
 ::SQL_STATEMENT = "SELECT * from sandwiches"
@@ -14,7 +11,7 @@ NewRelic::TransactionSample::Segment.class_eval do
   
 end
 class NewRelic::TransationSampleTest < Test::Unit::TestCase
-  
+  include TransactionSampleTestHelper
   def setup
     NewRelic::Agent.manual_start
   end
@@ -22,7 +19,7 @@ class NewRelic::TransationSampleTest < Test::Unit::TestCase
   def test_sql
     assert ActiveRecord::Base.test_connection({}).disconnected == false
     
-    t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
     
     s = t.prepare_to_send(:obfuscate_sql => true, :explain_enabled => true, :explain_sql => 0.00000001)
     
@@ -48,7 +45,7 @@ class NewRelic::TransationSampleTest < Test::Unit::TestCase
   def test_disable_sql
     t = nil
     NewRelic::Agent.disable_sql_recording do
-      t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+      t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
     end
     
     s = t.prepare_to_send(:obfuscate_sql => true, :explain_sql => 0.00000001)
@@ -61,17 +58,17 @@ class NewRelic::TransationSampleTest < Test::Unit::TestCase
   
   def test_disable_tt
     NewRelic::Agent.disable_transaction_tracing do
-      t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+      t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
       assert t.nil?
     end
-    
-    t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+  end
+  def test_enabled_tt
+    t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
     assert t
   end
   
-  
   def test_record_sql_off
-    t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
     
     s = t.prepare_to_send(:obfuscate_sql => true, :explain_sql => 0.00000001, :record_sql => :off)
     
@@ -82,7 +79,7 @@ class NewRelic::TransationSampleTest < Test::Unit::TestCase
   
   
   def test_record_sql_raw
-    t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
     
     s = t.prepare_to_send(:obfuscate_sql => true, :explain_sql => 0.00000001, :record_sql => :raw)
     
@@ -97,7 +94,7 @@ class NewRelic::TransationSampleTest < Test::Unit::TestCase
   
   
   def test_record_sql_obfuscated
-    t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
     
     s = t.prepare_to_send(:obfuscate_sql => true, :explain_sql => 0.00000001, :record_sql => :obfuscated)
     
@@ -114,13 +111,39 @@ class NewRelic::TransationSampleTest < Test::Unit::TestCase
   def test_sql_throw
     ActiveRecord::Base.test_connection({}).throw = true
     
-    t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
     
     # the sql connection will throw
     t.prepare_to_send(:obfuscate_sql => true, :explain_sql => 0.00000001)
   end
   
+
   def test_exclusive_duration
+    t = nested_sample
+    s1 = t.root_segment.called_segments.first
+    assert_equal 3.0, s1.duration
+    assert_equal 2.0, s1.exclusive_duration
+  end
+  
+  def test_count
+    assert_equal 4, nested_sample.count_segments
+  end
+  
+  
+  def test_truncate
+    sample = nested_sample
+    sample.truncate(2)
+    assert_equal 2, sample.count_segments
+    
+    sample = large_sample
+    assert_equal 101, large_sample.count_segments
+    sample.truncate(2)
+    assert_equal 2, sample.count_segments
+    assert_equal 101, sample.params[:segment_count]
+  end
+    
+  private
+  def nested_sample
     t = NewRelic::TransactionSample.new
     
     t.params[:test] = "hi"
@@ -133,39 +156,31 @@ class NewRelic::TransationSampleTest < Test::Unit::TestCase
     
     s2.params[:test] = "test"
     
-    s2.to_s
-    
     s1.add_called_segment(s2)
-    
     s2.end_trace 3.0
     s1.end_trace 4.0
     
-    t.to_s
+    s3 = t.create_segment(4.0, "post_filter")
+    t.root_segment.add_called_segment(s3)
+    s3.end_trace 6.0
     
-    assert_equal 3.0, s1.duration
-    assert_equal 2.0, s1.exclusive_duration
+    s4 = t.create_segment(6.0, "post_filter")
+    t.root_segment.add_called_segment(s4)
+    s4.end_trace 7.0
+    t
   end
   
-  
-  
-  private
-  def get_sql_transaction(*sql)
-    sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
-    sampler.notice_first_scope_push Time.now.to_f
-    sampler.notice_transaction '/path', nil, :jim => "cool"
-    sampler.notice_push_scope "a"
-    
-    sampler.notice_transaction '/path/2', nil, :jim => "cool"
-    
-    sql.each {|sql_statement| sampler.notice_sql(sql_statement, {:adapter => "test"}, 0 ) }
-    
-    sleep 1.0
+  def large_sample
+    t = NewRelic::TransactionSample.new
     
-    sampler.notice_pop_scope "a"
-    sampler.notice_scope_empty
+    s1 = t.create_segment(1.0, "controller")
+    t.root_segment.add_called_segment(s1)
     
-    sampler.samples[0]
+    100.times do
+      s1.add_called_segment(t.create_segment(1.0, "segment"))
+    end
+    t
   end
   
-  
+
 end

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -1,18 +1,32 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
-##require 'new_relic/agent/transaction_sampler'
 
-NewRelic::Agent::TransactionSampler.send :public, :builder
-
-class NewRelic::Agent::TransationSamplerTest < Test::Unit::TestCase
+class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   
+  module MockGCStats
+    
+    def time
+      return 0 if @@values.empty?
+      raise "too many calls" if @@index >= @@values.size
+      @@curtime ||= 0
+      @@curtime += (@@values[@@index] * 1e09).to_i
+      @@index += 1
+      @@curtime
+    end
+    
+    def self.mock_values= array
+      @@values = array
+      @@index = 0
+    end
+    
+  end
+
   def setup
     Thread::current[:record_sql] = nil
-    mock_agent = mock()
-    stats_engine_mock = mock()
-    stats_engine_mock.stubs(:add_scope_stack_listener)
-    mock_agent.stubs(:stats_engine).returns(stats_engine_mock)
-    mock_agent.stubs(:set_sql_obfuscator).returns(stats_engine_mock)
-    @sampler = NewRelic::Agent::TransactionSampler.new(mock_agent)
+    agent = NewRelic::Agent.instance
+    stats_engine = NewRelic::Agent::StatsEngine.new
+    agent.stubs(:stats_engine).returns(stats_engine)
+    @sampler = NewRelic::Agent::TransactionSampler.new
+    stats_engine.transaction_sampler = @sampler
   end
   
   def test_multiple_samples
@@ -28,6 +42,56 @@ class NewRelic::Agent::TransationSamplerTest < Test::Unit::TestCase
     assert_equal "a", samples.last.root_segment.called_segments[0].metric_name
   end
 
+  def test_sample_tree
+    assert_equal 0, @sampler.scope_depth
+    
+    @sampler.notice_first_scope_push Time.now.to_f
+    @sampler.notice_transaction "/path", nil, {}
+    @sampler.notice_push_scope "a"
+    
+    @sampler.notice_push_scope "b"
+    @sampler.notice_pop_scope "b"
+    
+    @sampler.notice_push_scope "c"
+    @sampler.notice_push_scope "d"
+    @sampler.notice_pop_scope "d"
+    @sampler.notice_pop_scope "c"
+    
+    @sampler.notice_pop_scope "a"
+    @sampler.notice_scope_empty
+    sample = @sampler.harvest([],0.0).first
+    assert_equal "ROOT{a{b,c{d}}}", sample.to_s_compact
+    
+  end
+
+  def test_sample__gc_stats
+    GC.extend MockGCStats
+    # These are effectively Garbage Collects, detected each time GC.time is
+    # called by the transaction sampler.  One time value in seconds for each call.
+    MockGCStats.mock_values = [0,0,0,1,0,0,1,0,0,0,0,0,0,0,0]
+    assert_equal 0, @sampler.scope_depth
+    
+    @sampler.notice_first_scope_push Time.now.to_f
+    @sampler.notice_transaction "/path", nil, {}
+    @sampler.notice_push_scope "a"
+
+    @sampler.notice_push_scope "b"
+    @sampler.notice_pop_scope "b"
+
+    @sampler.notice_push_scope "c"
+    @sampler.notice_push_scope "d"
+    @sampler.notice_pop_scope "d"
+    @sampler.notice_pop_scope "c"
+
+    @sampler.notice_pop_scope "a"
+    @sampler.notice_scope_empty
+    
+    sample = @sampler.harvest([],0.0).first
+    assert_equal "ROOT{a{b,c{d}}}", sample.to_s_compact
+  ensure
+    MockGCStats.mock_values = []
+  end
+
   def test_sample_id 
     run_sample_trace do 
       assert @sampler.current_sample_id != 0, @sampler.current_sample_id 
@@ -49,10 +113,10 @@ class NewRelic::Agent::TransationSamplerTest < Test::Unit::TestCase
     not_as_slow = @sampler.harvest(slowest, 0)[0]
     assert not_as_slow == slowest
     
-    run_sample_trace { sleep 0.6 }
+    run_sample_trace { sleep 0.601 }
     new_slowest = @sampler.harvest(slowest, 0)[0]
     assert new_slowest != slowest
-    assert new_slowest.duration >= 0.6
+    assert new_slowest.duration >= 0.600, "Slowest duration must be > 0.6: #{new_slowest.duration}"
   end
   
   
@@ -103,6 +167,10 @@ class NewRelic::Agent::TransationSamplerTest < Test::Unit::TestCase
     @sampler.notice_push_scope "a"
     @sampler.notice_pop_scope "a"
     @sampler.notice_scope_empty
+    
+    assert_equal 0, @sampler.scope_depth
+    sample = @sampler.harvest(nil, 0.0).first
+    assert_equal "ROOT{a}", sample.to_s_compact
   end
   
   def test_double_scope_stack_empty
@@ -128,7 +196,7 @@ class NewRelic::Agent::TransationSamplerTest < Test::Unit::TestCase
     
     @sampler.notice_sql("test", nil, 0)
     
-    segment = @sampler.builder.current_segment
+    segment = @sampler.send(:builder).current_segment
     
     assert_nil segment[:sql]
   end
@@ -140,7 +208,7 @@ class NewRelic::Agent::TransationSamplerTest < Test::Unit::TestCase
     
     @sampler.notice_sql("test", nil, 1)
     
-    segment = @sampler.builder.current_segment
+    segment = @sampler.send(:builder).current_segment
     
     assert segment[:sql]
     assert segment[:backtrace]
@@ -152,7 +220,7 @@ class NewRelic::Agent::TransationSamplerTest < Test::Unit::TestCase
     @sampler.notice_first_scope_push t.to_f
     @sampler.notice_push_scope 'Bill', (t+1.second).to_f
     
-    segment = @sampler.builder.current_segment
+    segment = @sampler.send(:builder).current_segment
     assert segment[:backtrace]
   end
   
@@ -164,7 +232,7 @@ class NewRelic::Agent::TransationSamplerTest < Test::Unit::TestCase
     
     @sampler.notice_sql("test", nil, 1)
     
-    segment = @sampler.builder.current_segment
+    segment = @sampler.send(:builder).current_segment
     
     assert segment[:sql]
     assert_nil segment[:backtrace]
@@ -182,7 +250,7 @@ class NewRelic::Agent::TransationSamplerTest < Test::Unit::TestCase
       len += sql.length
     end
     
-    segment = @sampler.builder.current_segment
+    segment = @sampler.send(:builder).current_segment
     
     sql = segment[:sql]
     
@@ -198,7 +266,7 @@ class NewRelic::Agent::TransationSamplerTest < Test::Unit::TestCase
     
     @sampler.notice_sql(orig_sql, nil, 0)
     
-    segment = @sampler.builder.current_segment
+    segment = @sampler.send(:builder).current_segment
     
     assert_equal orig_sql, segment[:sql]
     assert_equal "SELECT * from Jim where id=?", segment.obfuscated_sql
@@ -223,52 +291,52 @@ class NewRelic::Agent::TransationSamplerTest < Test::Unit::TestCase
     
     # basic statement
     assert_equal "INSERT INTO X values(?,?, ? , ?)", 
-    @sampler.default_sql_obfuscator("INSERT INTO X values('test',0, 1 , 2)")
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, "INSERT INTO X values('test',0, 1 , 2)")
     
     # escaped literals
     assert_equal "INSERT INTO X values(?, ?,?, ? , ?)", 
-    @sampler.default_sql_obfuscator("INSERT INTO X values('', 'jim''s ssn',0, 1 , 'jim''s son''s son')")
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, "INSERT INTO X values('', 'jim''s ssn',0, 1 , 'jim''s son''s son')")
     
     # multiple string literals             
     assert_equal "INSERT INTO X values(?,?,?, ? , ?)", 
-    @sampler.default_sql_obfuscator("INSERT INTO X values('jim''s ssn','x',0, 1 , 2)")
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, "INSERT INTO X values('jim''s ssn','x',0, 1 , 2)")
     
     # empty string literal
     # NOTE: the empty string literal resolves to empty string, which for our purposes is acceptable
     assert_equal "INSERT INTO X values(?,?,?, ? , ?)", 
-    @sampler.default_sql_obfuscator("INSERT INTO X values('','x',0, 1 , 2)")
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, "INSERT INTO X values('','x',0, 1 , 2)")
     
     # try a select statement             
     assert_equal "select * from table where name=? and ssn=?",
-    @sampler.default_sql_obfuscator("select * from table where name='jim gochee' and ssn=0012211223")
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, "select * from table where name='jim gochee' and ssn=0012211223")
     
     # number literals embedded in sql - oh well
     assert_equal "select * from table_? where name=? and ssn=?",
-    @sampler.default_sql_obfuscator("select * from table_007 where name='jim gochee' and ssn=0012211223")
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, "select * from table_007 where name='jim gochee' and ssn=0012211223")
   end
   
   def test_sql_normalization__single_quotes
     assert_equal "INSERT ? into table",
-    @sampler.default_sql_obfuscator("INSERT 'this isn''t a real value' into table")
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, "INSERT 'this isn''t a real value' into table")
     assert_equal "INSERT ? into table",
-    @sampler.default_sql_obfuscator(%q[INSERT '"' into table])
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT '"' into table])
     assert_equal "INSERT ? into table",
-    @sampler.default_sql_obfuscator(%q[INSERT ' "some text" \" ' into table])
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT ' "some text" \" ' into table])
 #    could not get this one licked.  no biggie    
 #    assert_equal "INSERT ? into table",
-#    @sampler.default_sql_obfuscator(%q[INSERT '\'' into table])
+#    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT '\'' into table])
     assert_equal "INSERT ? into table",
-    @sampler.default_sql_obfuscator(%q[INSERT ''' ' into table])
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT ''' ' into table])
   end
   def test_sql_normalization__double_quotes
     assert_equal "INSERT ? into table",
-    @sampler.default_sql_obfuscator(%q[INSERT "this isn't a real value" into table])
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT "this isn't a real value" into table])
     assert_equal "INSERT ? into table",
-    @sampler.default_sql_obfuscator(%q[INSERT "'" into table])
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT "'" into table])
     assert_equal "INSERT ? into table",
-    @sampler.default_sql_obfuscator(%q[INSERT " \" " into table])
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT " \" " into table])
     assert_equal "INSERT ? into table",
-    @sampler.default_sql_obfuscator(%q[INSERT " 'some text' " into table])
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT " 'some text' " into table])
   end
   def test_sql_obfuscation_filters
     orig =  NewRelic::Agent.agent.obfuscator

data/test/new_relic/agent/worker_loop_test.rb

@@ -28,8 +28,8 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
   def test_add_tasks_with_different_periods
     @last_executed = nil
     
-    period1 = 0.2
-    period2 = 0.35
+    period1 = 0.5
+    period2 = 0.7
     
     @worker_loop.add_task(period1) do
       @last_executed = 1
@@ -40,24 +40,24 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     end
     
     @worker_loop.run_next_task
-    assert_equal @last_executed, 1      # 0.2 s
-    check_test_timestamp(0.2)
+    assert_equal @last_executed, 1
+    check_test_timestamp(0.5)
     
     @worker_loop.run_next_task
-    assert_equal @last_executed, 2      # 0.35 s
-    check_test_timestamp(0.35)
+    assert_equal @last_executed, 2
+    check_test_timestamp(0.7)
     
     @worker_loop.run_next_task
-    assert_equal @last_executed, 1      # 0.4 s
-    check_test_timestamp(0.4)
+    assert_equal @last_executed, 1 
+    check_test_timestamp(1.0)
     
     @worker_loop.run_next_task
-    assert_equal @last_executed, 1      # 0.6 s
-    check_test_timestamp(0.6)
+    assert_equal @last_executed, 2
+    check_test_timestamp(1.4)
     
     @worker_loop.run_next_task
-    assert_equal @last_executed, 2      # 0.7 s
-    check_test_timestamp(0.7)
+    assert_equal @last_executed, 1
+    check_test_timestamp(1.5)
   end
   
   def test_task_error__standard
@@ -93,9 +93,11 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
   end
   
   private
+  # The test is expected to have lasted no less than expected
+  # and no more than expected + 100 ms.
   def check_test_timestamp(expected)
     ts = Time.now - @test_start_time
-    delta = (expected - ts).abs
-    assert(delta < 0.05, "#{delta} exceeds 50 milliseconds")
+    delta = ts - expected
+    assert(delta <= 0.250, "#{ts} duration includes a delay of #{delta} that exceeds 250 milliseconds")
   end
 end