newrelic_rpm 3.5.7.59 → 3.5.8.64.beta

data/test/new_relic/agent/agent_test_controller_test.rb

@@ -131,18 +131,19 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
                 'Apdex/new_relic/agent/agent_test/action_with_error',
                 'HttpDispatcher',
                 'Controller/new_relic/agent/agent_test/action_with_error',
-                'Errors/all']
+                'Errors/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_controller_error
     engine.clear_stats
     assert_raise RuntimeError do
@@ -152,18 +153,19 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
                 'Apdex/new_relic/agent/agent_test/action_with_error',
                 'HttpDispatcher',
                 'Controller/new_relic/agent/agent_test/action_with_error',
-                'Errors/all']
+                'Errors/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
@@ -173,26 +175,29 @@ class NewRelic::Agent::AgentTestControllerTest < ActionController::TestCase
                 'Apdex/new_relic/agent/agent_test/action_with_before_filter_error',
                 'HttpDispatcher',
                 'Controller/new_relic/agent/agent_test/action_with_before_filter_error',
-                'Errors/all']
+                'Errors/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
@@ -205,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
@@ -241,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

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 [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(:transaction_guid => TRANSACTION_GUID)
+      NewRelic::Agent.expects(:add_custom_parameters).with(:transaction_referring_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

data/test/new_relic/agent/database_test.rb

@@ -5,13 +5,13 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
   def teardown
     NewRelic::Agent::Database::Obfuscator.instance.reset
   end
-  
+
   def test_process_resultset
     resultset = [["column"]]
     assert_equal([nil, [["column"]]],
                  NewRelic::Agent::Database.process_resultset(resultset))
   end
-  
+
   def test_explain_sql_select_with_mysql_connection
     config = {:adapter => 'mysql'}
     config.default('val')
@@ -30,7 +30,7 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
 
     result = NewRelic::Agent::Database.explain_sql(sql, config)
     assert_equal(plan.keys.sort, result[0].sort)
-    assert_equal(plan.values.compact.sort, result[1][0].compact.sort)    
+    assert_equal(plan.values.compact.sort, result[1][0].compact.sort)
   end
 
   def test_explain_sql_one_select_with_pg_connection
@@ -50,6 +50,44 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
                  NewRelic::Agent::Database.explain_sql(sql, config))
   end
 
+  def test_dont_collect_explain_for_parameterized_query
+    config = {:adapter => 'postgresql'}
+    config.default('val')
+    connection = mock('connection')
+    connection.expects(:execute).never
+    NewRelic::Agent::Database.stubs(:get_connection).with(config).returns(connection)
+    expects_logging(:debug, 'Unable to collect explain plan for parameterized query.')
+
+    sql = 'SELECT * FROM table WHERE id = $1'
+    assert_equal [], NewRelic::Agent::Database.explain_sql(sql, config)
+  end
+
+  def test_do_collect_explain_for_parameter_looking_literal
+    config = {:adapter => 'postgresql'}
+    config.default('val')
+    connection = mock('connection')
+    plan = [{"QUERY PLAN"=>"Some Jazz"}]
+    connection.stubs(:execute).returns(plan)
+    NewRelic::Agent::Database.stubs(:get_connection).with(config).returns(connection)
+
+    sql = "SELECT * FROM table WHERE id = 'noise $11'"
+    assert_equal([['QUERY PLAN'], [["Some Jazz"]]],
+                 NewRelic::Agent::Database.explain_sql(sql, config))
+  end
+
+  def test_dont_collect_explain_for_truncated_query
+    config = {:adapter => 'postgresql'}
+    config.default('val')
+    connection = mock('connection')
+    connection.expects(:execute).never
+    NewRelic::Agent::Database.stubs(:get_connection).with(config).returns(connection)
+    expects_logging(:debug, 'Unable to collect explain plan for truncated query.')
+
+    sql = 'SELECT * FROM table WHERE id IN (1,2,3,4,5...'
+    assert_equal [], NewRelic::Agent::Database.explain_sql(sql, config)
+
+  end
+
   def test_explain_sql_no_sql
     assert_equal(nil, NewRelic::Agent::Database.explain_sql(nil, nil))
   end
@@ -71,8 +109,8 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     config = mock('config')
     config.stubs(:[]).returns(nil)
     assert_equal([], NewRelic::Agent::Database.explain_sql('SELECT', config))
-  end  
-  
+  end
+
   def test_obfuscation_mysql_basic
     insert = %q[INSERT INTO `X` values("test",0, 1 , 2, 'test')]
     assert_equal("INSERT INTO `X` values(?,?, ? , ?, ?)",
@@ -90,9 +128,9 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     select = NewRelic::Agent::Database::Statement.new(%q[SELECT "table"."column" FROM "table" WHERE "table"."column" = 'value' AND "table"."other_column" = 'other value' LIMIT 1])
     select.adapter = :postgresql
     assert_equal(%q[SELECT "table"."column" FROM "table" WHERE "table"."column" = ? AND "table"."other_column" = ? LIMIT ?],
-                 NewRelic::Agent::Database.obfuscate_sql(select))  
+                 NewRelic::Agent::Database.obfuscate_sql(select))
   end
-  
+
   def test_obfuscation_escaped_literals
     insert = %q[INSERT INTO X values('', 'jim''s ssn',0, 1 , 'jim''s son''s son', """jim''s"" hat", "\"jim''s secret\"")]
     assert_equal("INSERT INTO X values(?, ?,?, ? , ?, ?, ?)",
@@ -104,7 +142,7 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     assert_equal(%q[SELECT * FROM `table_007` LIMIT ?],
                  NewRelic::Agent::Database.obfuscate_sql(select))
   end
-  
+
   def test_obfuscation_postgresql_integers_in_identifiers
     select = NewRelic::Agent::Database::Statement.new(%q[SELECT * FROM "table_007" LIMIT 1])
     select.adapter = :postgresql
@@ -112,25 +150,31 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
                  NewRelic::Agent::Database.obfuscate_sql(select))
   end
 
+  def test_obfuscation_of_truncated_query
+    insert = "INSERT INTO data (blah) VALUES ('abcdefg..."
+    assert_equal("Query too large (over 16k characters) to safely obfuscate",
+                 NewRelic::Agent::Database.obfuscate_sql(insert))
+  end
+
   def test_sql_obfuscation_filters
     NewRelic::Agent::Database.set_sql_obfuscator(:replace) do |string|
       "1" + string
     end
-    
+
     sql = "SELECT * FROM TABLE 123 'jim'"
-    
+
     assert_equal "1" + sql, NewRelic::Agent::Database.obfuscate_sql(sql)
-    
+
     NewRelic::Agent::Database.set_sql_obfuscator(:before) do |string|
       "2" + string
     end
-    
+
     assert_equal "12" + sql, NewRelic::Agent::Database.obfuscate_sql(sql)
-    
+
     NewRelic::Agent::Database.set_sql_obfuscator(:after) do |string|
       string + "3"
     end
-    
+
     assert_equal "12" + sql + "3", NewRelic::Agent::Database.obfuscate_sql(sql)
 
     NewRelic::Agent::Database::Obfuscator.instance.reset
@@ -140,11 +184,11 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
     foo_connection = mock('foo connection')
     bar_connection = mock('bar connection')
     NewRelic::Agent::Database::ConnectionManager.instance.instance_eval do
-      @connections = { :foo => foo_connection, :bar => bar_connection }      
+      @connections = { :foo => foo_connection, :bar => bar_connection }
     end
     foo_connection.expects(:disconnect!)
     bar_connection.expects(:disconnect!)
-    
+
     NewRelic::Agent::Database.close_connections
   end
 end