ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

data/test/new_relic/agent/agent/connect_test.rb

@@ -1,13 +1,30 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..', '..', '..','test_helper'))
+require 'new_relic/agent/agent'
+require 'ostruct'
+
 class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
-  require 'new_relic/agent/agent'
   include NewRelic::Agent::Agent::Connect
-
+  
   def setup
     @connected = nil
     @keep_retrying = nil
     @connect_attempts = 1
     @connect_retry_period = 0
+    @transaction_sampler = NewRelic::Agent::TransactionSampler.new
+    @sql_sampler = NewRelic::Agent::SqlSampler.new
+    server = NewRelic::Control::Server.new('localhost', 30303)
+    @service = NewRelic::Agent::NewRelicService.new('abcdef', server)
+  end
+
+  def control
+    fake_control = OpenStruct.new('validate_seed' => false,
+                                  'local_env' => OpenStruct.new('snapshot' => []))
+    fake_control.instance_eval do
+      def [](key)
+        return nil
+      end
+    end
+    fake_control
   end
 
   def test_tried_to_connect?
@@ -206,22 +223,40 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     enable_random_samples!(sampling_rate)
   end
 
+  def test_config_transaction_tracer
+    NewRelic::Control.instance.settings['transaction_tracer'] = {
+      'enabled' => true,
+      'random_sample' => false,
+      'explain_threshold' => 0.75,
+      'explain_enabled' => true
+    }
+
+    config_transaction_tracer
+
+    assert @transaction_sampler.enabled?
+    assert_equal 0.75, @transaction_sampler.explain_threshold
+    assert @transaction_sampler.explain_enabled
+#     assert_equal 1.5, @transaction_sampler.transaction_threshold
+  end
+
   def test_configure_transaction_tracer_with_random_sampling
     @config_should_send_samples = true
     @should_send_random_samples = true
     @slowest_transaction_threshold = 5
-    log.expects(:debug).with('Transaction tracing threshold is 5 seconds.')
+    log.stubs(:debug)
     self.expects(:enable_random_samples!).with(10)
     configure_transaction_tracer!(true, 10)
     assert @should_send_samples
+    assert_equal 5, @transaction_sampler.slow_capture_threshold
   end
 
   def test_configure_transaction_tracer_positive
     @config_should_send_samples = true
     @slowest_transaction_threshold = 5
-    log.expects(:debug).with('Transaction tracing threshold is 5 seconds.')
+    log.stubs(:debug)
     configure_transaction_tracer!(true, 10)
     assert @should_send_samples
+    assert_equal 5, @transaction_sampler.slow_capture_threshold
   end
 
   def test_configure_transaction_tracer_negative
@@ -238,38 +273,90 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     assert !@should_send_samples
   end
 
-  def test_set_collector_host_positive
-    control = mocked_control
-    self.expects(:invoke_remote).with(:get_redirect_host).returns('collector-deux.newrelic.com')
-    control.expects(:server_from_host).with('collector-deux.newrelic.com').returns('correct')
-    set_collector_host!
-    assert_equal 'correct', @collector
+  def test_apdex_f
+    NewRelic::Control.instance.expects(:apdex_t).returns(10)
+    assert_equal 40, apdex_f
   end
 
-  def test_set_collector_host_negative
-    @collector = 'initial value'
-    control = mocked_control
-    self.expects(:invoke_remote).with(:get_redirect_host).returns(nil)
-    set_collector_host!
-    assert_equal 'initial value', @collector, "should not modify collector value"
+  def test_apdex_f_threshold_positive
+    NewRelic::Control.instance.settings['transaction_tracer'] = { 'transaction_threshold' => 'apdex_f' }
+    assert apdex_f_threshold?
   end
 
-  def test_configure_transaction_tracer_random_samples
-    @config_should_send_samples = true
-    @should_send_random_samples = true
-    self.expects(:enable_random_samples!).with(10)
-    log.expects(:debug)
-    configure_transaction_tracer!(true, 10)
-    assert @should_send_samples
+  def test_apdex_f_threshold_negative
+    NewRelic::Control.instance.settings['transaction_tracer'] = { 'transaction_threshold' => 'WHEE' }
+    assert !apdex_f_threshold?
+  end
+
+  def test_set_sql_recording_default
+    NewRelic::Control.instance.settings['transaction_tracer'] = { }
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :obfuscated, @record_sql, " should default to :obfuscated, was #{@record_sql}"
+  end
+
+  def test_set_sql_recording_off
+    NewRelic::Control.instance.settings['transaction_tracer'] = {'record_sql' => 'off'}
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+  end
+
+  def test_set_sql_recording_none
+    NewRelic::Control.instance.settings['transaction_tracer'] = {'record_sql' => 'none'}    
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+  end
+
+  def test_set_sql_recording_raw
+    NewRelic::Control.instance.settings['transaction_tracer'] = {'record_sql' => 'raw'}        
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :raw, @record_sql, "should be set to :raw, was #{@record_sql}"
+  end
+
+  def test_set_sql_recording_falsy
+    NewRelic::Control.instance.settings['transaction_tracer'] = {'record_sql' => false}            
+    self.expects(:log_sql_transmission_warning?)
+    set_sql_recording!
+    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
+  end
+
+  def test_log_sql_transmission_warning_negative
+    log = mocked_log
+    @record_sql = :obfuscated
+    log.expects(:warn).never
+    log_sql_transmission_warning?
+  end
+
+  def test_log_sql_transmission_warning_positive
+    log = mocked_log
+    @record_sql = :raw
+    log.expects(:warn).with('Agent is configured to send raw SQL to the service')
+    log_sql_transmission_warning?
   end
 
   def test_query_server_for_configuration
-    self.expects(:set_collector_host!)
     self.expects(:connect_to_server).returns("so happy")
     self.expects(:finish_setup).with("so happy")
     query_server_for_configuration
   end
 
+  def test_connect_to_server_gets_config_from_collector
+    service = NewRelic::FakeService.new
+    NewRelic::Agent::Agent.instance.service = service
+    NewRelic::Agent.manual_start
+    service.mock['connect'] = {'agent_run_id' => 23, 'config' => 'a lot'}
+
+    response = NewRelic::Agent.agent.connect_to_server
+
+    assert_equal 23, response['agent_run_id']
+    assert_equal 'a lot', response['config']
+
+    NewRelic::Agent.shutdown
+  end
+
   def test_finish_setup
     config = {
       'agent_run_id' => 'fishsticks',
@@ -279,15 +366,25 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
       'collect_errors' => true,
       'sample_rate' => 10
     }
+    NewRelic::Control.instance.settings['transaction_tracer'] = {'enabled' => true}
     self.expects(:log_connection!).with(config)
     self.expects(:configure_transaction_tracer!).with(true, 10)
     self.expects(:configure_error_collector!).with(true)
+    @transaction_sampler = stub('transaction sampler', :configure! => true,
+                                :config => {})
+    @sql_sampler = stub('sql sampler', :configure! => true)    
     finish_setup(config)
-    assert_equal 'fishsticks', @agent_id
+    assert_equal 'fishsticks', @service.agent_id
     assert_equal 'pasta sauce', @report_period
     assert_equal 'tamales', @url_rules
   end
 
+  def test_finish_setup_without_config
+    @service.agent_id = 'blah'
+    finish_setup(nil)
+    assert_equal 'blah', @service.agent_id
+  end
+
   private
 
   def mocked_control
@@ -296,6 +393,12 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     fake_control
   end
 
+  def mocked_log
+    fake_log = mock('log')
+    self.stubs(:log).returns(fake_log)
+    fake_log
+  end
+
   def mocked_error_collector
     fake_collector = mock('error collector')
     self.stubs(:error_collector).returns(fake_collector)

data/test/new_relic/agent/agent/start_test.rb

@@ -51,91 +51,6 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
     log_app_names
   end
 
-  def test_apdex_f
-    NewRelic::Control.instance.expects(:apdex_t).returns(10)
-    assert_equal 40, apdex_f
-  end
-
-  def test_apdex_f_threshold_positive
-    self.expects(:sampler_config).returns({'transaction_threshold' => 'apdex_f'})
-    assert apdex_f_threshold?
-  end
-
-  def test_apdex_f_threshold_negative
-    self.expects(:sampler_config).returns({'transaction_threshold' => 'WHEE'})
-    assert !apdex_f_threshold?
-  end
-
-  def test_set_sql_recording_default
-    self.expects(:sampler_config).returns({})
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :obfuscated, @record_sql, " should default to :obfuscated, was #{@record_sql}"
-  end
-
-  def test_set_sql_recording_off
-    self.expects(:sampler_config).returns({'record_sql' => 'off'})
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
-  end
-
-  def test_set_sql_recording_none
-    self.expects(:sampler_config).returns({'record_sql' => 'none'})
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
-  end
-
-  def test_set_sql_recording_raw
-    self.expects(:sampler_config).returns({'record_sql' => 'raw'})
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :raw, @record_sql, "should be set to :raw, was #{@record_sql}"
-  end
-
-  def test_set_sql_recording_falsy
-    self.expects(:sampler_config).returns({'record_sql' => false})
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
-  end
-
-  def test_log_sql_transmission_warning_negative
-    log = mocked_log
-    @record_sql = :obfuscated
-    log.expects(:warn).never
-    log_sql_transmission_warning?
-  end
-
-  def test_log_sql_transmission_warning_positive
-    log = mocked_log
-    @record_sql = :raw
-    log.expects(:send).with(:warn, 'Agent is configured to send raw SQL to the service')
-    log_sql_transmission_warning?
-  end
-
-  def test_sampler_config
-    control = mocked_control
-    control.expects(:fetch).with('transaction_tracer', {})
-    sampler_config
-  end
-
-  def test_config_transaction_tracer
-    fake_sampler_config = mock('sampler config')
-    self.expects(:sampler_config).times(5).returns(fake_sampler_config)
-    fake_sampler_config.expects(:fetch).with('enabled', true)
-    fake_sampler_config.expects(:fetch).with('random_sample', false)
-    fake_sampler_config.expects(:fetch).with('explain_threshold', 0.5)
-    fake_sampler_config.expects(:fetch).with('explain_enabled', true)
-    self.expects(:set_sql_recording!)
-
-    fake_sampler_config.expects(:fetch).with('transaction_threshold', 2.0)
-    self.expects(:apdex_f_threshold?).returns(true)
-    self.expects(:apdex_f)
-    config_transaction_tracer
-  end
-
   def test_check_config_and_start_agent_disabled
     self.expects(:monitoring?).returns(false)
     check_config_and_start_agent
@@ -190,8 +105,8 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   def test_install_exit_handler_positive
     control = mocked_control
     control.expects(:send_data_on_exit).returns(true)
-    self.expects(:using_rubinius?).returns(false)
-    self.expects(:using_jruby?).returns(false)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(false)
     self.expects(:using_sinatra?).returns(false)
     # we are overriding at_exit above, to immediately return, so we can
     # test the shutdown logic. It's somewhat unfortunate, but we can't
@@ -209,21 +124,21 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   def test_install_exit_handler_weird_ruby
     control = mocked_control
     control.expects(:send_data_on_exit).times(3).returns(true)
-    self.expects(:using_rubinius?).returns(false)
-    self.expects(:using_jruby?).returns(false)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(false)
     self.expects(:using_sinatra?).returns(true)
     install_exit_handler
-    self.expects(:using_rubinius?).returns(false)
-    self.expects(:using_jruby?).returns(true)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(false)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('jruby').returns(true)
     install_exit_handler
-    self.expects(:using_rubinius?).returns(true)
+    NewRelic::LanguageSupport.expects(:using_engine?).with('rbx').returns(true)
     install_exit_handler
   end
 
   def test_notify_log_file_location_positive
     log = mocked_log
-    NewRelic::Control.instance.expects(:log_file).returns('CHUD CHUD CHUD')
-    log.expects(:send).with(:info, "Agent Log found in CHUD CHUD CHUD")
+    NewRelic::Control.instance.expects(:log_file).returns('./')
+    log.expects(:send).with(:info, "Agent Log at ./")
     notify_log_file_location
   end
 

data/test/new_relic/agent/agent/start_worker_thread_test.rb

@@ -8,6 +8,7 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
     self.expects(:connect).with('connection_options')
     @connected = true
     self.expects(:check_transaction_sampler_status)
+    self.expects(:check_sql_sampler_status)    
     self.expects(:log_worker_loop_start)
     self.expects(:create_and_run_worker_loop)
     deferred_work!('connection_options')
@@ -63,10 +64,7 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
     wl = mock('worker loop')
     NewRelic::Agent::WorkerLoop.expects(:new).returns(wl)
     wl.expects(:run).with(30).yields
-    self.expects(:harvest_and_send_timeslice_data)
-    self.expects(:harvest_and_send_slowest_sample)
-    self.expects(:harvest_and_send_errors)
-    NewRelic::Agent.expects(:load_data)
+    self.expects(:transmit_data)
     create_and_run_worker_loop
   end
 

data/test/new_relic/agent/agent_test.rb

@@ -2,10 +2,33 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper
 module NewRelic
   module Agent
     class AgentTest < Test::Unit::TestCase
-
       def setup
         super
         @agent = NewRelic::Agent::Agent.new
+        @agent.service = NewRelic::FakeService.new
+      end
+
+      def test_after_fork_reporting_to_channel
+        @agent.after_fork(:report_to_channel => 123)
+        assert(@agent.service.kind_of?(NewRelic::Agent::PipeService),
+               'Agent should use PipeService when directed to report to pipe channel')
+        assert_equal 123, @agent.service.channel_id
+      end
+      
+      def test_transmit_data_should_transmit
+        @agent.instance_eval { transmit_data }
+        assert @agent.service.agent_data.any?
+      end
+
+      def test_transmit_data_should_close_explain_db_connections
+        NewRelic::Agent::Database.expects(:close_connections)
+        @agent.instance_eval { transmit_data }
+      end
+      
+      def test_transmit_data_should_not_close_db_connections_if_forked
+        NewRelic::Agent::Database.expects(:close_connections).never
+        @agent.after_fork
+        @agent.instance_eval { transmit_data }
       end
 
       def test_serialize
@@ -17,7 +40,26 @@ module NewRelic
       end
 
       def test_harvest_timeslice_data
-        assert_equal({}, @agent.send(:harvest_timeslice_data), 'should return timeslice data')
+        assert_equal({}, @agent.send(:harvest_timeslice_data),
+                     'should return timeslice data')
+      end
+
+      def test_harvest_timelice_data_should_be_thread_safe
+        2000.times do |i|
+          @agent.stats_engine.stats_hash[i.to_s] = NewRelic::StatsBase.new
+        end
+        
+        harvest = Thread.new do
+          @agent.send(:harvest_timeslice_data)
+        end
+
+        app = Thread.new do
+          @agent.stats_engine.stats_hash["a"] = NewRelic::StatsBase.new
+        end
+        
+        assert_nothing_raised do
+          [app, harvest].each{|t| t.join}
+        end
       end
 
       def test_harvest_errors
@@ -89,85 +131,16 @@ module NewRelic
           @unsent_timeslice_data = unsent_timeslice_data
           @traces = unsent_traces
         }
-        unsent_errors.expects(:+).with([])
-        unsent_traces.expects(:+).with([])
-        @agent.merge_data_from([{}, [], []])
+        unsent_traces.expects(:+).with([1,2,3])
+        unsent_errors.expects(:+).with([4,5,6])
+        @agent.merge_data_from([{}, [1,2,3], [4,5,6]])
       end
 
-      def test_sql_normalization
-
-        # basic statement
-        assert_equal "INSERT INTO X values(?,?, ? , ?)",
-        @agent.send(:default_sql_obfuscator, "INSERT INTO X values('test',0, 1 , 2)")
-
-        # escaped literals
-        assert_equal "INSERT INTO X values(?, ?,?, ? , ?)",
-        @agent.send(:default_sql_obfuscator, "INSERT INTO X values('', 'jim''s ssn',0, 1 , 'jim''s son''s son')")
-
-        # multiple string literals
-        assert_equal "INSERT INTO X values(?,?,?, ? , ?)",
-        @agent.send(:default_sql_obfuscator, "INSERT INTO X values('jim''s ssn','x',0, 1 , 2)")
-
-        # empty string literal
-        # NOTE: the empty string literal resolves to empty string, which for our purposes is acceptable
-        assert_equal "INSERT INTO X values(?,?,?, ? , ?)",
-        @agent.send(:default_sql_obfuscator, "INSERT INTO X values('','x',0, 1 , 2)")
-
-        # try a select statement
-        assert_equal "select * from table where name=? and ssn=?",
-        @agent.send(:default_sql_obfuscator, "select * from table where name='jim gochee' and ssn=0012211223")
-
-        # number literals embedded in sql - oh well
-        assert_equal "select * from table_? where name=? and ssn=?",
-        @agent.send(:default_sql_obfuscator, "select * from table_007 where name='jim gochee' and ssn=0012211223")
+      def test_should_not_log_log_file_location_if_no_log_file
+        NewRelic::Control.instance.stubs(:log_file).returns('/vasrkjn4b3b4')
+        @agent.expects(:log).never
+        @agent.notify_log_file_location
       end
-
-      def test_sql_normalization__single_quotes
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, "INSERT 'this isn''t a real value' into table")
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, %q[INSERT '"' into table])
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, %q[INSERT ' "some text" \" ' into table])
-        #    could not get this one licked.  no biggie
-        #    assert_equal "INSERT ? into table",
-        #    @agent.send(:default_sql_obfuscator, %q[INSERT '\'' into table])
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, %q[INSERT ''' ' into table])
-      end
-      def test_sql_normalization__double_quotes
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, %q[INSERT "this isn't a real value" into table])
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, %q[INSERT "'" into table])
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, %q[INSERT " \" " into table])
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, %q[INSERT " 'some text' " into table])
-      end
-      def test_sql_obfuscation_filters
-        @agent.set_sql_obfuscator(:replace) do |string|
-          "1" + string
-        end
-
-        sql = "SELECT * FROM TABLE 123 'jim'"
-
-        assert_equal "1" + sql, @agent.obfuscator.call(sql)
-
-        @agent.set_sql_obfuscator(:before) do |string|
-          "2" + string
-        end
-
-        assert_equal "12" + sql, @agent.obfuscator.call(sql)
-
-        @agent.set_sql_obfuscator(:after) do |string|
-          string + "3"
-        end
-
-        assert_equal "12" + sql + "3", @agent.obfuscator.call(sql)
-      end
-
-
     end
   end
 end