sundawg_newrelic_rpm 3.5.8.1

data/test/script/ci.sh

@@ -0,0 +1,168 @@
+#!/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 its dependencies)
+# and executing them.
+#
+# It relies on 2 environment variables:
+#
+# RUBY - The rbenv 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'
+  export RUBY=1.9.3-p374
+fi
+if [ "x$BRANCH" == "x" ]; then
+  echo '$BRANCH is undefined'
+  echo 'defaulting to rails31'
+  export BRANCH=rails31
+fi
+
+if [ "x$JOB_NAME" == "x" ]; then
+  echo '$JOB_NAME is undefined'
+  echo 'defaulting to clrun'
+  export PROJECT_NAME=clrun
+else
+  CLEANSED_NAME=`echo $JOB_NAME  | sed "s/label//" | sed "s/Portland//" | sed "s/BRANCH//" | sed "s/RUBY//" | sed "s/[=\/,\._]//g" | sed "s/ReleaseCandidate/RC/"`
+  echo "setting PROJECT_NAME to $CLEANSED_NAME"
+  export PROJECT_NAME="$CLEANSED_NAME"
+fi
+
+eval "$(rbenv init -)" || true
+rbenv shell $RUBY
+if [ "x$(rbenv version-name)" = "x$RUBY" ]; then
+  echo "switched to ruby $RUBY"
+else
+  rbenv install $RUBY
+  rbenv shell $RUBY
+  if [ "x$(rbenv version-name)" = "x$RUBY" ]; then
+    echo "switched to ruby $RUBY"
+  else
+    echo "failed to install ruby $RUBY"
+    exit 1
+  fi
+fi
+
+echo `which ruby`
+ruby -v
+gem --version
+
+rake -h > /dev/null || gem install rake
+
+# 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 fetch || true
+)
+
+git clone $rpm_test_app_cache rpm_test_app
+cd rpm_test_app
+
+git fetch || true
+git checkout -t origin/$BRANCH || git checkout $BRANCH
+if [ -x $HOME/.rbenv/plugins/rbenv-gemsets ]; then
+  echo "$RUBY-$BRANCH" > .rbenv-gemsets
+fi
+
+# 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: <%= ENV['PROJECT_NAME'] %>
+
+# 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
+  echo "Warning: Rails 2.0 support in progress. This probably only works in CI"
+  mkdir -p vendor/plugins
+  GEM=`ls ../../../*.gem | tail -n1`
+  (cd vendor/plugins && gem unpack ../../$GEM)
+  mv vendor/plugins/newrelic_rpm* vendor/plugins/newrelic_rpm
+else
+  perl -p -i'.bak' -e 's#gem .newrelic_rpm.*$#gem "newrelic_rpm", :path => "\.\.\/\.\.\/"#' Gemfile
+fi
+
+if [ "x$RUBY" == "x1.8.6" ]; then
+  # Bundler 1.1 dropped support for ruby 1.8.6
+  bundle -h > /dev/null || gem install bundler -v'~>1.0.0' --no-rdoc --no-ri
+else
+  bundle -h > /dev/null || gem install bundler --no-rdoc --no-ri
+fi
+
+
+export RAILS_ENV=test
+bundle --local || 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

data/test/script/ci_agent-tests_runner.sh

@@ -0,0 +1,82 @@
+#!/bin/bash -e
+
+SCRATH_DIR=./agent-tests_tmp
+#git pull git@github.com:newrelic/ruby_agent-tests.git
+
+#echo $PWD 
+script_dirname=`dirname $0`
+#echo $script_dirname
+#echo $0
+
+# make sure that we're in the project root
+script_dirname=`dirname $0`
+cd "$script_dirname/../../"
+
+
+
+if [ -x $SCRATH_DIR ] ; then
+	echo "found tmp, deleting"
+	rm -fr $SCRATH_DIR
+fi 
+
+mkdir $SCRATH_DIR
+cd $SCRATH_DIR
+
+git clone --depth=1 git@github.com:newrelic/ruby_agent-tests.git ruby_agent-tests
+git clone --depth=1 git@github.com:newrelic/rpm_contrib.git rpm_contrib
+
+if [ -x ../../Ruby_Agent ] ; then
+	ln -s ../../Ruby_Agent ./ruby_agent
+else 
+	echo "*********** Ruby_Agent can't be found ***********"
+	exit 1
+fi
+
+#exit 0
+
+cd ruby_agent-tests
+./ci_run.sh 
+
+#echo "creating tmp dir"
+#mkdir tmp
+#echo "cd'ing to tmp"
+# cd tmp
+# echo $PWD
+
+
+# exit 0
+#env
+#ls -al /home/hudson/.rvm/bin
+# source ~/.rvm/scripts/rvm
+#rvm 1.9.2
+#ruby -v
+
+# rvm --force gemset delete ruby_agent-tests
+
+# rvm gemset create ruby_agent-tests
+
+# rvm gemset use ruby_agent-tests
+# gem install bundler
+# bundle update
+# bundle
+
+##
+# bundle exec ruby fake_collector.rb
+# bundle exec ruby sinatra_metric_explosion_test.rb
+
+########
+# clear out gemset for next test set
+#
+
+# cd rails3viewfedex
+# rvm --force gemset delete ruby_agent-tests
+
+# rvm gemset create ruby_agent-tests
+
+# rvm gemset use ruby_agent-tests
+
+# gem install bundler
+# bundle update
+# bundle
+# bundle exec ruby view_instrumentation_test.rb
+#exit 0

data/test/script/ci_bench.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+# Script to benchmark the ruby agent under various versions of ruby in ci.
+
+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'
+  exit 1
+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
+git clone --depth=1 git@github.com:newrelic/agent_prof.git agent_prof
+cd agent_prof
+
+perl -p -i'.bak' -e 's#gem +.newrelic_rpm.*$#gem "newrelic_rpm", :path => "\.\.\/\.\.\/"#' Gemfile
+
+rvm --force gemset delete ruby_bench_$RUBY
+rvm gemset create ruby_bench_$RUBY
+rvm gemset use ruby_bench_$RUBY
+
+if [ "x$RUBY" == "x1.8.6" ]; then
+  # Bundler 1.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
+
+bundle
+script/run
+bundle exec script/post_log_to_dashboard
+
+

data/test/script/ci_multiverse_runner.sh

@@ -0,0 +1,63 @@
+#!/bin/bash -e
+
+export PATH=$PATH:$HOME/bin
+
+echo $HOME
+echo $PATH
+#ls $HOME/bin
+
+
+
+if [ "x$RUBY" == "x" ] ; then
+  export RUBY=1.9.3
+fi
+
+echo "Tests will be run using $RUBY"
+#uname -a
+
+SCRATH_DIR=./multiverse_tmp
+script_dirname=`dirname $0`
+
+# make sure that we're in the project root
+cd "$script_dirname/../../"
+
+#pwd 
+
+if [ -x $SCRATH_DIR ] ; then
+  echo "found tmp, deleting"
+  rm -fr $SCRATH_DIR
+fi
+
+mkdir $SCRATH_DIR
+cd $SCRATH_DIR
+
+#pwd 
+if [[ $JOB_NAME =~ "Pangalactic" ]] ; then 
+  AGENT_LOCATION="../../../../../../Ruby_Agent"
+else
+  AGENT_LOCATION="../../Ruby_Agent"
+fi
+
+git clone --depth=1 git@github.com:newrelic/multiverse.git multiverse
+git clone --depth=1 git@github.com:newrelic/rpm_contrib.git rpm_contrib
+
+echo "Looking for Ruby Agent at $AGENT_LOCATION"
+#ls -l ../../../../../../
+#ls -l /home/hudson/workspace/
+
+if [ -x $AGENT_LOCATION ] ; then
+  ln -s $AGENT_LOCATION ./ruby_agent
+else
+  echo "*********** Ruby_Agent not found ***********"
+  exit 1
+fi
+
+cd multiverse
+#./ci_run.sh
+
+#pwd
+#ls -l ../
+
+eval "$(rbenv init -)" || true
+rbenv shell $RUBY
+script/runner

data/test/test_contexts.rb

@@ -0,0 +1,30 @@
+
+module TestContexts
+  def with_running_agent
+
+    context 'with running agent' do # this is needed for the nested setups
+
+      setup do
+        @log_data = StringIO.new
+        @log = Logger.new(@log_data)
+        NewRelic::Agent::Agent.instance.service = default_service
+        NewRelic::Agent.manual_start :log => @log
+        @agent = NewRelic::Agent.instance
+        @agent.transaction_sampler.send :clear_builder
+        @agent.transaction_sampler.reset!
+        @agent.stats_engine.clear_stats
+      end
+
+      yield
+
+      def teardown
+        super
+        NewRelic::Agent.shutdown
+        @log_data.reset
+        NewRelic::Control.instance['dispatcher']=nil
+        NewRelic::Control.instance['dispatcher_instance_id']=nil
+      end
+
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,240 @@
+module NewRelic; TEST = true; end unless defined? NewRelic::TEST
+ENV['RAILS_ENV'] = 'test'
+NEWRELIC_PLUGIN_DIR = File.expand_path(File.join(File.dirname(__FILE__),".."))
+$LOAD_PATH << '.'
+$LOAD_PATH << '../../..'
+$LOAD_PATH << File.join(NEWRELIC_PLUGIN_DIR,"lib")
+$LOAD_PATH << File.join(NEWRELIC_PLUGIN_DIR,"test")
+$LOAD_PATH << File.join(NEWRELIC_PLUGIN_DIR,"ui/helpers")
+$LOAD_PATH.uniq!
+
+require 'rubygems'
+require 'rake'
+# We can speed things up in tests that don't need to load rails.
+# You can also run the tests in a mode without rails.  Many tests
+# will be skipped.
+
+begin
+  require 'config/environment'
+#   require File.join(File.dirname(__FILE__),'..','..','rpm_test_app','config','environment')
+  begin
+    require 'test_help'
+  rescue LoadError
+    # ignore load problems on test help - it doesn't exist in rails 3
+  end
+  require 'newrelic_rpm'
+rescue LoadError => e
+  puts "Running tests in standalone mode."
+  require 'bundler'
+  Bundler.require
+  require 'rails/all'
+  require 'newrelic_rpm'
+
+  # Bootstrap a basic rails environment for the agent to run in.
+  class MyApp < Rails::Application
+    config.active_support.deprecation = :log
+    config.secret_token = "49837489qkuweoiuoqwehisuakshdjksadhaisdy78o34y138974xyqp9rmye8yrpiokeuioqwzyoiuxftoyqiuxrhm3iou1hrzmjk"
+    config.after_initialize do
+      NewRelic::Agent.manual_start
+    end
+  end
+  MyApp.initialize!
+
+end
+
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+begin # 1.8.6
+  require 'mocha/integration/test_unit'
+  require 'mocha/integration/test_unit/assertion_counter'
+rescue LoadError
+end
+
+def default_service(stubbed_method_overrides = {})
+  service = stub
+  stubbed_method_defaults = {
+    :connect => {},
+    :shutdown => nil,
+    :agent_id= => nil,
+    :agent_id => nil,
+    :collector => stub_everything,
+    :request_timeout= =>  nil,
+    :metric_data => nil,
+    :error_data => nil,
+    :transaction_sample_data => nil,
+    :get_agent_commands => []
+  }
+
+  service.stubs(stubbed_method_defaults.merge(stubbed_method_overrides))
+
+  # When session gets called yield to the given block.
+  service.stubs(:session).yields
+  service
+end
+
+class Test::Unit::TestCase
+  include Mocha::API
+
+  # we can delete this trick when we stop supporting rails2.0.x
+  if ENV['BRANCH'] != 'rails20'
+    # a hack because rails2.0.2 does not like double teardowns
+    def teardown
+      mocha_teardown
+    end
+  end
+end
+
+def assert_between(floor, ceiling, value, message="expected #{floor} <= #{value} <= #{ceiling}")
+  assert((floor <= value && value <= ceiling), message)
+end
+
+def check_metric_time(metric, value, delta)
+  time = NewRelic::Agent.get_stats(metric).total_call_time
+  assert_between((value - delta), (value + delta), time)
+end
+
+def check_metric_count(metric, value)
+  count = NewRelic::Agent.get_stats(metric).call_count
+  assert_equal(value, count, "should have the correct number of calls")
+end
+
+def check_unscoped_metric_count(metric, value)
+  count = NewRelic::Agent.get_stats_unscoped(metric).call_count
+  assert_equal(value, count, "should have the correct number of calls")
+end
+
+def generate_unscoped_metric_counts(*metrics)
+  metrics.inject({}) do |sum, metric|
+    sum[metric] = NewRelic::Agent.get_stats_no_scope(metric).call_count
+    sum
+  end
+end
+
+def generate_metric_counts(*metrics)
+  metrics.inject({}) do |sum, metric|
+    sum[metric] = NewRelic::Agent.get_stats(metric).call_count
+    sum
+  end
+end
+
+def assert_does_not_call_metrics(*metrics)
+  first_metrics = generate_metric_counts(*metrics)
+  yield
+  last_metrics = generate_metric_counts(*metrics)
+  assert_equal first_metrics, last_metrics, "should not have changed these metrics"
+end
+
+def assert_calls_metrics(*metrics)
+  first_metrics = generate_metric_counts(*metrics)
+  yield
+  last_metrics = generate_metric_counts(*metrics)
+  assert_not_equal first_metrics, last_metrics, "should have changed these metrics"
+end
+
+def assert_calls_unscoped_metrics(*metrics)
+  first_metrics = generate_unscoped_metric_counts(*metrics)
+  yield
+  last_metrics = generate_unscoped_metric_counts(*metrics)
+  assert_not_equal first_metrics, last_metrics, "should have changed these metrics"
+end
+
+unless defined?( assert_includes )
+  def assert_includes( collection, member, msg=nil )
+    msg = build_message( msg, "Expected ? to include ?", collection, member )
+    assert_block( msg ) { collection.include?(member) }
+  end
+end
+
+unless defined?( assert_not_includes )
+  def assert_not_includes( collection, member, msg=nil )
+    msg = build_message( msg, "Expected ? not to include ?", collection, member )
+    assert_block( msg ) { !collection.include?(member) }
+  end
+end
+
+def compare_metrics(expected, actual)
+  actual.delete_if {|a| a.include?('GC/cumulative') } # in case we are in REE
+  assert_equal(expected.to_a.sort, actual.to_a.sort, "extra: #{(actual - expected).to_a.inspect}; missing: #{(expected - actual).to_a.inspect}")
+end
+
+def with_config(config_hash, opts={})
+  opts = { :level => 0, :do_not_cast => false }.merge(opts)
+  if opts[:do_not_cast]
+    config = config_hash
+  else
+    config = NewRelic::Agent::Configuration::DottedHash.new(config_hash)
+  end
+  NewRelic::Agent.config.apply_config(config, opts[:level])
+  begin
+    yield
+  ensure
+    NewRelic::Agent.config.remove_config(config)
+  end
+end
+
+# Need to be a bit sloppy when testing against the logging--let everything
+# through, but check we (at least) get our particular message we care about
+def expects_logging(level, *with_params)
+  ::NewRelic::Agent.logger.stubs(level)
+  ::NewRelic::Agent.logger.expects(level).with(*with_params).once
+end
+
+def expects_no_logging(level)
+  ::NewRelic::Agent.logger.expects(level).never
+end
+
+# Sometimes need to test cases where we muddle with the global logger
+# If so, use this method to ensure it gets restored after we're done
+def without_logger
+  logger = ::NewRelic::Agent.logger
+  ::NewRelic::Agent.logger = nil
+  yield
+ensure
+  ::NewRelic::Agent.logger = logger
+end
+
+module NewRelic
+  def self.fixture_path(name)
+    File.join(File.dirname(__FILE__), 'fixtures', name)
+  end
+end
+
+module TransactionSampleTestHelper
+  module_function
+  def make_sql_transaction(*sql)
+    sampler = NewRelic::Agent::TransactionSampler.new
+    sampler.notice_first_scope_push Time.now.to_f
+    sampler.notice_transaction '/path', nil, :jim => "cool"
+    sampler.notice_push_scope "a"
+
+    sampler.notice_transaction '/path/2', nil, :jim => "cool"
+
+    sql.each {|sql_statement| sampler.notice_sql(sql_statement, {:adapter => "test"}, 0 ) }
+
+    sleep 0.02
+    yield if block_given?
+    sampler.notice_pop_scope "a"
+    sampler.notice_scope_empty
+
+    sampler.samples[0]
+  end
+
+  def run_sample_trace_on(sampler, path='/path')
+    sampler.notice_first_scope_push Time.now.to_f
+    sampler.notice_transaction path, path, {}
+    sampler.notice_push_scope "Controller/sandwiches/index"
+    sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'wheat'", nil, 0)
+    sampler.notice_push_scope "ab"
+    sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'white'", nil, 0)
+    yield sampler if block_given?
+    sampler.notice_pop_scope "ab"
+    sampler.notice_push_scope "lew"
+    sampler.notice_sql("SELECT * FROM sandwiches WHERE bread = 'french'", nil, 0)
+    sampler.notice_pop_scope "lew"
+    sampler.notice_pop_scope "Controller/sandwiches/index"
+    sampler.notice_scope_empty
+    sampler.samples[0]
+  end
+end