ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

data/test/new_relic/agent/worker_loop_test.rb

@@ -23,7 +23,7 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     # This shows how the tasks stay aligned with the period and don't drift.
     count = 0
     start = Time.now
-    @worker_loop.run(0.01) do
+    @worker_loop.run(0.03) do
       count +=1
       if count == 3
         @worker_loop.stop
@@ -31,7 +31,7 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
       end
     end
     elapsed = Time.now - start
-    assert_in_delta 0.03, elapsed, 0.02
+    assert_in_delta 0.09, elapsed, 0.03
   end
   def test_task_error__standard
     @logger.expects(:debug)
@@ -45,7 +45,7 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     end
     assert done
   end
-  class BadBoy < Exception; end
+  class BadBoy < StandardError; end
 
   def test_task_error__exception
     @logger.expects(:error).once

data/test/new_relic/agent_test.rb

@@ -0,0 +1,242 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require 'ostruct'
+
+module NewRelic
+  class MainAgentTest < Test::Unit::TestCase
+    
+    # mostly this module just passes through to the active agent
+    # through the agent method or the control instance through
+    # NewRelic::Control.instance . But it's nice to make sure.
+
+    def teardown
+      super
+      Thread.current[:newrelic_untraced] = nil
+    end
+    
+    def test_shutdown
+      mock_agent = mocked_agent
+      mock_agent.expects(:shutdown).with({})
+      NewRelic::Agent.shutdown
+    end
+
+    def test_after_fork
+      mock_agent = mocked_agent
+      mock_agent.expects(:after_fork).with({})
+      NewRelic::Agent.after_fork
+    end
+
+    def test_after_fork_sets_forked_flag
+      agent = NewRelic::Agent::Agent.new
+      assert !agent.forked?
+      agent.after_fork
+
+      assert agent.forked?
+    end
+    
+
+    if NewRelic::LanguageSupport.can_fork? &&
+        !NewRelic::LanguageSupport.using_version?('1.9.1')
+      def test_timeslice_harvest_with_after_fork_report_to_channel
+        NewRelic::Control.instance.stubs(:agent_enabled?).returns(true)
+        NewRelic::Control.instance.stubs(:monitor_mode?).returns(true)
+        
+        NewRelic::Agent::Agent.instance.service = NewRelic::FakeService.new
+        NewRelic::Agent.shutdown # make sure the agent is not already started
+        NewRelic::Agent.manual_start(:license_key => ('1234567890' * 4),
+                                     :start_channel_listener => true)
+        
+        metric = 'Custom/test/method'
+        NewRelic::Agent.instance.stats_engine.get_stats_no_scope(metric) \
+          .record_data_point(1.0)
+        
+        # ensure that cached metric ids don't interfere with metric merging
+        NewRelic::Agent.agent.instance_variable_set(:@metric_ids,
+                                    {NewRelic::MetricSpec.new('Instance/Busy') => 1})
+        
+        NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
+        NewRelic::Agent.register_report_channel(:agent_test) # before fork
+        pid = Process.fork do
+          NewRelic::Agent.after_fork(:report_to_channel => :agent_test)
+          NewRelic::Agent.agent.stats_engine.get_stats_no_scope(metric) \
+            .record_data_point(2.0)
+        end
+        Process.wait(pid)
+        NewRelic::Agent::PipeChannelManager.listener.stop
+        
+        engine = NewRelic::Agent.agent.stats_engine
+        assert_equal(3.0, engine.lookup_stats(metric).total_call_time)
+        assert_equal(2, engine.lookup_stats(metric).call_count)
+      end
+    end
+    
+    def test_reset_stats
+      mock_agent = mocked_agent
+      mock_agent.expects(:reset_stats)
+      NewRelic::Agent.reset_stats
+    end
+
+    def test_manual_start_default
+      mock_control = mocked_control
+      mock_control.expects(:init_plugin).with({:agent_enabled => true, :sync_startup => true})
+      NewRelic::Agent.manual_start
+    end
+    
+    def test_manual_start_with_opts
+      mock_control = mocked_control
+      mock_control.expects(:init_plugin).with({:agent_enabled => true, :sync_startup => false})
+      NewRelic::Agent.manual_start(:sync_startup => false)
+    end
+
+    def test_manual_start_starts_channel_listener
+      NewRelic::Agent::PipeChannelManager.listener.stop
+      NewRelic::Agent.agent.service = NewRelic::FakeService.new
+      NewRelic::Agent.manual_start(:start_channel_listener => true)
+      assert NewRelic::Agent::PipeChannelManager.listener.started?
+      NewRelic::Agent::PipeChannelManager.listener.stop
+      NewRelic::Agent.shutdown
+    end
+
+    def test_logger
+      control = mocked_control
+      control.expects(:log)
+      NewRelic::Agent.logger
+    end
+
+    def test_browser_timing_header
+      agent = mocked_agent
+      agent.expects(:browser_timing_header)
+      NewRelic::Agent.browser_timing_header
+    end
+
+    def test_browser_timing_footer
+      agent = mocked_agent
+      agent.expects(:browser_timing_footer)
+      NewRelic::Agent.browser_timing_footer
+    end
+
+    def test_get_stats
+      agent = mocked_agent
+      mock_stats_engine = mock('stats_engine')
+      agent.expects(:stats_engine).returns(mock_stats_engine)
+      mock_stats_engine.expects(:get_stats).with('Custom/test/metric', false)
+      NewRelic::Agent.get_stats('Custom/test/metric')
+    end
+    
+    # note that this is the same as get_stats above, they're just aliases
+    def test_get_stats_no_scope
+      agent = mocked_agent
+      mock_stats_engine = mock('stats_engine')
+      agent.expects(:stats_engine).returns(mock_stats_engine)
+      mock_stats_engine.expects(:get_stats).with('Custom/test/metric', false)
+      NewRelic::Agent.get_stats_no_scope('Custom/test/metric')
+    end
+
+    def test_agent_not_started
+      old_agent = NewRelic::Agent.agent
+      NewRelic::Agent.instance_eval { @agent = nil }
+      assert_raise(RuntimeError) do
+        NewRelic::Agent.agent
+      end
+      NewRelic::Agent.instance_eval { @agent = old_agent }
+    end
+
+    def test_agent_when_started
+      old_agent = NewRelic::Agent.agent
+      NewRelic::Agent.instance_eval { @agent = 'not nil' }
+      assert_equal('not nil', NewRelic::Agent.agent, "should return the value from @agent")
+      NewRelic::Agent.instance_eval { @agent = old_agent }
+    end
+
+    def test_abort_transaction_bang
+      NewRelic::Agent::Instrumentation::MetricFrame.expects(:abort_transaction!)
+      NewRelic::Agent.abort_transaction!
+    end
+
+    def test_is_transaction_traced_true
+      Thread.current[:record_tt] = true
+      assert_equal(true, NewRelic::Agent.is_transaction_traced?, 'should be true since the thread local is set')
+    end
+
+    def test_is_transaction_traced_blank
+      Thread.current[:record_tt] = nil
+      assert_equal(true, NewRelic::Agent.is_transaction_traced?, 'should be true since the thread local is not set')
+    end
+
+    def test_is_transaction_traced_false
+      Thread.current[:record_tt] = false
+      assert_equal(false, NewRelic::Agent.is_transaction_traced?, 'should be false since the thread local is false')
+    end
+    
+    def test_is_sql_recorded_true
+      Thread.current[:record_sql] = true
+      assert_equal(true, NewRelic::Agent.is_sql_recorded?, 'should be true since the thread local is set')
+    end
+
+    def test_is_sql_recorded_blank
+      Thread.current[:record_sql] = nil
+      assert_equal(true, NewRelic::Agent.is_sql_recorded?, 'should be true since the thread local is not set')
+    end
+
+    def test_is_sql_recorded_false
+      Thread.current[:record_sql] = false
+      assert_equal(false, NewRelic::Agent.is_sql_recorded?, 'should be false since the thread local is false')
+    end
+    
+    def test_is_execution_traced_true
+      Thread.current[:newrelic_untraced] = [true, true]
+      assert_equal(true, NewRelic::Agent.is_execution_traced?, 'should be true since the thread local is set')
+    end
+
+    def test_is_execution_traced_blank
+      Thread.current[:newrelic_untraced] = nil
+      assert_equal(true, NewRelic::Agent.is_execution_traced?, 'should be true since the thread local is not set')
+    end
+
+    def test_is_execution_traced_empty
+      Thread.current[:newrelic_untraced] = []
+      assert_equal(true, NewRelic::Agent.is_execution_traced?, 'should be true since the thread local is an empty array')
+    end
+
+    def test_is_execution_traced_false
+      Thread.current[:newrelic_untraced] = [true, false]
+      assert_equal(false, NewRelic::Agent.is_execution_traced?, 'should be false since the thread local stack has the last element false')
+    end
+    
+    def test_instance
+      assert_equal(NewRelic::Agent.agent, NewRelic::Agent.instance, "should return the same agent for both identical methods")
+    end
+    
+    def test_register_report_channel
+      NewRelic::Agent.register_report_channel(:channel_id)
+      assert NewRelic::Agent::PipeChannelManager.channels[:channel_id] \
+        .kind_of?(NewRelic::Agent::PipeChannelManager::Pipe)
+      NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
+    end
+    
+    private
+
+    def mocked_agent
+      agent = mock('agent')
+      NewRelic::Agent.stubs(:agent).returns(agent)
+      agent
+    end
+    
+    def mocked_control
+      server = NewRelic::Control::Server.new('localhost', 3000)
+      control = OpenStruct.new(:license_key => 'abcdef',
+                               :server => server)
+      control.instance_eval do
+        def [](key)
+          nil
+        end
+        
+        def fetch(k,d)
+          nil
+        end
+      end
+
+      NewRelic::Control.stubs(:instance).returns(control)
+      control
+    end
+  end
+end

data/test/new_relic/collection_helper_test.rb

@@ -15,12 +15,12 @@ class NewRelic::CollectionHelperTest < Test::Unit::TestCase
 
   include NewRelic::CollectionHelper
   def test_string
-    val = (('A'..'Z').to_a.join * 100).to_s
-    assert_equal val[0...256] + "...", normalize_params(val)
+    val = (('A'..'Z').to_a.join * 1024).to_s
+    assert_equal val[0...16384] + "...", normalize_params(val)
   end
   def test_array
     new_array = normalize_params [ 1000 ] * 2000
-    assert_equal 1024, new_array.size
+    assert_equal 128, new_array.size
     assert_equal '1000', new_array[0]
   end
   def test_boolean
@@ -55,7 +55,7 @@ class NewRelic::CollectionHelperTest < Test::Unit::TestCase
   end
   def test_hash
     val = ('A'..'Z').to_a.join * 100
-    assert_equal Hash["ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEF..." => (("0"*256) + "...")], normalize_params({ val => '0' * 512 })
+    assert_equal Hash[(val[0..63] + "...") => (("0"*16384) + "...")], normalize_params({ val => '0' * (16384*2) })
   end
   class MyHash < Hash
 
@@ -72,13 +72,7 @@ class NewRelic::CollectionHelperTest < Test::Unit::TestCase
     assert_equal Hash, myhash.class
   end
 
-  class MyEnumerable
-    include Enumerable
 
-    def each
-      yield "1"
-    end
-  end
 
   def test_enumerable
     e = MyEnumerable.new
@@ -101,27 +95,55 @@ class NewRelic::CollectionHelperTest < Test::Unit::TestCase
     s.each { | entry | val = entry; break }
     assert_match /^startfoo bar/, val
   end
-
+  class MyEnumerable
+    include Enumerable
+    
+    def each
+      yield "1"
+    end
+  end
+  
   def test_object
     assert_equal ["foo", '#<OpenStruct>'], normalize_params(['foo', OpenStruct.new('z'=>'q')])
   end
 
   def test_strip_backtrace
-    begin
-      ActiveRecordFixtures.setup
-#      ActiveRecordFixtures::Order.add_delay
-      ActiveRecordFixtures::Order.find 0
-      flunk "should throw"
-    rescue => e
-      #puts e
-      #puts e.backtrace.grep(/trace/).join("\n")
-      #puts "\n\n"
-      clean_trace = strip_nr_from_backtrace(e.backtrace)
-      assert_equal 0, clean_trace.grep(/newrelic_rpm/).size, clean_trace.join("\n")
-      assert_equal 0, clean_trace.grep(/trace/).size, clean_trace.join("\n")
-      assert (clean_trace.grep(/find/).size >= 3), "should see at least three frames with 'find' in them (#{e}): \n#{clean_trace.join("\n")}"
-    ensure
-      ActiveRecordFixtures.teardown
-    end
-  end if defined?(::ActiveRecord)
+    clean_trace = strip_nr_from_backtrace(mock_backtrace)
+    assert_equal(0, clean_trace.grep(/newrelic_rpm/).size,
+                 "should remove all instances of new relic from backtrace but got: #{clean_trace.join("\n")}")
+    assert_equal(0, clean_trace.grep(/trace/).size, 
+                     "should remove trace method tags from method names but got: #{clean_trace.join("\n")}")
+    assert((clean_trace.grep(/find/).size >= 3),
+               "should see at least three frames with 'find' in them: \n#{clean_trace.join("\n")}")
+  end
+
+  def test_disabled_strip_backtrace
+    NewRelic::Control.instance['disable_backtrace_cleanup'] = true
+    clean_trace = strip_nr_from_backtrace(mock_backtrace)
+    assert_equal(1, clean_trace.grep(/new_relic/).size,
+            "should not remove instances of new relic from backtrace but got: #{clean_trace.join("\n")}")
+    assert_equal(1, clean_trace.grep(/_trace/).size, 
+                   "should not remove trace method tags from method names but got: #{clean_trace.join("\n")}")
+    #       assert (clean_trace.grep(/find/).size >= 3), "should see at least three frames with 'find' in them (#{e}): \n#{clean_trace.join("\n")}"
+    NewRelic::Control.instance['disable_backtrace_cleanup'] = false
+  end
+  
+  private 
+  def mock_backtrace
+    [
+   %q{/home/app/gems/activerecord-2.3.12/lib/active_record/base.rb:1620:in `find_one_without_trace'}, 
+   %q{/home/app/gems/activerecord-2.3.12/lib/active_record/base.rb:1620:in `find_one'}, 
+   %q{/home/app/gems/activerecord-2.3.12/lib/active_record/base.rb:1603:in `find_from_ids'}, 
+   %q{./test/new_relic/collection_helper_test.rb:112:in `test_strip_stackdump'}, 
+   %q{/home/app/gems/mocha-0.9.8/lib/mocha/integration/test_unit/ruby_version_186_and_above.rb:19:in `__send__'}, 
+   %q{/home/app/gems/mocha-0.9.8/lib/mocha/integration/test_unit/ruby_version_186_and_above.rb:19:in `run'}, 
+   %q{/home/app/test/unit/testsuite.rb:34:in `run'}, 
+   %q{/home/app/test/unit/testsuite.rb:33:in `each'}, 
+   %q{/home/app/test/unit/testsuite.rb:33:in `run'}, 
+   %q{/home/app/test/unit/testsuite.rb:34:in `run'}, 
+   %q{/home/app/test/unit/testsuite.rb:33:in `each'}, 
+   %q{/home/app/test/unit/testsuite.rb:33:in `run'}, 
+   %q{/home/app/test/unit/ui/testrunnermediator.rb:46:in `run_suite'}
+   ]
+  end
 end

data/test/new_relic/control/configuration_test.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'/../../test_helper'))
+
+class NewRelic::Control::ConfigurationTest < Test::Unit::TestCase
+  require 'new_relic/control/configuration'
+  include NewRelic::Control::Configuration
+  
+  def setup
+    # The log stuff is memoized so let's clear it each time.
+    NewRelic::Control.instance.instance_variable_set '@log_path', nil
+    NewRelic::Control.instance.instance_variable_set '@log_file', nil
+    @root = ::Rails::VERSION::MAJOR == 3 ? Rails.root : RAILS_ROOT
+  end
+  
+  def teardown
+    NewRelic::Control.instance.settings.delete('log_file_path')
+  end
+  
+  def test_license_key_defaults_to_env_variable
+    ENV['NEWRELIC_LICENSE_KEY'] = nil
+    self.expects(:fetch).with('license_key', nil)
+    license_key
+
+    ENV['NEWRELIC_LICENSE_KEY'] = "a string"
+    self.expects(:fetch).with('license_key', 'a string')
+    license_key
+  end
+  
+  def test_log_path_uses_default_if_not_set
+    NewRelic::Control.instance.setup_log
+    assert_equal(File.expand_path("log/newrelic_agent.log"),
+                 NewRelic::Control.instance.log_file)
+  end
+
+  def test_log_file_path_uses_given_value
+    Dir.stubs(:mkdir).returns(true)
+    NewRelic::Control.instance['log_file_path'] = 'lerg'
+    NewRelic::Control.instance.setup_log
+    assert_match(/\/lerg\/newrelic_agent.log/,
+                 NewRelic::Control.instance.log_file)
+    NewRelic::Control.instance.settings.delete('log_file_path') # = nil    
+  end
+
+  def test_server_side_config_ignores_yaml
+    settings.merge! 'ssl' => false, 'transaction_tracer' => {'enabled' => true, 'stack_trace_threshold' => 1.0}, 'error_collector' => {'enabled' => true, 'ignore_errors' => 'ActiveRecord::RecordNotFound'}, 'capture_params' => false
+    merge_server_side_config 'transaction_tracer.enabled' => false, 'error_collector.enabled' => false
+    assert_equal({'ssl' => false, 'transaction_tracer' => {'enabled' => false}, 'error_collector' => {'enabled' => false}}, settings)
+  end
+
+  def test_install_browser_monitoring
+    require(File.expand_path(File.join(File.dirname(__FILE__),
+                         '/../../../lib/new_relic/rack/browser_monitoring')))
+    middleware = stub('middleware config')
+    config = stub('rails config', :middleware => middleware)
+    middleware.expects(:use).with(NewRelic::Rack::BrowserMonitoring)
+    NewRelic::Control.instance['browser_monitoring'] = { 'auto_instrument' => true }
+    NewRelic::Control.instance.instance_eval { @browser_monitoring_installed = false }
+
+    NewRelic::Control.instance.install_browser_monitoring(config)
+  end
+
+  def test_install_browser_monitoring_should_not_install_when_not_configured
+    middleware = stub('middleware config')
+    config = stub('rails config', :middleware => middleware)
+    middleware.expects(:use).never
+    NewRelic::Control.instance['browser_monitoring'] = { 'auto_instrument' => false }
+    NewRelic::Control.instance.instance_eval { @browser_monitoring_installed = false }
+    
+    NewRelic::Control.instance.install_browser_monitoring(config)
+
+    NewRelic::Control.instance['browser_monitoring'] = { 'auto_instrument' => true }
+  end
+
+  def test_data_serialization_default_off
+    DependencyDetection.send(:class_variable_set, '@@items', [])
+    assert NewRelic::Control.instance.disable_serialization?
+  end
+end