newrelic_rpm 3.8.1.221 → 3.9.0.229

data/test/new_relic/transaction_sample/fake_segment_test.rb

@@ -6,12 +6,12 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'test_hel
 require 'new_relic/transaction_sample/fake_segment'
 class NewRelic::TransactionSample::FakeSegmentTest < Minitest::Test
   def test_fake_segment_creation
-    NewRelic::TransactionSample::FakeSegment.new(0.1, 'Custom/test/metric', nil)
+    NewRelic::TransactionSample::FakeSegment.new(0.1, 'Custom/test/metric')
   end
 
   def test_parent_segment
     # should be public in this class, but not in the parent class
-    s = NewRelic::TransactionSample::FakeSegment.new(0.1, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::FakeSegment.new(0.1, 'Custom/test/metric')
     s.parent_segment = 'foo'
     assert_equal('foo', s.instance_eval { @parent_segment } )
   end

data/test/new_relic/transaction_sample/segment_test.rb

@@ -7,13 +7,13 @@ require 'new_relic/transaction_sample/segment'
 class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   def test_segment_creation
     # basic smoke test
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     assert_equal NewRelic::TransactionSample::Segment, s.class
   end
 
   def test_readers
     t = Time.now
-    s = NewRelic::TransactionSample::Segment.new(t, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(t, 'Custom/test/metric')
     assert_equal(t, s.entry_timestamp)
     assert_equal(nil, s.exit_timestamp)
     assert_equal(nil, s.parent_segment)
@@ -22,14 +22,14 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_end_trace
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     t = Time.now
     s.end_trace(t)
     assert_equal(t, s.exit_timestamp)
   end
 
   def test_add_called_segment
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     assert_equal [], s.called_segments
     fake_segment = mock('segment')
     fake_segment.expects(:parent_segment=).with(s)
@@ -38,15 +38,15 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_to_s
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     s.expects(:to_debug_str).with(0)
     s.to_s
   end
 
   def test_to_array
-    parent = NewRelic::TransactionSample::Segment.new(1, 'Custom/test/parent', 1)
+    parent = NewRelic::TransactionSample::Segment.new(1, 'Custom/test/parent')
     parent.params[:test] = 'value'
-    child = NewRelic::TransactionSample::Segment.new(2, 'Custom/test/child', 2)
+    child = NewRelic::TransactionSample::Segment.new(2, 'Custom/test/child')
     child.end_trace(3)
     parent.add_called_segment(child)
     parent.end_trace(4)
@@ -56,7 +56,7 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_to_array_with_bad_values
-    segment = NewRelic::TransactionSample::Segment.new(nil, nil, nil)
+    segment = NewRelic::TransactionSample::Segment.new(nil, nil)
     segment.end_trace(Rational(10, 1))
     expected = [0, 10_000.0, "<unknown>", {}, []]
     assert_equal(expected, segment.to_array)
@@ -64,9 +64,9 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
 
   if RUBY_VERSION >= '1.9.2'
     def test_to_json
-      parent = NewRelic::TransactionSample::Segment.new(1, 'Custom/test/parent', 1)
+      parent = NewRelic::TransactionSample::Segment.new(1, 'Custom/test/parent')
       parent.params[:test] = 'value'
-      child = NewRelic::TransactionSample::Segment.new(2, 'Custom/test/child', 2)
+      child = NewRelic::TransactionSample::Segment.new(2, 'Custom/test/child')
       child.end_trace(3)
       parent.add_called_segment(child)
       parent.end_trace(4)
@@ -76,7 +76,7 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_path_string
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     assert_equal("Custom/test/metric[]", s.path_string)
 
     fake_segment = mock('segment')
@@ -89,7 +89,7 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_to_s_compact
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     assert_equal("Custom/test/metric", s.to_s_compact)
 
     fake_segment = mock('segment')
@@ -101,31 +101,31 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_to_debug_str_basic
-    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric')
     assert_equal(">>   0 ms [Segment] Custom/test/metric \n<<  n/a Custom/test/metric\n", s.to_debug_str(0))
   end
 
   def test_to_debug_str_with_params
-    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric')
     s.params = {:whee => 'a param'}
     assert_equal(">>   0 ms [Segment] Custom/test/metric \n    -whee            : a param\n<<  n/a Custom/test/metric\n", s.to_debug_str(0))
   end
 
   def test_to_debug_str_closed
-    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric')
     s.end_trace(0.1)
     assert_equal(">>   0 ms [Segment] Custom/test/metric \n<< 100 ms Custom/test/metric\n", s.to_debug_str(0))
   end
 
   def test_to_debug_str_closed_with_nonnumeric
-    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric')
     s.end_trace("0.1")
     assert_equal(">>   0 ms [Segment] Custom/test/metric \n<< 0.1 Custom/test/metric\n", s.to_debug_str(0))
   end
 
   def test_to_debug_str_one_child
-    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
-    s.add_called_segment(NewRelic::TransactionSample::Segment.new(0.1, 'Custom/test/other', nil))
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric')
+    s.add_called_segment(NewRelic::TransactionSample::Segment.new(0.1, 'Custom/test/other'))
     assert_equal(">>   0 ms [Segment] Custom/test/metric \n  >> 100 ms [Segment] Custom/test/other \n  <<  n/a Custom/test/other\n<<  n/a Custom/test/metric\n", s.to_debug_str(0))
     # try closing it
     s.called_segments.first.end_trace(0.15)
@@ -134,9 +134,9 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_to_debug_str_multichild
-    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
-    s.add_called_segment(NewRelic::TransactionSample::Segment.new(0.1, 'Custom/test/other', nil))
-    s.add_called_segment(NewRelic::TransactionSample::Segment.new(0.11, 'Custom/test/extra', nil))
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric')
+    s.add_called_segment(NewRelic::TransactionSample::Segment.new(0.1, 'Custom/test/other'))
+    s.add_called_segment(NewRelic::TransactionSample::Segment.new(0.11, 'Custom/test/extra'))
     assert_equal(">>   0 ms [Segment] Custom/test/metric \n  >> 100 ms [Segment] Custom/test/other \n  <<  n/a Custom/test/other\n  >> 110 ms [Segment] Custom/test/extra \n  <<  n/a Custom/test/extra\n<<  n/a Custom/test/metric\n", s.to_debug_str(0))
     ending = 0.12
     s.called_segments.each { |x| x.end_trace(ending += 0.01) }
@@ -145,9 +145,9 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_to_debug_str_nested
-    inner = NewRelic::TransactionSample::Segment.new(0.2, 'Custom/test/inner', nil)
-    middle = NewRelic::TransactionSample::Segment.new(0.1, 'Custom/test/middle', nil)
-    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric', nil)
+    inner = NewRelic::TransactionSample::Segment.new(0.2, 'Custom/test/inner')
+    middle = NewRelic::TransactionSample::Segment.new(0.1, 'Custom/test/middle')
+    s = NewRelic::TransactionSample::Segment.new(0.0, 'Custom/test/metric')
     middle.add_called_segment(inner)
     s.add_called_segment(middle)
     assert_equal(">>   0 ms [Segment] Custom/test/metric \n  >> 100 ms [Segment] Custom/test/middle \n    >> 200 ms [Segment] Custom/test/inner \n    <<  n/a Custom/test/inner\n  <<  n/a Custom/test/middle\n<<  n/a Custom/test/metric\n", s.to_debug_str(0))
@@ -160,12 +160,12 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_called_segments_default
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     assert_equal([], s.called_segments)
   end
 
   def test_called_segments_with_segments
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     fake_segment = mock('segment')
     fake_segment.expects(:parent_segment=).with(s)
     s.add_called_segment(fake_segment)
@@ -180,19 +180,19 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
     fake_exit_timestamp.expects(:-).with(fake_entry_timestamp).returns(fake_result)
     fake_result.expects(:to_f).returns(0.5)
 
-    s = NewRelic::TransactionSample::Segment.new(fake_entry_timestamp, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(fake_entry_timestamp, 'Custom/test/metric')
     s.end_trace(fake_exit_timestamp)
     assert_equal(0.5, s.duration)
   end
 
   def test_exclusive_duration_no_children
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     s.expects(:duration).returns(0.5)
     assert_equal(0.5, s.exclusive_duration)
   end
 
   def test_exclusive_duration_with_children
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
 
     s.expects(:duration).returns(0.5)
 
@@ -206,12 +206,12 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_count_segments_default
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     assert_equal(1, s.count_segments)
   end
 
   def test_count_segments_with_children
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
 
     fake_segment = mock('segment')
     fake_segment.expects(:parent_segment=).with(s)
@@ -223,7 +223,7 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_key_equals
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     # doing this to hold the reference to the hash
     params = {}
     s.params = params
@@ -236,13 +236,13 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_key
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     s.params = {:foo => 'correct'}
     assert_equal('correct', s[:foo])
   end
 
   def test_params
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
 
     # should have a default value
     assert_equal(nil, s.instance_eval { @params })
@@ -254,7 +254,7 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_each_segment_default
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     # in the base case it just yields the block to itself
     count = 0
     s.each_segment do |x|
@@ -266,7 +266,7 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_each_segment_with_children
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
 
     fake_segment = mock('segment')
     fake_segment.expects(:parent_segment=).with(s)
@@ -283,7 +283,7 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_each_segment_with_nest_tracking
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
 
     summary = mock('summary')
     summary.expects(:current_nest_count).twice.returns(0).then.returns(1)
@@ -294,26 +294,26 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_find_segment_default
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     id_to_find = s.segment_id
     # should return itself in the base case
     assert_equal(s, s.find_segment(id_to_find))
   end
 
   def test_find_segment_not_found
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     assert_equal(nil, s.find_segment(-1))
   end
 
   def test_find_segment_with_children
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     id_to_find = s.segment_id
     # should return itself in the base case
     assert_equal(s, s.find_segment(id_to_find))
   end
 
   def test_explain_sql_raising_an_error
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     config = { :adapter => 'mysql' }
     statement = NewRelic::Agent::Database::Statement.new('SELECT')
     statement.config = config
@@ -326,13 +326,13 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
 
   def test_explain_sql_can_handle_missing_config
     # If TT segment came over from Resque child, might not be a Statement
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     s.params = { :sql => "SELECT * FROM galaxy" }
     s.explain_sql
   end
 
   def test_explain_sql_can_use_already_existing_plan
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     s.params = {
       :sql => "SELECT * FROM galaxy",
       :explain_plan => "EXPLAIN IT!"
@@ -342,7 +342,7 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
   end
 
   def test_params_equal
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     assert_equal(nil, s.instance_eval { @params })
 
     params = {:foo => 'correct'}
@@ -353,20 +353,20 @@ class NewRelic::TransactionSample::SegmentTest < Minitest::Test
 
   def test_obfuscated_sql
     sql = 'select * from table where id = 1'
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     s[:sql] = sql
     assert_equal('select * from table where id = ?', s.obfuscated_sql)
   end
 
   def test_called_segments_equals
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     assert_equal(nil, s.instance_eval { @called_segments })
     s.called_segments = [1, 2, 3]
     assert_equal([1, 2, 3], s.instance_eval { @called_segments })
   end
 
   def test_parent_segment_equals
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric')
     assert_equal(nil, s.instance_eval { @parent_segment })
     fake_segment = mock('segment')
     s.send(:parent_segment=, fake_segment)

data/test/new_relic/transaction_sample_test.rb

@@ -11,7 +11,7 @@ class NewRelic::TransactionSampleTest < Minitest::Test
 
   def setup
     @test_config = { :developer_mode => true }
-    NewRelic::Agent.config.apply_config(@test_config)
+    NewRelic::Agent.config.add_config_for_testing(@test_config)
 
     NewRelic::Agent.agent.transaction_sampler.reset!
 
@@ -221,13 +221,14 @@ class NewRelic::TransactionSampleTest < Minitest::Test
 
   def test_count_segments
     transaction = run_sample_trace do |sampler|
-      sampler.notice_push_frame "level0"
-      sampler.notice_push_frame "level-1"
-      sampler.notice_push_frame "level-2"
-      sampler.notice_sql(::SQL_STATEMENT, {}, 0)
-      sampler.notice_pop_frame "level-2"
-      sampler.notice_pop_frame "level-1"
-      sampler.notice_pop_frame "level0"
+      state = NewRelic::Agent::TransactionState.tl_get
+      sampler.notice_push_frame(state, "level0")
+      sampler.notice_push_frame(state, "level-1")
+      sampler.notice_push_frame(state, "level-2")
+      sampler.notice_sql(::SQL_STATEMENT, {}, 0, state)
+      sampler.notice_pop_frame(state, "level-2")
+      sampler.notice_pop_frame(state, "level-1")
+      sampler.notice_pop_frame(state, "level0")
     end
 
     assert_equal 6, transaction.count_segments

data/test/performance/lib/performance/instrumentation/stackprof.rb

@@ -13,20 +13,23 @@ module Performance
       end
 
       def before(test, test_name)
-        @profile_dir = Dir.mktmpdir('stackprof-profile')
-        @profile_path = File.join(@profile_dir, "profile.dump")
-        StackProf.start
+        StackProf.start(:mode => :wall)
       end
 
       def after(test, test_name)
         StackProf.stop
-        report = StackProf::Report.new(StackProf.results)
-        output_profile_path = artifact_path(test, test_name, "dot")
-        File.open(output_profile_path, "w") do |f|
+
+        output_dump_path = artifact_path(test, test_name, "dump")
+        StackProf.results(output_dump_path)
+        @artifacts << output_dump_path
+
+        results = Marshal.load(File.read(output_dump_path))
+        output_dot_path = artifact_path(test, test_name, "dot")
+        report = StackProf::Report.new(results)
+        File.open(output_dot_path, "w") do |f|
           report.print_graphviz(nil, f)
         end
-        @artifacts << output_profile_path
-        FileUtils.remove_entry_secure(@profile_dir)
+        @artifacts << output_dot_path
       end
     end
   end

data/test/performance/script/runner

@@ -22,6 +22,19 @@ parser = OptionParser.new do |opts|
   opts.on("-i", "--instrumentor=NAME", "Use the named instrumentor") do |name|
     options[:instrumentors] = [name]
   end
+  opts.on("-P", "--profile", "Do profiling around each test") do
+    best_profiling_instrumentor = [
+      Performance::Instrumentation::StackProfProfile,
+      Performance::Instrumentation::PerfToolsProfile
+    ].find(&:supported?)
+
+    if best_profiling_instrumentor
+      options[:inline] = true
+      options[:instrumentors] = [best_profiling_instrumentor.to_s]
+    else
+      Performance.logger.warn("Could not find a supported instrumentor for profiling.")
+    end
+  end
   opts.on("-s", "--suite=NAME", "Filter to just run a single test suite") do |name|
     options[:suite] = name
   end

data/test/performance/suites/config.rb

@@ -5,7 +5,7 @@
 class ConfigPerfTests < Performance::TestCase
   def setup
     @config = NewRelic::Agent::Configuration::Manager.new
-    @config.apply_config(:my_value => "boo")
+    @config.add_config_for_testing(:my_value => "boo")
   end
 
   def test_raw_access
@@ -67,9 +67,12 @@ class ConfigPerfTests < Performance::TestCase
 
 
   def with_deep_config_stack
+    # NOTE: As we have changed the way configs work, this example no longer
+    #       simulates production code. It would be impossible to have more than
+    #       5 levels on the config stack now.
     keys = (0..100).map {|i| "my_value_#{i}".to_sym}
     keys.each do |key|
-      @config.apply_config(key => key)
+      @config.add_config_for_testing(key => key)
     end
     keys
   end