newrelic_rpm 3.12.0.288 → 3.12.1.298

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

@@ -85,18 +85,11 @@ module NewRelic::Agent::Instrumentation
     def test_children_respect_parental_ignore_rules_with_only
       parent = Class.new do
         include ControllerInstrumentation
-
         newrelic_ignore(:only => :foo)
-
-        def foo(*args); end
-        def foo2(*args); end
       end
 
       child = Class.new(parent) do
         newrelic_ignore(:only => :bar)
-
-        def bar(*args); end
-        def bar2(*args); end
       end
 
       key = ControllerInstrumentation::NR_DO_NOT_TRACE_KEY
@@ -110,18 +103,11 @@ module NewRelic::Agent::Instrumentation
     def test_children_respect_parental_ignore_rules_with_except
       parent = Class.new do
         include ControllerInstrumentation
-
         newrelic_ignore(:except => :foo)
-
-        def foo(*args); end
-        def foo2(*args); end
       end
 
       child = Class.new(parent) do
         newrelic_ignore(:except => :bar)
-
-        def bar(*args); end
-        def bar2(*args); end
       end
 
       key = ControllerInstrumentation::NR_DO_NOT_TRACE_KEY
@@ -135,17 +121,11 @@ module NewRelic::Agent::Instrumentation
     def test_children_respect_parental_ignore_rules_with_except_and_only
       parent = Class.new do
         include ControllerInstrumentation
-
         newrelic_ignore(:only => :foo)
-
-        def foo(*args); end
-        def foo2(*args); end
       end
 
       child = Class.new(parent) do
         newrelic_ignore(:except => :foo)
-
-        def bar(*args); end
       end
 
       key = ControllerInstrumentation::NR_DO_NOT_TRACE_KEY
@@ -155,6 +135,29 @@ module NewRelic::Agent::Instrumentation
       assert IgnoreActions.is_filtered?(key, child, :foo2)
     end
 
+    def test_ignore_allows_strings
+      controller = Class.new do
+        include ControllerInstrumentation
+
+        newrelic_ignore(:only => "foo")
+      end
+
+      key = ControllerInstrumentation::NR_DO_NOT_TRACE_KEY
+      assert IgnoreActions.is_filtered?(key, controller, :foo)
+    end
+
+    def test_ignore_allows_mixed_strings_and_symbols
+      controller = Class.new do
+        include ControllerInstrumentation
+
+        newrelic_ignore(:only => ["foo", :bar])
+      end
+
+      key = ControllerInstrumentation::NR_DO_NOT_TRACE_KEY
+      assert IgnoreActions.is_filtered?(key, controller, :foo)
+      assert IgnoreActions.is_filtered?(key, controller, :bar)
+    end
+
     def test_transaction_name_calls_newrelic_metric_path
       @object.stubs(:newrelic_metric_path).returns('some/wacky/path')
       assert_equal('Controller/some/wacky/path', @txn_namer.name_for(nil, @object, :controller))

data/test/new_relic/agent/memory_logger_test.rb

@@ -64,4 +64,22 @@ class MemoryLoggerTest < Minitest::Test
 
     @logger.dump(real_logger)
   end
+
+  def test_log_once
+    @logger.log_once(:debug, :once, "Once")
+    @logger.log_once(:debug, :once, "Twice?")
+
+    real_logger = stub
+    real_logger.expects(:debug).once
+
+    @logger.dump(real_logger)
+  end
+
+  def test_implemented_agent_logger_interface
+    agent_logger_methods =  NewRelic::Agent::AgentLogger.instance_methods(false)
+    memory_logger_methods = NewRelic::Agent::MemoryLogger.instance_methods(false)
+
+    unimplemented = agent_logger_methods - memory_logger_methods
+    assert_empty unimplemented
+  end
 end

data/test/new_relic/agent/new_relic_service_test.rb

@@ -8,8 +8,7 @@ require 'new_relic/agent/commands/thread_profiler_session'
 
 class NewRelicServiceTest < Minitest::Test
   def setup
-    @server = NewRelic::Control::Server.new('somewhere.example.com',
-                                            30303, '10.10.10.10')
+    @server = NewRelic::Control::Server.new('somewhere.example.com', 30303)
     @service = NewRelic::Agent::NewRelicService.new('license-key', @server)
 
     @http_handle = create_http_handle
@@ -228,12 +227,6 @@ class NewRelicServiceTest < Minitest::Test
     assert_equal 'localhost', @service.collector.name
   end
 
-  def test_connect_resets_cached_ip_address
-    assert_equal '10.10.10.10', @service.collector.ip
-    @service.connect
-    assert_equal 'localhost', @service.collector.ip # 'localhost' resolves to nil
-  end
-
   def test_connect_uses_proxy_collector_if_no_redirect_host
     @http_handle.reset
     @http_handle.respond_to(:get_redirect_host, nil)
@@ -726,7 +719,7 @@ class NewRelicServiceTest < Minitest::Test
     spec1 = NewRelic::MetricSpec.new('foo')
     spec2 = NewRelic::MetricSpec.new('bar')
     hash.record(spec1, 1)
-    hash[spec2] = NewRelic::Agent::Stats.new()
+    hash.record(spec2) { |s| s.call_count = 0 }
 
     metric_data_array = @service.build_metric_data_array(hash)
     assert_equal(1, metric_data_array.size)

data/test/new_relic/agent/rpm_agent_test.rb

@@ -32,16 +32,6 @@ class NewRelic::Agent::RpmAgentTest < Minitest::Test
     assert(ignore_called)
   end
 
-  def test_startup_shutdown_shim
-    with_config(:agent_enabled => true) do
-      shim_agent = NewRelic::Agent::ShimAgent.instance
-      shim_agent.shutdown
-      refute shim_agent.started?
-      shim_agent.start
-      refute shim_agent.started?
-    end
-  end
-
   def test_startup_shutdown_real
     with_config(:agent_enabled => true, :monitor_mode => true) do
       NewRelic::Agent.manual_start :monitor_mode => true, :license_key => ('x' * 40)

data/test/new_relic/agent/sql_sampler_test.rb

@@ -159,13 +159,13 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     queries = [
                NewRelic::Agent::SlowSql.new("select * from test",
                                             "Database/test/select", config,
-                                            1.5, nil, &explainer),
+                                            1.5, nil, explainer),
                NewRelic::Agent::SlowSql.new("select * from test",
                                             "Database/test/select", config,
-                                            1.2, nil, &explainer),
+                                            1.2, nil, explainer),
                NewRelic::Agent::SlowSql.new("select * from test2",
                                             "Database/test2/select", config,
-                                            1.1, nil, &explainer)
+                                            1.1, nil, explainer)
               ]
     data.sql_data.concat(queries)
     @sampler.save_slow_sql data
@@ -300,7 +300,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
       explainer = NewRelic::Agent::Instrumentation::ActiveRecord::EXPLAINER
       data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test",
                                                          "Database/test/select",
-                                                         {}, 1.5, &explainer)])
+                                                         {}, 1.5, nil, explainer)])
       @sampler.save_slow_sql(data)
       sql_traces = @sampler.harvest!
 

data/test/new_relic/agent/stats_engine/stats_hash_test.rb

@@ -11,7 +11,7 @@ class NewRelic::Agent::StatsHashTest < Minitest::Test
   end
 
   def test_creates_default_entries
-    stats = @hash['a/b/c/d']
+    stats = @hash[NewRelic::MetricSpec.new('a/b/c/d')]
     assert_kind_of(NewRelic::Agent::Stats, stats)
   end
 
@@ -148,31 +148,31 @@ class NewRelic::Agent::StatsHashTest < Minitest::Test
   end
 
   def test_marshal_dump
-    @hash.record('foo', 1)
-    @hash.record('bar', 2)
+    @hash.record(NewRelic::MetricSpec.new('foo'), 1)
+    @hash.record(NewRelic::MetricSpec.new('bar'), 2)
     copy = Marshal.load(Marshal.dump(@hash))
     assert_equal(@hash, copy)
     assert_equal(@hash.started_at, copy.started_at)
   end
 
-  def test_borked_default_proc_can_record_metric
-    fake_borked_default_proc(@hash)
+  # We can only fix up the default proc on Rubies that let us set it
+  if {}.respond_to?(:default_proc=)
+    def test_borked_default_proc_can_record_metric
+      fake_borked_default_proc(@hash)
 
-    @hash.record(DEFAULT_SPEC, 1)
+      @hash.record(DEFAULT_SPEC, 1)
 
-    assert_equal(1, @hash.fetch(DEFAULT_SPEC, nil).call_count)
-  end
+      assert_equal(1, @hash[DEFAULT_SPEC].call_count)
+    end
 
-  def test_borked_default_proc_notices_agent_error
-    fake_borked_default_proc(@hash)
+    def test_borked_default_proc_notices_agent_error
+      fake_borked_default_proc(@hash)
 
-    @hash.record(DEFAULT_SPEC, 1)
+      @hash.record(DEFAULT_SPEC, 1)
 
-    assert_has_error NewRelic::Agent::StatsHash::StatsHashLookupError
-  end
+      assert_has_error NewRelic::Agent::StatsHash::StatsHashLookupError
+    end
 
-  # We can only fix up the default proc on Rubies that let us set it
-  if {}.respond_to?(:default_proc=)
     def test_borked_default_proc_heals_thyself
       fake_borked_default_proc(@hash)
 
@@ -186,13 +186,9 @@ class NewRelic::Agent::StatsHashTest < Minitest::Test
 
   DEFAULT_SPEC = NewRelic::MetricSpec.new('foo')
 
-  def fake_borked_default_proc(hash)
+  def fake_borked_default_proc(stats_hash)
     exception = NoMethodError.new("borked default proc gives a NoMethodError on `yield'")
-    if hash.respond_to?(:default_proc=)
-      hash.default_proc = Proc.new { raise exception }
-    else
-      hash.stubs(:[]).raises(exception)
-    end
+    hash = stats_hash.instance_variable_get(:@unscoped)
+    hash.default_proc = Proc.new { raise exception }
   end
-
 end

data/test/new_relic/agent/system_info_test.rb

@@ -5,39 +5,34 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..', '..','test_helper'))
 
 class NewRelic::Agent::SystemInfoTest < Minitest::Test
-
   def setup
+    NewRelic::Agent.instance.stats_engine.clear_stats
     @sysinfo = ::NewRelic::Agent::SystemInfo
     @sysinfo.clear_processor_info
   end
 
-  cpuinfo_test_dir = File.join(cross_agent_tests_dir, 'proc_cpuinfo')
-
-  Dir.chdir(cpuinfo_test_dir) do
-    Dir.glob("*.txt") do |file|
-      if file =~ /^((\d+|X)pack_(\d+|X)core_(\d+|X)logical).txt$/
-        test_name = "test_#{$1}"
-        test_path = File.join(cpuinfo_test_dir, file)
+  each_cross_agent_test :dir => 'proc_cpuinfo', :pattern => "*.txt" do |file|
+    if File.basename(file) =~ /^((\d+|X)pack_(\d+|X)core_(\d+|X)logical).txt$/
+      test_name = "test_#{$1}"
 
-        num_physical_packages  = $2.to_i
-        num_physical_cores     = $3.to_i
-        num_logical_processors = $4.to_i
-        num_physical_packages  = nil if num_physical_packages  < 1
-        num_physical_cores     = nil if num_physical_cores     < 1
-        num_logical_processors = nil if num_logical_processors < 1
+      num_physical_packages  = $2.to_i
+      num_physical_cores     = $3.to_i
+      num_logical_processors = $4.to_i
+      num_physical_packages  = nil if num_physical_packages  < 1
+      num_physical_cores     = nil if num_physical_cores     < 1
+      num_logical_processors = nil if num_logical_processors < 1
 
-        define_method(test_name) do
-          cpuinfo = File.read(test_path)
+      define_method(test_name) do
+        cpuinfo = File.read(file)
 
-          info = @sysinfo.parse_cpuinfo(cpuinfo)
+        info = @sysinfo.parse_cpuinfo(cpuinfo)
 
-          assert_equal(num_physical_packages , info[:num_physical_packages ])
-          assert_equal(num_physical_cores    , info[:num_physical_cores    ])
-          assert_equal(num_logical_processors, info[:num_logical_processors])
-        end
-      else
-        fail "Bad filename: cross_agent_tests/proc_cpuinfo/#{file}"
+        assert_equal(num_physical_packages , info[:num_physical_packages ])
+        assert_equal(num_physical_cores    , info[:num_physical_cores    ])
+        assert_equal(num_logical_processors, info[:num_logical_processors])
       end
+    else
+      fail "Bad filename: cross_agent_tests/proc_cpuinfo/#{file}"
     end
   end
 
@@ -55,7 +50,70 @@ class NewRelic::Agent::SystemInfoTest < Minitest::Test
 
       message = "Parsed incorrect Docker container ID from #{filename}"
       assert_equal(test_case['containerId'], container_id, message)
+
+      if test_case['expectedMetrics']
+        assert_metrics_recorded test_case['expectedMetrics']
+      else
+        refute_metrics_recorded "Supportability/utilization/docker/error"
+      end
+    end
+  end
+
+
+  each_cross_agent_test :dir => 'proc_meminfo', :pattern => '*.txt' do |file|
+    if File.basename(file) =~ /^meminfo_(\d+)MB.txt$/
+      test_name = "test_#{file}"
+
+      mem_total_expected = $1.to_f
+
+      define_method(test_name) do
+        meminfo = File.read(file)
+
+        mem_total_actual = @sysinfo.parse_linux_meminfo_in_mib(meminfo)
+
+        assert_equal(mem_total_expected, mem_total_actual)
+      end
+    else
+      fail "Bad filename: cross_agent_tests/proc_meminfo/#{file}"
+    end
+  end
+
+  def test_proc_meminfo_unparsable
+    assert_nil @sysinfo.parse_linux_meminfo_in_mib("")
+  end
+
+  def test_system_info_darwin_predicate
+    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("darwin13")
+    assert NewRelic::Agent::SystemInfo.darwin?, "Expected OS to match darwin"
+
+    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("linux")
+    refute NewRelic::Agent::SystemInfo.darwin?, "Did not expect OS to match darwin"
+  end
+
+  def test_system_info_linux_predicate
+    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("linux")
+    assert NewRelic::Agent::SystemInfo.linux?, "Expected OS to match linux"
+
+    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("darwin13")
+    refute NewRelic::Agent::SystemInfo.linux?, "Did not expect OS to match linux"
+  end
+
+  def test_system_info_bsd_predicate
+    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("freebsd")
+    assert NewRelic::Agent::SystemInfo.bsd?, "Expected OS to match bsd"
+
+    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("darwin13")
+    refute NewRelic::Agent::SystemInfo.bsd?, "Did not expect OS to match bsd"
+  end
+
+  def test_supportability_metric_recorded_when_docker_id_unavailable
+    NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns("linux")
+    cgroup_info = File.read File.join(cross_agent_tests_dir, 'docker_container_id', 'invalid-length.txt')
+    NewRelic::Agent::SystemInfo.expects(:proc_try_read).with('/proc/self/cgroup').returns(cgroup_info)
+    in_transaction('txn') do
+      assert_nil NewRelic::Agent::SystemInfo.docker_container_id
     end
+    assert_metrics_recorded "Supportability/utilization/docker/error"
   end
 end
 

data/test/new_relic/agent/transaction_event_aggregator_test.rb

@@ -294,13 +294,6 @@ class NewRelic::Agent::TransactionEventAggregatorTest < Minitest::Test
     end
   end
 
-  def test_includes_http_response_code_in_events
-    generate_request('whatever', :http_response_code => 404)
-    sample = captured_transaction_event
-    code = sample[EVENT_DATA_INDEX]['httpResponseCode']
-    assert_equal('404', code)
-  end
-
   def test_synthetics_aggregation_limits
     with_sampler_config(:'synthetics.events_limit' => 10,
                         :'analytics_events.max_samples_stored' => 0) do

data/test/new_relic/agent/transaction_test.rb

@@ -1412,7 +1412,7 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
     end
 
     actual = txn.attributes.agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER)
-    assert_equal 418, actual[:'httpResponseCode']
+    assert_equal "418", actual[:"httpResponseCode"]
   end
 
   def test_referer_in_agent_attributes

data/test/new_relic/agent/utilization_data_test.rb

@@ -3,16 +3,145 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
-require File.expand_path(File.join(File.dirname(__FILE__),'..','data_container_tests'))
+require 'new_relic/agent/utilization_data'
 
 module NewRelic::Agent
   class UtilizationDataTest < Minitest::Test
-    # We don't behave like a normal container, but we need to match the
-    # interface at least!
-    include NewRelic::BasicDataContainerMethodTests
+    def setup
+      stub_aws_info
+    end
+
+    def test_aws_information_is_included_when_available
+      stub_aws_info(
+        :instance_id => "i-e7e85ce1",
+        :instance_type => "m3.medium",
+        :availability_zone => "us-west-2b"
+      )
+
+      utilization_data = UtilizationData.new
+
+      expected = {
+        :aws => {
+          :id => "i-e7e85ce1",
+          :type => "m3.medium",
+          :zone => "us-west-2b"
+        }
+      }
+
+      assert_equal expected, utilization_data.to_collector_hash[:vendors]
+    end
+
+    def test_aws_information_is_omitted_when_available_but_disabled_by_config
+      stub_aws_info(
+        :instance_id => "i-e7e85ce1",
+        :instance_type => "m3.medium",
+        :availability_zone => "us-west-2b"
+      )
+
+      with_config(:'utilization.detect_aws' => false) do
+        utilization_data = UtilizationData.new
+        assert_nil utilization_data.to_collector_hash[:vendors]
+      end
+    end
+
+    def test_docker_information_is_included_when_available
+      NewRelic::Agent::SystemInfo.stubs(:docker_container_id).returns("47cbd16b77c50cbf71401")
+
+      utilization_data = UtilizationData.new
+
+      expected = {
+        :docker => {
+          :id => "47cbd16b77c50cbf71401"
+        }
+      }
+
+      assert_equal expected, utilization_data.to_collector_hash[:vendors]
+    end
+
+    def test_docker_information_is_omitted_when_available_but_disabled_by_config
+      NewRelic::Agent::SystemInfo.stubs(:docker_container_id).returns("47cbd16b77c50cbf71401")
+      with_config(:'utilization.detect_docker' => false) do
+        utilization_data = UtilizationData.new
+        assert_nil utilization_data.to_collector_hash[:vendors]
+      end
+    end
+
+    def test_logged_when_docker_container_id_is_unrecognized
+      NewRelic::Agent::SystemInfo.stubs(:ruby_os_identifier).returns('linux')
+      NewRelic::Agent::SystemInfo.stubs(:ram_in_mib).returns(128)
+      NewRelic::Agent::SystemInfo.stubs(:proc_try_read).returns('whatever')
+      NewRelic::Agent::SystemInfo.stubs(:parse_cgroup_ids).returns('cpu' => "*****YOLO*******")
+
+      expects_logging(:debug, includes("YOLO"))
+      utilization_data = UtilizationData.new
+      assert_nil utilization_data.to_collector_hash[:vendors]
+    end
+
+    def test_aws_and_docker_information_is_included_when_both_available
+      stub_aws_info(
+        :instance_id => "i-e7e85ce1",
+        :instance_type => "m3.medium",
+        :availability_zone => "us-west-2b"
+      )
+
+      NewRelic::Agent::SystemInfo.stubs(:docker_container_id).returns("47cbd16b77c50cbf71401")
+
+      utilization_data = UtilizationData.new
+
+      expected = {
+        :aws => {
+          :id => "i-e7e85ce1",
+          :type => "m3.medium",
+          :zone => "us-west-2b"
+        },
+        :docker => {
+          :id => "47cbd16b77c50cbf71401"
+        }
+      }
+
+       assert_equal expected, utilization_data.to_collector_hash[:vendors]
+    end
+
+    def test_vendor_information_is_omitted_if_unavailable
+      utilization_data = UtilizationData.new
+
+      assert_nil utilization_data.to_collector_hash[:vendors]
+    end
+
+    def test_hostname_is_present_in_collector_hash
+      NewRelic::Agent::Hostname.stubs(:get).returns("host")
+
+      utilization_data = UtilizationData.new
+
+      assert_equal "host", utilization_data.to_collector_hash[:hostname]
+    end
+
+    def test_cpu_count_is_present_in_collector_hash
+      NewRelic::Agent::SystemInfo.stubs(:num_logical_processors).returns(5)
+
+      utilization_data = UtilizationData.new
+
+      assert_equal 5, utilization_data.to_collector_hash[:logical_processors]
+    end
+
+    def test_memory_is_present_in_collector_hash
+      NewRelic::Agent::SystemInfo.stubs(:ram_in_mib).returns(128)
+
+      utilization_data = UtilizationData.new
+
+      assert_equal 128, utilization_data.to_collector_hash[:total_ram_mib]
+    end
+
+    def test_metadata_version_is_present_in_collector_hash
+      utilization_data = UtilizationData.new
+
+      assert_equal UtilizationData::METADATA_VERSION, utilization_data.to_collector_hash[:metadata_version]
+    end
 
-    def create_container
-      UtilizationData.new
+    def stub_aws_info(responses = {})
+      AWSInfo.any_instance.stubs(:remote_fetch).with("instance-id").returns(responses[:instance_id])
+      AWSInfo.any_instance.stubs(:remote_fetch).with("instance-type").returns(responses[:instance_type])
+      AWSInfo.any_instance.stubs(:remote_fetch).with("placement/availability-zone").returns(responses[:availability_zone])
     end
   end
 end