RubyGems - newrelic_rpm - Versions diffs - 4.0.0.332 → 6.13.1 - Mend

newrelic_rpm 4.0.0.332 → 6.13.1

Files changed (1193) hide show

data/test/multiverse/suites/agent_only/http_response_code_test.rb DELETED

@@ -1,38 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-# https://newrelic.atlassian.net/browse/RUBY-765
-require 'fake_collector'
-class HttpResponseCodeTest < Minitest::Test
-  include MultiverseHelpers
-  setup_and_teardown_agent
-  def test_request_entity_too_large
-    $collector.stub_exception('metric_data', {'error_type' => 'RuntimeError', 'message' => 'too much'}, 413)
-    NewRelic::Agent.increment_metric('Custom/too_big')
-    assert_metrics_recorded(['Custom/too_big'])
-    agent.send(:harvest_and_send_timeslice_data)
-    # make sure the data gets thrown away after we called collector without crashing
-    assert_metrics_not_recorded(['Custom/too_big'])
-    assert_equal(1, $collector.calls_for('metric_data').size)
-  end
-  def test_unsupported_media_type
-    $collector.stub_exception('metric_data', {'error_type' => 'RuntimeError', 'message' => 'looks bad'}, 415)
-    NewRelic::Agent.increment_metric('Custom/too_big')
-    assert_metrics_recorded(['Custom/too_big'])
-    agent.send(:harvest_and_send_timeslice_data)
-    # make sure the data gets thrown away after we called collector without crashing
-    assert_metrics_not_recorded(['Custom/too_big'])
-    assert_equal(1, $collector.calls_for('metric_data').size)
-  end
-end

data/test/multiverse/suites/agent_only/keepalive_test.rb DELETED

@@ -1,24 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-require 'newrelic_rpm'
-class KeepaliveTest < Minitest::Test
-  include MultiverseHelpers
-  def test_can_reestablish_connection
-    setup_agent(:aggressive_keepalive => true)
-    NewRelic::Agent.agent.send(:transmit_data)
-    # This is simulating the remote peer closing the TCP connection between
-    # harvest cycles.
-    $collector.last_socket.close
-    NewRelic::Agent.agent.send(:transmit_data)
-    metric_data_calls = $collector.calls_for('metric_data')
-    assert_equal(2, metric_data_calls.size)
-  end
-end

data/test/multiverse/suites/agent_only/key_transactions_test.rb DELETED

@@ -1,118 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-class KeyTransactionsTest < Minitest::Test
-  include MultiverseHelpers
-  WEB_KEY_TXN   = 'Controller/KeyTransactionsTest::TestWidget/key_txn'
-  OTHER_KEY_TXN = 'OtherTransaction/SidekiqJob/JobClass/key_txn'
-  OTHER_TXN     = 'OtherTransaction/SidekiqJob/JobClass/other_txn'
-  setup_and_teardown_agent do |collector|
-    collector.stub('connect', {
-      'web_transactions_apdex' => {
-        WEB_KEY_TXN   => 1,
-        OTHER_KEY_TXN => 1
-      },
-      'apdex_t' => 10
-    })
-  end
-  def after_setup
-    freeze_time
-  end
-  class TestWidget
-    include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
-    def key_txn
-      advance_time(5)
-    end
-    add_transaction_tracer :key_txn
-    def other_txn
-      advance_time(5)
-    end
-    add_transaction_tracer :other_txn
-  end
-  class TestBackgroundWidget
-    def key_txn
-      job(OTHER_KEY_TXN)
-    end
-    def other_txn
-      job(OTHER_TXN)
-    end
-    def job(name)
-      state = ::NewRelic::Agent::TransactionState.tl_get
-      ::NewRelic::Agent::Transaction.wrap(state, name, :other) do
-        advance_time(5)
-      end
-    end
-  end
-  SATISFYING = 0
-  TOLERATING = 1
-  FAILING    = 2
-  def test_applied_correct_apdex_t_to_key_txn
-    TestWidget.new.key_txn
-    NewRelic::Agent.instance.send(:harvest_and_send_timeslice_data)
-    stats = $collector.reported_stats_for_metric('Apdex')[0]
-    assert_equal(1.0, stats[FAILING],
-                 "Expected stats (#{stats}) to be apdex failing")
-  end
-  def test_applied_correct_apdex_t_to_regular_txn
-    TestWidget.new.other_txn
-    NewRelic::Agent.instance.send(:harvest_and_send_timeslice_data)
-    stats = $collector.reported_stats_for_metric('Apdex')[0]
-    assert_equal(1.0, stats[SATISFYING],
-                 "Expected stats (#{stats}) to be apdex satisfying")
-  end
-  def test_applied_correct_tt_theshold
-    TestWidget.new.key_txn
-    TestWidget.new.other_txn
-    NewRelic::Agent.instance.send(:harvest_and_send_transaction_traces)
-    traces = $collector.calls_for('transaction_sample_data')
-    assert_equal 1, traces.size
-    assert_equal(WEB_KEY_TXN, traces[0].metric_name)
-  end
-  def test_applied_correct_apdex_t_to_background_key_txn
-    TestBackgroundWidget.new.key_txn
-    NewRelic::Agent.instance.send(:harvest_and_send_timeslice_data)
-    stats = $collector.reported_stats_for_metric('ApdexOther')[0]
-    assert_equal(1.0, stats[FAILING],
-                 "Expected stats (#{stats}) to be apdex failing")
-  end
-  def test_no_apdex_for_regular_background_txn
-    TestBackgroundWidget.new.other_txn
-    NewRelic::Agent.instance.send(:harvest_and_send_timeslice_data)
-    assert_empty $collector.reported_stats_for_metric('ApdexOther')
-  end
-  def test_applied_correct_tt_theshold_to_background
-    TestBackgroundWidget.new.key_txn
-    TestBackgroundWidget.new.other_txn
-    NewRelic::Agent.instance.send(:harvest_and_send_transaction_traces)
-    traces = $collector.calls_for('transaction_sample_data')
-    assert_equal 1, traces.size
-    assert_equal(OTHER_KEY_TXN, traces[0].metric_name)
-  end
-end

data/test/multiverse/suites/agent_only/labels_test.rb DELETED

@@ -1,83 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-require 'fake_collector'
-class LabelsTest < Minitest::Test
-  include MultiverseHelpers
-  setup_and_teardown_agent
-  EXPECTED     = [{'label_type' => 'Server', 'label_value' => 'East'}]
-  YML_EXPECTED = [{'label_type' => 'Server', 'label_value' => 'Yaml'}]
-  def test_yaml_makes_it_to_the_collector
-    # Relies on the agent_only/config/newrelic.yml!
-    trigger_agent_reconnect
-    assert_connect_had_labels(YML_EXPECTED)
-  end
-  def test_labels_from_config_hash_make_it_to_the_collector
-    with_config("labels" => { "Server" => "East" }) do
-      trigger_agent_reconnect
-      assert_connect_had_labels(EXPECTED)
-    end
-  end
-  def test_labels_from_manual_start_hash_make_it_to_the_collector
-    trigger_agent_reconnect(:labels => { "Server" => "East" })
-    assert_connect_had_labels(EXPECTED)
-  end
-  def test_numeric_values_for_labels
-    trigger_agent_reconnect(:labels => { "Server" => 42 })
-    expected = [
-      { 'label_type' => 'Server', 'label_value' => '42' }
-    ]
-    assert_connect_had_labels(expected)
-  end
-  def test_boolean_values_for_labels
-    trigger_agent_reconnect(:labels => { "Server" => true })
-    expected = [
-      { 'label_type' => 'Server', 'label_value' => 'true' }
-    ]
-    assert_connect_had_labels(expected)
-  end
-  # All testing of string parsed label pairs should go through the cross agent
-  # test file for labels. Our dictionary passing is custom to Ruby, though.
-  load_cross_agent_test("labels").each do |testcase|
-    define_method("test_#{testcase['name']}_from_config_string") do
-      with_config("labels" => testcase["labelString"]) do
-        trigger_agent_reconnect
-        assert_connect_had_labels(testcase["expected"])
-      end
-    end
-    define_method("test_#{testcase['name']}_from_manual_start") do
-      trigger_agent_reconnect(:labels => testcase["labelString"])
-      assert_connect_had_labels(testcase["expected"])
-    end
-    define_method("test_#{testcase['name']}_from_env") do
-      begin
-        # Value must be here before reset for EnvironmentSource to see it
-        ENV['NEW_RELIC_LABELS'] = testcase["labelString"]
-        NewRelic::Agent.config.reset_to_defaults
-        trigger_agent_reconnect
-        assert_connect_had_labels(testcase["expected"])
-      ensure
-        ENV['NEW_RELIC_LABELS'] = nil
-      end
-    end
-  end
-  def assert_connect_had_labels(expected)
-    result = $collector.calls_for('connect').last['labels']
-    assert_equal expected.sort_by { |h| h['label_type']},
-                 result.sort_by { |h| h['label_type']}
-  end
-end

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

@@ -1,162 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-# 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'
-class LoggingTest < Minitest::Test
-  include MultiverseHelpers
-  def setup
-    NewRelic::Agent.stubs(:logger).returns(NewRelic::Agent::MemoryLogger.new)
-  end
-  def teardown
-    NewRelic::Agent.config.reset_to_defaults
-  end
-  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},
-        "No application name configured.")
-  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 known 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.add_config_for_testing(:'transaction_tracer.record_sql' => 'raw')
-    end
-  end
-  def test_logs_ssl_warning
-    running_agent_writes_to_log(
-      {},
-      "Agent is configured not to use SSL when communicating with New Relic's servers") do
-      NewRelic::Agent.config.add_config_for_testing(:ssl => true )
-      NewRelic::Agent.config.add_config_for_testing(:ssl => false)
-    end
-  end
-  def test_logs_if_sending_errors_on_change
-    running_agent_writes_to_log(
-      {:'error_collector.enabled' => false},
-      "Error traces will be sent") do
-      NewRelic::Agent.config.add_config_for_testing(:'error_collector.enabled' => true)
-    end
-  end
-  def test_logs_if_not_sending_errors_on_change
-    running_agent_writes_to_log(
-      {:'error_collector.enabled' => true},
-      "Error traces will not be sent") do
-      NewRelic::Agent.config.add_config_for_testing(:'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
-    setup_agent({}) do |collector|
-      collector.stub('connect', {}, 401)
-    end
-    saw?("Visit NewRelic.com to obtain a valid license key")
-    teardown_agent
-  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_missing_license_key
-    running_agent_writes_to_log(
-      { :license_key => false },
-      "No license key found.")
-  end
-  def test_logs_blank_license_key
-    running_agent_writes_to_log(
-      { :license_key => '' },
-      "No license key found.")
-  end
-  def test_logs_invalid_license_key
-    running_agent_writes_to_log(
-      { :license_key => 'a' * 30 },
-      "Invalid license key: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
-  end
-  def test_logs_unknown_config_setting_from_environment
-    env_var = 'NEW_RELIC_TOTORO'
-    setting = env_var.gsub(/NEW_RELIC_|NEWRELIC_/,'').downcase
-    running_agent_writes_to_log({}, "#{env_var} does not have a corresponding configuration setting (#{setting} does not exist).") do
-      ENV[env_var] = 'Ponyo'
-      NewRelic::Agent::Configuration::EnvironmentSource.new
-      ENV.delete(env_var)
-    end
-  end
-  def test_logs_forking_workers
-    running_agent_writes_to_log(
-      { :dispatcher => :passenger },
-      "Deferring startup of agent reporting thread")
-  end
-  # Helpers
-  def running_agent_writes_to_log(options, msg, &block)
-    run_agent(options, &block)
-    saw?(msg)
-  end
-  def saw?(*expected_messages)
-    # This is actually our MemoryLogger, so it has messages to check. Woot!
-    logger = NewRelic::Agent.logger
-    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 DELETED

@@ -1,89 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-# https://newrelic.atlassian.net/wiki/display/eng/The+Terror+and+Glory+of+Transaction+Traces
-# https://newrelic.atlassian.net/browse/RUBY-914
-require 'ostruct'
-class MarshalingTest < Minitest::Test
-  include MultiverseHelpers
-  include NewRelic::Agent::MethodTracer
-  setup_and_teardown_agent(:'transaction_tracer.transaction_threshold' => 0.0) do |collector|
-    collector.stub('connect', { 'agent_run_id' => 666 })
-  end
-  def test_transaction_trace_marshaling
-    freeze_time
-    in_transaction do
-      trace_execution_scoped('a') do
-        trace_execution_scoped('ab') do
-          advance_time 1
-        end
-      end
-    end
-    expected_sample = NewRelic::Agent.instance.transaction_sampler.last_sample
-    agent.service.connect
-    agent.send(:harvest_and_send_transaction_traces)
-    actual = $collector.calls_for('transaction_sample_data')[0][1][0]
-    encoder = NewRelic::Agent::NewRelicService::Encoders::Identity
-    expected = expected_sample.to_collector_array(encoder)
-    expected = NewRelic::Agent::EncodingNormalizer.normalize_object(expected)
-    assert_equal(expected, actual)
-  end
-  def test_metric_data_marshalling
-    metric = 'Custom/test/method'
-    NewRelic::Agent.record_metric metric, 1.0
-    NewRelic::Agent.record_metric metric, 2.0
-    expected = [ 2, 3.0, 3.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
-    in_transaction do
-      agent.sql_sampler.notice_sql("select * from test", "Database/test/select",
-                                    nil, 1.5)
-    end
-    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').last
-    assert_equal '9000', connect_data['agent_version']
-  end
-end