honkster-newrelic_rpm 2.13.1

data/test/new_relic/agent/metric_data_test.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+
+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
+    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 "/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 "/", f.uri
+    assert_nil f.referer
+  end
+  def test_request_parsing__slash
+    request = stub(:uri => 'http://creature.com/')
+    f.request = request
+    assert_equal "/", f.uri
+    assert_nil f.referer
+  end
+end

data/test/new_relic/agent/mock_scope_listener.rb

@@ -0,0 +1,23 @@
+
+class NewRelic::Agent::MockScopeListener
+  
+  attr_reader :scope
+  
+  def initialize
+    @scope = {}
+  end
+  
+  def notice_first_scope_push(time)
+  end
+  
+  def notice_push_scope(scope, time)
+    @scope[scope] = true
+  end
+  
+  def notice_pop_scope(scope, time)
+  end
+  
+  def notice_scope_empty(time)
+    
+  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/rpm_agent_test.rb

@@ -0,0 +1,142 @@
+ENV['SKIP_RAILS'] = 'true'
+require File.expand_path('../../../test_helper', __FILE__) 
+
+class RpmAgentTest < Test::Unit::TestCase # ActiveSupport::TestCase
+  extend TestContexts
+  
+  attr_reader :agent
+  
+  with_running_agent do
+    # Fake out the agent to think mongrel is running
+    
+    should "agent_setup" do
+      assert NewRelic::Agent.instance.class == NewRelic::Agent::Agent
+      assert_raise RuntimeError do
+        NewRelic::Control.instance.init_plugin :agent_enabled => false
+      end
+    end
+    
+    should "public_apis" do
+      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(StandardError.new("message"), :request_params => {:x => "y"})
+      assert ignore_called   
+      NewRelic::Agent.instance.error_collector.instance_variable_set '@ignore_filter', nil
+    end
+    
+    should "startup_shutdown" do
+      @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
+    
+    should "manual_start" do
+      NewRelic::Agent.instance.expects(:connect).once
+      NewRelic::Agent.instance.expects(:start_worker_thread).once
+      NewRelic::Agent.instance.instance_variable_set '@started', nil
+      NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
+    end
+    
+    should "post_fork_handler" do
+      NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
+      NewRelic::Agent.after_fork    
+      NewRelic::Agent.after_fork    
+    end
+    should "manual_overrides" do
+      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
+    
+    should "restart" do
+      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
+    
+    should "send_timeslice_data" do
+      @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
+    should "set_record_sql" do
+      @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]
+      @agent.set_record_sql(nil)
+    end
+    
+    should "version" do
+      assert_match /\d\.\d+\.\d+/, NewRelic::VERSION::STRING
+    end
+    
+    should "invoke_remote__ignore_non_200_results" do
+      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::ServerConnectionException, "Ignore #{code}" do
+          response_mock.stubs(:code).returns(code)
+          NewRelic::Agent.agent.invoke_remote  :get_data_report_period, 0
+        end
+      end
+    end
+    should "invoke_remote__throw_other_errors" do
+      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
+    
+    context "with transaction api" do
+      should "reject empty arguments" do
+        assert_raises RuntimeError do
+          NewRelic::Agent.record_transaction 0.5
+        end
+      end
+      should "record a transaction" do
+        NewRelic::Agent.record_transaction 0.5, 'uri' => "/users/create?foo=bar"
+      end
+      
+    end
+  end
+end

data/test/new_relic/agent/stats_engine/metric_stats_test.rb

@@ -0,0 +1,79 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper')) 
+
+
+class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
+  def setup
+    NewRelic::Agent.manual_start
+    @engine = NewRelic::Agent.instance.stats_engine
+  rescue => e
+    puts e
+    puts e.backtrace.join("\n")
+  end
+  def teardown
+    @engine.harvest_timeslice_data({},{})
+  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
+
+end
+

data/test/new_relic/agent/stats_engine/samplers_test.rb

@@ -0,0 +1,72 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..', '..','..','test_helper'))
+require 'new_relic/agent/samplers/cpu_sampler'
+
+class NewRelic::Agent::StatsEngine::SamplersTest < Test::Unit::TestCase
+  
+  def setup
+    @stats_engine = NewRelic::Agent::StatsEngine.new
+    NewRelic::Agent.instance.stubs(:stats_engine).returns(@stats_engine)
+  end
+  def test_cpu
+    s = NewRelic::Agent::Samplers::CpuSampler.new
+    # need to sleep because if you go to fast it will skip the points
+    s.stats_engine = @stats_engine
+    sleep 2
+    s.poll
+    sleep 2
+    s.poll
+    assert_equal 2, s.systemtime_stats.call_count
+    assert_equal 2, s.usertime_stats.call_count
+    assert s.usertime_stats.total_call_time >= 0, "user cpu greater/equal to 0: #{s.usertime_stats.total_call_time}"
+    assert s.systemtime_stats.total_call_time >= 0, "system cpu greater/equal to 0: #{s.systemtime_stats.total_call_time}"
+  end
+  def test_memory__default
+    s = NewRelic::Agent::Samplers::MemorySampler.new
+    s.stats_engine = @stats_engine
+    s.poll
+    s.poll
+    s.poll
+    assert_equal 3, s.stats.call_count
+    assert s.stats.total_call_time > 0.5, "cpu greater than 0.5 ms: #{s.stats.total_call_time}"
+  end
+  def test_memory__linux
+    return if RUBY_PLATFORM =~ /darwin/
+    NewRelic::Agent::Samplers::MemorySampler.any_instance.stubs(:platform).returns 'linux'
+    s = NewRelic::Agent::Samplers::MemorySampler.new
+    s.stats_engine = @stats_engine
+    s.poll
+    s.poll
+    s.poll
+    assert_equal 3, s.stats.call_count
+    assert s.stats.total_call_time > 0.5, "cpu greater than 0.5 ms: #{s.stats.total_call_time}"
+  end
+  def test_memory__solaris
+    return if defined? JRuby
+    NewRelic::Agent::Samplers::MemorySampler.any_instance.stubs(:platform).returns 'solaris'
+    NewRelic::Agent::Samplers::MemorySampler::ShellPS.any_instance.stubs(:get_memory).returns 999
+    s = NewRelic::Agent::Samplers::MemorySampler.new
+    s.stats_engine = @stats_engine
+    s.poll
+    assert_equal 1, s.stats.call_count
+    assert_equal 999, s.stats.total_call_time
+  end
+  def test_memory__windows
+    return if defined? JRuby
+    NewRelic::Agent::Samplers::MemorySampler.any_instance.stubs(:platform).returns 'win32'
+    assert_raise NewRelic::Agent::Sampler::Unsupported do
+      NewRelic::Agent::Samplers::MemorySampler.new
+    end
+  end
+  def test_load_samplers
+    @stats_engine.expects(:add_harvest_sampler).once unless defined? JRuby
+    @stats_engine.expects(:add_sampler).never
+    NewRelic::Control.instance.load_samplers
+    sampler_count = 4
+    assert_equal sampler_count, NewRelic::Agent::Sampler.sampler_classes.size, NewRelic::Agent::Sampler.sampler_classes.inspect
+  end
+  def test_memory__is_supported
+    NewRelic::Agent::Samplers::MemorySampler.stubs(:platform).returns 'windows'
+    assert !NewRelic::Agent::Samplers::MemorySampler.supported_on_this_platform? || defined? JRuby
+  end
+  
+end