honkster-newrelic_rpm 2.13.1

data/test/new_relic/agent/collection_helper_test.rb

@@ -0,0 +1,125 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require 'ostruct'
+require 'active_record_fixtures' if defined?(::ActiveRecord)
+class NewRelic::Agent::CollectionHelperTest < Test::Unit::TestCase
+  
+  def setup
+    super
+    NewRelic::Agent.manual_start
+  end
+  def teardown
+    super
+  end
+  
+  include NewRelic::CollectionHelper
+  def test_string
+    val = (('A'..'Z').to_a.join * 100).to_s
+    assert_equal val[0...256] + "...", normalize_params(val)
+  end
+  def test_array
+    new_array = normalize_params [ 1000 ] * 2000
+    assert_equal 1024, new_array.size
+    assert_equal '1000', new_array[0]
+  end
+  def test_boolean
+    np = normalize_params(NewRelic::Control.instance.settings)
+    assert_equal false, np['monitor_mode']
+  end
+  def test_string__singleton
+    val = "This String"
+    def val.hello; end
+    assert_equal "This String", normalize_params(val)
+    assert val.respond_to?(:hello)
+    assert !normalize_params(val).respond_to?(:hello)
+  end
+  class MyString < String; end
+  def test_kind_of_string
+    s = MyString.new "This is a string"
+    assert_equal "This is a string", s.to_s
+    assert_equal MyString, s.class
+    assert_equal String, s.to_s.class
+    params = normalize_params(:val => [s])
+    assert_equal String, params[:val][0].class
+    assert_equal String, flatten(s).class
+    assert_equal String, truncate(s, 2).class
+  end
+  def test_number
+    np = normalize_params({ 'one' => 1.0, 'two' => '2'})
+  end
+  def test_nil
+    np = normalize_params({ nil => 1.0, 'two' => nil})
+    assert_equal "1.0", np['']
+    assert_equal nil, np['two']
+  end
+  def test_hash
+    val = ('A'..'Z').to_a.join * 100
+    assert_equal Hash["ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEF..." => (("0"*256) + "...")], normalize_params({ val => '0' * 512 })
+  end
+  class MyHash < Hash
+    
+  end
+  # Test to ensure that hash subclasses are properly converted
+  def test_hash_subclass
+    h = MyHash.new
+    h[:mine] = 'mine'
+    custom_params = { :one => {:hash => { :a => :b}, :myhash => h }}
+    nh = normalize_params(custom_params)
+    myhash = custom_params[:one][:myhash]
+    assert_equal MyHash, myhash.class 
+    myhash = nh[:one][:myhash]
+    assert_equal Hash, myhash.class 
+  end
+  
+  class MyEnumerable
+    include Enumerable
+    
+    def each
+      yield "1"
+    end
+  end
+  
+  def test_enumerable
+    e = MyEnumerable.new
+    custom_params = { :one => {:hash => { :a => :b}, :myenum => e }}
+    nh = normalize_params(custom_params)
+    myenum = nh[:one][:myenum]
+    assert_match /MyEnumerable/, myenum
+  end
+  
+  def test_stringio
+    # Verify StringIO works like this normally:
+    s = StringIO.new "start" + ("foo bar bat " * 1000)
+    val = nil
+    s.each { | entry | val = entry; break } 
+    assert_match /^startfoo bar/, val
+
+    # make sure stringios aren't affected by calling normalize_params:
+    s = StringIO.new "start" + ("foo bar bat " * 1000)
+    v = normalize_params({ :foo => s.string })
+    s.each { | entry | val = entry; break } 
+    assert_match /^startfoo bar/, val
+  end
+  
+  def test_object
+    assert_equal ["foo", '#<OpenStruct>'], normalize_params(['foo', OpenStruct.new('z'=>'q')])
+  end
+  
+  def test_strip_backtrace
+    begin
+      ActiveRecordFixtures.setup
+#      ActiveRecordFixtures::Order.add_delay
+      ActiveRecordFixtures::Order.find 0
+      flunk "should throw"
+    rescue => e
+      #puts e
+      #puts e.backtrace.join("\n")
+      #puts "\n\n"
+      clean_trace = strip_nr_from_backtrace(e.backtrace)
+      assert_equal 0, clean_trace.grep(/newrelic_rpm/).size, clean_trace.inspect
+      assert_equal 0, clean_trace.grep(/trace/).size, clean_trace.inspect
+      assert_equal 3, clean_trace.grep(/find/).size, "should see three frames with 'find' in them (#{e}): \n#{clean_trace.join("\n")}"
+    ensure
+      ActiveRecordFixtures.teardown
+    end
+  end if defined?(::ActiveRecord)
+end

data/test/new_relic/agent/error_collector_test.rb

@@ -0,0 +1,163 @@
+# Run faster standalone
+ENV['SKIP_RAILS'] = 'true'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
+  
+  def setup
+    super
+    @error_collector = NewRelic::Agent::ErrorCollector.new
+    @error_collector.stubs(:enabled).returns(true)
+  end
+  def test_empty
+    @error_collector.harvest_errors([])
+    @error_collector.notice_error(nil, :metric=> 'path', :request_params => {:x => 'y'})
+    errors = @error_collector.harvest_errors([])
+    
+    assert_equal 0, errors.length
+
+    @error_collector.notice_error('Some error message', :metric=> 'path', :request_params => {:x => 'y'})
+    errors = @error_collector.harvest_errors([])
+    
+    err = errors.first
+    assert_equal 'Some error message', err.message 
+    assert_equal 'y', err.params[:request_params][:x]
+    assert_equal '', err.params[:request_uri]
+    assert_equal '', err.params[:request_referer]
+    assert_equal 'path', err.path 
+    assert_equal 'Error', err.exception_class
+
+  end
+  def test_simple
+    @error_collector.notice_error(Exception.new("message"), :uri => '/myurl/', :metric => 'path', :referer => 'test_referer', :request_params => {:x => 'y'})
+    
+    old_errors = []
+    errors = @error_collector.harvest_errors(old_errors)
+    
+    assert_equal errors.length, 1
+    
+    err = errors.first
+    assert_equal 'message', err.message 
+    assert_equal 'y', err.params[:request_params][:x]
+    assert err.params[:request_uri] == '/myurl/'
+    assert err.params[:request_referer] == "test_referer"
+    assert err.path == 'path'
+    assert err.exception_class == 'Exception'
+    
+    # the collector should now return an empty array since nothing
+    # has been added since its last harvest
+    errors = @error_collector.harvest_errors(nil)
+    assert errors.length == 0
+  end
+
+  def test_long_message
+    #yes, times 500. it's a 5000 byte string. Assuming strings are
+    #still 1 byte / char.
+    @error_collector.notice_error(Exception.new("1234567890" * 500), :uri => '/myurl/', :metric => 'path', :request_params => {:x => 'y'})
+    
+    old_errors = []
+    errors = @error_collector.harvest_errors(old_errors)
+    
+    assert_equal errors.length, 1
+    
+    err = errors.first
+    assert_equal 4096, err.message.length
+    assert_equal ('1234567890' * 500)[0..4095], err.message
+  end
+  
+  def test_collect_failover
+    @error_collector.notice_error(Exception.new("message"), :metric => 'first', :request_params => {:x => 'y'}) 
+    
+    errors = @error_collector.harvest_errors([])
+    
+    @error_collector.notice_error(Exception.new("message"), :metric => 'second', :request_params => {:x => 'y'}) 
+    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
+    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
+    
+    errors = @error_collector.harvest_errors(errors)
+    
+    assert_equal 1, errors.length
+    assert_equal 'first', errors.first.path
+    
+    # add two more
+    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
+    @error_collector.notice_error(Exception.new("message"), :metric => 'last', :request_params => {:x => 'y'}) 
+    
+    errors = @error_collector.harvest_errors(nil)
+    assert_equal 5, errors.length
+    assert_equal 'second', errors.first.path
+    assert_equal 'last', errors.last.path
+    
+  end
+  
+  def test_queue_overflow
+    
+    max_q_length = 20     # for some reason I can't read the constant in ErrorCollector
+    
+    silence_stream(::STDOUT) do
+     (max_q_length + 5).times do |n|
+        @error_collector.notice_error(Exception.new("exception #{n}"), :metric => "path", :request_params => {:x => n}) 
+      end
+    end
+    
+    errors = @error_collector.harvest_errors([])
+    assert errors.length == max_q_length 
+    errors.each_index do |i|
+      err = errors.shift
+      assert_equal i.to_s, err.params[:request_params][:x], err.params.inspect
+    end
+  end
+  
+  # Why would anyone undef these methods?
+  class TestClass
+    undef to_s
+    undef inspect
+  end
+  
+  
+  def test_supported_param_types
+    
+    types = [[1, '1'],
+    [1.1, '1.1'],
+    ['hi', 'hi'],
+    [:hi, :hi],
+    [Exception.new("test"), "#<Exception>"],
+    [TestClass.new, "#<NewRelic::Agent::ErrorCollectorTest::TestClass>"]
+    ]
+    
+    
+    types.each do |test|
+      @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => test[0]}) 
+      
+      assert_equal test[1], @error_collector.harvest_errors([])[0].params[:request_params][:x]
+    end
+  end
+  
+  
+  def test_exclude
+    @error_collector.ignore(["IOError"])
+    
+    @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
+    
+    errors = @error_collector.harvest_errors([])
+    
+    assert_equal 0, errors.length
+  end
+  
+  def test_exclude_block
+    @error_collector.ignore_error_filter do |e|
+      if e.is_a? IOError
+        nil
+      else
+        e
+      end
+    end
+    
+    @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
+    
+    errors = @error_collector.harvest_errors([])
+    
+    assert_equal 0, errors.length
+  end
+  
+end

data/test/new_relic/agent/memcache_instrumentation_test.rb

@@ -0,0 +1,103 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  
+  # This implementation: http://seattlerb.rubyforge.org/memcache-client/
+  def using_memcache_client?
+    ::MemCache.method_defined? :cache_get
+  end
+  
+  def setup
+    NewRelic::Agent.manual_start
+    @engine = NewRelic::Agent.instance.stats_engine
+    
+    if using_memcache_client?
+      @cache = ::MemCache.new('localhost')
+    else
+      server = ::MemCache::Server.new('localhost')
+      @cache = ::MemCache.new(server)
+    end
+    @key = 'schluessel'
+  end
+  
+  def _call_test_method_in_web_transaction(method, *args)
+    @engine.clear_stats
+    begin
+      perform_action_with_newrelic_trace(:name=>'action', :category => :controller) do
+        @cache.send(method.to_sym, *[@key, *args])
+      end
+    rescue ::MemCache::MemCacheError
+      # There's probably no memcached around
+    end
+  end
+  
+  def _call_test_method_in_background_task(method, *args)
+    @engine.clear_stats
+    begin
+      perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do
+        @cache.send(method.to_sym, *[@key, *args])
+      end
+    rescue ::MemCache::MemCacheError
+      # There's probably no memcached around
+    end
+  end
+  
+  def test_reads__web
+    %w[get get_multi].each do |method|
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_web_transaction(method)
+        compare_metrics ["MemCache/#{method}", "MemCache/allWeb", "MemCache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"],
+        @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+  
+  def test_writes__web
+    %w[incr decr delete].each do |method|
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_web_transaction(method)
+        expected_metrics = ["MemCache/#{method}", "MemCache/allWeb", "MemCache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+    
+    %w[set add].each do |method|
+      if @cache.class.method_defined?(method)
+        expected_metrics = ["MemCache/#{method}", "MemCache/allWeb", "MemCache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
+        _call_test_method_in_web_transaction(method, 'value')
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+  
+  def test_reads__background
+    %w[get get_multi].each do |method|
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_background_task(method)
+        compare_metrics ["MemCache/#{method}", "MemCache/allOther", "MemCache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"],
+        @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+  
+  def test_writes__background
+    
+    %w[incr decr delete].each do |method|
+      expected_metrics = ["MemCache/#{method}", "MemCache/allOther", "MemCache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_background_task(method)
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+    
+    %w[set add].each do |method|
+      expected_metrics = ["MemCache/#{method}", "MemCache/allOther", "MemCache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+      if @cache.class.method_defined?(method)
+        _call_test_method_in_background_task(method, 'value')
+        compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
+      end
+    end
+  end
+  
+end if defined? MemCache

data/test/new_relic/agent/method_tracer_test.rb

@@ -0,0 +1,340 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require 'new_relic/agent/mock_scope_listener'
+
+class Module
+  def method_traced?(method_name, metric_name)
+    traced_method_prefix = _traced_method_name(method_name, metric_name)
+    
+    method_defined? traced_method_prefix
+  end
+end  
+
+class Insider
+  def initialize(stats_engine)
+    @stats_engine = stats_engine
+  end
+  def catcher(level=0)
+    thrower(level) if level>0
+  end
+  def thrower(level)
+    if level == 0
+      # don't use a real sampler because we can't instantiate one
+      # sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
+      sampler = "<none>"
+      begin
+        @stats_engine.transaction_sampler = sampler
+        fail "This should not have worked."
+        rescue; end
+    else
+      thrower(level-1)
+    end
+  end
+end
+
+module NewRelic
+  module Agent
+    extend self
+    def module_method_to_be_traced (x, testcase)
+      testcase.assert x == "x"
+      testcase.assert testcase.stats_engine.peek_scope.name == "x"
+    end
+  end
+end
+
+class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
+  attr_reader :stats_engine
+  
+  def setup
+    super
+    NewRelic::Agent.manual_start
+    @stats_engine = NewRelic::Agent.instance.stats_engine
+    @stats_engine.clear_stats
+    @scope_listener = NewRelic::Agent::MockScopeListener.new
+    @old_sampler = NewRelic::Agent.instance.transaction_sampler
+    @stats_engine.transaction_sampler = @scope_listener
+  end
+
+  def teardown
+    @stats_engine.transaction_sampler = @old_sampler
+    @stats_engine.clear_stats
+    self.class.remove_method_tracer :method_to_be_traced, @metric_name if @metric_name
+    @metric_name = nil
+    super
+  end
+  
+  def test_basic
+    metric = "hello"
+    t1 = Time.now
+    self.class.trace_execution_scoped metric do
+      sleep 1
+      assert metric == @stats_engine.peek_scope.name
+    end
+    elapsed = Time.now - t1
+    
+    stats = @stats_engine.get_stats(metric)
+    check_time stats.total_call_time, elapsed
+    assert stats.call_count == 1
+  end
+  
+  def test_basic__original_api
+    metric = "hello"
+    t1 = Time.now
+    self.class.trace_method_execution metric, true, true, true do
+      sleep 1
+      assert metric == @stats_engine.peek_scope.name
+    end
+    elapsed = Time.now - t1
+    
+    stats = @stats_engine.get_stats(metric)
+    check_time stats.total_call_time, elapsed
+    assert stats.call_count == 1
+  end
+  
+  METRIC = "metric"
+  def test_add_method_tracer
+    @metric_name = METRIC
+    self.class.add_method_tracer :method_to_be_traced, METRIC
+    
+    t1 = Time.now
+    method_to_be_traced 1,2,3,true,METRIC
+    elapsed = Time.now - t1
+    
+    stats = @stats_engine.get_stats(METRIC)
+    check_time stats.total_call_time, elapsed
+    assert stats.call_count == 1
+  end
+  
+  def test_add_method_tracer__default
+    self.class.add_method_tracer :simple_method
+    
+    simple_method
+    
+    stats = @stats_engine.get_stats("Custom/#{self.class.name}/simple_method")
+    assert stats.call_count == 1
+    
+  end
+  def test_add_method_tracer__reentry
+    self.class.add_method_tracer :simple_method
+    self.class.add_method_tracer :simple_method
+    self.class.add_method_tracer :simple_method
+    
+    simple_method
+    
+    stats = @stats_engine.get_stats("Custom/#{self.class.name}/simple_method")
+    assert stats.call_count == 1
+    
+  end
+
+  def test_method_traced?
+    assert !self.class.method_traced?(:method_to_be_traced, METRIC)
+    self.class.add_method_tracer :method_to_be_traced, METRIC
+    assert self.class.method_traced?(:method_to_be_traced, METRIC)
+  end
+  
+  def test_tt_only
+    
+    assert_nil @scope_listener.scope["c2"]
+    self.class.add_method_tracer :method_c1, "c1", true
+    
+    self.class.add_method_tracer :method_c2, "c2", :metric => false
+    self.class.add_method_tracer :method_c3, "c3", false
+    
+    method_c1
+    
+    assert_not_nil @stats_engine.lookup_stat("c1")
+    assert_nil @stats_engine.lookup_stat("c2")
+    assert_not_nil @stats_engine.lookup_stat("c3")
+    
+    assert_not_nil @scope_listener.scope["c2"]
+  end
+  
+  def test_nested_scope_tracer
+    Insider.add_method_tracer :catcher, "catcher", :push_scope => true
+    Insider.add_method_tracer :thrower, "thrower", :push_scope => true
+    sampler = NewRelic::Agent.instance.transaction_sampler
+    mock = Insider.new(@stats_engine)
+    mock.catcher(0)
+    mock.catcher(5)
+    stats = @stats_engine.get_stats("catcher")
+    assert_equal 2, stats.call_count
+    stats = @stats_engine.get_stats("thrower")
+    assert_equal 6, stats.call_count
+    sample = sampler.harvest
+    assert_not_nil sample
+  end
+  
+  def test_add_same_tracer_twice
+    @metric_name = METRIC
+    self.class.add_method_tracer :method_to_be_traced, METRIC
+    self.class.add_method_tracer :method_to_be_traced, METRIC
+    
+    t1 = Time.now
+    method_to_be_traced 1,2,3,true,METRIC
+    elapsed = Time.now - t1
+    
+    stats = @stats_engine.get_stats(METRIC)
+    check_time stats.total_call_time, elapsed
+    assert stats.call_count == 1
+  end
+  
+  def test_add_tracer_with_dynamic_metric
+    metric_code = '#{args[0]}.#{args[1]}'
+    @metric_name = metric_code
+    expected_metric = "1.2"
+    self.class.add_method_tracer :method_to_be_traced, metric_code
+    
+    t1 = Time.now
+    method_to_be_traced 1,2,3,true,expected_metric
+    elapsed = Time.now - t1
+    
+    stats = @stats_engine.get_stats(expected_metric)
+    check_time stats.total_call_time, elapsed
+    assert stats.call_count == 1
+  end
+  
+  def test_trace_method_with_block
+    self.class.add_method_tracer :method_with_block, METRIC
+    
+    t1 = Time.now
+    method_with_block(1,2,3,true,METRIC) do |scope|
+      assert scope == METRIC
+    end
+    elapsed = Time.now - t1
+    
+    stats = @stats_engine.get_stats(METRIC)
+    check_time stats.total_call_time, elapsed
+    assert stats.call_count == 1
+  end
+  
+  def test_trace_module_method
+    NewRelic::Agent.add_method_tracer :module_method_to_be_traced, '#{args[0]}'
+    NewRelic::Agent.module_method_to_be_traced "x", self
+    NewRelic::Agent.remove_method_tracer :module_method_to_be_traced, '#{args[0]}'
+  end
+  
+  def test_remove
+    self.class.add_method_tracer :method_to_be_traced, METRIC
+    self.class.remove_method_tracer :method_to_be_traced, METRIC
+    
+    t1 = Time.now
+    method_to_be_traced 1,2,3,false,METRIC
+    elapsed = Time.now - t1
+    
+    stats = @stats_engine.get_stats(METRIC)
+    assert stats.call_count == 0
+  end
+  
+  def self.static_method(x, testcase, is_traced)
+    testcase.assert x == "x"
+    testcase.assert((testcase.stats_engine.peek_scope.name == "x") == is_traced)
+  end
+  
+  def trace_trace_static_method
+    self.add_method_tracer :static_method, '#{args[0]}'
+    self.class.static_method "x", self, true
+    self.remove_method_tracer :static_method, '#{args[0]}'
+    self.class.static_method "x", self, false
+  end
+  
+  def test_multiple_metrics__scoped
+    metrics = %w[first second third]
+    self.class.trace_execution_scoped metrics do
+      sleep 0.05
+    end
+    elapsed = @stats_engine.get_stats('first').average_call_time
+    metrics.map{|name| @stats_engine.get_stats name}.each do | m |
+      assert_equal 1, m.call_count
+      assert_equal elapsed, m.total_call_time
+    end
+  end
+  def test_multiple_metrics__unscoped
+    metrics = %w[first second third]
+    self.class.trace_execution_unscoped metrics do
+      sleep 0.05
+    end
+    elapsed = @stats_engine.get_stats('first').average_call_time
+    metrics.map{|name| @stats_engine.get_stats name}.each do | m |
+      assert_equal 1, m.call_count
+      assert_equal elapsed, m.total_call_time
+    end
+  end
+  def test_exception
+    begin
+      metric = "hey"
+      self.class.trace_execution_scoped metric do
+        assert @stats_engine.peek_scope.name == metric
+        throw Exception.new            
+      end
+      
+      assert false # should never get here
+    rescue Exception
+      # make sure the scope gets popped
+      assert @stats_engine.peek_scope == nil
+    end
+    
+    stats = @stats_engine.get_stats metric
+    assert stats.call_count == 1
+  end
+  
+  def test_add_multiple_tracers
+    self.class.add_method_tracer :method_to_be_traced, 'X', :push_scope => false
+    method_to_be_traced 1,2,3,true,nil
+    self.class.add_method_tracer :method_to_be_traced, 'Y'
+    method_to_be_traced 1,2,3,true,'Y'
+    self.class.remove_method_tracer :method_to_be_traced, 'Y'
+    method_to_be_traced 1,2,3,true,nil
+    self.class.remove_method_tracer :method_to_be_traced, 'X'
+    method_to_be_traced 1,2,3,false,'X'
+  end
+  
+  def trace_no_push_scope
+    self.class.add_method_tracer :method_to_be_traced, 'X', :push_scope => false
+    method_to_be_traced 1,2,3,true,nil
+    self.class.remove_method_tracer :method_to_be_traced, 'X'
+    method_to_be_traced 1,2,3,false,'X'
+  end
+  
+  def check_time(t1, t2)
+    assert_in_delta t2, t1, 0.02
+  end
+  
+  # =======================================================
+  # test methods to be traced
+  def method_to_be_traced(x, y, z, is_traced, expected_metric)
+    sleep 0.1
+    assert x == 1
+    assert y == 2
+    assert z == 3
+    scope_name = @stats_engine.peek_scope ? @stats_engine.peek_scope.name : nil
+    if is_traced
+      assert_equal expected_metric, scope_name
+    else
+      assert_not_equal expected_metric, scope_name
+    end
+  end
+  
+  def method_with_block(x, y, z, is_traced, expected_metric, &block)
+    sleep 0.1
+    assert x == 1
+    assert y == 2
+    assert z == 3
+    block.call(@stats_engine.peek_scope.name)
+    
+    scope_name = @stats_engine.peek_scope ? @stats_engine.peek_scope.name : nil
+    assert((expected_metric == scope_name) == is_traced)
+  end
+  
+  def method_c1
+    method_c2
+  end
+  
+  def method_c2
+    method_c3
+  end
+  
+  def method_c3
+  end
+
+  def simple_method
+  end
+end