newrelic_rpm 2.8.0

data/test/new_relic/agent/tc_transaction_sampler.rb

@@ -0,0 +1,305 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+##require 'new_relic/agent/transaction_sampler'
+
+::RPM_DEVELOPER = true unless defined? ::RPM_DEVELOPER
+
+    class NewRelic::Agent::TransactionSampler
+      public :builder
+    end
+    
+    class NewRelic::Agent::TransationSamplerTests < Test::Unit::TestCase
+      
+      def setup
+        Thread::current[:record_sql] = nil
+      end
+      
+      def test_multiple_samples
+        @sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+      
+        run_sample_trace
+        run_sample_trace
+        run_sample_trace
+        run_sample_trace
+      
+        samples = @sampler.get_samples
+        assert_equal 4, samples.length
+        assert_equal "a", samples.first.root_segment.called_segments[0].metric_name
+        assert_equal "a", samples.last.root_segment.called_segments[0].metric_name
+      end
+      
+      
+      def test_harvest_slowest
+        @sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+        
+        run_sample_trace
+        run_sample_trace
+        run_sample_trace { sleep 0.5 }
+        run_sample_trace
+        run_sample_trace
+        
+        slowest = @sampler.harvest_slowest_sample(nil)
+        assert slowest.duration >= 0.5
+        
+        run_sample_trace { sleep 0.2 }
+        not_as_slow = @sampler.harvest_slowest_sample(slowest)
+        assert not_as_slow == slowest
+        
+        run_sample_trace { sleep 0.6 }
+        new_slowest = @sampler.harvest_slowest_sample(slowest)
+        assert new_slowest != slowest
+        assert new_slowest.duration >= 0.6
+      end
+      
+      
+      def test_preare_to_send
+        @sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+
+        run_sample_trace { sleep 0.2 }
+        sample = @sampler.harvest_slowest_sample(nil)
+        
+        ready_to_send = sample.prepare_to_send
+        assert sample.duration == ready_to_send.duration
+        
+        assert ready_to_send.start_time.is_a?(Time)
+      end
+      
+      def test_multithread
+        @sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+        threads = []
+        
+        20.times do
+          t = Thread.new(@sampler) do |the_sampler|
+            @sampler = the_sampler
+            100.times do
+              run_sample_trace { sleep 0.01 }
+            end
+          end
+          
+          threads << t
+        end
+        threads.each {|t| t.join }
+      end
+      
+      def test_sample_with_parallel_paths
+        @sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+        
+        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"
+        
+        assert_equal 1, @sampler.scope_depth 
+        
+        @sampler.notice_pop_scope "a"
+        @sampler.notice_scope_empty
+
+        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_pop_scope "a"
+        @sampler.notice_scope_empty
+      end
+      
+      def test_double_scope_stack_empty
+        @sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+        
+        @sampler.notice_first_scope_push Time.now.to_f
+        @sampler.notice_transaction "/path", nil, {}
+        @sampler.notice_push_scope "a"
+        @sampler.notice_pop_scope "a"
+        @sampler.notice_scope_empty
+        @sampler.notice_scope_empty
+        @sampler.notice_scope_empty
+        @sampler.notice_scope_empty
+        
+        assert_not_nil @sampler.harvest_slowest_sample(nil)
+      end
+      
+
+      def test_record_sql_off
+        sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+        
+        sampler.notice_first_scope_push Time.now.to_f
+        
+        Thread::current[:record_sql] = false
+        
+        sampler.notice_sql("test", nil, 0)
+        
+        segment = sampler.builder.current_segment
+        
+        assert_nil segment[:sql]
+      end
+
+      def test_stack_trace__sql
+        sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+        
+        sampler.stack_trace_threshold = 0
+        
+        sampler.notice_first_scope_push Time.now.to_f
+        
+        sampler.notice_sql("test", nil, 1)
+        
+        segment = sampler.builder.current_segment
+        
+        assert segment[:sql]
+        assert segment[:backtrace]
+      end
+      def test_stack_trace__scope
+        sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+        
+        sampler.stack_trace_threshold = 0
+        t = Time.now
+        sampler.notice_first_scope_push t.to_f
+        sampler.notice_push_scope 'Bill', (t+1.second).to_f
+        
+        segment = sampler.builder.current_segment
+        assert segment[:backtrace]
+      end
+
+      def test_nil_stacktrace
+        sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+        
+        sampler.stack_trace_threshold = 2
+        
+        sampler.notice_first_scope_push Time.now.to_f
+        
+        sampler.notice_sql("test", nil, 1)
+        
+        segment = sampler.builder.current_segment
+        
+        assert segment[:sql]
+        assert_nil segment[:backtrace]
+      end
+      
+      def test_big_sql
+        @sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+        
+        @sampler.notice_first_scope_push Time.now.to_f
+        
+        sql = "SADJKHASDHASD KAJSDH ASKDH ASKDHASDK JASHD KASJDH ASKDJHSAKDJHAS DKJHSADKJSAH DKJASHD SAKJDH SAKDJHS"
+        
+        len = 0
+        while len <= NewRelic::Agent::TransactionSampler::MAX_SQL_LENGTH
+          @sampler.notice_sql(sql, nil, 0)
+          len += sql.length
+        end
+        
+        segment = @sampler.builder.current_segment
+        
+        sql = segment[:sql]
+        
+        assert sql.length <= NewRelic::Agent::TransactionSampler::MAX_SQL_LENGTH
+      end
+      
+      
+      def test_segment_obfuscated
+        @sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+        
+        @sampler.notice_first_scope_push Time.now.to_f
+        
+        orig_sql = "SELECT * from Jim where id=66"
+        
+        @sampler.notice_sql(orig_sql, nil, 0)
+        
+        segment = @sampler.builder.current_segment
+
+        assert_equal orig_sql, segment[:sql]
+        assert_equal "SELECT * from Jim where id=?", segment.obfuscated_sql
+      end
+      
+      
+      def test_param_capture
+        [true, false].each do |capture| 
+          t = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+          
+          NewRelic::Agent::TransactionSampler.capture_params = capture
+          
+          t.notice_first_scope_push Time.now.to_f
+          t.notice_transaction('/path', nil, {:param => 'hi'})
+          t.notice_scope_empty
+          
+          tt = t.harvest_slowest_sample
+          
+          assert_equal (capture) ? 1 : 0, tt.params[:request_params].length
+        end
+      end
+
+      
+      def test_sql_normalization
+        t = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+        
+        # basic statement
+        assert_equal "INSERT INTO X values(?,?, ? , ?)", 
+                     t.default_sql_obfuscator("INSERT INTO X values('test',0, 1 , 2)")
+                  
+        # escaped literals
+        assert_equal "INSERT INTO X values(?, ?,?, ? , ?)", 
+                     t.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(?,?,?, ? , ?)", 
+                     t.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(?,?,?, ? , ?)", 
+                     t.default_sql_obfuscator("INSERT INTO X values('','x',0, 1 , 2)")
+
+        # try a select statement             
+        assert_equal "select * from table where name=? and ssn=?",
+                     t.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=?",
+                     t.default_sql_obfuscator("select * from table_007 where name='jim gochee' and ssn=0012211223")
+      end
+      
+      def test_sql_obfuscation_filters
+        orig =  NewRelic::Agent.agent.obfuscator
+        
+        NewRelic::Agent.set_sql_obfuscator(:replace) do |sql|
+          sql = "1" + sql
+        end
+        
+        sql = "SELECT * FROM TABLE 123 'jim'"
+        
+        assert_equal "1" + sql, NewRelic::Agent.instance.obfuscator.call(sql)
+        
+        NewRelic::Agent.set_sql_obfuscator(:before) do |sql|
+          sql = "2" + sql
+        end
+
+        assert_equal "12" + sql, NewRelic::Agent.instance.obfuscator.call(sql)
+
+        NewRelic::Agent.set_sql_obfuscator(:after) do |sql|
+          sql = sql + "3"
+        end
+
+        assert_equal "12" + sql + "3", NewRelic::Agent.instance.obfuscator.call(sql)
+        
+        NewRelic::Agent.agent.set_sql_obfuscator(:replace, &orig)
+      end
+      
+      
+    private      
+      def run_sample_trace(&proc)
+        @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
+        @sampler.notice_pop_scope "ab"
+        @sampler.notice_push_scope "lew"
+        @sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'french'", nil, 0)
+        @sampler.notice_pop_scope "lew"
+        @sampler.notice_pop_scope "a"
+        @sampler.notice_scope_empty
+      end
+      
+    end
+

data/test/new_relic/agent/tc_worker_loop.rb

@@ -0,0 +1,101 @@
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+NewRelic::Agent::WorkerLoop.class_eval do 
+  public :run_next_task
+end
+
+class NewRelic::Agent::WorkerLoopTests < Test::Unit::TestCase
+  def setup
+    @log = ""
+    @logger = Logger.new(StringIO.new(@log))
+    @worker_loop = NewRelic::Agent::WorkerLoop.new(@logger)
+    @test_start_time = Time.now
+  end
+  def test_add_task
+    @x = false
+    period = 1.0
+    @worker_loop.add_task(period) do
+      @x = true
+    end
+    
+    assert !@x
+    @worker_loop.run_next_task
+    assert @x
+    check_test_timestamp period
+  end
+  
+  def test_add_tasks_with_different_periods
+    @last_executed = nil
+    
+    period1 = 0.2
+    period2 = 0.35
+    
+    @worker_loop.add_task(period1) do
+      @last_executed = 1
+    end
+    
+    @worker_loop.add_task(period2) do
+      @last_executed = 2
+    end
+    
+    @worker_loop.run_next_task
+    assert_equal @last_executed, 1      # 0.2 s
+    check_test_timestamp(0.2)
+    
+    @worker_loop.run_next_task
+    assert_equal @last_executed, 2      # 0.35 s
+    check_test_timestamp(0.35)
+    
+    @worker_loop.run_next_task
+    assert_equal @last_executed, 1      # 0.4 s
+    check_test_timestamp(0.4)
+    
+    @worker_loop.run_next_task
+    assert_equal @last_executed, 1      # 0.6 s
+    check_test_timestamp(0.6)
+    
+    @worker_loop.run_next_task
+    assert_equal @last_executed, 2      # 0.7 s
+    check_test_timestamp(0.7)
+  end
+  
+  def test_task_error__standard
+    @worker_loop.add_task(0.2) do
+      raise "Standard Error Test"
+    end
+    # Should not throw
+    @logger.expects(:error).once
+    @logger.expects(:debug).never
+    @worker_loop.run_next_task
+    
+  end
+  def test_task_error__runtime
+    @worker_loop.add_task(0.2) do
+      raise RuntimeError, "Runtime Error Test"
+    end
+    # Should not throw, but log at error level
+    # because it detects no agent listener inthe
+    # stack
+    @logger.expects(:error).once
+    @logger.expects(:debug).never
+    @worker_loop.run_next_task
+  end
+
+  def test_task_error__server
+    @worker_loop.add_task(0.2) do
+      raise NewRelic::Agent::ServerError, "Runtime Error Test"
+    end
+    # Should not throw
+    @logger.expects(:error).never
+    @logger.expects(:debug).once
+    @worker_loop.run_next_task
+  end
+  
+  private
+  def check_test_timestamp(expected)
+    ts = Time.now - @test_start_time
+    delta = (expected - ts).abs
+    assert(delta < 0.05, "#{delta} exceeds 50 milliseconds")
+  end
+end

data/test/new_relic/agent/testable_agent.rb

@@ -0,0 +1,13 @@
+
+##require 'new_relic/agent'
+
+
+RAILS_ROOT='.' if !defined? RAILS_ROOT
+
+
+class String
+  def titleize
+    self
+  end
+end
+

data/test/new_relic/tc_config.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'/../test_helper'))
+
+
+module NewRelic
+  class Config
+    public :log_file_name
+  end
+end
+
+class NewRelic::ConfigTests < Test::Unit::TestCase
+  
+  def test_rails_config
+    c = NewRelic::Config.instance
+    assert_equal :rails, c.app
+    assert_equal false, c['enabled']
+    c.local_env
+  end
+
+  def test_config_yaml_erb
+    c = NewRelic::Config.instance
+    assert_equal 'heyheyhey', c['erb_value']
+    assert_equal '', c['message']
+    assert_equal '', c['license_key']
+  end
+  
+  def test_log_file_name
+    c = NewRelic::Config.instance
+    
+    assert_equal "newrelic_agent.3000.log", c.log_file_name("3000")
+    assert_equal "newrelic_agent.passenger_redmine-0.7.log", c.log_file_name("passenger:redmine-0.7")
+    assert_equal "newrelic_agent._tmp_test_1.log", c.log_file_name("/tmp/test/1")
+    assert_equal "newrelic_agent.c__foo_bar_long_gone__yes_.log", c.log_file_name("c:/foo/bar long gone?/yes!")
+    assert_equal "newrelic_agent..._tmp_pipes.log", c.log_file_name("..\\tmp\\pipes")
+  end
+  
+end