newrelic_rpm 3.11.2.286 → 3.12.0.288

data/test/new_relic/agent_test.rb

@@ -13,6 +13,7 @@ module NewRelic
     include NewRelic::Agent::MethodTracer
 
     def setup
+      NewRelic::Agent.drop_buffered_data
       NewRelic::Agent.manual_start
       NewRelic::Agent.reset_config
       NewRelic::Agent.instance.stubs(:start_worker_thread)
@@ -24,7 +25,7 @@ module NewRelic
 
     def test_shutdown
       mock_agent = mocked_agent
-      mock_agent.expects(:shutdown).with({})
+      mock_agent.expects(:shutdown)
       NewRelic::Agent.shutdown
     end
 
@@ -39,23 +40,21 @@ module NewRelic
       NewRelic::Agent.manual_start(:monitor_mode => true, :license_key => "a" * 40)
       NewRelic::Agent.instance.service = default_service
       NewRelic::Agent.instance.finish_setup('agent_config' =>
-                                            { :some_absurd_setting => true })
-      assert NewRelic::Agent.config[:some_absurd_setting]
+                                            { 'data_report_period' => 10 })
+      assert_equal 10, NewRelic::Agent.config[:data_report_period]
       NewRelic::Agent.shutdown
-      assert !NewRelic::Agent.config[:some_absurd_setting]
+      assert_equal 60, NewRelic::Agent.config[:data_report_period]
     end
 
     def test_finish_setup_applied_server_side_config
       with_config_low_priority({
                     :'transction_tracer.enabled' => true,
-                    :'error_collector.enabled' => true,
-                    :log_level => 'info' }) do
-        NewRelic::Agent.instance.finish_setup('log_level' => 'debug',
+                    :'error_collector.enabled' => true }) do
+        NewRelic::Agent.instance.finish_setup(
          'agent_config' => { 'transaction_tracer.enabled' => false },
                                          'collect_errors' => false)
-        assert !NewRelic::Agent.config[:'transaction_tracer.enabled']
-        assert !NewRelic::Agent.config[:'error_collector.enabled']
-        assert_equal 'debug', NewRelic::Agent.config[:log_level]
+        refute NewRelic::Agent.config[:'transaction_tracer.enabled']
+        refute NewRelic::Agent.config[:'error_collector.enabled']
       end
     end
 
@@ -332,7 +331,7 @@ module NewRelic
       Transactor.new.txn do
         NewRelic::Agent.set_transaction_name('new_name')
       end
-      assert_equal 'Controller/new_name', sampler.last_sample.params[:path]
+      assert_equal 'Controller/new_name', sampler.last_sample.transaction_name
     end
 
     def test_set_transaction_name_gracefully_fails_when_frozen
@@ -395,12 +394,13 @@ module NewRelic
       assert called
     end
 
-    # The assumption is that txn.ignore! works as expected, and is tested elsewhere.
     def test_ignore_transaction_works
       in_transaction do |txn|
         NewRelic::Agent.ignore_transaction
         assert txn.ignore?
       end
+
+      assert_empty NewRelic::Agent.instance.transaction_sampler.harvest!
     end
 
     # The assumption is that txn.ignore_apdex! works as expected, and is tested elsewhere.
@@ -419,6 +419,21 @@ module NewRelic
       end
     end
 
+    def test_add_custom_parameters_deprecated
+      NewRelic::Agent::Deprecator.expects(:deprecate)
+      NewRelic::Agent.add_custom_parameters(:is => "bunk")
+    end
+
+    def test_add_request_parameters_deprecated
+      NewRelic::Agent::Deprecator.expects(:deprecate)
+      NewRelic::Agent.add_request_parameters(:is => "bunk")
+    end
+
+    def test_set_user_attributes_deprecated
+      NewRelic::Agent::Deprecator.expects(:deprecate)
+      NewRelic::Agent.set_user_attributes(:is => "bunk")
+    end
+
     private
 
     def with_unstarted_agent

data/test/new_relic/cli/commands/install_test.rb

@@ -0,0 +1,27 @@
+# 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/cli/command'
+require 'new_relic/cli/commands/install'
+
+class NewRelic::Cli::InstallTest < Minitest::Test
+  def test_fails_without_app_name
+    assert_raises(NewRelic::Cli::Command::CommandFailure) do
+      NewRelic::Cli::Install.new(["-l", "license"])
+    end
+  end
+
+  def test_basic_run
+    install = NewRelic::Cli::Install.new(["-l", "license", "app"])
+    assert_equal "license", install.license_key
+    assert_equal "app", install.app_name
+  end
+
+  def test_app_name_with_spaces
+    install = NewRelic::Cli::Install.new(["-l", "license", "my", "app"])
+    assert_equal "license", install.license_key
+    assert_equal "my app", install.app_name
+  end
+end

data/test/new_relic/coerce_test.rb

@@ -89,65 +89,6 @@ class CoerceTest < Minitest::Test
     string(Unstringable.new, "HERE")
   end
 
-  def test_event_params_coerce_returns_empty_hash_when_non_hash_is_passed
-    assert_equal({}, event_params([]))
-    assert_equal({}, event_params(''))
-    assert_equal({}, event_params(1))
-    assert_equal({}, event_params(nil))
-    assert_equal({}, event_params(self.class))
-  end
-
-  def test_event_params_coerce_converts_hash_keys_to_strings
-    assert_equal(
-      {'foo' => 1, 'bar' => 2, '3' => 3},
-      event_params({:foo => 1, 'bar' => 2, 3 => 3})
-    )
-  end
-
-  def test_event_params_coerce_only_allow_values_that_are_strings_symbols_floats_or_ints_or_bools
-    assert_equal(
-      {
-        'foo'    => 1.0,
-        'bar'    => 2,
-        'bang'   => 'woot',
-        'ok'     => 'dokey',
-        'truthy' => true,
-        'falsy'  => false
-      },
-      event_params(
-        {
-          'foo'    => 1.0,
-          'bar'    => 2,
-          'bang'   => 'woot',
-          'ok'     => :dokey,
-          'bad'    => [],
-          'worse'  => {},
-          'nope'   => Rational(1),
-          'truthy' => true,
-          'falsy'  => false
-        }
-      )
-    )
-  end
-
-  def test_event_params_turns_nan_or_infinity_into_null
-    assert_equal(
-      {
-        'nan'  => nil,
-        'inf'  => nil,
-        'ninf' => nil
-      },
-      event_params(
-        {
-          # 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
-
   class Unstringable
     undef :to_s
   end

data/test/new_relic/data_container_tests.rb

@@ -46,12 +46,12 @@ module NewRelic
     end
 
     def test_calling_harvest_after_re_populating_works
-      c = create_container
-      populate_container(c, num_data_items)
-      assert_equal(num_data_items, c.harvest!.size)
+      container = create_container
+      populate_container(container, num_data_items)
+      assert_equal(num_data_items, container.harvest!.size)
 
-      populate_container(c, num_data_items)
-      assert_equal(num_data_items, c.harvest!.size)
+      populate_container(container, num_data_items)
+      assert_equal(num_data_items, container.harvest!.size)
     end
   end
 

data/test/new_relic/fake_collector.rb

@@ -136,7 +136,7 @@ module NewRelic
 
             # Symbols remain in Ruby-marshalled data, so tidy up so tests can
             # rely on strings to compare against in fake collector results.
-            body = NewRelic::JSONWrapper.normalize(body)
+            body = NewRelic::Agent::EncodingNormalizer.normalize_object(body)
           end
         rescue
           body = "UNABLE TO DECODE BODY: #{raw_body}"
@@ -297,19 +297,26 @@ module NewRelic
         def synthetics_resource_id
           @body[9]
         end
-      end
 
-      class SubmittedTransactionTraceTree
-        def initialize(body, format)
-          @body = body
+        def agent_attributes
+          tree.attributes['agentAttributes']
         end
 
-        def request_params
-          @body[1]
+        def custom_attributes
+          tree.attributes['userAttributes']
         end
 
-        def custom_params
-          @body[2]
+        def intrinsic_attributes
+          tree.attributes['intrinsics']
+        end
+      end
+
+      class SubmittedTransactionTraceTree
+        attr_reader :attributes
+
+        def initialize(body, format)
+          @body = body
+          @attributes = body[4]
         end
       end
 
@@ -374,6 +381,17 @@ module NewRelic
         @params               = error_info[4]
       end
 
+      def agent_attributes
+        @params["agentAttributes"]
+      end
+
+      def custom_attributes
+        @params["userAttributes"]
+      end
+
+      def intrinsic_attributes
+        @params["intrinsics"]
+      end
     end
   end
 

data/test/new_relic/filtering_test_app.rb

@@ -12,7 +12,8 @@ class FilteringTestApp
     params = req.params
     filtered = ::NewRelic::Agent::ParameterFiltering.apply_filters(env, params)
     txn.filtered_params = filtered
+    txn.merge_request_parameters(filtered)
     raise "Intentional error" if params["raise"]
     [200, {}, ["Filters applied"]]
   end
-end
+end

data/test/new_relic/http_client_test_cases.rb

@@ -179,8 +179,8 @@ module HttpClientTestCases
     perform_action_with_newrelic_trace(:name => "task") do
       get_response
 
-      last_segment = find_last_transaction_segment()
-      assert_equal "External/localhost/#{client_name}/GET", last_segment.metric_name
+      last_node = find_last_transaction_node()
+      assert_equal "External/localhost/#{client_name}/GET", last_node.metric_name
     end
   end
 
@@ -316,9 +316,9 @@ module HttpClientTestCases
       in_transaction("test") do
         get_response
 
-        last_segment = find_last_transaction_segment()
-        assert_includes last_segment.params.keys, :transaction_guid
-        assert_equal TRANSACTION_GUID, last_segment.params[:transaction_guid]
+        last_node = find_last_transaction_node()
+        assert_includes last_node.params.keys, :transaction_guid
+        assert_equal TRANSACTION_GUID, last_node.params[:transaction_guid]
       end
     end
 
@@ -340,9 +340,9 @@ module HttpClientTestCases
       in_transaction("test") do
         get_response
 
-        last_segment = find_last_transaction_segment()
-        assert_includes last_segment.params.keys, :transaction_guid
-        assert_equal TRANSACTION_GUID, last_segment.params[:transaction_guid]
+        last_node = find_last_transaction_node()
+        assert_includes last_node.params.keys, :transaction_guid
+        assert_equal TRANSACTION_GUID, last_node.params[:transaction_guid]
       end
     end
 
@@ -404,7 +404,7 @@ module HttpClientTestCases
       get_response
     end
 
-    refute_match( /undefined method `rename_scope_segment" for nil:NilClass/i,
+    refute_match( /undefined method `.*" for nil:NilClass/i,
                      logger.messages.flatten.map {|log| log.to_s }.join(" ") )
   end
 
@@ -412,9 +412,9 @@ module HttpClientTestCases
     full_url = "#{default_url}?foo=bar#fragment"
     in_transaction do
       get_response(full_url)
-      last_segment = find_last_transaction_segment()
+      last_node = find_last_transaction_node()
       filtered_uri = default_url
-      assert_equal filtered_uri, last_segment.params[:uri]
+      assert_equal filtered_uri, last_node.params[:uri]
     end
   end
 
@@ -431,7 +431,7 @@ module HttpClientTestCases
   end
 
   # https://newrelic.atlassian.net/browse/RUBY-1244
-  def test_failure_to_add_tt_node_doesnt_append_params_to_wrong_segment
+  def test_failure_to_add_tt_node_doesnt_append_params_to_wrong_node
     # Fake a failure in our start-up code...
     NewRelic::JSONWrapper.stubs(:dump).raises("Boom!")
 
@@ -439,8 +439,8 @@ module HttpClientTestCases
       with_config(:"cross_application_tracer.enabled" => true) do
         get_response
 
-        last_segment = find_last_transaction_segment()
-        refute last_segment.params.key?(:uri)
+        last_node = find_last_transaction_node()
+        refute last_node.params.key?(:uri)
       end
     end
   end
@@ -466,8 +466,8 @@ module HttpClientTestCases
           # across all libraries
         end
 
-        last_segment = find_last_transaction_segment()
-        assert_equal("External/localhost/#{client_name}/GET", last_segment.metric_name)
+        last_node = find_last_transaction_node()
+        assert_equal("External/localhost/#{client_name}/GET", last_node.metric_name)
       end
 
       evil_server.stop

data/test/new_relic/json_wrapper_test.rb

@@ -20,61 +20,7 @@ class JSONWrapperTest < Minitest::Test
     assert(obj == copy)
   end
 
-  def test_normalize_converts_symbol_values_to_strings
-    result = NewRelic::JSONWrapper.normalize([:foo, :bar])
-    assert_equal(['foo', 'bar'], result)
-  end
-
-  def test_normalize_converts_symbols_in_hash_to_strings
-    result = NewRelic::JSONWrapper.normalize({:key => :value})
-    assert_equal({'key' => 'value'}, result)
-  end
-
   if NewRelic::LanguageSupport.supports_string_encodings?
-    def test_normalize_string_returns_input_if_correctly_encoded_utf8
-      string = "i want a pony"
-      result = NewRelic::JSONWrapper.normalize_string(string)
-      assert_same(string, result)
-      assert_equal(Encoding.find('UTF-8'), result.encoding)
-    end
-
-    def test_normalize_string_returns_munged_copy_if_ascii_8bit
-      string = (0..255).to_a.pack("C*")
-      result = NewRelic::JSONWrapper.normalize_string(string)
-      refute_same(string, result)
-      assert_equal(Encoding.find('ISO-8859-1'), result.encoding)
-      assert_equal(string, result.dup.force_encoding('ASCII-8BIT'))
-    end
-
-    def test_normalize_string_returns_munged_copy_if_invalid_utf8
-      string = (0..255).to_a.pack("C*").force_encoding('UTF-8')
-      result = NewRelic::JSONWrapper.normalize_string(string)
-      refute_same(result, string)
-      assert_equal(Encoding.find('ISO-8859-1'), result.encoding)
-      assert_equal(string, result.dup.force_encoding('UTF-8'))
-    end
-
-    def test_normalize_string_returns_munged_copy_if_other_convertible_encoding
-      string = "i want a pony".encode('UTF-16LE')
-      result = NewRelic::JSONWrapper.normalize_string(string)
-      refute_same(result, string)
-      assert_equal(Encoding.find('UTF-8'), result.encoding)
-      assert_equal(string, result.encode('UTF-16LE'))
-    end
-
-    def test_normalize_string_returns_munged_copy_if_other_non_convertible_enocding
-      # Attempting to convert from UTF-7 to UTF-8 in Ruby will raise an
-      # Encoding::ConverterNotFoundError, which is what we're trying to
-      # replicate for this test case.
-      # The following UTF-7 string decodes to 'Jyväskylä', a city in Finland
-      string = "Jyv+AOQ-skyl+AOQ-".force_encoding("UTF-7")
-      assert string.valid_encoding?
-      result = NewRelic::JSONWrapper.normalize_string(string)
-      refute_same(result, string)
-      assert_equal(Encoding.find('ISO-8859-1'), result.encoding)
-      assert_equal('Jyv+AOQ-skyl+AOQ-'.force_encoding('ISO-8859-1'), result)
-    end
-
     def test_normalizes_string_encodings_if_asked
       string = (0..255).to_a.pack("C*")
       encoded = NewRelic::JSONWrapper.dump([string], :normalize => true)

data/test/new_relic/marshalling_test_cases.rb

@@ -66,6 +66,7 @@ module MarshallingTestCases
         "name"      => "TestTransaction/do_it",
         "duration"  => 0.0,
       },
+      {},
       {}
     ]
 

data/test/new_relic/multiverse_helpers.rb

@@ -50,6 +50,10 @@ module MultiverseHelpers
     # test cases have the chance to change settings on the fake collector first
     start_fake_collector unless omit_collector?
 
+    # If a test not using the multiverse helper runs before us, we might need
+    # to clean up before a test too.
+    NewRelic::Agent.drop_buffered_data
+
     trigger_agent_reconnect(opts)
   end
 
@@ -123,5 +127,145 @@ module MultiverseHelpers
     ENV["NEWRELIC_OMIT_FAKE_COLLECTOR"] == "true"
   end
 
+  def run_harvest
+    NewRelic::Agent.instance.send(:transmit_data)
+    NewRelic::Agent.instance.send(:transmit_event_data)
+  end
+
+  def single_transaction_trace_posted
+    posts = $collector.calls_for("transaction_sample_data")
+    assert_equal 1, posts.length, "Unexpected post count"
+
+    transactions = posts.first.samples
+    assert_equal 1, transactions.length, "Unexpected trace count"
+
+    transactions.first
+  end
+
+  def single_error_posted
+    assert_equal 1, $collector.calls_for("error_data").length
+    assert_equal 1, $collector.calls_for("error_data").first.errors.length
+
+    $collector.calls_for("error_data").first.errors.first
+  end
+
+  def single_event_posted
+    assert_equal 1, $collector.calls_for("analytic_event_data").length
+    assert_equal 1, $collector.calls_for("analytic_event_data").first.events.length
+
+    $collector.calls_for("analytic_event_data").first.events.first
+  end
+
+  def capture_js_data
+    state = NewRelic::Agent::TransactionState.tl_get
+    events = stub(:subscribe => nil)
+    @instrumentor = NewRelic::Agent::JavascriptInstrumentor.new(events)
+    @js_data = @instrumentor.data_for_js_agent(state)
+
+    raw_attributes = @js_data["atts"]
+
+    if raw_attributes
+      attributes = NewRelic::JSONWrapper.load @instrumentor.obfuscator.deobfuscate(raw_attributes)
+      @js_custom_attributes = attributes['u']
+      @js_agent_attributes = attributes['a']
+    end
+  end
+
+  def assert_transaction_trace_has_agent_attribute(attribute, expected)
+    actual = single_transaction_trace_posted.agent_attributes[attribute]
+    assert_equal expected, actual
+  end
+
+  def assert_event_has_agent_attribute(attribute, expected)
+    assert_equal expected, single_event_posted.last[attribute]
+  end
+
+  def assert_error_has_agent_attribute(attribute, expected)
+    assert_equal expected, single_error_posted.params["agentAttributes"][attribute]
+  end
+
+  def assert_transaction_tracer_has_custom_attributes(attribute, expected)
+    actual = single_transaction_trace_posted.custom_attributes[attribute]
+    assert_equal expected, actual
+  end
+
+  def assert_transaction_event_has_custom_attributes(attribute, expected)
+    assert_equal expected, single_event_posted[1][attribute]
+  end
+
+  def assert_error_collector_has_custom_attributes(attribute, expected)
+    assert_equal expected, single_error_posted.params["userAttributes"][attribute]
+  end
+
+  def assert_browser_monitoring_has_custom_attributes(attribute, expected)
+    assert_equal expected, @js_custom_attributes[attribute]
+  end
+
+  def assert_browser_monitoring_has_agent_attribute(attribute, expected)
+    assert_equal expected, @js_agent_attributes[attribute]
+  end
+
+  def refute_transaction_tracer_has_custom_attributes(attribute)
+    refute_includes single_transaction_trace_posted.custom_attributes, attribute
+  end
+
+  def refute_transaction_event_has_custom_attributes(attribute)
+    refute_includes single_event_posted[1], attribute
+  end
+
+  def refute_error_collector_has_custom_attributes(attribute)
+    refute_includes single_error_posted.params["userAttributes"], attribute
+  end
+
+  def refute_browser_monitoring_has_custom_attributes(_)
+    assert_nil @js_custom_attributes
+  end
+
+  def refute_transaction_trace_has_agent_attribute(attribute)
+    refute_includes single_transaction_trace_posted.agent_attributes, attribute
+  end
+
+  def refute_event_has_agent_attribute(attribute)
+    refute_includes single_event_posted.last, attribute
+  end
+
+  def refute_error_has_agent_attribute(attribute)
+    refute_includes single_error_posted.params["agentAttributes"], attribute
+  end
+
+  def refute_browser_monitoring_has_any_attributes
+    refute_includes @js_data, "atts"
+  end
+
+  def refute_browser_monitoring_has_agent_attribute(_)
+    assert_nil @js_agent_attributes
+  end
+
+  def attributes_for_single_error_posted(key)
+    run_harvest
+    single_error_posted.params[key]
+  end
+
+  def user_attributes_for_single_error_posted
+    attributes_for_single_error_posted("userAttributes")
+  end
+
+  def agent_attributes_for_single_error_posted
+    attributes_for_single_error_posted("agentAttributes")
+  end
+
+  def agent_attributes_for_single_event_posted
+    run_harvest
+    single_event_posted[2]
+  end
+
+  def agent_attributes_for_single_event_posted_without_ignored_attributes
+    ignored_keys = ["httpResponseCode", "request.headers.referer",
+      "request.parameters.controller", "request.parameters.action"]
+    attrs = agent_attributes_for_single_event_posted
+    ignored_keys.each { |k| attrs.delete(k) }
+    attrs
+  end
+
   extend self
 end