sundawg_newrelic_rpm 3.5.8.1

data/test/new_relic/agent/worker_loop_test.rb

@@ -0,0 +1,84 @@
+ENV['SKIP_RAILS'] = 'true'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
+  def setup
+    @worker_loop = NewRelic::Agent::WorkerLoop.new
+    @test_start_time = Time.now
+  end
+
+  def test_add_task
+    @x = false
+    @worker_loop.run(0) do
+      @worker_loop.stop
+      @x = true
+    end
+    assert @x
+  end
+
+  def test_with_duration
+    worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => 0.1)
+
+    # Advance in small increments vs our period so time will pass over the
+    # nasty multiple calls to Time.now that WorkerLoop makes
+    Time.stubs(:now).returns(*ticks(0, 0.12, 0.005))
+
+    count = 0
+    worker_loop.run(0.04) do
+      count += 1
+    end
+
+    assert_equal 2, count
+  end
+
+  def test_duration_clock_starts_with_run
+    # This test is a little on the nose, but any timing based test WILL fail in CI
+    worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => 0.01)
+    assert_nil worker_loop.instance_variable_get(:@deadline)
+
+    worker_loop.run(0.001) {}
+    assert !worker_loop.instance_variable_get(:@deadline).nil?
+  end
+
+  def test_loop_limit
+    worker_loop = NewRelic::Agent::WorkerLoop.new(:limit => 2)
+    iterations = 0
+    worker_loop.run(0) { iterations += 1 }
+    assert_equal 2, iterations
+  end
+
+  def test_task_error__standard
+    expects_logging(:error, any_parameters)
+    # This loop task will run twice
+    done = false
+    @worker_loop.run(0) do
+      @worker_loop.stop
+      done = true
+      raise "Standard Error Test"
+    end
+    assert done
+  end
+
+  class BadBoy < StandardError; end
+
+  def test_task_error__exception
+    expects_logging(:error, any_parameters)
+    @worker_loop.run(0) do
+      @worker_loop.stop
+      raise BadBoy, "oops"
+    end
+  end
+
+  def test_task_error__server
+    expects_no_logging(:error)
+    expects_logging(:debug, any_parameters)
+    @worker_loop.run(0) do
+      @worker_loop.stop
+      raise NewRelic::Agent::ServerError, "Runtime Error Test"
+    end
+  end
+
+  def ticks(start, finish, step)
+    (start..finish).step(step).map{|i| Time.at(i)}
+  end
+end

data/test/new_relic/agent_test.rb

@@ -0,0 +1,296 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require 'ostruct'
+
+module NewRelic
+  # mostly this class 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.
+  class MainAgentTest < Test::Unit::TestCase
+
+    def setup
+      NewRelic::Agent.reset_config
+    end
+
+    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_shutdown_removes_manual_startup_config
+      NewRelic::Agent.manual_start(:some_absurd_setting => true)
+      assert NewRelic::Agent.config[:some_absurd_setting]
+      NewRelic::Agent.shutdown
+      assert !NewRelic::Agent.config[:some_absurd_setting]
+    end
+
+    def test_shutdown_removes_server_config
+      NewRelic::Agent.manual_start
+      NewRelic::Agent.instance.service = default_service
+      NewRelic::Agent.instance.finish_setup('agent_config' =>
+                                            { :some_absurd_setting => true })
+      assert NewRelic::Agent.config[:some_absurd_setting]
+      NewRelic::Agent.shutdown
+      assert !NewRelic::Agent.config[:some_absurd_setting]
+    end
+
+    def test_finish_setup_applied_server_side_config
+      with_config({ :'transction_tracer.enabled' => true,
+                    'error_collector.enabled' => true,
+                    :log_level => 'info' }, :level => 2) do
+        NewRelic::Agent.instance.finish_setup('log_level' => 'debug',
+         'agent_config' => { 'transaction_tracer.enabled' => false },
+                                         'collect_errors' => false)
+        assert !NewRelic::Agent.config[:'transaction_tracer.enabled']
+        assert !NewRelic::Agent.config[:'error_collector.enabled']
+        assert_equal 'debug', NewRelic::Agent.config[:log_level]
+      end
+    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
+        with_config(:agent_enabled => true, :monitor_mode => true) do
+          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)
+
+          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)
+          engine.reset_stats
+        end
+      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.manual_start(:start_channel_listener => true)
+      assert NewRelic::Agent::PipeChannelManager.listener.started?
+      NewRelic::Agent::PipeChannelManager.listener.stop
+      NewRelic::Agent.shutdown
+    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
+
+    def test_record_metric
+      dummy_engine = NewRelic::Agent.agent.stats_engine
+      dummy_engine.expects(:record_metric).with('foo', 12)
+      NewRelic::Agent.record_metric('foo', 12)
+    end
+
+    def test_record_metric_accepts_hash
+      dummy_engine = NewRelic::Agent.agent.stats_engine
+      stats_hash = {
+        :count => 12,
+        :total => 42,
+        :min   => 1,
+        :max   => 5,
+        :sum_of_squares => 999
+      }
+      expected_stats = NewRelic::Agent::Stats.new()
+      expected_stats.call_count = 12
+      expected_stats.total_call_time = 42
+      expected_stats.total_exclusive_time = 42
+      expected_stats.min_call_time = 1
+      expected_stats.max_call_time = 5
+      expected_stats.sum_of_squares = 999
+      dummy_engine.expects(:record_metric).with('foo', expected_stats)
+      NewRelic::Agent.record_metric('foo', stats_hash)
+    end
+
+    def test_increment_metric
+      dummy_engine = NewRelic::Agent.agent.stats_engine
+      dummy_stats = mock
+      dummy_stats.expects(:increment_count).with(12)
+      dummy_engine.expects(:record_metric).with('foo').yields(dummy_stats)
+      NewRelic::Agent.increment_metric('foo', 12)
+    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/coerce_test.rb

@@ -0,0 +1,65 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require 'new_relic/coerce'
+
+class CoerceTest < Test::Unit::TestCase
+
+  include NewRelic::Coerce
+
+  def test_int_coerce
+    assert_equal 1, int(1)
+    assert_equal 1, int("1")
+    assert_equal 1, int(1.0)
+    assert_equal 1, int(Rational(1, 1))
+    assert_equal 0, int("invalid")
+    assert_equal 0, int(nil)
+
+    # http://ruby-doc.org/core-1.8.7/Symbol.html#method-i-to_i
+    assert_equal 0, int(:wat) unless RUBY_VERSION < '1.9'
+  end
+
+  def test_int_coerce_logs
+    expects_logging(:warn, Not(includes("context")), any_parameters)
+    int("not valid")
+  end
+
+  def test_int_coerce_logs_with_context
+    expects_logging(:warn, all_of(includes("HERE"), includes("Integer")), anything)
+    int("not valid", "HERE")
+  end
+
+
+  def test_float_coerce
+    assert_equal 1.0, float(1.0)
+    assert_equal 1.0, float("1.0")
+    assert_equal 1.0, float(1)
+    assert_equal 1.0, float(Rational(1, 1))
+    assert_equal 0.0, float("invalid")
+    assert_equal 0.0, float(nil)
+    assert_equal 0.0, float(:symbols_are_fun)
+  end
+
+  def test_float_coerce_logs_with_context
+    expects_logging(:warn, all_of(includes("HERE"), includes("Float")), anything)
+    float("not valid", "HERE")
+  end
+
+
+  def test_string_coerce
+    assert_equal "1",      string(1)
+    assert_equal "1.0",    string(1.0)
+    assert_equal "string", string("string")
+    assert_equal "1/100",  string(Rational(1, 100))
+    assert_equal "yeah",   string(:yeah)
+    assert_equal nil,      string(nil)
+    assert_equal "",       string(Unstringable.new)
+  end
+
+  def test_string_coerce_logs_with_context
+    expects_logging(:warn, all_of(includes("HERE"), includes("String")), anything)
+    string(Unstringable.new, "HERE")
+  end
+
+  class Unstringable
+    undef :to_s
+  end
+end

data/test/new_relic/collection_helper_test.rb

@@ -0,0 +1,148 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require 'ostruct'
+require 'active_record_fixtures' if defined?(::ActiveRecord)
+
+require 'new_relic/collection_helper'
+class NewRelic::CollectionHelperTest < Test::Unit::TestCase
+
+  def setup
+    NewRelic::Agent.manual_start
+    super
+  end
+  def teardown
+    super
+  end
+
+  include NewRelic::CollectionHelper
+  def test_string
+    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 128, new_array.size
+    assert_equal '1000', new_array[0]
+  end
+  def test_boolean
+    np = normalize_params('monitor_mode' => false)
+    assert_equal false, np['monitor_mode']
+  end
+  def test_string__singleton
+    val = "This String"
+    def val.hello; end
+    assert_equal "This String", normalize_params(val)
+    assert val.respond_to?(:hello)
+    assert !normalize_params(val).respond_to?(:hello)
+  end
+  class MyString < String; end
+  def test_kind_of_string
+    s = MyString.new "This is a string"
+    assert_equal "This is a string", s.to_s
+    assert_equal MyString, s.class
+    assert_equal String, s.to_s.class
+    params = normalize_params(:val => [s])
+    assert_equal String, params[:val][0].class
+    assert_equal String, flatten(s).class
+    assert_equal String, truncate(s, 2).class
+  end
+  def test_number
+    np = normalize_params({ 'one' => 1.0, 'two' => '2'})
+  end
+  def test_nil
+    np = normalize_params({ nil => 1.0, 'two' => nil})
+    assert_equal "1.0", np['']
+    assert_equal nil, np['two']
+  end
+  def test_hash
+    val = ('A'..'Z').to_a.join * 100
+    assert_equal Hash[(val[0..63] + "...") => (("0"*16384) + "...")], normalize_params({ val => '0' * (16384*2) })
+  end
+  class MyHash < Hash
+
+  end
+  # Test to ensure that hash subclasses are properly converted
+  def test_hash_subclass
+    h = MyHash.new
+    h[:mine] = 'mine'
+    custom_params = { :one => {:hash => { :a => :b}, :myhash => h }}
+    nh = normalize_params(custom_params)
+    myhash = custom_params[:one][:myhash]
+    assert_equal MyHash, myhash.class
+    myhash = nh[:one][:myhash]
+    assert_equal Hash, myhash.class
+  end
+
+
+
+  def test_enumerable
+    e = MyEnumerable.new
+    custom_params = { :one => {:hash => { :a => :b}, :myenum => e }}
+    nh = normalize_params(custom_params)
+    myenum = nh[:one][:myenum]
+    assert_match /MyEnumerable/, myenum
+  end
+
+  def test_stringio
+    # Verify StringIO works like this normally:
+    s = StringIO.new "start" + ("foo bar bat " * 1000)
+    val = nil
+    s.each { | entry | val = entry; break }
+    assert_match /^startfoo bar/, val
+
+    # make sure stringios aren't affected by calling normalize_params:
+    s = StringIO.new "start" + ("foo bar bat " * 1000)
+    v = normalize_params({ :foo => s.string })
+    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
+    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
+    with_config(:disable_backtrace_cleanup => true) do
+      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")}")
+    end
+  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