sundawg_newrelic_rpm 3.5.8.1

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

@@ -0,0 +1,163 @@
+# 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
+    running_agent_writes_to_log(
+      {:'transaction_tracer.record_sql' => 'obfuscated'},
+      "Agent is configured to send raw SQL to the service") do
+
+      NewRelic::Agent.config.apply_config(:'transaction_tracer.record_sql' => 'raw')
+    end
+
+  end
+
+  def test_logs_ssl_warning
+    running_agent_writes_to_log(
+      {:ssl => false},
+      "Agent is configured not to use SSL when communicating with New Relic's servers") do
+
+      NewRelic::Agent.config.apply_config(:ssl => false)
+    end
+  end
+
+  def test_logs_ssl_verify_cert_warning
+    running_agent_writes_to_log(
+      {:ssl => false, :verify_certificate => false},
+      "Agent is configured to use SSL but to skip certificate validation when communicating with New Relic's servers") do
+
+      NewRelic::Agent.config.apply_config(:ssl => true, :verify_certificate => false)
+    end
+  end
+
+
+  def test_logs_if_sending_errors_on_change
+    running_agent_writes_to_log(
+      {:'error_collector.enabled' => false},
+      "Errors will be sent") do
+
+      NewRelic::Agent.config.apply_config(:'error_collector.enabled' => true)
+    end
+  end
+
+  def test_logs_if_not_sending_errors_on_change
+    running_agent_writes_to_log(
+      {:'error_collector.enabled' => true},
+      "Errors will not be sent") do
+
+      NewRelic::Agent.config.apply_config(:'error_collector.enabled' => false)
+    end
+  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.instance_variable_set(:@instance, nil)
+
+    @logger = NewRelic::Agent::MemoryLogger.new
+    NewRelic::Agent.logger = @logger
+    NewRelic::Agent::AgentLogger.stubs(:new).with(any_parameters).returns(@logger)
+  end
+
+  def teardown
+    $collector.reset
+
+    # Really clear out our agent instance since we set bad license keys
+    NewRelic::Agent::Agent.instance_variable_set(:@instance, nil)
+  end
+
+  # Helpers
+  def running_agent_writes_to_log(options, msg)
+    NewRelic::Agent.manual_start(options)
+    yield if block_given?
+    NewRelic::Agent.shutdown
+    saw?(msg)
+  end
+
+  def with_connect_response(status=200, response={})
+    $collector.mock['connect'] = [status, response]
+  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/agent_only/marshaling_test.rb

@@ -0,0 +1,96 @@
+# https://newrelic.atlassian.net/wiki/display/eng/The+Terror+and+Glory+of+Transaction+Traces
+# https://newrelic.atlassian.net/browse/RUBY-914
+
+class MarshalingTest < Test::Unit::TestCase
+  def setup
+    NewRelic::Agent.manual_start(:'transaction_tracer.transaction_threshold' => 0.0)
+    @agent = NewRelic::Agent.instance
+    @sampler = @agent.transaction_sampler
+
+    $collector ||= NewRelic::FakeCollector.new
+    $collector.reset
+    $collector.mock['connect'] = [200, {'return_value' => { 'agent_run_id' => 666 }}]
+    $collector.run
+  end
+
+  def teardown
+    Thread.current[:transaction_sample_builder] = nil
+    $collector.reset
+  end
+
+  def test_transaction_trace_marshaling
+    # create fake transaction trace
+    time = Time.now.to_f
+    @sampler.notice_first_scope_push time
+    @sampler.notice_transaction '/path', nil, {}
+    @sampler.notice_push_scope "a"
+    @sampler.notice_push_scope "ab"
+    sleep 1
+    @sampler.notice_pop_scope "ab"
+    @sampler.notice_pop_scope "a"
+    @sampler.notice_scope_empty
+
+    expected_sample = @sampler.instance_variable_get(:@slowest_sample)
+
+    @agent.service.connect
+    @agent.send(:harvest_and_send_slowest_sample)
+
+    if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
+      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+    else
+      marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+    end
+
+    assert_equal('666', $collector.calls_for('transaction_sample_data')[0].run_id)
+    assert_equal(expected_sample.to_collector_array(marshaller.default_encoder),
+                 $collector.calls_for('transaction_sample_data')[0][1][0])
+  end
+
+  def test_metric_data_marshalling
+    stats = NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Custom/test/method')
+    stats.record_data_point(1.0)
+    stats.record_data_point(2.0, 1.0)
+    expected = [ 2, 3.0, 2.0, 1.0, 2.0, 5.0 ]
+
+    @agent.service.connect
+    @agent.send(:harvest_and_send_timeslice_data)
+
+    assert_equal('666', $collector.calls_for('metric_data')[0].run_id)
+
+    custom_metric = $collector.reported_stats_for_metric('Custom/test/method')[0]
+    assert_equal(expected, custom_metric)
+  end
+
+  def test_error_data_marshalling
+    @agent.error_collector.notice_error(Exception.new('test error'))
+    @agent.service.connect
+    @agent.send(:harvest_and_send_errors)
+
+    assert_equal('666', $collector.calls_for('error_data')[0].run_id)
+
+    error_data = $collector.calls_for('error_data')[0][1][0]
+    assert_equal('test error', error_data[2])
+  end
+
+  def test_sql_trace_data_marshalling
+    @agent.sql_sampler.notice_first_scope_push(nil)
+    @agent.sql_sampler.notice_sql("select * from test",
+                                  "Database/test/select",
+                                  nil, 1.5)
+    @agent.sql_sampler.notice_scope_empty
+
+    @agent.service.connect
+    @agent.send(:harvest_and_send_slowest_sql)
+
+    sql_data = $collector.calls_for('sql_trace_data')[0][0]
+    assert_equal('select * from test', sql_data[0][3])
+  end
+
+  def test_connect_marshalling
+    @agent.service.connect('pid' => 1, 'agent_version' => '9000',
+                           'app_name' => 'test')
+
+    connect_data = $collector.calls_for('connect')[0]
+    assert_equal '9000', connect_data['agent_version']
+  end
+end

data/test/multiverse/suites/agent_only/method_visibility_test.rb

@@ -0,0 +1,98 @@
+require 'multiverse/color'
+
+class MethodVisibilityTest < Test::Unit::TestCase
+  extend Multiverse::Color
+  
+  class InstrumentedClass
+    include NewRelic::Agent::MethodTracer
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+    def public_method!
+    end
+
+    def public_transaction!
+    end
+
+    private
+    def private_method!
+    end
+
+    def private_transaction!
+    end
+
+    protected
+    def protected_method!
+    end
+
+    def protected_transaction!
+    end
+
+    add_method_tracer :public_method!
+    add_method_tracer :private_method!
+    add_method_tracer :protected_method!
+
+    add_transaction_tracer :public_transaction!
+    add_transaction_tracer :private_transaction!
+    add_transaction_tracer :protected_transaction!
+  end
+
+
+  class ObjectWithInstrumentation
+    include NewRelic::Agent::MethodTracer
+    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  end
+
+  class ObjectWithTracers < ObjectWithInstrumentation
+    private
+    def a_private_method
+    end
+    def a_private_transaction
+    end
+    protected
+    def a_protected_method
+    end
+    def a_protected_transaction
+    end
+
+    add_method_tracer :a_private_method
+    add_method_tracer :a_protected_method
+    add_transaction_tracer :a_private_transaction
+    add_transaction_tracer :a_protected_transaction
+  end
+
+
+  def setup
+    @instance = InstrumentedClass.new
+  end
+  
+  if NewRelic::VERSION::STRING >= '3.4.0.2'
+    %w| public private protected |.each do |visibility|
+      define_method "test_should_preserve_visibility_of_#{visibility}_traced_method" do
+        assert @instance.send("#{visibility}_methods").map{|s|s.to_sym}.include?(:"#{visibility}_method!"), "Method #{visibility}_method should be #{visibility}"
+      end
+      
+      define_method "test_should_preserve_visibility_of_#{visibility}_traced_transaction" do
+        assert @instance.send("#{visibility}_methods").map{|s|s.to_sym}.include?(:"#{visibility}_transaction!"), "Transcation #{visibility}_transaction should be #{visibility}"
+      end
+    end
+
+    def test_tracing_non_public_methods_doesnt_add_public_methods
+      assert_equal [], ObjectWithTracers.public_instance_methods - ObjectWithInstrumentation.public_instance_methods
+    end
+
+    # FIXME: Currently including MethodTracer and ControllerInstrumentation
+    # adds a bunch of public methods to the class.  It probably shouldn't do this.
+    #def test_instrumentation_doesnt_add_any_public_methods
+    #  assert_equal [], ObjectWithInstrumentation.public_instance_methods - Object.public_instance_methods
+    #end
+    #
+
+
+
+  else
+    def test_truth
+      assert true # jruby freaks out if there are no tests defined in the test class
+    end
+    puts yellow('SKIPPED! 3.4.0.1 and earlier fail preserve_visibility tests')
+  end
+end

data/test/multiverse/suites/agent_only/no_dns_resolv.rb

@@ -0,0 +1,17 @@
+
+class NoDnsResolv < Test::Unit::TestCase
+  def test_should_no_resolve_hostname_when_agent_is_disabled
+    Resolv.expects(:getaddress).never
+    NewRelic::Agent.manual_start(:monitor_mode => false)
+  end
+
+  def setup
+    NewRelic::Agent::Agent.instance_variable_set(:@instance, NewRelic::Agent::Agent.new)
+  end
+
+  def teardown
+    $collector.reset
+    NewRelic::Agent.shutdown
+    NewRelic::Agent::Agent.instance_variable_set(:@instance, nil)
+  end
+end

data/test/multiverse/suites/agent_only/pipe_manager_test.rb

@@ -0,0 +1,33 @@
+# https://newrelic.atlassian.net/browse/RUBY-669
+
+class PipeManagerTest < Test::Unit::TestCase
+  def setup
+    @listener = NewRelic::Agent::PipeChannelManager.listener
+  end
+
+  def teardown
+    @listener.stop
+  end
+  
+  def test_old_pipes_are_cleaned_up_after_timeout
+    @listener.timeout = 1
+    NewRelic::Agent::PipeChannelManager.register_report_channel(:timeout_test)
+    sleep 2
+    @listener.start
+    sleep 0.5 # give the thread some time to start, and clean things up
+    assert_nil NewRelic::Agent::PipeChannelManager.channels[:timeout_test]
+  end
+
+  def test_pipes_are_regularly_checked_for_freshness
+    @listener.select_timeout = 1
+    @listener.timeout = 2
+    NewRelic::Agent::PipeChannelManager.register_report_channel(:select_test)
+    
+    sleep 1.5
+    @listener.start
+    assert NewRelic::Agent::PipeChannelManager.channels[:select_test]
+    
+    sleep 1.5
+    assert_nil NewRelic::Agent::PipeChannelManager.channels[:select_test]
+  end
+end

data/test/multiverse/suites/agent_only/rename_rule_test.rb

@@ -0,0 +1,57 @@
+class RenameRuleTest < Test::Unit::TestCase
+  class TestWidget
+    include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+    def txn
+      mthd
+    end
+    add_transaction_tracer :txn
+
+    def mthd
+      'doot de doo'
+    end
+    add_method_tracer :mthd
+  end
+
+  def setup
+    $collector ||= NewRelic::FakeCollector.new
+    $collector.reset
+    txn_rule_specs = [ { 'match_expression' => 'RenameRuleTest',
+                         'replacement' => 'Class' } ]
+    metric_rule_specs = [ { 'match_expression' => 'RenameRuleTest',
+                            'replacement' => 'Class' } ]
+    $collector.mock['connect'] = [200, {'return_value' => {
+                                      "agent_run_id" => 666,
+                            'transaction_name_rules' => txn_rule_specs,
+                                 'metric_name_rules' => metric_rule_specs
+                                    }}]
+    $collector.run
+
+    NewRelic::Agent.manual_start(:sync_startup => true,
+                                 :force_reconnect => true)
+    TestWidget.new.txn
+  end
+
+  def teardown
+    NewRelic::Agent.shutdown
+  end
+
+  def test_transaction_name_rules
+    metric_names = ::NewRelic::Agent.instance.stats_engine.metrics
+    assert(metric_names.include?('Controller/Class::TestWidget/txn'),
+           "'Controller/Class::TestWidget/txn' not found in #{metric_names}")
+    assert(metric_names.include?('Apdex/Class::TestWidget/txn'),
+           "'Apdex/Class::TestWidget/txn' not found in #{metric_names}")
+    assert(!metric_names.include?('Controller/RenameRuleTest::TestWidget/txn'),
+           "'Controller/RenameRuleTest::TestWidget/txn' should not be in #{metric_names}")
+  end
+
+  def test_metric_name_rules
+    NewRelic::Agent.instance.send(:harvest_and_send_timeslice_data)
+    metric_names = $collector.calls_for('metric_data')[0].body[3].map{|m| m[0]['name']}
+    assert(metric_names.include?('Custom/Class::TestWidget/mthd'),
+           "'Custom/Class::TestWidget/mthd' not found in #{metric_names}")
+    assert(!metric_names.include?('Custom/RenameRuleTest::TestWidget/mthd'),
+           "'Custom/RenameRuleTest::TestWidget/mthd' should not be in #{metric_names}")
+  end
+end