wd_newrelic_rpm 3.3.4.1 → 3.5.5

data/test/new_relic/agent/agent_test.rb

@@ -1,30 +1,38 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/thread_profiler'
+
 module NewRelic
   module Agent
     class AgentTest < Test::Unit::TestCase
-
       def setup
         super
         @agent = NewRelic::Agent::Agent.new
+        @agent.service = NewRelic::FakeService.new
       end
 
-      def test_save_or_transmit_data_should_save
-        NewRelic::Agent.expects(:save_data).once
-        @agent.expects(:harvest_and_send_timeslice_data).never
-        NewRelic::DataSerialization.expects(:should_send_data?).returns(false)
-        @agent.instance_eval { save_or_transmit_data }
+      def test_after_fork_reporting_to_channel
+        @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')
+        assert_equal 123, @agent.service.channel_id
       end
-      
-      def test_save_or_transmit_data_should_transmit
-        NewRelic::Control.instance.stubs(:disable_serialization?).returns(false)
-        NewRelic::Agent.expects(:load_data)
-        @agent.expects(:harvest_and_send_timeslice_data)
-        @agent.expects(:harvest_and_send_slowest_sample)
-        @agent.expects(:harvest_and_send_errors)
-        NewRelic::DataSerialization.expects(:should_send_data?).returns(true)
-        @agent.instance_eval { save_or_transmit_data }
+
+      def test_transmit_data_should_transmit
+        @agent.instance_eval { transmit_data }
+        assert @agent.service.agent_data.any?
+      end
+
+      def test_transmit_data_should_close_explain_db_connections
+        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
+        @agent.instance_eval { transmit_data }
+      end
+
       def test_serialize
         assert_equal([{}, [], []], @agent.send(:serialize), "should return nil when shut down")
       end
@@ -33,6 +41,61 @@ 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_graceful_shutdown_ends_thread_profiling
+        @agent.thread_profiler.expects(:stop).once
+        @agent.instance_variable_set(:@connected, true)
+
+        @agent.send(:graceful_disconnect)
+      end
+
+      def test_harvest_and_send_thread_profile
+        profile = with_profile(:finished => true)
+        @agent.send(:harvest_and_send_thread_profile, false)
+
+        assert_equal([profile],
+                    @agent.service.agent_data \
+                      .find{|data| data.action == :profile_data}.params)
+      end
+
+      def test_harvest_and_send_thread_profile_when_not_finished
+        with_profile(:finished => false)
+        @agent.send(:harvest_and_send_thread_profile, false)
+
+        assert_nil @agent.service.agent_data.find{|data| data.action == :profile_data}
+      end
+
+      def test_harvest_and_send_thread_profile_when_not_finished_but_disconnecting
+        profile = with_profile(:finished => false)
+        @agent.send(:harvest_and_send_thread_profile, true)
+
+        assert_equal([profile],
+                     @agent.service.agent_data \
+                       .find{|data| data.action == :profile_data}.params)
+      end
+
+      def with_profile(opts)
+        profile = NewRelic::Agent::ThreadProfile.new(-1, 0, 0, true)
+        profile.aggregate(["chunky.rb:42:in `bacon'"], profile.traces[:other])
+        profile.instance_variable_set(:@finished, opts[:finished])
+
+        @agent.thread_profiler.instance_variable_set(:@profile, profile)
+        profile
+      end
+
       def test_harvest_timeslice_data
         assert_equal({}, @agent.send(:harvest_timeslice_data),
                      'should return timeslice data')
@@ -42,15 +105,17 @@ module NewRelic
         2000.times do |i|
           @agent.stats_engine.stats_hash[i.to_s] = NewRelic::StatsBase.new
         end
-        
-        harvest = Thread.new do
+
+        harvest = Thread.new("Harvesting Test run timeslices") do
           @agent.send(:harvest_timeslice_data)
         end
 
-        app = Thread.new do
-          @agent.stats_engine.stats_hash["a"] = NewRelic::StatsBase.new
+        app = Thread.new("Harvesting Test Modify stats_hash") do
+          200.times do |i|
+            @agent.stats_engine.stats_hash["a#{i}"] = NewRelic::StatsBase.new
+          end
         end
-        
+
         assert_nothing_raised do
           [app, harvest].each{|t| t.join}
         end
@@ -60,6 +125,11 @@ module NewRelic
         assert_equal([], @agent.send(:harvest_errors), 'should return errors')
       end
 
+      def test_check_for_agent_commands
+        @agent.send :check_for_agent_commands
+        assert_equal(1, @agent.service.calls_for(:get_agent_commands).size)
+      end
+
       def test_merge_data_from_empty
         unsent_timeslice_data = mock('unsent timeslice data')
         unsent_errors = mock('unsent errors')
@@ -86,7 +156,7 @@ module NewRelic
         }
         assert_equal(1, @agent.unsent_errors_size)
       end
-      
+
       def test_unsent_traces_size_empty
         @agent.instance_eval {
           @traces = nil
@@ -115,7 +185,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')
@@ -125,15 +195,31 @@ module NewRelic
           @unsent_timeslice_data = unsent_timeslice_data
           @traces = unsent_traces
         }
-        unsent_errors.expects(:+).with([])
-        unsent_traces.expects(:+).with([])
-        @agent.merge_data_from([{}, [], []])
+        unsent_traces.expects(:+).with([1,2,3])
+        unsent_errors.expects(:+).with([4,5,6])
+        @agent.merge_data_from([{}, [1,2,3], [4,5,6]])
       end
 
-      def test_should_not_log_log_file_location_if_no_log_file
-        NewRelic::Control.instance.stubs(:log_file).returns('/vasrkjn4b3b4')
-        @agent.expects(:log).never
-        @agent.notify_log_file_location
+      def test_fill_metric_id_cache_from_collect_response
+        response = [[{"scope"=>"Controller/blogs/index", "name"=>"Database/SQL/other"}, 1328],
+                    [{"scope"=>"", "name"=>"WebFrontend/QueueTime"}, 10],
+                    [{"scope"=>"", "name"=>"ActiveRecord/Blog/find"}, 1017]]
+
+        @agent.send(:fill_metric_id_cache, response)
+        assert_equal 1328, @agent.metric_ids[MetricSpec.new('Database/SQL/other', 'Controller/blogs/index')]
+        assert_equal 10,   @agent.metric_ids[MetricSpec.new('WebFrontend/QueueTime')]
+        assert_equal 1017, @agent.metric_ids[MetricSpec.new('ActiveRecord/Blog/find')]
+      end
+
+      def test_fill_metric_id_cache_from_collect_response
+        response = [[{"scope"=>"Controller/blogs/index", "name"=>"Database/SQL/other"}, 1328],
+                    [{"scope"=>"", "name"=>"WebFrontend/QueueTime"}, 10],
+                    [{"scope"=>"", "name"=>"ActiveRecord/Blog/find"}, 1017]]
+
+        @agent.send(:fill_metric_id_cache, response)
+        assert_equal 1328, @agent.metric_ids[MetricSpec.new('Database/SQL/other', 'Controller/blogs/index')]
+        assert_equal 10,   @agent.metric_ids[MetricSpec.new('WebFrontend/QueueTime')]
+        assert_equal 1017, @agent.metric_ids[MetricSpec.new('ActiveRecord/Blog/find')]
       end
     end
   end

data/test/new_relic/agent/agent_test_controller.rb

@@ -12,7 +12,7 @@ class NewRelic::Agent::AgentTestController < NewRelic::Agent::SuperclassControll
   @@headers_to_add = nil
 
   def index
-    sleep params['wait'].to_i if params['wait']
+    sleep params['wait'].to_f if params['wait']
     render :text => params.inspect
   end
   def _filter_parameters(params)

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,25 +281,57 @@ 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
 
 
-  def test_busycalculation
+  def test_busy_calculation_correctly_calculates_based_acccumlator
+
+    # woah it's 1970
+    now = Time.at 0
+
+    # We'll record two seconds of transactions
+    later = Time.at(now + 2)
+    NewRelic::Agent::BusyCalculator.stubs(:time_now).
+      returns(now).then.returns(later)
+
+    # reset harvest time to epoch (based on stub)
+    NewRelic::Agent::BusyCalculator.reset
+
+    # We record 1 second of busy time in our two seconds of wall clock
+    NewRelic::Agent::BusyCalculator.instance_variable_set(:@accumulator, 1.0)
+
+
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    # smooth out floating point math
+    stat_int = (stats('Instance/Busy').total_call_time * 10).to_i
+
+    # Despite your expectations, #total_call_time is a percentage here.
+    assert_equal(stat_int, 5,
+                 "#{stats('Instance/Busy').total_call_time} != 0.5")
+  end
+
+  def test_busy_calculation_generates_a_positive_value
     engine.clear_stats
-    assert_equal 0, NewRelic::Agent::BusyCalculator.busy_count
     get :index, 'social_security_number' => "001-555-1212", 'wait' => '0.05'
     NewRelic::Agent::BusyCalculator.harvest_busy
 
     assert_equal 1, stats('Instance/Busy').call_count
     assert_equal 1, stats('HttpDispatcher').call_count
-    # We are probably busy about 99% of the time, but lets make sure it's at least 50
-    assert stats('Instance/Busy').total_call_time > (0.5 * 0.05), stats('Instance/Busy').inspect
+
+    # Timing is too non-deterministic, so we just assert a positive, non-zero
+    # value here.  See
+    # #test_busy_calculation_correctly_calculates_based_acccumlator for
+    # assertions that the formula is correct.
+    assert(stats('Instance/Busy').total_call_time > 0,
+           "#{stats('Instance/Busy').total_call_time} !> 0")
     assert_equal 0, stats('WebFrontend/Mongrel/Average Queue Time').call_count
   end
-
   def test_queue_headers_no_header
     engine.clear_stats
     queue_length_stat = stats('Mongrel/Queue Length')

data/test/new_relic/agent/audit_logger_test.rb

@@ -0,0 +1,105 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require 'new_relic/agent/audit_logger'
+
+class AuditLoggerTest < Test::Unit::TestCase
+  def setup
+    @config = {
+      :'audit_log.enabled' => true
+    }
+    @uri = "http://really.notreal"
+    @marshaller = NewRelic::Agent::NewRelicService::Marshaller.new
+    @hostname = 'dummyhost'
+    @dummy_data = {
+      'foo' => [1, 2, 3],
+      'bar' => {
+        'baz' => 'qux',
+        'jingle' => 'bells'
+      }
+    }
+    Socket.stubs(:gethostname).returns(@hostname)
+  end
+
+  def setup_fake_logger
+    @fakelog = StringIO.new
+    @logger = NewRelic::Agent::AuditLogger.new(@config)
+    @logger.stubs(:ensure_log_path).returns(@fakelog)
+  end
+
+  def assert_log_contains_string(str)
+    @fakelog.rewind
+    log_body = @fakelog.read
+    assert(log_body.include?(str), "Expected log to contain string '#{str}'")
+  end
+
+  def test_never_setup_if_disabled
+    config = { :'audit_log.enabled' => false }
+    logger = NewRelic::Agent::AuditLogger.new(config)
+    logger.log_request(@uri, "hi there", @marshaller)
+    assert(!logger.setup?, "Expected logger to not have been setup")
+  end
+
+  def test_never_prepare_if_disabled
+    config = { :'audit_log.enabled' => false }
+    logger = NewRelic::Agent::AuditLogger.new(config)
+    marshaller = NewRelic::Agent::NewRelicService::Marshaller.new
+    marshaller.expects(:prepare).never
+    logger.log_request(@uri, "hi there", @marshaller)
+  end
+
+  def test_log_formatter
+    formatter = NewRelic::Agent::AuditLogger.new(@config).log_formatter
+    time = '2012-01-01 00:00:00'
+    msg = 'hello'
+    result = formatter.call(Logger::INFO, time, 'bleh', msg)
+    expected = "[2012-01-01 00:00:00 #{@hostname} (#{$$})] : hello\n"
+    assert_equal(expected, result)
+  end
+
+  def test_ensure_path_returns_nil_with_bogus_path
+    opts = { :'audit_log.path' => '/really/really/not/a/path' }
+    FileUtils.stubs(:mkdir_p).raises(SystemCallError, "i'd rather not")
+    logger = NewRelic::Agent::AuditLogger.new(@config.merge(opts))
+    assert_nil(logger.ensure_log_path)
+  end
+
+  def test_log_request_captures_system_call_errors
+    logger = NewRelic::Agent::AuditLogger.new(@config)
+    dummy_sink = StringIO.new
+    dummy_sink.stubs(:write).raises(SystemCallError, "nope")
+    logger.stubs(:ensure_log_path).returns(dummy_sink)
+
+    # In 1.9.2 and later, Logger::LogDevice#write captures any errors during
+    # writing and spits them out with Kernel#warn.
+    # This just silences that output to keep the test output uncluttered.
+    Logger::LogDevice.any_instance.stubs(:warn)
+
+    assert_nothing_raised do
+      logger.log_request(@uri, 'whatever', @marshaller)
+    end
+  end
+
+  def test_prepares_data_with_identity_encoder
+    setup_fake_logger
+    data = { 'foo' => 'bar' }
+    identity_encoder = NewRelic::Agent::NewRelicService::Encoders::Identity
+    @marshaller.expects(:prepare).with(data, { :encoder => identity_encoder })
+    @logger.log_request(@uri, data, @marshaller)
+  end
+
+  def test_logs_inspect_with_pruby_marshaller
+    setup_fake_logger
+    pruby_marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+    @logger.log_request(@uri, @dummy_data, pruby_marshaller)
+    assert_log_contains_string(@dummy_data.inspect)
+  end
+
+  def test_logs_json_with_json_marshaller
+    marshaller_cls = NewRelic::Agent::NewRelicService::JsonMarshaller
+    if marshaller_cls.is_supported?
+      setup_fake_logger
+      json_marshaller = marshaller_cls.new
+      @logger.log_request(@uri, @dummy_data, json_marshaller)
+      assert_log_contains_string(JSON.dump(@dummy_data))
+    end
+  end
+end

data/test/new_relic/agent/beacon_configuration_test.rb

@@ -2,110 +2,106 @@ 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
-    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')
+    with_config(:license_key => 'a' * 40) do
+      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::Control.instance.expects(:license_key).never
+    NewRelic::Agent.config.expects(:[]).with('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")
+    with_config(:license_key => 'a' * 40) do
+      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")
+    end
   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