newrelic_rpm 3.8.0.218 → 3.8.1.221

data/test/new_relic/agent/javascript_instrumentor_test.rb

@@ -168,7 +168,7 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
 
   def test_config_data_for_js_agent
     freeze_time
-    in_transaction do
+    in_transaction('most recent transaction') do
       with_config(CAPTURE_ATTRIBUTES => true) do
         NewRelic::Agent.set_user_attributes(:user => "user")
 
@@ -176,7 +176,6 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
         txn.stubs(:queue_time).returns(0)
         txn.stubs(:start_time).returns(Time.now - 10)
         txn.stubs(:guid).returns('ABC')
-        txn.name = 'most recent transaction'
 
         state = NewRelic::Agent::TransactionState.get
         state.request_token = '0123456789ABCDEF'

data/test/new_relic/agent/method_tracer/class_methods/add_method_tracer_test.rb

@@ -16,7 +16,7 @@ module NewRelic
 
             def test_validate_options_nonhash
               assert_raises(TypeError) do
-                validate_options([])
+                validate_options(:fluttershy, [])
               end
             end
 
@@ -24,14 +24,14 @@ module NewRelic
               self.expects(:check_for_illegal_keys!)
               self.expects(:set_deduct_call_time_based_on_metric).with(DEFAULT_SETTINGS)
               self.expects(:check_for_push_scope_and_metric)
-              validate_options({})
+              validate_options(:applejack, {})
             end
 
             def test_validate_options_override
               opts = {:push_scope => false, :metric => false, :force => true}
               self.expects(:check_for_illegal_keys!)
               self.expects(:check_for_push_scope_and_metric)
-              val = validate_options(opts)
+              val = validate_options(:pinkie_pie, opts)
               assert val.is_a?(Hash)
               assert (val[:push_scope] == false), val.inspect
               assert (val[:metric] == false), val.inspect
@@ -82,31 +82,25 @@ module NewRelic
               assert !val[:deduct_call_time_from_parent]
             end
 
-            def test_unrecognized_keys_positive
-              assert_equal [:unrecognized, :keys].to_set, unrecognized_keys([:hello, :world], {:unrecognized => nil, :keys => nil}).to_set
-            end
-
-            def test_unrecognized_keys_negative
-              assert_equal [], unrecognized_keys([:hello, :world], {:hello => nil, :world => nil})
-            end
-
-            def test_any_unrecognized_keys_positive
-              assert any_unrecognized_keys?([:one], {:one => nil, :two => nil})
-            end
-
-            def test_any_unrecognized_keys_negative
-              assert !any_unrecognized_keys?([:one], {:one => nil})
-            end
-
             def test_check_for_illegal_keys_positive
               assert_raises(RuntimeError) do
-                check_for_illegal_keys!({:unknown_key => nil})
+                check_for_illegal_keys!(:twilight_sparkle, {:unknown_key => nil})
               end
             end
 
             def test_check_for_illegal_keys_negative
               test_keys = Hash[*ALLOWED_KEYS.map {|x| [x, nil]}.flatten]
-              check_for_illegal_keys!(test_keys)
+              check_for_illegal_keys!(:rainbow_dash, test_keys)
+            end
+
+            def test_check_for_illegal_keys_deprecated
+              log = with_array_logger do
+                check_for_illegal_keys!(:rarity, :force => true)
+              end.array
+
+              assert_equal(1, log.size)
+
+              assert_match(/Deprecated options when adding method tracer to rarity: force/, log[0])
             end
 
             def test_traced_method_exists_positive
@@ -121,11 +115,6 @@ module NewRelic
               assert !traced_method_exists?(nil, nil)
             end
 
-            def test_assemble_code_header_forced
-              opts = {:force => true, :code_header => 'CODE HEADER'}
-              assert_equal "CODE HEADER", assemble_code_header('test_method', 'Custom/Test/test_method', opts)
-            end
-
             def test_assemble_code_header_unforced
               self.expects(:_untraced_method_name).returns("method_name_without_tracing")
               opts = {:force => false, :code_header => 'CODE HEADER'}

data/test/new_relic/agent/method_tracer/instance_methods/trace_execution_scoped_test.rb

@@ -11,24 +11,6 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
     NewRelic::Agent.agent.stats_engine.clear_stats
   end
 
-  def test_trace_disabled_negative
-    self.expects(:traced?).returns(false)
-    options = {:force => false}
-    assert trace_disabled?(options)
-  end
-
-  def test_trace_disabled_forced
-    self.expects(:traced?).returns(false)
-    options = {:force => true}
-    assert !(trace_disabled?(options))
-  end
-
-  def test_trace_disabled_positive
-    self.expects(:traced?).returns(true)
-    options = {:force => false}
-    assert !(trace_disabled?(options))
-  end
-
   def test_get_stats_unscoped
     fake_engine = mocked_object('stat_engine')
     fake_engine.expects(:get_stats_no_scope).with('foob').returns('fakestats')
@@ -64,29 +46,26 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
     )
   end
 
-  def test_metric_recording_in_root_transaction
-    options = { :transaction => true }
-    self.stubs(:has_parent?).returns(false)
-
+  def test_metric_recording_in_non_nested_transaction
     in_transaction('outer') do
-      trace_execution_scoped(['foo', 'bar'], options) do
+      trace_execution_scoped(['foo', 'bar']) do
         # erm
       end
     end
 
     expected_values = { :call_count => 1 }
     assert_metrics_recorded_exclusive(
-      'foo' => expected_values,
-      'bar' => expected_values
+      ['foo', 'outer'] => expected_values,
+      'foo'            => expected_values,
+      'bar'            => expected_values,
+      'outer'          => expected_values
     )
   end
 
-  def test_metric_recording_in_non_root_transaction
-    options = { :transaction => true }
-    self.stubs(:has_parent?).returns(true)
-    in_transaction('outer') do
-      in_transaction('inner') do
-        trace_execution_scoped(['inner', 'bar'], options) do
+  def test_metric_recording_in_nested_transactions
+    in_transaction('Controller/outer_txn') do
+      in_transaction('Controller/inner_txn') do
+        trace_execution_scoped(['foo', 'bar']) do
           # erm
         end
       end
@@ -94,42 +73,47 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
 
     expected_values = { :call_count => 1 }
     assert_metrics_recorded_exclusive(
-      'inner'            => expected_values,
-      ['inner', 'outer'] => expected_values,
-      'bar'              => expected_values
+      'HttpDispatcher'                                    => expected_values,
+      'Controller/inner_txn'                              => expected_values,
+
+      'Nested/Controller/inner_txn'                           => expected_values,
+      ['Nested/Controller/inner_txn', 'Controller/inner_txn'] => expected_values,
+      'Nested/Controller/outer_txn'                           => expected_values,
+      ['Nested/Controller/outer_txn', 'Controller/inner_txn'] => expected_values,
+
+      ['foo'                    , 'Controller/inner_txn'] => expected_values,
+      'foo'                                               => expected_values,
+      'bar'                                               => expected_values
     )
   end
 
-  def test_metric_recording_in_root_non_transaction
-    options = { :transaction => false }
-    self.stubs(:has_parent?).returns(false)
-
-    in_transaction('outer') do
-      trace_execution_scoped(['foo', 'bar'], options) do
-        # erm
+  def test_metric_recording_in_3_nested_transactions
+    in_transaction('Controller/outer_txn') do
+      in_transaction('Controller/middle_txn') do
+        in_transaction('Controller/inner_txn') do
+          # erm
+        end
       end
     end
 
-    expected_values = { :call_count => 1 }
-    assert_metrics_recorded_exclusive(
-      'foo'            => expected_values,
-      ['foo', 'outer'] => expected_values,
-      'bar'            => expected_values
-    )
+    assert_metrics_recorded([
+      'Controller/inner_txn',
+      'Nested/Controller/inner_txn',
+      'Nested/Controller/middle_txn',
+      'Nested/Controller/outer_txn'
+      ])
   end
 
-  def test_metric_recording_in_non_root_non_transaction
-    options = { :transaction => false }
-    self.stubs(:has_parent?).returns(false)
-
+  def test_metric_recording_inside_transaction
     in_transaction('outer') do
-      trace_execution_scoped(['foo', 'bar'], options) do
+      trace_execution_scoped(['foo', 'bar']) do
         # erm
       end
     end
 
     expected_values = { :call_count => 1 }
     assert_metrics_recorded_exclusive(
+      'outer'          => expected_values,
       'foo'            => expected_values,
       ['foo', 'outer'] => expected_values,
       'bar'            => expected_values
@@ -137,8 +121,7 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
   end
 
   def test_metric_recording_without_metric_option
-    options = { :metric => false, :transaction => true }
-    self.stubs(:has_parent?).returns(false)
+    options = { :metric => false, :scoped_metric => false }
 
     in_transaction('outer') do
       trace_execution_scoped(['foo', 'bar'], options) do
@@ -148,13 +131,13 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
 
     expected_values = { :call_count => 1 }
     assert_metrics_recorded_exclusive(
-      'bar' => expected_values
+      'outer' => expected_values,
+      'bar'   => expected_values
     )
   end
 
   def test_metric_recording_with_scoped_metric_only_option
-    options = { :transaction => false, :scoped_metric_only => true }
-    self.stubs(:has_parent?).returns(false)
+    options = { :scoped_metric_only => true }
 
     in_transaction('outer') do
       trace_execution_scoped(['foo', 'bar'], options) do
@@ -164,6 +147,7 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
 
     expected_values = { :call_count => 1 }
     assert_metrics_recorded_exclusive(
+      'outer'          => expected_values,
       ['foo', 'outer'] => expected_values
     )
   end
@@ -177,28 +161,6 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
     assert !h[:bar]
   end
 
-  def test_push_flag_true
-    fake_agent = mocked_object('agent_instance')
-    fake_agent.expects(:push_trace_execution_flag).with(true)
-    push_flag!(true)
-  end
-
-  def test_push_flag_false
-    self.expects(:agent_instance).never
-    push_flag!(false)
-  end
-
-  def test_pop_flag_true
-    fake_agent = mocked_object('agent_instance')
-    fake_agent.expects(:pop_trace_execution_flag)
-    pop_flag!(true)
-  end
-
-  def test_pop_flag_false
-    self.expects(:agent_instance).never
-    pop_flag!(false)
-  end
-
   def test_log_errors_base
     ran = false
     log_errors("name") do
@@ -231,9 +193,7 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
   def test_trace_execution_scoped_header
     options = {:force => false, :deduct_call_time_from_parent => false}
     self.expects(:log_errors).with('trace_execution_scoped header').yields
-    self.expects(:push_flag!).with(false)
-    fakestats = mocked_object('stat_engine')
-    fakestats.expects(:push_scope).with(:method_tracer, 1.0, false)
+    NewRelic::Agent::TracedMethodStack.expects(:push_frame).with(:method_tracer, 1.0, false)
     trace_execution_scoped_header(options, 1.0)
   end
 
@@ -249,31 +209,34 @@ class NewRelic::Agent::MethodTracer::TraceExecutionScopedTest < Minitest::Test
     end
 
     assert_metrics_recorded_exclusive(
-      'parent' => { :call_count => 1, :total_call_time => 20, :total_exclusive_time => 10 },
-      ['parent', 'txn'] => { :call_count => 1, :total_call_time => 20, :total_exclusive_time => 10 },
-      'child'  => { :call_count => 1, :total_call_time => 10, :total_exclusive_time => 10 },
-      ['child', 'txn']  => { :call_count => 1, :total_call_time => 10, :total_exclusive_time => 10 }
+      'txn'    => {
+        :call_count           =>  1,
+      },
+      'parent' => {
+        :call_count           =>  1,
+        :total_call_time      => 20,
+        :total_exclusive_time => 10,
+      },
+      ['parent', 'txn'] => {
+        :call_count           =>  1,
+        :total_call_time      => 20,
+        :total_exclusive_time => 10,
+      },
+      'child'  => {
+        :call_count           =>  1,
+        :total_call_time      => 10,
+        :total_exclusive_time => 10,
+      },
+      ['child', 'txn']  => {
+        :call_count           =>  1,
+        :total_call_time      => 10,
+        :total_exclusive_time => 10,
+      }
     )
   end
 
-  def test_force_flag_enables_metric_recording_in_ignored_transaction
-    NewRelic::Agent.instance.push_trace_execution_flag(false)
-    in_transaction('txn') do
-      trace_execution_scoped(['foo'], :force => true) do
-        # whatever, man
-      end
-    end
-
-    assert_metrics_recorded_exclusive(
-      'foo'          => { :call_count => 1 },
-      ['foo', 'txn'] => { :call_count => 1 }
-    )
-  ensure
-    NewRelic::Agent.instance.pop_trace_execution_flag()
-  end
-
   def test_trace_execution_scoped_disabled
-    self.expects(:trace_disabled?).returns(true)
+    self.expects(:traced?).returns(false)
     # make sure the method doesn't beyond the abort
     self.expects(:set_if_nil).never
     ran = false

data/test/new_relic/agent/method_tracer_test.rb

@@ -26,9 +26,9 @@ class Insider
       # sampler = NewRelic::Agent::TransactionSampler.new(NewRelic::Agent.instance)
       sampler = "<none>"
       begin
-        @stats_engine.transaction_sampler = sampler
         fail "This should not have worked."
-        rescue; end
+      rescue
+      end
     else
       thrower(level-1)
     end

data/test/new_relic/agent/mock_scope_listener.rb

@@ -11,17 +11,14 @@ class NewRelic::Agent::MockScopeListener
     @scopes = []
   end
 
-  def notice_first_scope_push(time)
+  def notice_push_frame(time)
   end
 
-  def notice_push_scope(time)
-  end
-
-  def notice_pop_scope(scope, time)
+  def notice_pop_frame(scope, time)
     @scopes << scope
   end
 
-  def notice_scope_empty(time)
+  def on_finishing_transaction(time)
   end
 
   def enabled?

data/test/new_relic/agent/pipe_channel_manager_test.rb

@@ -57,14 +57,14 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
 
     def test_listener_merges_transaction_traces
       sampler = NewRelic::Agent.agent.transaction_sampler
-      sample = run_sample_trace_on(sampler)
+      sample = run_sample_trace
       assert_equal(1, sampler.count)
 
       listener = start_listener_with_pipe(667)
       run_child(667) do
         NewRelic::Agent.after_fork
         with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
-          sample = run_sample_trace_on(sampler)
+          sample = run_sample_trace
           service = NewRelic::Agent::PipeService.new(667)
           service.transaction_sample_data(sampler.harvest!)
         end
@@ -172,9 +172,9 @@ class NewRelic::Agent::PipeChannelManagerTest < Minitest::Test
     end
 
     def create_sql_sample(sampler)
-      sampler.notice_first_scope_push(Time.now)
+      sampler.on_start_transaction(Time.now)
       sampler.notice_sql("SELECT * FROM table", "ActiveRecord/Widgets/find", nil, 100)
-      sampler.notice_scope_empty('noodles', Time.now)
+      sampler.on_finishing_transaction('noodles', Time.now)
     end
   end
 

data/test/new_relic/agent/rules_engine_test.rb

@@ -89,4 +89,17 @@ class RulesEngineTest < Minitest::Test
 
     assert_equal('foo/*/bar/*', @engine.rename('foo/1/bar/22'))
   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
+
+      testcase["tests"].each do |test|
+        assert_equal(test["expected"], @engine.rename(test["input"]), "Input: #{test['input'].inspect}")
+      end
+    end
+  end
+
 end

data/test/new_relic/agent/sql_sampler_test.rb

@@ -23,9 +23,9 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
 
   def populate_container(sampler, n)
     n.times do |i|
-      sampler.notice_first_scope_push nil
+      sampler.on_start_transaction nil
       sampler.notice_sql("SELECT * FROM test#{i}", "Database/test/select", nil, 1)
-      sampler.notice_scope_empty('txn')
+      sampler.on_finishing_transaction('txn')
     end
   end
 
@@ -33,11 +33,11 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
 
   # Tests
 
-  def test_notice_first_scope_push
+  def test_on_start_transaction
     assert_nil @sampler.transaction_data
-    @sampler.notice_first_scope_push nil
+    @sampler.on_start_transaction nil
     refute_nil @sampler.transaction_data
-    @sampler.notice_scope_empty('txn')
+    @sampler.on_finishing_transaction('txn')
     assert_nil @sampler.transaction_data
   end
 
@@ -47,7 +47,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
   end
 
   def test_notice_sql
-    @sampler.notice_first_scope_push nil
+    @sampler.on_start_transaction nil
     @sampler.notice_sql "select * from test", "Database/test/select", nil, 1.5
     @sampler.notice_sql "select * from test2", "Database/test2/select", nil, 1.3
     # this sql will not be captured
@@ -57,7 +57,7 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
   end
 
   def test_notice_sql_truncates_query
-    @sampler.notice_first_scope_push nil
+    @sampler.on_start_transaction nil
     message = 'a' * 17_000
     @sampler.notice_sql(message, "Database/test/select", nil, 1.5)
     assert_equal('a' * 16_381 + '...', @sampler.transaction_data.sql_data[0].sql)
@@ -174,10 +174,8 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
 
   def test_sql_trace_should_include_transaction_guid
     txn_sampler = NewRelic::Agent::TransactionSampler.new
-    NewRelic::Agent.instance.stats_engine.transaction_sampler = txn_sampler
     txn_sampler.start_builder(Time.now)
-    @sampler.create_transaction_data
-    @sampler.notice_transaction('a uri', {:some => :params})
+    @sampler.on_start_transaction(Time.now, 'a uri', {:some => :params})
 
     assert_equal(NewRelic::Agent.instance.transaction_sampler.builder.sample.guid,
                  NewRelic::Agent.instance.sql_sampler.transaction_data.guid)