newrelic_rpm 3.9.0.229 → 3.9.1.236

data/test/new_relic/agent/hostname_test.rb

@@ -7,7 +7,7 @@ require 'new_relic/agent/hostname'
 
 module NewRelic
   module Agent
-    class HostnameTest < MiniTest::Unit::TestCase
+    class HostnameTest < Minitest::Test
       def test_get_returns_socket_hostname
         Socket.stubs(:gethostname).returns('Rivendell')
         assert_equal 'Rivendell', NewRelic::Agent::Hostname.get

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

@@ -219,4 +219,26 @@ class NewRelic::Agent::Instrumentation::ControllerInstrumentationTest < Minitest
     host.doit
     assert host.params_called
   end
+
+  class UserError < StandardError
+  end
+
+  def test_failure_during_starting_shouldnt_override_error_raised
+    host_class = Class.new do
+      include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+
+      def doit
+        perform_action_with_newrelic_trace do
+          raise UserError.new
+        end
+      end
+    end
+
+    NewRelic::Agent::Transaction.stubs(:start).returns(nil)
+
+    host = host_class.new
+    assert_raises(UserError) do
+      host.doit
+    end
+  end
 end

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

@@ -0,0 +1,37 @@
+# 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/middleware_tracing'
+
+class NewRelic::Agent::Instrumentation::MiddlewareTracingTest < Minitest::Test
+  class UserError < StandardError
+  end
+
+  def test_dont_block_errors_during_malfunctioning_transaction
+    middleware_class = Class.new do
+      include NewRelic::Agent::Instrumentation::MiddlewareTracing
+
+      attr_reader :category
+
+      def target
+        self
+      end
+
+      def transaction_options
+        {}
+      end
+
+      def traced_call(env)
+        raise UserError.new
+      end
+    end
+
+    NewRelic::Agent::Transaction.stubs(:start).returns(nil)
+
+    assert_raises(UserError) do
+      middleware_class.new.call({})
+    end
+  end
+end

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

@@ -24,9 +24,11 @@ class NewRelic::Agent::Instrumentation::NetInstrumentationTest < Minitest::Test
   def test_scope_stack_integrity_maintained_on_request_failure
     @socket.stubs(:write).raises('fake network error')
     with_config(:"cross_application_tracer.enabled" => true) do
-      expected = NewRelic::Agent::TracedMethodStack.tl_push_frame('dummy')
+      state    = NewRelic::Agent::TransactionState.tl_get
+      stack    = state.traced_method_stack
+      expected = stack.push_frame(state, 'dummy')
       Net::HTTP.get(URI.parse('http://www.google.com/index.html')) rescue nil
-      NewRelic::Agent::TracedMethodStack.tl_pop_frame(expected, 42, Time.now.to_f)
+      stack.pop_frame(state, expected, 42, Time.now.to_f)
     end
   end
 

data/test/new_relic/agent/javascript_instrumentor_test.rb

@@ -274,6 +274,48 @@ class NewRelic::Agent::JavascriptInstrumentorTest < Minitest::Test
     assert_equal(string, instrumentor.html_safe_if_needed(string))
   end
 
+  def test_request_guid_to_include
+    state = NewRelic::Agent::TransactionState.tl_get
+    with_config(:apdex_t => 2.0) do
+      freeze_time
+      in_transaction do |txn|
+        state.request_token = "token"
+        advance_time(4.0)
+
+        data = instrumentor.data_for_js_agent(state)
+        assert_equal(state.current_transaction.guid, data['ttGuid'])
+      end
+    end
+  end
+
+  def test_request_guid_excluded_if_request_fast_enough
+    state = NewRelic::Agent::TransactionState.tl_get
+    with_config(:apdex_t => 2.0) do
+      freeze_time
+
+      state.request_token = "token"
+      in_transaction do |txn|
+        advance_time(1.0)
+        data = instrumentor.data_for_js_agent(state)
+        assert_nil(data['ttGuid'])
+      end
+    end
+  end
+
+  def test_request_guid_excluded_if_no_token
+    state = NewRelic::Agent::TransactionState.tl_get
+    with_config(:apdex_t => 2.0) do
+      freeze_time
+
+      state.request_token = nil
+      in_transaction do |txn|
+        advance_time(4.0)
+        data = instrumentor.data_for_js_agent(state)
+        assert_nil(data['ttGuid'])
+      end
+    end
+  end
+
   # Helpers
 
   BEGINNING_OF_FOOTER = '<script type="text/javascript">window.NREUM||(NREUM={});NREUM.info='

data/test/new_relic/agent/memcache_instrumentation_test.rb

@@ -75,10 +75,12 @@ if memcached_ready
     def test_reads__web
       commands = ['get']
       commands << 'get_multi' unless MEMCACHED_CLASS.name == 'Spymemcached'
-      commands.each do |method|
+      expected_metrics = commands
+      expected_metrics = ['single_get', 'multi_get'] if MEMCACHED_CLASS.name == 'Memcached' && Memcached::VERSION >= '1.8.0'
+      commands.zip(expected_metrics) do |method, metric|
         if @cache.class.method_defined?(method)
           _call_test_method_in_web_transaction(method)
-          compare_metrics ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"],
+          compare_metrics ["Memcache/#{metric}", "Memcache/allWeb", "Memcache/#{metric}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"],
           @engine.metrics.select{|m| m =~ /^memcache.*/i}
         end
       end
@@ -106,10 +108,12 @@ if memcached_ready
     def test_reads__background
       commands = ['get']
       commands << 'get_multi' unless MEMCACHED_CLASS.name == 'Spymemcached'
-      commands.each do |method|
+      expected_metrics = commands
+      expected_metrics = ['single_get', 'multi_get'] if MEMCACHED_CLASS.name == 'Memcached' && Memcached::VERSION >= '1.8.0'
+      commands.zip(expected_metrics) do |method, metric|
         if @cache.class.method_defined?(method)
           _call_test_method_in_background_task(method)
-          compare_metrics ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"],
+          compare_metrics ["Memcache/#{metric}", "Memcache/allOther", "Memcache/#{metric}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"],
           @engine.metrics.select{|m| m =~ /^memcache.*/i}
         end
       end
@@ -135,7 +139,9 @@ if memcached_ready
     end
 
     def test_handles_cas
-      expected_metrics = ["Memcache/cas", "Memcache/allOther", "Memcache/cas:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+      expected_metrics = ["cas"]
+      expected_metrics = ["single_get", "single_cas"] if MEMCACHED_CLASS.name == 'Memcached' && Memcached::VERSION >= '1.8.0'
+      expected_metrics = ["Memcache/allOther"] + expected_metrics.flat_map {|m| ["Memcache/#{m}", "Memcache/#{m}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"] }
       if @cache.class.method_defined?(:cas)
         @engine.clear_stats
         perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do

data/test/new_relic/agent/request_sampler_test.rb

@@ -128,6 +128,15 @@ class NewRelic::Agent::RequestSamplerTest < Minitest::Test
     end
   end
 
+  def test_samples_on_transaction_finished_event_include_apdex_perf_zone
+    with_sampler_config do
+      generate_request('name', :apdex_perf_zone => 'S')
+
+      event_data = single_sample[EVENT_DATA_INDEX]
+      assert_equal 'S', event_data['nr.apdexPerfZone']
+    end
+  end
+
   def test_samples_on_transaction_finished_event_includes_guid
     with_sampler_config do
       generate_request('name', :guid => "GUID")

data/test/new_relic/agent/sql_sampler_test.rb

@@ -205,6 +205,26 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     end
   end
 
+  def test_should_not_collect_anything_when_record_sql_is_off
+    sampler = NewRelic::Agent.agent.sql_sampler
+
+    settings = {
+      :'slow_sql.enabled'    => true,
+      :'slow_sql.record_sql' => 'off'
+    }
+
+    with_config(settings) do
+      in_transaction do
+        sql = "SELECT * FROM test"
+        metric_name = "Database/test/select"
+        sampler.notice_sql(sql, metric_name, {}, 10)
+      end
+    end
+
+    traces = sampler.harvest!
+    assert_empty(traces)
+  end
+
   def test_sql_id_fits_in_a_mysql_int_11
     sql_trace = NewRelic::Agent::SqlTrace.new("select * from test",
             NewRelic::Agent::SlowSql.new("select * from test",
@@ -232,6 +252,27 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     end
   end
 
+  def test_sends_obfuscated_queries_when_configured_via_slow_sql_settings
+    settings = {
+      :'slow_sql.record_sql'           => 'obfuscated',
+      :'transaction_tracer.record_sql' => 'raw'
+    }
+    with_config(settings) do
+      data = NewRelic::Agent::TransactionSqlData.new
+      data.set_transaction_info("/c/a", 'guid')
+      data.set_transaction_name("WebTransaction/Controller/c/a")
+      data.sql_data.concat([NewRelic::Agent::SlowSql.new("select * from test where foo = 'bar'",
+                                                         "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!
+
+      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_can_directly_marshal_traces_for_pipe_transmittal
     with_config(:'transaction_tracer.explain_enabled' => false) do
       data = NewRelic::Agent::TransactionSqlData.new
@@ -316,4 +357,9 @@ class NewRelic::Agent::SqlSamplerTest < Minitest::Test
     assert_equal(2, aggregated_trace.call_count)
     assert_equal(3, aggregated_trace.total_call_time)
   end
+
+  def test_on_finishing_transaction_with_busted_transaction_state_does_not_crash
+    state = NewRelic::Agent::TransactionState.tl_get
+    @sampler.on_finishing_transaction(state, "whatever", Time.now)
+  end
 end

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

@@ -14,6 +14,7 @@ class NewRelic::Agent::StatsEngine
     end
 
     def teardown
+      NewRelic::Agent.drop_buffered_data
       GCProfiler.reset
     end
 

data/test/new_relic/agent/transaction_sampler_test.rb

@@ -36,8 +36,13 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
     NewRelic::Agent.instance.instance_variable_set(:@transaction_sampler, @sampler)
     @test_config = { :'transaction_tracer.enabled' => true }
     NewRelic::Agent.config.add_config_for_testing(@test_config)
-    @txn = stub('txn', :best_name => '/path', :guid => 'a guid',
-                :custom_parameters => {}, :filtered_params => {})
+    @txn = stub('txn',
+                :best_name => '/path',
+                :guid => 'a guid',
+                :custom_parameters => {},
+                :cat_trip_id => '',
+                :cat_path_hash => '',
+                :filtered_params => {} )
   end
 
   def teardown
@@ -779,11 +784,61 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
         NewRelic::Agent.add_custom_parameters(:foo => 'bar')
       end
     end
-    sample = NewRelic::Agent.agent.transaction_sampler.harvest![0]
-    custom_params = sample.params[:custom_params]
+    custom_params = custom_params_from_last_sample
     assert_includes custom_params.keys, :foo
   end
 
+  def test_custom_params_include_gc_time
+    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      in_transaction do
+        NewRelic::Agent::StatsEngine::GCProfiler.stubs(:record_delta).returns(10.0)
+      end
+    end
+
+    assert_equal 10.0, custom_params_from_last_sample[:gc_time]
+  end
+
+  def test_custom_params_include_tripid
+    guid = nil
+
+    NewRelic::Agent.instance.cross_app_monitor.stubs(:client_referring_transaction_trip_id).returns('PDX-NRT')
+
+    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      in_transaction do |transaction|
+        NewRelic::Agent::TransactionState.tl_get.is_cross_app_caller = true
+        guid = transaction.guid
+      end
+    end
+
+    assert_equal 'PDX-NRT', custom_params_from_last_sample[:'nr.trip_id']
+  end
+
+  def test_custom_params_dont_include_tripid_if_not_cross_app_transaction
+    NewRelic::Agent.instance.cross_app_monitor.stubs(:client_referring_transaction_trip_id).returns('PDX-NRT')
+
+    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      in_transaction do |transaction|
+        NewRelic::Agent::TransactionState.tl_get.is_cross_app_caller = false
+      end
+    end
+
+    assert_nil custom_params_from_last_sample[:'nr.trip_id']
+  end
+
+  def test_custom_params_include_path_hash
+    path_hash = nil
+
+    with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      in_transaction do |transaction|
+        state = NewRelic::Agent::TransactionState.tl_get
+        state.is_cross_app_caller = true
+        path_hash = transaction.cat_path_hash(state)
+      end
+    end
+
+    assert_equal path_hash, custom_params_from_last_sample[:'nr.path_hash']
+  end
+
   class Dummy
     include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
     def run(n)
@@ -873,4 +928,9 @@ class NewRelic::Agent::TransactionSamplerTest < Minitest::Test
     @sampler.notice_pop_frame(state, "a")
     @sampler.on_finishing_transaction(state, @txn, (stop || Time.now.to_f))
   end
+
+  def custom_params_from_last_sample
+    sample = NewRelic::Agent.agent.transaction_sampler.harvest!.first
+    sample.params[:custom_params]
+  end
 end

data/test/new_relic/agent/transaction_state_test.rb

@@ -61,81 +61,6 @@ module NewRelic::Agent
       end
     end
 
-    GUID = "goo-id"
-
-    def test_request_guid_to_include
-      with_config(:apdex_t => 2.0) do
-        freeze_time
-        in_transaction do |txn|
-          state.request_token = "token"
-          advance_time(4.0)
-          assert_equal state.current_transaction.guid, state.request_guid_to_include
-        end
-      end
-    end
-
-    def test_requst_guid_excluded_if_request_fast_enough
-      with_config(:apdex_t => 2.0) do
-        freeze_time
-
-        state.request_token = "token"
-        in_transaction do |txn|
-          advance_time(1.0)
-          assert_equal "", state.request_guid_to_include
-        end
-      end
-    end
-
-    def test_request_guid_excluded_if_no_token
-      with_config(:apdex_t => 2.0) do
-        freeze_time
-
-        state.request_token = nil
-        in_transaction do |txn|
-          advance_time(4.0)
-          assert_equal "", state.request_guid_to_include
-        end
-      end
-    end
-
-    def test_no_request_guid_for_event
-      state.request_token = nil
-      state.is_cross_app_caller = false
-      state.referring_transaction_info = nil
-      in_transaction do
-        assert_nil state.request_guid_for_event
-      end
-    end
-
-    def test_request_guid_for_event
-      in_transaction do
-        state.request_token = nil
-        state.is_cross_app_caller = true
-        state.referring_transaction_info = nil
-        assert_equal state.current_transaction.guid, state.request_guid_for_event
-      end
-    end
-
-    def test_request_guid_for_event_if_referring_transaction
-      in_transaction do
-        state.request_token = nil
-        state.is_cross_app_caller = false
-        state.referring_transaction_info = ["another"]
-        assert_equal state.current_transaction.guid, state.request_guid_for_event
-      end
-    end
-
-    def test_request_guid_for_event_if_there_for_rum
-      with_config(:apdex_t => 2.0) do
-        in_transaction do
-          state.request_token = "token"
-          state.is_cross_app_caller = false
-          advance_time(10.0)
-          assert_equal state.current_transaction.guid, state.request_guid_for_event
-        end
-      end
-    end
-
     def test_reset_should_reset_cat_state
       state.is_cross_app_caller = true
       state.referring_transaction_info = ['foo', 'bar']

data/test/new_relic/agent/transaction_test.rb

@@ -338,6 +338,40 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
     refute found_guid
   end
 
+  def test_end_fires_a_transaction_finished_event_with_guid_if_request_token_and_too_long
+    guid = nil
+    NewRelic::Agent.subscribe(:transaction_finished) do |payload|
+      guid = payload[:guid]
+    end
+
+    with_config(:apdex_t => 2.0) do
+      freeze_time
+      in_transaction do
+        state = NewRelic::Agent::TransactionState.tl_get
+        state.request_token = 'token'
+        advance_time 4.0
+      end
+    end
+
+    refute_empty guid
+  end
+
+  def test_end_fires_a_transaction_finished_event_with_guid_if_referring_transaction
+    guid = nil
+    NewRelic::Agent.subscribe(:transaction_finished) do |payload|
+      guid = payload[:guid]
+    end
+
+    with_config(:apdex_t => 2.0) do
+      in_transaction do
+        state = NewRelic::Agent::TransactionState.tl_get
+        state.referring_transaction_info = ["another"]
+      end
+    end
+
+    refute_empty guid
+  end
+
   def test_end_fires_a_transaction_finished_event_with_referring_transaction_guid
     referring_guid = nil
     NewRelic::Agent.subscribe(:transaction_finished) do |payload|
@@ -365,6 +399,74 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
     refute found_referring_guid
   end
 
+  def test_end_fires_a_transaction_finished_event_with_apdex_perf_zone
+    apdex = nil
+    NewRelic::Agent.subscribe(:transaction_finished) do |payload|
+      apdex = payload[:apdex_perf_zone]
+    end
+
+    freeze_time
+
+    with_config(:apdex_t => 1.0) do
+      in_web_transaction { advance_time 0.5 }
+      assert_equal('S', apdex)
+
+      in_web_transaction { advance_time 1.5 }
+      assert_equal('T', apdex)
+
+      in_web_transaction { advance_time 4.5 }
+      assert_equal('F', apdex)
+    end
+  end
+
+  def test_background_transaction_event_doesnt_include_apdex_perf_zone
+    apdex = nil
+    NewRelic::Agent.subscribe(:transaction_finished) do |payload|
+      apdex = payload[:apdex_perf_zone]
+    end
+
+    freeze_time
+
+    with_config(:apdex_t => 1.0) do
+      in_background_transaction { advance_time 0.5 }
+      assert_nil apdex
+    end
+  end
+
+  def test_cross_app_fields_in_finish_event_payload
+    keys = []
+    NewRelic::Agent.subscribe(:transaction_finished) do |payload|
+      keys = payload.keys
+    end
+
+    in_transaction do
+      NewRelic::Agent::TransactionState.tl_get.is_cross_app_caller = true
+    end
+
+    assert_includes keys, :cat_trip_id
+    assert_includes keys, :cat_path_hash
+  end
+
+  def test_cross_app_fields_not_in_finish_event_payload_if_no_cross_app_calls
+    keys = []
+    NewRelic::Agent.subscribe(:transaction_finished) do |payload|
+      keys = payload.keys
+    end
+
+    freeze_time
+
+    in_transaction do
+      advance_time(10)
+
+      state = NewRelic::Agent::TransactionState.tl_get
+      state.request_token = 'token'
+      state.is_cross_app_caller = false
+    end
+
+    refute_includes keys, :cat_trip_id
+    refute_includes keys, :cat_path_hash
+  end
+
   def test_logs_warning_if_a_non_hash_arg_is_passed_to_add_custom_params
     expects_logging(:warn, includes("add_custom_parameters"))
     in_transaction do
@@ -372,6 +474,15 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
     end
   end
 
+  def test_ignores_custom_parameters_when_in_high_security
+    with_config(:high_security => true) do
+      in_transaction do |txn|
+        NewRelic::Agent.add_custom_parameters(:failure => "is an option")
+        assert_empty txn.custom_parameters
+      end
+    end
+  end
+
   def test_user_attributes_alias_to_custom_parameters
     in_transaction('user_attributes') do |txn|
       txn.set_user_attributes(:set_instance => :set_instance)
@@ -639,6 +750,37 @@ class NewRelic::Agent::TransactionTest < Minitest::Test
     assert_metrics_recorded('Errors/all' => { :call_count => 2 })
   end
 
+  def test_start_safe_from_exceptions
+    NewRelic::Agent::Transaction.any_instance.stubs(:start).raises("Haha")
+    expects_logging(:error, any_parameters)
+
+    in_transaction("Controller/boom") do
+      # nope
+    end
+
+    # We expect our transaction to fail, but no exception should surface
+    assert_metrics_not_recorded(['Controller/boom'])
+  end
+
+  def test_stop_safe_from_exceptions
+    NewRelic::Agent::Transaction.any_instance.stubs(:stop).raises("Haha")
+    expects_logging(:error, any_parameters)
+
+    in_transaction("Controller/boom") do
+      # nope
+    end
+
+    # We expect our transaction to fail, but no exception should surface
+    assert_metrics_not_recorded(['Controller/boom'])
+  end
+
+  def test_stop_safe_when_no_transaction_available
+    expects_logging(:error, includes(NewRelic::Agent::Transaction::FAILED_TO_STOP_MESSAGE))
+
+    state = NewRelic::Agent::TransactionState.new
+    NewRelic::Agent::Transaction.stop(state)
+  end
+
   def assert_has_custom_parameter(txn, key, value = key)
     assert_equal(value, txn.custom_parameters[key])
   end