ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

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

@@ -9,6 +9,7 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
     puts e
     puts e.backtrace.join("\n")
   end
+  
   def teardown
     @engine.harvest_timeslice_data({},{})
     super
@@ -28,6 +29,7 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
   end
 
   def test_harvest
+    @engine.clear_stats
     s1 = @engine.get_stats "a"
     s2 = @engine.get_stats "c"
 
@@ -35,47 +37,46 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
     s2.trace_call 1
     s2.trace_call 3
 
-    assert @engine.get_stats("a").call_count == 1
-    assert @engine.get_stats("a").total_call_time == 10
+    assert_equal 1, @engine.get_stats("a").call_count
+    assert_equal 10, @engine.get_stats("a").total_call_time
 
-    assert @engine.get_stats("c").call_count == 2
-    assert @engine.get_stats("c").total_call_time == 4
+    assert_equal 2, @engine.get_stats("c").call_count
+    assert_equal 4, @engine.get_stats("c").total_call_time
 
     metric_data = @engine.harvest_timeslice_data({}, {}).values
-
+    
     # after harvest, all the metrics should be reset
-    assert @engine.get_stats("a").call_count == 0
-    assert @engine.get_stats("a").total_call_time == 0
+    assert_equal 0, @engine.get_stats("a").call_count
+    assert_equal 0, @engine.get_stats("a").total_call_time
 
-    assert @engine.get_stats("c").call_count == 0
-    assert @engine.get_stats("c").total_call_time == 0
+    assert_equal 0, @engine.get_stats("c").call_count
+    assert_equal 0, @engine.get_stats("c").total_call_time
 
     metric_data = metric_data.reverse if metric_data[0].metric_spec.name != "a"
 
-    assert metric_data[0].metric_spec.name == "a"
+    assert_equal 'a', metric_data[0].metric_spec.name
 
-    assert metric_data[0].stats.call_count == 1
-    assert metric_data[0].stats.total_call_time == 10
+    assert_equal 1, metric_data[0].stats.call_count
+    assert_equal 10, metric_data[0].stats.total_call_time
   end
 
   def test_harvest_with_merge
     s = @engine.get_stats "a"
     s.trace_call 1
 
-    assert @engine.get_stats("a").call_count == 1
+    assert_equal 1, @engine.get_stats("a").call_count
 
     harvest = @engine.harvest_timeslice_data({}, {})
-    assert s.call_count == 0
+    assert_equal 0, s.call_count
     s.trace_call 2
-    assert s.call_count == 1
+    assert_equal 1, s.call_count
 
     # this calk should merge the contents of the previous harvest,
     # so the stats for metric "a" should have 2 data points
     harvest = @engine.harvest_timeslice_data(harvest, {})
     stats = harvest.fetch(NewRelic::MetricSpec.new("a")).stats
-    assert stats.call_count == 2
-    assert stats.total_call_time == 3
+    assert_equal 2, stats.call_count
+    assert_equal 3, stats.total_call_time
   end
-
 end
 

data/test/new_relic/agent/stats_engine_test.rb

@@ -9,8 +9,10 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
     puts e
     puts e.backtrace.join("\n")
   end
+  
   def teardown
     @engine.harvest_timeslice_data({},{})
+    mocha_teardown
     super
   end
 
@@ -169,17 +171,50 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
     @engine.pop_scope scope2, 10
     @engine.pop_scope scope1, 10
 
-    assert_equal 0, scope4.children_time
-    assert_equal 10, scope3.children_time
-    assert_equal 10, scope2.children_time
-    assert_equal 10, scope1.children_time
+    assert_equal 0, scope4.children_time.round
+    assert_equal 10, scope3.children_time.round
+    assert_equal 10, scope2.children_time.round
+    assert_equal 10, scope1.children_time.round
   end
 
 
+  def test_collect_gc_data
+    GC.disable unless NewRelic::LanguageSupport.using_engine?('jruby')
+    if NewRelic::LanguageSupport.using_engine?('rbx')
+      agent = ::Rubinius::Agent.loopback
+      agent.stubs(:get).with('system.gc.young.total_wallclock') \
+        .returns([:value, 1000], [:value, 2500])
+      agent.stubs(:get).with('system.gc.full.total_wallclock') \
+        .returns([:value, 2000], [:value, 3500])
+      agent.stubs(:get).with('system.gc.young.count') \
+        .returns([:value, 1], [:value, 2])
+      agent.stubs(:get).with('system.gc.full.count') \
+        .returns([:value, 1], [:value, 2])
+      ::Rubinius::Agent.stubs(:loopback).returns(agent)
+    elsif NewRelic::LanguageSupport.using_version?('1.9')
+      ::GC::Profiler.stubs(:enabled?).returns(true)
+      ::GC::Profiler.stubs(:total_time).returns(1.0, 4.0) 
+      ::GC.stubs(:count).returns(1, 3)      
+    elsif NewRelic::LanguageSupport.using_version?('1.8')
+      ::GC.stubs(:time).returns(1000000, 4000000)
+      ::GC.stubs(:collections).returns(1, 3)
+    end
+    
+    engine = NewRelic::Agent.instance.stats_engine
+    scope = engine.push_scope "scope"
+    engine.start_transaction
+    engine.pop_scope scope, 0.01
+    engine.end_transaction
+    
+    gc_stats = engine.get_stats('GC/cumulative')
+    assert_equal 2, gc_stats.call_count
+    assert_equal 3.0, gc_stats.total_call_time
+  ensure
+    GC.enable unless NewRelic::LanguageSupport.using_engine?('jruby')
+  end
+  
   private
   def check_time_approximate(expected, actual)
     assert((expected - actual).abs < 0.1, "Expected between #{expected - 0.1} and #{expected + 0.1}, got #{actual}")
   end
-
 end
-

data/test/new_relic/agent/transaction_info_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'ostruct'
+
+class NewRelic::Agent::TransactionInfoTest < Test::Unit::TestCase
+  def setup
+    @request = OpenStruct.new(:cookies => {'NRAGENT' => 'tk=1234<tag>evil</tag>5678'})
+  end
+  
+  def test_get_token_gets_sanitized_token_from_cookie
+    assert_equal('1234&lt;tag&gt;evil&lt;/tag&gt;5678',
+                 NewRelic::Agent::TransactionInfo.get_token(@request))
+  end
+end

data/test/new_relic/agent/transaction_sample_builder_test.rb

@@ -6,6 +6,14 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
     @builder = NewRelic::Agent::TransactionSampleBuilder.new
   end
 
+  # 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)
+    assert segment, "Segment should not be nil"
+    assert segment.is_a?(NewRelic::TransactionSample::Segment), "Segment should not be a #{segment.class.name}"
+  end
+
   def test_build_sample
     build_segment("a") do
       build_segment("aa") do
@@ -42,7 +50,7 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
     begin
       builder.sample
       assert false
-    rescue Exception => e
+    rescue => e
       # expected
     end
 
@@ -52,7 +60,7 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
 
     begin
       build_segment "b"
-      assert_false
+      assert false
     rescue TypeError => e
       # expected
     end
@@ -94,8 +102,10 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
 
     should_be_a_copy = sample.omit_segments_with('OMIT NOTHING')
     validate_segment should_be_a_copy.root_segment, false
-
-    assert sample.to_s == should_be_a_copy.to_s
+    
+    assert_equal sample.params, should_be_a_copy.params
+    assert_equal(sample.root_segment.to_debug_str(0),
+                 should_be_a_copy.root_segment.to_debug_str(0))
 
     without_code_loading = sample.omit_segments_with('Rails/Application Code Loading')
     validate_segment without_code_loading.root_segment, false
@@ -159,7 +169,20 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
     @builder.finish_trace(Time.now.to_f)
     validate_builder
   end
+  
+  def test_trace_should_not_record_more_than_segment_limit
+    @builder.segment_limit = 3
+    8.times {|i| build_segment i.to_s }
+    assert_equal 3, @builder.sample.count_segments
+  end
 
+  # regression
+  def test_trace_should_log_segment_reached_once
+    @builder.segment_limit = 3
+    NewRelic::Control.instance.log.expects(:debug).once
+    8.times {|i| build_segment i.to_s }
+  end
+  
   def validate_builder(check_names = true)
     validate_segment @builder.sample.root_segment, check_names
   end

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -57,6 +57,15 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     assert(lock.is_a?(Mutex), "Samples lock should be a mutex, is: #{lock.inspect}")
   end
 
+  def test_configure
+    control = NewRelic::Control.instance
+    control.merge_options('transaction_tracer' => {'stack_trace_threshold' => 5.0, 'limit_segments' => 20, 'explain_threshold' => 4.0})
+    @sampler.configure!
+    assert_equal 20, @sampler.instance_variable_get('@segment_limit')
+    assert_equal 5.0, @sampler.instance_variable_get('@stack_trace_threshold')
+    assert_equal 4.0, @sampler.instance_variable_get('@explain_threshold')
+  end
+
   def test_current_sample_id_default
     builder = mock('builder')
     builder.expects(:sample_id).returns(11111)
@@ -77,10 +86,10 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_disable
-    assert_equal(nil, @sampler.instance_variable_get('@disabled'))
+    assert_nil @sampler.instance_variable_get('@disabled')
     @sampler.disable
-    assert_equal(true, @sampler.instance_variable_get('@disabled'))
-    assert_equal(nil, NewRelic::Agent.instance.stats_engine.instance_variable_get('@transaction_sampler'))
+    assert @sampler.instance_variable_get('@disabled')
+    assert_nil NewRelic::Agent.instance.stats_engine.instance_variable_get('@transaction_sampler')
   end
 
   def test_sampling_rate_equals_default
@@ -238,7 +247,8 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_store_sample_for_developer_mode_no_dev
-    NewRelic::Control.instance.expects(:developer_mode?).returns(false)
+    NewRelic::Control.instance.stubs(:developer_mode?).returns(false)
+    @sampler.configure!
     sample = mock('sample')
     @sampler.store_sample_for_developer_mode(sample)
     assert_equal([], @sampler.instance_variable_get('@samples'))
@@ -255,7 +265,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     assert_equal(new_sample, @sampler.instance_variable_get('@slowest_sample'))
   end
 
-
   def test_store_slowest_sample_not_slowest
     old_sample = mock('old_sample')
     new_sample = mock('new_sample')
@@ -288,7 +297,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     new_sample.expects(:duration).returns(1.0)
     assert_equal(true, @sampler.slowest_sample?(old_sample, new_sample))
   end
-
+    
   def test_truncate_samples_no_samples
     @sampler.instance_eval { @max_samples = 10 }
     @sampler.instance_eval { @samples = [] }
@@ -518,19 +527,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     assert_equal([], result, "should not add samples to the array when harvest count is not moduli sampling rate")
   end
 
-  def test_add_random_sample_to_duplicate
-    @sampler.instance_eval { @random_sampling = true }
-    sample = mock('sample')
-    @sampler.instance_eval {
-      @harvest_count = 1
-      @sampling_rate = 2
-      @random_sample = sample
-    }
-    result = [sample]
-    @sampler.add_random_sample_to(result)
-    assert_equal([sample], result, "should not add duplicate samples to the array")
-  end
-
   def test_add_random_sample_to_activated
     @sampler.instance_eval { @random_sampling = true }
     sample = mock('sample')
@@ -557,7 +553,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     assert_equal([], result, "should not add the sample to the array")
   end
 
-
   def test_add_samples_to_no_data
     result = []
     slow_threshold = 2.0
@@ -569,6 +564,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   def test_add_samples_to_one_result
     sample = mock('sample')
     sample.expects(:duration).returns(1).at_least_once
+    sample.stubs(:force_persist).returns(false)
     result = [sample]
     slow_threshold = 2.0
     @sampler.instance_eval { @slowest_sample = nil }
@@ -601,6 +597,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     slower_sample.expects(:duration).returns(10.0).at_least_once
     faster_sample = mock('faster')
     faster_sample.expects(:duration).returns(5.0).at_least_once
+    faster_sample.stubs(:force_persist).returns(false)
     result = [faster_sample]
     slow_threshold = 2.0
     @sampler.instance_eval { @slowest_sample = slower_sample }
@@ -611,6 +608,8 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   def test_add_samples_to_keep_older_slower_sample
     slower_sample = mock('slower')
     slower_sample.expects(:duration).returns(10.0).at_least_once
+    slower_sample.stubs(:force_persist).returns(false)
+    
     faster_sample = mock('faster')
     faster_sample.expects(:duration).returns(5.0).at_least_once
     result = [slower_sample]
@@ -619,6 +618,22 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     @sampler.expects(:add_random_sample_to).with([slower_sample])
     assert_equal([slower_sample], @sampler.add_samples_to(result, slow_threshold))
   end
+    
+  def test_keep_force_persist
+    sample1 = mock('regular')
+    sample1.stubs(:duration).returns(10)
+    sample1.stubs(:force_persist).returns(false)
+    
+    sample2 = mock('force_persist')
+    sample2.stubs(:duration).returns(1)
+    sample2.stubs(:force_persist).returns(true)
+    
+    result = @sampler.add_samples_to([sample1,sample2], 2.0)
+    
+    assert_equal 2, result.length
+    assert_equal sample1, result[0]
+    assert_equal sample2, result[1]
+  end  
 
   def test_start_builder_default
     Thread.current[:record_tt] = true
@@ -641,6 +656,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     @sampler.expects(:disabled).returns(false)
     @sampler.send(:start_builder)
     assert_equal(fake_builder, Thread.current[:transaction_sample_builder], "should not overwrite an existing transaction sample builder")
+    Thread.current[:transaction_sample_builder] = nil
   end
 
   def test_builder
@@ -659,7 +675,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   # generally usefully so
 
   def test_multiple_samples
-
     run_sample_trace
     run_sample_trace
     run_sample_trace
@@ -732,7 +747,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   # sample traces, for example. It's unfortunate, but we can't
   # reliably turn off GC on all versions of ruby under test
   def test_harvest_slowest
-
     run_sample_trace
     run_sample_trace
     run_sample_trace { sleep 0.1 }
@@ -740,24 +754,22 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     run_sample_trace
 
     slowest = @sampler.harvest(nil, 0)[0]
-    assert((slowest.duration >= 0.09), "expected sample duration >= 0.09, but was: #{slowest.duration.inspect}")
-    # this assert is here to make sure the test remains valid
-    assert((slowest.duration <= 0.15), "expected sample duration <= 0.15, but was: #{slowest.duration.inspect}")
-
+    first_duration = slowest.duration
+    assert((first_duration >= 0.1),
+           "expected sample duration >= 0.1, but was: #{slowest.duration.inspect}")
 
     run_sample_trace { sleep 0.0001 }
     not_as_slow = @sampler.harvest(slowest, 0)[0]
     assert((not_as_slow == slowest), "Should re-harvest the same transaction since it should be slower than the new transaction - expected #{slowest.inspect} but got #{not_as_slow.inspect}")
 
-    run_sample_trace { sleep 0.16 }
+    run_sample_trace { sleep(first_duration + 0.1) }
+
     new_slowest = @sampler.harvest(slowest, 0)[0]
     assert((new_slowest != slowest), "Should not harvest the same trace since the new one should be slower")
-    assert((new_slowest.duration >= 0.15), "Slowest duration must be >= 0.15, but was: #{new_slowest.duration.inspect}")
+    assert((new_slowest.duration >= first_duration + 0.1), "Slowest duration must be >= #{first_duration + 0.1}, but was: #{new_slowest.duration.inspect}")
   end
 
-
   def test_prepare_to_send
-
     run_sample_trace { sleep 0.002 }
     sample = @sampler.harvest(nil, 0)[0]
 
@@ -784,7 +796,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_sample_with_parallel_paths
-
     assert_equal 0, @sampler.scope_depth
 
     @sampler.notice_first_scope_push Time.now.to_f
@@ -810,7 +821,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_double_scope_stack_empty
-
     @sampler.notice_first_scope_push Time.now.to_f
     @sampler.notice_transaction "/path", nil, {}
     @sampler.notice_push_scope "a"
@@ -825,7 +835,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
 
 
   def test_record_sql_off
-
     @sampler.notice_first_scope_push Time.now.to_f
 
     Thread::current[:record_sql] = false
@@ -849,8 +858,8 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     assert segment[:sql]
     assert segment[:backtrace]
   end
+  
   def test_stack_trace__scope
-
     @sampler.stack_trace_threshold = 0
     t = Time.now
     @sampler.notice_first_scope_push t.to_f
@@ -861,7 +870,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_nil_stacktrace
-
     @sampler.stack_trace_threshold = 2
 
     @sampler.notice_first_scope_push Time.now.to_f
@@ -875,7 +883,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
   end
 
   def test_big_sql
-
     @sampler.notice_first_scope_push Time.now.to_f
 
     sql = "SADJKHASDHASD KAJSDH ASKDH ASKDHASDK JASHD KASJDH ASKDJHSAKDJHAS DKJHSADKJSAH DKJASHD SAKJDH SAKDJHS"
@@ -893,9 +900,7 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     assert sql.length <= 16384
   end
 
-
   def test_segment_obfuscated
-
     @sampler.notice_first_scope_push Time.now.to_f
     @sampler.notice_push_scope "foo"
 
@@ -910,7 +915,6 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
     @sampler.notice_pop_scope "foo"
   end
 
-
   def test_param_capture
     [true, false].each do |capture|
       NewRelic::Control.instance.stubs(:capture_params).returns(capture)
@@ -923,23 +927,41 @@ class NewRelic::Agent::TransactionSamplerTest < Test::Unit::TestCase
       assert_equal (capture) ? 1 : 0, tt.params[:request_params].length
     end
   end
-
-
+  
+  def test_should_not_collect_segments_beyond_limit
+    NewRelic::Control.instance.merge_options('transaction_tracer' => {
+                                               'limit_segments' => 3,
+                                             })
+    @sampler.configure!
+    run_sample_trace do
+      @sampler.notice_push_scope 'a1'
+      @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'hallah'", nil, 0)
+      @sampler.notice_push_scope 'a11'
+      @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'semolina'", nil, 0)
+      @sampler.notice_pop_scope "a11"
+      @sampler.notice_pop_scope "a1"
+    end
+    assert_equal 3, @sampler.samples[0].count_segments
+    NewRelic::Control.instance.merge_options('transaction_tracer' => {
+                                               'limit_segments' => 4000,
+                                             })
+  end
+  
   private
-  def run_sample_trace(&proc)
+  
+  def run_sample_trace
     @sampler.notice_first_scope_push Time.now.to_f
     @sampler.notice_transaction '/path', nil, {}
     @sampler.notice_push_scope "a"
     @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'wheat'", nil, 0)
     @sampler.notice_push_scope "ab"
     @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'white'", nil, 0)
-    proc.call if proc
+    yield if block_given?
     @sampler.notice_pop_scope "ab"
-    @sampler.notice_push_scope "lew"
+    @sampler.notice_push_scope "ac"
     @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'french'", nil, 0)
-    @sampler.notice_pop_scope "lew"
+    @sampler.notice_pop_scope "ac"
     @sampler.notice_pop_scope "a"
     @sampler.notice_scope_empty
   end
-
 end