newrelic_rpm 3.4.2.1 → 3.5.0

data/test/new_relic/agent/agent/start_test.rb

@@ -188,7 +188,7 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   def test_monitoring_negative
     log = mocked_log
     with_config(:monitor_mode => false) do
-      log.expects(:send).with(:warn, "Agent configured not to send data in this environment - edit newrelic.yml to change this")
+      log.expects(:send).with(:warn, "Agent configured not to send data in this environment.")
       assert !monitoring?
     end
   end
@@ -202,7 +202,7 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   def test_has_license_key_negative
     with_config(:license_key => false) do
       log = mocked_log
-      log.expects(:send).with(:error, 'No license key found.  Please edit your newrelic.yml file and insert your license key.')
+      log.expects(:send).with(:warn, 'No license key found in newrelic.yml config.')
       assert !has_license_key?
     end
   end

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

@@ -7,8 +7,6 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
     self.expects(:catch_errors).yields
     self.expects(:connect).with('connection_options')
     @connected = true
-    self.expects(:check_transaction_sampler_status)
-    self.expects(:check_sql_sampler_status)    
     self.expects(:log_worker_loop_start)
     self.expects(:create_and_run_worker_loop)
     deferred_work!('connection_options')
@@ -23,49 +21,24 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
     deferred_work!('connection_options')
   end
 
-  def test_check_transaction_sampler_status_enabled
-    with_config(:developer_mode => false) do
-      @should_send_samples = true
-      @transaction_sampler = mock('transaction_sampler')
-      @transaction_sampler.expects(:enable)
-      check_transaction_sampler_status
-    end
-  end
-
-  def test_check_transaction_sampler_status_devmode
-    with_config(:developer_mode => true) do
-      @should_send_samples = false
-      @transaction_sampler = mock('transaction_sampler')
-      @transaction_sampler.expects(:enable)
-      check_transaction_sampler_status
-    end
-  end
-
-  def test_check_transaction_sampler_status_disabled
-    with_config(:developer_mode => false) do
-      @should_send_samples = false
-      @transaction_sampler = mock('transaction_sampler')
-      @transaction_sampler.expects(:disable)
-      check_transaction_sampler_status
-    end
-  end
-
   def test_log_worker_loop_start
-    @report_period = 30
     log = mocked_log
     log.expects(:info).with("Reporting performance data every 30 seconds.")
     log.expects(:debug).with("Running worker loop")
-    log_worker_loop_start
+    with_config(:data_report_period => 30) do
+      log_worker_loop_start
+    end
   end
 
   def test_create_and_run_worker_loop
-    @report_period = 30
     @should_send_samples = true
     wl = mock('worker loop')
     NewRelic::Agent::WorkerLoop.expects(:new).returns(wl)
     wl.expects(:run).with(30).yields
     self.expects(:transmit_data)
-    create_and_run_worker_loop
+    with_config(:data_report_period => 30) do
+      create_and_run_worker_loop
+    end
   end
 
   def test_handle_force_restart

data/test/new_relic/agent/agent_test.rb

@@ -14,7 +14,7 @@ module NewRelic
                'Agent should use PipeService when directed to report to pipe channel')
         assert_equal 123, @agent.service.channel_id
       end
-      
+
       def test_transmit_data_should_transmit
         @agent.instance_eval { transmit_data }
         assert @agent.service.agent_data.any?
@@ -24,7 +24,7 @@ module NewRelic
         NewRelic::Agent::Database.expects(:close_connections)
         @agent.instance_eval { transmit_data }
       end
-      
+
       def test_transmit_data_should_not_close_db_connections_if_forked
         NewRelic::Agent::Database.expects(:close_connections).never
         @agent.after_fork
@@ -39,6 +39,20 @@ module NewRelic
         assert_equal([], @agent.send(:harvest_transaction_traces), 'should return transaction traces')
       end
 
+      def test_harvest_and_send_slowest_sample
+        with_config(:'transaction_tracer.explain_threshold' => 2,
+                    :'transaction_tracer.explain_enabled' => true,
+                    :'transaction_tracer.record_sql' => 'raw') do
+          trace = stub('transaction trace', :force_persist => true,
+                       :truncate => 4000)
+          trace.expects(:prepare_to_send).with(:record_sql => :raw,
+                                               :explain_sql => 2,
+                                               :keep_backtraces => true)
+          @agent.instance_variable_set(:@traces, [ trace ])
+          @agent.send :harvest_and_send_slowest_sample
+        end
+      end
+
       def test_harvest_timeslice_data
         assert_equal({}, @agent.send(:harvest_timeslice_data),
                      'should return timeslice data')
@@ -48,7 +62,7 @@ module NewRelic
         2000.times do |i|
           @agent.stats_engine.stats_hash[i.to_s] = NewRelic::StatsBase.new
         end
-        
+
         harvest = Thread.new do
           @agent.send(:harvest_timeslice_data)
         end
@@ -56,7 +70,7 @@ module NewRelic
         app = Thread.new do
           @agent.stats_engine.stats_hash["a"] = NewRelic::StatsBase.new
         end
-        
+
         assert_nothing_raised do
           [app, harvest].each{|t| t.join}
         end
@@ -92,7 +106,7 @@ module NewRelic
         }
         assert_equal(1, @agent.unsent_errors_size)
       end
-      
+
       def test_unsent_traces_size_empty
         @agent.instance_eval {
           @traces = nil
@@ -121,7 +135,7 @@ 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')

data/test/new_relic/agent/agent_test_controller_test.rb

@@ -7,7 +7,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   self.controller_class = NewRelic::Agent::AgentTestController
 
   attr_accessor :agent, :engine
-  
+
   def test_initialization
   # Suggested by cee-dub for merb tests.  I'm actually amazed if our tests work with merb.
     if defined?(Merb::Router)
@@ -23,7 +23,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
       Rails.application.routes.draw do
         match '/:controller/:action.:format'
         match '/:controller/:action'
-      end    
+      end
     end
 
     if defined?(Rails) && Rails.respond_to?(:application) && Rails.application.respond_to?(:routes)
@@ -41,7 +41,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     end
     @engine = @agent.stats_engine
   end
-  
+
   # Normally you can do this with #setup but for some reason in rails 2.0.2
   # setup is not called.
   if NewRelic::Control.instance.rails_version <= '2.1.0'
@@ -281,9 +281,11 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   def test_controller_params
     agent.transaction_sampler.reset!
     get :index, 'number' => "001-555-1212"
-    s = agent.transaction_sampler.harvest(nil, 0.0)
+    s = with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      agent.transaction_sampler.harvest(nil)
+    end
     assert_equal 1, s.size
-    assert_equal 6, s.first.params.size
+    assert_equal 5, s.first.params.size
   end
 
 

data/test/new_relic/agent/beacon_configuration_test.rb

@@ -2,38 +2,33 @@ 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}"
+    with_config(:application_id => 'an application id',
+                :beacon => 'beacon', :'rum.enabled' => true) do
+      bc = NewRelic::Agent::BeaconConfiguration.new
+      assert_equal true, bc.enabled?
+      assert_equal '', bc.browser_timing_header
     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)
-    s = "<script type=\"text/javascript\">var NREUMQ=NREUMQ||[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>"
-    assert_equal(s, bc.browser_timing_header)
+    with_config(:browser_key => 'a key', :application_id => 'an application id',
+                :beacon => 'beacon', :'rum.enabled' => true) do
+      bc = NewRelic::Agent::BeaconConfiguration.new
+      assert bc.enabled?
+      s = "<script type=\"text/javascript\">var NREUMQ=NREUMQ||[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>"
+      assert_equal(s, bc.browser_timing_header)
+    end
   end
 
   def test_license_bytes_nil
     with_config(:license_key => 'a' * 40) do
-      connect_data = {}
-      bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+      bc = NewRelic::Agent::BeaconConfiguration.new
       assert_equal([97] * 40, bc.license_bytes, 'should return the bytes of the license key')
     end
   end
 
   def test_license_bytes_existing_bytes
-    connect_data = {}
-    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    bc = NewRelic::Agent::BeaconConfiguration.new
     bc.instance_eval { @license_bytes = [97] * 40 }
     NewRelic::Agent.config.expects(:[]).with('license_key').never
     assert_equal([97] * 40, bc.license_bytes, "should return the cached value if it exists")
@@ -41,8 +36,7 @@ class NewRelic::Agent::BeaconConfigurationTest < Test::Unit::TestCase
 
   def test_license_bytes_should_set_instance_cache
     with_config(:license_key => 'a' * 40) do
-      connect_data = {}
-      bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+      bc = NewRelic::Agent::BeaconConfiguration.new
       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")
@@ -50,64 +44,64 @@ class NewRelic::Agent::BeaconConfigurationTest < Test::Unit::TestCase
   end
 
   def test_build_browser_timing_header_disabled
-    connect_data = {}
-    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+    bc = NewRelic::Agent::BeaconConfiguration.new
     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 = NewRelic::Agent::BeaconConfiguration.new
     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")
+    with_config(:browser_key => 'a browser monitoring key', :beacon => 'beacon') do
+      bc = NewRelic::Agent::BeaconConfiguration.new
+      assert(bc.build_browser_timing_header.include?('NREUMQ'),
+             "header should be generated when rum is enabled and browser monitoring key is set")
+    end
   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
+    with_config(:browser_key => 'a' * 40, :beacon => 'beacon') do
+      mock_javascript = mock('javascript')
+      bc = NewRelic::Agent::BeaconConfiguration.new
+      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
   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)
-    s = "if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\n"
-    assert_equal(s, bc.build_load_file_js(connect_data))
+    with_config(:'rum.load_episodes_file' => false) do
+      bc = NewRelic::Agent::BeaconConfiguration.new
+      s = "if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\n"
+      assert_equal(s, bc.build_load_file_js)
+    end
   end
-  
+
   def test_build_load_file_js_load_episodes_file_missing
-    connect_data = {}
-    bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
-    s = "if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nvar e=document.createElement(\"script\");\ne.type=\"text/javascript\";e.async=true;e.src=\"\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\n"
-    
-    assert_equal(s, bc.build_load_file_js(connect_data))
+    with_config(:'rum.load_episodes_file' => '') do
+      bc = NewRelic::Agent::BeaconConfiguration.new
+      s = "if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\n"
+      assert_equal(s, bc.build_load_file_js)
+    end
   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)
-    s = "if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nvar e=document.createElement(\"script\");\ne.type=\"text/javascript\";e.async=true;e.src=\"\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\n"
-    
-    assert_equal(s, bc.build_load_file_js(connect_data))
+    bc = NewRelic::Agent::BeaconConfiguration.new
+#     s = "if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nvar e=document.createElement(\"script\");\ne.type=\"text/javascript\";e.async=true;e.src=\"\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\n"
+    s = "if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nvar e=document.createElement(\"script\");\ne.type=\"text/javascript\";\ne.src=((\"http:\"===document.location.protocol)?\"http:\":\"https:\") + \"//\" +\n  \"\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\n"
+    assert_equal(s, bc.build_load_file_js)
   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")
+
+  def test_build_load_file_js_load_episodes_file_with_episodes_file
+    with_config(:episodes_file => 'an episodes url') do
+      bc = NewRelic::Agent::BeaconConfiguration.new
+      assert(bc.build_load_file_js.include?('an episodes url'),
+             "should include the episodes url by default")
+    end
   end
 end

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -7,25 +7,37 @@ require 'ostruct'
 class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   include NewRelic::Agent::BrowserMonitoring
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-  
+
   def setup
     NewRelic::Agent.manual_start
-    config = {:disable_mobile_headers => false }
-    NewRelic::Agent.config.apply_config(config)
-    @browser_monitoring_key = "fred"
+    @config = {
+      :beacon                 => 'beacon',
+      :disable_mobile_headers => false,
+      :browser_key            => 'browserKey',
+      :application_id         => 5,
+      :'rum.enabled'          => true,
+      :episodes_file          => 'this_is_my_file',
+      :'rum.jsonp'            => true
+    }
+    NewRelic::Agent.config.apply_config(@config)
     @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", 'rum.jsonp' => true})
+      @beacon_configuration = NewRelic::Agent::BeaconConfiguration.new
     end
+
+  def teardown
     Thread.current[:last_metric_frame] = nil
     NewRelic::Agent::TransactionInfo.clear
-    NewRelic::Agent.config.remove_config(config)
+    NewRelic::Agent.config.remove_config(@config)
   end
 
-  def teardown
     mocha_teardown
   end
 
+  def test_auto_instrumentation_config_defaults_to_enabled
+    assert NewRelic::Agent.config[:'browser_monitoring.auto_instrument']
+  end
+
   def test_browser_monitoring_start_time_is_reset_each_request_when_auto_instrument_is_disabled
     controller = Object.new
     def controller.perform_action_without_newrelic_trace(method, options={});
@@ -59,15 +71,17 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   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"}))
+    NewRelic::Agent.instance.expects(:beacon_configuration).at_least_once.returns( NewRelic::Agent::BeaconConfiguration.new)
     header = browser_timing_header
     assert_equal "<script type=\"text/javascript\">var NREUMQ=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
+    with_config(:'rum.enabled' => false) do
+      NewRelic::Agent.instance.expects(:beacon_configuration).twice.returns( NewRelic::Agent::BeaconConfiguration.new)
+      header = browser_timing_header
+      assert_equal "", header
+    end
   end
 
   def test_browser_timing_header_disable_all_tracing
@@ -93,22 +107,28 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
       snippet = '<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {
 NREUMQ.push(["load",new Date().getTime()]);
 var e=document.createElement("script");'
-      assert footer.include?(snippet), "Expected footer to include snippet: #{snippet}, but instead was #{footer}"
+      assert(footer.include?(snippet),
+             "Expected footer to include snippet: #{snippet}, but instead was #{footer}")
     end
   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
+    with_config(:browser_key => '') do
+      browser_timing_header
+      NewRelic::Agent.instance.expects(:beacon_configuration).returns(NewRelic::Agent::BeaconConfiguration.new)
+      footer = browser_timing_footer
+      assert_equal "", footer
+    end
   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
+    with_config(:'rum.enabled' => false) do
+      browser_timing_header
+      NewRelic::Agent.instance.expects(:beacon_configuration) \
+        .returns(NewRelic::Agent::BeaconConfiguration.new)
+      footer = browser_timing_footer
+      assert_equal "", footer
+    end
   end
 
   def test_browser_timing_footer_with_rum_enabled_not_specified
@@ -116,16 +136,18 @@ var e=document.createElement("script");'
 
     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 =  NewRelic::Agent::BeaconConfiguration.new
     config.expects(:license_bytes).returns(license_bytes).at_least_once
     NewRelic::Agent.instance.expects(:beacon_configuration).returns(config).at_least_once
     footer = browser_timing_footer
     beginning_snippet = '<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {
 NREUMQ.push(["load",new Date().getTime()]);
 var e=document.createElement("script");'
-    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}")
+    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
@@ -135,7 +157,6 @@ var e=document.createElement("script");'
     assert_equal "", footer
   end
 
-
   def test_browser_timing_footer_disable_all_tracing
     browser_timing_header
     footer = nil
@@ -154,30 +175,31 @@ var e=document.createElement("script");'
     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")
+  def test_browser_timing_footer_browser_key_missing
+    with_config(:browser_key => '') do
+      fake_config = mock('beacon configuration')
+      NewRelic::Agent.instance.expects(:beacon_configuration).returns(fake_config)
+      fake_config.expects(:nil?).returns(false)
+      fake_config.expects(:enabled?).returns(true)
+      self.expects(:generate_footer_js).never
+      assert_equal('', browser_timing_footer, "should not return a footer when there is no key")
+    end
   end
 
   def test_generate_footer_js_null_case
     self.expects(:browser_monitoring_start_time).returns(nil)
     assert_equal('', generate_footer_js(NewRelic::Agent.instance.beacon_configuration), "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.stubs(:beacon_configuration).returns(fake_bc)
-    self.expects(:footer_js_string).with(NewRelic::Agent.instance.beacon_configuration, 'beacon', 'a' * 40, 1).returns('footer js')
-    assert_equal('footer js', generate_footer_js(NewRelic::Agent.instance.beacon_configuration), 'should generate and return the footer JS when there is a start time')
+    with_config(:browser_key => 'a' * 40) do
+      self.expects(:browser_monitoring_start_time).returns(Time.at(100))
+      fake_bc = mock('beacon configuration')
+      NewRelic::Agent.instance.stubs(:beacon_configuration).returns(fake_bc)
+      self.expects(:footer_js_string).with(NewRelic::Agent.instance.beacon_configuration).returns('footer js')
+      assert_equal('footer js', generate_footer_js(NewRelic::Agent.instance.beacon_configuration),
+                   'should generate and return the footer JS when there is a start time')
+    end
   end
 
   def test_browser_monitoring_transaction_name_basic
@@ -199,27 +221,23 @@ var e=document.createElement("script");'
   def test_browser_monitoring_transaction_name_nil
     assert_equal('(unknown)', browser_monitoring_transaction_name, "should fill in a default when it is nil")
   end
-  
+
   def test_browser_monitoring_transaction_name_when_tt_disabled
-    @sampler = NewRelic::Agent.instance.transaction_sampler
-    @sampler.disable
+    with_config(:'transaction_tracer.enabled' => false) do
+      perform_action_with_newrelic_trace(:name => 'disabled_transactions') do
+        self.class.inspect
+      end
 
-    perform_action_with_newrelic_trace(:name => 'disabled_transactions') do
-      self.class.inspect
+      assert_match(/disabled_transactions/, browser_monitoring_transaction_name,
+                   "should name transaction when transaction tracing disabled")
     end
-        
-    assert_match(/disabled_transactions/, browser_monitoring_transaction_name,
-                 "should name transaction when transaction tracing disabled")
-  ensure
-    @sampler.enable
-  end
-  
-  
+  end
+
   def test_browser_monitoring_start_time
     mock = mock('transaction info')
-    
+
     NewRelic::Agent::TransactionInfo.set(mock)
-    
+
     mock.stubs(:start_time).returns(Time.at(100))
     mock.stubs(:guid).returns('ABC')
     assert_equal(Time.at(100), browser_monitoring_start_time, "should take the value from the thread local")
@@ -234,7 +252,7 @@ var e=document.createElement("script");'
   def test_browser_monitoring_app_time_nonzero
     start = Time.now
     self.expects(:browser_monitoring_start_time).returns(start - 1)
-    Time.expects(:now).returns(start)
+    Time.stubs(:now).returns(start)
     assert_equal(1000, browser_monitoring_app_time, 'should return a rounded time')
   end
 
@@ -261,10 +279,6 @@ var e=document.createElement("script");'
   end
 
   def test_footer_js_string_basic
-    beacon = ''
-    license_key = ''
-    application_id = 1
-
     # mocking this because JRuby thinks that Time.now - Time.now
     # always takes at least 1ms
     self.expects(:browser_monitoring_app_time).returns(0)
@@ -275,21 +289,21 @@ var e=document.createElement("script");'
 
     sample = mock('transaction info')
     NewRelic::Agent::TransactionInfo.set(sample)
-    
+
     sample.stubs(:start_time).returns(Time.at(100))
     sample.stubs(:guid).returns('ABC')
     sample.stubs(:transaction_name).returns('most recent transaction')
     sample.stubs(:include_guid?).returns(true)
     sample.stubs(:duration).returns(12.0)
     sample.stubs(:token).returns('0123456789ABCDEF')
-    
+
     self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'most recent transaction').returns('most recent transaction')
     self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'user').returns('user')
     self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'account').returns('account')
     self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'product').returns('product')
 
-    value = footer_js_string(NewRelic::Agent.instance.beacon_configuration, beacon, license_key, application_id)
-    assert_equal("<script type=\"text/javascript\">if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nvar e=document.createElement(\"script\");\ne.type=\"text/javascript\";e.async=true;e.src=\"this_is_my_file\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\nNREUMQ.push([\"nrfj\",\"\",\"\",1,\"most recent transaction\",0,0,new Date().getTime(),\"ABC\",\"0123456789ABCDEF\",\"user\",\"account\",\"product\"])</script>", value, "should return the javascript given some default values")
+    value = footer_js_string(NewRelic::Agent.instance.beacon_configuration)
+    assert_equal("<script type=\"text/javascript\">if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nvar e=document.createElement(\"script\");\ne.type=\"text/javascript\";\ne.src=((\"http:\"===document.location.protocol)?\"http:\":\"https:\") + \"//\" +\n  \"this_is_my_file\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\nNREUMQ.push([\"nrfj\",\"beacon\",\"browserKey\",5,\"most recent transaction\",0,0,new Date().getTime(),\"ABC\",\"0123456789ABCDEF\",\"user\",\"account\",\"product\"]);</script>", value, "should return the javascript given some default values")
   end
 
   def test_html_safe_if_needed_unsafed
@@ -326,11 +340,11 @@ var e=document.createElement("script");'
     output = obfuscate(NewRelic::Agent.instance.beacon_configuration, text)
     assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1YyNsZHZ3cSl6YmluZCJsYiV1amllZit4aHl2YiRtZ3d4cCp7ZWhiZyNrYyZ0ZWhmZyx5ZHp3ZSVuZnh5cyt8ZGRhZiRqYCd7ZGtnYC11Z3twZCZvaXl6cix9aGdgYSVpYSh6Z2pgYSF2Znxx', output, "should output obfuscated text")
   end
-  
+
   def test_no_mobile_response_header_if_no_mobile_request_header_given
     request = Rack::Request.new({})
     response = Rack::Response.new
-    
+
     NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
     assert_nil response['X-NewRelic-Beacon-Url']
   end
@@ -342,13 +356,13 @@ var e=document.createElement("script");'
     NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
     assert_nil response['X-NewRelic-Beacon-Url']
   end
-  
+
   def test_place_beacon_url_header_when_given_mobile_request_header
-    response = mobile_transaction    
+    response = mobile_transaction
     assert_equal('http://beacon/mobile/1/browserKey',
                  response['X-NewRelic-Beacon-Url'])
   end
-  
+
   def test_place_beacon_url_header_when_given_mobile_request_header_with_https
     request = Rack::Request.new('X_NEWRELIC_MOBILE_TRACE' => 'true',
                                 'rack.url_scheme' => 'https')
@@ -359,11 +373,11 @@ var e=document.createElement("script");'
 
   def test_place_beacon_payload_head_when_given_mobile_request_header
     Time.stubs(:now).returns(6)
-    response = mobile_transaction    
+    response = mobile_transaction
     txn_name = obfuscate(NewRelic::Agent.instance.beacon_configuration,
                          browser_monitoring_transaction_name)
-    expected_payload = %|["apId","#{txn_name}",#{browser_monitoring_queue_time},#{browser_monitoring_app_time}]|
-    
+    expected_payload = %|["5","#{txn_name}",#{browser_monitoring_queue_time},#{browser_monitoring_app_time}]|
+
     assert_equal expected_payload, response['X-NewRelic-App-Server-Metrics'].strip
   end