ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

data/test/new_relic/transaction_analysis/segment_summary_test.rb

@@ -63,6 +63,20 @@ class NewRelic::TransactionAnalysis::SegmentSummaryTest < Test::Unit::TestCase
     assert_equal 0.5, @ss.total_time_percentage
   end
 
+  def test_nesting_total_time
+    segment = mock('segment')
+    segment.expects(:metric_name).twice.returns('Controller/foo')
+    segment.expects(:duration).returns(0.1)
+    segment.expects(:exclusive_duration).returns(0)
+    @ss << segment
+    segment.expects(:exclusive_duration).returns(0.1)
+    @ss.current_nest_count += 1
+    @ss << segment
+    assert_equal 0.1, @ss.total_time
+    assert_equal 0.1, @ss.exclusive_time
+    assert_equal 2, @ss.call_count
+  end
+
   def test_ui_name_default
     @ss.metric_name = 'Remainder'
     assert_equal 'Remainder', @ss.ui_name

data/test/new_relic/transaction_analysis_test.rb

@@ -28,7 +28,7 @@ class NewRelic::TransactionAnalysisTest < Test::Unit::TestCase
     other_segment.expects(:metric_name).twice.returns('Controller/foo')
     other_segment.expects(:duration).returns(0.1)
     other_segment.expects(:exclusive_duration).returns(0.1)
-    self.expects(:each_segment).multiple_yields(root_segment, other_segment)
+    self.expects(:each_segment_with_nest_tracking).multiple_yields(root_segment, other_segment)
     self.expects(:root_segment).twice.returns(root_segment)
     self.expects(:duration).returns(0.1)
     data = breakdown_data
@@ -56,7 +56,7 @@ class NewRelic::TransactionAnalysisTest < Test::Unit::TestCase
     yet_another.expects(:metric_name).twice.returns('Controller/bar')
     yet_another.expects(:duration).returns(0.2)
     yet_another.expects(:exclusive_duration).returns(0.2)
-    self.expects(:each_segment).multiple_yields(root_segment, other_segment, yet_another)
+    self.expects(:each_segment_with_nest_tracking).multiple_yields(root_segment, other_segment, yet_another)
     self.expects(:root_segment).times(3).returns(root_segment)
     self.expects(:duration).returns(0.1)
     data = breakdown_data(1)
@@ -76,7 +76,7 @@ class NewRelic::TransactionAnalysisTest < Test::Unit::TestCase
     other_segment.expects(:metric_name).twice.returns('Controller/foo')
     other_segment.expects(:duration).returns(0.1)
     other_segment.expects(:exclusive_duration).returns(0.1)
-    self.expects(:each_segment).multiple_yields(root_segment, other_segment)
+    self.expects(:each_segment_with_nest_tracking).multiple_yields(root_segment, other_segment)
     self.expects(:root_segment).twice.returns(root_segment)
     self.expects(:duration).returns(0.2)
     data = breakdown_data

data/test/new_relic/transaction_sample/segment_test.rb

@@ -313,6 +313,17 @@ class NewRelic::TransactionSample::SegmentTest < Test::Unit::TestCase
     assert_equal(2, count)
   end
 
+  def test_each_segment_with_nest_tracking
+    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
+
+    summary = mock('summary')
+    summary.expects(:current_nest_count).twice.returns(0).then.returns(1)
+    summary.expects(:current_nest_count=).twice
+    s.each_segment_with_nest_tracking do |x|
+      summary
+    end
+  end
+
   def test_find_segment_default
     s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
     id_to_find = s.segment_id
@@ -332,75 +343,12 @@ class NewRelic::TransactionSample::SegmentTest < Test::Unit::TestCase
     assert_equal(s, s.find_segment(id_to_find))
   end
 
-  def test_explain_sql_no_sql
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
-    s.params = {:sql => nil}
-    assert_equal(nil, s.explain_sql)
-  end
-
-  def test_explain_sql_no_connection_config
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
-    s.params = {:sql => 'foo', :connection_config => nil}
-    assert_equal(nil, s.explain_sql)
-  end
-
-  def test_explain_sql_non_select
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
-    s.params = {:sql => 'foo', :connection_config => mock('config')}
-    assert_equal([], s.explain_sql)
-  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)
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
-    s.params = {:sql => 'SELECT', :connection_config => config}
-    assert_equal([], s.explain_sql)
-  end
-
-  def test_explain_sql_one_select_with_connection
-    s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
-    config = mock('config')
-    s.params = {:sql => 'SELECT', :connection_config => config}
-    connection = mock('connection')
-    # two rows, two columns
-    connection.expects(:execute).with('EXPLAIN SELECT').returns([["string", "string"], ["string", "string"]])
-    NewRelic::TransactionSample.expects(:get_connection).with(config).returns(connection)
-    assert_equal([[['string', 'string'], ['string', 'string']]], s.explain_sql)
-  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))
-  end
-
-  def test_explain_sql_two_selects_with_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}
-    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)
-  end
-
   def test_explain_sql_raising_an_error
     s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
     config = mock('config')
     s.params = {:sql => 'SELECT', :connection_config => config}
     connection = mock('connection')
-    NewRelic::TransactionSample.expects(:get_connection).with(config).raises(RuntimeError.new("whee"))
+    NewRelic::Agent::Database.expects(:get_connection).with(config).raises(RuntimeError.new("whee"))
     assert_nothing_raised do
       s.explain_sql
     end
@@ -415,25 +363,12 @@ class NewRelic::TransactionSample::SegmentTest < Test::Unit::TestCase
     s.params = params
     assert_equal(params, s.instance_eval { @params })
   end
-
-  def test_handle_exception_in_explain
-    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')
-    # 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
-      raise(fake_error)
-    end
-  end
-
+  
   def test_obfuscated_sql
-    sql = 'some sql'
+    sql = 'select * from table where id = 1'
     s = NewRelic::TransactionSample::Segment.new(Time.now, 'Custom/test/metric', nil)
     s[:sql] = sql
-    NewRelic::TransactionSample.expects(:obfuscate_sql).with(sql)
-    s.obfuscated_sql
+    assert_equal('select * from table where id = ?', s.obfuscated_sql)
   end
 
   def test_called_segments_equals

data/test/new_relic/transaction_sample_test.rb

@@ -6,9 +6,9 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
 
   def setup
     @connection_stub = Mocha::Mockery.instance.named_mock('connection')
-    @connection_stub.stubs(:execute).returns('QUERY RESULT')
+    @connection_stub.stubs(:execute).returns([['QUERY RESULT']])
 
-    NewRelic::TransactionSample.stubs(:get_connection).returns @connection_stub
+    NewRelic::Agent::Database.stubs(:get_connection).returns @connection_stub
     @t = make_sql_transaction(::SQL_STATEMENT, ::SQL_STATEMENT)
   end
 
@@ -19,7 +19,7 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   def test_not_record_sql_when_record_sql_off
     s = @t.prepare_to_send(:explain_sql => 0.00000001)
     s.each_segment do |segment|
-      assert_nil segment.params[:explanation]
+      assert_nil segment.params[:explain_plan]
       assert_nil segment.params[:sql]
     end
   end
@@ -29,7 +29,7 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
     got_one = false
     s.each_segment do |segment|
       fail if segment.params[:obfuscated_sql]
-      got_one = got_one || segment.params[:explanation] || segment.params[:sql]
+      got_one = got_one || segment.params[:explain_plan] || segment.params[:sql]
     end
     assert got_one
   end
@@ -40,7 +40,7 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
 
     got_one = false
     s.each_segment do |segment|
-      got_one = got_one || segment.params[:explanation] || segment.params[:sql]
+      got_one = got_one || segment.params[:explain_plan] || segment.params[:sql]
     end
 
     assert got_one
@@ -77,22 +77,16 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
   end
 
   def test_have_explains
-
     s = @t.prepare_to_send(:record_sql => :obfuscated, :explain_sql => 0.00000001)
-
-    explain_count = 0
+    
     s.each_segment do |segment|
-      if segment.params[:explanation]
-        explanations = segment.params[:explanation]
-
-        explanations.each do |explanation|
-          assert_kind_of Array, explanation
-          assert_equal "QUERY RESULT", explanation.join('')
-          explain_count += 1
-        end
+      if segment.params[:explain_plan]
+        explanation = segment.params[:explain_plan]
+
+        assert_kind_of Array, explanation
+        assert_equal([nil, [["QUERY RESULT"]]], explanation)
       end
     end
-    assert_equal 2, explain_count
   end
 
   def test_not_record_sql_without_record_sql_option
@@ -104,7 +98,7 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
     s = t.prepare_to_send(:explain_sql => 0.00000001)
 
     s.each_segment do |segment|
-      assert_nil segment.params[:explanation]
+      assert_nil segment.params[:explain_plan]
       assert_nil segment.params[:sql]
     end
   end
@@ -167,4 +161,17 @@ class NewRelic::TransactionSampleTest < Test::Unit::TestCase
     s = @t.prepare_to_send(:explain_sql => 0.1)
     assert(s.timestamp.instance_of?(Float), "s.timestamp should be a Float, but is #{s.timestamp.class.inspect}")
   end
+
+  def test_count_segments
+    transaction = run_sample_trace_on(NewRelic::Agent::TransactionSampler.new) do |sampler|
+      sampler.notice_push_scope "level0"
+      sampler.notice_push_scope "level-1"
+      sampler.notice_push_scope "level-2"
+      sampler.notice_sql(::SQL_STATEMENT, nil, 0)
+      sampler.notice_pop_scope "level-2"
+      sampler.notice_pop_scope "level-1"
+      sampler.notice_pop_scope "level0"
+    end
+    assert_equal 6, transaction.count_segments
+  end
 end

data/test/script/build_test_gem.sh

@@ -0,0 +1,51 @@
+#!/bin/bash
+
+# print commands in this script as they're invoked
+set -x
+# fail if any command fails
+set -e
+
+if [ "x$BUILD_NUMBER" == "x" ]; then
+  echo '$BUILD_NUMBER is undefined'
+  echo 'setting $BUILD_NUMBER to alpha'
+  BUILD_NUMBER=alpha
+fi
+
+SHA1=`git log --pretty=format:'%h' -n 1`
+echo "building gem for commit $SHA"
+
+if [[ `gem list jeweler | grep [j]eweler | wc -l` -eq 1 ]]; then
+  echo "detected jeweler. skipping install"
+else
+  gem install jeweler --no-ri --no-rdoc
+fi
+
+# setup a gems directory as a work area for artifacts
+rm -rf gems/
+mkdir gems
+
+# an identifier including the hudson build number and the git sha1
+
+# FIXME: don't include the $SHA1 since some of our builds systems are confused
+# by this.
+BUILD_ID=$BUILD_NUMBER #.$SHA1
+
+# rewrite the version file, setting the patch identifier to include the
+# BUILD_ID
+perl -p -i -e "s#BUILD *= *.*\$#BUILD = '$BUILD_ID'#" lib/new_relic/version.rb
+
+# generate the gemspec
+rake gemspec
+
+# build the gem
+gem build *.gemspec
+
+# move artifacts to the gems directory
+cp *.gemspec gems/
+mv *.gem gems/
+
+cd gems
+
+# create a tarfile including the gem and the gemspec
+gem_version=`ls *.gem | sed 's/\.gem$//' | sed 's/newrelic_rpm-//'`
+tar czvf newrelic_rpm_agent-${gem_version}.tar.gz *

data/test/script/ci.sh

@@ -0,0 +1,140 @@
+#!/bin/bash
+
+# Script to run test suites in CI or in development mode.  This script handles
+# checking out test dependencies (currently rpm_test_app and it's dependencies)
+# and executing them.
+#
+# It relies on 2 environment variables:
+#
+# RUBY - The rvm ruby you want to use (e.g. 1.8.7, ree, jruby)
+#
+# BRANCH - The rpm_test_app branch you want to use (e.g. rails20, rails31)
+#
+# Example usage:
+# RUBY=ree BRANCH=rails20 test/script/ci.sh
+#
+# RUBY=ree BRANCH=rails20 test/script/ci.sh
+#
+# RUBY=jruby BRANCH=rails22 test/script/ci.sh
+
+echo "Executing $0"
+echo "Running in $(pwd)"
+
+# print commands in this script as they're invoked
+#set -x
+# fail if any command fails
+set -e
+
+# check for require environment variables
+if [ "x$RUBY" == "x" ]; then
+  echo '$RUBY is undefined'
+  echo 'defaulting to 1.9.3'
+  RUBY=1.9.3
+fi
+if [ "x$BRANCH" == "x" ]; then
+  echo '$BRANCH is undefined'
+  echo 'defaulting to rails31'
+  BRANCH=rails31
+fi
+
+. "$HOME/.rvm/scripts/rvm"
+rvm use $RUBY || rvm install $RUBY
+echo `which ruby`
+
+# make sure that we're in the project root
+script_dirname=`dirname $0`
+cd "$script_dirname/../../"
+pwd
+
+rm -rf tmp
+mkdir -p tmp
+cd tmp
+
+
+#rpm_test_app_cache=~/.rpm_test_app_cache
+rpm_test_app_cache=~/workspace/.rpm_test_app_cache
+(
+  echo "updating local cache of rpm_test_app in $rpm_test_app_cache"
+  git clone --mirror git://github.com/newrelic/rpm_test_app.git $rpm_test_app_cache || true
+  cd $rpm_test_app_cache
+)
+
+git clone $rpm_test_app_cache rpm_test_app
+cd rpm_test_app || true # rvm overrides cd and it's f-ing up the build by exiting 2
+
+git checkout -t origin/$BRANCH || git checkout $BRANCH
+
+
+# Re-write database.yml to this here doc
+( cat << "YAML" ) > config/database.yml
+# Shared properties for mysql db
+mysql: &mysql
+  adapter: mysql
+  socket: <%= (`uname -s` =~ /Linux/ ) ? "" :"/tmp/mysql.sock" %>
+  username: root
+  host: localhost
+  database: <%= [ 'rails_blog', ENV['BRANCH'], ENV['RUBY'] ].compact.join('_') %>
+
+# Shared properties for postgres.  This won't work with our schema but
+# Does work with agent tests
+sqlite3: &sqlite3
+<% if defined?(JRuby) %>
+  adapter: jdbcsqlite3
+<% else %>
+  adapter: sqlite3
+<% end %>
+  database: db/all.sqlite3
+  pool: 5
+  timeout: 5000
+  host: localhost
+  
+# SQLite version 3.x
+#   gem install sqlite3-ruby (not necessary on OS X Leopard)
+development:
+  <<: *sqlite3
+
+test:
+  <<: *mysql
+
+production:
+  <<: *mysql
+YAML
+
+
+mkdir -p log
+mkdir -p tmp
+if [ "x$BRANCH" == "xrails20" ]; then
+  printf "\e[0;31;49mWarning:\e[0m "
+  echo "Testing against the rails20 branch requires your changes to be committed. Uncommitted changes will not be used."
+  mkdir -p vendor/plugins
+  git clone ../.. vendor/plugins/newrelic_rpm
+else
+  perl -p -i'.bak' -e 's#gem .newrelic_rpm.*$#gem "newrelic_rpm", :path => "\.\.\/\.\.\/"#' Gemfile
+fi
+
+# save time by reusing the gemset if it exists
+
+gemset=ruby_agent_tests_$BRANCH
+rvm gemset use $gemset || ( rvm gemset create $gemset && rvm gemset use $gemset )
+
+if [ "x$RUBY" == "x1.8.6" ]; then
+  # Bundler 0.1 dropped support for ruby 1.8.6
+  gem install bundler -v'~>1.0.0' --no-rdoc --no-ri
+else
+  gem install bundler --no-rdoc --no-ri
+fi
+
+
+export RAILS_ENV=test
+bundle
+
+# FIXME:  Here we actually trigger the tests. Since the agent deals so heavily
+# in units of time we have many tests that assert that durations are measured
+# correctly.  These almost always pass, but as the CI machine has come under
+# heavier load there tend to be discrepencies between the duration measured in
+# the test and the duration the agent measures.  This is due to lags in CPU
+# scheduling since many processes are running on the box simultaneously.
+# To reduce the noise from these sporardic failures we rerun the test suite if
+# there are failures to see if they are transient (instead of re-running it by
+# hand).  Ultimately we'll move towards a more elegant solution.
+bundle exec rake --trace db:create:all test:newrelic || bundle exec rake --trace test:newrelic || bundle exec rake --trace test:newrelic