newrelic_rpm 2.8.11 → 2.9.2

data/test/new_relic/agent/tc_agent.rb

@@ -1,148 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-##require 'new_relic/agent/agent'
-##require 'new_relic/local_environment'
-require 'net/http'
-
-class AgentTests < ActiveSupport::TestCase
-  
-  attr_reader :agent
-  
-  # Fake out the agent to think mongrel is running
-  def setup
-    @agent = NewRelic::Agent.instance
-    @agent.start :test, :test
-  end
-  
-  # Remove the port method so it won't think mongrel
-  # is available
-  def teardown
-    @agent.shutdown
-    super
-  end
-  
-  def test_public_apis
-    begin
-      NewRelic::Agent.set_sql_obfuscator(:unknown) do |sql|
-        puts sql
-      end
-      fail
-    rescue
-      # ok
-    end
-    
-    
-    ignore_called = false
-    NewRelic::Agent.ignore_error_filter do |e|
-      ignore_called = true
-      nil
-    end
-    
-    NewRelic::Agent.agent.error_collector.notice_error('path', nil, {:x => 'y'}, ActionController::RoutingError.new("message"))
-    
-    assert ignore_called    
-  end
-  
-  def test_startup_shutdown
-    @agent.shutdown
-    assert (not @agent.started?)
-    @agent.start "ruby", "test1"
-    assert @agent.started?
-    @agent.shutdown
-    @agent.start "ruby", "test2"
-  end
-  def test_setup_log_default
-    assert @agent.log.instance_of?(Logger), @agent.log
-    logfile = @agent.log.instance_eval { @logdev.filename }
-    assert_match /\/log\/newrelic_agent\..*\.log$/,logfile
-    @agent.shutdown
-  end
-  
-  def test_classloading_patch
-    require 'new_relic/agent/patch_const_missing'
-    ClassLoadingWatcher.set_background_thread(Thread.current)
-    
-    NewRelic::Config.instance.log.expects(:error).at_least_once.with{|args| args =~ /Agent background thread.*:FooBar/}
-    NewRelic::Config.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.set_background_thread(Thread.current)
-    
-    # try loading some non-existent class
-    NewRelic::Config.instance.log.expects(:error).at_least_once.with{|args| args =~ /Agent background thread.*net/}
-    NewRelic::Config.instance.log.expects(:error).with{|args| args =~ /Agent background thread.*net/}.never
-    
-    ClassLoadingWatcher.enable_warning
-    
-    require 'net/http'
-
-    ClassLoadingWatcher.disable_warning
-
-    require 'net/http'
-  end
-  
-  def test_load
-    require 'new_relic/agent/patch_const_missing'
-    ClassLoadingWatcher.set_background_thread(Thread.current)
-    
-    # try loading some non-existent class
-    NewRelic::Config.instance.log.expects(:error).at_least_once.with{|args| args =~ /Agent background thread.*/}
-    NewRelic::Config.instance.log.expects(:error).with{|args| args =~ /Agent background thread.*/}.never
-    
-    ClassLoadingWatcher.enable_warning
-    
-    load 'net/http.rb'
-
-    ClassLoadingWatcher.disable_warning
-
-    load 'net/http.rb'
-  end
-
-  def test_info
-    props = NewRelic::Config.instance.app_config_info
-    list = props.assoc('Plugin List').last.sort
-    assert_not_nil list # can't really guess what might be in here.  
-    assert_match /jdbc|postgres|mysql|sqlite/, props.assoc('Database adapter').last
-  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/tc_controller.rb

@@ -1,77 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
-require 'action_controller/base'
-#require 'new_relic/agent/agent_test_controller'
-
-class AgentControllerTests < ActionController::TestCase
-  
-  self.controller_class = NewRelic::Agent::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
-    NewRelic::Agent::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/new_relic/agent/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/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.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

@@ -1,52 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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_stats_engine.rb

@@ -1,218 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
-require 'test/unit'
-##require 'new_relic/agent/stats_engine'
-
-
-module NewRelic::Agent
-  class StatsEngineTests < Test::Unit::TestCase
-    def setup
-      @engine = StatsEngine.new
-    end
-  
-    def test_get_no_scope
-      s1 = @engine.get_stats "a"
-      s2 = @engine.get_stats "a"
-      s3 = @engine.get_stats "b"
-      
-      assert_not_nil s1
-      assert_not_nil s2
-      assert_not_nil s3
-      
-      assert s1 == s2
-      assert s1 != s3
-    end
-    
-    def test_harvest
-      s1 = @engine.get_stats "a"
-      s2 = @engine.get_stats "c"
-      
-      s1.trace_call 10
-      s2.trace_call 1
-      s2.trace_call 3
-      
-      assert @engine.get_stats("a").call_count == 1
-      assert @engine.get_stats("a").total_call_time == 10
-      
-      assert @engine.get_stats("c").call_count == 2
-      assert @engine.get_stats("c").total_call_time == 4
-      
-      metric_data = @engine.harvest_timeslice_data({}, {}).values
-      
-      # after harvest, all the metrics should be reset
-      assert @engine.get_stats("a").call_count == 0
-      assert @engine.get_stats("a").total_call_time == 0
-      
-      assert @engine.get_stats("c").call_count == 0
-      assert @engine.get_stats("c").total_call_time == 0
-
-      metric_data = metric_data.reverse if metric_data[0].metric_spec.name != "a"
-
-      assert metric_data[0].metric_spec.name == "a"
-
-      assert metric_data[0].stats.call_count == 1
-      assert metric_data[0].stats.total_call_time == 10
-    end
-    
-    def test_harvest_with_merge
-      s = @engine.get_stats "a"
-      s.trace_call 1
-      
-      assert @engine.get_stats("a").call_count == 1
-      
-      harvest = @engine.harvest_timeslice_data({}, {})
-      assert s.call_count == 0
-      s.trace_call 2
-      assert s.call_count == 1
-      
-      # this calk should merge the contents of the previous harvest,
-      # so the stats for metric "a" should have 2 data points
-      harvest = @engine.harvest_timeslice_data(harvest, {})
-      stats = harvest.fetch(NewRelic::MetricSpec.new("a")).stats
-      assert stats.call_count == 2
-      assert stats.total_call_time == 3
-    end
-    
-    def test_scope
-      @engine.push_scope "scope1"
-      assert @engine.peek_scope.name == "scope1"
-      
-      expected = @engine.push_scope "scope2"
-      @engine.pop_scope expected, 0
-      
-      scoped = @engine.get_stats "a"
-      scoped.trace_call 3
-      
-      assert scoped.total_call_time == 3
-      unscoped = @engine.get_stats "a"
-      
-      assert scoped == @engine.get_stats("a")
-      assert unscoped.total_call_time == 3
-    end
-   
-
-    def test_simplethrowcase(depth=0)
-      
-      fail "doh" if depth == 10
-      
-      scope = @engine.push_scope "scope#{depth}"    
-            
-      begin
-        test_simplethrowcase(depth+1)
-      rescue StandardError => e
-        if (depth != 0)
-          raise e
-        end
-      ensure
-        @engine.pop_scope scope, 0
-      end
-      
-      if depth == 0
-        assert @engine.peek_scope.nil?
-      end
-    end
-    
-    
-    def test_scope_failure
-      scope1 = @engine.push_scope "scope1"
-      @engine.push_scope "scope2"
-      
-      begin
-        @engine.pop_scope scope1
-        fail "Didn't throw when scope push/pop mismatched"
-      rescue
-        # success
-      end
-    end
-    
-    def test_children_time
-      t1 = Time.now
-      
-      expected1 = @engine.push_scope "a"
-        sleep 0.1
-        t2 = Time.now
-
-        expected2 = @engine.push_scope "b"
-          sleep 0.2
-          t3 = Time.now
-          
-          expected = @engine.push_scope "c"
-            sleep 0.3
-          scope = @engine.pop_scope expected, Time.now - t3
-          
-          t4 = Time.now
-    
-          check_time_approximate 0, scope.children_time
-          check_time_approximate 0.3, @engine.peek_scope.children_time
-    
-          sleep 0.1
-          t5 = Time.now
-    
-          expected = @engine.push_scope "d"
-            sleep 0.2
-          scope = @engine.pop_scope expected, Time.now - t5
-          
-          t6 = Time.now
-
-          check_time_approximate 0, scope.children_time
-    
-        scope = @engine.pop_scope expected2, Time.now - t2
-        assert_equal scope.name, 'b'
-        
-        check_time_approximate (t4 - t3) + (t6 - t5), scope.children_time
-      
-      scope = @engine.pop_scope expected1, Time.now - t1
-      assert_equal scope.name, 'a'
-      
-      check_time_approximate (t6 - t2), scope.children_time
-    end
-    
-    def test_simple_start_transaction
-      @engine.push_scope "scope"
-      @engine.start_transaction
-      assert @engine.peek_scope.nil?
-    end 
-    
-    
-    # test for when the scope stack contains an element only used for tts and not metrics
-    def test_simple_tt_only_scope
-       scope1 = @engine.push_scope "a", 0, true
-       scope2 = @engine.push_scope "b", 10, false
-       scope3 = @engine.push_scope "c", 20, true
-       
-       @engine.pop_scope scope3, 10
-       @engine.pop_scope scope2, 10
-       @engine.pop_scope scope1, 10
-       
-       assert_equal 0, scope3.children_time
-       assert_equal 10, scope2.children_time
-       assert_equal 10, scope1.children_time 
-    end
-    
-    def test_double_tt_only_scope
-       scope1 = @engine.push_scope "a", 0, true
-       scope2 = @engine.push_scope "b", 10, false
-       scope3 = @engine.push_scope "c", 20, false
-       scope4 = @engine.push_scope "d", 30, true
-       
-       @engine.pop_scope scope4, 10
-       @engine.pop_scope scope3, 10
-       @engine.pop_scope scope2, 10
-       @engine.pop_scope scope1, 10
-       
-       assert_equal 0, scope4.children_time
-       assert_equal 10, scope3.children_time
-       assert_equal 10, scope2.children_time
-       assert_equal 10, scope1.children_time 
-    end
-    
-
-    private 
-      def check_time_approximate(expected, actual)
-        assert((expected - actual).abs < 0.01, "Expected #{expected}, got #{actual}")
-      end
-
-  end
-  
-
-  
-end