newrelic_rpm 3.11.2.286 → 3.12.0.288

data/test/multiverse/suites/sinatra/sinatra_test_cases.rb

@@ -129,17 +129,6 @@ module SinatraTestCases
     get '/pass'
   end
 
-  def test_file_upload_params_are_filtered
-    with_config(:capture_params => true) do
-      params = {
-        :title => "blah",
-        :file => Rack::Test::UploadedFile.new(__FILE__, 'text/plain')
-      }
-      post '/files', params
-      assert_equal({"title" => "blah", "file" => "[FILE]"}, last_transaction_trace_request_params)
-    end
-  end
-
   def fail_on_second_params_call
     Sinatra::Request.any_instance.
       stubs(:params).returns({}).

data/test/multiverse/suites/typhoeus/Envfile

@@ -7,7 +7,7 @@ suite_condition("Typhoeus excluded on 1.8.7") do
 end
 
 gemfile <<-RB
-  gem 'typhoeus', '~> 0.6.5'
+  gem 'typhoeus', '~> 0.7.1'
   gem 'rack'
   gem 'json', :platforms => [:rbx, :mri_18]
 
@@ -16,7 +16,13 @@ gemfile <<-RB
 RB
 
 gemfile <<-RB
-  gem 'typhoeus', '~> 0.6.5'
+  gem 'typhoeus', '~> 0.7.1'
+  gem 'rack'
+  gem 'json', :platforms => [:rbx, :mri_18]
+RB
+
+gemfile <<-RB
+  gem 'typhoeus', '~> 0.6.9'
   gem 'rack'
   gem 'json', :platforms => [:rbx, :mri_18]
 RB

data/test/multiverse/suites/typhoeus/typhoeus_test.rb

@@ -96,8 +96,8 @@ if NewRelic::Agent::Instrumentation::TyphoeusTracing.is_supported_version?
         refute_nil(caught_exception)
         assert_equal('noodle', caught_exception.message)
 
-        last_segment = find_last_transaction_segment
-        assert_equal "External/localhost/Typhoeus/GET", last_segment.metric_name
+        last_node = find_last_transaction_node
+        assert_equal "External/localhost/Typhoeus/GET", last_node.metric_name
       end
     end
 
@@ -117,8 +117,8 @@ if NewRelic::Agent::Instrumentation::TyphoeusTracing.is_supported_version?
         5.times { hydra.queue(Typhoeus::Request.new(default_url, ssl_option)) }
         hydra.run
 
-        last_segment = find_last_transaction_segment()
-        assert_equal "External/Multiple/Typhoeus::Hydra/run", last_segment.metric_name
+        last_node = find_last_transaction_node()
+        assert_equal "External/Multiple/Typhoeus::Hydra/run", last_node.metric_name
       end
     end
 

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

@@ -134,10 +134,11 @@ class NewRelic::Agent::Agent::ConnectTest < Minitest::Test
   end
 
   def test_configure_transaction_tracer_server_disabled
-    config = NewRelic::Agent::Configuration::ServerSource.new('collect_traces' => false,
-                                                              'developer_mode' => false)
-    with_config(config) do
-      assert !@transaction_sampler.enabled?
+    config = NewRelic::Agent::Configuration::ServerSource.new('collect_traces' => false)
+    with_config(:developer_mode => false) do
+      with_config(config) do
+        refute @transaction_sampler.enabled?
+      end
     end
   end
 
@@ -260,11 +261,14 @@ class NewRelic::Agent::Agent::ConnectTest < Minitest::Test
   end
 
   def test_finish_setup_replaces_server_config
-    finish_setup(:boo => "boo")
-    finish_setup(:hoo => true)
-
-    assert NewRelic::Agent.config[:hoo]
-    assert_nil NewRelic::Agent.config[:boo]
+    finish_setup('apdex_t' => 42)
+    assert_equal 42, NewRelic::Agent.config[:apdex_t]
+    assert_kind_of NewRelic::Agent::Configuration::ServerSource, NewRelic::Agent.config.source(:apdex_t)
+
+    # this should create a new server source that replaces the existing one that
+    # had apdex_t specified, rather than layering on top of the existing one.
+    finish_setup('data_report_period' => 12)
+    assert_kind_of NewRelic::Agent::Configuration::DefaultSource, NewRelic::Agent.config.source(:apdex_t)
   end
 
   def test_logging_collector_messages

data/test/new_relic/agent/agent_test.rb

@@ -11,7 +11,10 @@ module NewRelic
 
       def setup
         super
+        @original_agent = NewRelic::Agent.agent
         @agent = NewRelic::Agent::Agent.new
+        NewRelic::Agent.agent = @agent
+
         @agent.service = default_service
         @agent.agent_command_router.stubs(:new_relic_service).returns(@agent.service)
         @agent.stubs(:start_worker_thread)
@@ -21,6 +24,7 @@ module NewRelic
       end
 
       def teardown
+        NewRelic::Agent.agent = @original_agent
         NewRelic::Agent.config.reset_to_defaults
       end
 
@@ -338,6 +342,36 @@ module NewRelic
         end
       end
 
+      def test_connect_replaces_attribute_filter
+        old_filter = @agent.attribute_filter
+
+        @agent.stubs(:connected?).returns(true)
+        @agent.service.expects(:connect).returns({})
+        @agent.send(:connect, :force_reconnect => true)
+
+        refute old_filter == @agent.attribute_filter, "#{@agent.attribute_filter} should not be equal to\n#{old_filter}"
+      end
+
+      def test_connect_replaces_transaction_rules
+        old_rules = @agent.transaction_rules
+
+        @agent.stubs(:connected?).returns(true)
+        @agent.service.expects(:connect).returns({})
+        @agent.send(:connect, :force_reconnect => true)
+
+        refute old_rules == @agent.transaction_rules, "#{@agent.transaction_rules} should not be equal to\n#{old_rules}"
+      end
+
+      def test_connect_replaces_stats_engine_metric_rules
+        old_rules = @agent.stats_engine.metric_rules
+
+        @agent.stubs(:connected?).returns(true)
+        @agent.service.expects(:connect).returns({})
+        @agent.send(:connect, :force_reconnect => true)
+
+        refute old_rules == @agent.stats_engine.metric_rules, "#{@agent.stats_engine.metric_rules} should not be equal to\n#{old_rules}"
+      end
+
       def test_connect_settings
         expected = [
          :pid,
@@ -564,30 +598,6 @@ module NewRelic
         end
       end
 
-      def test_stop_event_loop_runs_loop_before_exit_with_force_send_config
-        fake_loop = mock
-        fake_loop.expects(:run_once)
-        fake_loop.stubs(:stop)
-
-        @agent.instance_variable_set(:@event_loop, fake_loop)
-
-        with_config(:force_send => true) do
-          @agent.stop_event_loop
-        end
-      end
-
-      def test_stop_event_loop_doesnt_run_loop_if_force_send_is_false
-        fake_loop = mock
-        fake_loop.expects(:run_once).never
-        fake_loop.stubs(:stop)
-
-        @agent.instance_variable_set(:@event_loop, fake_loop)
-
-        with_config(:force_send => false) do
-          @agent.stop_event_loop
-        end
-      end
-
       def test_stop_event_loop_stops_the_loop
         fake_loop = mock
         fake_loop.expects(:stop)

data/test/new_relic/agent/attribute_filter_test.rb

@@ -0,0 +1,218 @@
+# 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

@@ -0,0 +1,160 @@
+# 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
+    assert_equal(
+      {
+        'nan'  => nil,
+        'inf'  => nil,
+        'ninf' => nil
+      },
+      NewRelic::Agent::AttributeProcessing.flatten_and_coerce(
+        {
+          # Ruby 1.8.7 doesn't have Float::NAN, INFINITY so we have to hack it
+          'nan'  => 0.0  / 0.0,
+          'inf'  => 1.0  / 0.0,
+          'ninf' => -1.0 / 0.0
+        }
+      )
+    )
+  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
+end