newrelic_rpm 2.9.9 → 2.10.3

data/test/new_relic/agent/error_collector_test.rb

@@ -1,8 +1,6 @@
 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
   
@@ -18,11 +16,30 @@ end
 class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   
   def setup
-    @error_collector = NewRelic::Agent::ErrorCollector.new(nil)
+    @error_collector = NewRelic::Agent::ErrorCollector.new
+    NewRelic::Agent.instance.stubs(:should_send_errors).returns(true)
+  end
+  def teardown
+    
+  end
+  def test_empty
+    @error_collector.harvest_errors([])
+    @error_collector.notice_error(nil, :metric=> 'path', :request_params => {:x => 'y'})
+    errors = @error_collector.harvest_errors([])
+    
+    assert_equal errors.length, 1
+    
+    err = errors.first
+    assert_equal '<no message>', err.message 
+    assert_equal 'y', err.params[:request_params][:x]
+    assert_equal '', err.params[:request_uri]
+    assert_equal '', err.params[:request_referer]
+    assert_equal 'path', err.path 
+    assert_equal '<no exception>', err.exception_class
+
   end
-  
   def test_simple
-    @error_collector.notice_error(Exception.new("message"), FakeRequest.new('/myurl/'), 'path', {:x => 'y'})
+    @error_collector.notice_error(Exception.new("message"), :uri => '/myurl/', :metric => 'path', :referer => 'test_referer', :request_params => {:x => 'y'})
     
     old_errors = []
     errors = @error_collector.harvest_errors(old_errors)
@@ -46,7 +63,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   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'})
+    @error_collector.notice_error(Exception.new("1234567890" * 500), :uri => '/myurl/', :metric => 'path', :request_params => {:x => 'y'})
     
     old_errors = []
     errors = @error_collector.harvest_errors(old_errors)
@@ -54,17 +71,18 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     assert_equal errors.length, 1
     
     err = errors.first
-    assert_equal ('1234567890' * 500)[0..4096], err.message
+    assert_equal 4096, err.message.length
+    assert_equal ('1234567890' * 500)[0..4095], err.message
   end
   
   def test_collect_failover
-    @error_collector.notice_error(Exception.new("message"), nil, 'first', {:x => 'y'})
+    @error_collector.notice_error(Exception.new("message"), :metric => 'first', :request_params => {: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'})
+    @error_collector.notice_error(Exception.new("message"), :metric => 'second', :request_params => {:x => 'y'}) 
+    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
+    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
     
     errors = @error_collector.harvest_errors(errors)
     
@@ -72,8 +90,8 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     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'})
+    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
+    @error_collector.notice_error(Exception.new("message"), :metric => 'last', :request_params => {:x => 'y'}) 
     
     errors = @error_collector.harvest_errors(nil)
     assert_equal 5, errors.length
@@ -88,7 +106,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     
     silence_stream(::STDERR) do
      (max_q_length + 5).times do |n|
-        @error_collector.notice_error(Exception.new("exception #{n}"), nil, "path", {:x => n})
+        @error_collector.notice_error(Exception.new("exception #{n}"), :metric => "path", :request_params => {:x => n}) 
       end
     end
     
@@ -119,7 +137,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     
     
     types.each do |test|
-      @error_collector.notice_error(Exception.new("message"), nil, 'path', {:x => test[0]})
+      @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => test[0]}) 
       
       assert_equal test[1], @error_collector.harvest_errors([])[0].params[:request_params][:x]
     end
@@ -129,7 +147,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   def test_exclude
     @error_collector.ignore(["ActionController::RoutingError"])
     
-    @error_collector.notice_error(ActionController::RoutingError.new("message"), nil, 'path', {:x => 'y'})
+    @error_collector.notice_error(ActionController::RoutingError.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
     
     errors = @error_collector.harvest_errors([])
     
@@ -145,7 +163,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
       end
     end
     
-    @error_collector.notice_error(ActionController::RoutingError.new("message"), nil, 'path', {:x => 'y'})
+    @error_collector.notice_error(ActionController::RoutingError.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
     
     errors = @error_collector.harvest_errors([])
     

data/test/new_relic/agent/method_tracer_test.rb

@@ -22,7 +22,7 @@ class Insider
       # sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
       sampler = "<none>"
       begin
-        @stats_engine.add_scope_stack_listener sampler
+        @stats_engine.transaction_sampler = sampler
         fail "This should not have worked."
         rescue; end
     else
@@ -33,15 +33,6 @@ 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"
@@ -54,22 +45,27 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
   attr_reader :stats_engine
   
   def setup
+    super
     NewRelic::Agent.manual_start
     @stats_engine = NewRelic::Agent.instance.stats_engine
-    @stats_engine.reset
+    @stats_engine.clear_stats
     @scope_listener = NewRelic::Agent::MockScopeListener.new
-    @stats_engine.add_scope_stack_listener(@scope_listener)
+    @old_sampler = NewRelic::Agent.instance.transaction_sampler
+    @stats_engine.transaction_sampler = @scope_listener
   end
-  
+
   def teardown
+    @stats_engine.transaction_sampler = @old_sampler
+    @stats_engine.clear_stats
     self.class.remove_method_tracer :method_to_be_traced, @metric_name if @metric_name
     @metric_name = nil
+    super
   end
   
   def test_basic
     metric = "hello"
     t1 = Time.now
-    self.class.trace_method_execution_with_scope metric, true, true do
+    self.class.trace_execution_scoped metric do
       sleep 1
       assert metric == @stats_engine.peek_scope.name
     end
@@ -108,7 +104,27 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     assert stats.call_count == 1
   end
   
-  
+  def test_add_method_tracer__default
+    self.class.add_method_tracer :simple_method
+    
+    simple_method
+    
+    stats = @stats_engine.get_stats("Custom/#{self.class.name}/simple_method")
+    assert stats.call_count == 1
+    
+  end
+  def test_add_method_tracer__reentry
+    self.class.add_method_tracer :simple_method
+    self.class.add_method_tracer :simple_method
+    self.class.add_method_tracer :simple_method
+    
+    simple_method
+    
+    stats = @stats_engine.get_stats("Custom/#{self.class.name}/simple_method")
+    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
@@ -220,10 +236,32 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     self.class.static_method "x", self, false
   end
   
+  def test_multiple_metrics__scoped
+    metrics = %w[first second third]
+    self.class.trace_execution_scoped metrics do
+      sleep 0.05
+    end
+    elapsed = @stats_engine.get_stats('first').average_call_time
+    metrics.map{|name| @stats_engine.get_stats name}.each do | m |
+      assert_equal 1, m.call_count
+      assert_equal elapsed, m.total_call_time
+    end
+  end
+  def test_multiple_metrics__unscoped
+    metrics = %w[first second third]
+    self.class.trace_execution_unscoped metrics do
+      sleep 0.05
+    end
+    elapsed = @stats_engine.get_stats('first').average_call_time
+    metrics.map{|name| @stats_engine.get_stats name}.each do | m |
+      assert_equal 1, m.call_count
+      assert_equal elapsed, m.total_call_time
+    end
+  end
   def test_exception
     begin
-      metric = "hey there"
-      self.class.trace_method_execution_with_scope metric, true, true do
+      metric = "hey"
+      self.class.trace_execution_scoped metric do
         assert @stats_engine.peek_scope.name == metric
         throw Exception.new            
       end
@@ -256,8 +294,8 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
     method_to_be_traced 1,2,3,false,'X'
   end
   
-  def check_time (t1, t2)
-    assert((t2-t1).abs < 0.01, "Times not close: #{t1} ~ #{t2}")
+  def check_time(t1, t2)
+    assert_in_delta t2, t1, 0.02
   end
   
   # =======================================================
@@ -296,5 +334,7 @@ class NewRelic::Agent::MethodTracerTest < Test::Unit::TestCase
   
   def method_c3
   end
-  
+
+  def simple_method
+  end
 end

data/test/new_relic/agent/metric_data_test.rb

@@ -47,9 +47,9 @@ class NewRelic::Agent::MetricDataTest < Test::Unit::TestCase
   
   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']
+    compare_spec(metric_data.metric_spec, import['metric_spec']) unless metric_data.metric_id
+    compare_stat(metric_data.stats, import['stats'])
   end
   
 end

data/test/new_relic/agent/metric_frame_test.rb

@@ -0,0 +1,51 @@
+require 'test/unit'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+class NewRelic::Agent::MetricFrameTest < Test::Unit::TestCase
+
+  attr_reader :f
+  def setup
+    @f = NewRelic::Agent::Instrumentation::MetricFrame.new
+  end
+  
+  def test_request_parsing__none
+    assert_nil f.uri
+    assert_nil f.referer
+  end
+  def test_request_parsing__path
+    request = stub(:path => '/path?hello=bob#none')
+    f.request = request
+    assert_equal "/path", f.uri
+  end
+  def test_request_parsing__fullpath
+    request = stub(:fullpath => '/path?hello=bob#none')
+    f.request = request
+    assert_equal "/path", f.uri
+  end
+  def test_request_parsing__referer
+    request = stub(:referer => 'https://www.yahoo.com:8080/path/hello?bob=none&foo=bar')
+    f.request = request
+    assert_nil f.uri
+    assert_equal "https://www.yahoo.com:8080/path/hello", f.referer
+  end
+
+  def test_request_parsing__uri
+    request = stub(:uri => 'http://creature.com/path?hello=bob#none', :referer => '/path/hello?bob=none&foo=bar')
+    f.request = request
+    assert_equal "http://creature.com/path", f.uri
+    assert_equal "/path/hello", f.referer
+  end
+  
+  def test_request_parsing__hostname_only
+    request = stub(:uri => 'http://creature.com')
+    f.request = request
+    assert_equal "http://creature.com", f.uri
+    assert_nil f.referer
+  end
+  def test_request_parsing__slash
+    request = stub(:uri => 'http://creature.com/')
+    f.request = request
+    assert_equal "http://creature.com/", f.uri
+    assert_nil f.referer
+  end
+end

data/test/new_relic/agent/net_instrumentation_test.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+class NewRelic::Agent::NetInstrumentationTest < Test::Unit::TestCase
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  def setup
+    NewRelic::Agent.manual_start
+    @engine = NewRelic::Agent.instance.stats_engine
+    @engine.clear_stats
+  end
+  def test_get
+    url = URI.parse('http://www.google.com/index.html')
+    res = Net::HTTP.start(url.host, url.port) {|http|
+      http.get('/index.html')
+    }
+    assert_match /<head>/, res.body
+    assert_equal %w[External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all].sort,
+       @engine.metrics.sort 
+  end
+
+  def test_background
+    perform_action_with_newrelic_trace("task", :category => :task) do
+      url = URI.parse('http://www.google.com/index.html')
+      res = Net::HTTP.start(url.host, url.port) {|http|
+        http.get('/index.html')
+      }
+      assert_match /<head>/, res.body
+    end
+    assert_equal @engine.metrics.select{|m| m =~ /^External/}.sort, 
+       %w[External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all
+       External/www.google.com/Net::HTTP/GET:OtherTransaction/Background/NewRelic::Agent::NetInstrumentationTest/task].sort
+  end
+
+  def test_transactional
+    perform_action_with_newrelic_trace("task") do
+      url = URI.parse('http://www.google.com/index.html')
+      res = Net::HTTP.start(url.host, url.port) {|http|
+        http.get('/index.html')
+      }
+      assert_match /<head>/, res.body
+    end
+    assert_equal @engine.metrics.select{|m| m =~ /^External/}.sort, 
+       %w[External/www.google.com/Net::HTTP/GET External/allWeb External/www.google.com/all
+       External/www.google.com/Net::HTTP/GET:Controller/NewRelic::Agent::NetInstrumentationTest/task].sort
+  end
+  def test_get__simple
+    Net::HTTP.get URI.parse('http://www.google.com/index.html')
+    assert_equal @engine.metrics.sort, 
+       %w[External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all].sort
+  end
+  def test_ignore
+    NewRelic::Agent.disable_all_tracing do
+      url = URI.parse('http://www.google.com/index.html')
+      res = Net::HTTP.start(url.host, url.port) {|http|
+        http.post('/index.html','data')
+      }
+    end
+    assert_equal 0, @engine.metrics.size 
+  end
+  def test_head
+    url = URI.parse('http://www.google.com/index.html')
+    res = Net::HTTP.start(url.host, url.port) {|http|
+      http.head('/index.html')
+    }
+    assert_equal %w[External/www.google.com/Net::HTTP/HEAD External/allOther External/www.google.com/all].sort,
+    @engine.metrics.sort 
+  end
+  
+  def test_post
+    url = URI.parse('http://www.google.com/index.html')
+    res = Net::HTTP.start(url.host, url.port) {|http|
+      http.post('/index.html','data')
+    }
+    assert_equal %w[External/www.google.com/Net::HTTP/POST External/allOther External/www.google.com/all].sort, 
+    @engine.metrics.sort 
+  end
+  
+end

data/test/new_relic/agent/{agent_test.rb → rpm_agent_test.rb}

@@ -2,7 +2,7 @@ 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
+class RpmAgentTest < ActiveSupport::TestCase
   
   attr_reader :agent
   
@@ -35,10 +35,10 @@ class AgentTest < ActiveSupport::TestCase
       ignore_called = true
       nil
     end
+    NewRelic::Agent.notice_error(ActionController::RoutingError.new("message"), :request_params => {:x => "y"})
+    assert ignore_called   
+    NewRelic::Agent.ignore_error_filter
     
-    NewRelic::Agent.agent.error_collector.notice_error(ActionController::RoutingError.new("message"), nil, "path", {:x => "y"} )
-    
-    assert ignore_called    
   end
   
   def test_startup_shutdown
@@ -70,8 +70,29 @@ class AgentTest < ActiveSupport::TestCase
     assert_equal "mailer", NewRelic::Control.instance.dispatcher_instance_id
   end
   
+  def test_send_timeslice_data
+    @agent.expects(:invoke_remote).returns({NewRelic::MetricSpec.new("/A/b/c") => 1, NewRelic::MetricSpec.new("/A/b/c", "/X") => 2, NewRelic::MetricSpec.new("/A/b/d") => 3 }.to_a)
+    @agent.send :harvest_and_send_timeslice_data
+    assert_equal 3, @agent.metric_ids.size
+    assert_equal 3, @agent.metric_ids[NewRelic::MetricSpec.new("/A/b/d") ], @agent.metric_ids.inspect
+  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
+    assert_match /\d\.\d+\.\d+/, NewRelic::VERSION::STRING
   end
   
   def test_invoke_remote__ignore_non_200_results