dolores_rpm 3.2.0.2

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -0,0 +1,278 @@
+ENV['SKIP_RAILS'] = 'true'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+require "new_relic/agent/browser_monitoring"
+
+class NewRelic::Agent::BrowserMonitoringTest < Test::Unit::TestCase
+  include NewRelic::Agent::BrowserMonitoring
+
+  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"})
+    end
+    Thread.current[:newrelic_most_recent_transaction] = "MyCoolTransaction"
+  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_timing_header_with_no_beacon_configuration
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns( nil)
+    header = browser_timing_header
+    assert_equal "", header
+  end
+
+  def test_browser_timing_header
+    header = browser_timing_header
+    assert_equal "<script type=\"text/javascript\">var NREUMQ=NREUMQ||[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>", header
+  end
+
+  def test_browser_timing_header_with_rum_enabled_not_specified
+    NewRelic::Agent.instance.expects(:beacon_configuration).at_least_once.returns( NewRelic::Agent::BeaconConfiguration.new({"browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
+    header = browser_timing_header
+    assert_equal "<script type=\"text/javascript\">var NREUMQ=NREUMQ||[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>", header
+  end
+
+  def test_browser_timing_header_with_rum_enabled_false
+    NewRelic::Agent.instance.expects(:beacon_configuration).twice.returns( NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => false, "browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
+    header = browser_timing_header
+    assert_equal "", header
+  end
+
+  def test_browser_timing_header_disable_all_tracing
+    header = nil
+    NewRelic::Agent.disable_all_tracing do
+      header = browser_timing_header
+    end
+    assert_equal "", header
+  end
+
+  def test_browser_timing_header_disable_transaction_tracing
+    header = nil
+    NewRelic::Agent.disable_transaction_tracing do
+      header = browser_timing_header
+    end
+    assert_equal "", header
+  end
+
+  def test_browser_timing_footer
+    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()]);
+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"}))
+    footer = browser_timing_footer
+    assert_equal "", footer
+  end
+
+  def test_browser_timing_footer_with_no_browser_key_rum_disabled
+    browser_timing_header
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns( NewRelic::Agent::BeaconConfiguration.new({"rum.enabled" => false, "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file"}))
+    footer = browser_timing_footer
+    assert_equal "", footer
+  end
+
+  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}
+    config =  NewRelic::Agent::BeaconConfiguration.new({"browser_key" => "browserKey", "application_id" => "apId", "beacon"=>"beacon", "episodes_url"=>"this_is_my_file", "license_bytes" => license_bytes})
+    config.expects(:license_bytes).returns(license_bytes).at_least_once
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns(config).at_least_once
+    footer = browser_timing_footer
+    beginning_snippet = '<script type="text/javascript">if (!NREUMQ.f) { NREUMQ.f=function() {
+NREUMQ.push(["load",new Date().getTime()]);
+var e=document.createElement("script");'
+    ending_snippet = "])</script>"
+    assert(footer.include?(beginning_snippet), "expected footer to include beginning snippet: #{beginning_snippet}, but was #{footer}")
+    assert(footer.include?(ending_snippet), "expected footer to include ending snippet: #{ending_snippet}, but was #{footer}")
+  end
+
+  def test_browser_timing_footer_with_no_beacon_configuration
+    browser_timing_header
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns( nil)
+    footer = browser_timing_footer
+    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
+    footer = nil
+    NewRelic::Agent.disable_all_tracing do
+      footer = browser_timing_footer
+    end
+    assert_equal "", footer
+  end
+
+  def test_browser_timing_footer_disable_transaction_tracing
+    browser_timing_header
+    footer = nil
+    NewRelic::Agent.disable_transaction_tracing do
+      footer = browser_timing_footer
+    end
+    assert_equal "", footer
+  end
+
+  def test_browser_timing_footer_browser_monitoring_key_missing
+    fake_config = mock('beacon configuration')
+    NewRelic::Agent.instance.expects(:beacon_configuration).returns(fake_config)
+    fake_config.expects(:nil?).returns(false)
+    fake_config.expects(:rum_enabled).returns(true)
+    fake_config.expects(:browser_monitoring_key).returns(nil)
+    self.expects(:generate_footer_js).never
+    assert_equal('', browser_timing_footer, "should not return a footer when there is no key")
+  end
+
+  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")
+  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')
+  end
+
+  def test_browser_monitoring_transaction_name_basic
+    Thread.current[:newrelic_most_recent_transaction] = '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] = ''
+    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")
+  end
+
+  def test_browser_monitoring_start_time
+    Thread.current[:newrelic_start_time] = Time.at(100)
+    assert_equal(Time.at(100), browser_monitoring_start_time, "should take the value from the thread local")
+  end
+
+  def test_clamp_to_positive
+    assert_equal(0.0, clamp_to_positive(-1), "should clamp a negative value to zero")
+    assert_equal(1232, clamp_to_positive(1232), "should pass through the value when it is positive")
+    assert_equal(0, clamp_to_positive(0), "should not mess with zero when passing it through")
+  end
+
+  def test_browser_monitoring_app_time_nonzero
+    start = Time.now
+    self.expects(:browser_monitoring_start_time).returns(start - 1)
+    Time.expects(:now).returns(start)
+    assert_equal(1000, browser_monitoring_app_time, 'should return a rounded time')
+  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
+    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'
+    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
+    assert_equal(3000, browser_monitoring_queue_time, 'should return a rounded time')
+  end
+
+  def test_footer_js_string_basic
+    beacon = ''
+    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")
+  end
+
+  def test_html_safe_if_needed_unsafed
+    string = mock('string')
+    # here to handle 1.9 encoding - we stub this out because it should
+    # be handled automatically and is outside the scope of this test
+    string.stubs(:respond_to?).with(:encoding).returns(false)
+    string.expects(:respond_to?).with(:html_safe).returns(false)
+    assert_equal(string, html_safe_if_needed(string))
+  end
+
+  def test_html_safe_if_needed_safed
+    string = mock('string')
+    string.expects(:respond_to?).with(:html_safe).returns(true)
+    string.expects(:html_safe).returns(string)
+    # here to handle 1.9 encoding - we stub this out because it should
+    # be handled automatically and is outside the scope of this test
+    string.stubs(:respond_to?).with(:encoding).returns(false)
+    assert_equal(string, html_safe_if_needed(string))
+  end
+
+  def test_obfuscate_basic
+    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)
+    assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1', output, "should output obfuscated text")
+  end
+
+  def test_obfuscate_long_string
+    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)
+    assert_equal('YCJrZXV2fih5Y25vaCFtZSR2a2ZkZSp/aXV1YyNsZHZ3cSl6YmluZCJsYiV1amllZit4aHl2YiRtZ3d4cCp7ZWhiZyNrYyZ0ZWhmZyx5ZHp3ZSVuZnh5cyt8ZGRhZiRqYCd7ZGtnYC11Z3twZCZvaXl6cix9aGdgYSVpYSh6Z2pgYSF2Znxx', output, "should output obfuscated text")
+  end
+end

data/test/new_relic/agent/busy_calculator_test.rb

@@ -0,0 +1,81 @@
+# Run faster standalone
+ENV['SKIP_RAILS'] = 'true'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper'))
+class NewRelic::Agent::BusyCalculatorTest < Test::Unit::TestCase
+  attr_reader :now
+  def setup
+    @now = Time.now.to_f
+    NewRelic::Agent::BusyCalculator.reset
+    @instance_busy = NewRelic::MethodTraceStats.new
+    NewRelic::Agent::BusyCalculator.stubs(:instance_busy_stats).returns(@instance_busy)
+  end
+
+  def test_normal
+    # start the timewindow 10 seconds ago
+    # start a request at 10 seconds, 5 seconds long
+    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 5.0)
+    assert_equal 5, NewRelic::Agent::BusyCalculator.accumulator
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, @instance_busy.call_count
+    assert_in_delta 0.50, @instance_busy.total_call_time, 0.05
+  end
+  def test_split
+    # start the timewindow 10 seconds ago
+    # start a request at 5 seconds, don't finish
+    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 5.0)
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, @instance_busy.call_count, @instance_busy
+    assert_in_delta 0.50, @instance_busy.total_call_time, 0.05
+  end
+  def test_reentrancy
+    # start the timewindow 10 seconds ago
+    # start a request at 5 seconds, don't finish, but make two more
+    # complete calls, which should be ignored.
+    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 5.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 4.5)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 4.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 3.5)
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 3.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 2.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 1.0)
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, @instance_busy.call_count
+    assert_in_delta 0.50, @instance_busy.total_call_time, 0.05
+  end
+  def test_concurrency
+    # start the timewindow 10 seconds ago
+    # start a request at 10 seconds, 5 seconds long
+    NewRelic::Agent::BusyCalculator.stubs(:harvest_start).returns(now - 10.0)
+    NewRelic::Agent::BusyCalculator.dispatcher_start(now - 8.0)
+    worker = Thread.new do
+      # Get busy for 6 - 3 seconds
+      NewRelic::Agent::BusyCalculator.dispatcher_start(now - 6.0)
+      NewRelic::Agent::BusyCalculator.dispatcher_start(now - 5.0)
+      NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 4.0)
+      NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 3.0)
+    end
+    # Get busy for 8 - 2 seconds
+    NewRelic::Agent::BusyCalculator.dispatcher_finish(now - 2.0)
+    worker.join
+    NewRelic::Agent::BusyCalculator.harvest_busy
+
+    assert_equal 1, @instance_busy.call_count
+    # 3 + 6 = 9, or 90%
+    assert_in_delta 0.90, @instance_busy.total_call_time, 0.1
+
+  end
+  def test_dont_ignore_zero_counts
+    assert_equal 0, @instance_busy.call_count, "Problem with test--instance busy not starting off at zero."
+    NewRelic::Agent::BusyCalculator.harvest_busy
+    NewRelic::Agent::BusyCalculator.harvest_busy
+    NewRelic::Agent::BusyCalculator.harvest_busy
+    assert_equal 3, @instance_busy.call_count
+  end
+end

data/test/new_relic/agent/database_test.rb

@@ -0,0 +1,162 @@
+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_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_handle_exception_in_explain
+    fake_error = Exception.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))
+    
+    NewRelic::Agent::Database.handle_exception_in_explain do
+      raise(fake_error)
+    end
+  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")
+  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])
+  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])
+  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
+end