ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

data/test/new_relic/agent/rpm_agent_test.rb

@@ -34,21 +34,23 @@ class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::Test
     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
+      with_config(:agent_enabled => true) 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
     end
 
     should "manual_start" do
@@ -67,28 +69,30 @@ class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::Test
     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
+      assert_equal "testjobs", NewRelic::Agent.config.app_names[0]
+      assert_equal "mailer", NewRelic::Control.instance.local_env.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
+      assert_equal "testjobs", NewRelic::Agent.config.app_names[0]
+      assert_equal "mailer", NewRelic::Control.instance.local_env.dispatcher_instance_id
       NewRelic::Agent.shutdown
     end
 
     should "send_timeslice_data" do
       # this test fails due to a rubinius bug
       return if NewRelic::LanguageSupport.using_engine?('rbx')
-      @agent.service.expects(:metric_data).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.service = NewRelic::FakeService.new
+      @agent.service.expects(:metric_data).returns([ [{'name' => '/A/b/c'}, 1],
+                                                     [{'name' => '/A/b/c', 'scope' => '/X'}, 2],
+                                                     [{'name' => '/A/b/d'}, 3] ])
       @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
+      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)

data/test/new_relic/agent/sql_sampler_test.rb

@@ -1,7 +1,6 @@
 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
@@ -10,17 +9,17 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     @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    
+    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    
+    assert_nil @sampler.transaction_data
     @sampler.notice_sql "select * from test", "Database/test/select", nil, 10
   end
 
@@ -33,45 +32,45 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     assert_not_nil @sampler.transaction_data
     assert_equal 2, @sampler.transaction_data.sql_data.size
   end
-  
+
   def test_harvest_slow_sql
     data = NewRelic::Agent::TransactionSqlData.new
     data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
                               'guid')
     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 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.size
   end
-  
+
   def test_sql_aggregation
-    sql_trace = NewRelic::Agent::SqlTrace.new("select * from test", 
+    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", {},
                               'guid')
-    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), 
+    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.size
   end
@@ -83,10 +82,10 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
       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
@@ -96,13 +95,13 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
                               'guid')
     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 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.size
   end
@@ -117,19 +116,19 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
                               'guid')
     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 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   
+    @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)    
+                 sql_traces[0].params[:explain_plan][1][0].sort)
     assert_equal(["bar0", "bar1", "bar2"],
                  sql_traces[1].params[:explain_plan][1][0].sort)
   end
@@ -145,48 +144,74 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
     assert_equal(NewRelic::Agent.instance.transaction_sampler.builder.sample.guid,
                  NewRelic::Agent.instance.sql_sampler.transaction_data.guid)
   end
-  
+
   def test_should_not_collect_explain_plans_when_disabled
-    NewRelic::Control.instance['transaction_tracer'] = { 'explain_enabled' => false }
-    data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
-                              'guid')
-    
-    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['transaction_tracer'] = { 'explain_enabled' => true }
+    with_config(:'transaction_tracer.explain_enabled' => false) do
+      data = NewRelic::Agent::TransactionSqlData.new
+      data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
+                                'guid')
+
+      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])
+    end
   end
 
   def test_sql_id_fits_in_a_mysql_int_11
-    sql_trace = NewRelic::Agent::SqlTrace.new("select * from test", 
+    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
 
   def test_sends_obfuscated_queries_when_configured
-    NewRelic::Control.instance['transaction_tracer'] = { 'record_sql' => 'obfuscated' }
-    
-    data = NewRelic::Agent::TransactionSqlData.new
-    data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
-                              'guid')
-    data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test where foo = 'bar'",
-                                                       "Database/test/select", {}, 1.5), 
-                          NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2,3,4,5)",
-                                                       "Database/test/select", {}, 1.2)])
-    @sampler.harvest_slow_sql(data)      
-    sql_traces = @sampler.harvest
+    with_config(:'transaction_tracer.record_sql' => 'obfuscated') do
+      data = NewRelic::Agent::TransactionSqlData.new
+      data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
+                                'guid')
+      data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test where foo = 'bar'",
+                                                         "Database/test/select", {}, 1.5),
+                            NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2,3,4,5)",
+                                                         "Database/test/select", {}, 1.2)])
+      @sampler.harvest_slow_sql(data)
+      sql_traces = @sampler.harvest
+
+      assert_equal('select * from test where foo = ?', sql_traces[0].sql)
+      assert_equal('select * from test where foo in (?,?,?,?,?)', sql_traces[1].sql)
+    end
+  end
 
-    assert_equal('select * from test where foo = ?', sql_traces[0].sql)
-    assert_equal('select * from test where foo in (?,?,?,?,?)', sql_traces[1].sql)        
+  def test_to_collector_array
+    with_config(:'transaction_tracer.explain_enabled' => false) do
+      data = NewRelic::Agent::TransactionSqlData.new
+      data.set_transaction_info("WebTransaction/Controller/c/a", "/c/a", {},
+                                'guid')
+      data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test",
+                                                         "Database/test/select",
+                                                         {}, 1.5)])
+      @sampler.harvest_slow_sql(data)
+      sql_traces = @sampler.harvest
+
+      params = RUBY_VERSION >= '1.9.2' ? "eJyrrgUAAXUA+Q==\n" : {}
+      expected = [ 'WebTransaction/Controller/c/a', '/c/a', 526336943,
+                   'select * from test', 'Database/test/select',
+                   1, 1500, 1500, 1500, params ]
+
+      if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
+        marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      else
+        marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+      end
+
+      assert_equal expected, sql_traces[0].to_collector_array(marshaller)
+    end
   end
 end

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

@@ -1,30 +1,13 @@
 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)
+    self.stats_hash = NewRelic::Agent::StatsEngine::MetricStats::SynchronizedHash.new
+    assert_equal({}, merge_stats({}, {}))
   end
 
 

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

@@ -44,7 +44,7 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
     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
@@ -78,5 +78,16 @@ class NewRelic::Agent::MetricStatsTest < Test::Unit::TestCase
     assert_equal 2, stats.call_count
     assert_equal 3, stats.total_call_time
   end
+
+  def test_rescues_from_synchronization_failure_on_write
+    hash = NewRelic::Agent::StatsEngine::MetricStats::SynchronizedHash.new
+    10.times { |i| hash[i] = i }
+
+    assert_nothing_raised do
+      hash.each do |k, v|
+        hash[11] = 1
+      end
+    end
+  end
 end
 

data/test/new_relic/agent/stats_engine_test.rb

@@ -9,7 +9,7 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
     puts e
     puts e.backtrace.join("\n")
   end
-  
+
   def teardown
     @engine.harvest_timeslice_data({},{})
     mocha_teardown
@@ -193,26 +193,35 @@ class NewRelic::Agent::StatsEngineTest < Test::Unit::TestCase
       ::Rubinius::Agent.stubs(:loopback).returns(agent)
     elsif NewRelic::LanguageSupport.using_version?('1.9')
       ::GC::Profiler.stubs(:enabled?).returns(true)
-      ::GC::Profiler.stubs(:total_time).returns(1.0, 4.0) 
-      ::GC.stubs(:count).returns(1, 3)      
-    elsif NewRelic::LanguageSupport.using_version?('1.8')
+      ::GC::Profiler.stubs(:total_time).returns(1.0, 4.0)
+      ::GC.stubs(:count).returns(1, 3)
+      ::GC::Profiler.stubs(:clear).returns(nil)
+    elsif NewRelic::LanguageSupport.using_version?('1.8.7') &&
+        RUBY_DESCRIPTION =~ /Ruby Enterprise Edition/
       ::GC.stubs(:time).returns(1000000, 4000000)
       ::GC.stubs(:collections).returns(1, 3)
+    else
+      return true # no need to test if we're not collecting GC metrics
     end
-    
+
     engine = NewRelic::Agent.instance.stats_engine
-    scope = engine.push_scope "scope"
+    tracer = NewRelic::Agent::TransactionSampler.new
+    tracer.instance_variable_set(:@last_sample,
+                                 NewRelic::TransactionSample.new)
+    engine.transaction_sampler = tracer
     engine.start_transaction
+    scope = engine.push_scope "scope"
     engine.pop_scope scope, 0.01
     engine.end_transaction
-    
+
     gc_stats = engine.get_stats('GC/cumulative')
     assert_equal 2, gc_stats.call_count
     assert_equal 3.0, gc_stats.total_call_time
+    assert_equal(3.0, tracer.last_sample.params[:custom_params][:gc_time])
   ensure
     GC.enable unless NewRelic::LanguageSupport.using_engine?('jruby')
   end
-  
+
   private
   def check_time_approximate(expected, actual)
     assert((expected - actual).abs < 0.1, "Expected between #{expected - 0.1} and #{expected + 0.1}, got #{actual}")

data/test/new_relic/agent/thread_profiler_test.rb

@@ -0,0 +1,536 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'base64'
+require 'thread'
+require 'timeout'
+require 'zlib'
+require 'new_relic/agent/threaded_test'
+require 'new_relic/agent/thread_profiler'
+
+if RUBY_VERSION < '1.9.2'
+class ThreadProfilerUnsupportedTest < Test::Unit::TestCase
+  def setup
+    @profiler = NewRelic::Agent::ThreadProfiler.new
+  end
+
+  def test_thread_profiling_isnt_supported
+    assert_equal false, NewRelic::Agent::ThreadProfiler.is_supported?
+  end
+
+  def test_wont_start_when_not_supported
+    @profiler.start(0, 0, 0, true)
+    assert_equal false, @profiler.running?
+  end
+
+  def test_stop_is_safe_when_not_supported
+    @profiler.start(0, 0, 0, true)
+    @profiler.stop(true)
+  end
+
+end
+end
+
+if RUBY_VERSION >= '1.9.2'
+require 'json'
+
+class ThreadProfilerTest < ThreadedTest
+
+  START_COMMAND = [[666,{
+      "name" => "start_profiler",
+      "arguments" => {
+        "profile_id" => 42,
+        "sample_period" => 0.02,
+        "duration" => 0.025,
+        "only_runnable_threads" => false,
+        "only_request_threads" => false,
+        "profile_agent_code" => false,
+      }
+    }]]
+
+  STOP_COMMAND = [[666,{
+      "name" => "stop_profiler",
+      "arguments" => {
+        "profile_id" => 42,
+        "report_data" => true,
+      }
+    }]]
+
+  STOP_AND_DISCARD_COMMAND = [[666,{
+      "name" => "stop_profiler",
+      "arguments" => {
+        "profile_id" => 42,
+        "report_data" => false,
+      }
+    }]]
+
+  NO_COMMAND = []
+
+  def setup
+    super
+    @profiler = NewRelic::Agent::ThreadProfiler.new
+  end
+
+  def test_is_supported
+    assert NewRelic::Agent::ThreadProfiler.is_supported?
+  end
+
+  def test_is_not_running
+    assert !@profiler.running?
+  end
+
+  def test_is_running
+    @profiler.start(0, 0, 0, true)
+    assert @profiler.running?
+  end
+
+  def test_is_not_finished_if_no_profile_started
+    assert !@profiler.finished?
+  end
+
+  def test_can_stop_a_running_profile
+    @profiler.start(0, 0, 0, true)
+    assert @profiler.running?
+
+    @profiler.stop(true)
+
+    assert @profiler.finished?
+    assert_not_nil @profiler.profile
+  end
+
+  def test_can_stop_a_running_profile_and_discard
+    @profiler.start(0, 0, 0, true)
+    assert @profiler.running?
+
+    @profiler.stop(false)
+
+    assert_nil @profiler.profile
+  end
+
+  def test_wont_crash_if_stopping_when_not_started
+    @profiler.stop(true)
+    assert_equal false, @profiler.running?
+  end
+
+  def test_respond_to_commands_with_no_commands_doesnt_run
+    @profiler.respond_to_commands(NO_COMMAND)
+    assert_equal false, @profiler.running?
+  end
+
+  def test_respond_to_commands_starts_running
+    @profiler.respond_to_commands(START_COMMAND)
+    assert_equal true, @profiler.running?
+  end
+
+  def test_respond_to_commands_stops
+    @profiler.start(0, 0, 0, true)
+    assert @profiler.running?
+
+    @profiler.respond_to_commands(STOP_COMMAND)
+    assert_equal true, @profiler.profile.finished?
+  end
+
+  def test_respond_to_commands_stops_and_discards
+    @profiler.start(0, 0, 0, true)
+    assert @profiler.running?
+
+    @profiler.respond_to_commands(STOP_AND_DISCARD_COMMAND)
+    assert_nil @profiler.profile
+  end
+
+  def test_respond_to_commands_wont_start_second_profile
+    @profiler.start(0, 0, 0, true)
+    original_profile = @profiler.profile
+
+    @profiler.respond_to_commands(START_COMMAND)
+
+    assert_equal original_profile, @profiler.profile
+  end
+
+  def test_response_to_commands_start_notifies_of_result
+    saw_command_id = nil
+    @profiler.respond_to_commands(START_COMMAND) { |id, err| saw_command_id = id }
+    assert_equal 666, saw_command_id
+  end
+
+  def test_response_to_commands_start_notifies_of_error
+    saw_command_id = nil
+    error = nil
+
+    @profiler.respond_to_commands(START_COMMAND)
+    @profiler.respond_to_commands(START_COMMAND) { |id, err| saw_command_id = id; error = err }
+
+    assert_equal 666, saw_command_id
+    assert_not_nil error
+  end
+
+  def test_response_to_commands_stop_notifies_of_result
+    saw_command_id = nil
+    @profiler.start(0,0, 0, true)
+    @profiler.respond_to_commands(STOP_COMMAND) { |id, err| saw_command_id = id }
+    assert_equal 666, saw_command_id
+  end
+
+  def test_command_attributes_passed_along
+    @profiler.respond_to_commands(START_COMMAND)
+    assert_equal 42,  @profiler.profile.profile_id
+    assert_equal 0.02, @profiler.profile.interval
+    assert_equal false, @profiler.profile.profile_agent_code
+  end
+
+  def test_missing_name_in_command
+    command = [[666,{ "arguments" => {} } ]]
+    @profiler.respond_to_commands(command)
+
+    assert_equal false, @profiler.running?
+  end
+
+  def test_malformed_agent_command
+    command = [[666]]
+    @profiler.respond_to_commands(command)
+
+    assert_equal false, @profiler.running?
+  end
+
+end
+
+class ThreadProfileTest < ThreadedTest
+
+  def setup
+    super
+
+    @single_trace = [
+      "irb.rb:69:in `catch'",
+      "irb.rb:69:in `start'",
+      "irb:12:in `<main>'"
+    ]
+
+    @profile = NewRelic::Agent::ThreadProfile.new(-1, 0.029, 0.01, true)
+  end
+
+  # Running Tests
+  def test_profiler_collects_backtrace_from_every_thread
+    FakeThread.list << FakeThread.new
+    FakeThread.list << FakeThread.new
+
+    @profile.run
+
+    assert_equal 2, @profile.poll_count
+    assert_equal 4, @profile.sample_count
+  end
+
+  def test_profiler_collects_into_request_bucket
+    FakeThread.list << FakeThread.new(
+      :bucket => :request,
+      :backtrace => @single_trace)
+
+    @profile.run
+
+    assert_equal 1, @profile.traces[:request].size
+  end
+
+  def test_profiler_collects_into_background_bucket
+    FakeThread.list << FakeThread.new(
+      :bucket => :background,
+      :backtrace => @single_trace)
+
+    @profile.run
+
+    assert_equal 1, @profile.traces[:background].size
+  end
+
+  def test_profiler_collects_into_other_bucket
+    FakeThread.list << FakeThread.new(
+      :bucket => :other,
+      :backtrace => @single_trace)
+
+    @profile.run
+
+    assert_equal 1, @profile.traces[:other].size
+  end
+
+  def test_profiler_collects_into_agent_bucket
+    FakeThread.list << FakeThread.new(
+      :bucket => :agent,
+      :backtrace => @single_trace)
+
+    @profile.run
+
+    assert_equal 1, @profile.traces[:agent].size
+  end
+
+  def test_profiler_ignores_agent_threads_when_told_to
+    FakeThread.list << FakeThread.new(
+      :bucket => :ignore,
+      :backtrace => @single_trace)
+
+    @profile.run
+
+    @profile.traces.each do |key, trace|
+      assert trace.empty?, "Trace :#{key} should have been empty"
+    end
+  end
+
+  def test_profiler_tries_to_scrub_backtraces
+    FakeThread.list << FakeThread.new(
+      :bucket => :agent,
+      :backtrace => @single_trace,
+      :scrubbed_backtrace => @single_trace[0..0])
+
+    @profile.run
+
+    assert_equal [], @profile.traces[:agent].first.children
+  end
+
+  def test_profile_can_be_stopped
+    # Can't easily stop in middle of processing since FakeThread's synchronous
+    # Mark to bail immediately, then see we didn't record anything
+    @profile.stop
+
+    @profile.run
+
+    assert_not_nil @profile.stop_time
+    assert_equal true, @profile.finished?
+
+    assert_equal 0, @profile.poll_count
+    @profile.traces.each do |key, trace|
+      assert_equal [], trace, "Trace for :#{key} should have been empty"
+    end
+  end
+
+  def test_profiler_tracks_time
+    @profile.run
+
+    assert_not_nil @profile.start_time
+    assert_not_nil @profile.stop_time
+  end
+
+  def test_finished
+    assert !@profile.finished?
+
+    @profile.run.join
+
+    assert @profile.finished?
+  end
+
+  # Parsing and Aggregation Tests
+  def test_parse_backtrace
+    trace = [
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/1.9.1/irb.rb:69:in `catch'",
+      "/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/1.9.1/irb.rb:69:in `start'",
+      "/Users/jclark/.rbenv/versions/1.9.3/bin/irb:12:in `<main>'"
+    ]
+
+    result = NewRelic::Agent::ThreadProfile.parse_backtrace(trace)
+    assert_equal({ :method => 'catch',
+                   :file => '/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/1.9.1/irb.rb',
+                   :line_no => 69 }, result[0])
+    assert_equal({ :method => 'start',
+                   :file => '/Users/jclark/.rbenv/versions/1.9.3-p194/lib/ruby/1.9.1/irb.rb',
+                   :line_no => 69 }, result[1])
+    assert_equal({ :method => '<main>',
+                   :file => '/Users/jclark/.rbenv/versions/1.9.3/bin/irb',
+                   :line_no => 12 }, result[2])
+  end
+
+  def test_aggregate_empty_trace
+    result = @profile.aggregate([])
+    assert_nil result
+  end
+
+  def test_aggregate_nil_trace
+    result = @profile.aggregate(nil)
+    assert_nil result
+  end
+
+  def test_aggregate_builds_tree_from_first_trace
+    result = @profile.aggregate(@single_trace)
+
+    tree = NewRelic::Agent::ThreadProfile::Node.new(@single_trace[-1])
+    child = NewRelic::Agent::ThreadProfile::Node.new(@single_trace[-2], tree)
+    NewRelic::Agent::ThreadProfile::Node.new(@single_trace[-3], child)
+
+    assert_equal tree, result
+  end
+
+  def test_aggregate_builds_tree_from_overlapping_traces
+    result = @profile.aggregate(@single_trace)
+    result = @profile.aggregate(@single_trace, [result])
+
+    tree = NewRelic::Agent::ThreadProfile::Node.new(@single_trace[-1])
+    tree.runnable_count += 1
+    child = NewRelic::Agent::ThreadProfile::Node.new(@single_trace[-2], tree)
+    child.runnable_count += 1
+    grand = NewRelic::Agent::ThreadProfile::Node.new(@single_trace[-3], child)
+    grand.runnable_count += 1
+
+    assert_equal tree, result
+  end
+
+  def test_aggregate_builds_tree_from_diverging_traces
+    other_trace = [
+      "irb.rb:69:in `catch'",
+      "chunky_bacon.rb:42:in `start'",
+      "irb:12:in `<main>'"
+    ]
+
+    result = @profile.aggregate(@single_trace)
+    result = @profile.aggregate(@single_trace, [result])
+
+    tree = NewRelic::Agent::ThreadProfile::Node.new(@single_trace[-1])
+    tree.runnable_count += 1
+
+    child = NewRelic::Agent::ThreadProfile::Node.new(@single_trace[-2], tree)
+    grand = NewRelic::Agent::ThreadProfile::Node.new(@single_trace[-3], child)
+
+    other_child = NewRelic::Agent::ThreadProfile::Node.new(other_trace[-2], tree)
+    other_grand = NewRelic::Agent::ThreadProfile::Node.new(other_trace[-3], other_child)
+
+    assert_equal tree, result
+  end
+
+  def test_prune_tree
+    @profile.aggregate(@single_trace)
+
+    t = @profile.prune!(1)
+
+    assert_equal 0, @profile.traces[:request].first.children.size
+  end
+
+  def test_prune_keeps_highest_counts
+    @profile.aggregate(@single_trace, @profile.traces[:request])
+    @profile.aggregate(@single_trace, @profile.traces[:other])
+    @profile.aggregate(@single_trace, @profile.traces[:other])
+
+    @profile.prune!(1)
+
+    assert_equal [], @profile.traces[:request]
+    assert_equal 1, @profile.traces[:other].size
+    assert_equal [], @profile.traces[:other][0].children
+  end
+
+  def test_prune_keeps_highest_count_then_depths
+    @profile.aggregate(@single_trace, @profile.traces[:request])
+    @profile.aggregate(@single_trace, @profile.traces[:other])
+
+    @profile.prune!(2)
+
+    assert_equal 1, @profile.traces[:request].size
+    assert_equal 1, @profile.traces[:other].size
+    assert_equal [], @profile.traces[:request][0].children
+    assert_equal [], @profile.traces[:other][0].children
+  end
+
+  def test_to_compressed_array
+    @profile.instance_variable_set(:@start_time, 1350403938892.524)
+    @profile.instance_variable_set(:@stop_time, 1350403939904.375)
+    @profile.instance_variable_set(:@poll_count, 10)
+    @profile.instance_variable_set(:@sample_count, 2)
+
+    trace = ["thread_profiler.py:1:in `<module>'"]
+    10.times { @profile.aggregate(trace, @profile.traces[:other]) }
+
+    trace = [
+      "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:489:in `__bootstrap'", 
+      "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:512:in `__bootstrap_inner'",
+      "/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py:480:in `run'",
+      "thread_profiler.py:76:in `_profiler_loop'",
+      "thread_profiler.py:103:in `_run_profiler'",
+      "thread_profiler.py:165:in `collect_thread_stacks'"]
+    10.times { @profile.aggregate(trace, @profile.traces[:agent]) }
+ 
+    expected = [[
+          -1, 
+          1350403938892.524, 
+          1350403939904.375, 
+          10, 
+          "eJy9klFPwjAUhf/LfW7WDQTUGBPUiYkGdAxelqXZRpGGrm1uS8xi/O924JQX\n9Un7dm77ndN7c19hlt7FCZxnWQZug7xYMYN6LSTHwDRA4KLWq53kl0CinEQh\nCUmW5zmBJH5axPPUk16MJ/E0/cGk0lLyyrGPS+uKamu943DQeX5HMtypz5In\nwv6vRCeZ1NoAGQ2PCDpvrOM1fRAlFtjQWyxq/qJxa+lj4zZaBeuuQpccrdDK\n0l4wolKU1OxftOoQLNTzIdL/EcjJafjnQYyVWjvrsDBMKNVOZBD1/jO27fPs\naBG+DoGr8fX9JJktpjftVry9A9unzGo=\n",
+          2, 
+          0
+      ]]
+
+    assert_equal expected, @profile.to_compressed_array
+  end
+
+  def test_compress
+    original = '{"OTHER": [[["thread_profiler.py", "<module>", 1], 10, 0, []]], "REQUEST": [], "AGENT": [[["/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py", "__bootstrap", 489], 10, 0, [[["/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py", "__bootstrap_inner", 512], 10, 0, [[["/System/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/threading.py", "run", 480], 10, 0, [[["thread_profiler.py", "_profiler_loop", 76], 10, 0, [[["thread_profiler.py", "_run_profiler", 103], 10, 0, [[["thread_profiler.py", "collect_thread_stacks", 165], 10, 0, []]]]]]]]]]]]], "BACKGROUND": []}'
+    assert_equal( 
+      "eJy9UtFOwjAU/ZWlz2QdKKCGmKBOTDSgY/iyLM02ijR0vcttiVmM/047J0LiA080bdJz2nPPbe/9IrP4KYzIjZckCTFr5NmSVQgrITn6VU06HhmVsNxKfmv33dSuoOPZmaSpBSQK3xbhPHYBHBxPwmncRqPzWhte0heRY4Y1fcSs5J+AG01fa7MG5a9+GfrOUQtQmvb8IZUip1Vzw6GfpIT6aNNhLAcw2mBWWXh5dX2Q01lcmVCKoyX73d5ZvHGrmpcGx27/V2uPmQRwPzQcnCSzJnvOVTq4OEVWgJS8MKw91SYrNtrJB/3jVvkbVnU3vn+eRLPF9KHpm+8dYyPRqg==",
+      NewRelic::Agent::ThreadProfile.compress(original).gsub(/\n/, ''))
+  end
+end
+
+class ThreadProfileNodeTest < Test::Unit::TestCase
+  SINGLE_LINE = "irb.rb:69:in `catch'"
+
+  def test_single_node_converts_to_array
+    line = "irb.rb:69:in `catch'"
+    node = NewRelic::Agent::ThreadProfile::Node.new(line)
+
+    assert_equal([
+        ["irb.rb", "catch", 69],
+        0, 0,
+        []],
+      node.to_array)
+  end
+
+  def test_multiple_nodes_converts_to_array
+    line = "irb.rb:69:in `catch'"
+    child_line = "bacon.rb:42:in `yum'"
+    node = NewRelic::Agent::ThreadProfile::Node.new(line)
+    child = NewRelic::Agent::ThreadProfile::Node.new(child_line, node)
+
+    assert_equal([
+        ["irb.rb", "catch", 69],
+        0, 0,
+        [
+          [
+            ['bacon.rb', 'yum', 42],
+            0,0,
+            []
+          ]
+        ]],
+      node.to_array)
+  end
+
+  def test_add_child_twice
+    parent = NewRelic::Agent::ThreadProfile::Node.new(SINGLE_LINE)
+    child = NewRelic::Agent::ThreadProfile::Node.new(SINGLE_LINE)
+
+    parent.add_child(child)
+    parent.add_child(child)
+
+    assert_equal 1, parent.children.size
+  end
+
+  def test_prune_keeps_children
+    parent = NewRelic::Agent::ThreadProfile::Node.new(SINGLE_LINE)
+    child = NewRelic::Agent::ThreadProfile::Node.new(SINGLE_LINE, parent)
+
+    parent.prune!
+
+    assert_equal [child], parent.children
+  end
+
+  def test_prune_removes_children
+    parent = NewRelic::Agent::ThreadProfile::Node.new(SINGLE_LINE)
+    child = NewRelic::Agent::ThreadProfile::Node.new(SINGLE_LINE, parent)
+
+    child.to_prune = true
+    parent.prune!
+
+    assert_equal [], parent.children
+  end
+
+  def test_prune_removes_children
+    parent = NewRelic::Agent::ThreadProfile::Node.new(SINGLE_LINE)
+    child = NewRelic::Agent::ThreadProfile::Node.new(SINGLE_LINE, parent)
+    grandchild = NewRelic::Agent::ThreadProfile::Node.new(SINGLE_LINE, child)
+
+    grandchild.to_prune = true
+    parent.prune!
+
+    assert_equal [child], parent.children
+    assert_equal [], child.children
+  end
+
+end
+end