newrelic_rpm 2.8.11 → 2.9.2

data/test/new_relic/agent/controller_test.rb

@@ -0,0 +1,107 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require 'action_controller/base'
+
+class AgentControllerTest < ActionController::TestCase
+  
+  self.controller_class = NewRelic::Agent::AgentTestController
+  
+  attr_accessor :agent
+  
+  # Normally you can do this with #setup but for some reason in rails 2.0.2
+  # setup is not called.
+  def initialize name
+    super name
+    Thread.current[:controller_ignored] = nil
+    NewRelic::Agent.manual_start
+    @agent = NewRelic::Agent.instance
+    #    @agent.instrument_app
+    agent.transaction_sampler.harvest
+    NewRelic::Agent::AgentTestController.class_eval do
+      newrelic_ignore :only => [:action_to_ignore, :entry_action, :base_action]
+      newrelic_ignore_apdex :only => :action_to_ignore_apdex
+    end
+  end
+  
+  def teardown
+    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__ignore_base
+    engine = @agent.stats_engine
+    get :base_action
+    assert_equal true, Thread.current[:controller_ignored]
+  end
+  def test_metric__no_ignore
+    engine = @agent.stats_engine
+    path = 'new_relic/agent/agent_test/index'
+    cpu_stats = engine.get_stats_no_scope("ControllerCPU/#{path}")
+    index_stats = engine.get_stats_no_scope("Controller/#{path}")
+    index_apdex_stats = engine.get_custom_stats("Apdex/#{path}", NewRelic::ApdexStats)
+    assert_difference 'index_stats.call_count' do
+      assert_difference 'index_apdex_stats.call_count' do
+        assert_difference 'cpu_stats.call_count' do
+          get :index
+        end
+      end
+    end
+    assert_nil Thread.current[:controller_ignored]
+  end
+  def test_metric__ignore_apdex
+    engine = @agent.stats_engine
+    path = 'new_relic/agent/agent_test/action_to_ignore_apdex'
+    cpu_stats = engine.get_stats_no_scope("ControllerCPU/#{path}")
+    index_stats = engine.get_stats_no_scope("Controller/#{path}")
+    index_apdex_stats = engine.get_custom_stats("Apdex/#{path}", NewRelic::ApdexStats)
+    assert_difference 'index_stats.call_count' do
+      assert_no_difference 'index_apdex_stats.call_count' do
+        assert_difference 'cpu_stats.call_count' do
+          get :action_to_ignore_apdex
+        end
+      end
+    end
+    assert_nil Thread.current[:controller_ignored]
+    
+  end
+  def test_metric__dispatched
+    engine = @agent.stats_engine
+    get :entry_action
+    assert_nil Thread.current[:controller_ignored]
+    assert_nil engine.lookup_stat('Controller/agent_test/entry_action')
+    assert_equal 1, engine.lookup_stat('Controller/new_relic/agent/agent_test/internal_action').call_count
+  end
+  def test_action_instrumentation
+    begin
+      get :index, :foo => 'bar'
+      assert_match /bar/, @response.body
+      #rescue ActionController::RoutingError
+      # you might get here if you don't have the default route installed.
+    end
+  end
+  
+  def test_controller_params
+    
+    assert agent.transaction_sampler
+    
+    num_samples = NewRelic::Agent.instance.transaction_sampler.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.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/dispatcher_instrumentation_test.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+class NewRelic::Agent::DispatcherInstrumentationTest < Test::Unit::TestCase
+  
+  class FunnyDispatcher
+    include NewRelic::Agent::Instrumentation::DispatcherInstrumentation
+    def newrelic_response_code; end
+  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_equal 0, NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.busy_count
+    d.newrelic_dispatcher_start
+    sleep 1.0
+    assert_equal 1, NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.busy_count
+    d.newrelic_dispatcher_finish
+    assert_equal 0, NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.busy_count
+    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_ignore_zero_counts
+    assert_equal 0, @instance_busy.call_count, "Problem with test--instance busy not starting off at zero."
+    NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.harvest_busy
+    NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.harvest_busy
+    NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.harvest_busy
+    assert_equal 0, @instance_busy.call_count  
+  end
+  def test_recursive_call
+    d0 = FunnyDispatcher.new
+    d1 = FunnyDispatcher.new
+
+    assert_equal 0, @instance_busy.call_count, "Problem with test--instance busy not starting off at zero."
+
+    NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.harvest_busy
+    NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.harvest_busy
+    assert_equal 0, @instance_busy.call_count  
+
+    assert_equal 0, NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.busy_count
+    d0.newrelic_dispatcher_start
+    assert_equal 1, NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.busy_count
+    d1.newrelic_dispatcher_start
+    assert_equal 2, NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.busy_count
+    sleep 1
+    d0.newrelic_dispatcher_finish
+    assert_equal 1, NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.busy_count
+    d1.newrelic_dispatcher_finish
+    assert_equal 0, NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.busy_count
+    assert_nil Thread.current[:newrelic_t0]
+    NewRelic::Agent::Instrumentation::DispatcherInstrumentation::BusyCalculator.harvest_busy
+    assert_equal 1, @instance_busy.call_count  
+    assert @instance_busy.total_call_time.between?(1.8, 2.1), "Should be about 200%: #{@instance_busy.total_call_time}"
+  end
+end

data/test/new_relic/agent/error_collector_test.rb

@@ -0,0 +1,155 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+##require 'new_relic/agent/error_collector'
+require 'test/unit'
+
+
+class FakeRequest
+  attr_reader :path
+  
+  def initialize(path)
+    @path = path
+  end
+  
+  def referer
+    "test_referer"
+  end
+end
+
+class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
+  
+  def setup
+    @error_collector = NewRelic::Agent::ErrorCollector.new(nil)
+  end
+  
+  def test_simple
+    @error_collector.notice_error(Exception.new("message"), FakeRequest.new('/myurl/'), 'path', {: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), FakeRequest.new('/myurl/'), 'path', {:x => 'y'})
+    
+    old_errors = []
+    errors = @error_collector.harvest_errors(old_errors)
+    
+    assert_equal errors.length, 1
+    
+    err = errors.first
+    assert_equal ('1234567890' * 500)[0..4096], err.message
+  end
+  
+  def test_collect_failover
+    @error_collector.notice_error(Exception.new("message"), nil, 'first', {:x => 'y'})
+    
+    errors = @error_collector.harvest_errors([])
+    
+    @error_collector.notice_error(Exception.new("message"), nil, 'second', {:x => 'y'})
+    @error_collector.notice_error(Exception.new("message"), nil, 'path', {:x => 'y'})
+    @error_collector.notice_error(Exception.new("message"), nil, 'path', {: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"), nil, 'path', {:x => 'y'})
+    @error_collector.notice_error(Exception.new("message"), nil, 'last', {: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(::STDERR) do
+     (max_q_length + 5).times do |n|
+        @error_collector.notice_error(Exception.new("exception #{n}"), nil, "path", {: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"), nil, 'path', {:x => test[0]})
+      
+      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(ActionController::RoutingError.new("message"), nil, 'path', {: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? ActionController::RoutingError
+        nil
+      else
+        e
+      end
+    end
+    
+    @error_collector.notice_error(ActionController::RoutingError.new("message"), nil, 'path', {:x => 'y'})
+    
+    errors = @error_collector.harvest_errors([])
+    
+    assert_equal 0, errors.length
+  end
+  
+end

data/test/new_relic/agent/{tc_method_tracer.rb → method_tracer_test.rb}

@@ -1,8 +1,6 @@
 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)
@@ -52,23 +50,20 @@ module NewRelic
   end
 end
 
-class NewRelic::Agent::MethodTracerTests < Test::Unit::TestCase
+class NewRelic::Agent::MethodTracerTest < 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
+    NewRelic::Agent.manual_start
+    @stats_engine = NewRelic::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
@@ -102,7 +97,6 @@ class NewRelic::Agent::MethodTracerTests < Test::Unit::TestCase
   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
@@ -141,7 +135,7 @@ class NewRelic::Agent::MethodTracerTests < Test::Unit::TestCase
   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
+    sampler = NewRelic::Agent.instance.transaction_sampler
     mock = Insider.new(@stats_engine)
     mock.catcher(0)
     mock.catcher(5)
@@ -149,7 +143,7 @@ class NewRelic::Agent::MethodTracerTests < Test::Unit::TestCase
     assert_equal 2, stats.call_count
     stats = @stats_engine.get_stats("thrower")
     assert_equal 6, stats.call_count
-    sample = sampler.harvest_slowest_sample
+    sample = sampler.harvest
     assert_not_nil sample
   end
   
@@ -263,7 +257,7 @@ class NewRelic::Agent::MethodTracerTests < Test::Unit::TestCase
   end
   
   def check_time (t1, t2)
-    assert((t2-t1).abs < 0.01)
+    assert((t2-t1).abs < 0.01, "Times not close: #{t1} ~ #{t2}")
   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
+