ghazel-newrelic_rpm 3.1.0.1

data/test/new_relic/agent/apdex_from_server_test.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+class NewRelic::Agent::ApdexFromServerTest < Test::Unit::TestCase
+
+  def test_true
+    # we need tests in this file - TBD
+    assert true
+  end
+end

data/test/new_relic/agent/beacon_configuration_test.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require "new_relic/agent/beacon_configuration"
+class NewRelic::Agent::BeaconConfigurationTest < Test::Unit::TestCase
+  def test_initialize_basic
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal true, bc.rum_enabled
+    assert_equal '', bc.browser_timing_header
+    %w[application_id browser_monitoring_key beacon].each do |method|
+      value = bc.send(method.to_sym)
+      assert_equal nil, value, "Expected #{method} to be nil, but was #{value.inspect}"
+    end
+  end
+
+  def test_initialize_with_real_data
+    connect_data = {'browser_key' => 'a browser monitoring key', 'application_id' => 'an application id', 'beacon' => 'a beacon', 'rum_enabled' => true}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal(true, bc.rum_enabled)
+    assert_equal('a browser monitoring key', bc.browser_monitoring_key)
+    assert_equal('an application id', bc.application_id)
+    assert_equal('a beacon', bc.beacon)
+    assert_equal(109, bc.browser_timing_header.size, "should output the javascript with all the data available")
+  end
+
+  def test_license_bytes_nil
+    connect_data = {}
+    NewRelic::Control.instance.expects(:license_key).returns('a' * 40).once
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal([97] * 40, bc.license_bytes, 'should return the bytes of the license key')
+  end
+
+  def test_license_bytes_existing_bytes
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    bc.instance_eval { @license_bytes = [97] * 40 }
+    NewRelic::Control.instance.expects(:license_key).never
+    assert_equal([97] * 40, bc.license_bytes, "should return the cached value if it exists")
+  end
+
+  def test_license_bytes_should_set_instance_cache
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    NewRelic::Control.instance.expects(:license_key).returns('a' * 40)
+    bc.instance_eval { @license_bytes = nil }
+    bc.license_bytes
+    assert_equal([97] * 40, bc.instance_variable_get('@license_bytes'), "should cache the license bytes for later")
+  end
+
+  def test_build_browser_timing_header_disabled
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    bc.instance_eval { @rum_enabled = false }
+    assert_equal '', bc.build_browser_timing_header, "should not return a header when rum enabled is false"
+  end
+
+  def test_build_browser_timing_header_enabled_but_no_key
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    bc.instance_eval { @rum_enabled = true; @browser_monitoring_key = nil }
+    assert_equal '', bc.build_browser_timing_header, "should not return a header when browser_monitoring_key is nil"
+  end
+  
+  def test_build_browser_timing_header_enabled_with_key
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    bc.instance_eval { @browser_monitoring_key = 'a browser monitoring key' }
+    assert(bc.build_browser_timing_header.include?('NREUMQ'), "header should be generated when rum is enabled and browser monitoring key is set")
+  end
+
+  def test_build_browser_timing_header_should_html_safe_header
+    mock_javascript = mock('javascript')
+    connect_data = {'browser_key' => 'a' * 40}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal('a' * 40, bc.instance_variable_get('@browser_monitoring_key'), "should save the key from the config")
+    bc.expects(:javascript_header).returns(mock_javascript)
+    mock_javascript.expects(:respond_to?).with(:html_safe).returns(true)
+    mock_javascript.expects(:html_safe)
+    bc.build_browser_timing_header
+  end
+  
+  def test_build_load_file_js_load_episodes_file_false
+    connect_data = {'rum.load_episodes_file' => false}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal '', bc.build_load_file_js(connect_data), "should be empty when load episodes file is false"
+  end
+  
+  def test_build_load_file_js_load_episodes_file_missing
+    connect_data = {}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal(184, bc.build_load_file_js(connect_data).size, "should output the javascript when there is no configuration")
+  end
+
+  def test_build_load_file_js_load_episodes_file_present
+    connect_data = {'rum.load_episodes_file' => true}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert_equal(184, bc.build_load_file_js(connect_data).size, "should output the javascript when rum.load_episodes_file is true")
+  end
+  
+  def test_build_load_file_js_load_episodes_file_with_episodes_url
+    connect_data = {'episodes_url' => 'an episodes url'}
+    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    assert(bc.build_load_file_js(connect_data).include?('an episodes url'), "should include the episodes url by default")
+  end
+end

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -0,0 +1,274 @@
+ENV['SKIP_RAILS'] = 'true'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require "new_relic/agent/browser_monitoring"
+
+class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
+  include NewRelic::Agent::BrowserMonitoring
+
+  def setup
+    NewRelic::Agent.manual_start
+    @browser_monitoring_key = "fred"
+    @episodes_file = "this_is_my_file"
+    NewRelic::Agent.instance.instance_eval do
+      @beacon_configuration = NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => true, "browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"})
+    end
+    Thread.current[:newrelic_most_recent_transaction] = "MyCoolTransaction"
+  end
+
+  def teardown
+    mocha_teardown
+    Thread.current[:newrelic_start_time] = nil
+    Thread.current[:newrelic_metric_frame] = nil
+    Thread.current[:newrelic_most_recent_transaction] = nil
+  end
+
+  def test_browser_timing_header_with_no_beacon_configuration
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns( nil)
+    header = browser_timing_header
+    assert_equal "", header
+  end
+
+  def test_browser_timing_header
+    header = browser_timing_header
+    assert_equal "<script type=\"text/javascript\">var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>", header
+  end
+
+  def test_browser_timing_header_with_rum_enabled_not_specified
+    NewRelic::Agent.instance.expects(:beacon_configuration).at_least_once.returns( NewRelic::Agent::BeaconConfiguration.new({"browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
+    header = browser_timing_header
+    assert_equal "<script type=\"text/javascript\">var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>", header
+  end
+
+  def test_browser_timing_header_with_rum_enabled_false
+    NewRelic::Agent.instance.expects(:beacon_configuration).twice.returns( NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => false, "browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
+    header = browser_timing_header
+    assert_equal "", header
+  end
+
+  def test_browser_timing_header_disable_all_tracing
+    header = nil
+    NewRelic::Agent.disable_all_tracing do
+      header = browser_timing_header
+    end
+    assert_equal "", header
+  end
+
+  def test_browser_timing_header_disable_transaction_tracing
+    header = nil
+    NewRelic::Agent.disable_transaction_tracing do
+      header = browser_timing_header
+    end
+    assert_equal "", header
+  end
+
+  def test_browser_timing_footer
+    browser_timing_header
+    NewRelic::Control.instance.expects(:license_key).returns("a" * 13)
+
+    Thread.current[:newrelic_start_time] = Time.now
+
+    footer = browser_timing_footer
+    snippet = "<script type=\"text/javascript\">(function(){var d=document;var e=d.createElement(\"script\");e.async=true;e.src=\"this_is_my_file\";e.type=\"text/javascript\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})();NREUMQ.push([\"nrf2\","
+    assert footer.include?(snippet), "Expected footer to include snippet: #{snippet}, but instead was #{footer}"
+  end
+
+  def test_browser_timing_footer_without_calling_header
+    footer = browser_timing_footer
+    assert_equal "", footer
+  end
+
+  def test_browser_timing_footer_with_no_browser_key_rum_enabled
+    browser_timing_header
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => true, "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
+    footer = browser_timing_footer
+    assert_equal "", footer
+  end
+
+  def test_browser_timing_footer_with_no_browser_key_rum_disabled
+    browser_timing_header
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => false, "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
+    footer = browser_timing_footer
+    assert_equal "", footer
+  end
+
+  def test_browser_timing_footer_with_rum_enabled_not_specified
+    browser_timing_header
+    Thread.current[:newrelic_start_time] = Time.now
+
+    license_bytes = [];
+    ("a" * 13).each_byte {|byte| license_bytes << byte}
+    config =  NewRelic::Agent::BeaconConfiguration.new({"browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file", "license_bytes" => license_bytes})
+    config.expects(:license_bytes).returns(license_bytes)
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns(config).at_least_once
+    footer = browser_timing_footer
+    beginning_snippet = "(function(){var d=document;var e=d.createElement(\"script\");e.async=true;e.src=\"this_is_my_file\";e.type=\"text/javascript\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})();NREUMQ.push([\"nrf2\","
+    ending_snippet = "])</script>"
+    assert(footer.include?(beginning_snippet), "expected footer to include beginning snippet: #{beginning_snippet}, but was #{footer}")
+    assert(footer.include?(ending_snippet), "expected footer to include ending snippet: #{ending_snippet}, but was #{footer}")
+  end
+
+  def test_browser_timing_footer_with_no_beacon_configuration
+    browser_timing_header
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns( nil)
+    footer = browser_timing_footer
+    assert_equal "", footer
+  end
+
+  def test_browser_timing_footer_with_no_start_time
+    browser_timing_header
+    Thread.current[:newrelic_start_time] = nil
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new({"browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
+    footer = browser_timing_footer
+    assert_equal('', footer)
+  end
+
+
+  def test_browser_timing_footer_disable_all_tracing
+    browser_timing_header
+    footer = nil
+    NewRelic::Agent.disable_all_tracing do
+      footer = browser_timing_footer
+    end
+    assert_equal "", footer
+  end
+
+  def test_browser_timing_footer_disable_transaction_tracing
+    browser_timing_header
+    footer = nil
+    NewRelic::Agent.disable_transaction_tracing do
+      footer = browser_timing_footer
+    end
+    assert_equal "", footer
+  end
+
+  def test_browser_timing_footer_browser_monitoring_key_missing
+    fake_config = mock('beacon configuration')
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns(fake_config)
+    fake_config.expects(:nil?).returns(false)
+    fake_config.expects(:rum_enabled).returns(true)
+    fake_config.expects(:browser_monitoring_key).returns(nil)
+    self.expects(:generate_footer_js).never
+    assert_equal('', browser_timing_footer, "should not return a footer when there is no key")
+  end
+
+  def test_generate_footer_js_null_case
+    self.expects(:browser_monitoring_start_time).returns(nil)
+    assert_equal('', generate_footer_js, "should not send javascript when there is no start time")
+  end
+
+  def test_generate_footer_js_with_start_time
+    self.expects(:browser_monitoring_start_time).returns(Time.at(100))
+    fake_bc = mock('beacon configuration')
+    fake_bc.expects(:application_id).returns(1)
+    fake_bc.expects(:beacon).returns('beacon')
+    fake_bc.expects(:browser_monitoring_key).returns('a' * 40)
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns(fake_bc)
+    self.expects(:footer_js_string).with('beacon', 'a' * 40, 1).returns('footer js')
+    assert_equal('footer js', generate_footer_js, 'should generate and return the footer JS when there is a start time')
+  end
+
+  def test_browser_monitoring_transaction_name_basic
+    Thread.current[:newrelic_most_recent_transaction] = 'a transaction name'
+    assert_equal('a transaction name', browser_monitoring_transaction_name, "should take the value from the thread local")
+  end
+
+  def test_browser_monitoring_transaction_name_empty
+    Thread.current[:newrelic_most_recent_transaction] = ''
+    assert_equal('', browser_monitoring_transaction_name, "should take the value even when it is empty")
+  end
+
+  def test_browser_monitoring_transaction_name_nil
+    Thread.current[:newrelic_most_recent_transaction] = nil
+    assert_equal('<unknown>', browser_monitoring_transaction_name, "should fill in a default when it is nil")
+  end
+
+  def test_browser_monitoring_start_time
+    Thread.current[:newrelic_start_time] = Time.at(100)
+    assert_equal(Time.at(100), browser_monitoring_start_time, "should take the value from the thread local")
+  end
+
+  def test_clamp_to_positive
+    assert_equal(0.0, clamp_to_positive(-1), "should clamp a negative value to zero")
+    assert_equal(1232, clamp_to_positive(1232), "should pass through the value when it is positive")
+    assert_equal(0, clamp_to_positive(0), "should not mess with zero when passing it through")
+  end
+
+  def test_browser_monitoring_app_time_nonzero
+    start = Time.now
+    self.expects(:browser_monitoring_start_time).returns(start - 1)
+    Time.expects(:now).returns(start)
+    assert_equal(1000, browser_monitoring_app_time, 'should return a rounded time')
+  end
+
+  def test_browser_monitoring_queue_time_nil
+    Thread.current[:newrelic_queue_time] = nil
+    assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is no queue time')
+  end
+
+  def test_browser_monitoring_queue_time_zero
+    Thread.current[:newrelic_queue_time] = 0.0
+    assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is zero queue time')
+  end
+
+  def test_browser_monitoring_queue_time_ducks
+    Thread.current[:newrelic_queue_time] = 'a duck'
+    assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is an incorrect queue time')
+  end
+
+  def test_browser_monitoring_queue_time_nonzero
+    Thread.current[:newrelic_queue_time] = 3.00002
+    assert_equal(3000, browser_monitoring_queue_time, 'should return a rounded time')
+  end
+
+  def test_footer_js_string_basic
+    beacon = ''
+    license_key = ''
+    application_id = 1
+
+    Thread.current[:newrelic_queue_time] = nil
+    # mocking this because JRuby thinks that Time.now - Time.now
+    # always takes at least 1ms
+    self.expects(:browser_monitoring_app_time).returns(0)
+    Thread.current[:newrelic_most_recent_transaction] = 'most recent transaction'
+
+    self.expects(:obfuscate).with('most recent transaction').returns('most recent transaction')
+
+    value = footer_js_string(beacon, license_key, application_id)
+    assert_equal('<script type="text/javascript">(function(){var d=document;var e=d.createElement("script");e.async=true;e.src="this_is_my_file";e.type="text/javascript";var s=d.getElementsByTagName("script")[0];s.parentNode.insertBefore(e,s);})();NREUMQ.push(["nrf2","","",1,"most recent transaction",0,0,new Date().getTime()])</script>', value, "should return the javascript given some default values")
+  end
+
+  def test_html_safe_if_needed_unsafed
+    string = mock('string')
+    # here to handle 1.9 encoding - we stub this out because it should
+    # be handled automatically and is outside the scope of this test
+    string.stubs(:respond_to?).with(:encoding).returns(false)
+    string.expects(:respond_to?).with(:html_safe).returns(false)
+    assert_equal(string, html_safe_if_needed(string))
+  end
+
+  def test_html_safe_if_needed_safed
+    string = mock('string')
+    string.expects(:respond_to?).with(:html_safe).returns(true)
+    string.expects(:html_safe).returns(string)
+    # here to handle 1.9 encoding - we stub this out because it should
+    # be handled automatically and is outside the scope of this test
+    string.stubs(:respond_to?).with(:encoding).returns(false)
+    assert_equal(string, html_safe_if_needed(string))
+  end
+
+  def test_obfuscate_basic
+    text = 'a happy piece of small text'
+    key = (1..40).to_a
+    NewRelic::Agent.instance.beacon_configuration.expects(:license_bytes).returns(key)
+    output = obfuscate(text)
+    assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1', output, "should output obfuscated text")
+  end
+
+  def test_obfuscate_long_string
+    text = 'a happy piece of small text' * 5
+    key = (1..40).to_a
+    NewRelic::Agent.instance.beacon_configuration.expects(:license_bytes).returns(key)
+    output = obfuscate(text)
+    assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1YyNsZHZ3cSl6YmluZCJsYiV1amllZit4aHl2YiRtZ3d4cCp7ZWhiZyNrYyZ0ZWhmZyx5ZHp3ZSVuZnh5cyt8ZGRhZiRqYCd7ZGtnYC11Z3twZCZvaXl6cix9aGdgYSVpYSh6Z2pgYSF2Znxx', output, "should output obfuscated text")
+  end
+end

data/test/new_relic/agent/busy_calculator_test.rb

@@ -0,0 +1,81 @@
+# Run faster standalone
+ENV['SKIP_RAILS'] = 'true'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
+  attr_reader :now
+  def setup
+    @now = Time.now.to_f
+    NewRelic::Agent::BusyCalculator.reset
+    @instance_busy = NewRelic::MethodTraceStats.new
+    NewRelic::Agent::BusyCalculator.stubs(:instance_busy_stats).returns(@instance_busy)
+  end
+
+  def test_normal
+    # start the timewindow 10 seconds ago
+    # start a request at 10 seconds, 5 seconds long
+    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 5.0)
+    assert_equal 5, NewRelic::Agent::BusyCalculator.accumulator
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, @instance_busy.call_count
+    assert_in_delta 0.50, @instance_busy.total_call_time, 0.05
+  end
+  def test_split
+    # start the timewindow 10 seconds ago
+    # start a request at 5 seconds, don't finish
+    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 5.0)
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, @instance_busy.call_count, @instance_busy
+    assert_in_delta 0.50, @instance_busy.total_call_time, 0.05
+  end
+  def test_reentrancy
+    # start the timewindow 10 seconds ago
+    # start a request at 5 seconds, don't finish, but make two more
+    # complete calls, which should be ignored.
+    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 5.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 4.5)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 4.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 3.5)
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 3.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 2.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 1.0)
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, @instance_busy.call_count
+    assert_in_delta 0.50, @instance_busy.total_call_time, 0.05
+  end
+  def test_concurrency
+    # start the timewindow 10 seconds ago
+    # start a request at 10 seconds, 5 seconds long
+    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 8.0)
+    worker = Thread.new do
+      # Get busy for 6 - 3 seconds
+      NewRelic::Agent::BusyCalculator.dispatcher_start(now - 6.0)
+      NewRelic::Agent::BusyCalculator.dispatcher_start(now - 5.0)
+      NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 4.0)
+      NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 3.0)
+    end
+    # Get busy for 8 - 2 seconds
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 2.0)
+    worker.join
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, @instance_busy.call_count
+    # 3 + 6 = 9, or 90%
+    assert_in_delta 0.90, @instance_busy.total_call_time, 0.1
+
+  end
+  def test_dont_ignore_zero_counts
+    assert_equal 0, @instance_busy.call_count, "Problem with test--instance busy not starting off at zero."
+    NewRelic::Agent::BusyCalculator.harvest_busy
+    NewRelic::Agent::BusyCalculator.harvest_busy
+    NewRelic::Agent::BusyCalculator.harvest_busy
+    assert_equal 3, @instance_busy.call_count
+  end
+end