wd_newrelic_rpm 3.5.5 → 3.5.6

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/busy_calculator_test.rb

@@ -85,4 +85,12 @@ class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
       assert_equal 0, @instance_busy.call_count
     end
   end
+
+  def test_finishing_without_starting_doesnt_raise
+    Thread.current[:busy_entries] = nil
+    assert_nothing_raised do
+      NewRelic::Agent::BusyCalculator.dispatcher_finish
+    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

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/event_listener_test.rb

@@ -0,0 +1,46 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+class EventListenerTest < Test::Unit::TestCase
+
+  def setup
+    @events = NewRelic::Agent::EventListener.new
+
+    @called = false
+    @called_with = nil
+
+    @check_method = Proc.new do |*args|
+      @called = true
+      @called_with = args
+    end
+  end
+
+  def test_notifies
+    @events.subscribe(:before_call, &@check_method)
+    @events.notify(:before_call, :env => "env")
+
+    assert_was_called
+    assert_equal([{:env => "env"}], @called_with)
+  end
+
+  def test_failure_during_notify_doesnt_block_other_hooks
+    @events.subscribe(:after_call) { raise "Boo!" }
+    @events.subscribe(:after_call, &@check_method)
+
+    @events.notify(:after_call)
+
+    assert_was_called
+  end
+
+  def test_runaway_events
+    @events.runaway_threshold = 0
+    expects_logging(:debug, includes("my_event"))
+    @events.subscribe(:my_event) {}
+  end
+
+
+  def assert_was_called
+    assert @called, "Event wasn't called"
+  end
+
+end
+

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

@@ -1,39 +1,66 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
 
-class NewRelic::Agent::Instrumentation::BrowserMonitoringTimingsTest < Test::Unit::TestCase
-
-  def setup
-    Time.stubs(:now).returns(2000)
-    @transaction = stub(
-      :transaction_name => "Name",
-      :start_time => 0
-    )
-  end
+module NewRelic::Agent::Instrumentation
+  class BrowserMonitoringTimingsTest < Test::Unit::TestCase
 
-  def test_queue_time
-    t = NewRelic::Agent::Instrumentation::BrowserMonitoringTimings.new(1000.1234, @transaction)
-    assert_equal 1_000_123, t.queue_time_in_millis
-  end
+    def setup
+      Time.stubs(:now).returns(Time.at(2000))
+      @transaction = stub(
+        :transaction_name => "Name",
+        :start_time => 0
+      )
+    end
 
-  def test_queue_time_clamps_to_positive
-    t = NewRelic::Agent::Instrumentation::BrowserMonitoringTimings.new(-1000, @transaction)
-    assert_equal 0, t.queue_time_in_millis
-  end
+    def test_queue_time_in_millis
+      t = BrowserMonitoringTimings.new(1000.1234, @transaction)
+      assert_equal 1_000_123, t.queue_time_in_millis
+    end
 
-  def test_app_time
-    t = NewRelic::Agent::Instrumentation::BrowserMonitoringTimings.new(nil, @transaction)
-    assert_equal 2_000_000, t.app_time_in_millis
-  end
+    def test_queue_time_in_seconds
+      t = BrowserMonitoringTimings.new(1000.1234, @transaction)
+      assert_equal 1_000.1234, t.queue_time_in_seconds
+    end
 
-  def test_transaction_name
-    t = NewRelic::Agent::Instrumentation::BrowserMonitoringTimings.new(nil, @transaction)
-    assert_equal "Name", t.transaction_name
-  end
+    def test_queue_time_clamps_to_positive
+      t = BrowserMonitoringTimings.new(-1000, @transaction)
+      assert_equal 0, t.queue_time_in_millis
+    end
 
-  def test_defaults_to_transaction_info
-    t = NewRelic::Agent::Instrumentation::BrowserMonitoringTimings.new(1000, nil)
-    assert_equal nil, t.transaction_name
-    assert_equal 0.0, t.start_time_in_millis
-  end
+    def test_queue_time_clamps_to_positive_in_seconds
+      t = BrowserMonitoringTimings.new(-1000, @transaction)
+      assert_equal 0, t.queue_time_in_seconds
+    end
+
+    def test_app_time_in_millis
+      t = BrowserMonitoringTimings.new(nil, @transaction)
+      assert_equal 2_000_000, t.app_time_in_millis
+    end
 
+    def test_app_time_in_seconds
+      t = BrowserMonitoringTimings.new(nil, @transaction)
+      assert_equal 2_000, t.app_time_in_seconds
+    end
+
+    def test_locks_time_at_instantiation
+      t = BrowserMonitoringTimings.new(1000, @transaction)
+      original = t.app_time_in_seconds
+
+      Time.stubs(:now).returns(3000)
+      later = t.app_time_in_seconds
+
+      assert_equal original, later
+    end
+
+    def test_transaction_name
+      t = BrowserMonitoringTimings.new(nil, @transaction)
+      assert_equal "Name", t.transaction_name
+    end
+
+    def test_defaults_to_transaction_info
+      t = BrowserMonitoringTimings.new(1000, nil)
+      assert_equal nil, t.transaction_name
+      assert_equal 0.0, t.start_time_in_millis
+    end
+
+  end
 end