newrelic_rpm 4.0.0.332 → 4.4.0.336

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

@@ -1,39 +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 AgentRunIdHandlingTest < Minitest::Test
-  include MultiverseHelpers
-
-  NON_NUMERIC_RUN_ID = 'some-crazy-non-integer-thing'
-
-  setup_and_teardown_agent do
-    $collector.stub('connect', { "agent_run_id" => NON_NUMERIC_RUN_ID })
-  end
-
-  # This test verifies that the Ruby agent is able to accept non-numeric values
-  # of the agent run ID handed down by the collector in response to the connect
-  # method. This is required for agent protocol version 14.
-  def test_handles_non_numeric_agent_run_ids
-    NewRelic::Agent.agent.send(:transmit_data)
-    metric_data_post = $collector.calls_for('metric_data').last
-    assert_equal(NON_NUMERIC_RUN_ID, metric_data_post[0])
-  end
-
-  # The sql_data endpoint sends the agent run ID as a query string parameter,
-  # rather than embedded within the body, so make sure we handle that.
-  def test_handles_non_numeric_agent_run_id_on_slow_sql_traces
-    simulate_slow_sql_trace
-    sql_data_post = $collector.calls_for('sql_trace_data').last
-    assert_equal(NON_NUMERIC_RUN_ID, sql_data_post.query_params['run_id'])
-  end
-
-  def simulate_slow_sql_trace
-    in_transaction do
-      agent.sql_sampler.notice_sql("select * from test", "Database/test/select", nil, 1.5)
-    end
-    NewRelic::Agent.agent.send(:harvest_and_send_slowest_sql)
-  end
-end

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

@@ -1,57 +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-981 Audit Log
-
-require 'newrelic_rpm'
-
-class AuditLogTest < Minitest::Test
-  include MultiverseHelpers
-
-  def setup
-    @string_log = StringIO.new
-    NewRelic::Agent::AuditLogger.any_instance.stubs(:ensure_log_path).returns(@string_log)
-  end
-
-  def audit_log_contents
-    if @contents.nil?
-      @string_log.rewind
-      @contents = @string_log.read
-    end
-    @contents
-  end
-
-  def test_logs_nothing_by_default
-    run_agent do
-      perform_actions
-      assert_equal('', audit_log_contents)
-    end
-  end
-
-  def test_logs_nothing_when_disabled
-    run_agent(:'audit_log.enabled' => false) do
-      perform_actions
-      assert_equal('', audit_log_contents)
-    end
-  end
-
-  def test_logs_request_bodies_human_readably_ish
-    run_agent(:'audit_log.enabled' => true) do
-      perform_actions
-      $collector.agent_data.each do |req|
-        assert_audit_log_contains_object(audit_log_contents, req.body)
-      end
-    end
-  end
-
-  def perform_actions
-    state = NewRelic::Agent::TransactionState.tl_get
-    NewRelic::Agent.instance.sql_sampler.on_start_transaction(state, nil)
-    NewRelic::Agent.instance.sql_sampler.notice_sql("select * from test",
-                                 "Database/test/select",
-                                 nil, 1.5, state)
-    NewRelic::Agent.instance.sql_sampler.on_finishing_transaction(state, 'txn')
-    NewRelic::Agent.instance.send(:harvest_and_send_slowest_sql)
-  end
-end

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

@@ -1,87 +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 CollectorExceptionHandlingTest < Minitest::Test
-  include MultiverseHelpers
-
-  setup_and_teardown_agent do
-    NewRelic::Agent.agent.stubs(:sleep)
-  end
-
-  def after_setup
-    # there's a call to sleep in handle_force_restart that we want to skip
-    $collector.reset
-  end
-
-
-  RESTART_PAYLOAD       = { 'error_type' => 'NewRelic::Agent::ForceRestartException'    }
-  DISCONNECT_PAYLOAD    = { 'error_type' => 'NewRelic::Agent::ForceDisconnectException' }
-  RUNTIME_ERROR_PAYLOAD = { 'error_type' => 'RuntimeError'                              }
-
-
-  def test_should_reconnect_on_force_restart_exception
-    # We stub these exceptions because we want the EventLoop to exit with a
-    # ForceRestartException the first time through, then (after reconnecting)
-    # we force the disconnect so that this test will end cleanly.
-
-    $collector.stub_exception('metric_data'       , RESTART_PAYLOAD   ).once
-    $collector.stub_exception('get_agent_commands', DISCONNECT_PAYLOAD).once
-
-    with_config(:data_report_period => 0) do
-      NewRelic::Agent.agent.deferred_work!({})
-    end
-
-    assert_equal(2, $collector.calls_for('connect').size)
-
-    # We expect one metric_data post that the collector responds to with the
-    # ForceRestartException, and then another that gets through successfully.
-    metric_data_calls = $collector.calls_for('metric_data')
-    assert_equal(2, metric_data_calls.size)
-    refute_equal(metric_data_calls[0].run_id, metric_data_calls[1].run_id)
-  end
-
-  def test_should_stop_reporting_after_force_disconnect
-    $collector.stub_exception('metric_data', DISCONNECT_PAYLOAD).once
-
-    with_config(:data_report_period => 0) do
-      NewRelic::Agent.agent.deferred_work!({})
-    end
-
-    assert_equal(1, $collector.calls_for('connect').size)
-    assert_equal(1, $collector.calls_for('metric_data').size)
-  end
-
-  def test_should_stop_reporting_after_force_disconnect_on_connect
-    $collector.stub_exception('connect', DISCONNECT_PAYLOAD).once
-
-    with_config(:data_report_period => 0) do
-      NewRelic::Agent.agent.deferred_work!({})
-    end
-
-    assert_equal(1, $collector.calls_for('connect').size)
-  end
-
-  def test_should_reconnect_on_connect_exception
-    $collector.stub_exception('connect', RUNTIME_ERROR_PAYLOAD).once
-    $collector.stub_exception('metric_data', DISCONNECT_PAYLOAD).once
-
-    with_config(:data_report_period => 0) do
-      NewRelic::Agent.agent.deferred_work!({})
-    end
-
-    assert_equal(2, $collector.calls_for('connect').size)
-  end
-
-  def test_should_reconnect_on_get_redirect_host_exception
-    $collector.stub_exception('get_redirect_host', RUNTIME_ERROR_PAYLOAD).once
-    $collector.stub_exception('metric_data', DISCONNECT_PAYLOAD).once
-
-    with_config(:data_report_period => 0) do
-      NewRelic::Agent.agent.deferred_work!({})
-    end
-
-    assert_equal(2, $collector.calls_for('get_redirect_host').size)
-    assert_equal(1, $collector.calls_for('connect').size)
-  end
-end

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

@@ -1,27 +0,0 @@
----
-development:
-  error_collector:
-    enabled: true
-  apdex_t: 0.24
-  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: <%= $collector ||= nil; $collector && $collector.port %>
-  transaction_tracer:
-    record_sql: obfuscated
-    enabled: true
-    stack_trace_threshold: 0.5
-  capture_params: false
-  browser_monitoring:
-    auto_instrument: true
-  labels:
-    Server: Yaml
-
-# A few tests use this in confirming behavior around mis-matched environments
-# Doesn't need to actually support running the agent in production mode.
-production:
-  enabled: false

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

@@ -1,94 +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 'rack/test'
-require 'fake_collector'
-require './testing_app'
-require 'new_relic/rack/agent_hooks'
-
-class CrossApplicationTracingTest < Minitest::Test
-  include MultiverseHelpers
-  setup_and_teardown_agent(:cross_process_id => "boo",
-                           :encoding_key => "\0",
-                           :trusted_account_ids => [1]) \
-  do |collector|
-    collector.stub('connect', {
-      'agent_run_id' => 666,
-      'transaction_name_rules' => [{"match_expression" => "ignored_transaction",
-                                    "ignore"           => true}]})
-  end
-
-  include Rack::Test::Methods
-
-  def app
-    Rack::Builder.app { run TestingApp.new }
-  end
-
-  def test_cross_app_doesnt_modify_without_header
-    get '/'
-    assert_nil last_response.headers["X-NewRelic-App-Data"]
-  end
-
-  def test_cross_app_doesnt_modify_with_invalid_header
-    get '/', nil, {'HTTP_X_NEWRELIC_ID' => Base64.encode64('otherjunk')}
-    assert_nil last_response.headers["X-NewRelic-App-Data"]
-  end
-
-  def test_cross_app_writes_out_information
-    get '/', nil, {'HTTP_X_NEWRELIC_ID' => Base64.encode64('1#234')}
-    refute_nil last_response.headers["X-NewRelic-App-Data"]
-    assert_metrics_recorded(['ClientApplication/1#234/all'])
-  end
-
-  def test_cross_app_doesnt_modify_if_txn_is_ignored
-    get '/', {'transaction_name' => 'ignored_transaction'}, {'HTTP_X_NEWRELIC_ID' => Base64.encode64('1#234')}
-    assert_nil last_response.headers["X-NewRelic-App-Data"]
-  end
-
-  def test_cross_app_error_attaches_process_id_to_intrinsics
-    assert_raises(RuntimeError) do
-      get '/', {'fail' => 'true'}, {'HTTP_X_NEWRELIC_ID' => Base64.encode64('1#234')}
-    end
-
-    assert_includes attributes_for(last_traced_error, :intrinsic), :client_cross_process_id
-  end
-
-  load_cross_agent_test("cat_map").each do |test_case|
-    # We only can do test cases here that don't involve outgoing calls
-    if !test_case["outboundRequests"]
-      if test_case['inboundPayload']
-        request_headers = {
-          'HTTP_X_NEWRELIC_ID'          => Base64.encode64('1#234'),
-          'HTTP_X_NEWRELIC_TRANSACTION' => json_dump_and_encode(test_case['inboundPayload'])
-        }
-      else
-        request_headers = {}
-      end
-
-      define_method("test_#{test_case['name']}") do
-        txn_name_parts = test_case['transactionName'].split('/')
-        txn_category   = txn_name_parts[0..1].join('/')
-        txn_name       = txn_name_parts[2..-1].join('/')
-
-        request_params = {
-          'transaction_name' => txn_name,
-          'transaction_category' => txn_category,
-          'guid' => test_case['transactionGuid']
-        }
-
-        with_config('app_name' => test_case['appName']) do
-          get '/', request_params, request_headers
-        end
-
-        event = get_last_analytics_event
-        assert_event_attributes(
-          event,
-          test_case['name'],
-          test_case['expectedIntrinsicFields'],
-          test_case['nonExpectedIntrinsicFields']
-        )
-      end
-    end
-  end
-end

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

@@ -1,82 +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 CustomAnalyticsEventsTest < Minitest::Test
-  include MultiverseHelpers
-
-  setup_and_teardown_agent
-
-  def test_custom_analytics_events_are_submitted
-    t0 = freeze_time
-    NewRelic::Agent.record_custom_event(:DummyType, :foo => :bar, :baz => :qux)
-
-    NewRelic::Agent.agent.send(:harvest_and_send_analytic_event_data)
-    events = last_posted_events
-
-    expected_event = [{'type' => 'DummyType', 'timestamp' => t0.to_i },
-                      {'foo' => 'bar', 'baz' => 'qux'}]
-    assert_equal(expected_event, events.first)
-  end
-
-  def test_record_custom_event_returns_falsy_if_event_was_dropped
-    max_samples = NewRelic::Agent.config[:'custom_insights_events.max_samples_stored']
-    max_samples.times do
-      NewRelic::Agent.record_custom_event(:DummyType, :foo => :bar)
-    end
-
-    result = NewRelic::Agent.record_custom_event(:DummyType, :foo => :bar)
-    refute(result)
-  end
-
-  def test_record_doesnt_record_if_invalid_event_type
-    bad_event_type  = 'bad$news'
-    good_event_type = 'good news'
-
-    NewRelic::Agent.record_custom_event(bad_event_type,  :foo => :bar)
-    NewRelic::Agent.record_custom_event(good_event_type, :foo => :bar)
-
-    NewRelic::Agent.agent.send(:harvest_and_send_analytic_event_data)
-    events = last_posted_events
-
-    assert_equal(1, events.size)
-    assert_equal(good_event_type, events.first[0]['type'])
-  end
-
-  def test_events_are_not_recorded_when_disabled_by_feature_gate
-    connect_response = {
-      'agent_run_id'          => 1,
-      'collect_custom_events' => false
-    }
-
-    $collector.stub('connect', connect_response)
-
-    trigger_agent_reconnect
-
-    NewRelic::Agent.record_custom_event('whatever', :foo => :bar)
-
-    NewRelic::Agent.agent.send(:harvest_and_send_analytic_event_data)
-    assert_equal(0, $collector.calls_for(:custom_event_data).size)
-  end
-
-  def test_post_includes_metadata
-    10.times do |i|
-      NewRelic::Agent.record_custom_event(:DummyType, :foo => :bar, :baz => :qux, :i => i)
-    end
-
-    NewRelic::Agent.agent.send(:harvest_and_send_analytic_event_data)
-    post = last_custom_event_post
-
-    assert_equal({"reservoir_size"=>1000, "events_seen"=>10}, post.reservoir_metadata)
-  end
-
-  def last_custom_event_post
-    posts = $collector.calls_for('custom_event_data')
-    assert_equal(1, posts.size)
-    posts.first
-  end
-
-  def last_posted_events
-    last_custom_event_post.events
-  end
-end

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

@@ -1,60 +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 CustomQueueTimeTest < Minitest::Test
-  include MultiverseHelpers
-
-  setup_and_teardown_agent
-
-  DummyRequest = Struct.new(:headers, :cookies) do
-    def path
-      "/"
-    end
-  end
-
-  class DummyApp
-    include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
-    def run_transaction(request, simulated_queue_time)
-      opts = { :name => 'run_transaction', :class_name => 'DummyApp', :request => request }
-
-      advance_time(simulated_queue_time)
-
-      perform_action_with_newrelic_trace(opts) do
-        # nothing
-      end
-    end
-  end
-
-  def setup
-    freeze_time
-    @headers = { 'HTTP_X_REQUEST_START' => "t=#{Time.now.to_f}" }
-  end
-
-  def test_pulls_request_headers_from_passed_in_rack_request
-    request = Rack::Request.new(@headers)
-    DummyApp.new.run_transaction(request, 10)
-
-    assert_metrics_recorded(
-      'WebFrontend/QueueTime' => {
-        :call_count      => 1,
-        :total_call_time => 10
-      }
-    )
-  end
-
-  def test_pulls_request_headers_from_passed_in_request_responding_to_headers
-    request = DummyRequest.new(@headers, {})
-    DummyApp.new.run_transaction(request, 10)
-
-    assert_metrics_recorded(
-      'WebFrontend/QueueTime' => {
-        :call_count      => 1,
-        :total_call_time => 10
-      }
-    )
-  end
-end

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

@@ -1,122 +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 EncodingHandlingTest < Minitest::Test
-  include MultiverseHelpers
-
-  setup_and_teardown_agent
-
-  def test_handles_mis_encoded_database_queries
-    with_config(:'transaction_tracer.transaction_threshold' => 0.0,
-      :'transaction_tracer.record_sql' => :raw) do
-      in_transaction do
-        state = NewRelic::Agent::TransactionState.tl_get
-        agent.transaction_sampler.notice_sql(bad_string, nil, 42, state)
-      end
-      assert_endpoint_received_string('transaction_sample_data', normalized_bad_string)
-    end
-  end
-
-  def test_handles_mis_encoded_request_params
-    with_config(:'capture_params' => true,
-      :'transaction_tracer.transaction_threshold' => 0.0) do
-      options = { :filtered_params => { bad_string => bad_string }}
-      in_transaction(options) do
-        # nothin
-      end
-    end
-    assert_endpoint_received_string('transaction_sample_data', normalized_bad_string)
-  end
-
-  def test_handles_mis_encoded_custom_attributes
-    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
-      in_transaction do
-        NewRelic::Agent.add_custom_attributes(:foo => bad_string)
-      end
-    end
-    assert_endpoint_received_string('transaction_sample_data', normalized_bad_string)
-  end
-
-  def test_handles_mis_encoded_custom_attributes_on_analytics_events
-    in_transaction(:category => :controller) do
-      NewRelic::Agent.add_custom_attributes(:foo => bad_string)
-    end
-    assert_endpoint_received_string('analytic_event_data', normalized_bad_string)
-  end
-
-  def test_handles_mis_encoded_custom_attributes_on_errors
-    NewRelic::Agent.notice_error('bad news', :custom_params => {'foo' => bad_string})
-    assert_endpoint_received_string('error_data', normalized_bad_string)
-  end
-
-  def test_handles_mis_encoded_exception_message
-    NewRelic::Agent.notice_error(bad_string)
-    assert_endpoint_received_string('error_data', normalized_bad_string)
-  end
-
-  def test_handles_mis_encoded_metric_names
-    NewRelic::Agent.record_metric(bad_string, 42)
-    assert_endpoint_received_string('metric_data', normalized_bad_string)
-  end
-
-  def test_handles_mis_encoded_transaction_names
-    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
-      in_transaction do
-        NewRelic::Agent.set_transaction_name(bad_string)
-      end
-    end
-    expected_transaction_name = "other/#{normalized_bad_string}"
-    assert_endpoint_received_string('transaction_sample_data', expected_transaction_name)
-  end
-
-  def test_handles_mis_encoded_strings_in_environment_report
-    $collector.reset
-    ::NewRelic::EnvironmentReport.report_on('Dummy') do
-      bad_string
-    end
-    agent.instance_variable_set(:@environment_report, agent.environment_for_connect)
-    agent.connect_to_server
-    assert_endpoint_received_string('connect', normalized_bad_string)
-  end
-
-  def assert_endpoint_received_string(endpoint, string)
-    agent.send(:transmit_data)
-    agent.send(:transmit_event_data)
-    requests = $collector.calls_for(endpoint)
-    assert_equal(1, requests.size)
-    request = requests.first
-    request.decode! if request.respond_to?(:decode!)
-    assert_contains_string(request, string)
-  end
-
-  def assert_contains_string(request, string)
-    object_graph = request.body
-    object_graph = request.samples if request.respond_to?(:samples)
-    assert object_graph_contains_string?(request.body, string), "Did not find desired string in #{request.body.inspect}"
-  end
-
-  def object_graph_contains_string?(object_graph, string)
-    case object_graph
-    when String
-      string == object_graph
-    when Array
-      object_graph.any? { |x| object_graph_contains_string?(x, string) }
-    when Hash
-      (
-        object_graph_contains_string?(object_graph.keys, string) ||
-        object_graph_contains_string?(object_graph.values, string)
-      )
-    else
-      false
-    end
-  end
-
-  def bad_string
-    [128].to_a.pack("C*").force_encoding('UTF-8')
-  end
-
-  def normalized_bad_string
-    bad_string.force_encoding('ISO-8859-1').encode('UTF-8')
-  end
-end

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

@@ -1,98 +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 ErrorEventsTest < Minitest::Test
-  include MultiverseHelpers
-
-  setup_and_teardown_agent do
-    freeze_time
-  end
-
-  def test_error_events_are_submitted
-    txn = generate_errors
-
-    NewRelic::Agent.agent.send(:harvest_and_send_error_event_data)
-
-    intrinsics, _, _ = last_error_event
-
-    assert_equal txn.best_name, intrinsics["transactionName"]
-    assert_equal "RuntimeError", intrinsics["error.class"]
-    assert_equal "Big Controller", intrinsics["error.message"]
-    assert_equal "TransactionError", intrinsics["type"]
-    assert_equal txn.payload[:duration], intrinsics["duration"]
-  end
-
-  def test_records_supportability_metrics
-    with_config :'error_collector.max_event_samples_stored' => 10 do
-      generate_errors 15
-
-      NewRelic::Agent.agent.send(:harvest_and_send_error_event_data)
-
-      assert_metrics_recorded({
-        "Supportability/Events/TransactionError/Sent" => {:call_count => 10},
-        "Supportability/Events/TransactionError/Seen" => {:call_count => 15}
-      })
-    end
-  end
-
-  def test_does_not_record_error_events_when_disabled
-    with_config :'error_collector.capture_events' => false do
-      generate_errors 5
-
-      NewRelic::Agent.agent.send(:harvest_and_send_error_event_data)
-      assert_equal(0, $collector.calls_for(:error_event_data).size)
-    end
-  end
-
-  def test_does_not_record_error_events_when_disabled_by_feature_gate
-
-    $collector.stub('connect', {
-      'agent_run_id'          => 1,
-      'collect_error_events' => false
-    })
-    trigger_agent_reconnect
-
-    generate_errors 5
-
-    NewRelic::Agent.agent.send(:harvest_and_send_error_event_data)
-    assert_equal(0, $collector.calls_for(:error_event_data).size)
-
-    # reset the collect_error_events flag so that the ErrorEventAggregator
-    # will be enabled for the next test
-    $collector.stub('connect', {
-      'agent_run_id'          => 1,
-      'collect_error_events' => true
-    })
-
-    trigger_agent_reconnect
-  end
-
-  def test_error_events_created_outside_of_transaction
-    NewRelic::Agent.notice_error RuntimeError.new "No Txn"
-    NewRelic::Agent.agent.send(:harvest_and_send_error_event_data)
-
-    intrinsics, _, _ = last_error_event
-
-    assert_equal "TransactionError", intrinsics["type"]
-    assert_in_delta Time.now.to_f, intrinsics["timestamp"], 0.001
-    assert_equal "RuntimeError", intrinsics["error.class"]
-    assert_equal "No Txn", intrinsics["error.message"]
-  end
-
-  def generate_errors num_errors = 1
-    in_transaction :transaction_name => "Controller/blogs/index" do |t|
-      num_errors.times { t.notice_error RuntimeError.new "Big Controller" }
-    end
-  end
-
-  def last_error_event
-    post = last_error_event_post
-    assert_equal(1, post.events.size)
-    post.events.last
-  end
-
-  def last_error_event_post
-    $collector.calls_for(:error_event_data).first
-  end
-end