factorylabs-newrelic_rpm 2.10.2.2

data/test/new_relic/agent/transaction_sample_test.rb

@@ -0,0 +1,186 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require 'new_relic/agent/mock_ar_connection'
+require 'test/unit'
+
+::SQL_STATEMENT = "SELECT * from sandwiches"
+
+NewRelic::TransactionSample::Segment.class_eval do
+  def handle_exception_in_explain(e)
+    fail "Got error in explain plan: #{e}"
+  end
+  
+end
+class NewRelic::TransationSampleTest < Test::Unit::TestCase
+  include TransactionSampleTestHelper
+  def setup
+    NewRelic::Agent.manual_start
+  end
+  
+  def test_sql
+    assert ActiveRecord::Base.test_connection({}).disconnected == false
+    
+    t = make_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 = make_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 = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+      assert t.nil?
+    end
+  end
+  def test_enabled_tt
+    t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
+    assert t
+  end
+  
+  def test_record_sql_off
+    t = make_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 = make_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 = make_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 = 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"
+    
+    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"
+    
+    s1.add_called_segment(s2)
+    s2.end_trace 3.0
+    s1.end_trace 4.0
+    
+    s3 = t.create_segment(4.0, "post_filter")
+    t.root_segment.add_called_segment(s3)
+    s3.end_trace 6.0
+    
+    s4 = t.create_segment(6.0, "post_filter")
+    t.root_segment.add_called_segment(s4)
+    s4.end_trace 7.0
+    t
+  end
+  
+  def large_sample
+    t = NewRelic::TransactionSample.new
+    
+    s1 = t.create_segment(1.0, "controller")
+    t.root_segment.add_called_segment(s1)
+    
+    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

@@ -0,0 +1,404 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+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
+    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
+    
+    run_sample_trace
+    run_sample_trace
+    run_sample_trace
+    run_sample_trace
+    
+    samples = @sampler.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_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_sequence
+    assert_equal 0, @sampler.scope_depth
+    
+    @sampler.notice_transaction "/path1", nil, {}
+    @sampler.notice_first_scope_push Time.now.to_f
+    @sampler.notice_push_scope "a"
+    @sampler.notice_pop_scope "a"
+    @sampler.notice_scope_empty
+    @sampler.notice_transaction "/path2", nil, {}
+    @sampler.notice_first_scope_push Time.now.to_f
+    @sampler.notice_push_scope "b"
+    @sampler.notice_pop_scope "b"
+    @sampler.notice_scope_empty
+    assert_equal 2, @sampler.samples.size
+    assert_equal "/path1", @sampler.samples[0].params[:path]
+    assert_equal "/path2", @sampler.samples[1].params[:path]
+    assert_nil @sampler.send(:builder)
+  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 
+    end
+  end
+  
+  def test_harvest_slowest
+    
+    run_sample_trace
+    run_sample_trace
+    run_sample_trace { sleep 0.5 }
+    run_sample_trace
+    run_sample_trace
+    
+    slowest = @sampler.harvest(nil, 0)[0]
+    assert slowest.duration >= 0.5
+    
+    run_sample_trace { sleep 0.2 }
+    not_as_slow = @sampler.harvest(slowest, 0)[0]
+    assert not_as_slow == slowest
+    
+    run_sample_trace { sleep 0.6 }
+    new_slowest = @sampler.harvest(slowest, 0)[0]
+    assert new_slowest != slowest
+    assert new_slowest.duration >= 0.6
+  end
+  
+  
+  def test_preare_to_send
+    
+    run_sample_trace { sleep 0.2 }
+    sample = @sampler.harvest(nil, 0)[0]
+    
+    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
+    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
+    
+    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
+    
+    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
+    
+    @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(nil, 0)[0]
+  end
+  
+  
+  def test_record_sql_off
+    
+    @sampler.notice_first_scope_push Time.now.to_f
+    
+    Thread::current[:record_sql] = false
+    
+    @sampler.notice_sql("test", nil, 0)
+    
+    segment = @sampler.send(:builder).current_segment
+    
+    assert_nil segment[:sql]
+  end
+  
+  def test_stack_trace__sql
+    @sampler.stack_trace_threshold = 0
+    
+    @sampler.notice_first_scope_push Time.now.to_f
+    
+    @sampler.notice_sql("test", nil, 1)
+    
+    segment = @sampler.send(:builder).current_segment
+    
+    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
+    @sampler.notice_push_scope 'Bill', (t+1.second).to_f
+    
+    segment = @sampler.send(:builder).current_segment
+    assert segment[:backtrace]
+  end
+  
+  def test_nil_stacktrace
+    
+    @sampler.stack_trace_threshold = 2
+    
+    @sampler.notice_first_scope_push Time.now.to_f
+    
+    @sampler.notice_sql("test", nil, 1)
+    
+    segment = @sampler.send(:builder).current_segment
+    
+    assert segment[:sql]
+    assert_nil segment[:backtrace]
+  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"
+    
+    len = 0
+    while len <= NewRelic::Agent::TransactionSampler::MAX_SQL_LENGTH
+      @sampler.notice_sql(sql, nil, 0)
+      len += sql.length
+    end
+    
+    segment = @sampler.send(:builder).current_segment
+    
+    sql = segment[:sql]
+    
+    assert sql.length <= NewRelic::Agent::TransactionSampler::MAX_SQL_LENGTH
+  end
+  
+  
+  def test_segment_obfuscated
+    
+    @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.send(: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| 
+      NewRelic::Control.instance.stubs(:capture_params).returns(capture)
+      @sampler.notice_first_scope_push Time.now.to_f
+      @sampler.notice_transaction('/path', nil, {:param => 'hi'})
+      @sampler.notice_scope_empty
+      
+      tt = @sampler.harvest(nil,0)[0]
+      
+      assert_equal (capture) ? 1 : 0, tt.params[:request_params].length
+    end
+  end
+  
+  
+  def test_sql_normalization
+    
+    # basic statement
+    assert_equal "INSERT INTO X values(?,?, ? , ?)", 
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, "INSERT INTO X values('test',0, 1 , 2)")
+    
+    # escaped literals
+    assert_equal "INSERT INTO X values(?, ?,?, ? , ?)", 
+    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(?,?,?, ? , ?)", 
+    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(?,?,?, ? , ?)", 
+    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=?",
+    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=?",
+    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",
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, "INSERT 'this isn''t a real value' into table")
+    assert_equal "INSERT ? into table",
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT '"' into table])
+    assert_equal "INSERT ? 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",
+#    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT '\'' into table])
+    assert_equal "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",
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT "this isn't a real value" into table])
+    assert_equal "INSERT ? into table",
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT "'" into table])
+    assert_equal "INSERT ? into table",
+    NewRelic::Agent.instance.send(:default_sql_obfuscator, %q[INSERT " \" " into table])
+    assert_equal "INSERT ? 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
+    
+    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