sundawg_newrelic_rpm 3.5.8.1

data/test/new_relic/agent/method_tracer/class_methods/add_method_tracer_test.rb

@@ -0,0 +1,158 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
+
+require 'set'
+module NewRelic
+  module Agent
+    class Agent
+      module MethodTracer
+        module ClassMethods
+          class AddMethodTracerTest < Test::Unit::TestCase
+            #  require 'new_relic/agent/method_tracer'
+            include NewRelic::Agent::MethodTracer::ClassMethods::AddMethodTracer
+
+            def test_validate_options_nonhash
+              assert_raise(TypeError) do
+                validate_options([])
+              end
+            end
+
+            def test_validate_options_defaults
+              self.expects(:check_for_illegal_keys!)
+              self.expects(:set_deduct_call_time_based_on_metric).with(DEFAULT_SETTINGS)
+              self.expects(:check_for_push_scope_and_metric)
+              validate_options({})
+            end
+
+            def test_validate_options_override
+              opts = {:push_scope => false, :metric => false, :force => true}
+              self.expects(:check_for_illegal_keys!)
+              self.expects(:check_for_push_scope_and_metric)
+              val = validate_options(opts)
+              assert val.is_a?(Hash)
+              assert (val[:push_scope] == false), val.inspect
+              assert (val[:metric] == false), val.inspect
+              assert (val[:force] == true), val.inspect
+            end
+
+            def test_default_metric_name_code
+              assert_equal "Custom/#{self.class.name}/test_method", self.class.default_metric_name_code('test_method')
+            end
+
+            def test_newrelic_method_exists_positive
+              self.expects(:method_defined?).returns(true)
+              assert newrelic_method_exists?('test_method')
+            end
+
+            def test_newrelic_method_exists_negative
+              self.class.expects(:method_defined?).returns(false)
+              self.class.expects(:private_method_defined?).returns(false)
+
+              assert !self.class.newrelic_method_exists?('test_method')
+            end
+
+            def test_set_deduct_call_time_based_on_metric_positive
+              opts = {:metric => true}
+              val = set_deduct_call_time_based_on_metric(opts)
+              assert val.is_a?(Hash)
+              assert val[:deduct_call_time_from_parent]
+            end
+
+            def test_set_deduct_call_time_based_on_metric_negative
+              opts = {:metric => false}
+              val = set_deduct_call_time_based_on_metric(opts)
+              assert val.is_a?(Hash)
+              assert !val[:deduct_call_time_from_parent]
+            end
+
+            def test_set_deduct_call_time_based_on_metric_non_nil
+              opts = {:deduct_call_time_from_parent => true, :metric => false}
+              val = set_deduct_call_time_based_on_metric(opts)
+              assert val.is_a?(Hash)
+              assert val[:deduct_call_time_from_parent]
+            end
+
+            def test_set_deduct_call_time_based_on_metric_opposite
+              opts = {:deduct_call_time_from_parent => false, :metric => true}
+              val = set_deduct_call_time_based_on_metric(opts)
+              assert val.is_a?(Hash)
+              assert !val[:deduct_call_time_from_parent]
+            end
+
+            def test_unrecognized_keys_positive
+              assert_equal [:unrecognized, :keys].to_set, unrecognized_keys([:hello, :world], {:unrecognized => nil, :keys => nil}).to_set
+            end
+
+            def test_unrecognized_keys_negative
+              assert_equal [], unrecognized_keys([:hello, :world], {:hello => nil, :world => nil})
+            end
+
+            def test_any_unrecognized_keys_positive
+              assert any_unrecognized_keys?([:one], {:one => nil, :two => nil})
+            end
+
+            def test_any_unrecognized_keys_negative
+              assert !any_unrecognized_keys?([:one], {:one => nil})
+            end
+
+            def test_check_for_illegal_keys_positive
+              assert_raise(RuntimeError) do
+                check_for_illegal_keys!({:unknown_key => nil})
+              end
+            end
+
+            def test_check_for_illegal_keys_negative
+              test_keys = Hash[*ALLOWED_KEYS.map {|x| [x, nil]}.flatten]
+              check_for_illegal_keys!(test_keys)
+            end
+
+            def test_traced_method_exists_positive
+              self.expects(:_traced_method_name)
+              self.expects(:method_defined?).returns(true)
+              assert traced_method_exists?('test_method', 'Custom/Test/test_method')
+            end
+
+            def test_traced_method_exists_negative
+              self.expects(:_traced_method_name)
+              self.expects(:method_defined?).returns(false)
+              assert !traced_method_exists?(nil, nil)
+            end
+
+            def test_assemble_code_header_forced
+              opts = {:force => true, :code_header => 'CODE HEADER'}
+              assert_equal "CODE HEADER", assemble_code_header('test_method', 'Custom/Test/test_method', opts)
+            end
+
+            def test_assemble_code_header_unforced
+              self.expects(:_untraced_method_name).returns("method_name_without_tracing")
+              opts = {:force => false, :code_header => 'CODE HEADER'}
+              assert_equal "return method_name_without_tracing(*args, &block) unless NewRelic::Agent.is_execution_traced?\nCODE HEADER", assemble_code_header('test_method', 'Custom/Test/test_method', opts)
+            end
+
+            def test_check_for_push_scope_and_metric_positive
+              check_for_push_scope_and_metric({:push_scope => true})
+              check_for_push_scope_and_metric({:metric => true})
+            end
+
+            def test_check_for_push_scope_and_metric_negative
+              assert_raise(RuntimeError) do
+                check_for_push_scope_and_metric({:push_scope => false, :metric => false})
+              end
+            end
+
+            def test_code_to_eval_scoped
+              self.expects(:validate_options).returns({:push_scope => true})
+              self.expects(:method_with_push_scope).with('test_method', 'Custom/Test/test_method', {:push_scope => true})
+              code_to_eval('test_method', 'Custom/Test/test_method', {})
+            end
+
+            def test_code_to_eval_unscoped
+              self.expects(:validate_options).returns({:push_scope => false})
+              self.expects(:method_without_push_scope).with('test', 'Custom/Test/test', {:push_scope => false})
+              code_to_eval('test', 'Custom/Test/test', {})
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/new_relic/agent/method_tracer/instance_methods/trace_execution_scoped_test.rb

@@ -0,0 +1,222 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
+class NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScopedTest < Test::Unit::TestCase
+  require 'new_relic/agent/method_tracer'
+  include NewRelic::Agent::MethodTracer::InstanceMethods::TraceExecutionScoped
+
+  def test_trace_disabled_negative
+    self.expects(:traced?).returns(false)
+    options = {:force => false}
+    assert trace_disabled?(options)
+  end
+
+  def test_trace_disabled_forced
+    self.expects(:traced?).returns(false)
+    options = {:force => true}
+    assert !(trace_disabled?(options))
+  end
+
+  def test_trace_disabled_positive
+    self.expects(:traced?).returns(true)
+    options = {:force => false}
+    assert !(trace_disabled?(options))
+  end
+
+  def test_get_stats_unscoped
+    fake_engine = mocked_object('stat_engine')
+    fake_engine.expects(:get_stats_no_scope).with('foob').returns('fakestats')
+    assert_equal 'fakestats', get_stats_unscoped('foob')
+  end
+
+  def test_get_stats_scoped_scoped_only
+    fake_engine = mocked_object('stat_engine')
+    fake_engine.expects(:get_stats).with('foob', true, true).returns('fakestats')
+    assert_equal 'fakestats', get_stats_scoped('foob', true)
+  end
+
+  def test_get_stats_scoped_no_scoped_only
+    fake_engine = mocked_object('stat_engine')
+    fake_engine.expects(:get_stats).with('foob', true, false).returns('fakestats')
+    assert_equal 'fakestats', get_stats_scoped('foob', false)
+  end
+
+  def test_stat_engine
+    assert_equal agent_instance.stats_engine, stat_engine
+  end
+
+  def test_agent_instance
+    assert_equal NewRelic::Agent.instance, agent_instance
+  end
+
+  def test_main_stat
+    self.expects(:get_stats_scoped).with('hello', true)
+    opts = {:scoped_metric_only => true}
+    main_stat('hello', opts)
+  end
+
+  def test_get_metric_stats_metric
+    metrics = ['foo', 'bar', 'baz']
+    opts = {:metric => true}
+    self.expects(:get_stats_unscoped).twice
+    self.expects(:main_stat).with('foo', opts)
+    first_name, stats = get_metric_stats(metrics, opts)
+    assert_equal 'foo', first_name
+    assert_equal 3, stats.length
+  end
+
+  def test_get_metric_stats_no_metric
+    metrics = ['foo', 'bar', 'baz']
+    opts = {:metric => false}
+    self.expects(:get_stats_unscoped).twice
+    first_name, stats = get_metric_stats(metrics, opts)
+    assert_equal 'foo', first_name
+    assert_equal 2, stats.length
+  end
+
+  def test_set_if_nil
+    h = {}
+    set_if_nil(h, :foo)
+    assert h[:foo]
+    h[:bar] = false
+    set_if_nil(h, :bar)
+    assert !h[:bar]
+  end
+
+  def test_push_flag_true
+    fake_agent = mocked_object('agent_instance')
+    fake_agent.expects(:push_trace_execution_flag).with(true)
+    push_flag!(true)
+  end
+
+  def test_push_flag_false
+    self.expects(:agent_instance).never
+    push_flag!(false)
+  end
+
+  def test_pop_flag_true
+    fake_agent = mocked_object('agent_instance')
+    fake_agent.expects(:pop_trace_execution_flag)
+    pop_flag!(true)
+  end
+
+  def test_pop_flag_false
+    self.expects(:agent_instance).never
+    pop_flag!(false)
+  end
+
+  def test_log_errors_base
+    ran = false
+    log_errors("name", "metric") do
+      ran = true
+    end
+    assert ran, "should run the contents of the block"
+  end
+
+  def test_log_errors_with_return
+    ran = false
+    return_val = log_errors('name', 'metric') do
+      ran = true
+      'happy trees'
+    end
+
+    assert ran, "should run contents of block"
+    assert_equal 'happy trees', return_val, "should return contents of the block"
+  end
+
+  def test_log_errors_with_error
+    expects_logging(:error, 
+      includes("Caught exception in name. Metric name = metric"),
+      instance_of(RuntimeError))
+
+    log_errors("name", "metric") do
+      raise "should not propagate out of block"
+    end
+  end
+
+  def test_trace_execution_scoped_header
+    options = {:force => false, :deduct_call_time_from_parent => false}
+    self.expects(:log_errors).with('trace_execution_scoped header', 'foo').yields
+    self.expects(:push_flag!).with(false)
+    fakestats = mocked_object('stat_engine')
+    fakestats.expects(:push_scope).with('foo', 1.0, false)
+    trace_execution_scoped_header('foo', options, 1.0)
+  end
+
+  def test_trace_execution_scoped_footer
+    t0 = 1.0
+    t1 = 2.0
+    metric = 'foo'
+    metric_stats = [mock('fakestat')]
+    metric_stats.first.expects(:trace_call).with(1.0, 0.5)
+    expected_scope = 'an expected scope'
+    engine = mocked_object('stat_engine')
+    scope = mock('scope')
+    engine.expects(:pop_scope).with('an expected scope', 1.0, 2.0).returns(scope)
+    scope.expects(:children_time).returns(0.5)
+    self.expects(:pop_flag!).with(false)
+    self.expects(:log_errors).with('trace_method_execution footer', 'foo').yields
+
+    trace_execution_scoped_footer(t0, metric, metric_stats, expected_scope, false, t1)
+  end
+
+  def test_trace_execution_scoped_disabled
+    self.expects(:trace_disabled?).returns(true)
+    # make sure the method doesn't beyond the abort
+    self.expects(:set_if_nil).never
+    ran = false
+    value = trace_execution_scoped(nil, {:options => 'hash'}) do
+      ran = true
+      1172
+    end
+
+    assert ran, 'should run contents of block'
+    assert_equal 1172, value, 'should return contents of block'
+  end
+
+  def test_trace_execution_scoped_default
+    passed_in_opts = {}
+    opts_after_correction = {:metric => true, :deduct_call_time_from_parent => true}
+    self.expects(:trace_disabled?).returns(false)
+    self.expects(:get_metric_stats).with(['metric', 'array'], opts_after_correction).returns(['metric', ['stats']])
+    self.expects(:trace_execution_scoped_header).with('metric', opts_after_correction).returns(['start_time', 'expected_scope'])
+    self.expects(:trace_execution_scoped_footer).with('start_time', 'metric', ['stats'], 'expected_scope', nil)
+    ran = false
+    value = trace_execution_scoped(['metric', 'array'], passed_in_opts) do
+      ran = true
+      1172
+    end
+
+    assert ran, 'should run contents of the block'
+    assert_equal 1172, value, 'should return the contents of the block'
+  end
+
+  def test_trace_execution_scoped_with_error
+    passed_in_opts = {}
+    opts_after_correction = {:metric => true, :deduct_call_time_from_parent => true}
+    self.expects(:trace_disabled?).returns(false)
+    self.expects(:get_metric_stats).with(['metric', 'array'], opts_after_correction).returns(['metric', ['stats']])
+    self.expects(:trace_execution_scoped_header).with('metric', opts_after_correction).returns(['start_time', 'expected_scope'])
+    self.expects(:trace_execution_scoped_footer).with('start_time', 'metric', ['stats'], 'expected_scope', nil)
+    ran = false
+    assert_raises(RuntimeError) do
+      trace_execution_scoped(['metric', 'array'], passed_in_opts) do
+        ran = true
+        raise 'raising a test error'
+      end
+    end
+
+    assert ran, 'should run contents of the block'
+  end
+
+  private
+
+  def mocked_object(name)
+    object = mock(name)
+    self.stubs(name).returns(object)
+    object
+  end
+
+  def mocked_control
+    mocked_object('control')
+  end
+end
+

data/test/new_relic/agent/method_tracer_test.rb

@@ -0,0 +1,389 @@
+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
+
+module TestModuleWithLog
+  extend self
+  def other_method
+    #just here to be traced
+    log "12345"
+  end
+
+  def log( msg )
+    msg
+  end
+  include NewRelic::Agent::MethodTracer
+  add_method_tracer :other_method, 'Custom/foo/bar'
+end
+
+class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
+  attr_reader :stats_engine
+
+  def setup
+    Thread::current[:newrelic_scope_stack] = nil
+
+    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
+    super
+  end
+
+  def teardown
+    @stats_engine.transaction_sampler = @old_sampler
+    @stats_engine.clear_stats
+    begin
+      self.class.remove_method_tracer :method_to_be_traced, @metric_name if @metric_name
+    rescue RuntimeError
+      # ignore 'no tracer' errors from remove method tracer
+    end
+
+    @metric_name = nil
+    super
+  end
+
+  def test_preserve_logging
+    assert_equal '12345', TestModuleWithLog.other_method
+  end
+
+  def test_basic
+    metric = "hello"
+    t1 = Time.now
+    self.class.trace_execution_scoped metric do
+      sleep 0.05
+      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 0.05
+      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
+
+    begin
+      self.class.remove_method_tracer :method_to_be_traced, METRIC
+    rescue RuntimeError
+      # ignore 'no tracer' errors from remove method tracer
+    end
+
+
+    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)
+    begin
+      self.class.remove_method_tracer :method_to_be_traced, METRIC
+    rescue RuntimeError
+      # ignore 'no tracer' errors from remove method tracer
+    end
+  end
+
+  def test_tt_only
+
+    assert_nil @scope_listener.scope["c2"]
+    self.class.add_method_tracer :method_c1, "c1", :push_scope => true
+
+    self.class.add_method_tracer :method_c2, "c2", :metric => false
+    self.class.add_method_tracer :method_c3, "c3", :push_scope => false
+
+    method_c1
+
+    assert_not_nil @stats_engine.lookup_stats("c1")
+    assert_nil @stats_engine.lookup_stats("c2")
+    assert_not_nil @stats_engine.lookup_stats("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
+
+    begin
+      self.class.remove_method_tracer :method_to_be_traced, METRIC
+    rescue RuntimeError
+      # ignore 'no tracer' errors from remove method tracer
+    end
+
+    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
+
+    begin
+      self.class.remove_method_tracer :method_to_be_traced, metric_code
+    rescue RuntimeError
+      # ignore 'no tracer' errors from remove method tracer
+    end
+
+    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
+      sleep 0.1 # pad the test a bit to increase the margin of error
+    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').total_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').total_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 StandardError.new
+      end
+
+      assert false # should never get here
+    rescue StandardError
+      # 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, 'XX', :push_scope => false
+    method_to_be_traced 1,2,3,true,nil
+    self.class.add_method_tracer :method_to_be_traced, 'YY'
+    method_to_be_traced 1,2,3,true,'YY'
+    self.class.remove_method_tracer :method_to_be_traced, 'YY'
+    method_to_be_traced 1,2,3,true,nil
+    self.class.remove_method_tracer :method_to_be_traced, 'XX'
+    method_to_be_traced 1,2,3,false,'XX'
+  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.05
+  end
+
+  # =======================================================
+  # test methods to be traced
+  def method_to_be_traced(x, y, z, is_traced, expected_metric)
+    sleep 0.01
+    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.01
+    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