newrelic_rpm 2.8.11 → 2.9.2

data/test/config/{test_config.rb → test_control.rb}

@@ -1,26 +1,30 @@
-require 'new_relic/config/rails'
+require 'new_relic/control/rails'
 require 'new_relic/agent/agent_test_controller'
 
-class NewRelic::Config::Test < NewRelic::Config::Rails
+class NewRelic::Control::Test < NewRelic::Control::Rails
   def env
     'test'
   end
+  def app
+    :rails
+  end
   def config_file
     File.join(File.dirname(__FILE__), "newrelic.yml")
   end
-  def initialize
-    super
-    setup_log env
+  def initialize local_env
+    super local_env
+    setup_log 
   end
   # when running tests, don't write out stderr
   def log!(msg, level=:info)
     log.send level, msg if log
   end
-  
+
   # Add the default route in case it's missing.  Need it for testing.
   def install_devmode_route
-    if super
-      ActionController::Routing::RouteSet.class_eval do
+    super
+    ActionController::Routing::RouteSet.class_eval do
+      return if defined? draw_without_test_route
       def draw_with_test_route
         draw_without_test_route do | map |
           map.connect ':controller/:action/:id'
@@ -29,7 +33,7 @@ class NewRelic::Config::Test < NewRelic::Config::Rails
       end
       alias_method_chain :draw, :test_route
     end
-    return true
-    end
+    # Force the routes to be reloaded
+    ActionController::Routing::Routes.reload!
   end
 end

data/test/new_relic/agent/active_record_instrumentation_test.rb

@@ -0,0 +1,189 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require 'active_record_fixtures'
+
+class ActiveRecordInstrumentationTest < Test::Unit::TestCase
+  
+  def setup
+    NewRelic::Agent.manual_start
+    NewRelic::Agent.instance.stats_engine.clear_stats
+    ActiveRecordFixtures.setup
+    NewRelic::Agent.instance.transaction_sampler.harvest
+  rescue
+    puts e
+    puts e.backtrace.join("\n")
+  end
+  
+  def teardown
+    ActiveRecordFixtures.teardown
+  end
+  def test_agent_setup
+    assert NewRelic::Agent.instance.class == NewRelic::Agent::Agent
+  end
+  def test_finder
+    ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
+    ActiveRecordFixtures::Order.find(:all)
+    s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
+    assert_equal 1, s.call_count
+    ActiveRecordFixtures::Order.find_all_by_name "jeff"
+    s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
+    assert_equal 2, s.call_count
+  end
+  
+  # multiple duplicate find calls should only cause metric trigger on the first
+  # call.  the others are ignored.
+  def test_query_cache
+    ActiveRecordFixtures::Order.cache do
+      m = ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
+      ActiveRecordFixtures::Order.find(:all)
+      s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
+      assert_equal 1, s.call_count
+      
+      10.times { ActiveRecordFixtures::Order.find m.id }
+    end
+    s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
+    assert_equal 2, s.call_count    
+  end
+  
+  def test_metric_names
+    m = ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
+    m = ActiveRecordFixtures::Order.find(m.id)
+    m.id = 999
+    m.save!
+    
+    metrics = NewRelic::Agent.instance.stats_engine.metrics
+    #   This doesn't work on hudson because the sampler metrics creep in.    
+    #   metrics = NewRelic::Agent.instance.stats_engine.metrics.select { |mname| mname =~ /ActiveRecord\/ActiveRecordFixtures::Order\// }.sort
+    expected = %W[
+      ActiveRecord/create
+      ActiveRecord/find
+      ActiveRecord/ActiveRecordFixtures::Order/create
+      ActiveRecord/ActiveRecordFixtures::Order/find
+      ]
+    expected += %W[ActiveRecord/save ActiveRecord/ActiveRecordFixtures::Order/save] if NewRelic::Control.instance.rails_version < '2.1.0'   
+    compare_metrics expected, metrics
+    assert_equal 1, NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find").call_count
+    assert_equal 1, NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/create").call_count
+  end
+  def test_join_metrics
+    m = ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
+    m = ActiveRecordFixtures::Order.find(m.id)
+    s = m.shipments.create
+    m.shipments.to_a
+    m.destroy
+    
+    metrics = NewRelic::Agent.instance.stats_engine.metrics
+    #   This doesn't work on hudson because the sampler metrics creep in.    
+    #   metrics = NewRelic::Agent.instance.stats_engine.metrics.select { |mname| mname =~ /ActiveRecord\/ActiveRecordFixtures::Order\// }.sort
+    compare_metrics %W[
+    ActiveRecord/destroy
+    ActiveRecord/ActiveRecordFixtures::Order/destroy
+    Database/SQL/insert
+    Database/SQL/delete
+    ActiveRecord/create
+    ActiveRecord/find
+    ActiveRecord/ActiveRecordFixtures::Order/create
+    ActiveRecord/ActiveRecordFixtures::Order/find
+    ActiveRecord/ActiveRecordFixtures::Shipment/find
+    ActiveRecord/ActiveRecordFixtures::Shipment/create
+    ], metrics
+    assert_equal 1, NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find").call_count
+    assert_equal 1, NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Shipment/find").call_count
+    assert_equal 1, NewRelic::Agent.get_stats("Database/SQL/insert").call_count
+    assert_equal 1, NewRelic::Agent.get_stats("Database/SQL/delete").call_count
+  end
+  def test_direct_sql
+    list = ActiveRecordFixtures::Order.connection.select_rows "select * from #{ActiveRecordFixtures::Order.table_name}"
+    metrics = NewRelic::Agent.instance.stats_engine.metrics
+    compare_metrics %W[
+    Database/SQL/select
+    ], metrics
+    assert_equal 1, NewRelic::Agent.get_stats("Database/SQL/select").call_count
+  end
+  
+  def test_run_explains
+    ActiveRecordFixtures::Order.add_delay
+    ActiveRecordFixtures::Order.find(:all)
+    
+    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
+    
+    segment = sample.root_segment.called_segments.first.called_segments.first
+    assert_match /^SELECT \* FROM ["`]?#{ActiveRecordFixtures::Order.table_name}["`]?$/i, segment.params[:sql].strip
+    NewRelic::TransactionSample::Segment.any_instance.expects(:explain_sql).returns([])
+    sample = sample.prepare_to_send(:obfuscate_sql => true, :explain_enabled => true, :explain_sql => 0.0)
+    segment = sample.root_segment.called_segments.first.called_segments.first
+  end
+  def test_prepare_to_send
+    ActiveRecordFixtures::Order.add_delay
+    ActiveRecordFixtures::Order.find(:all)
+    
+    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
+    # 
+    sql_segment = sample.root_segment.called_segments.first.called_segments.first
+    assert_match /^SELECT /, sql_segment.params[:sql]
+    assert sql_segment.duration > 0.0, "Segment duration must be greater than zero."
+    sample = sample.prepare_to_send(:record_sql => :raw, :explain_enabled => true, :explain_sql => 0.0)
+    sql_segment = sample.root_segment.called_segments.first.called_segments.first
+    assert_match /^SELECT /, sql_segment.params[:sql]
+    explanations = sql_segment.params[:explanation]
+    if isMysql? || isPostgres?
+      assert_not_nil explanations, "No explains in segment: #{sql_segment}"
+      assert_equal 1, explanations.size,"No explains in segment: #{sql_segment}" 
+      assert_equal 1, explanations.first.size
+    end
+  end
+  def test_transaction
+    ActiveRecordFixtures::Order.add_delay
+    ActiveRecordFixtures::Order.find(:all)
+    
+    sample = NewRelic::Agent.instance.transaction_sampler.last_sample
+    
+    sample = sample.prepare_to_send(:obfuscate_sql => true, :explain_enabled => true, :explain_sql => 0.0)
+    segment = sample.root_segment.called_segments.first.called_segments.first
+    assert_nil segment.params[:sql], "SQL should have been removed."
+    explanations = segment.params[:explanation]
+    if isMysql? || isPostgres?
+      assert_not_nil explanations, "No explains in segment: #{segment}"
+      assert_equal 1, explanations.size,"No explains in segment: #{segment}" 
+      assert_equal 1, explanations.first.size
+    end    
+    if isPostgres?
+      assert_equal Array, explanations.class
+      assert_equal Array, explanations[0].class
+      assert_equal Array, explanations[0][0].class
+      assert_match /Seq Scan on test_data/, explanations[0][0].join(";") 
+    elsif isMysql?
+      assert_equal "1;SIMPLE;#{ActiveRecordFixtures::Order.table_name};ALL;;;;;1;", explanations.first.first.join(";")
+    end
+    
+    s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
+    assert_equal 1, s.call_count
+  end
+  # These are only valid for rails 2.1 and later
+  if NewRelic::Control.instance.rails_version >= NewRelic::VersionNumber.new("2.1.0")
+    ActiveRecordFixtures::Order.class_eval do
+      named_scope :jeffs, :conditions => { :name => 'Jeff' }
+    end
+    def test_named_scope
+      ActiveRecordFixtures::Order.create :name => 'Jeff'
+      s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
+      before_count = s.call_count
+      x = ActiveRecordFixtures::Order.jeffs.find(:all)
+      assert_equal 1, x.size
+      se = NewRelic::Agent.instance.stats_engine
+      assert_equal before_count+1, s.call_count
+    end
+  end
+  
+  private
+  def compare_metrics expected_list, actual_list
+    actual = Set.new actual_list
+    expected = Set.new expected_list
+    assert_equal expected, actual, "extra: #{(actual - expected).to_a.join(", ")}; missing: #{(expected - actual).to_a.join(", ")}"
+  end
+  def isPostgres?
+    ActiveRecordFixtures::Order.configurations[RAILS_ENV]['adapter'] =~ /postgres/
+  end
+  def isMysql?
+    ActiveRecordFixtures::Order.connection.class.name =~ /mysql/i 
+  end
+end

data/test/new_relic/agent/agent_test.rb

@@ -0,0 +1,104 @@
+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.agent.error_collector.notice_error(ActionController::RoutingError.new("message"), nil, "path", {: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_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

@@ -1,6 +1,20 @@
+# 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 < ActionController::Base
+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
@@ -13,6 +27,9 @@ class NewRelic::Agent::AgentTestController < ActionController::Base
   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

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/{tc_collection_helper.rb → collection_helper_test.rb}

@@ -1,17 +1,13 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
 require 'ostruct'
-require 'new_relic/agent/model_fixture'
-
-class NewRelic::Agent::CollectionHelperTests < Test::Unit::TestCase
+require 'active_record_fixtures'
+class NewRelic::Agent::CollectionHelperTest < Test::Unit::TestCase
   
   def setup
     super
-    NewRelic::Agent::ModelFixture.setup
-    NewRelic::Agent.instance.start :test, :test
+    NewRelic::Agent.manual_start
   end
   def teardown
-    NewRelic::Agent::ModelFixture.teardown
-    NewRelic::Agent.instance.shutdown
     super
   end
   
@@ -26,7 +22,7 @@ class NewRelic::Agent::CollectionHelperTests < Test::Unit::TestCase
     assert_equal '1000', new_array[0]
   end
   def test_boolean
-    np = normalize_params(NewRelic::Config.instance.settings)
+    np = normalize_params(NewRelic::Control.instance.settings)
     assert_equal false, np['enabled']
   end
   class MyString < String; end
@@ -68,11 +64,11 @@ class NewRelic::Agent::CollectionHelperTests < Test::Unit::TestCase
   end
   
   class MyEnumerable
-     include Enumerable
-     
-     def each
-       yield "1"
-     end
+    include Enumerable
+    
+    def each
+      yield "1"
+    end
   end
   
   def test_enumerable
@@ -84,30 +80,39 @@ class NewRelic::Agent::CollectionHelperTests < Test::Unit::TestCase
   end
   
   def test_stringio
-    # make sure stringios aren't affected
+    # 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 })
-    val = ""
-    s.each { | val | break } 
+    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 z="q">'], normalize_params(['foo', OpenStruct.new('z'=>'q')])
+    assert_equal ["foo", '#<OpenStruct>'], normalize_params(['foo', OpenStruct.new('z'=>'q')])
   end
   
   def test_strip_backtrace
     begin
-      NewRelic::Agent::ModelFixture.find 0
+      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"
+      #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: \n#{clean_trace.join("\n")}"
+      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