newrelic_rpm 3.5.5.540.dev → 3.5.6.42.beta

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

@@ -11,7 +11,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/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/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")
 
@@ -242,8 +201,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,16 +210,10 @@ 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
@@ -316,12 +267,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

@@ -11,12 +11,26 @@ module NewRelic
       end
 
       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.instance_eval { transmit_data }
         assert @agent.service.agent_data.any?
@@ -57,8 +71,7 @@ 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
 
@@ -221,6 +234,50 @@ 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.stubs(: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
     end
   end
 end

data/test/new_relic/agent/configuration/manager_test.rb

@@ -182,6 +182,34 @@ module NewRelic::Agent::Configuration
       assert_equal 'right', state
     end
 
+    def test_finished_configuring
+      @manager.apply_config(:layer => "yo")
+      assert_equal false, @manager.finished_configuring?
+
+      @manager.apply_config(ServerSource.new({}))
+      assert_equal true, @manager.finished_configuring?
+    end
+
+    def test_notifies_finished_configuring
+      called = false
+      NewRelic::Agent.instance.events.subscribe(:finished_configuring) { called = true }
+      @manager.apply_config(ServerSource.new({}))
+
+      assert_equal true, called
+    end
+
+    def test_doesnt_notify_unless_finished
+      called = false
+      NewRelic::Agent.instance.events.subscribe(:finished_configuring) { called = true }
+
+      @manager.apply_config(:fake => "config")
+      @manager.apply_config(ManualSource.new(:manual => true))
+      @manager.apply_config(YamlSource.new("", "test"))
+
+      assert_equal false, called
+    end
+
+
     def test_should_log_when_applying
       expects_logging(:debug, anything, includes("asdf"))
       @manager.apply_config(:test => "asdf")

data/test/new_relic/agent/configuration/yaml_source_test.rb

@@ -4,10 +4,10 @@ require 'new_relic/agent/configuration/yaml_source'
 module NewRelic::Agent::Configuration
   class YamlSourceTest < Test::Unit::TestCase
     def setup
-      test_yml_path = File.expand_path(File.join(File.dirname(__FILE__),
+      @test_yml_path = File.expand_path(File.join(File.dirname(__FILE__),
                                                  '..','..','..',
                                                  'config','newrelic.yml'))
-      @source = YamlSource.new(test_yml_path, 'test')
+      @source = YamlSource.new(@test_yml_path, 'test')
     end
 
     def test_should_load_given_yaml_file
@@ -48,11 +48,21 @@ module NewRelic::Agent::Configuration
       assert_equal 1.1, @source[:apdex_t]
     end
 
+    def test_should_not_log_error_by_default
+      expects_no_logging(:error)
+      YamlSource.new(@test_yml_path, 'test')
+    end
+
     def test_should_log_if_no_file_is_found
       expects_logging(:error, any_parameters)
       source = YamlSource.new('no_such_file.yml', 'test')
     end
 
+    def test_should_log_if_environment_is_not_present
+      expects_logging(:error, any_parameters)
+      source = YamlSource.new(@test_yml_path, 'nonsense')
+    end
+
     def test_should_not_fail_to_log_missing_file_during_startup
       without_logger do
         ::NewRelic::Agent::StartupLogger.any_instance.expects(:error)

data/test/new_relic/agent/cross_process_monitoring_test.rb

@@ -1,69 +1,181 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 
 module NewRelic::Agent
-  class CrossProcessMonitoringTest < Test::Unit::TestCase
+  class CrossProcessMonitorTest < Test::Unit::TestCase
     AGENT_CROSS_PROCESS_ID = "qwerty"
-    REQUEST_CROSS_PROCESS_ID = "asdf"
+    REQUEST_CROSS_PROCESS_ID = "42#1234"
 
-    def setup
-      NewRelic::Agent.instance.stubs(:cross_process_id).returns(AGENT_CROSS_PROCESS_ID)
-      NewRelic::Agent.instance.stubs(:cross_process_encoding_bytes).returns([0])
+    ENCODING_KEY_NOOP = "\0"
+    TRUSTED_ACCOUNT_IDS = [42,13]
 
-      @request_with_id = stub(:env => {'X-NewRelic-ID' => REQUEST_CROSS_PROCESS_ID})
-      @empty_request = stub(:env => {})
+    CROSS_PROCESS_ID_POSITION = 0
+    TRANSACTION_NAME_POSITION = 1
+    QUEUE_TIME_POSITION = 2
+    APP_TIME_POSITION = 3
+    CONTENT_LENGTH_POSITION = 4
 
+    def setup
       @response = {}
+
+      @monitor = NewRelic::Agent::CrossProcessMonitor.new()
+      @monitor.finish_setup(
+        :cross_process_id => AGENT_CROSS_PROCESS_ID,
+        :encoding_key => ENCODING_KEY_NOOP,
+        :trusted_account_ids => TRUSTED_ACCOUNT_IDS)
+    end
+
+    def when_request_runs(request=for_id(REQUEST_CROSS_PROCESS_ID))
+      @monitor.save_client_cross_process_id(request)
+      @monitor.set_transaction_custom_parameters
+      @monitor.insert_response_header(request, @response)
+    end
+
+    def when_request_has_error(request=for_id(REQUEST_CROSS_PROCESS_ID))
+      options = {}
+      @monitor.save_client_cross_process_id(request)
+      @monitor.set_error_custom_parameters(options)
+      @monitor.insert_response_header(request, @response)
+
+      options
     end
 
     def test_adds_response_header
-      timings = stub(
-        :transaction_name => "transaction",
-        :queue_time_in_millis => 1000,
-        :app_time_in_millis => 2000)
+      with_default_timings
+
+      when_request_runs
+
+      assert_equal ["qwerty", "transaction", 1000, 2000, -1], unpacked_response
+    end
+
+    def test_strips_bad_characters_in_transaction_name
+      NewRelic::Agent::BrowserMonitoring.stubs(:timings).returns(stub(
+          :transaction_name => "\"'goo",
+          :queue_time_in_seconds => 1000,
+          :app_time_in_seconds => 2000))
+
+      when_request_runs
 
-      NewRelic::Agent::BrowserMonitoring.stubs(:timings).returns(timings)
+      assert_equal "goo", unpacked_response[TRANSACTION_NAME_POSITION]
+    end
 
-      CrossProcessMonitoring.insert_response_header(@request_with_id, @response)
+    def test_doesnt_write_response_header_if_id_blank
+      with_default_timings
 
-      assert unpacked_response.include?("transaction")
-      assert unpacked_response.include?("1000")
-      assert unpacked_response.include?("2000")
-      assert unpacked_response.include?(AGENT_CROSS_PROCESS_ID)
+      when_request_runs(for_id(''))
+      assert_nil response_app_data
+    end
+
+    def test_doesnt_write_response_header_if_untrusted_id
+      with_default_timings
+
+      when_request_runs(for_id("4#1234"))
+      assert_nil response_app_data
+    end
+
+    def test_doesnt_write_response_header_if_improperly_formatted_id
+      with_default_timings
+
+      when_request_runs(for_id("42"))
+      assert_nil response_app_data
     end
 
     def test_doesnt_add_header_if_no_id_in_request
-      CrossProcessMonitoring.insert_response_header(@empty_request, @response)
+      when_request_runs({})
       assert_nil response_app_data
     end
 
     def test_doesnt_add_header_if_no_id_on_agent
-      NewRelic::Agent.instance.stubs(:cross_process_id).returns(nil)
+      @monitor.finish_setup(
+        :cross_process_id => nil,
+        :encoding_key => ENCODING_KEY_NOOP,
+        :trusted_account_ids => TRUSTED_ACCOUNT_IDS)
 
-      CrossProcessMonitoring.insert_response_header(@request_with_id, @response)
+      when_request_runs
       assert_nil response_app_data
     end
 
     def test_doesnt_add_header_if_config_disabled
       with_config(:'cross_process.enabled' => false) do
-        CrossProcessMonitoring.insert_response_header(@request_with_id, @response)
+        when_request_runs
         assert_nil response_app_data
       end
     end
 
-    def test_finds_id_from_headers
-      %w{X-NewRelic-ID HTTP_X_NEWRELIC_ID X_NEWRELIC_ID}.each do |key|
-        request = stub(:env => { key => REQUEST_CROSS_PROCESS_ID })
+    def test_includes_content_length
+      with_default_timings
+
+      when_request_runs(for_id(REQUEST_CROSS_PROCESS_ID).merge("Content-Length" => 3000))
+      assert_equal 3000, unpacked_response[CONTENT_LENGTH_POSITION]
+    end
+
+    def test_finds_content_length_from_headers
+      %w{Content-Length HTTP_CONTENT_LENGTH CONTENT_LENGTH cOnTeNt-LeNgTh}.each do |key|
+        request = { key => 42 }
 
-        assert_equal(
-          REQUEST_CROSS_PROCESS_ID, \
-          CrossProcessMonitoring.id_from_request(request),
+        assert_equal(42, @monitor.content_length_from_request(request), \
           "Failed to find header on key #{key}")
       end
     end
 
-    def test_doesnt_find_id_in_headers
-      request = stub(:env => {})
-      assert_nil CrossProcessMonitoring.id_from_request(request)
+    def test_writes_custom_parameters
+      with_default_timings
+
+      NewRelic::Agent.expects(:add_custom_parameters).once
+
+      when_request_runs
+    end
+
+    def test_error_writes_custom_parameters
+      with_default_timings
+
+      options = when_request_has_error
+
+      assert_equal REQUEST_CROSS_PROCESS_ID, options[:client_cross_process_id]
+    end
+
+    def test_error_doesnt_write_custom_parameters_if_no_id
+      with_default_timings
+
+      options = when_request_has_error(for_id(''))
+
+      assert_equal false, options.key?(:client_cross_process_id)
+    end
+
+    def test_writes_metric
+      with_default_timings
+
+      metric = mock()
+      metric.expects(:record_data_point).with(2000)
+      NewRelic::Agent.instance.stats_engine.stubs(:get_stats_no_scope).returns(metric)
+
+      when_request_runs
+    end
+
+    def test_doesnt_write_metric_if_id_blank
+      with_default_timings
+      NewRelic::Agent.instance.stats_engine.expects(:get_stats_no_scope).never
+
+      when_request_runs(for_id(''))
+    end
+
+    def test_decoding_blank
+      assert_equal "", @monitor.decode_with_key("")
+    end
+
+    def test_get_bytes_with_nil
+      assert_equal [], @monitor.send(:get_bytes, nil)
+    end
+
+    def with_default_timings
+      NewRelic::Agent::BrowserMonitoring.stubs(:timings).returns(stub(
+          :transaction_name => "transaction",
+          :queue_time_in_seconds => 1000,
+          :app_time_in_seconds => 2000))
+    end
+
+    def for_id(id)
+      encoded_id = id == "" ? "" : Base64.encode64(id)
+      { 'X-NewRelic-ID' => encoded_id }
     end
 
     def response_app_data
@@ -71,7 +183,8 @@ module NewRelic::Agent
     end
 
     def unpacked_response
-      response_app_data.unpack("m0").first
+      # Assumes array is valid JSON and Ruby, which is currently is
+      eval(Base64.decode64(response_app_data))
     end
   end
 end