sundawg_newrelic_rpm 3.5.8.1

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

@@ -0,0 +1,85 @@
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'new_relic/agent/configuration/yaml_source'
+
+module NewRelic::Agent::Configuration
+  class YamlSourceTest < Test::Unit::TestCase
+    def setup
+      @test_yml_path = File.expand_path(File.join(File.dirname(__FILE__),
+                                                 '..','..','..',
+                                                 'config','newrelic.yml'))
+      @source = YamlSource.new(@test_yml_path, 'test')
+    end
+
+    def test_should_load_given_yaml_file
+      assert_equal '127.0.0.1', @source[:api_host]
+    end
+
+    def test_should_apply_erb_transformations
+      assert_equal 'heyheyhey', @source[:erb_value]
+      assert_equal '', @source[:message]
+      assert_equal '', @source[:license_key]
+    end
+
+    def test_config_booleans
+      assert_equal true, @source[:tval]
+      assert_equal false, @source[:fval]
+      assert_nil @source[:not_in_yaml_val]
+      assert_equal true, @source[:yval]
+      assert_equal 'sure', @source[:sval]
+    end
+
+    def test_appnames
+      assert_equal %w[a b c], @source[:app_name]
+    end
+
+    def test_should_load_the_config_for_the_correct_env
+      assert_not_equal 'the.wrong.host', @source[:host]
+    end
+
+    def test_should_convert_to_dot_notation
+      assert_equal 'raw', @source[:'transaction_tracer.record_sql']
+    end
+
+    def test_should_ignore_apdex_f_setting_for_transaction_threshold
+      assert_equal nil, @source[:'transaction_tracer.transaction_threshold']
+    end
+
+    def test_should_correctly_handle_floats
+      assert_equal 1.1, @source[:apdex_t]
+    end
+
+    def test_should_not_log_error_by_default
+      expects_no_logging(:error)
+      YamlSource.new(@test_yml_path, 'test')
+    end
+
+    def test_should_log_if_no_file_is_found
+      expects_logging(:error, any_parameters)
+      source = YamlSource.new('no_such_file.yml', 'test')
+    end
+
+    def test_should_log_if_environment_is_not_present
+      expects_logging(:error, any_parameters)
+      source = YamlSource.new(@test_yml_path, 'nonsense')
+    end
+
+    def test_should_not_fail_to_log_missing_file_during_startup
+      without_logger do
+        ::NewRelic::Agent::StartupLogger.any_instance.expects(:error)
+        source = YamlSource.new('no_such_file.yml', 'test')
+      end
+    end
+
+    def test_should_not_fail_to_log_invalid_file_during_startup
+      without_logger do
+        ::NewRelic::Agent::StartupLogger.any_instance.expects(:error)
+
+        File.stubs(:exists?).returns(true)
+        File.stubs(:read).raises(StandardError.new("boo"))
+
+        source = YamlSource.new('fake.yml', 'test')
+      end
+    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

data/test/new_relic/agent/database_test.rb

@@ -0,0 +1,194 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..',
+                                   'test_helper'))
+require 'new_relic/agent/database'
+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')
+    sql = 'SELECT foo'
+    connection = mock('connection')
+    plan = {
+      "select_type"=>"SIMPLE", "key_len"=>nil, "table"=>"blogs", "id"=>"1",
+      "possible_keys"=>nil, "type"=>"ALL", "Extra"=>"", "rows"=>"2",
+      "ref"=>nil, "key"=>nil
+    }
+    result = mock('explain plan')
+    result.expects(:each_hash).yields(plan)
+    # two rows, two columns
+    connection.expects(:execute).with('EXPLAIN SELECT foo').returns(result)
+    NewRelic::Agent::Database.expects(:get_connection).with(config).returns(connection)
+
+    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)
+  end
+
+  def test_explain_sql_one_select_with_pg_connection
+    config = {:adapter => 'postgresql'}
+    config.default('val')
+    sql = 'select count(id) from blogs limit 1'
+    connection = mock('connection')
+    plan = [{"QUERY PLAN"=>"Limit  (cost=11.75..11.76 rows=1 width=4)"},
+            {"QUERY PLAN"=>"  ->  Aggregate  (cost=11.75..11.76 rows=1 width=4)"},
+            {"QUERY PLAN"=>"        ->  Seq Scan on blogs  (cost=0.00..11.40 rows=140 width=4)"}]
+    connection.expects(:execute).returns(plan)
+    NewRelic::Agent::Database.expects(:get_connection).with(config).returns(connection)
+    assert_equal([['QUERY PLAN'],
+                  [["Limit  (cost=11.75..11.76 rows=1 width=4)"],
+                   ["  ->  Aggregate  (cost=11.75..11.76 rows=1 width=4)"],
+                   ["        ->  Seq Scan on blogs  (cost=0.00..11.40 rows=140 width=4)"]]],
+                 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
+
+  def test_explain_sql_no_connection_config
+    assert_equal(nil, NewRelic::Agent::Database.explain_sql('select foo', nil))
+  end
+
+  def test_explain_sql_non_select
+    assert_equal([], NewRelic::Agent::Database.explain_sql('foo',
+                                                           mock('config')))
+  end
+
+  def test_explain_sql_one_select_no_connection
+    # NB this test raises an error in the log, much as it might if a
+    # user supplied a config that was not valid. This is generally
+    # expected behavior - the get_connection method shouldn't allow
+    # errors to percolate up.
+    config = mock('config')
+    config.stubs(:[]).returns(nil)
+    assert_equal([], NewRelic::Agent::Database.explain_sql('SELECT', config))
+  end
+
+  def test_obfuscation_mysql_basic
+    insert = %q[INSERT INTO `X` values("test",0, 1 , 2, 'test')]
+    assert_equal("INSERT INTO `X` values(?,?, ? , ?, ?)",
+                 NewRelic::Agent::Database.obfuscate_sql(insert))
+    select = %q[SELECT `table`.`column` FROM `table` WHERE `table`.`column` = 'value' AND `table`.`other_column` = "other value" LIMIT 1]
+    assert_equal(%q[SELECT `table`.`column` FROM `table` WHERE `table`.`column` = ? AND `table`.`other_column` = ? LIMIT ?],
+                 NewRelic::Agent::Database.obfuscate_sql(select))
+  end
+
+  def test_obfuscation_postgresql_basic
+    insert = NewRelic::Agent::Database::Statement.new(%q[INSERT INTO "X" values('test',0, 1 , 2, 'test')])
+    insert.adapter = :postgresql
+    assert_equal('INSERT INTO "X" values(?,?, ? , ?, ?)',
+                 NewRelic::Agent::Database.obfuscate_sql(insert))
+    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))
+  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(?, ?,?, ? , ?, ?, ?)",
+                 NewRelic::Agent::Database.obfuscate_sql(insert))
+  end
+
+  def test_obfuscation_mysql_integers_in_identifiers
+    select = %q[SELECT * FROM `table_007` LIMIT 1]
+    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
+    assert_equal(%q[SELECT * FROM "table_007" LIMIT ?],
+                 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
+  end
+
+  def test_close_connections_closes_all_held_db_connections
+    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 }
+    end
+    foo_connection.expects(:disconnect!)
+    bar_connection.expects(:disconnect!)
+
+    NewRelic::Agent::Database.close_connections
+  end
+end