newrelic_rpm 4.0.0.332 → 6.13.1

data/test/performance/lib/performance/runner.rb

@@ -1,221 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'socket'
-
-module Performance
-  class Runner
-    attr_reader :instrumentors
-
-    DEFAULTS = {
-      :instrumentors    => [],
-      :inline           => false,
-      :iterations       => nil,
-      :reporter_classes => ['ConsoleReporter'],
-      :brief            => false,
-      :tags             => {},
-      :dir              => File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'suites')),
-      :agent_path       => ENV['AGENT_PATH'] || File.join(File.dirname(__FILE__), '..', '..', '..', '..')
-    }
-
-    def initialize(options={})
-      @options = DEFAULTS.merge(options)
-      create_instrumentors(options[:instrumentors] || [])
-      load_test_files(@options[:dir])
-      @reporter_classes = @options[:reporter_classes].map { |cls| Performance.const_get(cls) }
-      @hostname = Socket.gethostname
-    end
-
-    def artifacts_base_dir
-      File.expand_path(File.join('.', 'artifacts'))
-    end
-
-    def create_instrumentors(names)
-      instrumentor_classes = names.map do |name|
-        Performance::Instrumentation.instrumentor_class_by_name(name)
-      end.compact
-
-      instrumentor_classes |= Instrumentation.default_instrumentors
-
-      @instrumentors = []
-      instrumentor_classes.each do |cls|
-        cls.setup if cls.respond_to?(:setup)
-        @instrumentors << cls.new(artifacts_base_dir)
-      end
-    end
-
-    def load_test_files(dir)
-      Dir.glob(File.join(dir, "**", "*.rb")).each do |filename|
-        require filename
-      end
-    end
-
-    def add_progress_callbacks(test_case)
-      test_case.on(:before_each) do |_test_case, name|
-        print "#{name}: "
-      end
-      test_case.on(:after_each) do |_test_case, name, result|
-        print "#{result.elapsed} s\n"
-      end
-    end
-
-    def add_instrumentor_callbacks(test_case)
-      test_case.on(:before_each) do |test, test_name|
-        instrumentors.each do |i|
-          i.reset
-          i.before(test, test_name)
-        end
-      end
-      test_case.on(:after_each) do |test, test_name, result|
-        instrumentors.reverse.each { |i| i.after(test, test_name) }
-        instrumentors.each do |i|
-          result.measurements.merge!(i.results)
-          result.artifacts.concat(i.artifacts)
-        end
-      end
-    end
-
-    def add_metadata_callbacks(test_case)
-      test_case.on(:after_each) do |test, test_name, result|
-        result.tags.merge!(
-          :newrelic_rpm_version => @newrelic_rpm_version,
-          :newrelic_rpm_git_sha => @newrelic_rpm_git_sha,
-          :ruby_version         => RUBY_DESCRIPTION,
-          :host                 => @hostname
-        )
-        result.tags.merge!(@options[:tags])
-      end
-    end
-
-    def create_test_case(cls)
-      test_case = cls.new
-      test_case.target_iterations = @options[:iterations] if @options[:iterations]
-      test_case.target_duration   = @options[:duration]   if @options[:duration]
-      add_progress_callbacks(test_case) if @options[:progress]
-      add_instrumentor_callbacks(test_case)
-      add_metadata_callbacks(test_case)
-      test_case
-    end
-
-    def methods_for_test_case(test_case)
-      methods = test_case.runnable_test_methods
-      methods = methods.shuffle if @options[:randomize]
-      if @options[:name]
-        filter = Regexp.new(@options[:name])
-        methods = methods.select { |m| m.match(filter) }
-      elsif @options[:identifier]
-        _suite, method = @options[:identifier].split('#')
-        methods = methods.select { |m| m == method }
-      end
-      methods
-    end
-
-    def newrelic_rpm_path
-      File.expand_path(File.join(@options[:agent_path], 'lib'))
-    end
-
-    def load_newrelic_rpm
-      unless @loaded_newrelic_rpm
-        path = newrelic_rpm_path
-        $:.unshift(path)
-        require "newrelic_rpm"
-        @newrelic_rpm_version = NewRelic::VERSION::STRING
-        @newrelic_rpm_git_sha = find_newrelic_rpm_git_sha(path)
-        @loaded_newrelic_rpm = true
-      end
-    end
-
-    def find_newrelic_rpm_git_sha(path)
-      build_file_path = File.join(path, 'new_relic', 'build.rb')
-      if File.exist?(build_file_path)
-        build_file_contents = File.read(build_file_path)
-        return $1.strip if build_file_contents =~ /GITSHA: (.*)/
-      else
-        %x((cd '#{path}' && git log --pretty='%h' -n 1)).strip
-      end
-    end
-
-    def run_test_subprocess(test_case, method)
-      test_case_name = test_case.class.name
-      test_identifier = "#{test_case_name}##{method}"
-      runner_script = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'script', 'runner'))
-      cmd = "#{runner_script} -T #{test_identifier} -j -q -I"
-      cmd << " -A #{@options[:agent_path]}"
-      cmd << " -N #{@options[:iterations]}" if @options[:iterations]
-      cmd << " -d #{@options[:duration]}"   if @options[:duration]
-      output = nil
-      IO.popen(cmd) do |io|
-        output = io.read
-      end
-      results = JSON.parse(output)
-      result = Result.from_hash(results.first)
-      result.tags.merge!(@options[:tags])
-      result
-    end
-
-    def run_test_inline(test_case, method)
-      begin
-        load_newrelic_rpm
-        GC.start
-        test_case.run(method)
-      rescue => e
-        result = Result.new(test_case.class.name, method)
-        result.exception = e
-        result
-      end
-    end
-
-    def run_test_case(test_case)
-      methods_for_test_case(test_case).map do |method|
-        if @options[:inline]
-          run_test_inline(test_case, method)
-        else
-          run_test_subprocess(test_case, method)
-        end
-      end
-    end
-
-    def suites_to_run
-      if @options[:identifier]
-        suite, _method = @options[:identifier].split('#')
-        TestCase.subclasses.select { |cls| cls.name == suite }
-      elsif @options[:suite]
-        TestCase.subclasses.select { |cls| @options[:suite].include?(cls.name) }
-      else
-        TestCase.subclasses
-      end
-    end
-
-    def run_all_test_cases
-      results = []
-      suites_to_run.each do |cls|
-        test_case = create_test_case(cls)
-        results += run_test_case(test_case)
-      end
-      results
-    end
-
-    def run_and_report
-      t0 = Time.now
-      results = run_all_test_cases
-      report_results(results, Time.now - t0)
-    end
-
-    def list_test_cases
-      results = []
-      suites_to_run.each do |cls|
-        methods_for_test_case(cls.new).each do |method|
-          results << [cls, method]
-        end
-      end
-      results
-    end
-
-    def report_results(results, elapsed)
-      @reporter_classes.each do |cls|
-        cls.new(results, elapsed, @options).report
-      end
-    end
-  end
-end

data/test/performance/lib/performance/table.rb

@@ -1,105 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-module Performance
-  class Table
-    class Formatter
-      attr_reader :name
-
-      def initialize(name, format_string=nil, &blk)
-        @name = name
-        @format_string = format_string
-        @format_proc   = blk
-      end
-
-      def measure(value)
-        format(value).size
-      end
-
-      def format(value, width=nil)
-        formatted = if @format_string
-          sprintf(@format_string, value)
-        elsif @format_proc
-          @format_proc.call(value)
-        else
-          value.to_s
-        end
-
-        formatted = justify(value, formatted, width) if width
-        formatted
-      end
-
-      def justify(value, formatted, width)
-        case value
-        when Numeric then formatted.rjust(width)
-        else              formatted.ljust(width)
-        end
-      end
-    end
-
-    class Builder
-      attr_reader :formatters
-
-      def initialize
-        @formatters = []
-      end
-
-      def column(name, format_string=nil, &blk)
-        @formatters << Formatter.new(name, format_string, &blk)
-      end
-    end
-
-    def initialize(rows, &blk)
-      @rows = rows
-
-      builder = Builder.new
-      builder.instance_eval(&blk)
-      @schema = builder.formatters
-    end
-
-    def column_widths
-      widths = Array.new(@schema.size, 0)
-      @schema.each_with_index do |col, idx|
-        widths[idx] = col.name.to_s.size
-      end
-      @rows.each do |row|
-        row.each_with_index do |cell, idx|
-          width = @schema[idx].measure(cell)
-          widths[idx] = [widths[idx], width].max
-        end
-      end
-      widths
-    end
-
-    def render_row(parts)
-      "| " + parts.join(" | ") + " |"
-    end
-
-    def render
-      widths = column_widths
-
-      blanks    = widths.map { |w| "-" * w }
-      top       = '+-' + blanks.join('-+-') + '-+'
-      separator = '|-' + blanks.join('-+-') + '-|'
-      bottom    = '+-' + blanks.join('-+-') + '-+'
-
-      text_rows = []
-
-      headers = @schema.zip(widths).map { |(c, w)| c.name.to_s.ljust(w) }
-      text_rows << render_row(headers)
-
-      @rows.each do |row|
-        parts = []
-        row.each_with_index do |v, i|
-          parts << @schema[i].format(v, widths[i])
-        end
-        text_rows << render_row(parts)
-      end
-
-      puts top + "\n"
-      puts text_rows.join("\n" + separator + "\n")
-      puts bottom + "\n"
-    end
-  end
-end

data/test/performance/lib/performance/test_case.rb

@@ -1,152 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-module Performance
-  class TestCase
-    DEFAULT_WARMUP_DURATION = 2
-    DEFAULT_DURATION        = 5
-    BATCH_TIME              = 0.1
-
-    @subclasses = []
-
-    def self.inherited(cls)
-      @subclasses << cls
-    end
-
-    def self.subclasses
-      @subclasses
-    end
-
-    attr_accessor :target_iterations, :target_duration
-
-    def initialize
-      @callbacks = {}
-      @target_iterations = nil
-      @target_duration   = DEFAULT_DURATION
-    end
-
-    def setup; end
-    def teardown; end
-
-    def self.skip_test(test_method_name, options={})
-      skip_specifiers << [test_method_name, options]
-    end
-
-    def self.skip_specifiers
-      @skip_specifiers ||= []
-    end
-
-    def on(event, &action)
-      @callbacks[event] ||= []
-      @callbacks[event] << action
-    end
-
-    def fire(event, *args)
-      if @callbacks[event]
-        @callbacks[event].each { |cb| cb.arity > 0 ? cb.call(*args) : cb.call }
-      end
-    end
-
-    def runnable_test_methods
-      results = self.methods.map(&:to_s).select { |m| m =~ /^test_/ }
-      self.class.skip_specifiers.each do |specifier|
-        method_name, options = *specifier
-        skipped_platforms = Array(options[:platforms])
-        skipped = Platform.current.match_any?(skipped_platforms)
-        results.delete(method_name.to_s) if skipped
-      end
-      results
-    end
-
-    def with_callbacks(name, warmup=false)
-      fire(:before_each, self, name) unless warmup
-      yield
-      fire(:after_each, self, name, @result) unless warmup
-    end
-
-    # This is used to get a rough approximation of the amount of time required
-    # to call action once. We do this so that we will be able to run the actual
-    # timing loop in chunks of iterations, rather than calling Time.now in
-    # between every iteration.
-    def estimate_time_per_iteration(action, duration)
-      start_time = Time.now
-      deadline = start_time + duration
-      
-      iterations = 0
-      while Time.now < deadline
-        action.call
-        iterations += 1
-      end
-      
-      (Time.now - start_time) / iterations
-    end
-
-    def estimate_iterations_per_unit_time(time_per_iteration, desired_duration)
-      (desired_duration / time_per_iteration).ceil
-    end
-
-    def batch_size_in_iterations(blk)
-      approx_time_per_iteration = nil
-      approx_time_per_iteration = estimate_time_per_iteration(blk, DEFAULT_WARMUP_DURATION)
-      estimate_iterations_per_unit_time(approx_time_per_iteration, BATCH_TIME)
-    end
-
-    def run_block_in_batches(blk, duration, batch_size)
-      deadline = Time.now + duration
-      total_iterations = 0
-      while Time.now < deadline
-        batch_iterations = 0
-        while batch_iterations < batch_size
-          blk.call
-          batch_iterations += 1
-        end
-        total_iterations += batch_iterations
-      end
-      total_iterations
-    end
-
-    def run_block_n_times(blk, n)
-      iterations = 0
-      while iterations < n
-        blk.call
-        iterations += 1
-      end
-      iterations
-    end
-
-    def measure(&blk)
-      total_iterations = 0
-      start_time       = nil
-      elapsed          = nil
-
-      batch_size = batch_size_in_iterations(blk) unless target_iterations
-
-      with_callbacks(@result.test_name, false) do
-        start_time = Time.now
-        if target_iterations
-          total_iterations = run_block_n_times(blk, target_iterations)
-        else
-          total_iterations = run_block_in_batches(blk, target_duration, batch_size)
-        end
-        elapsed = Time.now - start_time
-      end
-
-      @result.iterations            = total_iterations
-      @result.timer.start_timestamp = start_time
-      @result.timer.elapsed         = elapsed
-    end
-
-    def run(name)
-      @result = Result.new(self.class, name)
-      begin
-        setup
-        self.send(name)
-        teardown
-      rescue StandardError, LoadError => e
-        @result.exception = e
-      end
-      @result
-    end
-  end
-end