wd_newrelic_rpm 3.5.5 → 3.5.6

data/test/multiverse/suites/resque/resque_setup.rb

@@ -0,0 +1,15 @@
+require 'resque'
+require 'newrelic_rpm'
+
+redis_port = ENV["NEWRELIC_MULTIVERSE_REDIS_PORT"]
+$redis = Redis.new(:port => redis_port)
+Resque.redis = $redis
+
+class JobForTesting
+  @queue = :resque_test
+
+  def self.perform(key, val, sleep_duration=0)
+    sleep sleep_duration
+    $redis.set(key, val)
+  end
+end

data/test/multiverse/suites/sinatra/config/newrelic.yml

@@ -12,7 +12,7 @@ development:
   app_name: test
   host: 127.0.0.1
   api_host: 127.0.0.1
-  port: 30303
+  port: <%= 30_000 + ($$ % 10_000) %>
   transaction_tracer:
     record_sql: obfuscated
     enabled: true
@@ -20,5 +20,4 @@ development:
     transaction_threshold: 1.0
   capture_params: false
   log_level: debug
-  #log_file_path: STDOUT
   disable_serialization: false

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/multiverse/test/suite_examples/one/a/config/newrelic.yml

@@ -13,7 +13,7 @@ development:
   app_name: test
   host: 127.0.0.1
   api_host: 127.0.0.1
-  port: 30303
+  port: <%= 30_000 + ($$ % 10_000) %>
   transaction_tracer:
     record_sql: obfuscated
     enabled: true

data/test/multiverse/test/suite_examples/one/b/config/newrelic.yml

@@ -13,7 +13,7 @@ development:
   app_name: test
   host: 127.0.0.1
   api_host: 127.0.0.1
-  port: 30303
+  port: <%= 30_000 + ($$ % 10_000) %>
   transaction_tracer:
     record_sql: obfuscated
     enabled: true

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

@@ -8,7 +8,7 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   def setup
     @connected = nil
     @keep_retrying = nil
-    @connect_attempts = 1
+    @connect_attempts = 0
     @connect_retry_period = 0
     @transaction_sampler = NewRelic::Agent::TransactionSampler.new
     @sql_sampler = NewRelic::Agent::SqlSampler.new
@@ -33,76 +33,35 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     fake_control
   end
 
-  def test_tried_to_connect?
-    # base case, should default to false
-    assert !tried_to_connect?({})
+  def test_should_connect_if_pending
+    @connect_state = :pending
+    assert(should_connect?, "should attempt to connect if pending")
   end
 
-  def test_tried_to_connect_connected
-    # is true if connected is true.
-    @connected = true
-    assert tried_to_connect?({})
+  def test_should_not_connect_if_disconnected
+    @connect_state = :disconnected
+    assert(!should_connect?, "should not attempt to connect if force disconnected")
   end
 
-  def test_tried_to_connect_forced
-    # is false if force_reconnect is true
-    assert !tried_to_connect?({:force_reconnect => true})
-  end
-
-  def test_should_keep_retrying_base
-    # default to true
-    should_keep_retrying?({})
-    assert @keep_retrying, "should keep retrying by default"
-  end
-
-  def test_should_keep_retrying_option_true
-    # should be true if keep_retrying is true
-    should_keep_retrying?({:keep_retrying => true})
-  end
-
-  def test_get_retry_period
-    (1..6).each do |x|
-      @connect_attempts = x
-      assert_equal get_retry_period, x * 60, "should be #{x} minutes"
-    end
-    @connect_attempts = 100
-    assert_equal get_retry_period, 600, "should max out at 10 minutes after 6 tries"
+  def test_should_connect_if_forced
+    @connect_state = :disconnected
+    assert(should_connect?(true), "should connect if forced")
+    @connect_state = :connected
+    assert(should_connect?(true), "should connect if forced")
   end
 
   def test_increment_retry_period
-    @connect_retry_period = 0
-    @connect_attempts = 1
-    assert_equal 0, connect_retry_period
-    increment_retry_period!
-    assert_equal 60, connect_retry_period
-  end
-
-  def test_should_retry_true
-    @keep_retrying = true
-    @connect_attempts = 1
-    self.expects(:increment_retry_period!).once
-    assert should_retry?, "should retry in this circumstance"
-    assert_equal 2, @connect_attempts, "should be on the second attempt"
-  end
-
-  def test_should_retry_false
-    @keep_retrying = false
-    self.expects(:disconnect).once
-    assert !should_retry?
+    10.times do |i|
+      assert_equal((i * 60), connect_retry_period)
+      note_connect_failure
+    end
+    assert_equal(600, connect_retry_period)
   end
 
   def test_disconnect
     assert disconnect
   end
 
-  def test_attr_accessor_connect_retry_period
-    assert_accessor(:connect_retry_period)
-  end
-
-  def test_attr_accessor_connect_attempts
-    assert_accessor(:connect_attempts)
-  end
-
   def test_log_error
     error = StandardError.new("message")
 
@@ -224,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
 
@@ -242,8 +200,6 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
       'collect_traces' => true,
       'collect_errors' => true,
       'sample_rate' => 10,
-      'cross_process_id' => '1#234',
-      'encoding_key'     => 'a' * 30,
       'agent_config' => { 'transaction_tracer.record_sql' => 'raw' }
     }
     self.expects(:log_connection!).with(config)
@@ -253,26 +209,18 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     with_config(:'transaction_tracer.enabled' => true) do
       finish_setup(config)
       assert_equal 'fishsticks', @service.agent_id
-      assert_equal '1#234', @cross_process_id
-      assert_equal 'a'  * 30, @cross_process_encoding_key
-      assert_equal [97] * 30, @cross_process_encoding_bytes
       assert_equal 'raw', NewRelic::Agent.config[:'transaction_tracer.record_sql']
     end
   end
 
-  def test_get_bytes_with_nil
-    assert_equal [], get_bytes(nil)
-  end
 
   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')
@@ -287,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
@@ -316,12 +248,4 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     self.stubs(:error_collector).returns(fake_collector)
     fake_collector
   end
-
-  def assert_accessor(sym)
-    var_name = "@#{sym}"
-    instance_variable_set(var_name, 1)
-    assert (self.send(sym) == 1)
-    self.send(sym.to_s + '=', 10)
-    assert (instance_variable_get(var_name) == 10)
-  end
 end

data/test/new_relic/agent/agent/start_worker_thread_test.rb

@@ -6,7 +6,7 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
   def test_deferred_work_connects
     self.expects(:catch_errors).yields
     self.expects(:connect).with('connection_options')
-    @connected = true
+    self.stubs(:connected?).returns(true)
     self.expects(:log_worker_loop_start)
     self.expects(:create_and_run_worker_loop)
     deferred_work!('connection_options')
@@ -15,7 +15,7 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
   def test_deferred_work_connect_failed
     self.expects(:catch_errors).yields
     self.expects(:connect).with('connection_options')
-    @connected = false
+    self.stubs(:connected?).returns(false)
     deferred_work!('connection_options')
   end
 
@@ -43,7 +43,7 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
     handle_force_restart(error)
 
     assert_equal({}, @metric_ids)
-    assert @connected.nil?
+    assert_equal(:pending, @connect_state)
   end
 
   def test_handle_force_disconnect

data/test/new_relic/agent/agent_test.rb

@@ -4,22 +4,59 @@ require 'new_relic/agent/thread_profiler'
 module NewRelic
   module Agent
     class AgentTest < Test::Unit::TestCase
+
       def setup
         super
         @agent = NewRelic::Agent::Agent.new
-        @agent.service = NewRelic::FakeService.new
+        @agent.service = default_service
       end
 
+      #
+      # Helpers
+      #
+
+      def with_profile(opts)
+        profile = NewRelic::Agent::ThreadProfile.new(-1, 0, 0, true)
+        profile.aggregate(["chunky.rb:42:in `bacon'"], profile.traces[:other])
+        profile.instance_variable_set(:@finished, opts[:finished])
+
+        @agent.thread_profiler.instance_variable_set(:@profile, profile)
+        profile
+      end
+
+      #
+      # Tests
+      #
+
       def test_after_fork_reporting_to_channel
+        @agent.stubs(:connected?).returns(true)
         @agent.after_fork(:report_to_channel => 123)
         assert(@agent.service.kind_of?(NewRelic::Agent::PipeService),
                'Agent should use PipeService when directed to report to pipe channel')
+        NewRelic::Agent::PipeService.any_instance.expects(:shutdown).never
         assert_equal 123, @agent.service.channel_id
       end
 
+      def test_after_fork_should_close_pipe_if_parent_not_connected
+        pipe = mock
+        pipe.expects(:write).with('EOF')
+        pipe.expects(:close)
+        dummy_channels = { 123 => pipe }
+        NewRelic::Agent::PipeChannelManager.stubs(:channels).returns(dummy_channels)
+
+        @agent.stubs(:connected?).returns(false)
+        @agent.after_fork(:report_to_channel => 123)
+        assert(@agent.disconnected?)
+      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
@@ -57,43 +94,26 @@ module NewRelic
 
       def test_graceful_shutdown_ends_thread_profiling
         @agent.thread_profiler.expects(:stop).once
-        @agent.instance_variable_set(:@connected, true)
-
+        @agent.stubs(:connected?).returns(true)
         @agent.send(:graceful_disconnect)
       end
 
       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 with_profile(opts)
-        profile = NewRelic::Agent::ThreadProfile.new(-1, 0, 0, true)
-        profile.aggregate(["chunky.rb:42:in `bacon'"], profile.traces[:other])
-        profile.instance_variable_set(:@finished, opts[:finished])
-
-        @agent.thread_profiler.instance_variable_set(:@profile, profile)
-        profile
       end
 
       def test_harvest_timeslice_data
@@ -126,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
@@ -186,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
@@ -221,6 +249,73 @@ module NewRelic
         assert_equal 10,   @agent.metric_ids[MetricSpec.new('WebFrontend/QueueTime')]
         assert_equal 1017, @agent.metric_ids[MetricSpec.new('ActiveRecord/Blog/find')]
       end
+
+      def test_connect_retries_on_timeout
+        service = @agent.service
+        def service.connect(opts={})
+          unless @tried
+            @tried = true
+            raise Timeout::Error
+          end
+          nil
+        end
+        @agent.stubs(:connect_retry_period).returns(0)
+        @agent.send(:connect)
+        assert(@agent.connected?)
+      end
+
+      def test_connect_does_not_retry_if_keep_retrying_false
+        @agent.service.expects(:connect).once.raises(Timeout::Error)
+        @agent.send(:connect, :keep_retrying => false)
+        assert(@agent.disconnected?)
+      end
+
+      def test_connect_does_not_retry_on_license_error
+        @agent.service.expects(:connect).raises(NewRelic::Agent::LicenseException)
+        @agent.send(:connect)
+        assert(@agent.disconnected?)
+      end
+
+      def test_connect_does_not_reconnect_by_default
+        @agent.stubs(:connected?).returns(true)
+        @agent.service.expects(:connect).never
+        @agent.send(:connect)
+      end
+
+      def test_connect_does_not_reconnect_if_disconnected
+        @agent.stubs(:disconnected?).returns(true)
+        @agent.service.expects(:connect).never
+        @agent.send(:connect)
+      end
+
+      def test_connect_does_reconnect_if_forced
+        @agent.stubs(:connected?).returns(true)
+        @agent.service.expects(:connect)
+        @agent.send(:connect, :force_reconnect => true)
+      end
+
+      def test_defer_start_if_resque_dispatcher_and_channel_manager_isnt_started
+        NewRelic::Agent::PipeChannelManager.listener.expects(:started?).returns(false)
+
+        # :send_data_on_exit setting to avoid setting an at_exit
+        with_config( :send_data_on_exit => false, :dispatcher => :resque ) do
+          @agent.start
+        end
+
+        assert !@agent.started?
+      end
+
+      def test_doesnt_defer_start_if_resque_dispatcher_and_channel_manager_started
+        NewRelic::Agent::PipeChannelManager.listener.expects(:started?).returns(true)
+
+        # :send_data_on_exit setting to avoid setting an at_exit
+        with_config( :send_data_on_exit => false, :dispatcher => :resque ) do
+          @agent.start
+        end
+
+        assert @agent.started?
+      end
+
     end
   end
 end