newrelic_rpm 3.5.6.48.beta → 3.5.6.55

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

@@ -32,16 +32,12 @@ class NewRelic::Agent::WorkerLoopTest < Test::Unit::TestCase
   end
 
   def test_duration_clock_starts_with_run
-    # Purposefully testing time, but shouldn't be particularly fragile
+    # 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)
-    sleep 0.02
+    assert_nil worker_loop.instance_variable_get(:@deadline)
 
-    called = false
-    worker_loop.run(0.001) do
-      called = true
-    end
-
-    assert(called, "Didn't run the loop even once")
+    worker_loop.run(0.001) {}
+    assert !worker_loop.instance_variable_get(:@deadline).nil?
   end
 
   def test_loop_limit

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

data/test/new_relic/command/deployments_test.rb

@@ -79,6 +79,6 @@ class NewRelic::Command::DeploymentsTest < Test::Unit::TestCase
     @mock_response = mock()
     @mock_response.expects(:is_a?).with(Net::HTTPSuccess).returns(true)
     mock_connection.expects(:request).returns(@mock_response)
-    NewRelic::Control.instance.stubs(:http_connection).returns(mock_connection)
+    NewRelic::Agent::NewRelicService.any_instance.stubs(:http_connection).returns(mock_connection)
   end
 end

data/test/new_relic/control_test.rb

@@ -12,42 +12,6 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     NewRelic::Agent.shutdown
   end
 
-  def test_cert_file_path
-    assert @control.cert_file_path
-    assert_equal File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'cert', 'cacert.pem')), @control.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 = @control.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 = @control.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_test_config
     if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 4
@@ -87,22 +51,30 @@ class NewRelic::ControlTest < Test::Unit::TestCase
   end
 
   def test_resolve_ip_for_localhost
-    assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    with_config(:ssl => false, :verify_certificate => false) do
+      assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    end
   end
 
   def test_resolve_ip_for_non_existent_domain
-    Resolv.stubs(:getaddress).raises(Resolv::ResolvError)
-    IPSocket.stubs(:getaddress).raises(SocketError)
-    assert_equal nil, control.send(:convert_to_ip_address, 'q1239988737.us')
+    with_config(:ssl => false, :verify_certificate => false) do
+      Resolv.stubs(:getaddress).raises(Resolv::ResolvError)
+      IPSocket.stubs(:getaddress).raises(SocketError)
+      assert_equal nil, control.send(:convert_to_ip_address, 'q1239988737.us')
+    end
   end
 
   def test_resolves_valid_ip
-    Resolv.stubs(:getaddress).with('collector.newrelic.com').returns('204.93.223.153')
-    assert_equal '204.93.223.153', control.send(:convert_to_ip_address, 'collector.newrelic.com')
+    with_config(:ssl => false, :verify_certificate => false) do
+      Resolv.stubs(:getaddress).with('collector.newrelic.com').returns('204.93.223.153')
+      assert_equal '204.93.223.153', control.send(:convert_to_ip_address, 'collector.newrelic.com')
+    end
   end
 
   def test_do_not_resolve_if_we_need_to_verify_a_cert
-    assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    with_config(:ssl => false, :verify_certificate => false) do
+      assert_equal nil, control.send(:convert_to_ip_address, 'localhost')
+    end
     with_config(:ssl => true, :verify_certificate => true) do
       assert_equal 'localhost', control.send(:convert_to_ip_address, 'localhost')
     end
@@ -144,7 +116,10 @@ class NewRelic::ControlTest < Test::Unit::TestCase
     old_ipsocket = IPSocket
     Object.instance_eval { remove_const :Resolv}
     Object.instance_eval {remove_const:'IPSocket' }
-    assert_equal(nil, control.send(:convert_to_ip_address, 'collector.newrelic.com'), "DNS is down, should be no IP for server")
+
+    with_config(:ssl => false, :verify_certificate => false) do
+      assert_equal(nil, control.send(:convert_to_ip_address, 'collector.newrelic.com'), "DNS is down, should be no IP for server")
+    end
 
     Object.instance_eval {const_set('Resolv', old_resolv); const_set('IPSocket', old_ipsocket)}
     # these are here to make sure that the constant tomfoolery above

data/test/new_relic/fake_collector.rb

@@ -92,8 +92,9 @@ module NewRelic
           begin
           ::Rack::Handler::WEBrick.run(self,
                                        :Port => port,
-                                       :Logger => WEBrick::Log.new("/dev/null"),
-                                       :AccessLog => [nil, nil])
+                                       :Logger => ::WEBrick::Log.new("/dev/null"),
+                                       :AccessLog => [ ['/dev/null', ::WEBrick::AccessLog::COMMON_LOG_FORMAT] ]
+                                      )
           rescue Errno::EADDRINUSE => ex
             msg = "Port #{port} for FakeCollector was in use"
             if !@seen_port_failure

data/test/new_relic/local_environment_test.rb

@@ -53,7 +53,7 @@ class NewRelic::LocalEnvironmentTest < Test::Unit::TestCase
     assert_equal 0, s.size
     e.gather_environment_info
     s = e.snapshot
-    assert_match /1\.(8\.[67]|9\.\d)/, s.assoc('Ruby version').last, s.inspect
+    assert_match /1\.8\.[67]|1\.9\.|2\.0/, s.assoc('Ruby version').last, s.inspect
     assert_equal 'test', s.assoc('Framework').last, s.inspect
     # Make sure the processor count is determined on linux systems
     if File.exists? '/proc/cpuinfo'

data/test/new_relic/metric_data_test.rb

@@ -151,4 +151,33 @@ class NewRelic::MetricDataTest < Test::Unit::TestCase
     expected = [ 1234, [2, 3.0, 2.0, 1.0, 2.0, 5.0] ]
     assert_equal expected, md.to_collector_array
   end
+
+  # Rationals in metric data? -- https://support.newrelic.com/tickets/28053
+  def test_to_collector_array_with_rationals
+    stats = NewRelic::MethodTraceStats.new
+    stats.call_count = Rational(1, 1)
+    stats.total_call_time = Rational(2, 1)
+    stats.total_exclusive_time = Rational(3, 1)
+    stats.min_call_time = Rational(4, 1)
+    stats.max_call_time = Rational(5, 1)
+    stats.sum_of_squares = Rational(6, 1)
+
+    md = NewRelic::MetricData.new(nil, stats, 1234)
+    expected = [1234, [1, 2.0, 3.0, 4.0, 5.0, 6.0]]
+    assert_equal expected, md.to_collector_array
+  end
+
+  def test_to_collector_array_with_bad_values
+    stats = NewRelic::MethodTraceStats.new
+    stats.call_count = nil
+    stats.total_call_time = "junk"
+    stats.total_exclusive_time = Object.new
+    stats.min_call_time = []
+    stats.max_call_time = {}
+    stats.sum_of_squares = Exception.new("Boo")
+
+    md = NewRelic::MetricData.new(nil, stats, 1234)
+    expected = [1234, [0, 0, 0, 0, 0, 0]]
+    assert_equal expected, md.to_collector_array
+  end
 end

data/test/new_relic/noticed_error_test.rb

@@ -16,6 +16,14 @@ class NewRelic::Agent::NoticedErrorTest < Test::Unit::TestCase
     assert_equal expected, error.to_collector_array
   end
 
+  def test_to_collector_array_with_bad_values
+    error = NewRelic::NoticedError.new(@path, @params, nil, Rational(10, 1))
+    expected = [
+      10_000.0, @path, "<no message>", "Error", @params
+    ]
+    assert_equal expected, error.to_collector_array
+  end
+
   def test_handles_non_string_exception_messages
     e = Exception.new({ :non => :string })
     error = NewRelic::NoticedError.new(@path, @params, e, @time)