newrelic_rpm 3.5.4.35.beta → 3.5.5.38

data/test/multiverse/suites/logging/Envfile

@@ -0,0 +1,4 @@
+gemfile <<-RB
+  gem 'rack'
+  gem 'mocha', '< 0.13', :require => false
+RB

data/test/multiverse/suites/logging/config/newrelic.yml

@@ -0,0 +1,22 @@
+---
+development:
+  error_collector:
+    capture_source: true
+    enabled: false
+  apdex_t: 0.5
+  ssl: false
+  monitor_mode: true
+  license_key: bootstrap_newrelic_admin_license_key_000
+  developer_mode: false
+  app_name: test
+  host: 127.0.0.1
+  api_host: 127.0.0.1
+  port: 30303
+  transaction_tracer:
+    record_sql: obfuscated
+    enabled: true
+    stack_trace_threshold: 0.5
+    transaction_threshold: 1.0
+  capture_params: false
+  log_level: debug
+  disable_serialization: false

data/test/multiverse/suites/logging/logging_test.rb

@@ -0,0 +1,143 @@
+# RUBY-980 Improve logging
+# This test suite is for checking IMPORTANT conditions that we log rather than
+# trying to do this via brittle unit tests
+
+require 'logger'
+require 'newrelic_rpm'
+require 'fake_collector'
+require 'mocha'
+
+class LoggingTest < Test::Unit::TestCase
+
+  def test_logs_app_name
+    running_agent_writes_to_log( 
+       {:app_name => "My App"},
+       "Application: My App")
+  end
+
+  def test_logs_error_with_bad_app_name
+    running_agent_writes_to_log( 
+       {:app_name => false},
+        "Unable to determine application name.")
+  end
+
+  def test_logs_dispatcher
+    dispatcher = "Y U NO SERVER WEBPAGE"
+
+    running_agent_writes_to_log(
+      {:dispatcher => dispatcher},
+      dispatcher)
+  end
+
+  def test_logs_missing_dispatcher
+    running_agent_writes_to_log(
+      {:dispatcher => ''},
+      "No dispatcher detected")
+  end
+
+  def test_logs_raw_sql_warning
+    NewRelic::Agent.config.apply_config(:'transaction_tracer.record_sql' => 'obfuscated')
+
+    running_agent_writes_to_log(
+      {:'transaction_tracer.record_sql' => 'raw'},
+      "Agent is configured to send raw SQL to the service")
+  end
+
+  def test_logs_if_sending_errors_on_change
+    NewRelic::Agent.config.apply_config(:'error_collector.enabled' => false)
+
+    running_agent_writes_to_log(
+      {:'error_collector.enabled' => true},
+      "Errors will be sent")
+  end
+
+  def test_logs_if_not_sending_errors_on_change
+    NewRelic::Agent.config.apply_config(:'error_collector.enabled' => true)
+
+    running_agent_writes_to_log(
+      {:'error_collector.enabled' => false},
+      "Errors will not be sent")
+  end
+
+  def test_logs_transaction_tracing_disabled
+    running_agent_writes_to_log(
+      {:'transaction_tracer.enabled' => false},
+      "Transaction traces will not be sent")
+  end
+
+  def test_invalid_license_key
+    with_connect_response(401)
+    running_agent_writes_to_log({},
+      "Visit NewRelic.com to obtain a valid license key")
+  end
+
+  def test_logs_monitor_mode_disabled
+    running_agent_writes_to_log(
+      {:monitor_mode => false },
+      "Agent configured not to send data in this environment.")
+  end
+
+  def test_logs_mising_license_key
+    running_agent_writes_to_log(
+      { :license_key => false },
+      "No license key found in newrelic.yml config.")
+  end
+
+  def test_logs_invalid_license_key
+    running_agent_writes_to_log(
+      { :license_key => 'a' * 30 },
+      "Invalid license key: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
+  end
+
+  def test_logs_forking_workers
+    running_agent_writes_to_log(
+      { :dispatcher => :passenger },
+      "Connecting workers after forking.")
+  end
+
+  # Initialization
+  def setup
+    $collector ||= NewRelic::FakeCollector.new
+    $collector.reset
+    $collector.mock['connect'] = [200, {'return_value' => {"agent_run_id" => 666 }}]
+    $collector.run
+
+    NewRelic::Agent.reset_config 
+    NewRelic::Agent.agent = NewRelic::Agent::Agent.new
+    NewRelic::Control.instance(true)
+
+    @logger = NewRelic::Agent::MemoryLogger.new
+    NewRelic::Agent.logger = @logger
+    NewRelic::Agent::AgentLogger.stubs(:new).with(any_parameters).returns(@logger)
+  end
+
+  def teardown
+    $collector.reset
+  end
+
+  # Helpers
+  def running_agent_writes_to_log(options, msg)
+    run_agent_with(options) do
+      saw?(msg)
+    end
+  end
+
+  def with_connect_response(status=200, response={})
+    $collector.mock['connect'] = [status, response]
+  end
+
+  def run_agent_with(options = {})
+    NewRelic::Agent.manual_start(options)
+    NewRelic::Agent.shutdown
+    yield
+  end
+
+  def saw?(*expected_messages)
+    flattened = @logger.messages.flatten
+    expected_messages.each do |expected|
+      found = flattened.any? {|msg| msg.to_s.include?(expected)}
+      @logger.messages.each {|msg| puts msg.inspect} if !found
+      assert(found, "Didn't see message '#{expected}'")
+    end
+  end
+end

data/test/multiverse/suites/no_load/config/newrelic.yml

@@ -13,11 +13,10 @@ development:
   api_host: 127.0.0.1
   port: 30303
   transaction_tracer:
-    record_sql: obfuscated
+    record_sql: raw
     enabled: true
     stack_trace_threshold: 0.5
     transaction_threshold: 1.0
   capture_params: false
   log_level: debug
-  #log_file_path: STDOUT
   disable_serialization: false

data/test/multiverse/suites/rum_auto_instrumentation/sanity_test.rb

@@ -76,19 +76,6 @@ class RumAutoTest < Test::Unit::TestCase
     assert(!last_response.body.include?(%'NREUMQ'))
   end
 
-  # regression
-  def test_autoinstrumenation_fails_gracefully_with_js_that_contains_embedded_html_tags
-    # we got this one from a customer
-    # https://support.newrelic.com/tickets/14208
-    MyApp.response = File.read(File.dirname(__FILE__) + '/problem_response.html')
-    get '/'
-
-    # assert that our js is inserted at the end of the head tag, and not in the
-    # middle of his script tag.
-    assert(!last_response.body.include?(%'NREUMQ'))
-  end
-
-
   def test_autoinstrumenation_doesnt_run_for_crazy_shit_like_this
     MyApp.response = '<html><head <body </body>'
     get '/'

data/test/new_relic/agent/agent/connect_test.rb

@@ -12,14 +12,19 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     @connect_retry_period = 0
     @transaction_sampler = NewRelic::Agent::TransactionSampler.new
     @sql_sampler = NewRelic::Agent::SqlSampler.new
+    @error_collector = NewRelic::Agent::ErrorCollector.new
     server = NewRelic::Control::Server.new('localhost', 30303)
     @service = NewRelic::Agent::NewRelicService.new('abcdef', server)
-    log.stubs(:warn => true, :info => true, :debug => true)
+    @test_config = { :developer_mode => true }
+    NewRelic::Agent.config.apply_config(@test_config)
+  end
+
+  def teardown
+    NewRelic::Agent.config.remove_config(@test_config)
   end
 
   def control
-    fake_control = OpenStruct.new('validate_seed' => false,
-                                  'local_env' => OpenStruct.new('snapshot' => []))
+    fake_control = OpenStruct.new('local_env' => OpenStruct.new('snapshot' => []))
     fake_control.instance_eval do
       def [](key)
         return nil
@@ -75,7 +80,6 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   def test_should_retry_true
     @keep_retrying = true
     @connect_attempts = 1
-    log.expects(:info).once
     self.expects(:increment_retry_period!).once
     assert should_retry?, "should retry in this circumstance"
     assert_equal 2, @connect_attempts, "should be on the second attempt"
@@ -100,44 +104,25 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   end
 
   def test_log_error
-    error = mock('error')
-    error.expects(:backtrace).once.returns(["line", "secondline"])
-    error.expects(:message).once.returns("message")
-    fake_control = mock()
-    fake_control.expects(:server).returns("server")
-    self.expects(:control).once.returns(fake_control)
-    log.expects(:error).with("Error establishing connection with New Relic Service at server: message")
-    log.expects(:debug).with("line\nsecondline")
+    error = StandardError.new("message")
+
+    expects_logging(:error, 
+      includes("Error establishing connection with New Relic Service"), \
+      instance_of(StandardError))
+
     log_error(error)
   end
 
   def test_handle_license_error
-    error = mock('error')
+    error = mock(:message => "error message")
     self.expects(:disconnect).once
-    log.expects(:error).once.with("error message")
-    log.expects(:info).once.with("Visit NewRelic.com to obtain a valid license key, or to upgrade your account.")
-    error.expects(:message).returns("error message")
     handle_license_error(error)
   end
 
-  def test_log_seed_token
-    with_config(:validate_seed => 'many seeds', :validate_token => 'a token, man') do
-      log.expects(:debug).with("Connecting with validation seed/token: many seeds/a token, man").once
-      log_seed_token
-    end
-  end
-
-  def test_no_seed_token
-    with_config(:validate_seed => false) do
-      log.expects(:debug).never
-      log_seed_token
-    end
-  end
-
   def test_environment_for_connect_positive
-    fake_env = mock('local_env')
-    fake_env.expects(:snapshot).once.returns("snapshot")
-    NewRelic::Control.instance.expects(:local_env).once.returns(fake_env)
+    fake_env = stub('local_env', :discovered_dispatcher => nil)
+    fake_env.expects(:snapshot).returns("snapshot")
+    NewRelic::Control.instance.expects(:local_env).at_least_once.returns(fake_env)
     with_config(:send_environment_info => true) do
       assert_equal 'snapshot', environment_for_connect
     end
@@ -149,62 +134,20 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     end
   end
 
-  def test_validate_settings
-    with_config(:validate_seed => 'seed', :validate_token => 'token') do
-      assert_equal 'seed', NewRelic::Agent.instance.validate_settings[:seed]
-      assert_equal 'token', NewRelic::Agent.instance.validate_settings[:token]
-    end
-  end
-
   def test_connect_settings
     control = mocked_control
     NewRelic::Agent.config.expects(:app_names)
-    self.expects(:validate_settings)
     self.expects(:environment_for_connect)
-    keys = %w(pid host app_name language agent_version environment settings validate)
+    keys = %w(pid host app_name language agent_version environment settings)
     value = connect_settings
     keys.each do |k|
       assert(value.has_key?(k.to_sym), "should include the key #{k}")
     end
   end
 
-  def test_configure_error_collector_base
-    error_collector = NewRelic::Agent::ErrorCollector.new
-    NewRelic::Control.instance.log.stubs(:debug)
-    NewRelic::Control.instance.log.expects(:debug) \
-      .with("Errors will not be sent to the New Relic service.").at_least_once
-    with_config(:'error_collector.enabled' => false) do
-      # noop
-    end
-  end
-
-  def test_configure_error_collector_enabled
-    with_config(:'error_collector.enabled' => false) do
-      error_collector = NewRelic::Agent::ErrorCollector.new
-      NewRelic::Control.instance.log.stubs(:debug)
-      NewRelic::Control.instance.log.expects(:debug) \
-        .with("Errors will be sent to the New Relic service.").at_least_once
-      with_config(:'error_collector.enabled' => true) do
-        # noop
-      end
-    end
-  end
-
-  def test_configure_error_collector_server_disabled
-    error_collector = NewRelic::Agent::ErrorCollector.new
-    NewRelic::Control.instance.log.stubs(:debug)
-    NewRelic::Control.instance.log.expects(:debug) \
-      .with("Errors will not be sent to the New Relic service.").at_least_once
-    config = NewRelic::Agent::Configuration::ServerSource.new('collect_errors' => false)
-    with_config(config) do
-      # noop
-    end
-  end
-
   def test_configure_transaction_tracer_with_random_sampling
     with_config(:'transaction_tracer.transaction_threshold' => 5,
                 :'transaction_tracer.random_sample' => true) do
-      log.stubs(:debug)
       sample = TransactionSampleTestHelper.make_sql_transaction
       @transaction_sampler.store_sample(sample)
 
@@ -225,9 +168,6 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
   end
 
   def test_configure_transaction_tracer_server_disabled
-    @transaction_sampler.stubs(:log).returns(log)
-    log.stubs(:debug)
-    log.expects(:debug).with('Transaction traces will not be sent to the New Relic service.')
     config = NewRelic::Agent::Configuration::ServerSource.new('collect_traces' => false,
                                                               'developer_mode' => false)
     with_config(config) do
@@ -302,6 +242,8 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
       'collect_traces' => true,
       'collect_errors' => true,
       'sample_rate' => 10,
+      'cross_process_id' => '1#234',
+      'encoding_key'     => 'a' * 30,
       'agent_config' => { 'transaction_tracer.record_sql' => 'raw' }
     }
     self.expects(:log_connection!).with(config)
@@ -311,10 +253,17 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     with_config(:'transaction_tracer.enabled' => true) do
       finish_setup(config)
       assert_equal 'fishsticks', @service.agent_id
+      assert_equal '1#234', @cross_process_id
+      assert_equal 'a'  * 30, @cross_process_encoding_key
+      assert_equal [97] * 30, @cross_process_encoding_bytes
       assert_equal 'raw', NewRelic::Agent.config[:'transaction_tracer.record_sql']
     end
   end
 
+  def test_get_bytes_with_nil
+    assert_equal [], get_bytes(nil)
+  end
+
   def test_logging_collector_messages
     NewRelic::Agent.manual_start
     service = NewRelic::FakeService.new
@@ -325,9 +274,8 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
                      { 'message' => 'ha cha cha', 'level' => 'WARN' }]
     }
 
-    NewRelic::Control.instance.log.stubs(:info)
-    NewRelic::Control.instance.log.expects(:info).with('beep boop')
-    NewRelic::Control.instance.log.expects(:warn).with('ha cha cha')
+    expects_logging(:info, 'beep boop')
+    expects_logging(:warn, 'ha cha cha')
 
     NewRelic::Agent.agent.query_server_for_configuration
     NewRelic::Agent.shutdown
@@ -363,22 +311,12 @@ class NewRelic::Agent::Agent::ConnectTest < Test::Unit::TestCase
     fake_control
   end
 
-  def mocked_log
-    fake_log = mock('log')
-    self.stubs(:log).returns(fake_log)
-    fake_log
-  end
-
   def mocked_error_collector
     fake_collector = mock('error collector')
     self.stubs(:error_collector).returns(fake_collector)
     fake_collector
   end
 
-  def log
-    @logger ||= Object.new
-  end
-
   def assert_accessor(sym)
     var_name = "@#{sym}"
     instance_variable_set(var_name, 1)

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

@@ -14,8 +14,7 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   end
 
   def test_already_started_positive
-    control = mocked_control
-    control.expects(:log!).with("Agent Started Already!", :error)
+    ::Logger.any_instance.expects(:error).with("Agent Started Already!")
     self.expects(:started?).returns(true)
     assert already_started?, "should have already started"
   end
@@ -37,55 +36,6 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
     end
   end
 
-  def test_log_dispatcher_positive
-    log = mocked_log
-    with_config(:dispatcher => 'Y U NO SERVE WEBPAGE') do
-      log.expects(:info).with("Dispatcher: Y U NO SERVE WEBPAGE")
-      log_dispatcher
-    end
-  end
-
-  def test_log_dispatcher_negative
-    log = mocked_log
-    with_config(:dispatcher => '') do
-      log.expects(:info).with("No dispatcher detected.")
-      log_dispatcher
-    end
-  end
-
-  def test_log_app_names_string
-    with_config(:app_name => 'zam;zam;zabam') do
-      log = mocked_log
-      log.expects(:info).with("Application: zam, zam, zabam")
-      log_app_names
-    end
-  end
-
-  def test_log_app_names_array
-    with_config(:app_name => ['zam', 'zam', 'zabam']) do
-      log = mocked_log
-      log.expects(:info).with("Application: zam, zam, zabam")
-      log_app_names
-    end
-  end
-
-  def test_log_app_names_with_env_var
-    # bad app name after env - used to cover the yaml config
-    with_config({:app_name => false}, 1) do
-      log = mocked_log
-      log.expects(:info).with("Application: start_test") # set in setup
-      log_app_names
-    end
-  end
-
-  def test_log_app_names_with_unknown
-    with_config(:app_name => false) do
-      log = mocked_log
-      log.expects(:error).with('Unable to determine application name. Please set the application name in your newrelic.yml or in a NEW_RELIC_APP_NAME environment variable.')
-      log_app_names
-    end
-  end
-
   def test_check_config_and_start_agent_disabled
     self.expects(:monitoring?).returns(false)
     check_config_and_start_agent
@@ -165,30 +115,14 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
     end
   end
 
-  def test_notify_log_file_location_positive
-    log = mocked_log
-    NewRelic::Control.instance.expects(:log_file).returns('./')
-    log.expects(:send).with(:info, "Agent Log at ./")
-    notify_log_file_location
-  end
-
-  def test_notify_log_file_location_negative
-    log = mocked_log
-    NewRelic::Control.instance.expects(:log_file).returns(nil)
-    notify_log_file_location
-  end
-
   def test_monitoring_positive
     with_config(:monitor_mode => true) do
-      log = mocked_log
       assert monitoring?
     end
   end
 
   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.")
       assert !monitoring?
     end
   end
@@ -201,8 +135,6 @@ 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(:warn, 'No license key found in newrelic.yml config.')
       assert !has_license_key?
     end
   end
@@ -226,16 +158,12 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
 
   def test_correct_license_length_negative
     with_config(:license_key => 'a' * 30) do
-      log = mocked_log
-      log.expects(:send).with(:error, "Invalid license key: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
       assert !correct_license_length
     end
   end
 
   def test_using_forking_dispatcher_positive
     with_config(:dispatcher => :passenger) do
-      log = mocked_log
-      log.expects(:send).with(:info, "Connecting workers after forking.")
       assert using_forking_dispatcher?
     end
   end
@@ -250,16 +178,15 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
     # should not log
     assert log_unless(true, :warn, "DURRR")
   end
+
   def test_log_unless_negative
     # should log
-    log = mocked_log
-    log.expects(:send).with(:warn, "DURRR")
+    expects_logging(:warn, "DURRR")
     assert !log_unless(false, :warn, "DURRR")
   end
 
   def test_log_if_positive
-    log = mocked_log
-    log.expects(:send).with(:warn, "WHEE")
+    expects_logging(:warn, "WHEE")
     assert log_if(true, :warn, "WHEE")
   end
 
@@ -269,13 +196,6 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
 
   private
 
-  def mocked_log
-    fake_log = mock('log')
-    self.stubs(:log).returns(fake_log)
-    fake_log
-  end
-
-
   def mocked_control
     fake_control = mock('control')
     self.stubs(:control).returns(fake_control)