wd_newrelic_rpm 3.5.5 → 3.5.6

data/test/new_relic/agent/instrumentation/task_instrumentation_test.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'test_contexts'))
 
 class NewRelic::Agent::Instrumentation::TaskInstrumentationTest < Test::Unit::TestCase
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation

data/test/new_relic/agent/new_relic_service_test.rb

@@ -1,6 +1,62 @@
 require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_helper'))
 require 'new_relic/agent/thread_profiler'
 
+# Tests of HTTP Keep Alive implementation that require a different setup and
+# set of mocks.
+class NewRelicServiceKeepAliveTest < Test::Unit::TestCase
+  def setup
+    @server = NewRelic::Control::Server.new('somewhere.example.com',
+                                            30303, '10.10.10.10')
+    @service = NewRelic::Agent::NewRelicService.new('license-key', @server)
+  end
+
+  def stub_net_http_handle(overrides = {})
+    stub('http_handle', :start => true, :finish => true, :address => '10.10.10.10', :port => 30303)
+  end
+
+  def test_session_block_reuses_http_handle
+    handle1 = stub_net_http_handle
+    handle2 = stub_net_http_handle
+    @service.stubs(:create_http_connection).returns(handle1, handle2)
+
+    block_ran = false
+    @service.session do
+      block_ran = true
+      assert(@service.http_connection)
+
+      # check we get the same object back each time we call http_connection in the block
+      assert_equal(@service.http_connection.object_id, handle1.object_id)
+      assert_equal(@service.http_connection.object_id, handle1.object_id)
+    end
+    assert(block_ran)
+  end
+
+  def test_multiple_http_handles_are_used_outside_session_block
+    handle1 = stub_net_http_handle
+    handle2 = stub_net_http_handle
+    @service.stubs(:create_http_connection).returns(handle1, handle2)
+    assert_equal(@service.http_connection.object_id, handle1.object_id)
+    assert_equal(@service.http_connection.object_id, handle2.object_id)
+  end
+
+
+  def test_session_starts_and_finishes_http_session
+    handle1 = stub_net_http_handle
+    handle1.expects(:start).once
+    handle1.expects(:finish).once
+    @service.stubs(:create_http_connection).returns(handle1)
+
+    block_ran = false
+    @service.session do
+      block_ran = true
+      # mocks expect #start and #finish to be called.  This is how Net::HTTP
+      # implements keep alive
+    end
+    assert(block_ran)
+  end
+
+end
+
 class NewRelicServiceTest < Test::Unit::TestCase
   def initialize(*_)
     [ :HTTPSuccess,
@@ -27,7 +83,7 @@ class NewRelicServiceTest < Test::Unit::TestCase
                                             30303, '10.10.10.10')
     @service = NewRelic::Agent::NewRelicService.new('license-key', @server)
     @http_handle = HTTPHandle.new
-    NewRelic::Control.instance.stubs(:http_connection).returns(@http_handle)
+    @service.stubs(:create_http_connection).returns(@http_handle)
 
     @http_handle.respond_to(:get_redirect_host, 'localhost')
     connect_response = {
@@ -43,6 +99,43 @@ class NewRelicServiceTest < Test::Unit::TestCase
     end
   end
 
+  def test_cert_file_path
+    assert @service.cert_file_path
+    assert_equal File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'cert', 'cacert.pem')), @service.cert_file_path
+  end
+
+  # This test does not actually use the ruby agent in any way - it's
+  # testing that the CA file we ship actually validates our server's
+  # certificate. It's used for customers who enable verify_certificate
+  def test_cert_file
+    require 'socket'
+    require 'openssl'
+
+    s   = TCPSocket.new 'collector.newrelic.com', 443
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.ca_file = @service.cert_file_path
+    ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    s   = OpenSSL::SSL::SSLSocket.new s, ctx
+    s.connect
+    # should not raise an error
+  end
+
+  # see above, but for staging, as well. This allows us to test new
+  # certificates in a non-customer-facing place before setting them
+  # live.
+  def test_staging_cert_file
+    require 'socket'
+    require 'openssl'
+
+    s   = TCPSocket.new 'staging-collector.newrelic.com', 443
+    ctx = OpenSSL::SSL::SSLContext.new
+    ctx.ca_file = @service.cert_file_path
+    ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    s   = OpenSSL::SSL::SSLSocket.new s, ctx
+    s.connect
+    # should not raise an error
+  end
+
   def test_initialize_uses_correct_license_key_settings
     with_config(:license_key => 'abcde') do
       service = NewRelic::Agent::NewRelicService.new
@@ -65,7 +158,7 @@ class NewRelicServiceTest < Test::Unit::TestCase
   def test_connect_resets_cached_ip_address
     assert_equal '10.10.10.10', @service.collector.ip
     @service.connect
-    assert_nil @service.collector.ip # 'localhost' resolves to nil
+    assert_equal 'localhost', @service.collector.ip # 'localhost' resolves to nil
   end
 
   def test_connect_uses_proxy_collector_if_no_redirect_host

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -77,9 +77,9 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
       sampler.notice_error(Exception.new("message"), :uri => '/myurl/',
                            :metric => 'path', :referer => 'test_referer',
                            :request_params => {:x => 'y'})
-      NewRelic::Agent.agent.merge_data_from([nil, nil, [sampler.errors]])
+      NewRelic::Agent.agent.merge_data_from([nil, nil, sampler.errors])
 
-      assert_equal(1, NewRelic::Agent.agent.unsent_errors_size)
+      assert_equal(1, NewRelic::Agent.agent.error_collector.errors.size)
 
       listener = start_listener_with_pipe(668)
 
@@ -94,7 +94,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Test::Unit::TestCase
       Process.wait(pid)
       listener.stop
 
-      assert_equal(2, NewRelic::Agent.agent.unsent_errors_size)
+      assert_equal(2, NewRelic::Agent.agent.error_collector.errors.size)
     end
 
     def test_close_pipe_on_EOF_string

data/test/new_relic/agent/pipe_service_test.rb

@@ -14,7 +14,27 @@ class PipeServiceTest < Test::Unit::TestCase
   def test_connect_returns_nil
     assert_nil @service.connect({}) 
   end
-  
+
+  # a #session method is required of services, though in the case of the
+  # PipeService all it does is invoke the block it's passed.
+  def test_session_invokes_block
+    block_ran = false
+    @service.session do
+      block_ran = true
+    end
+    assert(block_ran)
+  end
+
+  def test_write_to_missing_pipe_logs_error
+    service = NewRelic::Agent::PipeService.new(:non_existant)
+    ::NewRelic::Agent.logger.expects(:error) \
+      .with(regexp_matches(/Unable to send data to parent process/)).once
+
+    assert_nothing_raised do
+      service.metric_data(Time.now, Time.now, {})
+    end
+  end
+
   if NewRelic::LanguageSupport.can_fork? &&
       !NewRelic::LanguageSupport.using_version?('1.9.1')
 

data/test/new_relic/agent/rpm_agent_test.rb

@@ -1,5 +1,6 @@
 ENV['SKIP_RAILS'] = 'true'
 require File.expand_path('../../../test_helper', __FILE__)
+require File.expand_path('../../../test_contexts', __FILE__)
 
 class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::TestCase
   extend TestContexts
@@ -85,7 +86,6 @@ class NewRelic::Agent::RpmAgentTest < Test::Unit::TestCase # ActiveSupport::Test
     should "send_timeslice_data" do
       # this test fails due to a rubinius bug
       return if NewRelic::LanguageSupport.using_engine?('rbx')
-      @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] ])

data/test/new_relic/agent/sql_sampler_test.rb

@@ -214,4 +214,24 @@ class NewRelic::Agent::SqlSamplerTest < Test::Unit::TestCase
       assert_equal expected, sql_traces[0].to_collector_array(marshaller.default_encoder)
     end
   end
+
+  def test_to_collector_array_with_bad_values
+    slow = NewRelic::Agent::SlowSql.new("query", "transaction", {}, Rational(12, 1))
+    trace = NewRelic::Agent::SqlTrace.new("query", slow, "path", "uri")
+    trace.call_count = Rational(10, 1)
+    trace.instance_variable_set(:@sql_id, "1234")
+
+    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
+      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+    else
+      marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+    end
+
+    params = RUBY_VERSION >= '1.9.2' ? "eJyrrgUAAXUA+Q==\n" : {}
+    expected = [ "path", "uri", 1234, "query", "transaction",
+                 10, 12000, 12000, 12000, params]
+
+    assert_equal expected, trace.to_collector_array(marshaller.default_encoder)
+  end
+
 end

data/test/new_relic/agent/thread_profiler_test.rb

@@ -210,7 +210,11 @@ class ThreadProfileTest < ThreadedTest
       "irb:12:in `<main>'"
     ]
 
-    @profile = NewRelic::Agent::ThreadProfile.new(-1, 0.029, 0.01, true)
+    # Run the worker_loop for the thread profile based on two iterations
+    # This takes time fussiness out of the equation and keeps the tests stable
+    ignored_duration = 666
+    @profile = NewRelic::Agent::ThreadProfile.new(-1, ignored_duration, 0.01, true)
+    @profile.instance_variable_set(:@worker_loop, NewRelic::Agent::WorkerLoop.new(:limit => 2))
   end
 
   # Running Tests
@@ -426,12 +430,7 @@ class ThreadProfileTest < ThreadedTest
     assert_equal [], @profile.traces[:other][0].children
   end
 
-  def test_to_collector_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)
-
+  def build_well_known_trace
     trace = ["thread_profiler.py:1:in `<module>'"]
     10.times { @profile.aggregate(trace, @profile.traces[:other]) }
 
@@ -443,13 +442,24 @@ class ThreadProfileTest < ThreadedTest
       "thread_profiler.py:103:in `_run_profiler'",
       "thread_profiler.py:165:in `collect_thread_stacks'"]
     10.times { @profile.aggregate(trace, @profile.traces[:agent]) }
+  end
+
+  WELL_KNOWN_TRACE_ENCODED = "eJy9klFPwjAUhf/LfW7WDQTUGBPUiYkGdAxelqXZRpGGrm1uS8xi/O924JQX\n9Un7dm77ndN7c19hlt7FCZxnWQZug7xYMYN6LSTHwDRA4KLWq53kl0CinEQh\nCUmW5zmBJH5axPPUk16MJ/E0/cGk0lLyyrGPS+uKamu943DQeX5HMtypz5In\nwv6vRCeZ1NoAGQ2PCDpvrOM1fRAlFtjQWyxq/qJxa+lj4zZaBeuuQpccrdDK\n0l4wolKU1OxftOoQLNTzIdL/EcjJafjnQYyVWjvrsDBMKNVOZBD1/jO27fPs\naBG+DoGr8fX9JJktpjftVry9A9unzGo=\n"
+
+  def test_to_collector_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)
+
+    build_well_known_trace
  
     expected = [[
           -1, 
           1350403938892.524, 
           1350403939904.375, 
           10, 
-          "eJy9klFPwjAUhf/LfW7WDQTUGBPUiYkGdAxelqXZRpGGrm1uS8xi/O924JQX\n9Un7dm77ndN7c19hlt7FCZxnWQZug7xYMYN6LSTHwDRA4KLWq53kl0CinEQh\nCUmW5zmBJH5axPPUk16MJ/E0/cGk0lLyyrGPS+uKamu943DQeX5HMtypz5In\nwv6vRCeZ1NoAGQ2PCDpvrOM1fRAlFtjQWyxq/qJxa+lj4zZaBeuuQpccrdDK\n0l4wolKU1OxftOoQLNTzIdL/EcjJafjnQYyVWjvrsDBMKNVOZBD1/jO27fPs\naBG+DoGr8fX9JJktpjftVry9A9unzGo=\n",
+          WELL_KNOWN_TRACE_ENCODED,
           2, 
           0
       ]]
@@ -457,6 +467,29 @@ class ThreadProfileTest < ThreadedTest
     marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
     assert_equal expected, @profile.to_collector_array(marshaller.default_encoder)
   end
+
+  def test_to_collector_array_with_bad_values
+    @profile.instance_variable_set(:@profile_id, "-1")
+    @profile.instance_variable_set(:@start_time, "")
+    @profile.instance_variable_set(:@stop_time, nil)
+    @profile.instance_variable_set(:@poll_count, Rational(10, 1))
+    @profile.instance_variable_set(:@sample_count, nil)
+
+    build_well_known_trace
+
+    expected = [[
+          -1,
+          0.0,
+          0.0,
+          10,
+          WELL_KNOWN_TRACE_ENCODED,
+          0,
+          0
+      ]]
+
+    marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+    assert_equal expected, @profile.to_collector_array(marshaller.default_encoder)
+  end
 end
 
 class ThreadProfileNodeTest < Test::Unit::TestCase
@@ -492,6 +525,18 @@ class ThreadProfileNodeTest < Test::Unit::TestCase
       node.to_array)
   end
 
+  def test_gracefully_handle_bad_values_in_to_array
+    node = NewRelic::Agent::ThreadProfile::Node.new(SINGLE_LINE)
+    node.instance_variable_set(:@line_no, "blarg")
+    node.runnable_count = Rational(10, 1)
+
+    assert_equal([
+         ["irb.rb", "catch", 0],
+         10, 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)

data/test/new_relic/agent/worker_loop_test.rb

@@ -18,6 +18,11 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
 
   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
@@ -26,6 +31,15 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     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
@@ -33,21 +47,6 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
     assert_equal 2, iterations
   end
 
-  def test_density
-    # This shows how the tasks stay aligned with the period and don't drift.
-    count = 0
-    start = Time.now
-    @worker_loop.run(0.03) do
-      count +=1
-      if count == 3
-        @worker_loop.stop
-        next
-      end
-    end
-    elapsed = Time.now - start
-    assert_in_delta 0.09, elapsed, 0.03
-  end
-
   def test_task_error__standard
     expects_logging(:error, any_parameters)
     # This loop task will run twice
@@ -71,11 +70,15 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
   end
 
   def test_task_error__server
-    expects_no_logging(:error, any_parameters)
+    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).to_a
+  end
 end

data/test/new_relic/agent_test.rb

@@ -31,6 +31,7 @@ module NewRelic
 
     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]
@@ -70,7 +71,6 @@ module NewRelic
       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::Agent.instance.service = NewRelic::FakeService.new
           NewRelic::Agent.manual_start(:license_key => ('1234567890' * 4),
                                        :start_channel_listener => true)
 
@@ -120,7 +120,6 @@ module NewRelic
 
     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

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