dolores_rpm 3.2.0.6 → 3.3.4.fork

data/test/new_relic/agent/beacon_configuration_test.rb

@@ -19,7 +19,8 @@ class NewRelic::Agent::BeaconConfigurationTest < Test::Unit::TestCase
     assert_equal('a browser monitoring key', bc.browser_monitoring_key)
     assert_equal('an application id', bc.application_id)
     assert_equal('a beacon', bc.beacon)
-    assert_equal(117, bc.browser_timing_header.size, "should output the javascript with all the data available")
+    s = "<script type=\"text/javascript\">var NREUMQ=NREUMQ||[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>"
+    assert_equal(s, bc.browser_timing_header)
   end
 
   def test_license_bytes_nil
@@ -81,22 +82,24 @@ class NewRelic::Agent::BeaconConfigurationTest < Test::Unit::TestCase
   def test_build_load_file_js_load_episodes_file_false
     connect_data = {'rum.load_episodes_file' => false}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
-    assert_equal(160, bc.build_load_file_js(connect_data).size,
-                 "should include timing footer but not rum.js load")
+    s = "if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\n"
+    assert_equal(s, bc.build_load_file_js(connect_data))
   end
   
   def test_build_load_file_js_load_episodes_file_missing
     connect_data = {}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
-    assert_equal(278, bc.build_load_file_js(connect_data).size,
-                 "should output the javascript when there is no configuration")
+    s = "if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nvar e=document.createElement(\"script\");\ne.type=\"text/javascript\";e.async=true;e.src=\"\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\n"
+    
+    assert_equal(s, bc.build_load_file_js(connect_data))
   end
 
   def test_build_load_file_js_load_episodes_file_present
     connect_data = {'rum.load_episodes_file' => true}
     bc = NewRelic::Agent::BeaconConfiguration.new(connect_data)
-    assert_equal(278, bc.build_load_file_js(connect_data).size,
-            "should output the javascript when rum.load_episodes_file is true")
+    s = "if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nvar e=document.createElement(\"script\");\ne.type=\"text/javascript\";e.async=true;e.src=\"\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\n"
+    
+    assert_equal(s, bc.build_load_file_js(connect_data))
   end
   
   def test_build_load_file_js_load_episodes_file_with_episodes_url

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -4,22 +4,41 @@ require "new_relic/agent/browser_monitoring"
 
 class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
   include NewRelic::Agent::BrowserMonitoring
-
+  include NewRelic::Agent::Instrumentation::ControllerInstrumentation
+  
   def setup
     NewRelic::Agent.manual_start
     @browser_monitoring_key = "fred"
     @episodes_file = "this_is_my_file"
     NewRelic::Agent.instance.instance_eval do
-      @beacon_configuration = NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => true, "browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"})
+      @beacon_configuration = NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => true, "browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file", 'rum.jsonp' => true})
     end
-    Thread.current[:newrelic_most_recent_transaction] = "MyCoolTransaction"
+    Thread.current[:last_metric_frame] = nil
+    NewRelic::Agent::TransactionInfo.clear
   end
 
   def teardown
     mocha_teardown
-    Thread.current[:newrelic_start_time] = nil
-    Thread.current[:newrelic_metric_frame] = nil
-    Thread.current[:newrelic_most_recent_transaction] = nil
+  end
+
+  def test_browser_monitoring_start_time_is_reset_each_request_when_auto_instrument_is_disabled
+    controller = Object.new
+    def controller.perform_action_without_newrelic_trace(method, options={});
+      # noop; instrument me
+    end
+    def controller.newrelic_metric_path; "foo"; end
+    controller.extend ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
+    controller.extend ::NewRelic::Agent::BrowserMonitoring
+    NewRelic::Control.instance['browser_monitoring'] = { 'auto_instrument' => false }
+
+    controller.perform_action_with_newrelic_trace(:index)
+    first_request_start_time = controller.send(:browser_monitoring_start_time)
+    controller.perform_action_with_newrelic_trace(:index)
+    second_request_start_time = controller.send(:browser_monitoring_start_time)
+
+    # assert that these aren't the same time object
+    # the start time should be reinitialized each request to the controller
+    assert !(first_request_start_time.equal? second_request_start_time)
   end
 
   def test_browser_timing_header_with_no_beacon_configuration
@@ -65,8 +84,6 @@ class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
     browser_timing_header
     NewRelic::Control.instance.expects(:license_key).returns("a" * 13)
 
-    Thread.current[:newrelic_start_time] = Time.now
-
     footer = browser_timing_footer
     snippet = '<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {
 NREUMQ.push(["load",new Date().getTime()]);
@@ -74,11 +91,6 @@ var e=document.createElement("script");'
     assert footer.include?(snippet), "Expected footer to include snippet: #{snippet}, but instead was #{footer}"
   end
 
-  def test_browser_timing_footer_without_calling_header
-    Thread.current[:newrelic_start_time] = nil    
-    assert_equal "", browser_timing_footer
-  end
-
   def test_browser_timing_footer_with_no_browser_key_rum_enabled
     browser_timing_header
     NewRelic::Agent.instance.expects(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => true, "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
@@ -95,7 +107,6 @@ var e=document.createElement("script");'
 
   def test_browser_timing_footer_with_rum_enabled_not_specified
     browser_timing_header
-    Thread.current[:newrelic_start_time] = Time.now
 
     license_bytes = [];
     ("a" * 13).each_byte {|byte| license_bytes << byte}
@@ -118,14 +129,6 @@ var e=document.createElement("script");'
     assert_equal "", footer
   end
 
-  def test_browser_timing_footer_with_no_start_time
-    browser_timing_header
-    Thread.current[:newrelic_start_time] = nil
-    NewRelic::Agent.instance.expects(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new({"browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
-    footer = browser_timing_footer
-    assert_equal('', footer)
-  end
-
 
   def test_browser_timing_footer_disable_all_tracing
     browser_timing_header
@@ -157,37 +160,62 @@ var e=document.createElement("script");'
 
   def test_generate_footer_js_null_case
     self.expects(:browser_monitoring_start_time).returns(nil)
-    assert_equal('', generate_footer_js, "should not send javascript when there is no start time")
+    assert_equal('', generate_footer_js(NewRelic::Agent.instance.beacon_configuration), "should not send javascript when there is no start time")
   end
-
+ 
   def test_generate_footer_js_with_start_time
     self.expects(:browser_monitoring_start_time).returns(Time.at(100))
     fake_bc = mock('beacon configuration')
     fake_bc.expects(:application_id).returns(1)
     fake_bc.expects(:beacon).returns('beacon')
     fake_bc.expects(:browser_monitoring_key).returns('a' * 40)
-    NewRelic::Agent.instance.expects(:beacon_configuration).returns(fake_bc)
-    self.expects(:footer_js_string).with('beacon', 'a' * 40, 1).returns('footer js')
-    assert_equal('footer js', generate_footer_js, 'should generate and return the footer JS when there is a start time')
+    NewRelic::Agent.instance.stubs(:beacon_configuration).returns(fake_bc)
+    self.expects(:footer_js_string).with(NewRelic::Agent.instance.beacon_configuration, 'beacon', 'a' * 40, 1).returns('footer js')
+    assert_equal('footer js', generate_footer_js(NewRelic::Agent.instance.beacon_configuration), 'should generate and return the footer JS when there is a start time')
   end
 
   def test_browser_monitoring_transaction_name_basic
-    Thread.current[:newrelic_most_recent_transaction] = 'a transaction name'
+    mock = mock('transaction sample')
+    NewRelic::Agent::TransactionInfo.set(mock)
+    mock.stubs(:transaction_name).returns('a transaction name')
+
     assert_equal('a transaction name', browser_monitoring_transaction_name, "should take the value from the thread local")
   end
 
   def test_browser_monitoring_transaction_name_empty
-    Thread.current[:newrelic_most_recent_transaction] = ''
+    mock = mock('transaction sample')
+    NewRelic::Agent::TransactionInfo.set(mock)
+
+    mock.stubs(:transaction_name).returns('')
     assert_equal('', browser_monitoring_transaction_name, "should take the value even when it is empty")
   end
 
   def test_browser_monitoring_transaction_name_nil
-    Thread.current[:newrelic_most_recent_transaction] = nil
-    assert_equal('<unknown>', browser_monitoring_transaction_name, "should fill in a default when it is nil")
+    assert_equal('(unknown)', browser_monitoring_transaction_name, "should fill in a default when it is nil")
   end
+  
+  def test_browser_monitoring_transaction_name_when_tt_disabled
+    @sampler = NewRelic::Agent.instance.transaction_sampler
+    @sampler.disable
 
+    perform_action_with_newrelic_trace(:name => 'disabled_transactions') do
+      self.class.inspect
+    end
+        
+    assert_match(/disabled_transactions/, browser_monitoring_transaction_name,
+                 "should name transaction when transaction tracing disabled")
+  ensure
+    @sampler.enable
+  end
+  
+  
   def test_browser_monitoring_start_time
-    Thread.current[:newrelic_start_time] = Time.at(100)
+    mock = mock('transaction info')
+    
+    NewRelic::Agent::TransactionInfo.set(mock)
+    
+    mock.stubs(:start_time).returns(Time.at(100))
+    mock.stubs(:guid).returns('ABC')
     assert_equal(Time.at(100), browser_monitoring_start_time, "should take the value from the thread local")
   end
 
@@ -205,22 +233,24 @@ var e=document.createElement("script");'
   end
 
   def test_browser_monitoring_queue_time_nil
-    Thread.current[:newrelic_queue_time] = nil
     assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is no queue time')
   end
 
   def test_browser_monitoring_queue_time_zero
-    Thread.current[:newrelic_queue_time] = 0.0
+    frame = Thread.current[:last_metric_frame] = mock('metric frame')
+    frame.expects(:queue_time).returns(0.0)
     assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is zero queue time')
   end
 
   def test_browser_monitoring_queue_time_ducks
-    Thread.current[:newrelic_queue_time] = 'a duck'
+    frame = Thread.current[:last_metric_frame] = mock('metric frame')
+    frame.expects(:queue_time).returns('a duck')
     assert_equal(0.0, browser_monitoring_queue_time, 'should return zero when there is an incorrect queue time')
   end
 
   def test_browser_monitoring_queue_time_nonzero
-    Thread.current[:newrelic_queue_time] = 3.00002
+    frame = Thread.current[:last_metric_frame] = mock('metric frame')
+    frame.expects(:queue_time).returns(3.00002)
     assert_equal(3000, browser_monitoring_queue_time, 'should return a rounded time')
   end
 
@@ -229,16 +259,31 @@ var e=document.createElement("script");'
     license_key = ''
     application_id = 1
 
-    Thread.current[:newrelic_queue_time] = nil
     # mocking this because JRuby thinks that Time.now - Time.now
     # always takes at least 1ms
     self.expects(:browser_monitoring_app_time).returns(0)
-    Thread.current[:newrelic_most_recent_transaction] = 'most recent transaction'
-
-    self.expects(:obfuscate).with('most recent transaction').returns('most recent transaction')
-
-    value = footer_js_string(beacon, license_key, application_id)
-    assert_equal("<script type=\"text/javascript\">if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nvar e=document.createElement(\"script\");\ne.type=\"text/javascript\";e.async=true;e.src=\"this_is_my_file\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\nNREUMQ.push([\"nrf2\",\"\",\"\",1,\"most recent transaction\",0,0,new Date().getTime()])</script>", value, "should return the javascript given some default values")
+    frame = Thread.current[:last_metric_frame] = mock('metric frame')
+    user_attributes = {:user => "user", :account => "account", :product => "product"}
+    frame.expects(:user_attributes).returns(user_attributes).at_least_once
+    frame.expects(:queue_time).returns(0)
+
+    sample = mock('transaction info')
+    NewRelic::Agent::TransactionInfo.set(sample)
+    
+    sample.stubs(:start_time).returns(Time.at(100))
+    sample.stubs(:guid).returns('ABC')
+    sample.stubs(:transaction_name).returns('most recent transaction')
+    sample.stubs(:include_guid?).returns(true)
+    sample.stubs(:duration).returns(12.0)
+    sample.stubs(:token).returns('0123456789ABCDEF')
+    
+    self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'most recent transaction').returns('most recent transaction')
+    self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'user').returns('user')
+    self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'account').returns('account')
+    self.expects(:obfuscate).with(NewRelic::Agent.instance.beacon_configuration, 'product').returns('product')
+
+    value = footer_js_string(NewRelic::Agent.instance.beacon_configuration, beacon, license_key, application_id)
+    assert_equal("<script type=\"text/javascript\">if (!NREUMQ.f) { NREUMQ.f=function() {\nNREUMQ.push([\"load\",new Date().getTime()]);\nvar e=document.createElement(\"script\");\ne.type=\"text/javascript\";e.async=true;e.src=\"this_is_my_file\";\ndocument.body.appendChild(e);\nif(NREUMQ.a)NREUMQ.a();\n};\nNREUMQ.a=window.onload;window.onload=NREUMQ.f;\n};\nNREUMQ.push([\"nrfj\",\"\",\"\",1,\"most recent transaction\",0,0,new Date().getTime(),\"ABC\",\"0123456789ABCDEF\",\"user\",\"account\",\"product\"])</script>", value, "should return the javascript given some default values")
   end
 
   def test_html_safe_if_needed_unsafed
@@ -264,7 +309,7 @@ var e=document.createElement("script");'
     text = 'a happy piece of small text'
     key = (1..40).to_a
     NewRelic::Agent.instance.beacon_configuration.expects(:license_bytes).returns(key)
-    output = obfuscate(text)
+    output = obfuscate(NewRelic::Agent.instance.beacon_configuration, text)
     assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1', output, "should output obfuscated text")
   end
 
@@ -272,7 +317,7 @@ var e=document.createElement("script");'
     text = 'a happy piece of small text' * 5
     key = (1..40).to_a
     NewRelic::Agent.instance.beacon_configuration.expects(:license_bytes).returns(key)
-    output = obfuscate(text)
+    output = obfuscate(NewRelic::Agent.instance.beacon_configuration, text)
     assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1YyNsZHZ3cSl6YmluZCJsYiV1amllZit4aHl2YiRtZ3d4cCp7ZWhiZyNrYyZ0ZWhmZyx5ZHp3ZSVuZnh5cyt8ZGRhZiRqYCd7ZGtnYC11Z3twZCZvaXl6cix9aGdgYSVpYSh6Z2pgYSF2Znxx', output, "should output obfuscated text")
   end
 end

data/test/new_relic/agent/database_test.rb

@@ -74,7 +74,7 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
   end  
   
   def test_handle_exception_in_explain
-    fake_error = Exception.new('a message')
+    fake_error = StandardError.new('a message')
     NewRelic::Control.instance.log.expects(:error).with('Error getting query plan: a message')
     # backtrace can be basically any string, just should get logged
     NewRelic::Control.instance.log.expects(:debug).with(instance_of(String))
@@ -83,59 +83,46 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
       raise(fake_error)
     end
   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_sql_normalization
-    # basic statement
-    assert_equal "INSERT INTO X values(?,?, ? , ?)",
-    NewRelic::Agent::Database.obfuscate_sql("INSERT INTO X values('test',0, 1 , 2)")
-
-    # escaped literals
-    assert_equal "INSERT INTO X values(?, ?,?, ? , ?)",
-    NewRelic::Agent::Database.obfuscate_sql("INSERT INTO X values('', 'jim''s ssn',0, 1 , 'jim''s son''s son')")
-    
-    # multiple string literals
-    assert_equal "INSERT INTO X values(?,?,?, ? , ?)",
-    NewRelic::Agent::Database.obfuscate_sql("INSERT INTO X values('jim''s ssn','x',0, 1 , 2)")
-    
-    # empty string literal
-    # NOTE: the empty string literal resolves to empty string, which for our purposes is acceptable
-    assert_equal "INSERT INTO X values(?,?,?, ? , ?)",
-    NewRelic::Agent::Database.obfuscate_sql("INSERT INTO X values('','x',0, 1 , 2)")
-    
-    # try a select statement
-    assert_equal "select * from table where name=? and ssn=?",
-    NewRelic::Agent::Database.obfuscate_sql("select * from table where name='jim gochee' and ssn=0012211223")
-    
-    # number literals embedded in sql - oh well
-    assert_equal "select * from table_? where name=? and ssn=?",
-    NewRelic::Agent::Database.obfuscate_sql("select * from table_007 where name='jim gochee' and ssn=0012211223")
+  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_sql_normalization__single_quotes
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql("INSERT 'this isn''t a real value' into table")
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT '"' into table])
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT ' "some text" \" ' into table])
-    #    could not get this one licked.  no biggie
-    #    assert_equal "INSERT ? into table",
-    #    @agent.send(:default_sql_obfuscator, %q[INSERT '\'' into table])
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT ''' ' into table])
+  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_sql_normalization__double_quotes
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT "this isn't a real value" into table])
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT "'" into table])
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT " \" " into table])
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT " 'some text' " into table])
+  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_sql_obfuscation_filters
     NewRelic::Agent::Database.set_sql_obfuscator(:replace) do |string|
       "1" + string

data/test/new_relic/agent/error_collector_test.rb

@@ -3,12 +3,12 @@ ENV['SKIP_RAILS'] = 'true'
 require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
 
 class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
-
   def setup
     super
     @error_collector = NewRelic::Agent::ErrorCollector.new
     @error_collector.stubs(:enabled).returns(true)
   end
+  
   def test_empty
     @error_collector.harvest_errors([])
     @error_collector.notice_error(nil, :metric=> 'path', :request_params => {:x => 'y'})
@@ -26,10 +26,10 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     assert_equal '', err.params[:request_referer]
     assert_equal 'path', err.path
     assert_equal 'Error', err.exception_class
-
   end
+  
   def test_simple
-    @error_collector.notice_error(Exception.new("message"), :uri => '/myurl/', :metric => 'path', :referer => 'test_referer', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :uri => '/myurl/', :metric => 'path', :referer => 'test_referer', :request_params => {:x => 'y'})
 
     old_errors = []
     errors = @error_collector.harvest_errors(old_errors)
@@ -42,7 +42,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     assert err.params[:request_uri] == '/myurl/'
     assert err.params[:request_referer] == "test_referer"
     assert err.path == 'path'
-    assert err.exception_class == 'Exception'
+    assert err.exception_class == 'StandardError'
 
     # the collector should now return an empty array since nothing
     # has been added since its last harvest
@@ -53,7 +53,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   def test_long_message
     #yes, times 500. it's a 5000 byte string. Assuming strings are
     #still 1 byte / char.
-    @error_collector.notice_error(Exception.new("1234567890" * 500), :uri => '/myurl/', :metric => 'path', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("1234567890" * 500), :uri => '/myurl/', :metric => 'path', :request_params => {:x => 'y'})
 
     old_errors = []
     errors = @error_collector.harvest_errors(old_errors)
@@ -66,13 +66,13 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
   end
 
   def test_collect_failover
-    @error_collector.notice_error(Exception.new("message"), :metric => 'first', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :metric => 'first', :request_params => {:x => 'y'})
 
     errors = @error_collector.harvest_errors([])
 
-    @error_collector.notice_error(Exception.new("message"), :metric => 'second', :request_params => {:x => 'y'})
-    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'})
-    @error_collector.notice_error(Exception.new("message"), :metric => 'last', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :metric => 'second', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :metric => 'last', :request_params => {:x => 'y'})
 
     errors = @error_collector.harvest_errors(errors)
 
@@ -80,8 +80,8 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     assert_equal 'first', errors.first.path
     assert_equal 'last', errors.last.path
 
-    @error_collector.notice_error(Exception.new("message"), :metric => 'first', :request_params => {:x => 'y'})
-    @error_collector.notice_error(Exception.new("message"), :metric => 'last', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :metric => 'first', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :metric => 'last', :request_params => {:x => 'y'})
 
     errors = @error_collector.harvest_errors(nil)
     assert_equal 2, errors.length
@@ -95,7 +95,7 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
 
     silence_stream(::STDOUT) do
      (max_q_length + 5).times do |n|
-        @error_collector.notice_error(Exception.new("exception #{n}"), :metric => "path", :request_params => {:x => n})
+        @error_collector.notice_error(StandardError.new("exception #{n}"), :metric => "path", :request_params => {:x => n})
       end
     end
 
@@ -120,13 +120,13 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     [1.1, '1.1'],
     ['hi', 'hi'],
     [:hi, :hi],
-    [Exception.new("test"), "#<Exception>"],
+    [StandardError.new("test"), "#<StandardError>"],
     [TestClass.new, "#<NewRelic::Agent::ErrorCollectorTest::TestClass>"]
     ]
 
 
     types.each do |test|
-      @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => test[0]})
+      @error_collector.notice_error(StandardError.new("message"), :metric => 'path', :request_params => {:x => test[0]})
 
       assert_equal test[1], @error_collector.harvest_errors([])[0].params[:request_params][:x]
     end
@@ -148,13 +148,30 @@ class NewRelic::Agent::ErrorCollectorTest < Test::Unit::TestCase
     @error_collector.ignore_error_filter &wrapped_filter_proc
         
     @error_collector.notice_error(IOError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
-    @error_collector.notice_error(Exception.new("message"), :metric => 'path', :request_params => {:x => 'y'})
+    @error_collector.notice_error(StandardError.new("message"), :metric => 'path', :request_params => {:x => 'y'})
     
     errors = @error_collector.harvest_errors([])
 
     assert_equal 1, errors.length
   end
 
+  def test_obfuscates_error_messages_when_high_security_is_set
+    NewRelic::Control.instance['high_security'] = true
+    
+    @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo = 'bar'"))
+    @error_collector.notice_error(StandardError.new("YO SQL BAD: serect * flom test where foo in (1,2,3,4,5)"))
+
+    old_errors = []
+    errors = @error_collector.harvest_errors([])
+
+    assert_equal('YO SQL BAD: serect * flom test where foo = ?',
+                 errors[0].message)
+    assert_equal('YO SQL BAD: serect * flom test where foo in (?,?,?,?,?)',
+                 errors[1].message)
+    
+    NewRelic::Control.instance['high_security'] = nil
+  end
+
   private
   
   def wrapped_filter_proc