rails-perftest 0.0.1

data/Rakefile

@@ -0,0 +1,37 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+namespace :test do
+  Rake::TestTask.new("regular") do |t|
+    t.libs = ["test"]
+    t.pattern = "test/*_test.rb"
+    t.ruby_opts = ['-w']
+  end
+
+  Rake::TestTask.new("generators") do |t|
+    t.libs = ["test"]
+    t.pattern = "test/generators/*_test.rb"
+    t.ruby_opts = ['-w']
+  end
+end
+
+task :test => ['test:regular', 'test:generators']
+task :default => :test
+
+specname = "rails-perftest.gemspec"
+deps = `git ls-files`.split("\n") - [specname]
+
+file specname => deps do
+  files       = `git ls-files`.split("\n")
+  test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+  executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+
+  require 'erb'
+
+  File.open specname, 'w:utf-8' do |f|
+    f.write ERB.new(File.read("#{specname}.erb")).result(binding)
+  end
+end
+task :build => specname

data/bin/perftest

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+current_dir = Dir.pwd
+rails_root = current_dir
+
+APP_PATH = File.expand_path('config/application',  rails_root)
+require File.expand_path('config/boot',  rails_root)
+
+require 'rails/perftest/commands'

data/lib/generators/rails/app/templates/test/performance/browsing_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+require 'rails/performance_test_help'
+
+class BrowsingTest < ActionDispatch::PerformanceTest
+  # Refer to the documentation for all available options
+  # self.profile_options = { runs: 5, metrics: [:wall_time, :memory],
+  #                          output: 'tmp/performance', formats: [:flat] }
+
+  test "homepage" do
+    get '/'
+  end
+end

data/lib/generators/rails/performance_test/USAGE

@@ -0,0 +1,10 @@
+Description:
+    Stubs out a new performance test. Pass the name of the test, either
+    CamelCased or under_scored, as an argument.
+
+    This generator invokes the current performance tool, which defaults to
+    TestUnit.
+
+Example:
+    `rails generate performance_test GeneralStories` creates a GeneralStories
+    performance test in test/performance/general_stories_test.rb

data/lib/generators/rails/performance_test/performance_test_generator.rb

@@ -0,0 +1,14 @@
+module Rails
+  module Generators
+    class PerformanceTestGenerator < NamedBase # :nodoc:
+      check_class_collision suffix: "Test"
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def create_performance_test_file
+        template 'performance_test.rb', File.join('test/performance', class_path, "#{file_name}_test.rb")
+      end
+
+    end
+  end
+end

data/lib/generators/rails/performance_test/templates/performance_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+require 'rails/performance_test_help'
+
+class <%= class_name %>Test < ActionDispatch::PerformanceTest
+  # Refer to the documentation for all available options
+  # self.profile_options = { runs: 5, metrics: [:wall_time, :memory],
+  #                          output: 'tmp/performance', formats: [:flat] }
+
+  test "homepage" do
+    get '/'
+  end
+end

data/lib/rails-perftest.rb

@@ -0,0 +1,2 @@
+require 'rails/perftest/railtie' if defined? Rails
+require "rails/perftest/version"

data/lib/rails/performance_test_help.rb

@@ -0,0 +1,3 @@
+ActionController::Base.perform_caching = true
+ActiveSupport::Dependencies.mechanism = :require
+Rails.logger.level = ActiveSupport::Logger::INFO

data/lib/rails/perftest/action_controller.rb

@@ -0,0 +1,3 @@
+module ActionController
+  autoload :PerformanceTest, 'rails/perftest/action_controller/performance_test'
+end

data/lib/rails/perftest/action_controller/performance_test.rb

@@ -0,0 +1,3 @@
+ActionController::PerformanceTest = ActionDispatch::PerformanceTest
+
+ActiveSupport::Deprecation.warn 'ActionController::PerformanceTest is deprecated and will be removed, use ActionDispatch::PerformanceTest instead.'

data/lib/rails/perftest/action_dispatch.rb

@@ -0,0 +1,3 @@
+module ActionDispatch
+  autoload :PerformanceTest, 'rails/perftest/action_dispatch/performance_test'
+end

data/lib/rails/perftest/action_dispatch/performance_test.rb

@@ -0,0 +1,10 @@
+require 'rails/perftest/active_support/testing/performance'
+
+module ActionDispatch
+  # An integration test that runs a code profiler on your test methods.
+  # Profiling output for combinations of each test method, measurement, and
+  # output format are written to your tmp/performance directory.
+  class PerformanceTest < ActionDispatch::IntegrationTest
+    include ActiveSupport::Testing::Performance
+  end
+end

data/lib/rails/perftest/active_support/testing/performance.rb

@@ -0,0 +1,271 @@
+require 'fileutils'
+require 'active_support/concern'
+require 'active_support/core_ext/class/delegating_attributes'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/number_helper'
+
+module ActiveSupport
+  module Testing
+    module Performance
+      extend ActiveSupport::Concern
+
+      included do
+        superclass_delegating_accessor :profile_options
+        self.profile_options = {}
+      end
+
+      # each implementation should define metrics and freeze the defaults
+      DEFAULTS =
+        if ARGV.include?('--benchmark') # HAX for rake test
+          { :runs => 4,
+            :output => 'tmp/performance',
+            :benchmark => true }
+        else
+          { :runs => 1,
+            :output => 'tmp/performance',
+            :benchmark => false }
+        end
+
+      def full_profile_options
+        DEFAULTS.merge(profile_options)
+      end
+
+      def full_test_name
+        "#{self.class.name}##{method_name}"
+      end
+
+      def run(runner)
+        @runner = runner
+
+        run_warmup
+        if full_profile_options && metrics = full_profile_options[:metrics]
+          metrics.each do |metric_name|
+            if klass = Metrics[metric_name.to_sym]
+              run_profile(klass.new)
+            end
+          end
+        end
+
+        return
+      end
+
+      def run_test(metric, mode)
+        result = '.'
+        begin
+          run_callbacks :setup
+          setup
+          metric.send(mode) { __send__ method_name }
+        rescue Exception => e
+          result = @runner.puke(self.class, method_name, e)
+        ensure
+          begin
+            teardown
+            run_callbacks :teardown
+          rescue Exception => e
+            result = @runner.puke(self.class, method_name, e)
+          end
+        end
+        result
+      end
+
+      protected
+        # overridden by each implementation.
+        def run_gc; end
+
+        def run_warmup
+          run_gc
+
+          time = Metrics::Time.new
+          run_test(time, :benchmark)
+          puts "%s (%s warmup)" % [full_test_name, time.format(time.total)]
+
+          run_gc
+        end
+
+        def run_profile(metric)
+          klass = full_profile_options[:benchmark] ? Benchmarker : Profiler
+          performer = klass.new(self, metric)
+
+          performer.run
+          puts performer.report
+          performer.record
+        end
+
+      class Performer
+        delegate :run_test, :full_profile_options, :full_test_name, :to => :@harness
+
+        def initialize(harness, metric)
+          @harness, @metric, @supported = harness, metric, false
+        end
+
+        def report
+          if @supported
+            rate = @total / full_profile_options[:runs]
+            '%20s: %s' % [@metric.name, @metric.format(rate)]
+          else
+            '%20s: unsupported' % @metric.name
+          end
+        end
+
+        protected
+          def output_filename
+            "#{full_profile_options[:output]}/#{full_test_name}_#{@metric.name}"
+          end
+      end
+
+      # overridden by each implementation.
+      class Profiler < Performer
+        def time_with_block
+          before = Time.now
+          yield
+          Time.now - before
+        end
+
+        def run;    end
+        def record; end
+      end
+
+      class Benchmarker < Performer
+        def initialize(*args)
+          super
+          @supported = @metric.respond_to?('measure')
+        end
+
+        def run
+          return unless @supported
+
+          full_profile_options[:runs].to_i.times { run_test(@metric, :benchmark) }
+          @total = @metric.total
+        end
+
+        def record
+          avg = @metric.total / full_profile_options[:runs].to_i
+          now = Time.now.utc.xmlschema
+          with_output_file do |file|
+            file.puts "#{avg},#{now},#{environment}"
+          end
+        end
+
+        def environment
+          @env ||= [].tap do |env|
+            env << "#{$1}.#{$2}" if File.directory?('.git') && `git branch -v` =~ /^\* (\S+)\s+(\S+)/
+            env << rails_version if defined?(Rails::VERSION::STRING)
+            env << "#{RUBY_ENGINE}-#{RUBY_VERSION}.#{RUBY_PATCHLEVEL}"
+            env << RUBY_PLATFORM
+          end.join(',')
+        end
+
+        protected
+          if defined?(Rails::VERSION::STRING)
+            HEADER = 'measurement,created_at,app,rails,ruby,platform'
+          else
+            HEADER = 'measurement,created_at,app,ruby,platform'
+          end
+
+          def with_output_file
+            fname = output_filename
+
+            if new = !File.exist?(fname)
+              FileUtils.mkdir_p(File.dirname(fname))
+            end
+
+            File.open(fname, 'ab') do |file|
+              file.puts(HEADER) if new
+              yield file
+            end
+          end
+
+          def output_filename
+            "#{super}.csv"
+          end
+
+          def rails_version
+            "rails-#{Rails::VERSION::STRING}#{rails_branch}"
+          end
+
+          def rails_branch
+            if File.directory?('vendor/rails/.git')
+              Dir.chdir('vendor/rails') do
+                ".#{$1}.#{$2}" if `git branch -v` =~ /^\* (\S+)\s+(\S+)/
+              end
+            end
+          end
+      end
+
+      module Metrics
+        def self.[](name)
+          const_get(name.to_s.camelize)
+        rescue NameError
+          nil
+        end
+
+        class Base
+          include ActiveSupport::NumberHelper
+
+          attr_reader :total
+
+          def initialize
+            @total = 0
+          end
+
+          def name
+            @name ||= self.class.name.demodulize.underscore
+          end
+
+          def benchmark
+            with_gc_stats do
+              before = measure
+              yield
+              @total += (measure - before)
+            end
+          end
+
+          # overridden by each implementation.
+          def profile; end
+
+          protected
+            # overridden by each implementation.
+            def with_gc_stats; end
+        end
+
+        class Time < Base
+          def measure
+            ::Time.now.to_f
+          end
+
+          def format(measurement)
+            if measurement < 1
+              '%d ms' % (measurement * 1000)
+            else
+              '%.2f sec' % measurement
+            end
+          end
+        end
+
+        class Amount < Base
+          def format(measurement)
+            number_to_delimited(measurement.floor)
+          end
+        end
+
+        class DigitalInformationUnit < Base
+          def format(measurement)
+            number_to_human_size(measurement, :precision => 2)
+          end
+        end
+
+        # each implementation provides its own metrics like ProcessTime, Memory or GcRuns
+      end
+    end
+  end
+end
+
+case RUBY_ENGINE
+  when 'ruby'   then require 'rails/perftest/active_support/testing/performance/ruby'
+  when 'rbx'    then require 'rails/perftest/active_support/testing/performance/rubinius'
+  when 'jruby'  then require 'rails/perftest/active_support/testing/performance/jruby'
+  else
+    $stderr.puts 'Your ruby interpreter is not supported for benchmarking.'
+    exit
+end

data/lib/rails/perftest/active_support/testing/performance/jruby.rb

@@ -0,0 +1,115 @@
+require 'jruby/profiler'
+require 'java'
+java_import java.lang.management.ManagementFactory
+
+module ActiveSupport
+  module Testing
+    module Performance
+      DEFAULTS.merge!(
+        if ARGV.include?('--benchmark')
+          {:metrics => [:wall_time, :user_time, :memory, :gc_runs, :gc_time]}
+        else
+          { :metrics => [:wall_time],
+            :formats => [:flat, :graph] }
+        end).freeze
+
+      protected
+        def run_gc
+          ManagementFactory.memory_mx_bean.gc
+        end
+
+      class Profiler < Performer
+        def initialize(*args)
+          super
+          @supported = @metric.is_a?(Metrics::WallTime)
+        end
+
+        def run
+          return unless @supported
+
+          @total = time_with_block do
+            @data = JRuby::Profiler.profile do
+              full_profile_options[:runs].to_i.times { run_test(@metric, :profile) }
+            end
+          end
+        end
+
+        def record
+          return unless @supported
+
+          klasses = full_profile_options[:formats].map { |f| JRuby::Profiler.const_get("#{f.to_s.camelize}ProfilePrinter") }.compact
+
+          klasses.each do |klass|
+            fname = output_filename(klass)
+            FileUtils.mkdir_p(File.dirname(fname))
+            File.open(fname, 'wb') do |file|
+              klass.new(@data).printProfile(file)
+            end
+          end
+        end
+
+        protected
+          def output_filename(printer_class)
+            suffix =
+              case printer_class.name.demodulize
+                when 'FlatProfilePrinter';  'flat.txt'
+                when 'GraphProfilePrinter'; 'graph.txt'
+                else printer_class.name.sub(/ProfilePrinter$/, '').underscore
+              end
+
+            "#{super()}_#{suffix}"
+          end
+      end
+
+      module Metrics
+        class Base
+          def profile
+            yield
+          end
+
+          protected
+            def with_gc_stats
+              ManagementFactory.memory_mx_bean.gc
+              yield
+            end
+        end
+
+        class WallTime < Time
+          def measure
+            super
+          end
+        end
+
+        class CpuTime < Time
+          def measure
+            ManagementFactory.thread_mx_bean.get_current_thread_cpu_time / 1000 / 1000 / 1000.0 # seconds
+          end
+        end
+
+        class UserTime < Time
+          def measure
+            ManagementFactory.thread_mx_bean.get_current_thread_user_time / 1000 / 1000 / 1000.0 # seconds
+          end
+        end
+
+        class Memory < DigitalInformationUnit
+          def measure
+            ManagementFactory.memory_mx_bean.non_heap_memory_usage.used + ManagementFactory.memory_mx_bean.heap_memory_usage.used
+          end
+        end
+
+        class GcRuns < Amount
+          def measure
+            ManagementFactory.garbage_collector_mx_beans.inject(0) { |total_runs, current_gc| total_runs += current_gc.collection_count }
+          end
+        end
+
+        class GcTime < Time
+          def measure
+            ManagementFactory.garbage_collector_mx_beans.inject(0) { |total_time, current_gc| total_time += current_gc.collection_time } / 1000.0 # seconds
+          end
+        end
+      end
+    end
+  end
+end