dolores_rpm 3.2.0.2

data/test/new_relic/agent/rpm_agent_test.rb

@@ -0,0 +1,149 @@
+ENV['SKIP_RAILS'] = 'true'
+require File.expand_path('../../../test_helper', __FILE__)
+
+class NewRelic::Agent::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?
+      NewRelic::Agent.shutdown
+    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)
+      NewRelic::Agent.shutdown
+    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
+      NewRelic::Agent.shutdown
+    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
+      NewRelic::Agent.shutdown
+    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
+      NewRelic::Agent.shutdown
+    end
+
+    should "send_timeslice_data" do
+      # this test fails due to a rubinius bug
+      return if (RUBY_DESCRIPTION =~ /rubinius/i)
+      @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 !NewRelic::Agent.is_sql_recorded?
+      NewRelic::Agent.disable_sql_recording do
+        assert_equal false, NewRelic::Agent.is_sql_recorded?
+        NewRelic::Agent.disable_sql_recording do
+          assert_equal false, NewRelic::Agent.is_sql_recorded?
+        end
+        assert_equal false, NewRelic::Agent.is_sql_recorded?
+      end
+      assert !NewRelic::Agent.is_sql_recorded?
+      @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/sampler_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
+class NewRelic::Agent::SamplerTest < Test::Unit::TestCase
+  require 'new_relic/agent/sampler'
+
+  def test_inherited_should_append_subclasses_to_sampler_classes
+    test_class = Class.new(NewRelic::Agent::Sampler)
+    sampler_classes = NewRelic::Agent::Sampler.instance_eval { @sampler_classes }
+    assert(sampler_classes.include?(test_class), "Sampler classes (#{@sampler_classes.inspect}) does not include #{test_class.inspect}")
+    # cleanup the sampler created above
+    NewRelic::Agent::Sampler.instance_eval { @sampler_classes.delete(test_class) }
+  end
+
+  def test_sampler_classes_should_be_an_array
+    sampler_classes = NewRelic::Agent::Sampler.instance_variable_get('@sampler_classes')
+    assert(sampler_classes.is_a?(Array), 'Sampler classes should be saved as an array')
+    assert(sampler_classes.include?(NewRelic::Agent::Samplers::CpuSampler), 'Sampler classes should include the CPU sampler')
+  end
+
+end

data/test/new_relic/agent/shim_agent_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+module NewRelic
+  module Agent
+    class ShimAgentTest < Test::Unit::TestCase
+
+      def setup
+        super
+        @agent = NewRelic::Agent::ShimAgent.new
+      end
+
+      def test_serialize
+        assert_equal(nil, @agent.serialize, "should return nil when shut down")
+      end
+
+      def test_merge_data_from
+        assert_equal(nil, @agent.merge_data_from(mock('metric data')))
+      end
+    end
+  end
+end

data/test/new_relic/agent/sql_sampler_test.rb

@@ -0,0 +1,160 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
+  
+  def setup
+    agent = NewRelic::Agent.instance
+    stats_engine = NewRelic::Agent::StatsEngine.new
+    agent.stubs(:stats_engine).returns(stats_engine)
+    @sampler = NewRelic::Agent::SqlSampler.new
+    stats_engine.sql_sampler = @sampler
+    @connection = stub('ActiveRecord connection', :execute => 'result')
+    NewRelic::Agent::Database.stubs(:get_connection).returns(@connection)
+  end
+  
+  def test_notice_first_scope_push
+    assert_nil @sampler.transaction_data    
+    @sampler.notice_first_scope_push nil
+    assert_not_nil @sampler.transaction_data
+    @sampler.notice_scope_empty
+    assert_nil @sampler.transaction_data
+  end
+  
+  def test_notice_sql_no_transaction
+    assert_nil @sampler.transaction_data    
+    @sampler.notice_sql "select * from test", "Database/test/select", nil, 10
+  end
+
+  def test_notice_sql
+    @sampler.notice_first_scope_push nil
+    @sampler.notice_sql "select * from test", "Database/test/select", nil, 1.5
+    @sampler.notice_sql "select * from test2", "Database/test2/select", nil, 1.3
+    # this sql will not be captured
+    @sampler.notice_sql "select * from test", "Database/test/select", nil, 0
+    assert_not_nil @sampler.transaction_data
+    assert_equal 2, @sampler.transaction_data.sql_data.count
+  end
+  
+  def test_harvest_slow_sql
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info "WebTransaction/Controller/c/a", "/c/a", {}
+    data.sql_data.concat [
+      NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5), 
+      NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2), 
+      NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)
+    ]
+    @sampler.harvest_slow_sql data
+      
+    assert_equal 2, @sampler.sql_traces.count
+  end
+  
+  def test_sql_aggregation
+    sql_trace = NewRelic::Agent::SqlTrace.new("select * from test", 
+            NewRelic::Agent::SlowSql.new("select * from test",
+                "Database/test/select", {}, 1.2),
+        "tx_name", "uri")
+      
+    sql_trace.aggregate NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5), "slowest_tx_name", "slow_uri"
+    sql_trace.aggregate NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.1), "other_tx_name", "uri2"
+    
+    assert_equal 3, sql_trace.call_count
+    assert_equal "slowest_tx_name", sql_trace.path
+    assert_equal "slow_uri", sql_trace.url
+    assert_equal 1.5, sql_trace.max_call_time
+  end
+  
+  def test_harvest
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info "WebTransaction/Controller/c/a", "/c/a", {}
+    
+    data.sql_data.concat [NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5), 
+                          NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2), 
+                          NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)]
+    @sampler.harvest_slow_sql data
+      
+    sql_traces = @sampler.harvest
+    assert_equal 2, sql_traces.count
+  end
+
+  def test_harvest_should_not_take_more_than_10
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {})
+    15.times do |i|
+      data.sql_data << NewRelic::Agent::SlowSql.new("select * from test#{(i+97).chr}",
+                                                    "Database/test#{(i+97).chr}/select", {}, i)
+    end
+    
+    @sampler.harvest_slow_sql data
+    result = @sampler.harvest
+    
+    assert_equal(10, result.size)
+    assert_equal(14, result.sort{|a,b| b.max_call_time <=> a.max_call_time}.first.total_call_time)
+  end
+
+  def test_harvest_should_aggregate_similar_queries
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info "WebTransaction/Controller/c/a", "/c/a", {}
+    queries = [
+               NewRelic::Agent::SlowSql.new("select  * from test where foo in (1, 2)  ", "Database/test/select", {}, 1.5), 
+               NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2, 3 ,4,  5,6, 'snausage')", "Database/test/select", {}, 1.2), 
+               NewRelic::Agent::SlowSql.new("select * from test2 where foo in (1,2)", "Database/test2/select", {}, 1.1)
+              ]
+    data.sql_data.concat(queries)
+    @sampler.harvest_slow_sql data
+      
+    sql_traces = @sampler.harvest
+    assert_equal 2, sql_traces.count    
+  end
+
+  def test_harvest_should_collect_explain_plans
+    @connection.expects(:execute).with("EXPLAIN select * from test") \
+     .returns([{"header0" => 'foo0', "header1" => 'foo1', "header2" => 'foo2'}])
+    @connection.expects(:execute).with("EXPLAIN select * from test2") \
+     .returns([{"header0" => 'bar0', "header1" => 'bar1', "header2" => 'bar2'}])
+
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info "WebTransaction/Controller/c/a", "/c/a", {}
+    
+    queries = [
+               NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5), 
+               NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2), 
+               NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)
+              ]
+    data.sql_data.concat(queries)
+    @sampler.harvest_slow_sql data   
+    sql_traces = @sampler.harvest
+    assert_equal(["header0", "header1", "header2"],
+                 sql_traces[0].params[:explain_plan][0].sort)
+    assert_equal(["header0", "header1", "header2"],
+                 sql_traces[1].params[:explain_plan][0].sort)
+    assert_equal(["foo0", "foo1", "foo2"],
+                 sql_traces[0].params[:explain_plan][1][0].sort)    
+    assert_equal(["bar0", "bar1", "bar2"],
+                 sql_traces[1].params[:explain_plan][1][0].sort)
+  end
+
+  def test_should_not_collect_explain_plans_when_disabled
+    NewRelic::Control.instance['slow_sql'] = { 'explain_enabled' => false }
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info "WebTransaction/Controller/c/a", "/c/a", {}
+    
+    queries = [
+               NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5)
+              ]
+    data.sql_data.concat(queries)
+    @sampler.harvest_slow_sql data   
+    sql_traces = @sampler.harvest
+    assert_equal(nil, sql_traces[0].params[:explain_plan])
+    NewRelic::Control.instance['slow_sql'] = { 'explain_enabled' => true }
+  end
+
+  def test_sql_id_fits_in_a_mysql_int_11
+    sql_trace = NewRelic::Agent::SqlTrace.new("select * from test", 
+            NewRelic::Agent::SlowSql.new("select * from test",
+                "Database/test/select", {}, 1.2),
+        "tx_name", "uri")
+    
+    assert -2147483648 <= sql_trace.sql_id, "sql_id too small"
+    assert 2147483647 >= sql_trace.sql_id, "sql_id too large"
+  end
+end

data/test/new_relic/agent/stats_engine/metric_stats/harvest_test.rb

@@ -0,0 +1,150 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','..','test_helper'))
+require 'new_relic/agent/stats_engine/metric_stats'
+class NewRelic::Agent::StatsEngine::MetricStats::HarvestTest < Test::Unit::TestCase
+  include NewRelic::Agent::StatsEngine::MetricStats::Harvest
+
+  attr_accessor :stats_hash
+  def test_merge_stats_trivial
+    self.stats_hash = {}
+    merge_stats({}, {})
+  end
+
+  def test_merge_stats_with_nil_stats
+    metric_ids = mock('metric ids')
+    mock_stats_hash = mock('stats_hash')
+    mock_spec = mock('spec')
+    mock_stats = mock('stats')
+    mock_stats_hash.expects(:each).yields(mock_spec, mock_stats)
+    self.stats_hash = mock_stats_hash
+
+    self.expects(:coerce_to_metric_spec).with(mock_spec).returns(mock_spec)
+    self.expects(:clone_and_reset_stats).with(mock_spec, mock_stats).returns(mock_stats)
+    self.expects(:merge_old_data!).with(mock_spec, mock_stats, {})
+    metric_ids.expects(:[]).with(mock_spec).returns('an id')
+    self.expects(:add_data_to_send_unless_empty).with({}, mock_stats, mock_spec, 'an id')
+
+
+    merge_stats({}, metric_ids)
+  end
+
+
+  def test_get_stats_hash_from_hash
+    assert_equal({}, get_stats_hash_from({}))
+  end
+
+  def test_get_stats_hash_from_engine
+    assert_equal({}, get_stats_hash_from(NewRelic::Agent::StatsEngine.new))
+  end
+
+  def test_coerce_to_metric_spec_metric_spec
+    assert_equal NewRelic::MetricSpec.new, coerce_to_metric_spec(NewRelic::MetricSpec.new)
+  end
+
+  def test_coerce_to_metric_spec_string
+    assert_equal NewRelic::MetricSpec.new('foo'), coerce_to_metric_spec('foo')
+  end
+
+  def test_clone_and_reset_stats_nil
+    spec = NewRelic::MetricSpec.new('foo', 'bar')
+    stats = nil
+    begin
+      clone_and_reset_stats(spec, stats)
+    rescue RuntimeError => e
+      assert_equal("Nil stats for foo (bar)", e.message)
+    end
+  end
+
+  def test_clone_and_reset_stats_present
+    # spec is only used for debug output
+    spec = nil
+    stats = mock('stats')
+    stats_clone = mock('stats_clone')
+    stats.expects(:clone).returns(stats_clone)
+    stats.expects(:reset)
+    # should return a clone
+    assert_equal stats_clone, clone_and_reset_stats(spec, stats)
+  end
+
+  def test_merge_old_data_present
+    metric_spec = mock('metric_spec')
+    stats = mock('stats obj')
+    stats.expects(:merge!).with('some stats')
+    old_data = mock('old data')
+    old_data.expects(:stats).returns('some stats')
+    old_data_hash = {metric_spec => old_data}
+    merge_old_data!(metric_spec, stats, old_data_hash)
+  end
+
+  def test_merge_old_data_nil
+    metric_spec = mock('metric_spec')
+    stats = mock('stats') # doesn't matter
+    old_data_hash = {metric_spec => nil}
+    merge_old_data!(metric_spec, stats, old_data_hash)
+  end
+
+  def test_add_data_to_send_unless_empty_when_is_empty
+    stats = mock('stats')
+    stats.expects(:is_reset?).returns(true)
+    assert_equal nil, add_data_to_send_unless_empty(nil, stats, nil, nil)
+  end
+
+  def test_add_data_to_send_unless_empty_main
+    data = mock('data hash')
+    stats = mock('stats')
+    stats.expects(:is_reset?).returns(false)
+    metric_spec = mock('spec')
+
+    NewRelic::MetricData.expects(:new).with(metric_spec, stats, nil).returns('metric data')
+    data.expects(:[]=).with(metric_spec, 'metric data')
+    add_data_to_send_unless_empty(data, stats, metric_spec, nil)
+  end
+
+  def test_add_data_to_send_unless_empty_with_id
+    data = mock('data hash')
+    stats = mock('stats')
+    stats.expects(:is_reset?).returns(false)
+    metric_spec = mock('spec')
+    id = mock('id')
+
+    NewRelic::MetricData.expects(:new).with(nil, stats, id).returns('metric data')
+    data.expects(:[]=).with(metric_spec, 'metric data')
+    assert_equal 'metric data', add_data_to_send_unless_empty(data, stats, metric_spec, id)
+  end
+
+  def test_merge_data_basic
+    mock_stats_hash = mock('stats hash')
+    self.stats_hash = mock_stats_hash
+    merge_data({})
+  end
+
+  def test_merge_data_new_and_old_data
+    stats = NewRelic::MethodTraceStats.new
+    stats.record_data_point(1.0)
+    new_stats = NewRelic::MethodTraceStats.new
+    new_stats.record_data_point(2.0)
+    self.expects(:lookup_stats).with('Custom/test/method', '').returns(new_stats)
+    assert_equal(2.0, new_stats.total_call_time)
+
+    metric_spec = NewRelic::MetricSpec.new('Custom/test/method')
+    mock_stats_hash = mock('stats_hash')
+    self.stats_hash = mock_stats_hash
+    merge_data({metric_spec => NewRelic::MetricData.new(metric_spec, stats, nil)})
+    assert_equal(3.0, new_stats.total_call_time)
+  end
+
+  def test_merge_data_old_data
+    stats = NewRelic::MethodTraceStats.new
+    stats.record_data_point(1.0)
+    self.expects(:lookup_stats).returns(nil)
+
+    metric_spec = NewRelic::MetricSpec.new('Custom/test/method')
+    mock_stats_hash = mock('stats_hash')
+    mock_stats_hash.expects(:[]=).with(metric_spec, stats)
+    self.stats_hash = mock_stats_hash
+    merge_data({metric_spec => NewRelic::MetricData.new(metric_spec, stats, nil)})
+  end
+
+end
+
+
+

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

@@ -0,0 +1,82 @@
+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({},{})
+    super
+  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
+    @engine.clear_stats
+    s1 = @engine.get_stats "a"
+    s2 = @engine.get_stats "c"
+
+    s1.trace_call 10
+    s2.trace_call 1
+    s2.trace_call 3
+
+    assert_equal 1, @engine.get_stats("a").call_count
+    assert_equal 10, @engine.get_stats("a").total_call_time
+
+    assert_equal 2, @engine.get_stats("c").call_count
+    assert_equal 4, @engine.get_stats("c").total_call_time
+
+    metric_data = @engine.harvest_timeslice_data({}, {}).values
+    
+    # after harvest, all the metrics should be reset
+    assert_equal 0, @engine.get_stats("a").call_count
+    assert_equal 0, @engine.get_stats("a").total_call_time
+
+    assert_equal 0, @engine.get_stats("c").call_count
+    assert_equal 0, @engine.get_stats("c").total_call_time
+
+    metric_data = metric_data.reverse if metric_data[0].metric_spec.name != "a"
+
+    assert_equal 'a', metric_data[0].metric_spec.name
+
+    assert_equal 1, metric_data[0].stats.call_count
+    assert_equal 10, metric_data[0].stats.total_call_time
+  end
+
+  def test_harvest_with_merge
+    s = @engine.get_stats "a"
+    s.trace_call 1
+
+    assert_equal 1, @engine.get_stats("a").call_count
+
+    harvest = @engine.harvest_timeslice_data({}, {})
+    assert_equal 0, s.call_count
+    s.trace_call 2
+    assert_equal 1, s.call_count
+
+    # 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_equal 2, stats.call_count
+    assert_equal 3, stats.total_call_time
+  end
+end
+

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

@@ -0,0 +1,99 @@
+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
+
+  class TestObject
+    include NewRelic::Agent::StatsEngine::Samplers
+  end
+
+  def setup
+    @stats_engine = NewRelic::Agent::StatsEngine.new
+    NewRelic::Agent.instance.stubs(:stats_engine).returns(@stats_engine)
+  end
+
+  def test_add_sampler_to_positive
+    object = TestObject.new
+    sampler = mock('sampler')
+    sampler_array = mock('sampler_array')
+    sampler_array.expects(:include?).with(sampler).returns(false)
+    sampler_array.expects(:<<).with(sampler)
+    sampler.expects(:stats_engine=).with(object)
+
+    object.send(:add_sampler_to, sampler_array, sampler)
+  end
+
+  def test_add_sampler_to_negative
+    object = TestObject.new
+    sampler = mock('sampler')
+    sampler_array = mock('sampler_array')
+    sampler_array.expects(:include?).with(sampler).returns(true)
+    assert_raise(RuntimeError) do
+      object.send(:add_sampler_to, sampler_array, sampler)
+    end
+  end
+
+  def test_cpu
+    s = NewRelic::Agent::Samplers::CpuSampler.new
+    # need to set this instance value to prevent it skipping a 'too
+    # fast' poll time
+    s.stats_engine = @stats_engine
+    s.instance_eval { @last_time = Time.now - 1.1 }
+    s.poll
+    s.instance_eval { @last_time = Time.now - 1.1 }
+    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).at_least_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