newrelic_rpm 3.1.1 → 3.1.2.beta1

data/lib/new_relic/transaction_sample/segment.rb

@@ -176,7 +176,7 @@ module NewRelic
       end
 
       # Perform this in the runtime environment of a managed
-      # application, to explain the sql statement(s) executed within a
+      # application, to explain the sql statement executed within a
       # segment of a transaction sample. Returns an array of
       # explanations (which is an array rows consisting of an array of
       # strings for each column returned by the the explain query)
@@ -185,24 +185,23 @@ module NewRelic
       # transaction in a report period, selected for shipment to New
       # Relic
       def explain_sql
+        return @explain_sql if @explain_sql
         sql = params[:sql]
         return nil unless sql && params[:connection_config]
-        statements = sql.split(";\n")
-        statements.map! do |statement|
-          # a small sleep to make sure we yield back to the parent
-          # thread regularly, if there are many explains
-          sleep(0.0001)
-          explain_statement(statement, params[:connection_config])
-        end
-        statements.compact!
-        statements
+        statement = sql.split(";\n")[0] # only explain the first
+        @explain_sql = explain_statement(statement, params[:connection_config]) || []
+        @explain_sql
       end
 
       def explain_statement(statement, config)
         if is_select?(statement)
           handle_exception_in_explain do
             connection = NewRelic::TransactionSample.get_connection(config)
-            process_resultset(connection.execute("EXPLAIN #{statement}")) if connection
+            plan = nil
+            if connection
+              plan = process_resultset(connection.execute("EXPLAIN #{statement}"))
+            end
+            return plan
           end
         end
       end
@@ -218,29 +217,36 @@ module NewRelic
         # The resultset type varies for different drivers.  Only thing you can count on is
         # that it implements each.  Also: can't use select_rows because the native postgres
         # driver doesn't know that method.
-
-        if items.respond_to?(:each)
-          rows = []
+        
+        headers = values = []
+        if items.respond_to?(:each_hash)
+          items.each_hash do |row|
+            headers = row.keys
+            values = headers.map{|h| row[h] }
+          end
+        elsif items.respond_to?(:each)
           items.each do |row|
-            columns = []
-            row.each do |column|
-              columns << column.to_s
+            if row.kind_of?(Hash)
+              headers = row.keys
+              values = headers.map{|h| row[h] }
+            else
+              values = row
             end
-            rows << columns
           end
-          rows
         else
-          [items]
+          values = [items]
         end
+        
+        headers = nil if headers.empty?
+        [headers, values]
       end
 
-
       def handle_exception_in_explain
         yield
       rescue Exception => e
         begin
           # guarantees no throw from explain_sql
-          NewRelic::Control.instance.log.error("Error getting explain plan: #{e.message}")
+          NewRelic::Control.instance.log.error("Error getting query plan: #{e.message}")
           NewRelic::Control.instance.log.debug(e.backtrace.join("\n"))
         rescue Exception
           # double exception. throw up your hands

data/lib/new_relic/version.rb

@@ -3,8 +3,8 @@ module NewRelic
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 1
-    TINY  = 1
-    BUILD = nil # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
+    TINY  = 2
+    BUILD = 'beta1' # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end
 

data/newrelic_rpm.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{newrelic_rpm}
-  s.version = "3.1.1"
+  s.version = "3.1.2.beta1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bill Kayser", "Jon Guymon", "Justin George", "Darin Swanson"]
-  s.date = %q{2011-07-28}
+  s.date = %q{2011-08-18}
   s.description = %q{New Relic is a performance management system, developed by New Relic,
 Inc (http://www.newrelic.com).  New Relic provides you with deep
 information about the performance of your web application as it runs
@@ -18,7 +18,7 @@ Gem or plugin, hosted on
 http://github.com/newrelic/rpm/
 }
   s.email = %q{support@newrelic.com}
-  s.executables = ["newrelic_cmd", "newrelic", "mongrel_rpm"]
+  s.executables = ["mongrel_rpm", "newrelic", "newrelic_cmd"]
   s.extra_rdoc_files = [
     "CHANGELOG",
     "LICENSE",
@@ -106,6 +106,7 @@ http://github.com/newrelic/rpm/
     "lib/new_relic/control/server_methods.rb",
     "lib/new_relic/data_serialization.rb",
     "lib/new_relic/delayed_job_injection.rb",
+    "lib/new_relic/language_support.rb",
     "lib/new_relic/local_environment.rb",
     "lib/new_relic/merbtasks.rb",
     "lib/new_relic/metric_data.rb",

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

@@ -190,8 +190,8 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   def test_install_exit_handler_positive
     control = mocked_control
     control.expects(:send_data_on_exit).returns(true)
-    self.expects(:using_rubinius?).returns(false)
-    self.expects(:using_jruby?).returns(false)
+    NewRelic::LanguageSupport.expects(:using_rubinius?).returns(false)
+    NewRelic::LanguageSupport.expects(:using_jruby?).returns(false)
     self.expects(:using_sinatra?).returns(false)
     # we are overriding at_exit above, to immediately return, so we can
     # test the shutdown logic. It's somewhat unfortunate, but we can't
@@ -209,14 +209,14 @@ class NewRelic::Agent::Agent::StartTest < Test::Unit::TestCase
   def test_install_exit_handler_weird_ruby
     control = mocked_control
     control.expects(:send_data_on_exit).times(3).returns(true)
-    self.expects(:using_rubinius?).returns(false)
-    self.expects(:using_jruby?).returns(false)
+    NewRelic::LanguageSupport.expects(:using_rubinius?).returns(false)
+    NewRelic::LanguageSupport.expects(:using_jruby?).returns(false)
     self.expects(:using_sinatra?).returns(true)
     install_exit_handler
-    self.expects(:using_rubinius?).returns(false)
-    self.expects(:using_jruby?).returns(true)
+    NewRelic::LanguageSupport.expects(:using_rubinius?).returns(false)
+    NewRelic::LanguageSupport.expects(:using_jruby?).returns(true)
     install_exit_handler
-    self.expects(:using_rubinius?).returns(true)
+    NewRelic::LanguageSupport.expects(:using_rubinius?).returns(true)
     install_exit_handler
   end
 

data/test/new_relic/agent/agent_test.rb

@@ -33,7 +33,26 @@ module NewRelic
       end
 
       def test_harvest_timeslice_data
-        assert_equal({}, @agent.send(:harvest_timeslice_data), 'should return timeslice data')
+        assert_equal({}, @agent.send(:harvest_timeslice_data),
+                     'should return timeslice data')
+      end
+
+      def test_harvest_timelice_data_should_be_thread_safe
+        2000.times do |i|
+          @agent.stats_engine.stats_hash[i.to_s] = NewRelic::StatsBase.new
+        end
+        
+        harvest = Thread.new do
+          @agent.send(:harvest_timeslice_data)
+        end
+
+        app = Thread.new do
+          @agent.stats_engine.stats_hash["a"] = NewRelic::StatsBase.new
+        end
+        
+        assert_nothing_raised do
+          [app, harvest].each{|t| t.join}
+        end
       end
 
       def test_harvest_errors

data/test/new_relic/agent/instrumentation/active_record_instrumentation_test.rb

@@ -133,7 +133,6 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     check_metric_count("ActiveRecord/ActiveRecordFixtures::Order/create", 1)
   end
 
-
   def test_metric_names_standard
     # fails due to a bug in rails 3 - log does not provide the correct
     # transaction type - it returns 'SQL' instead of 'Foo Create', for example.
@@ -148,11 +147,12 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
       ActiveRecord/ActiveRecordFixtures::Order/create]
 
     if NewRelic::Control.instance.rails_version < '2.1.0'
-      expected += %W[ActiveRecord/save ActiveRecord/ActiveRecordFixtures::Order/save]
+      expected += ['ActiveRecord/save',
+                   'ActiveRecord/ActiveRecordFixtures::Order/save']
     end
 
     assert_calls_metrics(*expected) do
-      m = ActiveRecordFixtures::Order.create :id => 0, :name => 'jeff'
+      m = ActiveRecordFixtures::Order.create :id => 0, :name => 'donkey'
       m = ActiveRecordFixtures::Order.find(m.id)
       m.id = 999
       m.save!
@@ -315,6 +315,7 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
   def test_show_sql
     return if isSqlite?
+    return if isPostgres?
 
     expected_metrics = %W[ActiveRecord/all Database/SQL/show]
 
@@ -368,11 +369,11 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
     sample = sample.prepare_to_send(:record_sql => :raw, :explain_sql => 0.0)
     sql_segment = sample.root_segment.called_segments.first.called_segments.first.called_segments.first
     assert_match /^SELECT /, sql_segment.params[:sql]
-    explanations = sql_segment.params[:explanation]
+    explanations = sql_segment.params[:explain_plan]
     if isMysql? || isPostgres?
       assert_not_nil explanations, "No explains in segment: #{sql_segment}"
-      assert_equal 1, explanations.size,"No explains in segment: #{sql_segment}"
-      assert_equal 1, explanations.first.size
+      assert_equal(2, explanations.size,
+                   "No explains in segment: #{sql_segment}")
     end
   end
 
@@ -389,14 +390,17 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
     sample = sample.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.0)
     segment = sample.root_segment.called_segments.first.called_segments.first.called_segments.first
-    explanations = segment.params[:explanation]
-    assert_not_nil explanations, "No explains in segment: #{segment}"
-    assert_equal 1, explanations.size,"No explains in segment: #{segment}"
-    assert_equal 1, explanations.first.size, "should be one row of explanation"
+    explanation = segment.params[:explain_plan]
+    assert_not_nil explanation, "No explains in segment: #{segment}"
+    assert_equal 2, explanation.size,"No explains in segment: #{segment}"
 
-    row = explanations.first.first
-    assert_equal 10, row.size
-    assert_equal ['1', 'SIMPLE', ActiveRecordFixtures::Order.table_name], row[0..2]
+    assert_equal 10, explanation[0].size
+    ['id', 'select_type', 'table'].each do |c|
+      assert explanation[0].include?(c)
+    end
+    ['1', 'SIMPLE', ActiveRecordFixtures::Order.table_name].each do |c|
+      assert explanation[1].include?(c)
+    end
 
     s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
     assert_equal 1, s.call_count
@@ -416,16 +420,14 @@ class NewRelic::Agent::Instrumentation::ActiveRecordInstrumentationTest < Test::
 
     sample = sample.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.0)
     segment = sample.root_segment.called_segments.first.called_segments.first.called_segments.first
-    explanations = segment.params[:explanation]
+    explanations = segment.params[:explain_plan]
 
     assert_not_nil explanations, "No explains in segment: #{segment}"
     assert_equal 1, explanations.size,"No explains in segment: #{segment}"
     assert_equal 1, explanations.first.size
 
-    assert_equal Array, explanations.class
-    assert_equal Array, explanations[0].class
-    assert_equal Array, explanations[0][0].class
-    assert_match /Seq Scan on test_data/, explanations[0][0].join(";")
+    assert_equal("Explain Plan", explanations[0][0])
+    assert_match /Seq Scan on test_data/, explanations[0][1].join(";")
 
     s = NewRelic::Agent.get_stats("ActiveRecord/ActiveRecordFixtures::Order/find")
     assert_equal 1, s.call_count

data/test/new_relic/agent/instrumentation/instrumentation_test.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'te
 class NewRelic::Agent::Instrumentation::InstrumentationTest < Test::Unit::TestCase
   def test_load_all_instrumentation_files
     # just checking for syntax errors and unguarded code
-    Dir.glob(NEWRELIC_PLUGIN_DIR + '/lib/new_relic/agent/instrumentation/**/*.rb') do |f|
+    Dir.glob('new_relic/agent/instrumentation/**/*.rb') do |f|
       require f
     end
     require 'new_relic/delayed_job_injection'

data/test/new_relic/agent/instrumentation/net_instrumentation_test.rb

@@ -21,7 +21,7 @@ unless ENV['FAST_TESTS']
         http.get('/index.html')
       }
       assert_match /<head>/, res.body
-      assert_equal %w[External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all].sort,
+      assert_equal %w[External/all External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all].sort,
       metrics_without_gc.sort
     end
 
@@ -33,7 +33,7 @@ unless ENV['FAST_TESTS']
         }
         assert_match /<head>/, res.body
       end
-      assert_equal %w[External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all
+      assert_equal %w[External/all External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all
        External/www.google.com/Net::HTTP/GET:OtherTransaction/Background/NewRelic::Agent::Instrumentation::NetInstrumentationTest/task].sort, metrics_without_gc.select{|m| m =~ /^External/}.sort
     end
 
@@ -45,13 +45,13 @@ unless ENV['FAST_TESTS']
         }
         assert_match /<head>/, res.body
       end
-      assert_equal %w[External/www.google.com/Net::HTTP/GET External/allWeb External/www.google.com/all
+      assert_equal %w[External/all External/www.google.com/Net::HTTP/GET External/allWeb External/www.google.com/all
        External/www.google.com/Net::HTTP/GET:Controller/NewRelic::Agent::Instrumentation::NetInstrumentationTest/task].sort, metrics_without_gc.select{|m| m =~ /^External/}.sort
     end
     def test_get__simple
       Net::HTTP.get URI.parse('http://www.google.com/index.html')
       assert_equal metrics_without_gc.sort,
-      %w[External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all].sort
+      %w[External/all External/www.google.com/Net::HTTP/GET External/allOther External/www.google.com/all].sort
     end
     def test_ignore
       NewRelic::Agent.disable_all_tracing do
@@ -67,7 +67,7 @@ unless ENV['FAST_TESTS']
       res = Net::HTTP.start(url.host, url.port) {|http|
         http.head('/index.html')
       }
-      assert_equal %w[External/www.google.com/Net::HTTP/HEAD External/allOther External/www.google.com/all].sort,
+      assert_equal %w[External/all External/www.google.com/Net::HTTP/HEAD External/allOther External/www.google.com/all].sort,
       metrics_without_gc.sort
     end
 
@@ -76,7 +76,7 @@ unless ENV['FAST_TESTS']
       res = Net::HTTP.start(url.host, url.port) {|http|
         http.post('/index.html','data')
       }
-      assert_equal %w[External/www.google.com/Net::HTTP/POST External/allOther External/www.google.com/all].sort,
+      assert_equal %w[External/all External/www.google.com/Net::HTTP/POST External/allOther External/www.google.com/all].sort,
       metrics_without_gc.sort
     end
 

data/test/new_relic/agent/transaction_sample_builder_test.rb

@@ -52,7 +52,7 @@ class NewRelic::Agent::TransationSampleBuilderTest < Test::Unit::TestCase
 
     begin
       build_segment "b"
-      assert_false
+      assert false
     rescue TypeError => e
       # expected
     end

data/test/new_relic/data_serialization_test.rb

@@ -10,11 +10,12 @@ class NewRelic::DataSerializationTest < Test::Unit::TestCase
     @file = "#{path}/newrelic_agent_store.db"
     Dir.mkdir(path) if !File.directory?(path)
     FileUtils.rm_rf(@file)
-    FileUtils.rm_rf("#{@path}/newrelic_agent_store.age")
+    FileUtils.rm_rf("#{@path}/newrelic_agent_store.pid")
   end
   
   def teardown
-    NewRelic::Control.instance['disable_serialization'] = false # this gets set to true in some tests
+    # this gets set to true in some tests
+    NewRelic::Control.instance['disable_serialization'] = false
   end
   
   def test_read_and_write_from_file_read_only
@@ -135,7 +136,76 @@ class NewRelic::DataSerializationTest < Test::Unit::TestCase
     NewRelic::Control.instance.expects(:log_path).returns('./tmp')
     Dir.mkdir('./tmp') if !File.directory?('./tmp')
     NewRelic::DataSerialization.update_last_sent!
-    assert(File.exists?('./tmp/newrelic_agent_store.age'),
+    assert(File.exists?('./tmp/newrelic_agent_store.pid'),
            "Age file not created at user specified location")
   end
+  
+  def test_pid_age_creates_pid_file_if_none_exists
+    assert(!File.exists?("#{@path}/newrelic_agent_store.pid"),
+           'pid file found, should not be there')
+    assert(!NewRelic::DataSerialization.pid_too_old?,
+           "new pid should not be too old")
+    assert(File.exists?("#{@path}/newrelic_agent_store.pid"),
+           'pid file not found, should be there')
+  end
+
+  def test_loading_does_not_seg_fault_if_gc_triggers
+    require 'timeout'
+    
+    Thread.abort_on_exception = true
+    rcv,snd = IO.pipe
+    
+    write = Thread.new do
+      obj = ('a'..'z').inject({}){|h,s|h[s.intern]=s*1024;h}
+      data = Marshal.dump(obj)
+      snd.write(data[0,data.size/2])
+      sleep(0.1)
+      snd.write(data[(data.size/2)..-1])
+    end
+    
+    read = Thread.new do
+      lock = Mutex.new
+      lock.synchronize do
+        NewRelic::DataSerialization.class_eval { load(rcv) }
+      end
+    end
+
+    gc = Thread.new do
+      10.times do
+        GC.start
+      end
+    end
+
+    begin
+      Timeout::timeout(1) do
+        write.join
+        read.join
+        gc.join
+      end
+    rescue Timeout::Error
+      # rubinius deadlocks which seems to be a rubinius bug
+      raise unless NewRelic::LanguageSupport.using_rubinius?
+    end
+    # should not seg fault
+  end
+
+  def test_dump_should_be_thread_safe
+    stats_hash = {}
+
+    2000.times do |i|
+      stats_hash[i.to_s] = NewRelic::StatsBase.new
+    end
+        
+    harvest = Thread.new do
+      NewRelic::DataSerialization.class_eval { dump(stats_hash) }
+    end
+    
+    app = Thread.new do
+      stats_hash["a"] = NewRelic::StatsBase.new
+    end
+    
+    assert_nothing_raised do
+      [app, harvest].each{|t| t.join}
+    end    
+  end
 end

data/test/new_relic/transaction_sample/segment_test.rb

@@ -373,37 +373,47 @@ class NewRelic::TransactionSample::SegmentTest < Test::Unit::TestCase
     assert_equal([], s.explain_sql)
   end
 
-  def test_explain_sql_one_select_with_connection
+  def test_explain_sql_one_select_with_mysql_connection
     s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
-    config = mock('config')
+    config = {:adapter => 'mysql'}
+    config.default('val')
     s.params = {:sql => 'SELECT', :connection_config => config}
     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').returns([["string", "string"], ["string", "string"]])
+    connection.expects(:execute).with('EXPLAIN SELECT').returns(result)
     NewRelic::TransactionSample.expects(:get_connection).with(config).returns(connection)
-    assert_equal([[['string', 'string'], ['string', 'string']]], s.explain_sql)
+    
+    assert_equal(plan.keys.sort, s.explain_sql[0].sort)
+    assert_equal(plan.values.compact.sort, s.explain_sql[1].compact.sort)    
   end
 
   # this basically casts the resultset to an array of rows, which are
   # arrays of columns
   def test_process_resultset
     s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
-    items = mock('bar')
-    row = ["column"]
-    items.expects(:respond_to?).with(:each).returns(true)
-    items.expects(:each).yields(row)
-    assert_equal([["column"]], s.process_resultset(items))
+    items = [["column"]]
+    assert_equal([nil, ["column"]], s.process_resultset(items))
   end
 
-  def test_explain_sql_two_selects_with_connection
+  def test_explain_sql_one_select_with_pg_connection
     s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
-    config = mock('config')
-    s.params = {:sql => "SELECT true();\nSELECT false()", :connection_config => config}
+    config = {:adapter => 'postgresql'}
+    config.default('val')
+    s.params = {:sql => "SELECT true()", :connection_config => config}
     connection = mock('connection')
     # two rows, two columns
-    connection.expects(:execute).returns([["string", "string"], ["string", "string"]]).twice
-    NewRelic::TransactionSample.expects(:get_connection).with(config).returns(connection).twice
-    assert_equal([[['string', 'string'], ['string', 'string']], [['string', 'string'], ['string', 'string']]], s.explain_sql)
+    connection.expects(:execute).returns([{"QUERY PLAN"=>"Seq Scan on foo (cost=0.00..11.40 rows=140 width=540)"}])
+    NewRelic::TransactionSample.expects(:get_connection).with(config).returns(connection)
+    assert_equal([['QUERY PLAN'],
+                   ['Seq Scan on foo (cost=0.00..11.40 rows=140 width=540)']],
+                 s.explain_sql)
   end
 
   def test_explain_sql_raising_an_error
@@ -431,7 +441,7 @@ class NewRelic::TransactionSample::SegmentTest < Test::Unit::TestCase
     s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
     fake_error = Exception.new
     fake_error.expects(:message).returns('a message')
-    NewRelic::Control.instance.log.expects(:error).with('Error getting explain plan: 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))
     s.handle_exception_in_explain do