newrelic_rpm 4.0.0.332 → 4.8.0.341

data/test/new_relic/agent/agent_test_controller.rb

@@ -1,84 +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.
-
-# Defining a test controller class with a superclass, used to
-# verify correct attribute inheritence
-class NewRelic::Agent::SuperclassController <  ActionController::Base
-  def base_action
-    render :text => 'none'
-  end
-end
-# This is a controller class used in testing controller instrumentation
-class NewRelic::Agent::AgentTestController < NewRelic::Agent::SuperclassController
-  include NewRelic::TestHelpers::Exceptions
-  # filter_parameter_logging :social_security_number
-
-  @@headers_to_add = nil
-
-  def index
-    sleep params['wait'].to_f if params['wait']
-    render :text => params.inspect
-  end
-  def _filter_parameters(params)
-    filter_parameters params
-  end
-  def action_inline
-    render(:inline => "<%= 'foo' %>fah")
-  end
-
-  def action_to_render
-    render :text => params.inspect
-  end
-  def action_to_ignore
-    render :text => 'unmeasured'
-  end
-  def action_to_ignore_apdex
-    render :text => 'unmeasured'
-  end
-  before_filter :oops, :only => :action_with_before_filter_error
-  def action_with_before_filter_error
-    render :text => 'nothing'
-  end
-  def oops
-    raise "error in before filter"
-  end
-
-  def rescue_action_locally(exception)
-    if exception.is_a? TestException
-      raise "error in the handler"
-    end
-  end
-  def action_with_error
-    raise "error in action"
-  end
-  def entry_action
-    perform_action_with_newrelic_trace(:name => 'internal_action') do
-      internal_action
-    end
-  end
-
-  def self.set_some_headers(hash_of_headers)
-    if ::Rails::VERSION::MAJOR.to_i == 4
-      NewRelic::Agent.instance.events.notify(:before_call, hash_of_headers)
-    else
-      @@headers_to_add ||= {}
-      @@headers_to_add.merge!(hash_of_headers)
-    end
-  end
-
-  def self.clear_headers
-    @@headers_to_add = nil
-  end
-
-  def newrelic_request_headers(_)
-    @@headers_to_add ||= {}
-  end
-
-  private
-  def internal_action
-    perform_action_with_newrelic_trace(:name => 'internal_traced_action', :force => true) do
-      render :text => 'internal action'
-    end
-  end
-end

data/test/new_relic/agent/apdex_from_server_test.rb

@@ -1,13 +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 File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-
-class NewRelic::Agent::ApdexFromServerTest < Minitest::Test
-
-  def test_true
-    # we need tests in this file - TBD
-    assert true
-  end
-end

data/test/new_relic/agent/api_tests/datastore_api_test.rb

@@ -1,64 +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 File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
-require 'new_relic/agent/transaction'
-
-module NewRelic
-  module Agent
-    class DatastoreApiTest < Minitest::Test
-      def setup
-        freeze_time
-        NewRelic::Agent.drop_buffered_data
-      end
-
-      load_cross_agent_test('datastores/datastore_api').each do |test|
-        define_method :"test_#{test['test_name'].tr(' ', '_')}" do
-          NewRelic::Agent::Hostname.stubs(:get).returns(test['input']['system_hostname'])
-
-          params = test['input']['parameters']
-          txn_helper_method = test['input']['is_web'] ? :in_web_transaction : :in_background_transaction
-          config = test['input']['configuration'].merge(:disable_harvest_thread => true)
-
-          with_config config do
-            send(txn_helper_method) do
-              segment = NewRelic::Agent::Transaction.start_datastore_segment(
-                params['product'], params['operation'], params['collection'],
-                params['host'], params['port_path_or_id'], params['database_name']
-              )
-              segment.notice_sql "select * from foo"
-              advance_time 2.0
-              segment.finish
-            end
-
-            host, port_path_or_id, database_name =
-              test['expectation']['transaction_segment_and_slow_query_trace'].values_at('host', 'port_path_or_id', 'database_name')
-
-            segment_name = test['expectation']['metrics_scoped'][0]
-
-            assert_metrics_recorded test['expectation']['metrics_unscoped']
-            assert_expected_tt_segment_params segment_name, host, port_path_or_id, database_name
-            assert_expected_slow_sql_params host, port_path_or_id, database_name
-          end
-        end
-      end
-
-      def assert_expected_tt_segment_params segment_name, host, port_path_or_id, database_name
-        trace = last_transaction_trace
-        segment = find_node_with_name trace, segment_name
-
-        assert_equal host, segment[:host]
-        assert_equal port_path_or_id, segment[:port_path_or_id]
-        assert_equal database_name, segment[:database_name]
-      end
-
-      def assert_expected_slow_sql_params host, port_path_or_id, database_name
-        sql_trace = last_sql_trace
-
-        assert_equal host, sql_trace.params[:host]
-        assert_equal port_path_or_id, sql_trace.params[:port_path_or_id]
-        assert_equal database_name, sql_trace.params[:database_name]
-      end
-    end
-  end
-end

data/test/new_relic/agent/attribute_filter_test.rb

@@ -1,218 +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 File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-
-require 'new_relic/agent/attribute_filter'
-require 'pp'
-
-module NewRelic::Agent
-  class AttributeFilterTest < Minitest::Test
-    test_cases = load_cross_agent_test("attribute_configuration")
-    test_cases.each do |test_case|
-      define_method("test_#{test_case['testname'].gsub(/\W/, "_")}") do
-        with_config(test_case['config']) do
-          filter = AttributeFilter.new(NewRelic::Agent.config)
-
-          attribute_name            = test_case['input_key']
-          desired_destination_names = test_case['input_default_destinations']
-
-          desired_destinations  = to_bitfield(desired_destination_names)
-          actual_destinations   = filter.apply(attribute_name, desired_destinations)
-          expected_destinations = to_bitfield(test_case['expected_destinations'])
-
-          assert_equal(to_names(expected_destinations), to_names(actual_destinations),
-                       PP.pp(test_case, "") + PP.pp(filter.rules, ""))
-        end
-      end
-    end
-
-    def test_allows?
-      with_all_enabled do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        default_destination = AttributeFilter::DST_ALL
-
-        assert filter.allows?(default_destination, AttributeFilter::DST_TRANSACTION_EVENTS)
-        assert filter.allows?(default_destination, AttributeFilter::DST_TRANSACTION_TRACER)
-        assert filter.allows?(default_destination, AttributeFilter::DST_ERROR_COLLECTOR)
-        assert filter.allows?(default_destination, AttributeFilter::DST_BROWSER_MONITORING)
-      end
-    end
-
-    def test_allows_with_restricted_default_destination
-      with_all_enabled do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        default_destination = AttributeFilter::DST_ERROR_COLLECTOR
-
-        assert filter.allows?(default_destination, AttributeFilter::DST_ERROR_COLLECTOR)
-
-        refute filter.allows?(default_destination, AttributeFilter::DST_TRANSACTION_EVENTS)
-        refute filter.allows?(default_destination, AttributeFilter::DST_TRANSACTION_TRACER)
-        refute filter.allows?(default_destination, AttributeFilter::DST_BROWSER_MONITORING)
-      end
-    end
-
-
-    def test_allows_with_multiple_default_destinations
-      with_all_enabled do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        default_destination = AttributeFilter::DST_ERROR_COLLECTOR|AttributeFilter::DST_TRANSACTION_TRACER
-
-        assert filter.allows?(default_destination, AttributeFilter::DST_ERROR_COLLECTOR)
-        assert filter.allows?(default_destination, AttributeFilter::DST_TRANSACTION_TRACER)
-
-        refute filter.allows?(default_destination, AttributeFilter::DST_TRANSACTION_EVENTS)
-        refute filter.allows?(default_destination, AttributeFilter::DST_BROWSER_MONITORING)
-      end
-    end
-
-    def test_capture_params_false_adds_exclude_rule_for_request_parameters
-      with_config(:capture_params => false) do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        result = filter.apply 'request.parameters.muggle', AttributeFilter::DST_NONE
-
-        assert_destinations [], result
-      end
-    end
-
-    def test_capture_params_true_allows_request_params_for_traces_and_errors
-      with_config(:capture_params => true) do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        result = filter.apply 'request.parameters.muggle', AttributeFilter::DST_NONE
-
-        assert_destinations ['transaction_tracer', 'error_collector'], result
-      end
-    end
-
-    def test_resque_capture_params_false_adds_exclude_rule_for_request_parameters
-      with_config(:'resque.capture_params' => false) do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        result = filter.apply 'job.resque.args.*', AttributeFilter::DST_NONE
-
-        assert_destinations [], result
-      end
-    end
-
-    def test_resque_capture_params_true_allows_request_params_for_traces_and_errors
-      with_config(:'resque.capture_params' => true) do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        result = filter.apply 'job.resque.args.*', AttributeFilter::DST_NONE
-
-        assert_destinations ['transaction_tracer', 'error_collector'], result
-      end
-    end
-
-    def test_sidekiq_capture_params_false_adds_exclude_rule_for_request_parameters
-      with_config(:'sidekiq.capture_params' => false) do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        result = filter.apply 'job.sidekiq.args.*', AttributeFilter::DST_NONE
-
-        assert_destinations [], result
-      end
-    end
-
-    def test_sidekiq_capture_params_true_allows_request_params_for_traces_and_errors
-      with_config(:'sidekiq.capture_params' => true) do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        result = filter.apply 'job.sidekiq.args.*', AttributeFilter::DST_NONE
-
-        assert_destinations ['transaction_tracer', 'error_collector'], result
-      end
-    end
-
-    def test_might_allow_prefix_default_case
-      filter = AttributeFilter.new(NewRelic::Agent.config)
-      refute filter.might_allow_prefix?(:'request.parameters')
-    end
-
-    def test_might_allow_prefix_blanket_include
-      with_config(:'attributes.include' => '*') do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        assert filter.might_allow_prefix?(:'request.parameters')
-      end
-    end
-
-    def test_might_allow_prefix_general_include
-      with_config(:'attributes.include' => 'request.*') do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        assert filter.might_allow_prefix?(:'request.parameters')
-      end
-    end
-
-    def test_might_allow_prefix_prefix_include
-      with_config(:'attributes.include' => 'request.parameters.*') do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        assert filter.might_allow_prefix?(:'request.parameters')
-      end
-    end
-
-    def test_might_allow_prefix_prefix_include_tt_only
-      with_config(:'transaction_tracer.attributes.include' => 'request.parameters.*') do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        assert filter.might_allow_prefix?(:'request.parameters')
-      end
-    end
-
-    def test_might_allow_prefix_non_matching_include
-      with_config(:'transaction_tracer.attributes.include' => 'otherthing') do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        refute filter.might_allow_prefix?(:'request.parameters')
-      end
-    end
-
-    def test_might_allow_prefix_more_specific_rule
-      with_config(:'attributes.include' => 'request.parameters.lolz') do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        assert filter.might_allow_prefix?(:'request.parameters')
-      end
-    end
-
-    def test_might_allow_prefix_more_specific_rule_with_wildcard
-      with_config(:'attributes.include' => 'request.parameters.lolz.*') do
-        filter = AttributeFilter.new(NewRelic::Agent.config)
-        assert filter.might_allow_prefix?(:'request.parameters')
-      end
-    end
-
-    def assert_destinations(expected, result)
-      assert_equal to_bitfield(expected), result, "Expected #{expected}, got #{to_names(result)}"
-    end
-
-    def to_names(bitfield)
-      names = []
-
-      names << 'transaction_events' if (bitfield & AttributeFilter::DST_TRANSACTION_EVENTS) != 0
-      names << 'transaction_tracer' if (bitfield & AttributeFilter::DST_TRANSACTION_TRACER) != 0
-      names << 'error_collector'    if (bitfield & AttributeFilter::DST_ERROR_COLLECTOR)    != 0
-      names << 'browser_monitoring' if (bitfield & AttributeFilter::DST_BROWSER_MONITORING) != 0
-
-      names
-    end
-
-    def to_bitfield(destination_names)
-      bitfield = AttributeFilter::DST_NONE
-
-      destination_names.each do |name|
-        case name
-        when 'transaction_events' then bitfield |= AttributeFilter::DST_TRANSACTION_EVENTS
-        when 'transaction_tracer' then bitfield |= AttributeFilter::DST_TRANSACTION_TRACER
-        when 'error_collector'    then bitfield |= AttributeFilter::DST_ERROR_COLLECTOR
-        when 'browser_monitoring' then bitfield |= AttributeFilter::DST_BROWSER_MONITORING
-        end
-      end
-
-      bitfield
-    end
-
-    def with_all_enabled
-      with_config(
-        :'transaction_tracer.attributes.enabled' => true,
-        :'transaction_events.attributes.enabled' => true,
-        :'error_collector.attributes.enabled' => true,
-        :'browser_monitoring.attributes.enabled' => true) do
-        yield
-      end
-    end
-  end
-end

data/test/new_relic/agent/attribute_processing_test.rb

@@ -1,164 +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 File.expand_path(File.join(File.dirname(__FILE__), '..', '..','test_helper'))
-require 'new_relic/agent/attribute_processing'
-
-class AttributeProcessingTest < Minitest::Test
-  def test_flatten_and_coerce_handles_nested_hashes
-    params = {"user" =>
-      {"addresses" =>
-        [
-          {"street" => "123 Street", "city" => "City", "state" => "ST", "zip" => "12345"},
-          {"street" => "123 Blvd", "city" => "City2", "state" => "ST2", "zip" => "54321"}
-        ]
-      }
-    }
-
-    expected = {
-      "request.parameters.user.addresses.0.street" => "123 Street",
-      "request.parameters.user.addresses.0.city"   => "City",
-      "request.parameters.user.addresses.0.state"  => "ST",
-      "request.parameters.user.addresses.0.zip"    => "12345",
-      "request.parameters.user.addresses.1.street" => "123 Blvd",
-      "request.parameters.user.addresses.1.city"   => "City2",
-      "request.parameters.user.addresses.1.state"  => "ST2",
-      "request.parameters.user.addresses.1.zip"    => "54321"
-    }
-
-    actual = NewRelic::Agent::AttributeProcessing.flatten_and_coerce(params, 'request.parameters')
-
-    assert_equal(expected, actual)
-  end
-
-  def test_flatten_and_coerce_coerces_values
-    params = {
-      "v1" => Class.new,
-      "v2" => :symbol,
-      "v3" => 1.01
-    }
-
-    expected = {
-      "request.parameters.v1" => "#<Class>",
-      "request.parameters.v2" => "symbol",
-      "request.parameters.v3" => 1.01
-    }
-
-    actual = NewRelic::Agent::AttributeProcessing.flatten_and_coerce(params, 'request.parameters')
-
-    assert_equal(expected, actual)
-  end
-
-  def test_prefix_optional_for_flatten_and_coerce
-    params = {:foo => {:bar => ["v1", "v2"]}}
-
-    expected = {
-      "foo.bar.0" => "v1",
-      "foo.bar.1" => "v2"
-    }
-
-    actual = NewRelic::Agent::AttributeProcessing.flatten_and_coerce(params)
-
-    assert_equal(expected, actual)
-  end
-
-  def test_prefix_optional_for_flatten_and_coerce_with_initial_array_argument
-    params = [:foo => {:bar => ["v1", "v2"]}]
-
-    expected = {
-      "0.foo.bar.0" => "v1",
-      "0.foo.bar.1" => "v2"
-    }
-
-    actual = NewRelic::Agent::AttributeProcessing.flatten_and_coerce(params)
-
-    assert_equal(expected, actual)
-  end
-
-  def test_flatten_and_coerce_replaces_empty_hash_with_string_representation
-    params = {:foo => {:bar => {}}}
-
-    expected = { "foo.bar" => "{}" }
-
-    actual = NewRelic::Agent::AttributeProcessing.flatten_and_coerce(params)
-
-    assert_equal(expected, actual)
-  end
-
-  def test_flatten_and_coerce_replaces_empty_array_with_string_representation
-    params = {:foo => {:bar => []}}
-
-    expected = { "foo.bar" => "[]" }
-
-    actual = NewRelic::Agent::AttributeProcessing.flatten_and_coerce(params)
-
-    assert_equal(expected, actual)
-  end
-
-  def test_flatten_and_coerce_coerce_handles_values_mixed_and_complex_types_properly
-    assert_equal(
-      {
-        'foo'    => 1.0,
-        'bar'    => 2,
-        'bang'   => 'woot',
-        'ok'     => 'dokey',
-        'yes'    => '[]',
-        'yup'    => '{}',
-        'yayuh'  => '#<Rational>',
-        'truthy' => true,
-        'falsy'  => false
-      },
-      NewRelic::Agent::AttributeProcessing.flatten_and_coerce(
-        {
-          'foo'    => 1.0,
-          'bar'    => 2,
-          'bang'   => 'woot',
-          'ok'     => :dokey,
-          'yes'    => [],
-          'yup'  => {},
-          'yayuh'   => Rational(1),
-          'truthy' => true,
-          'falsy'  => false
-        }
-      )
-    )
-  end
-
-  def test_flatten_and_coerce_turns_nan_or_infinity_into_null_and_then_dropped
-    assert_equal(
-      {
-      },
-      NewRelic::Agent::AttributeProcessing.flatten_and_coerce(
-        {
-          'nan'  => Float::NAN,
-          'inf'  => Float::INFINITY,
-          'ninf' => -Float::INFINITY
-        }
-      )
-    )
-  end
-
-  def test_flatten_and_coerce_logs_warning_with_unexpected_arguments
-    expects_logging(:warn, all_of(includes("Unexpected object"), includes("flatten_and_coerce")))
-    NewRelic::Agent::AttributeProcessing.flatten_and_coerce(Object.new)
-  end
-
-  def test_flatten_and_coerce_calls_a_block_key_and_value_when_provided
-    params = {:foo => {:bar => ["qux", "quux"]}}
-    yielded = {}
-
-    NewRelic::Agent::AttributeProcessing.flatten_and_coerce(params) { |k, v| yielded[k] = v}
-
-    expected = {"foo.bar.0" => "qux", "foo.bar.1" => "quux"}
-    assert_equal expected, yielded
-  end
-
-  def test_flatten_and_coerce_leaves_nils_alone
-    params   = { :referer => nil }
-    expected = { }
-
-    result = NewRelic::Agent::AttributeProcessing.flatten_and_coerce(params)
-    assert_equal expected, result
-  end
-end