newrelic_rpm 2.14.1 → 3.0.0.beta1

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -0,0 +1,124 @@
+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
+  end
+
+  def teardown
+    mocha_teardown
+    Thread.current[:newrelic_start_time] = nil
+    Thread.current[:newrelic_metric_frame] = 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>var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);(function(){var d=document;var e=d.createElement(\"script\");e.type=\"text/javascript\";e.async=true;e.src=\"this_is_my_file\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})()</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>var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);(function(){var d=document;var e=d.createElement(\"script\");e.type=\"text/javascript\";e.async=true;e.src=\"this_is_my_file\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})()</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
+    NewRelic::Control.instance.expects(:license_key).returns("a" * 13)
+
+    Thread.current[:newrelic_start_time] = Time.now
+
+    footer = browser_timing_footer
+    assert footer.include?("<script type=\"text/javascript\" charset=\"utf-8\">NREUMQ.push([\"nrf2\",")
+  end
+
+  def test_browser_timing_footer_with_no_browser_key_rum_enabled
+    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
+     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
+    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
+    assert footer.include?("<script type=\"text/javascript\" charset=\"utf-8\">NREUMQ.push([\"nrf2\",")
+  end
+
+  def test_browser_timing_footer_with_no_beacon_configuration
+    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
+    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
+    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
+    footer = nil
+    NewRelic::Agent.disable_transaction_tracing do
+      footer = browser_timing_footer
+    end
+    assert_equal "", footer
+  end
+end

data/test/new_relic/agent/busy_calculator_test.rb

@@ -1,6 +1,6 @@
 # Run faster standalone
 ENV['SKIP_RAILS'] = 'true'
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
   attr_reader :now
   def setup
@@ -9,7 +9,7 @@ class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
     @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
@@ -18,7 +18,7 @@ class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
     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
@@ -28,7 +28,7 @@ class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
     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
@@ -45,7 +45,7 @@ class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
     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
@@ -65,7 +65,7 @@ class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
     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.025
@@ -76,6 +76,6 @@ class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
     NewRelic::Agent::BusyCalculator.harvest_busy
     NewRelic::Agent::BusyCalculator.harvest_busy
     NewRelic::Agent::BusyCalculator.harvest_busy
-    assert_equal 3, @instance_busy.call_count  
+    assert_equal 3, @instance_busy.call_count
   end
 end

data/test/new_relic/agent/error_collector/notice_error_test.rb

@@ -1,8 +1,8 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper')) 
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
 class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
   require 'new_relic/agent/error_collector'
   include NewRelic::Agent::ErrorCollector::NoticeError
-  
+
   def test_error_params_from_options_mocked
     options = {:initial => 'options'}
     self.expects(:uri_ref_and_root).returns({:hi => 'there', :hello => 'bad'})
@@ -15,7 +15,7 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
       'yay'
     end
   end
-  
+
   def test_sense_method
     object = Object.new
     object.extend(Winner)
@@ -29,7 +29,7 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
     assert_equal '', fetch_from_options(options, :none, '')
     assert_equal({}, options)
   end
-  
+
   def test_uri_ref_and_root_default
     fake_control = mocked_control
     fake_control.expects(:root).returns('rootbeer')
@@ -39,9 +39,9 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
 
   def test_uri_ref_and_root_values
     fake_control = mocked_control
-    fake_control.expects(:root).returns('rootbeer')    
+    fake_control.expects(:root).returns('rootbeer')
     options = {:uri => 'whee', :referer => 'bang'}
-    assert_equal({:request_referer => 'bang', :rails_root => 'rootbeer', :request_uri => 'whee'}, uri_ref_and_root(options))    
+    assert_equal({:request_referer => 'bang', :rails_root => 'rootbeer', :request_uri => 'whee'}, uri_ref_and_root(options))
   end
 
   def test_custom_params_from_opts_base
@@ -73,7 +73,7 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
     assert_equal(nil, request_params_from_opts(val))
     assert_equal({}, val, "should delete request_params key from hash")
   end
-  
+
   def test_normalized_request_and_custom_params_base
     self.expects(:normalize_params).with(nil).returns(nil)
     self.expects(:normalize_params).with({}).returns({})
@@ -131,7 +131,7 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
   def test_exception_info
     exception = mock('exception')
     self.expects(:sense_method).with(exception, 'file_name').returns('file_name')
-    self.expects(:sense_method).with(exception, 'line_number').returns('line_number')    
+    self.expects(:sense_method).with(exception, 'line_number').returns('line_number')
     self.expects(:extract_source).with(exception).returns('source')
     self.expects(:extract_stack_trace).with(exception).returns('stack_trace')
     assert_equal({:file_name => 'file_name', :line_number => 'line_number', :source => 'source', :stack_trace => 'stack_trace'},
@@ -153,7 +153,7 @@ class NewRelic::Agent::ErrorCollector::NoticeErrorTest < Test::Unit::TestCase
     @errors = []
     self.expects(:over_queue_limit?).with(exception).returns(true)
     add_to_error_queue('foo', exception)
-    assert_equal([], @errors)    
+    assert_equal([], @errors)
   end
 
   def test_should_exit_notice_error_disabled

data/test/new_relic/agent/error_collector_test.rb

@@ -1,9 +1,9 @@
 # Run faster standalone
 ENV['SKIP_RAILS'] = 'true'
-require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper')) 
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 
 class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
-  
+
   def setup
     super
     @error_collector = NewRelic::Agent::ErrorCollector.new
@@ -13,37 +13,37 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     @error_collector.harvest_errors([])
     @error_collector.notice_error(nil, :metric=> 'path', :request_params => {:x => 'y'})
     errors = @error_collector.harvest_errors([])
-    
+
     assert_equal 0, errors.length
 
     @error_collector.notice_error('Some error message', :metric=> 'path', :request_params => {:x => 'y'})
     errors = @error_collector.harvest_errors([])
-    
+
     err = errors.first
-    assert_equal 'Some error message', err.message 
+    assert_equal 'Some error message', err.message
     assert_equal 'y', err.params[:request_params][:x]
     assert_equal '', err.params[:request_uri]
     assert_equal '', err.params[:request_referer]
-    assert_equal 'path', err.path 
+    assert_equal 'path', err.path
     assert_equal 'Error', err.exception_class
 
   end
   def test_simple
     @error_collector.notice_error(Exception.new("message"), :uri => '/myurl/', :metric => 'path', :referer => 'test_referer', :request_params => {:x => 'y'})
-    
+
     old_errors = []
     errors = @error_collector.harvest_errors(old_errors)
-    
+
     assert_equal errors.length, 1
-    
+
     err = errors.first
-    assert_equal 'message', err.message 
+    assert_equal 'message', err.message
     assert_equal 'y', err.params[:request_params][:x]
     assert err.params[:request_uri] == '/myurl/'
     assert err.params[:request_referer] == "test_referer"
     assert err.path == 'path'
     assert err.exception_class == 'Exception'
-    
+
     # the collector should now return an empty array since nothing
     # has been added since its last harvest
     errors = @error_collector.harvest_errors(nil)
@@ -54,69 +54,69 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     #yes, times 500. it's a 5000 byte string. Assuming strings are
     #still 1 byte / char.
     @error_collector.notice_error(Exception.new("1234567890" * 500), :uri => '/myurl/', :metric => 'path', :request_params => {:x => 'y'})
-    
+
     old_errors = []
     errors = @error_collector.harvest_errors(old_errors)
-    
+
     assert_equal errors.length, 1
-    
+
     err = errors.first
     assert_equal 4096, err.message.length
     assert_equal ('1234567890' * 500)[0..4095], err.message
   end
-  
+
   def test_collect_failover
-    @error_collector.notice_error(Exception.new("message"), :metric => 'first', :request_params => {:x => 'y'}) 
-    
+    @error_collector.notice_error(Exception.new("message"), :metric => 'first', :request_params => {:x => 'y'})
+
     errors = @error_collector.harvest_errors([])
-    
-    @error_collector.notice_error(Exception.new("message"), :metric => 'second', :request_params => {:x => 'y'}) 
-    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
-    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
-    
+
+    @error_collector.notice_error(Exception.new("message"), :metric => 'second', :request_params => {:x => 'y'})
+    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'})
+    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'})
+
     errors = @error_collector.harvest_errors(errors)
-    
+
     assert_equal 1, errors.length
     assert_equal 'first', errors.first.path
-    
+
     # add two more
-    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
-    @error_collector.notice_error(Exception.new("message"), :metric => 'last', :request_params => {:x => 'y'}) 
-    
+    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'})
+    @error_collector.notice_error(Exception.new("message"), :metric => 'last', :request_params => {:x => 'y'})
+
     errors = @error_collector.harvest_errors(nil)
     assert_equal 5, errors.length
     assert_equal 'second', errors.first.path
     assert_equal 'last', errors.last.path
-    
+
   end
-  
+
   def test_queue_overflow
-    
+
     max_q_length = 20     # for some reason I can't read the constant in ErrorCollector
-    
+
     silence_stream(::STDOUT) do
      (max_q_length + 5).times do |n|
-        @error_collector.notice_error(Exception.new("exception #{n}"), :metric => "path", :request_params => {:x => n}) 
+        @error_collector.notice_error(Exception.new("exception #{n}"), :metric => "path", :request_params => {:x => n})
       end
     end
-    
+
     errors = @error_collector.harvest_errors([])
-    assert errors.length == max_q_length 
+    assert errors.length == max_q_length
     errors.each_index do |i|
       err = errors.shift
       assert_equal i.to_s, err.params[:request_params][:x], err.params.inspect
     end
   end
-  
+
   # Why would anyone undef these methods?
   class TestClass
     undef to_s
     undef inspect
   end
-  
-  
+
+
   def test_supported_param_types
-    
+
     types = [[1, '1'],
     [1.1, '1.1'],
     ['hi', 'hi'],
@@ -124,26 +124,26 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     [Exception.new("test"), "#<Exception>"],
     [TestClass.new, "#<NewRelic::Agent::ErrorCollectorTest::TestClass>"]
     ]
-    
-    
+
+
     types.each do |test|
-      @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => test[0]}) 
-      
+      @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => test[0]})
+
       assert_equal test[1], @error_collector.harvest_errors([])[0].params[:request_params][:x]
     end
   end
-  
-  
+
+
   def test_exclude
     @error_collector.ignore(["IOError"])
-    
-    @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
-    
+
+    @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
+
     errors = @error_collector.harvest_errors([])
-    
+
     assert_equal 0, errors.length
   end
-  
+
   def test_exclude_block
     @error_collector.ignore_error_filter do |e|
       if e.is_a? IOError
@@ -152,14 +152,14 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
         e
       end
     end
-    
-    @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'}) 
-    
+
+    @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
+
     errors = @error_collector.harvest_errors([])
-    
+
     assert_equal 0, errors.length
   end
-  
+
   private
   def silence_stream(*args)
     super