genki-newrelic_rpm 2.10.1

data/test/new_relic/agent/agent_test.rb

@@ -0,0 +1,117 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+##require 'new_relic/agent/agent'
+##require 'new_relic/local_environment'
+
+class AgentTest < ActiveSupport::TestCase
+  
+  attr_reader :agent
+  
+  # Fake out the agent to think mongrel is running
+  def setup
+    NewRelic::Agent.manual_start
+    @agent = NewRelic::Agent.instance
+  end
+  def teardown
+    NewRelic::Control.instance['app_name']=nil
+    NewRelic::Control.instance['dispatcher']=nil
+    NewRelic::Control.instance['dispatcher_instance_id']=nil
+  end
+  def test_agent_setup
+    assert NewRelic::Agent.instance.class == NewRelic::Agent::Agent
+    assert_raise RuntimeError do
+      NewRelic::Control.instance.init_plugin :agent_enabled => false
+    end
+  end
+  
+  def test_public_apis
+    assert_raise RuntimeError do
+      NewRelic::Agent.set_sql_obfuscator(:unknown) do |sql|
+        puts sql
+      end
+    end
+    
+    ignore_called = false
+    NewRelic::Agent.ignore_error_filter do |e|
+      ignore_called = true
+      nil
+    end
+    NewRelic::Agent.notice_error(ActionController::RoutingError.new("message"), :x => "y")
+    assert ignore_called    
+  end
+  
+  def test_startup_shutdown
+    @agent = NewRelic::Agent::ShimAgent.instance
+    @agent.shutdown
+    assert (not @agent.started?)
+    @agent.start 
+    assert !@agent.started?
+    # this installs the real agent:
+    NewRelic::Agent.manual_start
+    @agent = NewRelic::Agent.instance
+    assert @agent != NewRelic::Agent::ShimAgent.instance
+    assert @agent.started?
+    @agent.shutdown
+    assert !@agent.started?
+    @agent.start
+    assert @agent.started?
+  end
+  
+  def test_manual_overrides
+    NewRelic::Agent.manual_start :app_name => "testjobs", :dispatcher_instance_id => "mailer"
+    assert_equal "testjobs", NewRelic::Control.instance.app_names[0]
+    assert_equal "mailer", NewRelic::Control.instance.dispatcher_instance_id
+  end
+  def test_restart
+    NewRelic::Agent.manual_start :app_name => "noapp", :dispatcher_instance_id => ""
+    NewRelic::Agent.manual_start :app_name => "testjobs", :dispatcher_instance_id => "mailer"
+    assert_equal "testjobs", NewRelic::Control.instance.app_names[0]
+    assert_equal "mailer", NewRelic::Control.instance.dispatcher_instance_id
+  end
+  
+  def test_set_record_sql
+    @agent.set_record_sql(false)
+    assert !Thread::current[:record_sql]
+    NewRelic::Agent.disable_sql_recording do
+      assert_equal false, Thread::current[:record_sql]
+      NewRelic::Agent.disable_sql_recording do
+        assert_equal false, Thread::current[:record_sql]
+      end
+      assert_equal false, Thread::current[:record_sql]
+    end
+    assert !Thread::current[:record_sql], Thread::current[:record_sql]
+  ensure
+    @agent.set_record_sql(nil)
+  end
+  
+  def test_version
+    assert_match /\d\.\d+\.\d+/, NewRelic::VERSION::STRING
+  end
+  
+  def test_invoke_remote__ignore_non_200_results
+    NewRelic::Agent::Agent.class_eval do
+      public :invoke_remote
+    end
+    response_mock = mock()
+    Net::HTTP.any_instance.stubs(:request).returns(response_mock)
+    response_mock.stubs(:message).returns("bogus error")
+    
+    for code in %w[500 504 400 302 503] do 
+      assert_raise NewRelic::Agent::IgnoreSilentlyException, "Ignore #{code}" do
+        response_mock.stubs(:code).returns(code)
+        NewRelic::Agent.agent.invoke_remote  :get_data_report_period, 0
+      end
+    end
+  end
+  def test_invoke_remote__throw_other_errors
+    NewRelic::Agent::Agent.class_eval do
+      public :invoke_remote
+    end
+    response_mock = Net::HTTPSuccess.new  nil, nil, nil
+    response_mock.stubs(:body).returns("")
+    Marshal.stubs(:load).raises(RuntimeError, "marshal issue")
+    Net::HTTP.any_instance.stubs(:request).returns(response_mock)
+    assert_raise RuntimeError do
+      NewRelic::Agent.agent.invoke_remote  :get_data_report_period, 0xFEFE
+    end
+  end
+end

data/test/new_relic/agent/agent_test_controller.rb

@@ -0,0 +1,44 @@
+# Defining a test controller class with a superclass, used to 
+# verify correct attribute inheritence
+class NewRelic::Agent::SuperclassController <  ActionController::Base
+  def base_action
+    render :text => 'none'
+  end
+end
+# This is a controller class used in testing controller instrumentation
+class NewRelic::Agent::AgentTestController < NewRelic::Agent::SuperclassController
+  filter_parameter_logging :social_security_number
+  
+  def rescue_action(e) raise e end
+  
+  ActionController::Routing::Routes.draw do | map |
+    map.connect ':controller/:action.:format'
+  end
+  
+  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 action_to_ignore_apdex
+    render :text => 'unmeasured'
+  end
+  def entry_action
+    perform_action_with_newrelic_trace('internal_action') do
+      internal_action
+    end    
+  end
+  private
+  def internal_action
+    perform_action_with_newrelic_trace(:name => 'internal_traced_action', :force => true) do
+      render :text => 'internal action'
+    end
+  end
+end

data/test/new_relic/agent/classloader_patch_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+class ClassLoaderPatchTest < ActiveSupport::TestCase
+  
+  def test_const_undefined
+    require 'new_relic/agent/patch_const_missing'
+    ClassLoadingWatcher.background_thread = Thread.current
+    
+    # try loading some non-existent class
+    NewRelic::Control.instance.log.expects(:error).at_least_once.with{|args| args =~ /Agent background thread.*:FooBar/}
+    NewRelic::Control.instance.log.expects(:error).with{|args| args =~ /Agent background thread.*:FooBaz/}.never
+    
+    ClassLoadingWatcher.enable_warning
+    assert_raise NameError do
+      FooBar::Bat
+    end
+    
+    ClassLoadingWatcher.disable_warning
+    assert_raise NameError do
+      FooBaz::Bat
+    end
+  end
+
+  def test_require
+    require 'new_relic/agent/patch_const_missing'
+    ClassLoadingWatcher.background_thread = Thread.current
+    
+    # try loading some non-existent class
+    NewRelic::Control.instance.log.expects(:error).at_least_once.with{|args| args =~ /Agent background thread.*rational/}
+    NewRelic::Control.instance.log.expects(:error).with{|args| args =~ /Agent background thread.*pstore/}.never
+    
+    ClassLoadingWatcher.enable_warning
+    require('rational') # standard library probably not loaded yet
+
+    ClassLoadingWatcher.disable_warning
+
+    require 'pstore' # standard library probably not loaded yet
+  end
+  
+  def test_load
+    require 'new_relic/agent/patch_const_missing'
+    ClassLoadingWatcher.background_thread = Thread.current
+    
+    # try loading some non-existent class
+    NewRelic::Control.instance.log.expects(:error).with{|args| args =~ /Agent background thread.*tsort/}.at_least_once
+    NewRelic::Control.instance.log.expects(:error).with{|args| args =~ /Agent background thread.*getoptlong/}.never
+    
+    ClassLoadingWatcher.enable_warning
+    
+    load 'tsort.rb' # standard library probably not loaded yet
+
+    ClassLoadingWatcher.disable_warning
+
+    load 'getoptlong.rb'  # standard library probably not loaded yet
+  end
+end

data/test/new_relic/agent/collection_helper_test.rb

@@ -0,0 +1,118 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require 'ostruct'
+require 'active_record_fixtures'
+class NewRelic::Agent::CollectionHelperTest < Test::Unit::TestCase
+  
+  def setup
+    super
+    NewRelic::Agent.manual_start
+  end
+  def teardown
+    super
+  end
+  
+  include NewRelic::Agent::CollectionHelper
+  def test_string
+    val = ('A'..'Z').to_a.join * 100
+    assert_equal val.first(256) + "...", normalize_params(val)
+  end
+  def test_array
+    new_array = normalize_params [ 1000 ] * 50
+    assert_equal 20, new_array.size
+    assert_equal '1000', new_array[0]
+  end
+  def test_boolean
+    np = normalize_params(NewRelic::Control.instance.settings)
+    assert_equal false, np['enabled']
+  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.grep(/newrelic_rpm/)
+      assert_equal 0, clean_trace.grep(/trace/).size, clean_trace.grep(/trace/)
+      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
+end

data/test/new_relic/agent/dispatcher_instrumentation_test.rb

@@ -0,0 +1,76 @@
+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
+    super
+    NewRelic::Agent.manual_start
+    NewRelic::Agent.instance.stats_engine.clear_stats
+    @instance_busy = NewRelic::Agent.agent.stats_engine.get_stats('Instance/Busy')
+    @dispatch_stat = NewRelic::Agent.agent.stats_engine.get_stats 'HttpDispatcher'
+    @mongrel_queue_stat = NewRelic::Agent.agent.stats_engine.get_stats 'WebFrontend/Mongrel/Average Queue Time'
+  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_histogram
+    d = FunnyDispatcher.new
+    d.newrelic_dispatcher_start
+    d.newrelic_dispatcher_finish
+    bucket = NewRelic::Agent.instance.stats_engine.metrics.find { | m | m =~ /^Response Times/ }
+    assert_not_nil bucket
+    bucket_stats = NewRelic::Agent.instance.stats_engine.get_stats(bucket)
+    assert_equal 1, bucket_stats.call_count
+  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