genki-newrelic_rpm 2.10.1

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/agent/transaction_sample_builder_test.rb

@@ -0,0 +1,195 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
+  
+  def setup
+    @builder = NewRelic::Agent::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) * 1000
+    
+    # Need to allow substantial headroom on the upper bound to prevent 
+    # spurious errors.
+    assert delta >= 30, "delta #{delta} should be between 30 and 100"
+    # disable this test for a couple days:
+    assert delta <= 100, "delta #{delta} should be between 30 and 100"
+    
+    # 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)
+    p = s.parent_segment
+    
+    unless p.nil? || p.metric_name == 'ROOT'
+      assert p.called_segments.include?(s) 
+      assert_equal p.metric_name.length, s.metric_name.length - 1, "p: #{p.metric_name}, s: #{s.metric_name}" 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, check_names)
+    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

data/test/new_relic/agent/transaction_sample_test.rb

@@ -0,0 +1,146 @@
+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
+    
+    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 = 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
+    
+end

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -0,0 +1,387 @@
+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
+  
+  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(agent)
+  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__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.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.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.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.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.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.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(?,?, ? , ?)", 
+    @sampler.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')")
+    
+    # multiple string literals             
+    assert_equal "INSERT INTO X values(?,?,?, ? , ?)", 
+    @sampler.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)")
+    
+    # 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")
+    
+    # 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")
+  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")
+    assert_equal "INSERT ? into table",
+    @sampler.default_sql_obfuscator(%q[INSERT '"' into table])
+    assert_equal "INSERT ? into table",
+    @sampler.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])
+    assert_equal "INSERT ? into table",
+    @sampler.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])
+    assert_equal "INSERT ? into table",
+    @sampler.default_sql_obfuscator(%q[INSERT "'" into table])
+    assert_equal "INSERT ? into table",
+    @sampler.default_sql_obfuscator(%q[INSERT " \" " into table])
+    assert_equal "INSERT ? into table",
+    @sampler.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