newrelic_rpm 3.9.4.245 → 3.9.5.251

data/test/new_relic/agent/request_sampler_test.rb

@@ -236,6 +236,13 @@ class NewRelic::Agent::RequestSamplerTest < Minitest::Test
     end
   end
 
+  def test_includes_http_response_code_in_events
+    generate_request('whatever', :http_response_code => 404)
+    sample = single_sample
+    code = sample[EVENT_DATA_INDEX]['httpResponseCode']
+    assert_equal('404', code)
+  end
+
   #
   # Helpers
   #

data/test/new_relic/agent/rules_engine_test.rb

@@ -5,13 +5,9 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 
 class RulesEngineTest < Minitest::Test
-  def setup
-    @engine = NewRelic::Agent::RulesEngine.new
-  end
-
   def test_rule_defaults
-    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '.*',
-                                                  'replacement'      => '*')
+    rule = create_rule('match_expression' => '.*',
+                       'replacement'      => '*')
     assert !rule.terminate_chain
     assert !rule.each_segment
     assert !rule.ignore
@@ -20,84 +16,119 @@ class RulesEngineTest < Minitest::Test
   end
 
   def test_rule_applies_regex_rename
-    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
-                                                  'replacement'      => '*')
-    assert_equal(['foo/*/bar/22', true], rule.apply('foo/1/bar/22'))
+    rule = create_rule('match_expression' => '[0-9]+',
+                       'replacement'      => '*')
+
+    input = 'foo/1/bar/22'
+
+    refute(rule.terminal?)
+    assert(rule.matches?(input))
+    assert_equal('foo/*/bar/22', rule.apply(input))
   end
 
   def test_rules_can_apply_to_frozen_strings
-    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
-                                                  'replacement'      => '*')
-    assert_equal(['foo/*/bar/22', true], rule.apply('foo/1/bar/22'.freeze))
+    rule = create_rule('match_expression' => '[0-9]+',
+                       'replacement'      => '*')
+
+    input = 'foo/1/bar/22'.freeze
+
+    refute(rule.terminal?)
+    assert(rule.matches?(input))
+    assert_equal('foo/*/bar/22', rule.apply('foo/1/bar/22'.freeze))
   end
 
   def test_rule_applies_grouping_with_replacements
-    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '([0-9]+)',
-                                                  'replacement'      => '\\1\\1')
-    assert_equal(['foo/11/bar/22', true], rule.apply('foo/1/bar/22'))
+    rule = create_rule('match_expression' => '([0-9]+)',
+                       'replacement'      => '\\1\\1')
+
+    input = 'foo/1/bar/22'
+
+    refute(rule.terminal?)
+    assert(rule.matches?(input))
+    assert_equal('foo/11/bar/22', rule.apply('foo/1/bar/22'))
   end
 
   def test_rule_renames_all_matches_when_replace_all_is_true
-    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
-                                                  'replacement'      => '*',
-                                                  'replace_all'      => true)
-    assert_equal(['foo/*/bar/*', true], rule.apply('foo/1/bar/22'))
+    rule = create_rule('match_expression' => '[0-9]+',
+                       'replacement'      => '*',
+                       'replace_all'      => true)
+
+    refute(rule.terminal?)
+    assert(rule.matches?('foo/1/bar/22'))
+    assert_equal('foo/*/bar/*', rule.apply('foo/1/bar/22'))
   end
 
   def test_rule_with_no_match
-    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => 'QQ',
-                                                  'replacement'      => 'qq')
-    assert_equal(['foo/1/bar/22', false], rule.apply('foo/1/bar/22'))
+    rule = create_rule('match_expression' => 'QQ',
+                       'replacement'      => 'qq')
+
+    refute(rule.terminal?)
+    refute(rule.matches?('foo/1/bar/22'))
+    assert_equal('foo/1/bar/22', rule.apply('foo/1/bar/22'))
   end
 
   def test_applies_rules_in_order
-    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
-                                                  'replacement'      => '*',
-                                                  'replace_all'      => true,
-                                                  'eval_order'       => 0)
-    rerule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '\*',
-                                                    'replacement'      => 'x',
-                                                    'replace_all'      => true,
-                                                    'eval_order'       => 1)
-    @engine << rerule
-    @engine << rule
-
-    assert_equal('foo/x/bar/x', @engine.rename('foo/1/bar/22'))
+    rule = create_rule('match_expression' => '[0-9]+',
+                       'replacement'      => '*',
+                       'replace_all'      => true,
+                       'eval_order'       => 0)
+
+    rerule = create_rule('match_expression' => '\*',
+                         'replacement'      => 'x',
+                         'replace_all'      => true,
+                         'eval_order'       => 1)
+
+    engine = NewRelic::Agent::RulesEngine.new([rerule, rule])
+
+    assert_equal('foo/x/bar/x', engine.rename('foo/1/bar/22'))
   end
 
   def test_can_apply_rules_to_all_segments
-    rule = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+.*',
-                                                  'replacement'      => '*',
-                                                  'each_segment'     => true)
-    @engine << rule
+    rule = create_rule('match_expression' => '[0-9]+.*',
+                       'replacement'      => '*',
+                       'each_segment'     => true)
+
+    engine = NewRelic::Agent::RulesEngine.new([rule])
 
-    assert_equal('foo/*/bar/*', @engine.rename('foo/1a/bar/22b'))
+    assert_equal('foo/*/bar/*', engine.rename('foo/1a/bar/22b'))
   end
 
   def test_stops_after_terminate_chain
-    rule0 = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '[0-9]+',
-                                                   'replacement'      => '*',
-                                                   'each_segment'     => true,
-                                                   'eval_order'       => 0,
-                                                   'terminate_chain'  => true)
-    rule1 = NewRelic::Agent::RulesEngine::Rule.new('match_expression' => '.*',
-                                                   'replacement'      => 'X',
-                                                   'replace_all'      => true,
-                                                   'eval_order'       => 1)
-    @engine << rule0
-    @engine << rule1
-
-    assert_equal('foo/*/bar/*', @engine.rename('foo/1/bar/22'))
+    rule0 = create_rule('match_expression' => '[0-9]+',
+                        'replacement'      => '*',
+                        'each_segment'     => true,
+                        'eval_order'       => 0,
+                        'terminate_chain'  => true)
+
+    rule1 = create_rule('match_expression' => '.*',
+                        'replacement'      => 'X',
+                        'replace_all'      => true,
+                        'eval_order'       => 1)
+
+    engine = NewRelic::Agent::RulesEngine.new([rule0, rule1])
+
+    assert_equal('foo/*/bar/*', engine.rename('foo/1/bar/22'))
+  end
+
+  def create_rule(spec)
+    NewRelic::Agent::RulesEngine::ReplacementRule.new(spec)
   end
 
   load_cross_agent_test('rules').each do |testcase|
     define_method("test_#{testcase['testname']}") do
-      testcase["rules"].each do |rule|
-        @engine << NewRelic::Agent::RulesEngine::Rule.new(rule)
-      end
+      engine = NewRelic::Agent::RulesEngine.create_metric_rules('metric_name_rules' => testcase['rules'])
 
       testcase["tests"].each do |test|
-        assert_equal(test["expected"], @engine.rename(test["input"]), "Input: #{test['input'].inspect}")
+        assert_equal(test["expected"], engine.rename(test["input"]), "Input: #{test['input'].inspect}")
+      end
+    end
+  end
+
+  load_cross_agent_test('transaction_segment_terms').each do |testcase|
+    define_method("test_app_segment_terms_#{testcase['testname']}") do
+      engine = NewRelic::Agent::RulesEngine.create_transaction_rules(testcase)
+      testcase['tests'].each do |test|
+        assert_equal(test["expected"], engine.rename(test["input"]), "Input: #{test['input'].inspect}")
       end
     end
   end

data/test/new_relic/agent/sql_sampler_test.rb

@@ -71,7 +71,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     assert_equal('a' * 16_381 + '...', @sampler.tl_transaction_data.sql_data[0].sql)
   end
 
-  def test_harvest_slow_sql
+  def test_save_slow_sql
     data = NewRelic::Agent::TransactionSqlData.new
     data.set_transaction_info("/c/a", 'guid')
     data.set_transaction_name("WebTransaction/Controller/c/a")
@@ -80,7 +80,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
       NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2),
       NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)
     ]
-    @sampler.harvest_slow_sql data
+    @sampler.save_slow_sql data
 
     assert_equal 2, @sampler.sql_traces.size
   end
@@ -107,7 +107,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     data.sql_data.concat [NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.5),
                           NewRelic::Agent::SlowSql.new("select * from test", "Database/test/select", {}, 1.2),
                           NewRelic::Agent::SlowSql.new("select * from test2", "Database/test2/select", {}, 1.1)]
-    @sampler.harvest_slow_sql data
+    @sampler.save_slow_sql data
 
     sql_traces = @sampler.harvest!
     assert_equal 2, sql_traces.size
@@ -122,7 +122,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
                                                     "Database/test#{(i+97).chr}/select", {}, i)
     end
 
-    @sampler.harvest_slow_sql data
+    @sampler.save_slow_sql data
     result = @sampler.harvest!
 
     assert_equal(10, result.size)
@@ -139,7 +139,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
                NewRelic::Agent::SlowSql.new("select * from test2 where foo in (1,2)", "Database/test2/select", {}, 1.1)
               ]
     data.sql_data.concat(queries)
-    @sampler.harvest_slow_sql data
+    @sampler.save_slow_sql data
 
     sql_traces = @sampler.harvest!
     assert_equal 2, sql_traces.size
@@ -168,8 +168,9 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
                                             1.1, nil, &explainer)
               ]
     data.sql_data.concat(queries)
-    @sampler.harvest_slow_sql data
-    sql_traces = @sampler.harvest!
+    @sampler.save_slow_sql data
+    sql_traces = @sampler.harvest!.sort_by(&:total_call_time).reverse
+
     assert_equal(["header0", "header1", "header2"],
                  sql_traces[0].params[:explain_plan][0].sort)
     assert_equal(["header0", "header1", "header2"],
@@ -199,7 +200,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
                                               "Database/test/select", {}, 1.5)
                 ]
       data.sql_data.concat(queries)
-      @sampler.harvest_slow_sql data
+      @sampler.save_slow_sql data
       sql_traces = @sampler.harvest!
       assert_equal(nil, sql_traces[0].params[:explain_plan])
     end
@@ -244,8 +245,8 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
                                                          "Database/test/select", {}, 1.5),
                             NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2,3,4,5)",
                                                          "Database/test/select", {}, 1.2)])
-      @sampler.harvest_slow_sql(data)
-      sql_traces = @sampler.harvest!
+      @sampler.save_slow_sql(data)
+      sql_traces = @sampler.harvest!.sort_by(&:total_call_time).reverse
 
       assert_equal('select * from test where foo = ?', sql_traces[0].sql)
       assert_equal('select * from test where foo in (?,?,?,?,?)', sql_traces[1].sql)
@@ -265,14 +266,34 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
                                                          "Database/test/select", {}, 1.5),
                             NewRelic::Agent::SlowSql.new("select * from test where foo in (1,2,3,4,5)",
                                                          "Database/test/select", {}, 1.2)])
-      @sampler.harvest_slow_sql(data)
-      sql_traces = @sampler.harvest!
+      @sampler.save_slow_sql(data)
+      sql_traces = @sampler.harvest!.sort_by(&:total_call_time).reverse
 
       assert_equal('select * from test where foo = ?', sql_traces[0].sql)
       assert_equal('select * from test where foo in (?,?,?,?,?)', sql_traces[1].sql)
     end
   end
 
+  def test_takes_slowest_samples
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info("/c/a", 'guid')
+    data.set_transaction_name("WebTransaction/Controller/c/a")
+
+    count = NewRelic::Agent::SqlSampler::MAX_SAMPLES * 2
+    durations = (0...count).to_a.shuffle
+    durations.each do |i|
+      data.sql_data << NewRelic::Agent::SlowSql.new("SELECT * FROM table#{i}", "Database/table#{i}/select", {}, i)
+    end
+
+    @sampler.save_slow_sql(data)
+    sql_traces = @sampler.harvest!
+
+    harvested_durations = sql_traces.map(&:total_call_time).sort
+    expected_durations  = durations.sort.last(10)
+
+    assert_equal expected_durations, harvested_durations
+  end
+
   def test_can_directly_marshal_traces_for_pipe_transmittal
     with_config(:'transaction_tracer.explain_enabled' => false) do
       data = NewRelic::Agent::TransactionSqlData.new
@@ -280,7 +301,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
       data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test",
                                                          "Database/test/select",
                                                          {}, 1.5, &explainer)])
-      @sampler.harvest_slow_sql(data)
+      @sampler.save_slow_sql(data)
       sql_traces = @sampler.harvest!
 
       Marshal.dump(sql_traces)
@@ -295,7 +316,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
       data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test",
                                                          "Database/test/select",
                                                          {}, 1.5)])
-      @sampler.harvest_slow_sql(data)
+      @sampler.save_slow_sql(data)
       sql_traces = @sampler.harvest!
 
       if NewRelic::Agent::NewRelicService::JsonMarshaller.is_supported?
@@ -364,4 +385,19 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     state = NewRelic::Agent::TransactionState.tl_get
     @sampler.on_finishing_transaction(state, "whatever", Time.now)
   end
+
+  def test_caps_collection_of_unique_statements
+    data = NewRelic::Agent::TransactionSqlData.new
+    data.set_transaction_info("/c/a", 'guid')
+    data.set_transaction_name("WebTransaction/Controller/c/a")
+
+    count = NewRelic::Agent::SqlSampler::MAX_SAMPLES + 1
+    count.times do |i|
+      data.sql_data << NewRelic::Agent::SlowSql.new("SELECT * FROM table#{i}", "Database/table#{i}/select", {}, i)
+    end
+
+    @sampler.save_slow_sql(data)
+
+    assert_equal NewRelic::Agent::SqlSampler::MAX_SAMPLES, @sampler.sql_traces.size
+  end
 end

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

@@ -246,7 +246,7 @@ class NewRelic::Agent::MetricStatsTest < Minitest::Test
   end
 
   def test_harvest_applies_metric_rename_rules
-    rule = NewRelic::Agent::RulesEngine::Rule.new(
+    rule = NewRelic::Agent::RulesEngine::ReplacementRule.new(
       'match_expression' => '[0-9]+',
       'replacement'      => '*',
       'replace_all'      => true
@@ -268,7 +268,7 @@ class NewRelic::Agent::MetricStatsTest < Minitest::Test
   end
 
   def test_apply_rules_to_metric_data_respects_ignore_rules
-    rule = NewRelic::Agent::RulesEngine::Rule.new(
+    rule = NewRelic::Agent::RulesEngine::ReplacementRule.new(
       'match_expression' => 'bar',
       'ignore'           => 'true'
     )

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

@@ -33,7 +33,7 @@ class NewRelic::Agent::StatsEngine::SamplersTest < Minitest::Test
 
     freeze_time
     Process.stubs(:times).returns(timeinfo0, timeinfo1)
-    NewRelic::Agent::SystemInfo.stubs(:processor_count).returns(4)
+    NewRelic::Agent::SystemInfo.stubs(:num_logical_processors).returns(4)
 
     s = NewRelic::Agent::Samplers::CpuSampler.new # this calls poll
     advance_time(elapsed)

data/test/new_relic/agent/{stats_hash_test.rb → stats_engine/stats_hash_test.rb}

@@ -2,7 +2,7 @@
 # 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 File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..','test_helper'))
 
 class NewRelic::Agent::StatsHashTest < Minitest::Test
   def setup
@@ -184,45 +184,8 @@ class NewRelic::Agent::StatsHashTest < Minitest::Test
     end
   end
 
-  STAT_SETTERS = [:call_count=, :min_call_time=, :max_call_time=, :total_call_time=, :total_exclusive_time=, :sum_of_squares=]
   DEFAULT_SPEC = NewRelic::MetricSpec.new('foo')
 
-  STAT_SETTERS.each do |setter|
-    define_method("test_merge_allows_nil_destination_for_#{setter.to_s.gsub('=', '')}") do
-      dest = NewRelic::Agent::Stats.new
-      dest.send(setter, nil)
-      expected = dest.dup
-
-      @hash[DEFAULT_SPEC] = dest
-
-      incoming = NewRelic::Agent::StatsHash.new
-      incoming[DEFAULT_SPEC] = NewRelic::Agent::Stats.new
-
-      @hash.merge!(incoming)
-
-      assert_equal expected, @hash[DEFAULT_SPEC]
-      assert_has_error NewRelic::Agent::StatsHash::StatsMergerError
-    end
-  end
-
-  STAT_SETTERS.each do |setter|
-    define_method("test_merge_allows_nil_source_for_#{setter.to_s.gsub('=', '')}") do
-      dest = NewRelic::Agent::Stats.new
-      expected = dest.dup
-
-      @hash[DEFAULT_SPEC] = dest
-
-      source = NewRelic::Agent::Stats.new
-      source.send(setter, nil)
-      incoming = NewRelic::Agent::StatsHash.new
-      incoming[DEFAULT_SPEC] = source
-
-      @hash.merge!(incoming)
-
-      assert_equal expected, @hash[DEFAULT_SPEC]
-    end
-  end
-
   def fake_borked_default_proc(hash)
     exception = NoMethodError.new("borked default proc gives a NoMethodError on `yield'")
     if hash.respond_to?(:default_proc=)

data/test/new_relic/agent/system_info_test.rb

@@ -0,0 +1,45 @@
+# 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'))
+
+class NewRelic::Agent::SystemInfoTest < Minitest::Test
+
+  def setup
+    @sysinfo = ::NewRelic::Agent::SystemInfo
+    @sysinfo.clear_processor_info
+  end
+
+  test_dir = File.join(cross_agent_tests_dir, 'proc_cpuinfo')
+
+  Dir.chdir(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(test_dir, file)
+
+        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)
+
+          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}"
+      end
+    end
+  end
+
+end
+