onyx_newrelic_rpm 2.12.5

data/test/new_relic/agent/metric_data_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require 'test/unit'
+
+
+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_ar_connection.rb

@@ -0,0 +1,40 @@
+module ActiveRecord
+  class Base
+    class << self
+      def test_connection(config)
+        @connect ||= Connection.new
+      end
+    end
+  end
+  
+  class Connection
+    attr_accessor :throw
+    attr_reader :disconnected
+    
+    def initialize
+      @disconnected = false
+      @throw = false
+    end
+    
+    def disconnect!()
+      @disconnected = true
+    end
+    
+    def find()
+      # used to test that we've instrumented this...
+    end
+
+    def select_rows(s)
+      execute(s)
+    end
+    def execute(s)
+      fail "" if @throw
+      if s != "EXPLAIN #{::SQL_STATEMENT}"
+        fail "Unexpected sql statement #{s}"        
+      end
+      s
+    end
+  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,138 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+##require 'new_relic/agent/agent'
+##require 'new_relic/local_environment'
+
+class RpmAgentTest < 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::Agent.shutdown
+    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"), :request_params => {:x => "y"})
+    assert ignore_called   
+    NewRelic::Agent.instance.error_collector.instance_variable_set '@ignore_filter', nil
+  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_start
+    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
+  
+  def test_post_fork_handler
+    NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)
+    NewRelic::Agent.after_fork    
+    NewRelic::Agent.after_fork    
+  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_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
+  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::ServerConnectionException, "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/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
+