newrelic_rpm 3.11.2.286 → 3.12.0.288

data/test/new_relic/agent/configuration/default_source_test.rb

@@ -125,6 +125,94 @@ module NewRelic::Agent::Configuration
       end
     end
 
+    def test_transaction_tracer_attributes_enabled_default
+      with_config(:'transaction_tracer.capture_attributes' => :foo) do
+        assert_equal :foo, NewRelic::Agent.config['transaction_tracer.attributes.enabled']
+      end
+    end
+
+    def test_transaction_events_attributes_enabled_default
+      with_config(:'analytics_events.capture_attributes' => :foo) do
+        assert_equal :foo, NewRelic::Agent.config['transaction_events.attributes.enabled']
+      end
+    end
+
+    def test_error_collector_attributes_enabled_default
+      with_config(:'error_collector.capture_attributes' => :foo) do
+        assert_equal :foo, NewRelic::Agent.config['error_collector.attributes.enabled']
+      end
+    end
+
+    def test_browser_monitoring_attributes_enabled_default
+      with_config(:'browser_monitoring.capture_attributes' => :foo) do
+        assert_equal :foo, NewRelic::Agent.config['browser_monitoring.attributes.enabled']
+      end
+    end
+
+    def test_agent_attribute_settings_convert_comma_delimited_strings_into_an_arrays
+      types = %w(transaction_tracer. transaction_events. error_collector. browser_monitoring.)
+      types << ''
+
+      types.each do |type|
+        key = "#{type}attributes.exclude".to_sym
+
+        with_config(key => 'foo,bar,baz') do
+          expected = ["foo", "bar", "baz"]
+          result = NewRelic::Agent.config[key]
+
+          message = "Expected #{key} to convert comma delimited string into array.\nExpected: #{expected.inspect}, Result: #{result.inspect}\n"
+          assert expected == result, message
+        end
+
+        key = "#{type}attributes.include".to_sym
+
+        with_config(key => 'foo,bar,baz') do
+          assert_equal ["foo", "bar", "baz"], NewRelic::Agent.config[key]
+        end
+      end
+    end
+
+    def test_agent_attributes_settings_with_yaml_array
+      types = %w(transaction_tracer. transaction_events. error_collector. browser_monitoring.)
+      types << ''
+
+      types.each do |type|
+        key = "#{type}attributes.exclude".to_sym
+
+        with_config(key => ['foo','bar','baz']) do
+          expected = ["foo", "bar", "baz"]
+          result = NewRelic::Agent.config[key]
+
+          message = "Expected #{key} not to modify settings from YAML array.\nExpected: #{expected.inspect}, Result: #{result.inspect}\n"
+          assert expected == result, message
+        end
+
+        key = "#{type}attributes.include".to_sym
+
+        with_config(key => 'foo,bar,baz') do
+          assert_equal ["foo", "bar", "baz"], NewRelic::Agent.config[key]
+        end
+      end
+    end
+
+    def test_all_settings_specify_whether_they_are_allowed_from_server
+      unspecified_keys = []
+      bad_value_keys = []
+
+      @defaults.each do |key, spec|
+        if !spec.has_key?(:allowed_from_server)
+          unspecified_keys << key
+        end
+
+        if ![true, false].include?(spec[:allowed_from_server])
+          bad_value_keys << key
+        end
+      end
+
+      assert unspecified_keys.empty?, "The following keys did not specify a value for :allowed_from_server: #{unspecified_keys.join(', ')}"
+      assert bad_value_keys.empty?, "The following keys had incorrect :allowed_from_server values (only true or false are allowed): #{bad_value_keys.join(', ')}"
+    end
+
     def get_config_value_class(value)
       type = value.class
 

data/test/new_relic/agent/configuration/manager_test.rb

@@ -46,9 +46,8 @@ module NewRelic::Agent::Configuration
     def test_sources_applied_in_correct_order
       # in order of precedence
       high_security = HighSecuritySource.new({})
-      server_source = ServerSource.new(:foo => 'foo', :capture_params => true)
-      manual_source = ManualSource.new(:foo => 'bad', :bar => 'bar',
-                                       :capture_params => true)
+      server_source = ServerSource.new('data_report_period' => 3, 'capture_params' => true)
+      manual_source = ManualSource.new(:data_report_period  => 2, :bar => 'bar', :capture_params => true)
 
       # load them out of order, just to prove that load order
       # doesn't determine precedence
@@ -56,7 +55,7 @@ module NewRelic::Agent::Configuration
       @manager.replace_or_add_config(server_source)
       @manager.replace_or_add_config(high_security)
 
-      assert_equal 'foo', @manager['foo']
+      assert_equal 3,     @manager['data_report_period']
       assert_equal 'bar', @manager['bar']
       assert_equal false, @manager['capture_params']
     end

data/test/new_relic/agent/configuration/orphan_configuration_test.rb

@@ -29,7 +29,9 @@ class OrphanedConfigTest < Minitest::Test
     end
   end
 
-  AGENT_CONFIG_PATTERN      = /Agent\.config\[:['"]?([a-z\._]+)['"]?\s*\]/
+  # This is a bit loose (allows any config[] with the right key) so we can pass
+  # NewRelic::Agent.config into classes as long as we call the variable config
+  AGENT_CONFIG_PATTERN      = /config\[:['"]?([a-z\._]+)['"]?\s*\]/
   DEFAULT_VALUE_OF_PATTERN  = /:default\s*=>\s*value_of\(:['"]?([a-z\._]+)['"]?\)\s*/
   REGISTER_CALLBACK_PATTERN = /register_callback\(:['"]?([a-z\._]+)['"]?\)/
   NAMED_DEPENDENCY_PATTERN  = /^\s*named[ (]+\:?([a-z0-9\._]+).*$/

data/test/new_relic/agent/configuration/server_source_test.rb

@@ -159,5 +159,44 @@ module NewRelic::Agent::Configuration
       assert @source[:'analytics_events.enabled']
       assert @source[:'custom_insights_events.enabled']
     end
+
+    def test_should_strip_non_ssc_keys
+      rsp = {
+        'agent_config' => {
+          'attributes.include' => 'foo,bar',
+          'slow_sql.explain_threshold' => 42
+        }
+      }
+
+      source = ServerSource.new(rsp, {})
+      refute_includes source.keys, :'attributes.include'
+      assert_includes source.keys, :'slow_sql.explain_threshold'
+    end
+
+    def test_should_strip_unrecognized_keys_in_agent_config_hash
+      rsp = {
+        'agent_config' => {
+          'platypus' => 'mammal'
+        }
+      }
+
+      source = ServerSource.new(rsp, {})
+      refute_includes source.keys, :platypus
+    end
+
+    def test_should_not_merge_in_keys_that_are_not_allowed_at_top_level
+      rsp = {
+        'slow_sql.explain_threshold' => 42
+      }
+      source = ServerSource.new(rsp, {})
+      refute_includes source.keys, :'slow_sql.explain_threshold'
+    end
+
+    def test_all_top_level_keys_should_be_allowed_from_server
+      ServerSource::TOP_LEVEL_KEYS.each do |key|
+        assert DEFAULTS[key.to_sym], "Did not find entry in config DEFAULTS hash for to-level server config key #{key}"
+        assert DEFAULTS[key.to_sym][:allowed_from_server], "Expected top-level server config key #{key} to be allowed from server"
+      end
+    end
   end
 end

data/test/new_relic/agent/cross_app_monitor_test.rb

@@ -135,29 +135,13 @@ module NewRelic::Agent
       assert_equal(42, @monitor.content_length_from_request(request))
     end
 
-    def test_writes_custom_parameters
+    def test_writes_attributes
       with_default_timings
 
-      NewRelic::Agent.expects(:add_custom_parameters).with(:client_cross_process_id => REQUEST_CROSS_APP_ID)
-      NewRelic::Agent.expects(:add_custom_parameters).with(:referring_transaction_guid => REF_TRANSACTION_GUID)
+      txn = when_request_runs
 
-      when_request_runs
-    end
-
-    def test_error_writes_custom_parameters
-      with_default_timings
-
-      options = when_request_has_error
-
-      assert_equal REQUEST_CROSS_APP_ID, options[:client_cross_process_id]
-    end
-
-    def test_error_doesnt_write_custom_parameters_if_no_id
-      with_default_timings
-
-      options = when_request_has_error(for_id(''))
-
-      assert_equal false, options.key?(:client_cross_process_id)
+      assert_equal REQUEST_CROSS_APP_ID, attributes_for(txn, :intrinsic)[:client_cross_process_id]
+      assert_equal REF_TRANSACTION_GUID, attributes_for(txn, :intrinsic)[:referring_transaction_guid]
     end
 
     def test_writes_metric
@@ -225,23 +209,15 @@ module NewRelic::Agent
     #
 
     def when_request_runs(request=for_id(REQUEST_CROSS_APP_ID))
-      in_transaction('transaction') do
+      in_transaction('transaction') do |txn|
         @events.notify(:before_call, request)
         # Fake out our GUID for easier comparison in tests
         NewRelic::Agent::Transaction.tl_current.stubs(:guid).returns(TRANSACTION_GUID)
         @events.notify(:after_call, request, [200, @response, ''])
+        txn
       end
     end
 
-    def when_request_has_error(request=for_id(REQUEST_CROSS_APP_ID))
-      options = {}
-      @events.notify(:before_call, request)
-      @events.notify(:notice_error, nil, options)
-      @events.notify(:after_call, request, [500, @response, ''])
-
-      options
-    end
-
     def with_default_timings
       NewRelic::Agent::TransactionState.any_instance.stubs(:timings).returns(stub(
           :transaction_name => TRANSACTION_NAME,

data/test/new_relic/agent/cross_app_tracing_test.rb

@@ -9,10 +9,10 @@ module NewRelic
   module Agent
     class CrossAppTracingTest < Minitest::Test
 
-      attr_reader :segment, :request, :response
+      attr_reader :node, :request, :response
 
       def setup
-        @segment = stub_everything
+        @node = stub_everything
         @request = stub_everything(:uri => URI.parse("http://newrelic.com"),
                                    :type => "Fake",
                                    :method => "GET")
@@ -21,28 +21,28 @@ module NewRelic
       end
 
       def test_start_trace
-        t0      = Time.now
-        segment = CrossAppTracing.start_trace(@state, t0, request)
-        refute_nil segment
+        t0   = Time.now
+        node = CrossAppTracing.start_trace(@state, t0, request)
+        refute_nil node
       end
 
-      def test_start_trace_has_nil_segment_on_agent_failure
+      def test_start_trace_has_nil_node_on_agent_failure
         @state.traced_method_stack.stubs(:push_frame).raises("Boom!")
         t0      = Time.now
-        segment = CrossAppTracing.start_trace(@state, t0, request)
-        assert_nil segment
+        node = CrossAppTracing.start_trace(@state, t0, request)
+        assert_nil node
       end
 
       def test_finish_trace_treats_nil_start_time_as_agent_error
         expects_logging(:error, any_parameters)
         expects_no_pop_frame
-        CrossAppTracing.finish_trace(@state, nil, segment, request, response)
+        CrossAppTracing.finish_trace(@state, nil, node, request, response)
       end
 
       # Since we log and swallow errors, assert on the logging to ensure these
       # paths are cleanly accepting nils, not just smothering the exceptions.
 
-      def test_finish_trace_allows_nil_segment
+      def test_finish_trace_allows_nil_node
         expects_no_logging(:error)
         CrossAppTracing.finish_trace(@state, Time.now, nil, request, response)
       end
@@ -50,13 +50,13 @@ module NewRelic
       def test_finish_trace_allows_nil_request
         expects_no_logging(:error)
         expects_pop_frame
-        CrossAppTracing.finish_trace(@state, Time.now, segment, nil, response)
+        CrossAppTracing.finish_trace(@state, Time.now, node, nil, response)
       end
 
       def test_finish_trace_allows_nil_response
         expects_no_logging(:error)
         expects_pop_frame
-        CrossAppTracing.finish_trace(@state, Time.now, segment, request, nil)
+        CrossAppTracing.finish_trace(@state, Time.now, node, request, nil)
       end
 
       def expects_pop_frame

data/test/new_relic/agent/database/sql_obfuscation_test.rb

@@ -6,79 +6,53 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'te
 
 module NewRelic::Agent::Database
   class SqlObfuscationTest < Minitest::Test
-    attr_reader :obfuscator
-
-    def self.input_files(subdir=nil)
-      fixture_dir = File.join(cross_agent_tests_dir, "sql_obfuscation")
-      fixture_dir = File.join(fixture_dir, subdir) if subdir
-      Dir["#{fixture_dir}/*.sql"]
-    end
-
-    def self.adapter_from_input_file(input_file)
-      case input_file
-      when /\.postgres\.sql$/ then :postgresql
-      when /\.mysql\.sql$/    then :mysql
-      else nil
+    DIALECT_MAP = {
+      'postgres' => :postgresql,
+      'mysql'    => :mysql
+    }
+
+    def self.create_input_statements(raw_query, dialects)
+      dialects.map do |dialect|
+        NewRelic::Agent::Database::Statement.new(raw_query).tap do |s|
+          s.adapter = DIALECT_MAP[dialect]
+        end
       end
     end
 
-    def self.name_for_input_file(input_file)
-      adapter = adapter_from_input_file(input_file)
-      basename = File.basename(input_file)
-      name = basename.gsub(/\.(postgres|mysql)?\.sql$/, '')
-      name += "_#{adapter}" if adapter
-      name
-    end
-
-    def obfuscated_filename(query_file)
-      query_file.gsub(".sql", ".obfuscated")
-    end
-
-    def strip_comments(text)
-      text.gsub(/^\s*#.*/, '').strip
-    end
-
-    def read_query(input_file)
-      adapter = self.class.adapter_from_input_file(input_file)
-      query = strip_comments(File.read(input_file))
-
-      if adapter
-        query = NewRelic::Agent::Database::Statement.new(query)
-        query.adapter = adapter.to_sym
-      end
-
-      query
-    end
-    
-    def self.create_regular_obfuscation_test(filename, type = "normal")
-      name = name_for_input_file(filename)
-
-      define_method("test_sql_obfuscation_#{type}_#{name}") do
-        query               = read_query(filename)
-        expected_obfuscated = File.read(obfuscated_filename(filename))
-        actual_obfuscated   = NewRelic::Agent::Database.obfuscate_sql(query)
-        assert_equal(expected_obfuscated, actual_obfuscated, "Failed to obfuscate #{type} query from #{filename}\nQuery: #{query}")
+    def build_failure_message(statement, acceptable_outputs, actual_output)
+      msg = "Failed to obfuscate #{statement.adapter} query correctly.\n"
+      msg << "Input:    #{statement.to_s}\n"
+      if acceptable_outputs.size == 1
+        msg << "Expected: #{acceptable_outputs.first}\n"
+      else
+        msg << "Acceptable outputs:\n"
+        acceptable_outputs.each do |output|
+          msg << "          #{output}\n"
+        end
       end
+      msg << "Actual:   #{actual_output}\n"
     end
 
-    # Normal queries
-    input_files.each do |input_file|
-      create_regular_obfuscation_test(input_file)
-    end
-    
-    # Pathological queries
-    input_files('pathological').each do |input_file|
-      create_regular_obfuscation_test(input_file, "pathological")
-    end
+    test_cases = load_cross_agent_test('sql_obfuscation/sql_obfuscation')
+    test_cases.each do |test_case|
+      name = test_case['name']
+      query              = test_case['sql']
+      acceptable_outputs = test_case['obfuscated']
+      dialects           = test_case['dialects']
 
-    # Malformed queries
-    input_files('malformed').each do |input_file|
-      name = name_for_input_file(input_file)
+      # If the entire query is obfuscated because it's malformed, we use a
+      # placeholder message instead of just '?', so add that to the acceptable
+      # outputs.
+      if test_case['malformed']
+        acceptable_outputs << NewRelic::Agent::Database::Obfuscator::FAILED_TO_OBFUSCATE_MESSAGE
+      end
 
-      define_method("test_sql_obfuscation_malformed_#{name}") do
-        query = read_query(input_file)
-        actual_obfuscated = NewRelic::Agent::Database.obfuscate_sql(query)
-        assert_equal(NewRelic::Agent::Database::Obfuscator::FAILED_TO_OBFUSCATE_MESSAGE, actual_obfuscated, "Failed to obfuscate malformed query from #{input_file}\nQuery: #{query}")
+      create_input_statements(query, dialects).each do |statement|
+        define_method("test_sql_obfuscation_#{name}_#{statement.adapter}") do
+          actual_obfuscated = NewRelic::Agent::Database.obfuscate_sql(statement)
+          message = build_failure_message(statement, acceptable_outputs, actual_obfuscated)
+          assert_includes(acceptable_outputs, actual_obfuscated, message)
+        end
       end
     end
   end

data/test/new_relic/agent/datastores/metric_helper_test.rb

@@ -56,6 +56,42 @@ module NewRelic
         assert_equal expected, result
       end
 
+      def test_metrics_for_obeys_collection_and_operation_overrides
+        in_transaction do
+          NewRelic::Agent.with_database_metric_name("Model", "new_method") do
+            expected = [
+              "Datastore/statement/JonanDB/Model/new_method",
+              "Datastore/operation/JonanDB/new_method",
+              "Datastore/JonanDB/allOther",
+              "Datastore/JonanDB/all",
+              "Datastore/allOther",
+              "Datastore/all"
+            ]
+
+            result = Datastores::MetricHelper.metrics_for(@product, "original_method")
+            assert_equal expected, result
+          end
+        end
+      end
+
+      def test_metrics_for_obeys_collection_override
+        in_transaction do
+          NewRelic::Agent.with_database_metric_name("Model", nil) do
+            expected = [
+              "Datastore/statement/JonanDB/Model/original_method",
+              "Datastore/operation/JonanDB/original_method",
+              "Datastore/JonanDB/allOther",
+              "Datastore/JonanDB/all",
+              "Datastore/allOther",
+              "Datastore/all"
+            ]
+
+            result = Datastores::MetricHelper.metrics_for(@product, "original_method")
+            assert_equal expected, result
+          end
+        end
+      end
+
     end
   end
 end