newrelic_rpm 3.5.6.48.beta → 3.5.6.55

data/test/multiverse/suites/sinatra/sinatra_error_tracing_test.rb

@@ -0,0 +1,38 @@
+class SinatraErrorTracingTestApp < Sinatra::Base
+  configure do
+    set :show_exceptions, false
+  end
+
+  get '/will_boom' do
+    raise 'Boom!'
+  end
+
+  error do
+    'We are sorry'
+  end
+end
+
+class SinatraErrorTracingTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+  include ::NewRelic::Agent::Instrumentation::Sinatra
+
+  def app
+    SinatraErrorTracingTestApp
+  end
+
+  def setup
+    ::NewRelic::Agent.manual_start
+    @error_collector = ::NewRelic::Agent.instance.error_collector
+
+    assert(@error_collector.enabled?,
+           'error collector should be enabled')
+  end
+
+  def test_traps_errors
+    get '/will_boom'
+    assert_equal 500, last_response.status
+    assert_equal 'We are sorry', last_response.body
+
+    assert_equal(1, @error_collector.errors.size)
+  end
+end

data/test/multiverse/suites/sinatra/sinatra_test.rb

@@ -8,6 +8,9 @@ class SinatraRouteTestApp < Sinatra::Base
         halt 404 unless boolean
       end
     end
+
+    # treat errors like production for testing purposes
+    set :show_exceptions, false
   end
 
   get '/user/login' do
@@ -18,6 +21,11 @@ class SinatraRouteTestApp < Sinatra::Base
   get '/user/:id', :my_condition => false do |id|
     "Welcome #{id}"
   end
+
+  get '/error' do
+    raise "Uh-oh"
+  end
+
 end
 
 class SinatraTest < Test::Unit::TestCase
@@ -32,6 +40,10 @@ class SinatraTest < Test::Unit::TestCase
     ::NewRelic::Agent.manual_start
   end
 
+  def teardown
+    ::NewRelic::Agent.agent.error_collector.harvest_errors([])
+  end
+
   # https://support.newrelic.com/tickets/24779
   def test_lower_priority_route_conditions_arent_applied_to_higher_priority_routes
     get '/user/login'
@@ -52,4 +64,9 @@ class SinatraTest < Test::Unit::TestCase
     assert metric_names.include?("WebFrontend/WebServer/all")
     assert ::NewRelic::Agent.agent.stats_engine.get_stats("WebFrontend/WebServer/all")
   end
+
+  def test_shown_errors_get_caught
+    get '/error'
+    assert_equal 1, ::NewRelic::Agent.agent.error_collector.errors.size
+  end
 end

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

@@ -183,9 +183,8 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
 
   def test_connect_to_server_gets_config_from_collector
     NewRelic::Agent.manual_start
-    service = NewRelic::FakeService.new
-    NewRelic::Agent::Agent.instance.service = service
-    service.mock['connect'] = {'agent_run_id' => 23, 'config' => 'a lot'}
+    NewRelic::Agent::Agent.instance.service = default_service(
+      :connect => {'agent_run_id' => 23, 'config' => 'a lot'})
 
     response = NewRelic::Agent.agent.connect_to_server
 
@@ -217,13 +216,11 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
 
   def test_logging_collector_messages
     NewRelic::Agent.manual_start
-    service = NewRelic::FakeService.new
-    NewRelic::Agent::Agent.instance.service = service
-    service.mock['connect'] = {
-      'agent_run_id' => 23, 'config' => 'a lot',
-      'messages' => [{ 'message' => 'beep boop', 'level' => 'INFO' },
-                     { 'message' => 'ha cha cha', 'level' => 'WARN' }]
-    }
+    NewRelic::Agent::Agent.instance.service = default_service(
+      :connect => {
+        'messages' => [{ 'message' => 'beep boop', 'level' => 'INFO' },
+                       { 'message' => 'ha cha cha', 'level' => 'WARN' }]
+      })
 
     expects_logging(:info, 'beep boop')
     expects_logging(:warn, 'ha cha cha')
@@ -238,22 +235,6 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     assert_equal 'blah', @service.agent_id
   end
 
-  # no idea why this test leaks in Rails 2.0
-  # will be moved to a multiverse test eventually anyway
-  if !Rails::VERSION::STRING =~ /2\.0.*/
-    def test_set_apdex_t_from_server
-      service = NewRelic::FakeService.new
-      NewRelic::Agent::Agent.instance.service = service
-      service.mock['connect'] = { 'apdex_t' => 0.5 }
-      with_config(:sync_startup => true, :monitor_mode => true,
-                  :license_key => 'a' * 40) do
-        NewRelic::Agent.manual_start
-        assert_equal 0.5, NewRelic::Agent.config[:apdex_t]
-        NewRelic::Agent.shutdown
-      end
-    end
-  end
-
   private
 
   def mocked_control

data/test/new_relic/agent/agent_test.rb

@@ -8,23 +8,13 @@ module NewRelic
       def setup
         super
         @agent = NewRelic::Agent::Agent.new
-        @agent.service = NewRelic::FakeService.new
+        @agent.service = default_service
       end
 
       #
       # Helpers
       #
 
-      def with_config( options )
-        config_source = NewRelic::Agent::Configuration::ManualSource.new( options )
-        NewRelic::Agent.config.apply_config( config_source )
-
-        yield
-
-      ensure
-        NewRelic::Agent.config.remove_config( config_source ) if config_source
-      end
-
       def with_profile(opts)
         profile = NewRelic::Agent::ThreadProfile.new(-1, 0, 0, true)
         profile.aggregate(["chunky.rb:42:in `bacon'"], profile.traces[:other])
@@ -60,8 +50,13 @@ module NewRelic
       end
 
       def test_transmit_data_should_transmit
+        @agent.service.expects(:metric_data).at_least_once
+        @agent.instance_eval { transmit_data }
+      end
+
+      def test_transmit_data_should_use_one_http_handle_per_harvest
+        @agent.service.expects(:session).once
         @agent.instance_eval { transmit_data }
-        assert @agent.service.agent_data.any?
       end
 
       def test_transmit_data_should_close_explain_db_connections
@@ -105,27 +100,20 @@ module NewRelic
 
       def test_harvest_and_send_thread_profile
         profile = with_profile(:finished => true)
+        @agent.service.expects(:profile_data).with(any_parameters)
         @agent.send(:harvest_and_send_thread_profile, false)
-
-        assert_equal([profile],
-                    @agent.service.agent_data \
-                      .find{|data| data.action == :profile_data}.params)
       end
 
       def test_harvest_and_send_thread_profile_when_not_finished
         with_profile(:finished => false)
+        @agent.service.expects(:profile_data).never
         @agent.send(:harvest_and_send_thread_profile, false)
-
-        assert_nil @agent.service.agent_data.find{|data| data.action == :profile_data}
       end
 
       def test_harvest_and_send_thread_profile_when_not_finished_but_disconnecting
         profile = with_profile(:finished => false)
+        @agent.service.expects(:profile_data).with(any_parameters)
         @agent.send(:harvest_and_send_thread_profile, true)
-
-        assert_equal([profile],
-                     @agent.service.agent_data \
-                       .find{|data| data.action == :profile_data}.params)
       end
 
       def test_harvest_timeslice_data
@@ -158,8 +146,8 @@ module NewRelic
       end
 
       def test_check_for_agent_commands
+        @agent.service.expects(:get_agent_commands).returns([]).once
         @agent.send :check_for_agent_commands
-        assert_equal(1, @agent.service.calls_for(:get_agent_commands).size)
       end
 
       def test_merge_data_from_empty
@@ -218,18 +206,26 @@ module NewRelic
         assert_equal(1, @agent.unsent_timeslice_data, "should have the key from above")
       end
 
-      def test_merge_data_from_all_three_empty
-        unsent_timeslice_data = mock('unsent timeslice data')
-        unsent_errors = mock('unsent errors')
+      def test_merge_data_traces
         unsent_traces = mock('unsent traces')
         @agent.instance_eval {
-          @unsent_errors = unsent_errors
-          @unsent_timeslice_data = unsent_timeslice_data
           @traces = unsent_traces
         }
         unsent_traces.expects(:+).with([1,2,3])
-        unsent_errors.expects(:+).with([4,5,6])
-        @agent.merge_data_from([{}, [1,2,3], [4,5,6]])
+        @agent.merge_data_from([{}, [1,2,3], []])
+      end
+
+      def test_merge_data_from_abides_by_error_queue_limit
+        errors = []
+        40.times { |i| errors << Exception.new("boo #{i}") }
+
+        @agent.merge_data_from([{}, [], errors])
+
+        assert_equal 20, @agent.error_collector.errors.length
+
+        # This method should NOT increment error counts, since that has already
+        # been counted in the child
+        assert_equal 0, NewRelic::Agent.get_stats("Errors/all").call_count
       end
 
       def test_fill_metric_id_cache_from_collect_response
@@ -275,7 +271,7 @@ module NewRelic
       end
 
       def test_connect_does_not_retry_on_license_error
-        @agent.service.stubs(:connect).raises(NewRelic::Agent::LicenseException)
+        @agent.service.expects(:connect).raises(NewRelic::Agent::LicenseException)
         @agent.send(:connect)
         assert(@agent.disconnected?)
       end

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -373,7 +373,7 @@ var e=document.createElement("script");'
   end
 
   def test_place_beacon_payload_head_when_given_mobile_request_header
-    Time.stubs(:now).returns(6)
+    Time.stubs(:now).returns(Time.at(6))
     response = mobile_transaction
     txn_name = obfuscate(NewRelic::Agent.instance.beacon_configuration,
                          browser_monitoring_transaction_name)

data/test/new_relic/agent/error_collector_test.rb

@@ -186,7 +186,23 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     end
   end
 
+  def test_increments_count_on_errors
+    expects_error_count_increase(1) do
+      @error_collector.notice_error(StandardError.new("Boo"))
+    end
+  end
+
   private
+
+  def expects_error_count_increase(increase)
+    count = get_error_stats
+    yield
+    assert_equal increase, get_error_stats - count
+  end
+
+  def get_error_stats
+    NewRelic::Agent.get_stats("Errors/all").call_count
+  end
   
   def wrapped_filter_proc
     Proc.new do |e|

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

@@ -4,7 +4,7 @@ module NewRelic::Agent::Instrumentation
   class BrowserMonitoringTimingsTest < Test::Unit::TestCase
 
     def setup
-      Time.stubs(:now).returns(2000)
+      Time.stubs(:now).returns(Time.at(2000))
       @transaction = stub(
         :transaction_name => "Name",
         :start_time => 0

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