newrelic_rpm 2.8.0

data/test/new_relic/agent/tc_stats_engine.rb

@@ -0,0 +1,218 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require 'test/unit'
+##require 'new_relic/agent/stats_engine'
+
+
+module NewRelic::Agent
+  class StatsEngineTests < Test::Unit::TestCase
+    def setup
+      @engine = StatsEngine.new
+    end
+  
+    def test_get_no_scope
+      s1 = @engine.get_stats "a"
+      s2 = @engine.get_stats "a"
+      s3 = @engine.get_stats "b"
+      
+      assert_not_nil s1
+      assert_not_nil s2
+      assert_not_nil s3
+      
+      assert s1 == s2
+      assert s1 != s3
+    end
+    
+    def test_harvest
+      s1 = @engine.get_stats "a"
+      s2 = @engine.get_stats "c"
+      
+      s1.trace_call 10
+      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 @engine.get_stats("c").call_count == 2
+      assert @engine.get_stats("c").total_call_time == 4
+      
+      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 @engine.get_stats("c").call_count == 0
+      assert @engine.get_stats("c").total_call_time == 0
+
+      metric_data = metric_data.reverse if metric_data[0].metric_spec.name != "a"
+
+      assert metric_data[0].metric_spec.name == "a"
+
+      assert metric_data[0].stats.call_count == 1
+      assert metric_data[0].stats.total_call_time == 10
+    end
+    
+    def test_harvest_with_merge
+      s = @engine.get_stats "a"
+      s.trace_call 1
+      
+      assert @engine.get_stats("a").call_count == 1
+      
+      harvest = @engine.harvest_timeslice_data({}, {})
+      assert s.call_count == 0
+      s.trace_call 2
+      assert s.call_count == 1
+      
+      # 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
+    end
+    
+    def test_scope
+      @engine.push_scope "scope1"
+      assert @engine.peek_scope.name == "scope1"
+      
+      expected = @engine.push_scope "scope2"
+      @engine.pop_scope expected, 0
+      
+      scoped = @engine.get_stats "a"
+      scoped.trace_call 3
+      
+      assert scoped.total_call_time == 3
+      unscoped = @engine.get_stats "a"
+      
+      assert scoped == @engine.get_stats("a")
+      assert unscoped.total_call_time == 3
+    end
+   
+
+    def test_simplethrowcase(depth=0)
+      
+      fail "doh" if depth == 10
+      
+      scope = @engine.push_scope "scope#{depth}"    
+            
+      begin
+        test_simplethrowcase(depth+1)
+      rescue StandardError => e
+        if (depth != 0)
+          raise e
+        end
+      ensure
+        @engine.pop_scope scope, 0
+      end
+      
+      if depth == 0
+        assert @engine.peek_scope.nil?
+      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
+      end
+    end
+    
+    def test_children_time
+      t1 = Time.now
+      
+      expected1 = @engine.push_scope "a"
+        sleep 0.1
+        t2 = Time.now
+
+        expected2 = @engine.push_scope "b"
+          sleep 0.2
+          t3 = Time.now
+          
+          expected = @engine.push_scope "c"
+            sleep 0.3
+          scope = @engine.pop_scope expected, Time.now - t3
+          
+          t4 = Time.now
+    
+          check_time_approximate 0, scope.children_time
+          check_time_approximate 0.3, @engine.peek_scope.children_time
+    
+          sleep 0.1
+          t5 = Time.now
+    
+          expected = @engine.push_scope "d"
+            sleep 0.2
+          scope = @engine.pop_scope expected, Time.now - t5
+          
+          t6 = Time.now
+
+          check_time_approximate 0, scope.children_time
+    
+        scope = @engine.pop_scope expected2, Time.now - t2
+        assert_equal scope.name, 'b'
+        
+        check_time_approximate (t4 - t3) + (t6 - t5), scope.children_time
+      
+      scope = @engine.pop_scope expected1, Time.now - t1
+      assert_equal scope.name, 'a'
+      
+      check_time_approximate (t6 - t2), scope.children_time
+    end
+    
+    def test_simple_start_transaction
+      @engine.push_scope "scope"
+      @engine.start_transaction
+      assert @engine.peek_scope.nil?
+    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
+       
+       @engine.pop_scope scope3, 10
+       @engine.pop_scope scope2, 10
+       @engine.pop_scope scope1, 10
+       
+       assert_equal 0, scope3.children_time
+       assert_equal 10, scope2.children_time
+       assert_equal 10, scope1.children_time 
+    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
+       
+       assert_equal 0, scope4.children_time
+       assert_equal 10, scope3.children_time
+       assert_equal 10, scope2.children_time
+       assert_equal 10, scope1.children_time 
+    end
+    
+
+    private 
+      def check_time_approximate(expected, actual)
+        assert((expected - actual).abs < 0.01, "Expected #{expected}, got #{actual}")
+      end
+
+  end
+  
+
+  
+end

data/test/new_relic/agent/tc_synchronize.rb

@@ -0,0 +1,37 @@
+require 'test/unit'
+##require 'new_relic/agent/testable_agent'
+
+class TestSync
+  include NewRelic::Agent::Synchronize
+end
+
+class AgentSynchronizeTests < Test::Unit::TestCase
+  
+
+  def test_sync
+    t = TestSync.new
+    
+    worked = false
+    t.synchronize_sync do
+      worked = true
+    end
+    
+    assert worked
+    
+    worked = false
+    
+    t.synchronize_mutex do
+      worked = true
+    end
+    
+    assert worked
+    
+    worked = false
+    
+    t.synchronize_thread do
+      worked = true
+    end
+    
+    assert worked
+  end
+end

data/test/new_relic/agent/tc_transaction_sample.rb

@@ -0,0 +1,175 @@
+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"
+
+class NewRelic::TransationSampleTests < Test::Unit::TestCase
+  
+  def setup
+    super
+    NewRelic::Agent::Agent.instance.shutdown
+    NewRelic::Agent::Agent.instance.start(:test, :test)
+  end
+  def shutdown
+    NewRelic::Agent::Agent.instance.shutdown
+    super
+  end
+  def initialize(test)
+    super(test)
+  end
+  
+  def test_sql
+    assert ActiveRecord::Base.test_connection({}).disconnected == false
+    
+    t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    
+    s = t.prepare_to_send(:obfuscate_sql => true, :explain_enabled => true, :explain_sql => 0.00000001)
+    
+    explain_count = 0
+    
+    s.each_segment do |segment|
+      
+      if segment.params[:explanation]
+        explanations = segment.params[:explanation]
+        
+        explanations.each do |explanation|
+          assert_equal Array, explanation.class
+          assert_equal "EXPLAIN #{::SQL_STATEMENT}", explanation[0][0]
+          explain_count += 1
+        end
+      end
+    end
+    
+    assert_equal 2, explain_count
+    assert ActiveRecord::Base.test_connection({}).disconnected
+  end
+  
+  
+  def test_disable_sql
+    t = nil
+    NewRelic::Agent.disable_sql_recording do
+      t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    end
+    
+    s = t.prepare_to_send(:obfuscate_sql => true, :explain_sql => 0.00000001)
+    
+    s.each_segment do |segment|
+      fail if segment.params[:explanation] || segment.params[:obfuscated_sql]
+    end        
+  end
+  
+  
+  def test_disable_tt
+    NewRelic::Agent.disable_transaction_tracing do
+      t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+      assert t.nil?
+    end
+    
+    t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    assert t
+  end
+  
+  
+  def test_record_sql_off
+    t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    
+    s = t.prepare_to_send(:obfuscate_sql => true, :explain_sql => 0.00000001, :record_sql => :off)
+    
+    s.each_segment do |segment|
+      fail if segment.params[:explanation] || segment.params[:obfuscated_sql] || segment.params[:sql]
+    end        
+  end
+  
+  
+  def test_record_sql_raw
+    t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    
+    s = t.prepare_to_send(:obfuscate_sql => true, :explain_sql => 0.00000001, :record_sql => :raw)
+    
+    got_one = false
+    s.each_segment do |segment|
+      fail if segment.params[:obfuscated_sql]
+      got_one = got_one || segment.params[:explanation] || segment.params[:sql]
+    end
+    
+    assert got_one
+  end
+  
+  
+  def test_record_sql_obfuscated
+    t = get_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    
+    s = t.prepare_to_send(:obfuscate_sql => true, :explain_sql => 0.00000001, :record_sql => :obfuscated)
+    
+    got_one = false
+    s.each_segment do |segment|
+      fail if segment.params[:sql]
+      got_one = got_one || segment.params[:explanation] || segment.params[:sql_obfuscated]
+    end        
+    
+    assert got_one
+  end
+  
+  
+  def test_sql_throw
+    ActiveRecord::Base.test_connection({}).throw = true
+    
+    t = get_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 = NewRelic::TransactionSample.new
+    
+    t.params[:test] = "hi"
+    
+    s1 = t.create_segment(1.0, "controller")
+    
+    t.root_segment.add_called_segment(s1)
+    
+    s2 = t.create_segment(2.0, "AR1")
+    
+    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
+    
+    assert_equal 3.0, s1.duration
+    assert_equal 2.0, s1.exclusive_duration
+  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
+    
+    sampler.notice_pop_scope "a"
+    sampler.notice_scope_empty
+    
+    sampler.get_samples[0]
+  end
+  
+  
+end

data/test/new_relic/agent/tc_transaction_sample_builder.rb

@@ -0,0 +1,200 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+##require 'new_relic/agent/transaction_sampler'
+require 'test/unit'
+
+module NewRelic 
+  module Agent
+    class TransationSampleBuilderTests < Test::Unit::TestCase
+
+      def setup
+        @builder = TransactionSampleBuilder.new
+      end
+    
+      def test_build_sample
+        build_segment("a") do
+          build_segment("aa") do
+            build_segment("aaa")
+          end
+          build_segment("ab") do
+            build_segment("aba") do
+              build_segment("abaa")
+            end
+            build_segment("aba")
+            build_segment("abc") do
+              build_segment("abca")
+              build_segment("abcd")
+            end
+          end
+        end
+        build_segment "b"
+        build_segment "c" do
+          build_segment "ca" 
+          build_segment "cb" do
+            build_segment "cba"
+          end
+        end
+      
+        @builder.finish_trace(Time.now.to_f)
+        validate_builder
+      end
+    
+      def test_freeze
+        build_segment "a" do
+          build_segment "aa"
+        end
+        
+        begin 
+          builder.sample
+          assert false
+        rescue Exception => e
+          # expected
+        end
+        
+        @builder.finish_trace(Time.now.to_f)
+      
+        validate_builder
+      
+        begin
+          build_segment "b"
+          assert_false
+        rescue TypeError => e
+          # expected
+        end
+      end
+      
+      # this is really a test for transaction sample
+      def test_omit_segments_with
+        build_segment "Controller/my_controller/index" do
+          sleep 0.010
+          
+          build_segment "Rails/Application Code Loading" do
+            sleep 0.020
+            
+            build_segment "foo/bar" do
+              sleep 0.010
+            end
+          end
+          
+          build_segment "a" do
+            build_segment "ab"
+            sleep 0.010
+          end
+          build_segment "b" do
+            build_segment "ba"
+              sleep 0.05
+            build_segment "bb"
+            build_segment "bc" do
+              build_segment "bca"
+              sleep 0.05
+            end
+          end
+          build_segment "c"
+        end
+        @builder.finish_trace(Time.now.to_f)
+        
+        validate_builder false
+        
+        sample = @builder.sample
+        
+        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
+        
+        without_code_loading = sample.omit_segments_with('Rails/Application Code Loading')
+        validate_segment without_code_loading.root_segment, false
+        
+        # after we take out code loading, the delta should be approximately
+        # 30 milliseconds
+        delta = (sample.duration - without_code_loading.duration).to_ms
+        
+        # allow a few milliseconds for slop just in case this is running on a 386 ;)
+        assert delta >= 30, "delta #{delta} should be between 30 and 50"
+        # disable this test for a couple days:
+        assert delta <= 50, "delta #{delta} should be between 30 and 50"
+
+        # ensure none of the segments have this regex
+        without_code_loading.each_segment do |segment|
+          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"
+        end
+        build_segment "b" do
+          build_segment "ba"
+          build_segment "bb"
+          build_segment "bc" do
+            build_segment "bca"
+          end
+        end
+        build_segment "c"
+        
+        @builder.finish_trace(Time.now.to_f)
+        validate_builder
+        
+        dump = Marshal.dump @builder.sample
+        sample = Marshal.restore(dump)
+        validate_segment(sample.root_segment)
+      end
+        
+      def test_parallel_first_level_segments
+        build_segment "a" do
+          build_segment "ab"
+        end
+        build_segment "b"
+        build_segment "c"
+        
+        @builder.finish_trace(Time.now.to_f)
+        validate_builder
+      end
+      
+      def validate_builder(check_names = true)
+        validate_segment @builder.sample.root_segment, check_names
+      end
+    
+      def validate_segment(s, check_names = true)
+        parent = s.parent_segment
+
+        unless p.nil?
+          assert p.called_segments.include?(s) 
+          assert p.metric_name.length == s.metric_name.length - 1 if check_names
+          assert p.metric_name < s.metric_name if check_names
+          assert p.entry_timestamp <= s.entry_timestamp
+        end
+      
+        assert s.exit_timestamp >= s.entry_timestamp
+      
+        children = s.called_segments
+        last_segment = s
+        children.each do |child|
+          assert child.metric_name > last_segment.metric_name if check_names
+          assert child.entry_timestamp >= last_segment.entry_timestamp
+          last_metric = child
+        
+          validate_segment(child)
+        end
+      end
+      
+      def build_segment(metric, time = 0, &proc)
+        @builder.trace_entry(metric, Time.now.to_f)
+        proc.call if proc
+        @builder.trace_exit(metric, Time.now.to_f)
+      end
+    end
+  end
+end