newrelic_rpm 3.9.5.251 → 3.9.6.257

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

@@ -80,6 +80,30 @@ module NewRelic::Agent::Configuration
       nil
     end
 
+    def test_transform_for_returns_a_proc_for_settings_with_a_transform
+      assert_equal Proc, DefaultSource.transform_for(:'rules.ignore_url_regexes').class
+    end
+
+    def test_transform_for_returns_nil_for_settings_that_do_not_have_a_transform
+      assert_nil DefaultSource.transform_for(:ca_bundle_path)
+    end
+
+    def test_convert_to_list
+      result = DefaultSource.convert_to_list("Foo,Bar,Baz")
+      assert_equal ['Foo', 'Bar', 'Baz'], result
+    end
+
+    def test_convert_to_list_returns_original_argument_given_array
+      result = DefaultSource.convert_to_list(['Foo'])
+      assert_equal ['Foo'], result
+    end
+
+    def test_rules_ignore_converts_comma_delimited_string_to_array
+      with_config(:'rules.ignore_url_regexes' => 'Foo,Bar,Baz') do
+        assert_equal [/Foo/, /Bar/, /Baz/], NewRelic::Agent.config[:'rules.ignore_url_regexes']
+      end
+    end
+
     def get_config_value_class(value)
       type = value.class
 

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

@@ -298,7 +298,8 @@ module NewRelic::Agent::Configuration
         @manager.add_config_for_testing(:labels => testcase["labelString"])
 
         assert_warning if testcase["warning"]
-        assert_equal(testcase["expected"], @manager.parse_labels_from_string)
+        assert_equal(testcase["expected"].sort_by { |h| h["label_type"] },
+                     @manager.parse_labels_from_string.sort_by { |h| h["label_type"] })
       end
     end
 
@@ -312,7 +313,7 @@ module NewRelic::Agent::Configuration
 
     def test_parse_labels_from_string_with_hard_failure
       bad_string = "baaaad"
-      bad_string.stubs(:gsub).raises("Booom")
+      bad_string.stubs(:strip).raises("Booom")
       @manager.add_config_for_testing(:labels => bad_string)
 
       assert_parsing_error
@@ -367,6 +368,63 @@ module NewRelic::Agent::Configuration
       assert_parsed_labels(expected)
     end
 
+    def test_apply_transformations
+      transform = Proc.new { |value| value.gsub('foo', 'baz') }
+      ::NewRelic::Agent::Configuration::DefaultSource.stubs(:transform_for).returns(transform)
+
+      assert_equal 'bazbar', @manager.apply_transformations(:test, 'foobar')
+    end
+
+    def test_fetch_with_a_transform_returns_the_transformed_value
+      with_config(:rules => { :ignore_url_regexes => ['more than meets the eye'] }) do
+        assert_equal [/more than meets the eye/], @manager.fetch(:'rules.ignore_url_regexes')
+      end
+    end
+
+    def test_fetch_skips_the_config_layer_if_transformation_raises_error
+      bomb = Proc.new do |value|
+        if value == 'boom'
+          raise StandardError.new
+        else
+          value
+        end
+      end
+      @manager.stubs(:transform_from_default).returns(bomb)
+
+      with_config(:'rules.ignore_url_regexes' => 'boom') do
+        assert_equal [], @manager.fetch(:'rules.ignore_url_regexes')
+      end
+    end
+
+    def test_evaluate_procs_returns_evaluated_value_if_it_responds_to_call
+      callable = Proc.new { 'test' }
+      assert_equal 'test', @manager.evaluate_procs(callable)
+    end
+
+    def test_evaluate_procs_returns_original_value_if_it_does_not_respond_to_call
+      assert_equal 'test', @manager.evaluate_procs('test')
+    end
+
+    def test_apply_transformations_logs_error_if_transformation_fails
+      bomb = Proc.new { raise StandardError.new }
+      @manager.stubs(:transform_from_default).returns(bomb)
+
+      expects_logging(:error, includes("Error applying transformation"), any_parameters)
+
+      assert_raises StandardError do
+        @manager.apply_transformations(:test_key, 'test_value')
+      end
+    end
+
+    def test_apply_transformations_reraises_errors
+      bomb = Proc.new { raise StandardError.new }
+      @manager.stubs(:transform_from_default).returns(bomb)
+
+      assert_raises StandardError do
+        @manager.apply_transformations(:test_key, 'test_value')
+      end
+    end
+
     def assert_parsed_labels(expected)
       result = @manager.parsed_labels
 

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

@@ -12,12 +12,8 @@ class OrphanedConfigTest < Minitest::Test
   end
 
   def test_all_agent_config_keys_are_declared_in_default_source
-    non_test_files = all_rb_files.reject { |filename| filename.include? 'test.rb' }
-
     non_test_files.each do |file|
-      lines = File.read(file).split("\n")
-
-      lines.each_with_index do |line, index|
+      lines_in(file).each_with_index do |line, index|
         config_match = line.match(/Agent\.config\[:['"]?([a-z\._]+)['"]?\]/)
         next unless config_match
 
@@ -35,22 +31,16 @@ class OrphanedConfigTest < Minitest::Test
 
   AGENT_CONFIG_PATTERN      = /Agent\.config\[:['"]?([a-z\._]+)['"]?\s*\]/
   REGISTER_CALLBACK_PATTERN = /register_callback\(:['"]?([a-z\._]+)['"]?\)/
-  NAMED_DEPENDENCY_PATTERN  = /^\s*named[ (]+\:?([a-z\._]+).*$/
+  NAMED_DEPENDENCY_PATTERN  = /^\s*named[ (]+\:?([a-z0-9\._]+).*$/
 
   def test_all_default_source_config_keys_are_used_in_the_agent
-    non_test_files = all_rb_files.reject { |filename| filename.include? 'test.rb' }
-
     non_test_files.each do |file|
-      lines = File.read(file).split("\n")
-
-      lines.each_with_index do |line, index|
+      lines_in(file).each do |line|
         captures = []
         captures << line.scan(AGENT_CONFIG_PATTERN)
         captures << line.scan(REGISTER_CALLBACK_PATTERN)
         captures << line.scan(NAMED_DEPENDENCY_PATTERN).map(&method(:disable_name))
 
-        next if captures.empty?
-
         captures.flatten.map do |key|
           @default_keys.delete key.gsub("'", "").to_sym
         end
@@ -67,6 +57,28 @@ class OrphanedConfigTest < Minitest::Test
     assert_empty @default_keys
   end
 
+  def test_documented_all_named_instrumentation_files
+    non_test_files.each do |file|
+      next unless file.include?("new_relic/agent/instrumentation")
+
+      lines_in(file).each_with_index do |line, index|
+        captures = line.scan(NAMED_DEPENDENCY_PATTERN).map(&method(:disable_name))
+
+        captures.flatten.map do |key|
+          refute NewRelic::Agent::Configuration::DEFAULTS[key.to_sym].nil?, "#{file}:#{index+1} - Document key `#{key}` found as name for instrumentation.\n"
+        end
+      end
+    end
+  end
+
+  def lines_in(file)
+    File.read(file).split("\n")
+  end
+
+  def non_test_files
+    all_rb_files.reject { |filename| filename.include? 'test.rb' }
+  end
+
   def disable_name(names)
     names.map { |name| "disable_#{name}" }
   end

data/test/new_relic/agent/cross_app_tracing_test.rb

@@ -33,6 +33,12 @@ module NewRelic
         assert_nil segment
       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)
+      end
+
       # Since we log and swallow errors, assert on the logging to ensure these
       # paths are cleanly accepting nils, not just smothering the exceptions.
 
@@ -53,10 +59,13 @@ module NewRelic
         CrossAppTracing.finish_trace(@state, Time.now, segment, request, nil)
       end
 
-
       def expects_pop_frame
         @state.traced_method_stack.stubs(:pop_frame).once
       end
+
+      def expects_no_pop_frame
+        @state.traced_method_stack.stubs(:pop_frame).never
+      end
     end
   end
 end

data/test/new_relic/agent/instrumentation/active_job_test.rb

@@ -0,0 +1,20 @@
+# 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/instrumentation/active_job'
+
+module NewRelic::Agent::Instrumentation
+  class ActiveJobHelperTest < Minitest::Test
+    def test_rails_formatted_adapters_get_shortened
+      name = ActiveJobHelper.clean_adapter_name("ActiveJob::QueueAdapters::InlineAdapter")
+      assert_equal "ActiveJob::Inline", name
+    end
+
+    def test_unexpected_name_format
+      name = ActiveJobHelper.clean_adapter_name("Not::AnExpected::Adapter")
+      assert_equal "Not::AnExpected::Adapter", name
+    end
+  end
+end

data/test/new_relic/agent/instrumentation/active_record_test.rb

@@ -13,8 +13,7 @@ class NewRelic::Agent::Instrumentation::NewActiveRecordInstrumentationTest < Min
     NewRelic::Agent.manual_start
     ActiveRecord::Base.establish_connection unless ActiveRecord::Base.connection.active?
     ActiveRecordFixtures.setup
-    NewRelic::Agent.instance.transaction_sampler.reset!
-    NewRelic::Agent.instance.stats_engine.clear_stats
+    NewRelic::Agent.drop_buffered_data
   end
 
   def teardown
@@ -311,15 +310,21 @@ class NewRelic::Agent::Instrumentation::NewActiveRecordInstrumentationTest < Min
       end
     end
 
-    call_count = active_record_query_caching_broken_for_find ? 3 : 1
-    assert_activerecord_metrics(ActiveRecordFixtures::Order, 'find', :call_count => call_count)
+    assert_activerecord_metrics(ActiveRecordFixtures::Order, 'find', :call_count => 1)
     assert_remote_service_metrics
   end
 
   def test_cached_calls_are_not_recorded_with_select_all
-    query = "SELECT * FROM #{ActiveRecordFixtures::Order.table_name} WHERE name = 'Oberon'"
+    # If this is the first create, ActiveRecord needs to warm up,
+    # send some SQL SELECTS, etc.
     in_web_transaction do
       ActiveRecordFixtures::Order.create(:name => 'Oberon')
+    end
+    NewRelic::Agent.drop_buffered_data
+
+    # the actual test is here
+    query = "SELECT * FROM #{ActiveRecordFixtures::Order.table_name} WHERE name = 'Oberon'"
+    in_web_transaction do
       ActiveRecordFixtures::Order.connection.cache do
         ActiveRecordFixtures::Order.connection.select_all(query)
         ActiveRecordFixtures::Order.connection.select_all(query)
@@ -385,18 +390,6 @@ class NewRelic::Agent::Instrumentation::NewActiveRecordInstrumentationTest < Min
     end
   end
 
-  def active_record_query_caching_broken_for_find
-    # For ActiveRecord 3.1 and 3.2 running in JRuby, some
-    # query caching does not work.
-    return false unless defined? JRuby
-    return false unless active_record_major_version == 3
-
-    case active_record_minor_version
-    when 1, 2 then true
-    else false
-    end
-  end
-
   def assert_activerecord_metrics(model, operation, stats={})
     assert_metrics_recorded({
       "ActiveRecord/all" => {},

data/test/new_relic/agent/instrumentation/controller_instrumentation_test.rb

@@ -341,5 +341,20 @@ module NewRelic::Agent::Instrumentation
         host.doit
       end
     end
+
+    def test_should_not_set_request
+      clazz = Class.new do
+        include ControllerInstrumentation
+
+        def doit
+          perform_action_with_newrelic_trace do
+            NewRelic::Agent::TransactionState.tl_get.current_transaction.request
+          end
+        end
+      end
+
+      request = clazz.new.doit
+      assert_nil request
+    end
   end
 end

data/test/new_relic/agent/instrumentation/sinatra_test.rb

@@ -56,7 +56,7 @@ class NewRelic::Agent::Instrumentation::SinatraTest < Minitest::Test
     SinatraTestApp.stubs(:middleware).returns([])
 
     SinatraTestApp.expects(:build_without_newrelic).once
-    SinatraTestApp.expects(:use).at_least(3)
+    SinatraTestApp.expects(:use).at_least(2)
 
     SinatraTestApp.build_with_newrelic(@app)
   end

data/test/new_relic/agent/new_relic_service_test.rb

@@ -429,6 +429,18 @@ class NewRelicServiceTest < Minitest::Test
       end
     end
 
+    def test_json_marshaller_logs_on_empty_response_from_collector
+      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      expects_logging(:error, any_parameters)
+      assert_nil marshaller.load('')
+    end
+
+    def test_json_marshaller_logs_on_nil_response_from_collector
+      marshaller = NewRelic::Agent::NewRelicService::JsonMarshaller.new
+      expects_logging(:error, any_parameters)
+      assert_nil marshaller.load(nil)
+    end
+
     def test_raises_serialization_error_if_json_serialization_fails
       ::NewRelic::JSONWrapper.stubs(:dump).raises(RuntimeError.new('blah'))
       assert_raises(NewRelic::Agent::SerializationError) do
@@ -529,6 +541,18 @@ class NewRelicServiceTest < Minitest::Test
     end
   end
 
+  def test_pruby_marshaller_logs_on_empty_response_from_collector
+    marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+    expects_logging(:error, any_parameters)
+    assert_nil marshaller.load('')
+  end
+
+  def test_pruby_marshaller_logs_on_nil_response_from_collector
+    marshaller = NewRelic::Agent::NewRelicService::PrubyMarshaller.new
+    expects_logging(:error, any_parameters)
+    assert_nil marshaller.load(nil)
+  end
+
   def test_compress_request_if_needed_compresses_large_payloads
     large_payload = 'a' * 65 * 1024
     body, encoding = @service.compress_request_if_needed(large_payload)

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -13,12 +13,16 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
     @test_config = { :developer_mode => true }
     NewRelic::Agent.agent.drop_buffered_data
     NewRelic::Agent.config.add_config_for_testing(@test_config)
-    NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
+
+    listener = NewRelic::Agent::PipeChannelManager::Listener.new
+    NewRelic::Agent::PipeChannelManager.instance_variable_set(:@listener, listener)
+
     NewRelic::Agent.manual_start
     NewRelic::Agent::TransactionState.tl_clear_for_testing
   end
 
   def teardown
+    NewRelic::Agent::PipeChannelManager.listener.close_all_pipes
     NewRelic::Agent::PipeChannelManager.listener.stop
     NewRelic::Agent.shutdown
     NewRelic::Agent.config.remove_config(@test_config)
@@ -110,7 +114,7 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
           :duration => 10,
           :type => :controller
         })
-        NewRelic::Agent.agent.send(:transmit_transaction_event_data)
+        NewRelic::Agent.agent.send(:transmit_event_data)
       end
 
       assert_equal(1, request_sampler.samples.size)
@@ -223,6 +227,44 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
     assert_nil pipe.read
   end
 
+  def test_listener_pipes_race_condition
+    # 1.8.7 doesn't have easy singleton_class access, but also doesn't have
+    # races thanks to green threads and the GIL, so pitch it!
+    return if RUBY_VERSION < "1.9.2"
+
+    begin
+      listener = NewRelic::Agent::PipeChannelManager.listener
+      listener.instance_variable_set(:@select_timeout, 0.00001)
+      listener.start
+
+      listener.register_pipe(0)
+      pipe_out = listener.pipes[0].out
+
+      mutex = Mutex.new
+      mutex.lock
+      tried_to_close = false
+      pipe_out.singleton_class.send(:define_method, :closed?, Proc.new do
+        tried_to_close = true
+        mutex.synchronize do
+        end
+      end)
+
+      # Make sure we're actually paused in closed? call
+      until tried_to_close
+      end
+
+      t = Thread.new do
+        listener.register_pipe(1)
+      end
+
+      mutex.unlock
+      t.join
+    ensure
+      listener.close_all_pipes
+      listener.stop
+    end
+  end
+
   def run_child(channel_id)
     pid = Process.fork do
       yield

data/test/new_relic/agent/threading/agent_thread_test.rb

@@ -32,8 +32,7 @@ module NewRelic::Agent::Threading
 
       t = Thread.new do
         begin
-          in_transaction do |txn|
-            txn.request = 'whatever'
+          in_web_transaction do
             q0.push 'unblock main thread'
             q1.pop
           end

data/test/new_relic/agent/threading/backtrace_node_test.rb

@@ -73,6 +73,18 @@ module NewRelic::Agent::Threading
         node.as_array)
     end
 
+    def test_nodes_without_line_numbers
+      line = "transaction_sample_buffer.rb:in `visit_segment'"
+      node = create_node(line)
+      convert_nodes_to_array([node])
+
+      assert_equal([
+                   ["transaction_sample_buffer.rb", "visit_segment", -1],
+                   0, 0,
+                   []],
+                   node.as_array)
+    end
+
     def test_gracefully_handle_bad_values_in_to_array
       node = BacktraceNode.new(SINGLE_LINE)
       node.stubs(:parse_backtrace_frame).returns(["irb.rb", "catch", "blarg"])