newrelic_rpm 2.8.0

data/test/new_relic/agent/tc_controller.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require 'action_controller/base'
+
+
+class AgentTestController < ActionController::Base
+  filter_parameter_logging :social_security_number
+  def index
+    render :text => params.inspect
+  end
+  def _filter_parameters(params)
+    filter_parameters params
+  end
+  def action_to_render
+    render :text => params.inspect
+  end
+  def action_to_ignore
+    render :text => 'unmeasured'
+  end
+  def entry_action
+    perform_action_with_newrelic_trace('internal_action') do
+      internal_action
+    end    
+  end
+  private
+  def internal_action
+    render :text => 'internal action'
+  end
+end
+
+class AgentControllerTests < ActionController::TestCase
+  
+  self.controller_class = AgentTestController
+  
+  attr_accessor :agent
+  
+  def setup
+    super
+    Thread.current[:controller_ignored] = nil
+    @agent = NewRelic::Agent.instance
+    #    @agent.instrument_app
+    agent.start :test, :test
+    agent.transaction_sampler.harvest_slowest_sample
+    AgentTestController.class_eval do
+      newrelic_ignore :only => [:action_to_ignore, :entry_action]
+    end
+  end
+  
+  def teardown
+    NewRelic::Agent.instance.shutdown
+    Thread.current[:controller_ignored] = nil
+    super
+  end
+  def test_metric__ignore
+    engine = @agent.stats_engine
+    get :action_to_ignore
+    assert_equal true, Thread.current[:controller_ignored]
+  end
+  def test_metric__no_ignore
+    engine = @agent.stats_engine
+    index_stats = engine.get_stats_no_scope('Controller/agent_test/index')
+    assert_difference 'index_stats.call_count' do
+      get :index
+    end
+    assert_equal false, Thread.current[:controller_ignored]
+  end
+  def test_metric__dispatched
+    engine = @agent.stats_engine
+    get :entry_action
+    assert_equal false, Thread.current[:controller_ignored]
+    assert_nil engine.lookup_stat('Controller/agent_test/entry_action')
+    assert_equal 1, engine.lookup_stat('Controller/agent_test/internal_action').call_count
+  end
+  def test_action_instrumentation
+    get :index, :foo => 'bar'
+    assert_match /bar/, @response.body
+  end
+  
+  def test_controller_params
+    
+    assert agent.transaction_sampler
+    
+    num_samples = NewRelic::Agent.instance.transaction_sampler.get_samples.length
+    
+    assert_equal "[FILTERED]", @controller._filter_parameters({'social_security_number' => 'test'})['social_security_number']
+    
+    get :index, 'social_security_number' => "001-555-1212"
+    
+    samples = agent.transaction_sampler.get_samples
+    
+    agent.transaction_sampler.expects(:notice_transaction).never
+    
+    assert_equal num_samples + 1, samples.length
+    
+    assert_equal "[FILTERED]", samples.last.params[:request_params]["social_security_number"]
+    
+  end
+  
+end

data/test/new_relic/agent/tc_dispatcher_instrumentation.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+class NewRelic::Agent::DispatcherInstrumentationTests < Test::Unit::TestCase
+  
+  class FunnyDispatcher
+    include NewRelic::Agent::Instrumentation::DispatcherInstrumentation
+  end
+  def setup
+    @instance_busy = NewRelic::Agent.agent.stats_engine.get_stats('Instance/Busy')
+    @dispatch_stat = NewRelic::Agent.agent.stats_engine.get_stats 'Rails/HTTP Dispatch'
+    @mongrel_queue_stat = NewRelic::Agent.agent.stats_engine.get_stats 'WebFrontend/Mongrel/Average Queue Time'
+
+    NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.harvest_busy
+    @instance_busy.reset
+    @dispatch_stat.reset
+    @mongrel_queue_stat.reset
+
+  end
+  
+  def test_normal_call
+    d = FunnyDispatcher.new
+    assert !NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.is_busy?
+    d.newrelic_dispatcher_start
+    sleep 1.0
+    assert NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.is_busy?
+    d.newrelic_dispatcher_finish
+    assert !NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.is_busy?
+    assert_nil Thread.current[:newrelic_t0]
+    NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.harvest_busy
+
+    assert_equal 1, @instance_busy.call_count
+    assert_equal 1, @dispatch_stat.call_count
+    assert_equal 0, @mongrel_queue_stat.call_count
+    assert @dispatch_stat.total_call_time >= 1.0, "Total call time must be at least one second"
+    assert @instance_busy.total_call_time > 0.9 && @instance_busy.total_call_time <= 1.0, "instance busy = #{@instance_busy.inspect}"
+  end
+  def test_recursive_call
+    d = FunnyDispatcher.new
+    assert !NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.is_busy?
+    d.newrelic_dispatcher_start
+    assert NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.is_busy?
+    d.newrelic_dispatcher_start
+    assert NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.is_busy?
+    d.newrelic_dispatcher_finish
+    assert !NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.is_busy?
+    d.newrelic_dispatcher_finish
+    assert !NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.is_busy?
+    assert_nil Thread.current[:newrelic_t0]
+    NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.harvest_busy
+    assert_equal 1, @instance_busy.call_count  
+  end
+end

data/test/new_relic/agent/tc_error_collector.rb

@@ -0,0 +1,127 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+##require 'new_relic/agent/error_collector'
+require 'test/unit'
+
+    class NewRelic::Agent::ErrorCollectorTests < Test::Unit::TestCase
+      
+      def setup
+        @error_collector = NewRelic::Agent::ErrorCollector.new(nil)
+      end
+
+      def test_simple
+        @error_collector.notice_error('path', '/myurl/', {:x => 'y'}, Exception.new("message"))
+        
+        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.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_collect_failover
+        @error_collector.notice_error('first', nil, {:x => 'y'}, Exception.new("message"))
+        
+        errors = @error_collector.harvest_errors([])
+        
+        @error_collector.notice_error('second', nil, {:x => 'y'}, Exception.new("message"))
+        @error_collector.notice_error('path', nil, {:x => 'y'}, Exception.new("message"))
+        @error_collector.notice_error('path', nil, {:x => 'y'}, Exception.new("message"))
+        
+        errors = @error_collector.harvest_errors(errors)
+        
+        assert_equal 1, errors.length
+        assert_equal 'first', errors.first.path
+
+        # add two more
+        @error_collector.notice_error('path', nil, {:x => 'y'}, Exception.new("message"))
+        @error_collector.notice_error('last', nil, {:x => 'y'}, Exception.new("message"))
+        
+        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(::STDERR) do
+         (max_q_length + 5).times do |n|
+            @error_collector.notice_error("path", nil, {:x => n}, Exception.new("exception #{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: test>"],
+                 [TestClass.new, "#<NewRelic::Agent::ErrorCollectorTests::TestClass>"]
+                ]
+        
+        
+        types.each do |test|
+          @error_collector.notice_error('path', nil, {:x => test[0]}, Exception.new("message"))
+          
+          assert_equal test[1], @error_collector.harvest_errors([])[0].params[:request_params][:x]
+        end
+      end
+      
+      
+      def test_exclude
+        @error_collector.ignore(["ActionController::RoutingError"])
+        
+        @error_collector.notice_error('path', nil, {:x => 'y'}, ActionController::RoutingError.new("message"))
+        
+        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? ActionController::RoutingError
+            nil
+          else
+            e
+          end
+        end
+        
+        @error_collector.notice_error('path', nil, {:x => 'y'}, ActionController::RoutingError.new("message"))
+        
+        errors = @error_collector.harvest_errors([])
+        
+        assert_equal 0, errors.length
+      end
+
+    end

data/test/new_relic/agent/tc_method_tracer.rb

@@ -0,0 +1,306 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require 'new_relic/agent/mock_scope_listener'
+
+::RPM_TRACERS_ENABLED = true unless defined? ::RPM_TRACERS_ENABLED
+
+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.add_scope_stack_listener sampler
+        fail "This should not have worked."
+        rescue; end
+    else
+      thrower(level-1)
+    end
+  end
+end
+
+module NewRelic
+  module Agent
+    
+    # for testing, enable the stats engine to clear itself
+    class StatsEngine
+      def reset
+        scope_stack.clear
+        @stats_hash.clear
+      end
+    end
+    
+    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::MethodTracerTests < Test::Unit::TestCase
+  attr_reader :stats_engine
+  
+  def setup
+    NewRelic::Agent::Agent.instance.shutdown
+    NewRelic::Agent::Agent.instance.start 'rake', 'test'
+    @stats_engine = NewRelic::Agent::Agent.instance.stats_engine
+    @stats_engine.reset
+    @scope_listener = NewRelic::Agent::MockScopeListener.new
+    
+    @stats_engine.add_scope_stack_listener(@scope_listener)
+  end
+  
+  def teardown
+    self.class.remove_method_tracer :method_to_be_traced, @metric_name if @metric_name
+    @metric_name = nil
+    NewRelic::Agent::Agent.instance.shutdown
+  end
+  
+  def test_basic
+    metric = "hello"
+    t1 = Time.now
+    self.class.trace_method_execution_with_scope metric, 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
+  
+  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
+    assert ::RPM_TRACERS_ENABLED
+    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_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::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_slowest_sample
+    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_exception
+    begin
+      metric = "hey there"
+      self.class.trace_method_execution_with_scope metric, true, true 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)
+  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
+  
+end