genki-newrelic_rpm 2.10.1

data/test/new_relic/agent/method_tracer_test.rb

@@ -0,0 +1,335 @@
+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
+    NewRelic::Agent.manual_start
+    @stats_engine = NewRelic::Agent.instance.stats_engine
+    @stats_engine.clear_stats
+    @scope_listener = NewRelic::Agent::MockScopeListener.new
+    @stats_engine.transaction_sampler = @scope_listener
+  end
+  
+  def teardown
+    self.class.remove_method_tracer :method_to_be_traced, @metric_name if @metric_name
+    @metric_name = nil
+  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((t2-t1).abs < 0.01, "Times not close: #{t1} ~ #{t2}")
+  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

data/test/new_relic/agent/metric_data_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require 'test/unit'
+
+
+class NewRelic::Agent::MetricDataTest < Test::Unit::TestCase
+  
+  
+  # test to make sure the MetricData class can serialize to json
+  def test_json
+    spec = NewRelic::MetricSpec.new("controller", "metric#find")
+    
+    import = ActiveSupport::JSON.decode(spec.to_json)
+    
+    compare_spec(spec, import)
+    
+    stats = NewRelic::MethodTraceStats.new
+    
+    import = ActiveSupport::JSON.decode(stats.to_json)
+    
+    compare_stat(stats, import)
+    
+    metric_data = NewRelic::MetricData.new(spec, stats, 10)
+    
+    import = ActiveSupport::JSON.decode(metric_data.to_json)
+    
+    compare_metric_data(metric_data, import)
+  end
+  
+  
+  private 
+  
+  def compare_spec(spec, import)
+    assert_equal 2, import.length
+    assert_equal spec.name, import['name']
+    assert_equal spec.scope, import['scope']
+  end
+  
+  def compare_stat(stats, import)
+    assert_equal 6, import.length
+    assert_equal stats.total_call_time, import['total_call_time']
+    assert_equal stats.max_call_time, import['max_call_time']
+    assert_equal stats.min_call_time, import['min_call_time']
+    assert_equal stats.sum_of_squares, import['sum_of_squares']
+    assert_equal stats.call_count, import['call_count']
+    assert_equal stats.total_exclusive_time, import['total_exclusive_time']
+  end
+  
+  def compare_metric_data(metric_data, import)
+    assert_equal 3, import.length
+    compare_spec(metric_data.metric_spec, import['metric_spec'])
+    compare_stat(metric_data.stats, import['stats'])
+    assert_equal metric_data.metric_id, import['metric_id']
+  end
+  
+end
+

data/test/new_relic/agent/mock_ar_connection.rb

@@ -0,0 +1,40 @@
+module ActiveRecord
+  class Base
+    class << self
+      def test_connection(config)
+        @connect ||= Connection.new
+      end
+    end
+  end
+  
+  class Connection
+    attr_accessor :throw
+    attr_reader :disconnected
+    
+    def initialize
+      @disconnected = false
+      @throw = false
+    end
+    
+    def disconnect!()
+      @disconnected = true
+    end
+    
+    def find()
+      # used to test that we've instrumented this...
+    end
+
+    def select_rows(s)
+      execute(s)
+    end
+    def execute(s)
+      fail "" if @throw
+      if s != "EXPLAIN #{::SQL_STATEMENT}"
+        fail "Unexpected sql statement #{s}"        
+      end
+      s
+    end
+  end
+end
+
+

data/test/new_relic/agent/mock_scope_listener.rb

@@ -0,0 +1,23 @@
+
+class NewRelic::Agent::MockScopeListener
+  
+  attr_reader :scope
+  
+  def initialize
+    @scope = {}
+  end
+  
+  def notice_first_scope_push(time)
+  end
+  
+  def notice_push_scope(scope, time)
+    @scope[scope] = true
+  end
+  
+  def notice_pop_scope(scope, time)
+  end
+  
+  def notice_scope_empty(time)
+    
+  end
+end