wd_newrelic_rpm 3.5.6 → 3.5.8

data/test/new_relic/agent/agent_test_controller_test.rb

@@ -84,7 +84,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
 
   def test_new_queue_integration
     # make this test deterministic
-    Time.stubs(:now => Time.at(2))
+    Time.stubs(:now => Time.at(1360973845))
 
     NewRelic::Agent::AgentTestController.clear_headers
     engine.clear_stats
@@ -95,35 +95,9 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     check_metric_time('WebFrontend/QueueTime', 1, 0.1)
   end
 
-
-  def test_new_middleware_integration
-    # make this test deterministic
-    Time.stubs(:now => Time.at(2))
-
-    engine.clear_stats
-    start = ((Time.now - 1).to_f * 1_000_000).to_i
-    NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_MIDDLEWARE_START'=> "t=#{start}"
-    get :index
-
-    check_metric_time('Middleware/all', 1, 0.1)
-  end
-
-  def test_new_server_time_integration
-    # make this test deterministic
-    Time.stubs(:now => Time.at(2))
-
-    NewRelic::Agent::AgentTestController.clear_headers
-    engine.clear_stats
-    start = ((Time.now - 1).to_f * 1_000_000).to_i
-    NewRelic::Agent::AgentTestController.set_some_headers 'HTTP_X_REQUEST_START'=> "t=#{start}"
-    get :index
-
-    check_metric_time('WebFrontend/WebServer/all', 1, 0.1)
-  end
-
   def test_new_frontend_work_integration
     # make this test deterministic
-    Time.stubs(:now => Time.at(10))
+    Time.stubs(:now => Time.at(1360973845))
 
     engine.clear_stats
     times = [Time.now - 3, Time.now - 2, Time.now - 1]
@@ -132,10 +106,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
                                                             'HTTP_X_REQUEST_START'=> "t=#{times[0]}", 'HTTP_X_QUEUE_START' => "t=#{times[1]}", 'HTTP_X_MIDDLEWARE_START' => "t=#{times[2]}"})
     get :index
 
-
-    check_metric_time('WebFrontend/WebServer/all', 1, 0.1)
-    check_metric_time('Middleware/all', 1, 0.1)
-    check_metric_time('WebFrontend/QueueTime', 1, 0.1)
+    check_metric_time('WebFrontend/QueueTime', 3, 0.1)
   end
 
   def test_render_inline
@@ -161,20 +132,18 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
                 'HttpDispatcher',
                 'Controller/new_relic/agent/agent_test/action_with_error',
                 'Errors/all',
-                'Middleware/all',
-                'WebFrontend/WebServer/all',
-                'WebFrontend/QueueTime']
+                'Errors/Controller/new_relic/agent/agent_test/action_with_error']
 
     compare_metrics metrics, engine.metrics.reject{|m| m.index('Response')==0 || m.index('CPU')==0}
     assert_equal 1, engine.get_stats_no_scope("Controller/new_relic/agent/agent_test/action_with_error").call_count
     assert_equal 1, engine.get_stats_no_scope("Errors/all").call_count
     apdex = engine.get_stats_no_scope("Apdex")
-    score = apdex.get_apdex
-    assert_equal 1, score[2], 'failing'
-    assert_equal 0, score[1], 'tol'
-    assert_equal 0, score[0], 'satisfied'
 
+    assert_equal 1, apdex.apdex_f, 'failing'
+    assert_equal 0, apdex.apdex_t, 'tol'
+    assert_equal 0, apdex.apdex_s, 'satisfied'
   end
+
   def test_controller_error
     engine.clear_stats
     assert_raise RuntimeError do
@@ -185,20 +154,18 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
                 'HttpDispatcher',
                 'Controller/new_relic/agent/agent_test/action_with_error',
                 'Errors/all',
-                'WebFrontend/QueueTime',
-                'Middleware/all',
-                'WebFrontend/WebServer/all']
+                'Errors/Controller/new_relic/agent/agent_test/action_with_error']
 
     compare_metrics metrics, engine.metrics.reject{|m| m.index('Response')==0 || m.index('CPU')==0}
     assert_equal 1, engine.get_stats_no_scope("Controller/new_relic/agent/agent_test/action_with_error").call_count
     assert_equal 1, engine.get_stats_no_scope("Errors/all").call_count
     apdex = engine.get_stats_no_scope("Apdex")
-    score = apdex.get_apdex
-    assert_equal 1, score[2], 'failing'
-    assert_equal 0, score[1], 'tol'
-    assert_equal 0, score[0], 'satisfied'
 
+    assert_equal 1, apdex.apdex_f, 'failing'
+    assert_equal 0, apdex.apdex_t, 'tol'
+    assert_equal 0, apdex.apdex_s, 'satisfied'
   end
+
   def test_filter_error
     engine.clear_stats
     assert_raise RuntimeError do
@@ -209,28 +176,28 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
                 'HttpDispatcher',
                 'Controller/new_relic/agent/agent_test/action_with_before_filter_error',
                 'Errors/all',
-                'WebFrontend/QueueTime',
-                'Middleware/all',
-                'WebFrontend/WebServer/all']
+                'Errors/Controller/new_relic/agent/agent_test/action_with_before_filter_error']
 
     compare_metrics metrics, engine.metrics.reject{|m| m.index('Response')==0 || m.index('CPU')==0 || m.index('GC')==0}
     assert_equal 1, engine.get_stats_no_scope("Controller/new_relic/agent/agent_test/action_with_before_filter_error").call_count
     assert_equal 1, engine.get_stats_no_scope("Errors/all").call_count
     apdex = engine.get_stats_no_scope("Apdex")
-    score = apdex.get_apdex
-    assert_equal 1, score[2], 'failing'
-    assert_equal 0, score[1], 'tol'
-    assert_equal 0, score[0], 'satisfied'
+
+    assert_equal 1, apdex.apdex_f, 'failing'
+    assert_equal 0, apdex.apdex_t, 'tol'
+    assert_equal 0, apdex.apdex_s, 'satisfied'
   end
+
   def test_metric__ignore_base
     engine.clear_stats
     get :base_action
     compare_metrics [], engine.metrics
   end
+
   def test_metric__no_ignore
     path = 'new_relic/agent/agent_test/index'
     index_stats = stats("Controller/#{path}")
-    index_apdex_stats = engine.get_custom_stats("Apdex/#{path}", NewRelic::ApdexStats)
+    index_apdex_stats = engine.get_stats_no_scope("Apdex/#{path}")
     assert_difference 'index_stats.call_count' do
       assert_difference 'index_apdex_stats.call_count' do
         get :index
@@ -243,7 +210,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
     path = 'new_relic/agent/agent_test/action_to_ignore_apdex'
     cpu_stats = stats("ControllerCPU/#{path}")
     index_stats = stats("Controller/#{path}")
-    index_apdex_stats = engine.get_custom_stats("Apdex/#{path}", NewRelic::ApdexStats)
+    index_apdex_stats = engine.get_stats_no_scope("Apdex/#{path}")
     assert_difference 'index_stats.call_count' do
       assert_no_difference 'index_apdex_stats.call_count' do
         get :action_to_ignore_apdex
@@ -279,9 +246,9 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   end
 
   def test_controller_params
-    agent.transaction_sampler.reset!
-    get :index, 'number' => "001-555-1212"
     s = with_config(:'transaction_tracer.transaction_threshold' => 0.0) do
+      agent.transaction_sampler.reset!
+      get :index, 'number' => "001-555-1212"
       agent.transaction_sampler.harvest(nil)
     end
     assert_equal 1, s.size
@@ -344,7 +311,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
 
   def test_queue_headers_apache
     # make this test deterministic
-    Time.stubs(:now => Time.at(10))
+    Time.stubs(:now => Time.at(1360973845))
 
     NewRelic::Agent::AgentTestController.clear_headers
     engine.clear_stats
@@ -363,7 +330,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
   end
   def test_queue_headers_heroku
     # make this test deterministic
-    Time.stubs(:now => Time.at(10))
+    Time.stubs(:now => Time.at(1360973845))
 
     engine.clear_stats
     NewRelic::Agent::AgentTestController.clear_headers
@@ -383,7 +350,7 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
 
   def test_queue_headers_heroku_queue_length
     # make this test deterministic
-    Time.stubs(:now => Time.at(10))
+    Time.stubs(:now => Time.at(1360973845))
 
     engine.clear_stats
     NewRelic::Agent::AgentTestController.clear_headers

data/test/new_relic/agent/busy_calculator_test.rb

@@ -6,7 +6,7 @@ class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
   def setup
     @now = Time.now.to_f
     NewRelic::Agent::BusyCalculator.reset
-    @instance_busy = NewRelic::MethodTraceStats.new
+    @instance_busy = NewRelic::Agent::Stats.new
     NewRelic::Agent::BusyCalculator.stubs(:instance_busy_stats).returns(@instance_busy)
   end
 

data/test/new_relic/agent/configuration/server_source_test.rb

@@ -11,9 +11,10 @@ module NewRelic::Agent::Configuration
           'transaction_tracer.record_sql'            => 'raw',
           'error_collector.enabled'                  => true
         },
-        'apdex_t'                                  => 1.0,
-        'collect_errors'                           => false,
-        'collect_traces'                           => true
+        'apdex_t'                => 1.0,
+        'collect_errors'         => false,
+        'collect_traces'         => true,
+        'web_transactions_apdex' => { 'Controller/some/txn' => 1.5 }
       }
       @source = ServerSource.new(config)
     end
@@ -41,5 +42,9 @@ module NewRelic::Agent::Configuration
     def test_should_ignore_apdex_f_setting_for_transaction_threshold
       assert_equal nil, @source[:'transaction_tracer.transaction_threshold']
     end
+
+    def test_should_not_dot_the_web_transactions_apdex_hash
+      assert_equal 1.5, @source[:web_transactions_apdex]['Controller/some/txn']
+    end
   end
 end

data/test/new_relic/agent/cross_app_monitor_test.rb

@@ -0,0 +1,237 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+
+module NewRelic::Agent
+  class CrossAppMonitorTest < Test::Unit::TestCase
+    NEWRELIC_ID_HEADER        = NewRelic::Agent::CrossAppMonitor::NEWRELIC_ID_HEADER
+    NEWRELIC_TXN_HEADER       = NewRelic::Agent::CrossAppMonitor::NEWRELIC_TXN_HEADER
+
+    AGENT_CROSS_APP_ID        = "qwerty"
+    REQUEST_CROSS_APP_ID      = "42#1234"
+    TRANSACTION_GUID          = '941B0E8001E444E8'
+    REF_TRANSACTION_GUID      = '830092CDE59421D4'
+
+    TRANSACTION_NAME          = 'transaction'
+    QUEUE_TIME                = 1000
+    APP_TIME                  = 2000
+
+    ENCODING_KEY_NOOP         = "\0"
+    TRUSTED_ACCOUNT_IDS       = [42,13]
+
+    CROSS_APP_ID_POSITION     = 0
+    TRANSACTION_NAME_POSITION = 1
+    QUEUE_TIME_POSITION       = 2
+    APP_TIME_POSITION         = 3
+    CONTENT_LENGTH_POSITION   = 4
+
+    def setup
+      NewRelic::Agent.reset_config
+      NewRelic::Agent.instance.events.clear
+      @response = {}
+
+      @monitor = NewRelic::Agent::CrossAppMonitor.new()
+      @config = {
+        :cross_process_id => AGENT_CROSS_APP_ID,
+        :encoding_key => ENCODING_KEY_NOOP,
+        :trusted_account_ids => TRUSTED_ACCOUNT_IDS
+      }
+        
+      NewRelic::Agent.config.apply_config( @config )
+      @monitor.register_event_listeners
+      NewRelic::Agent::TransactionInfo.get.guid = TRANSACTION_GUID
+
+      # NewRelic::Agent.logger = NewRelic::Agent::AgentLogger.new( {:log_level => 'debug'}, '', Logger.new($stderr) )
+    end
+
+    def teardown
+      NewRelic::Agent.config.remove_config( @config )
+      NewRelic::Agent.instance.events.clear
+    end
+
+
+    #
+    # Tests
+    #
+
+    def test_adds_response_header
+      with_default_timings
+
+      when_request_runs
+
+      assert_equal 'WyJxd2VydHkiLCJ0cmFuc2FjdGlvbiIsMTAwMC4wLDIwMDAuMCwtMSwiOTQxQjBFODAwMUU0NDRFOCJd', response_app_data
+      assert_equal [AGENT_CROSS_APP_ID, TRANSACTION_NAME, QUEUE_TIME, APP_TIME, -1, TRANSACTION_GUID], unpacked_response
+    end
+
+    def test_strips_bad_characters_in_transaction_name
+      NewRelic::Agent::BrowserMonitoring.stubs(:timings).returns(stub(
+          :transaction_name => "\"'goo",
+          :queue_time_in_seconds => QUEUE_TIME,
+          :app_time_in_seconds => APP_TIME))
+
+      when_request_runs
+
+      assert_equal "goo", unpacked_response[TRANSACTION_NAME_POSITION]
+    end
+
+    def test_doesnt_write_response_header_if_id_blank
+      with_default_timings
+
+      when_request_runs(for_id(''))
+      assert_nil response_app_data
+    end
+
+    def test_doesnt_write_response_header_if_untrusted_id
+      with_default_timings
+
+      when_request_runs(for_id("4#1234"))
+      assert_nil response_app_data
+    end
+
+    def test_doesnt_write_response_header_if_improperly_formatted_id
+      with_default_timings
+
+      when_request_runs(for_id("42"))
+      assert_nil response_app_data
+    end
+
+    def test_doesnt_add_header_if_no_id_in_request
+      when_request_runs({})
+      assert_nil response_app_data
+    end
+
+    def test_doesnt_add_header_if_no_id_on_agent
+      # Since a +nil+ will make it fall back to the config installed in setup,
+      # we need to remove that first in order to test the no-id case
+      newconfig = @config.merge( :cross_process_id => nil )
+      NewRelic::Agent.config.remove_config( @config )
+
+      with_config( newconfig ) do
+        when_request_runs
+        assert_nil response_app_data
+      end
+    end
+
+    def test_doesnt_add_header_if_config_disabled
+      with_config(:"cross_application_tracer.enabled" => false) do
+        when_request_runs
+        assert_nil response_app_data
+      end
+    end
+
+    def test_includes_content_length
+      with_default_timings
+
+      when_request_runs(for_id(REQUEST_CROSS_APP_ID).merge("Content-Length" => 3000))
+      assert_equal 3000, unpacked_response[CONTENT_LENGTH_POSITION]
+    end
+
+    def test_finds_content_length_from_headers
+      %w{Content-Length HTTP_CONTENT_LENGTH CONTENT_LENGTH cOnTeNt-LeNgTh}.each do |key|
+        request = { key => 42 }
+
+        assert_equal(42, @monitor.content_length_from_request(request), \
+          "Failed to find header on key #{key}")
+      end
+    end
+
+    def test_writes_custom_parameters
+      with_default_timings
+
+      NewRelic::Agent.expects(:add_custom_parameters).with(:client_cross_process_id => REQUEST_CROSS_APP_ID)
+      NewRelic::Agent.expects(:add_custom_parameters).with(:referring_transaction_guid => REF_TRANSACTION_GUID)
+
+      when_request_runs
+    end
+
+    def test_error_writes_custom_parameters
+      with_default_timings
+
+      options = when_request_has_error
+
+      assert_equal REQUEST_CROSS_APP_ID, options[:client_cross_process_id]
+    end
+
+    def test_error_doesnt_write_custom_parameters_if_no_id
+      with_default_timings
+
+      options = when_request_has_error(for_id(''))
+
+      assert_equal false, options.key?(:client_cross_process_id)
+    end
+
+    def test_writes_metric
+      with_default_timings
+
+      metric = mock()
+      metric.expects(:record_data_point).with(APP_TIME)
+      NewRelic::Agent.instance.stats_engine.stubs(:get_stats_no_scope).returns(metric)
+
+      when_request_runs
+    end
+
+    def test_doesnt_write_metric_if_id_blank
+      with_default_timings
+      NewRelic::Agent.instance.stats_engine.expects(:get_stats_no_scope).never
+
+      when_request_runs(for_id(''))
+    end
+
+    def test_decoding_blank
+      assert_equal "",
+        NewRelic::Agent::CrossAppMonitor::EncodingFunctions.decode_with_key( 'querty', "" )
+    end
+
+    def test_encode_with_nil_uses_empty_key
+      assert_equal "querty",
+        NewRelic::Agent::CrossAppMonitor::EncodingFunctions.encode_with_key( nil, 'querty' )
+    end
+
+
+    #
+    # Helpers
+    #
+
+    def when_request_runs(request=for_id(REQUEST_CROSS_APP_ID))
+      event_listener = NewRelic::Agent.instance.events
+      event_listener.notify(:before_call, request)
+      event_listener.notify(:start_transaction, 'a name')
+      event_listener.notify(:after_call, request, [200, @response, ''])
+    end
+
+    def when_request_has_error(request=for_id(REQUEST_CROSS_APP_ID))
+      options = {}
+      event_listener = NewRelic::Agent.instance.events
+      event_listener.notify(:before_call, request)
+      event_listener.notify(:notice_error, nil, options)
+      event_listener.notify(:after_call, request, [500, @response, ''])
+
+      options
+    end
+
+    def with_default_timings
+      NewRelic::Agent::BrowserMonitoring.stubs(:timings).returns(stub(
+          :transaction_name => TRANSACTION_NAME,
+          :queue_time_in_seconds => QUEUE_TIME,
+          :app_time_in_seconds => APP_TIME))
+    end
+
+    def for_id(id)
+      encoded_id = id == "" ? "" : Base64.encode64(id)
+      encoded_txn_info = Base64.encode64( NewRelic.json_dump([ REF_TRANSACTION_GUID, false ]) )
+
+      return {
+        NEWRELIC_ID_HEADER => encoded_id,
+        NEWRELIC_TXN_HEADER => encoded_txn_info,
+      }
+    end
+
+    def response_app_data
+      @response['X-NewRelic-App-Data']
+    end
+
+    def unpacked_response
+      return nil unless response_app_data
+      NewRelic.json_load(Base64.decode64(response_app_data))
+    end
+
+  end
+end