newrelic_rpm 3.6.5.130 → 3.6.6.147

data/test/config/newrelic.yml

@@ -32,14 +32,14 @@ test:
   fval: false
   yval: yes
   sval: sure
-    
+
   transaction_tracer:
     record_sql: raw
     transaction_threshold: Apdex_f # case insensitive
     explain_threshold: 0.1
     explain_enabled: true
     stack_trace_threshold: 0.1
-    
+
   error_collector:
     enabled: true
     capture_source: true

data/test/multiverse/.gitignore

@@ -3,6 +3,8 @@ tmp
 .bundler_work_area
 Gemfile
 Gemfile.lock
+Gemfile.*
+Gemfile.*.lock
 *.log
 *.db
 .idea

data/test/multiverse/lib/multiverse/envfile.rb

@@ -6,8 +6,8 @@ module Multiverse
   # Reads an envfile.rb and converts it into gemfiles that can be used by
   # bundler
   class Envfile
-    attr_accessor :file_path, :condition, :newrelic_gemfile_options
-    attr_reader :before, :after, :mode, :skip_message, :omit_mocha
+    attr_accessor :file_path, :condition
+    attr_reader :before, :after, :mode, :skip_message, :omit_mocha, :omit_collector
 
     def initialize(file_path)
       self.file_path = file_path
@@ -25,13 +25,6 @@ module Multiverse
       @condition = block
     end
 
-    # string representation options hash to append to the newrelic_rpm line
-    # when setting up Gemfile
-    # e.g. ":require => false"
-    def newrelic_gemfile_options=(options_string)
-      @newrelic_gemfile_options = options_string
-    end
-
     def gemfile(content)
       @gemfiles.push content
     end
@@ -40,6 +33,10 @@ module Multiverse
       @omit_mocha = true
     end
 
+    def omit_collector!
+      @omit_collector = true
+    end
+
     def before_suite(&block)
       @before = block
     end

data/test/multiverse/lib/multiverse/environment.rb

@@ -3,7 +3,6 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'fileutils'
-require 'test/unit'
 module Multiverse
   ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
   $: << File.expand_path(File.join(ROOT, 'lib'))

data/test/multiverse/lib/multiverse/output_collector.rb

@@ -5,28 +5,60 @@
 # This module is responsible for intercepting output made through various stdlib
 # calls (i.e. puts, print, etc.) and printing summary information (e.g. a list
 # of failing tests) at the end of the process.
-#
+
+require 'thread'
+
 module Multiverse
   module OutputCollector
     include Color
     extend Color
-    def self.buffers
-      @buffer ||= []
-    end
+
+    @output_lock = Mutex.new
+    @buffer_lock = Mutex.new
 
     def self.failing_output
       @failing ||= []
     end
 
-    def self.report
-      puts
-      puts
+    def self.buffer(suite, env)
+      key = [suite, env]
+      @buffer_lock.synchronize do
+        @buffers ||= {}
+        @buffers[key] ||= ""
+        @buffers[key]
+      end
+    end
+
+    def self.failed(suite, env)
+      @failing ||= []
+      @failing << buffer(suite, env) + "\n"
+    end
+
+    def self.write(suite, env, msg)
+      buffer(suite, env) << msg
+    end
+
+    def self.suite_report(suite, env)
+      output(buffer(suite, env))
+    end
+
+    def self.overall_report
+      output("", "")
       if failing_output.empty?
-        puts green("There were no test failures")
+        output(green("There were no test failures"))
       else
-        puts red("There were failures in #{failing_output.size} test suites")
-        puts "Here is their output"
-        puts *failing_output
+        output(
+          red("There were failures in #{failing_output.size} test suites"),
+          "Here is their output",
+          *failing_output)
+      end
+    end
+
+    # Because the various environments potentially run in separate threads to
+    # start their processes, make sure we don't blatantly interleave output.
+    def self.output(*args)
+      @output_lock.synchronize do
+        puts *args
       end
     end
   end

data/test/multiverse/lib/multiverse/runner.rb

@@ -24,13 +24,36 @@ module Multiverse
       @exit_status
     end
 
-    def run(filter="")
+    # Args without a = are turned into just opts[key] = true
+    # Args with = get split, then assigned as key + value
+    # :suite gets ignored
+    def parse_args(args)
+      opts = {}
+      args.each do |(k, v)|
+        if v.index("name=") == 0
+          parts = v.split("=")
+          opts[:names] ||= []
+          opts[:names] << parts.last
+        elsif v.include?("=")
+          parts = v.split("=")
+          opts[parts.first.to_sym] = parts.last
+        elsif k != :suite
+          opts[v.to_sym] = true
+        end
+      end
+      opts
+    end
+
+    def run(filter="", opts={})
       Dir.new(SUITES_DIRECTORY).entries.each do |dir|
-        next if dir =~ /\A\./
-        next unless dir.include? filter
         full_path = File.join(SUITES_DIRECTORY, dir)
+
+        next if dir =~ /\A\./
+        next unless filter.nil? || dir.include?(filter)
+        next unless File.exists?(File.join(full_path, "Envfile"))
+
         begin
-          suite = Suite.new full_path
+          suite = Suite.new(full_path, opts)
           suite.execute
         rescue => e
           puts red("Error when trying to run suite in #{full_path.inspect}")
@@ -41,8 +64,17 @@ module Multiverse
         end
       end
 
-      OutputCollector.report
+      OutputCollector.overall_report
       exit exit_status
     end
+
+    # run_one is used to run a suite directly in process
+    # Pipe shenanigans in the typical Suite runner interferes with the debugger
+    def run_one(filter="", opts={})
+      dir = Dir.new(SUITES_DIRECTORY).entries.find { |d| d.include?(filter) }
+      full_path = File.join(SUITES_DIRECTORY, dir)
+      $stderr.reopen($stdout)
+      Suite.new(full_path, opts).execute_child_environment(opts.fetch(:env, "0").to_i)
+    end
   end
 end

data/test/multiverse/lib/multiverse/suite.rb

@@ -3,26 +3,30 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
-# this is to make sure that the Multiverse environment loads with the
-# the gem version of Minitest (necessary for Rails 4) and not the one
-# in standard library.
-if defined?(gem)
-  gem 'minitest'
-end
+# This makes sure that the Multiverse environment loads with the gem
+# version of Minitest, which we use throughout, not the one in stdlib on
+# Rubies starting with 1.9.x
+require 'rubygems'
+gem 'minitest', '~> 4.7.5'
 
 require File.expand_path(File.join(File.dirname(__FILE__), 'environment'))
+
 module Multiverse
   class Suite
     include Color
-    attr_accessor :directory, :include_debugger
-    def initialize(directory, include_debugger=nil)
+    attr_accessor :directory, :include_debugger, :seed, :names
+
+    def initialize(directory, opts={})
       self.directory = directory
-      self.include_debugger = !!include_debugger
+      self.include_debugger = opts.fetch(:run_one, false)
+      self.seed = opts.fetch(:seed, "")
+      self.names = opts.fetch(:names, [])
+      ENV["VERBOSE"] = '1' if opts[:verbose]
     end
 
-    def clean_gemfiles
-      FileUtils.rm_rf File.join(directory, 'Gemfile')
-      FileUtils.rm_rf File.join(directory, 'Gemfile.lock')
+    def clean_gemfiles(env_index)
+      FileUtils.rm_rf File.join(directory, "Gemfile.#{env_index}")
+      FileUtils.rm_rf File.join(directory, "Gemfile.#{env_index}.lock")
     end
 
 
@@ -34,16 +38,17 @@ module Multiverse
     end
 
     # load the environment for this suite after we've forked
-    def load_dependencies(gemfile_text)
-      clean_gemfiles
+    def load_dependencies(gemfile_text, env_index)
+      ENV["BUNDLE_GEMFILE"] = "Gemfile.#{env_index}"
+      clean_gemfiles(env_index)
       begin
-        generate_gemfile(gemfile_text)
+        generate_gemfile(gemfile_text, env_index)
         bundle
       rescue => e
         puts "#{e.class}: #{e}"
         puts "Fast local bundle failed.  Attempting to install from rubygems.org"
-        clean_gemfiles
-        generate_gemfile(gemfile_text, false)
+        clean_gemfiles(env_index)
+        generate_gemfile(gemfile_text, env_index, false)
         bundle
       end
       print_environment
@@ -57,34 +62,32 @@ module Multiverse
       raise "bundle command failed with (#{$?})" unless $? == 0
       Bundler.require
 
-      # Ensure mocha is loaded after the test framework by deferring until here
-      # see: http://gofreerange.com/mocha/docs/
-      unless environments.omit_mocha
-        if RUBY_VERSION > '1.8.7'
-          require 'mocha/setup'
-        else
-          require 'mocha'
-        end
-      end
     end
 
-    def generate_gemfile(gemfile_text, local = true)
-      gemfile = File.join(Dir.pwd, 'Gemfile')
+    def generate_gemfile(gemfile_text, env_index, local = true)
+      gemfile = File.join(Dir.pwd, "Gemfile.#{env_index}")
       File.open(gemfile,'w') do |f|
         f.puts '  source :rubygems' unless local
         f.print gemfile_text
         f.puts newrelic_gemfile_line unless gemfile_text =~ /^\s*gem .newrelic_rpm./
         f.puts jruby_openssl_line unless gemfile_text =~ /^\s*gem .jruby-openssl./
+        f.puts minitest_line unless gemfile_text =~ /^\s*gem .minitest[^_]./
+
+        # We currently pin usage of mocha at the 0.9.x line for compatibility
+        # 0.10.x had issues with the integration handlers and MiniTest on old Rubies
+        # 0.11.x introduced syntax that breaks 1.8.6 entirely :(
+        #
+        # If we want to move forward to MiniTest 5.0.x, this will need to be
+        # resolved in some fashion at that point
+        f.puts "  gem 'mocha', '~> 0.9.8', :require => false" unless environments.omit_mocha
+
         if RUBY_VERSION > '1.8.7'
-          f.puts "  gem 'test-unit', :require => 'test/unit'"
           f.puts "  gem 'debugger'" if include_debugger
-          f.puts "  gem 'mocha', '~> 0.13.0', :require => false" unless environments.omit_mocha
         else
           f.puts "  gem 'ruby-debug'" if include_debugger
-          f.puts "  gem 'mocha', '~> 0.9.8', :require => false" unless environments.omit_mocha
         end
       end
-      puts yellow("Gemfile set to:") if verbose?
+      puts yellow("Gemfile.#{env_index} set to:") if verbose?
       puts File.open(gemfile).read if verbose?
     end
 
@@ -92,7 +95,6 @@ module Multiverse
       line = ENV['NEWRELIC_GEMFILE_LINE'] if ENV['NEWRELIC_GEMFILE_LINE']
       path = ENV['NEWRELIC_GEM_PATH'] || '../../../..'
       line ||= "  gem 'newrelic_rpm', :path => '#{path}'"
-      line += ", #{environments.newrelic_gemfile_options}" if environments.newrelic_gemfile_options
       line
     end
 
@@ -100,6 +102,10 @@ module Multiverse
       "gem 'jruby-openssl', :require => false, :platforms => [:jruby]"
     end
 
+    def minitest_line
+      "gem 'minitest', '~> 4.7.5'"
+    end
+
     def print_environment
       puts yellow("Environment loaded with:") if verbose?
       gems = Bundler.definition.specs.inject([]) do |m, s|
@@ -111,10 +117,14 @@ module Multiverse
     end
 
     def execute_child_environment(env_index)
+      configure_before_bundling
+
       gemfile_text = environments[env_index]
-      load_dependencies(gemfile_text)
+      load_dependencies(gemfile_text, env_index)
+
+      configure_child_environment
       execute_ruby_files
-      trigger_test_unit
+      trigger_test_run
     end
 
     # Load the test suite's environment and execute it.
@@ -130,68 +140,140 @@ module Multiverse
       end
       puts yellow("\nRunning #{directory.inspect} in #{environments.size} environments")
       environments.before.call if environments.before
+
+      threads = []
       environments.each_with_index do |gemfile_text, i|
-        execute_with_pipe(i)
+        threads << execute_with_pipe(i)
       end
+      threads.each {|t| t.join}
+
       environments.after.call if environments.after
     end
 
     def execute_with_pipe(env)
-      OutputCollector.buffers.push('')
-      puts yellow("Running #{directory.inspect} for Envfile entry #{env}")
-      IO.popen("#{__FILE__} #{directory} #{env}") do |io|
-        puts yellow("Starting tests in child PID #{io.pid}")
-        while chars = io.read(8) do
-          OutputCollector.buffers.last << chars
-          print chars
+      Thread.new do
+        suite = File.basename(directory)
+        IO.popen("#{__FILE__} #{directory} #{env} '#{seed}' '#{names.join(",")}'") do |io|
+          OutputCollector.write(suite, env, yellow("Running #{suite.inspect} for Envfile entry #{env}\n"))
+          OutputCollector.write(suite, env, yellow("Starting tests in child PID #{io.pid}\n"))
+          until io.eof do
+            chars = io.read
+            OutputCollector.write(suite, env, chars)
+          end
+          OutputCollector.suite_report(suite, env)
         end
+
+        if $? != 0
+          OutputCollector.failed(suite, env)
+        end
+        Multiverse::Runner.notice_exit_status $?
       end
-      if $? != 0
-        OutputCollector.failing_output.push(OutputCollector.buffers.last)
-      end
-      Multiverse::Runner.notice_exit_status $?
     end
 
-    # something makes Test::Unit not want to run automatically.  Seems like the
-    # at_exit hook may be failing to run due to forking.
-    def trigger_test_unit
-      case
-      when defined? Test::Unit::RunCount # 1.9.3
-        # JRuby 1.7 doesn't seem to have a problem triggering test unit.  In
-        # contrast to MRI triggering it like this causes an error.
-        return if defined?(JRuby)
+    def trigger_test_run
+      # We drive everything manually ourselves through MiniTest.
+      #
+      # Autorun behaves differently across the different Ruby version we have
+      # to support, so this is simplest for making our test running consistent
+      options = []
+      options << "-v" if verbose?
+      options << "--seed=#{seed}" unless seed == ""
+      options << "--name=/#{names.map {|n| n + ".*"}.join("|")}/" unless names == []
+      exit(::MiniTest::Unit.new.run(options))
+    end
+
+    def configure_before_bundling
+      disable_harvest_thread
+      configure_fake_collector
+    end
+
+    def configure_child_environment
+      require 'minitest/unit'
+      patch_minitest_for_old_mocha
+      prevent_minitest_auto_run
+      require_mocha
+    end
+
+    def patch_minitest_for_old_mocha
+      # We use mocha 0.9 for compatibility with old Rubies
+      # Its MiniTest integration isn't quite ok for 4.7.5, though, so patch it
+      unless defined?(::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL)
+        ::MiniTest::Unit::TestCase.const_set("SUPPORTS_INFO_SIGNAL", false)
+      end
+    end
 
-        Test::Unit::RunCount.run_once do
-          exit(Test::Unit::Runner.new.run || true)
+    # Rails and minitest_tu_shim both want to do MiniTest::Unit.autorun for us
+    # We can't sidestep, so just gut the method to avoid doubled test runs
+    def prevent_minitest_auto_run
+      ::MiniTest::Unit.class_eval do
+        def self.autorun
+          # NO-OP
         end
-      when defined? MiniTest::Unit # 1.9.2
-        exit(MiniTest::Unit.new.run)
-      when defined? Test::Unit::AutoRunner # 1.8.7
-        exit(Test::Unit::AutoRunner.run)
-      else
-        raise "Can't figure out how to trigger Test::Unit"
       end
     end
 
+    def require_mocha
+      # We use an older version of mocha, so we just require mocha instead of mocha/setup
+      unless environments.omit_mocha
+        require 'mocha'
+      end
+    end
+
+    def disable_harvest_thread
+      # We don't want to have additional harvest threads running in our multiverse
+      # tests. The tests explicitly manage their lifecycle--resetting and harvesting
+      # to check results against the FakeCollector--so the harvest thread is actually
+      # destabilizing if it's running. Also, multiple restarts result in lots of
+      # threads running in some test suites.
+
+      ENV["NEWRELIC_DISABLE_HARVEST_THREAD"] = "true"
+    end
+
+    def configure_fake_collector
+      ENV["NEWRELIC_OMIT_FAKE_COLLECTOR"] = "true" if environments.omit_collector
+    end
+
     def execute_ruby_files
       Dir.chdir directory
-      Dir[File.join(directory, '*.rb')].each do |file|
+      ordered_ruby_files(directory).each do |file|
         puts yellow("Executing #{file.inspect}") if verbose?
         load file
       end
     end
 
+    def ordered_ruby_files(directory)
+      files = Dir[File.join(directory, '*.rb')]
+
+      before = files.find { |file| File.basename(file) == "before_suite.rb" }
+      after  = files.find { |file| File.basename(file) == "after_suite.rb" }
+
+      files.delete(before)
+      files.delete(after)
+
+      files.insert(0, before) if before
+      files.insert(-1, after) if after
+
+      files
+    end
+
     def verbose?
       ENV['VERBOSE']
     end
   end
 end
 
-# Exectute the suite.  We need this if we want to execute a suite by spawning a
+# Execute the suite.  We need this if we want to execute a suite by spawning a
 # new process instead of forking.
-if $0 == __FILE__
+if $0 == __FILE__ && $already_running.nil?
+  # Suite might get re-required, but don't execute again
+  $already_running = true
+
   # Redirect stderr to stdout so that we can capture both in the popen that
   # feeds into the OutputCollector above.
   $stderr.reopen($stdout)
-  Multiverse::Suite.new(ARGV[0], ARGV[2]).execute_child_environment(ARGV[1].to_i)
+
+  # Ugly, but seralized args passed along to #popen when kicking child off
+  dir, env_index, seed, names, _ = *ARGV
+  suite = Multiverse::Suite.new(dir, {:seed => seed, :names => names.split(",")})
+  suite.execute_child_environment(env_index.to_i)
 end