newrelic_rpm 3.1.2 → 3.2.0.beta1

data/test/new_relic/agent/agent/start_test.rb

@@ -51,91 +51,6 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
     log_app_names
   end
 
-  def test_apdex_f
-    NewRelic::Control.instance.expects(:apdex_t).returns(10)
-    assert_equal 40, apdex_f
-  end
-
-  def test_apdex_f_threshold_positive
-    self.expects(:sampler_config).returns({'transaction_threshold' => 'apdex_f'})
-    assert apdex_f_threshold?
-  end
-
-  def test_apdex_f_threshold_negative
-    self.expects(:sampler_config).returns({'transaction_threshold' => 'WHEE'})
-    assert !apdex_f_threshold?
-  end
-
-  def test_set_sql_recording_default
-    self.expects(:sampler_config).returns({})
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :obfuscated, @record_sql, " should default to :obfuscated, was #{@record_sql}"
-  end
-
-  def test_set_sql_recording_off
-    self.expects(:sampler_config).returns({'record_sql' => 'off'})
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
-  end
-
-  def test_set_sql_recording_none
-    self.expects(:sampler_config).returns({'record_sql' => 'none'})
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
-  end
-
-  def test_set_sql_recording_raw
-    self.expects(:sampler_config).returns({'record_sql' => 'raw'})
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :raw, @record_sql, "should be set to :raw, was #{@record_sql}"
-  end
-
-  def test_set_sql_recording_falsy
-    self.expects(:sampler_config).returns({'record_sql' => false})
-    self.expects(:log_sql_transmission_warning?)
-    set_sql_recording!
-    assert_equal :off, @record_sql, "should be set to :off, was #{@record_sql}"
-  end
-
-  def test_log_sql_transmission_warning_negative
-    log = mocked_log
-    @record_sql = :obfuscated
-    log.expects(:warn).never
-    log_sql_transmission_warning?
-  end
-
-  def test_log_sql_transmission_warning_positive
-    log = mocked_log
-    @record_sql = :raw
-    log.expects(:send).with(:warn, 'Agent is configured to send raw SQL to the service')
-    log_sql_transmission_warning?
-  end
-
-  def test_sampler_config
-    control = mocked_control
-    control.expects(:fetch).with('transaction_tracer', {})
-    sampler_config
-  end
-
-  def test_config_transaction_tracer
-    fake_sampler_config = mock('sampler config')
-    self.expects(:sampler_config).times(5).returns(fake_sampler_config)
-    fake_sampler_config.expects(:fetch).with('enabled', true)
-    fake_sampler_config.expects(:fetch).with('random_sample', false)
-    fake_sampler_config.expects(:fetch).with('explain_threshold', 0.5)
-    fake_sampler_config.expects(:fetch).with('explain_enabled', true)
-    self.expects(:set_sql_recording!)
-
-    fake_sampler_config.expects(:fetch).with('transaction_threshold', 2.0)
-    self.expects(:apdex_f_threshold?).returns(true)
-    self.expects(:apdex_f)
-    config_transaction_tracer
-  end
-
   def test_check_config_and_start_agent_disabled
     self.expects(:monitoring?).returns(false)
     check_config_and_start_agent

data/test/new_relic/agent/agent/start_worker_thread_test.rb

@@ -8,6 +8,7 @@ class NewRelic::Agent::Agent::StartWorkerThreadTest < Test::Unit::TestCase
     self.expects(:connect).with('connection_options')
     @connected = true
     self.expects(:check_transaction_sampler_status)
+    self.expects(:check_sql_sampler_status)    
     self.expects(:log_worker_loop_start)
     self.expects(:create_and_run_worker_loop)
     deferred_work!('connection_options')

data/test/new_relic/agent/agent_test.rb

@@ -129,79 +129,6 @@ module NewRelic
         @agent.merge_data_from([{}, [], []])
       end
 
-      def test_sql_normalization
-
-        # basic statement
-        assert_equal "INSERT INTO X values(?,?, ? , ?)",
-        @agent.send(:default_sql_obfuscator, "INSERT INTO X values('test',0, 1 , 2)")
-
-        # escaped literals
-        assert_equal "INSERT INTO X values(?, ?,?, ? , ?)",
-        @agent.send(:default_sql_obfuscator, "INSERT INTO X values('', 'jim''s ssn',0, 1 , 'jim''s son''s son')")
-
-        # multiple string literals
-        assert_equal "INSERT INTO X values(?,?,?, ? , ?)",
-        @agent.send(:default_sql_obfuscator, "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(?,?,?, ? , ?)",
-        @agent.send(:default_sql_obfuscator, "INSERT INTO X values('','x',0, 1 , 2)")
-
-        # try a select statement
-        assert_equal "select * from table where name=? and ssn=?",
-        @agent.send(:default_sql_obfuscator, "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=?",
-        @agent.send(:default_sql_obfuscator, "select * from table_007 where name='jim gochee' and ssn=0012211223")
-      end
-
-      def test_sql_normalization__single_quotes
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, "INSERT 'this isn''t a real value' into table")
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, %q[INSERT '"' into table])
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, %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",
-        @agent.send(:default_sql_obfuscator, %q[INSERT ''' ' into table])
-      end
-      def test_sql_normalization__double_quotes
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, %q[INSERT "this isn't a real value" into table])
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, %q[INSERT "'" into table])
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, %q[INSERT " \" " into table])
-        assert_equal "INSERT ? into table",
-        @agent.send(:default_sql_obfuscator, %q[INSERT " 'some text' " into table])
-      end
-      def test_sql_obfuscation_filters
-        @agent.set_sql_obfuscator(:replace) do |string|
-          "1" + string
-        end
-
-        sql = "SELECT * FROM TABLE 123 'jim'"
-
-        assert_equal "1" + sql, @agent.obfuscator.call(sql)
-
-        @agent.set_sql_obfuscator(:before) do |string|
-          "2" + string
-        end
-
-        assert_equal "12" + sql, @agent.obfuscator.call(sql)
-
-        @agent.set_sql_obfuscator(:after) do |string|
-          string + "3"
-        end
-
-        assert_equal "12" + sql + "3", @agent.obfuscator.call(sql)
-      end
-
       def test_should_not_log_log_file_location_if_no_log_file
         NewRelic::Control.instance.stubs(:log_file).returns('/vasrkjn4b3b4')
         @agent.expects(:log).never

data/test/new_relic/agent/browser_monitoring_test.rb

@@ -100,7 +100,7 @@ var e=document.createElement("script");'
     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)
+    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() {

data/test/new_relic/agent/database_test.rb

@@ -0,0 +1,160 @@
+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)
+  end
+end

data/test/new_relic/agent/instrumentation/metric_frame/pop_test.rb

@@ -5,10 +5,12 @@ class NewRelic::Agent::Instrumentation::MetricFrame::PopTest < Test::Unit::TestC
 
   attr_reader :agent
   attr_reader :transaction_sampler
+  attr_reader :sql_sampler
 
   def setup
     @agent = mock('agent')
     @transaction_sampler = mock('transaction sampler')
+    @sql_sampler = mock('sql sampler')
   end
 
   def teardown
@@ -39,6 +41,7 @@ class NewRelic::Agent::Instrumentation::MetricFrame::PopTest < Test::Unit::TestC
 
   def test_notice_scope_empty
     transaction_sampler.expects(:notice_scope_empty)
+    sql_sampler.expects(:notice_scope_empty)
     notice_scope_empty
   end
 

data/test/new_relic/agent/memcache_instrumentation_test.rb

@@ -2,10 +2,10 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','..','test_helper
 
 memcached_ready = false
 classes = {
-#   'memcache' => 'MemCache'
-#   'dalli' => 'Dalli::Client'
-#   'memcached' => 'Memcached'
-  'spymemcached' => 'Spymemcached'
+#   'memcache' => 'MemCache',
+#   'dalli' => 'Dalli::Client',
+  'memcached' => 'Memcached'
+#   'spymemcached' => 'Spymemcached'
 }
 begin
   TCPSocket.new('localhost', 11211)
@@ -25,7 +25,7 @@ end
 
 class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
   include NewRelic::Agent::Instrumentation::ControllerInstrumentation
-
+  
   def setup
     NewRelic::Agent.manual_start
     @engine = NewRelic::Agent.instance.stats_engine
@@ -43,7 +43,7 @@ class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
   end
   
   def teardown
-    if MEMCACHED_CLASS.name == 'Memecached'
+    if MEMCACHED_CLASS.name == 'Memcached'
       @cache.flush
     elsif MEMCACHED_CLASS.name == 'Spymemcached'
       @cache.flush
@@ -73,7 +73,7 @@ class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
     commands.each do |method|
       if @cache.class.method_defined?(method)
         _call_test_method_in_web_transaction(method)
-        compare_metrics ["MemCache/#{method}", "MemCache/allWeb", "MemCache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"],
+        compare_metrics ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"],
         @engine.metrics.select{|m| m =~ /^memcache.*/i}
       end
     end
@@ -83,7 +83,7 @@ class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
     %w[delete].each do |method|
       if @cache.class.method_defined?(method)
         _call_test_method_in_web_transaction(method)
-        expected_metrics = ["MemCache/#{method}", "MemCache/allWeb", "MemCache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
+        expected_metrics = ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
         compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
       end
     end
@@ -91,7 +91,7 @@ class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
     %w[set add].each do |method|
       @cache.delete(@key) rescue nil
       if @cache.class.method_defined?(method)
-        expected_metrics = ["MemCache/#{method}", "MemCache/allWeb", "MemCache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
+        expected_metrics = ["Memcache/#{method}", "Memcache/allWeb", "Memcache/#{method}:Controller/NewRelic::Agent::MemcacheInstrumentationTest/action"]
         _call_test_method_in_web_transaction(method, 'value')
         compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
       end
@@ -104,7 +104,7 @@ class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
     commands.each do |method|    
       if @cache.class.method_defined?(method)
         _call_test_method_in_background_task(method)
-        compare_metrics ["MemCache/#{method}", "MemCache/allOther", "MemCache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"],
+        compare_metrics ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"],
         @engine.metrics.select{|m| m =~ /^memcache.*/i}
       end
     end
@@ -112,7 +112,7 @@ class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
 
   def test_writes__background
     %w[delete].each do |method|
-      expected_metrics = ["MemCache/#{method}", "MemCache/allOther", "MemCache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+      expected_metrics = ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
       if @cache.class.method_defined?(method)
         _call_test_method_in_background_task(method)
         compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
@@ -121,7 +121,7 @@ class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
 
     %w[set add].each do |method|
       @cache.delete(@key) rescue nil
-      expected_metrics = ["MemCache/#{method}", "MemCache/allOther", "MemCache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+      expected_metrics = ["Memcache/#{method}", "Memcache/allOther", "Memcache/#{method}:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
       if @cache.class.method_defined?(method)
         _call_test_method_in_background_task(method, 'value')
         compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
@@ -130,7 +130,7 @@ class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
   end
 
   def test_handles_cas
-    expected_metrics = ["MemCache/cas", "MemCache/allOther", "MemCache/cas:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
+    expected_metrics = ["Memcache/cas", "Memcache/allOther", "Memcache/cas:OtherTransaction/Background/NewRelic::Agent::MemcacheInstrumentationTest/bg_task"]
     if @cache.class.method_defined?(:cas)
       @engine.clear_stats
       perform_action_with_newrelic_trace(:name => 'bg_task', :category => :task) do
@@ -139,6 +139,5 @@ class NewRelic::Agent::MemcacheInstrumentationTest < Test::Unit::TestCase
       compare_metrics expected_metrics, @engine.metrics.select{|m| m =~ /^memcache.*/i}
       assert_equal 3, @cache.get(@key)
     end    
-  end
-
+  end  
 end if memcached_ready