newrelic_rpm 3.4.1 → 3.4.2.beta1

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

@@ -24,30 +24,30 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
   end
 
   def test_check_transaction_sampler_status_enabled
-    control = mocked_control
-    control.expects(:developer_mode?).returns(false)
-    @should_send_samples = true
-    @transaction_sampler = mock('transaction_sampler')
-    @transaction_sampler.expects(:enable)
-    check_transaction_sampler_status
+    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
-    control = mocked_control
-    control.expects(:developer_mode?).returns(true)
-    @should_send_samples = false
-    @transaction_sampler = mock('transaction_sampler')
-    @transaction_sampler.expects(:enable)
-    check_transaction_sampler_status
+    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
-    control = mocked_control
-    control.expects(:developer_mode?).returns(false)
-    @should_send_samples = false
-    @transaction_sampler = mock('transaction_sampler')
-    @transaction_sampler.expects(:disable)
-    check_transaction_sampler_status
+    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

data/test/new_relic/agent/beacon_configuration_test.rb

@@ -24,27 +24,29 @@ class NewRelic::Agent::BeaconConfigurationTest < Test::Unit::TestCase
   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
+      connect_data = {}
+      bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+      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.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
+      connect_data = {}
+      bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
+      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

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -1,6 +1,7 @@
 ENV['SKIP_RAILS'] = 'true'
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 require "new_relic/agent/browser_monitoring"
+require 'ostruct'
 
 class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   include NewRelic::Agent::BrowserMonitoring
@@ -8,6 +9,8 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   
   def setup
     NewRelic::Agent.manual_start
+    config = {:disable_mobile_headers => false }
+    NewRelic::Agent.config.apply_config(config)
     @browser_monitoring_key = "fred"
     @episodes_file = "this_is_my_file"
     NewRelic::Agent.instance.instance_eval do
@@ -15,6 +18,7 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     end
     Thread.current[:last_metric_frame] = nil
     NewRelic::Agent::TransactionInfo.clear
+    NewRelic::Agent.config.remove_config(config)
   end
 
   def teardown
@@ -29,16 +33,17 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     def controller.newrelic_metric_path; "foo"; end
     controller.extend ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
     controller.extend ::NewRelic::Agent::BrowserMonitoring
-    NewRelic::Control.instance['browser_monitoring'] = { 'auto_instrument' => false }
 
-    controller.perform_action_with_newrelic_trace(:index)
-    first_request_start_time = controller.send(:browser_monitoring_start_time)
-    controller.perform_action_with_newrelic_trace(:index)
-    second_request_start_time = controller.send(:browser_monitoring_start_time)
+    with_config(:'browser_monitoring.auto_instrument' => false) do
+      controller.perform_action_with_newrelic_trace(:index)
+      first_request_start_time = controller.send(:browser_monitoring_start_time)
+      controller.perform_action_with_newrelic_trace(:index)
+      second_request_start_time = controller.send(:browser_monitoring_start_time)
 
-    # assert that these aren't the same time object
-    # the start time should be reinitialized each request to the controller
-    assert !(first_request_start_time.equal? second_request_start_time)
+      # assert that these aren't the same time object
+      # the start time should be reinitialized each request to the controller
+      assert !(first_request_start_time.equal? second_request_start_time)
+    end
   end
 
   def test_browser_timing_header_with_no_beacon_configuration
@@ -81,14 +86,14 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   end
 
   def test_browser_timing_footer
-    browser_timing_header
-    NewRelic::Control.instance.expects(:license_key).returns("a" * 13)
-
-    footer = browser_timing_footer
-    snippet = '<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {
+    with_config(:license_key => 'a' * 13) do
+      browser_timing_header
+      footer = browser_timing_footer
+      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
@@ -320,4 +325,54 @@ 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
+
+  def test_no_mobile_response_header_if_mobile_request_header_is_false
+    request = Rack::Request.new('HTTP_X_NEWRELIC_MOBILE_TRACE' => 'false')
+    response = Rack::Response.new
+
+    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    
+    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')
+    response = mobile_transaction(request)
+    assert_equal('https://beacon/mobile/1/browserKey',
+                 response['X-NewRelic-Beacon-Url'])
+  end
+
+  def test_place_beacon_payload_head_when_given_mobile_request_header
+    Time.stubs(:now).returns(6)
+    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}]|
+    
+    assert_equal expected_payload, response['X-NewRelic-App-Server-Metrics'].strip
+  end
+
+  def mobile_transaction(request=nil)
+    request ||= Rack::Request.new('X-NewRelic-Mobile-Trace' => 'true')
+    response = Rack::Response.new
+    txn_data = OpenStruct.new(:transaction_name => 'a transaction name',
+                              :start_time => 5)
+    NewRelic::Agent::TransactionInfo.set(txn_data)
+    NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
+    response
+  end
 end

data/test/new_relic/agent/configuration/environment_source_test.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/configuration/environment_source'
+
+module NewRelic::Agent::Configuration
+  class EnvironmentSourceTest < Test::Unit::TestCase
+    def test_environment_strings_are_applied
+      assert_applied_string 'NRCONFIG', 'config_path'
+      assert_applied_string 'NEW_RELIC_LICENSE_KEY', 'license_key'
+      assert_applied_string 'NEWRELIC_LICENSE_KEY', 'license_key'
+      assert_applied_string 'NEW_RELIC_APP_NAME', 'app_name'
+      assert_applied_string 'NEWRELIC_APP_NAME', 'app_name'
+      assert_applied_string 'NEW_RELIC_DISPATCHER', 'dispatcher'
+      assert_applied_string 'NEWRELIC_DISPATCHER', 'dispatcher'
+      assert_applied_string 'NEW_RELIC_FRAMEWORK', 'framework'
+      assert_applied_string 'NEWRELIC_FRAMEWORK', 'framework'
+    end
+
+    def test_environment_booleans_truths_are_applied
+      ENV['NEWRELIC_ENABLE'] = 'true'
+      assert EnvironmentSource.new[:agent_enabled]
+      ENV['NEWRELIC_ENABLE'] = 'on'
+      assert EnvironmentSource.new[:agent_enabled]
+      ENV['NEWRELIC_ENABLE'] = 'yes'
+      assert EnvironmentSource.new[:agent_enabled]
+      ENV.delete('NEWRELIC_ENABLE')
+    end
+
+    def test_environment_booleans_falsehoods_are_applied
+      ENV['NEWRELIC_ENABLE'] = 'false'
+      assert !EnvironmentSource.new[:agent_enabled]
+      ENV['NEWRELIC_ENABLE'] = 'off'
+      assert !EnvironmentSource.new[:agent_enabled]
+      ENV['NEWRELIC_ENABLE'] = 'no'
+      assert !EnvironmentSource.new[:agent_enabled]
+      ENV.delete('NEWRELIC_ENABLE')
+    end
+
+    def test_set_log_config_from_environment
+      ENV['NEW_RELIC_LOG'] = 'off/in/space.log'
+      source = EnvironmentSource.new
+      assert_equal 'off/in', source[:log_file_path]
+      assert_equal 'space.log', source[:log_file_name]
+    end
+
+    def test_set_log_config_STDOUT_from_environment
+      ENV['NEW_RELIC_LOG'] = 'STDOUT'
+      source = EnvironmentSource.new
+      assert_equal 'STDOUT', source[:log_file_name]
+      assert_equal 'STDOUT', source[:log_file_path]
+    end
+
+    def assert_applied_string(env_var, config_var)
+      ENV[env_var] = 'test value'
+      assert_equal 'test value', EnvironmentSource.new[config_var.to_sym]
+      ENV.delete(env_var)
+    end
+  end
+end

data/test/new_relic/agent/configuration/manager_test.rb

@@ -0,0 +1,120 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/configuration/manager'
+
+module NewRelic::Agent::Configuration
+  class ManagerTest < Test::Unit::TestCase
+    def setup
+      @manager = NewRelic::Agent::Configuration::Manager.new
+    end
+
+    def test_should_use_indifferent_access
+      config = NewRelic::Agent::Configuration::DottedHash.new('string' => 'string', :symbol => 'symbol')
+      @manager.apply_config(config)
+      assert_equal 'string', @manager[:string]
+      assert_equal 'symbol', @manager['symbol']
+      @manager.remove_config(config)
+    end
+
+    def test_should_apply_config_sources_in_order
+      config0 = {
+        :foo => 'default foo',
+        :bar => 'default bar',
+        :baz => 'default baz'
+      }
+      @manager.apply_config(config0)
+      config1 = { :foo => 'real foo' }
+      @manager.apply_config(config1)
+      config2 = { :foo => 'wrong foo', :bar => 'real bar' }
+      @manager.apply_config(config2, 1)
+
+      assert_equal 'real foo', @manager['foo']
+      assert_equal 'real bar', @manager['bar']
+      assert_equal 'default baz', @manager['baz']
+
+      @manager.remove_config(config0)
+      @manager.remove_config(config1)
+      @manager.remove_config(config2)
+    end
+
+    def test_identifying_config_source
+      hash_source = {:foo => 'foo', :bar => 'default'}
+      @manager.apply_config(hash_source)
+      test_source = TestSource.new
+      test_source[:bar] = 'bar'
+      test_source[:baz] = 'baz'
+      @manager.apply_config(test_source)
+
+      assert_not_equal test_source, @manager.source(:foo)
+      assert_equal test_source, @manager.source(:bar)
+      assert_equal test_source, @manager.source(:baz)
+
+      @manager.remove_config(hash_source)
+      @manager.remove_config(test_source)
+    end
+
+    def test_callable_value_for_config_should_return_computed_value
+      source = {
+        :foo          => 'bar',
+        :simple_value => Proc.new { '666' },
+        :reference    => Proc.new { self['foo'] }
+      }
+      @manager.apply_config(source)
+
+      assert_equal 'bar', @manager[:foo]
+      assert_equal '666', @manager[:simple_value]
+      assert_equal 'bar', @manager[:reference]
+
+      @manager.remove_config(source)
+    end
+
+    def test_source_accessors_should_be_available_as_keys
+      source = TestSource.new
+      @manager.apply_config(source)
+
+      assert_equal 'some value', @manager[:test_config_accessor]
+
+      @manager.remove_config(source)
+    end
+
+    def test_should_not_apply_removed_sources
+      test_source = TestSource.new
+      @manager.apply_config(test_source)
+      @manager.remove_config(test_source)
+
+      assert_equal nil, @manager['test_config_accessor']
+    end
+
+    def test_should_read_license_key_from_env
+      ENV['NEWRELIC_LICENSE_KEY'] = 'right'
+      manager = NewRelic::Agent::Configuration::Manager.new
+      manager.apply_config({:license_key => 'wrong'}, 1)
+
+      assert_equal 'right', manager['license_key']
+    end
+
+    def test_config_values_should_be_memoized
+      @manager.apply_config(:setting => 'correct value')
+      assert_equal 'correct value', @manager[:setting]
+
+      @manager.config_stack.unshift(:setting => 'wrong value')
+      assert_equal 'correct value', @manager[:setting]
+    end
+
+    def test_flattened_config
+      @manager.instance_variable_set(:@config_stack, [])
+      @manager.apply_config(:eins => Proc.new { self[:one] })
+      @manager.apply_config(:one => 1)
+      @manager.apply_config(:two => 2)
+      @manager.apply_config(:three => 3)
+
+      assert_equal({ :eins => 1, :one => 1, :two => 2, :three => 3 },
+                   @manager.flattened_config)
+    end
+
+    class TestSource < ::Hash
+      def test_config_accessor
+        'some value'
+      end
+    end
+  end
+end

data/test/new_relic/agent/configuration/server_source_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/configuration/server_source'
+
+module NewRelic::Agent::Configuration
+  class ServerSourceTest < Test::Unit::TestCase
+    def setup
+      config = {
+        'slow_sql.enabled'                         => true,
+        'transaction_tracer.transaction_threshold' => 'apdex_f',
+        'error_collector.enabled'                  => true,
+        'collect_errors'                           => false
+      }
+      @source = ServerSource.new(config)
+    end
+
+    def test_should_enable_tracer_as_configured
+      assert @source[:'slow_sql.enabled']
+    end
+
+    def test_should_disable_tracer_as_configured
+      assert !@source[:'error_collector.enabled']
+    end
+
+    def test_should_ignore_apdex_f_setting_for_transaction_threshold
+      assert_equal nil, @source[:'transaction_tracer.transaction_threshold']
+    end
+  end
+end

data/test/new_relic/agent/configuration/yaml_source_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/configuration/yaml_source'
+
+module NewRelic::Agent::Configuration
+  class YamlSourceTest < Test::Unit::TestCase
+    def setup
+      test_yml_path = File.expand_path(File.join(File.dirname(__FILE__),
+                                                 '..','..','..',
+                                                 'config','newrelic.yml'))
+      @source = YamlSource.new(test_yml_path, 'test')
+    end
+
+    def test_should_load_given_yaml_file
+      assert_equal '127.0.0.1', @source[:api_host]
+    end
+
+    def test_should_apply_erb_transformations
+      assert_equal 'heyheyhey', @source[:erb_value]
+      assert_equal '', @source[:message]
+      assert_equal '', @source[:license_key]
+    end
+
+    def test_config_booleans
+      assert_equal true, @source[:tval]
+      assert_equal false, @source[:fval]
+      assert_nil @source[:not_in_yaml_val]
+      assert_equal true, @source[:yval]
+      assert_equal 'sure', @source[:sval]
+    end
+
+    def test_appnames
+      assert_equal %w[a b c], @source[:app_name]
+    end
+
+    def test_should_load_the_config_for_the_correct_env
+      assert_not_equal 'the.wrong.host', @source[:host]
+    end
+
+    def test_should_convert_to_dot_notation
+      assert_equal 'raw', @source[:'transaction_tracer.record_sql']
+    end
+
+    def test_should_ignore_apdex_f_setting_for_transaction_threshold
+      assert_equal nil, @source[:'transaction_tracer.transaction_threshold']
+    end
+
+    def test_should_correctly_handle_floats
+      assert_equal 1.1, @source[:apdex_t]
+    end
+
+    def test_should_log_if_no_file_is_found
+      NewRelic::Control.instance.log.expects(:error)
+      source = YamlSource.new('no_such_file.yml', 'test')
+    end
+  end
+end