railsbench 0.9.2 → 0.9.8

data/lib/railsbench/railsbenchmark.rb

@@ -6,7 +6,7 @@ class RailsBenchmark
   attr_accessor :http_host, :remote_addr, :server_port
   attr_accessor :relative_url_root
   attr_accessor :perform_caching, :cache_template_loading
-  attr_accessor :session_data
+  attr_accessor :session_data, :session_key, :cookie_data
 
   def error_exit(msg)
     STDERR.puts msg
@@ -18,7 +18,13 @@ class RailsBenchmark
   end
 
   def relative_url_root=(value)
-    ActionController::AbstractRequest.relative_url_root = value
+    if ActionController::Base.respond_to?(:relative_url_root=)
+      # rails 2.3
+      ActionController::Base.relative_url_root = value
+    else
+      # earlier railses
+      ActionController::AbstractRequest.relative_url_root = value
+    end
     @relative_url_root = value
   end
 
@@ -35,24 +41,53 @@ class RailsBenchmark
     @server_port = options[:server_port] || '80'
 
     @session_data = options[:session_data] || {}
+    @session_key = options[:session_key] || '_session_id'
 
     ENV['RAILS_ENV'] = 'benchmarking'
 
-    require ENV['RAILS_ROOT'] + "/config/environment"
-    require 'dispatcher' # make edge rails happy
+    begin
+      require ENV['RAILS_ROOT'] + "/config/environment"
+      require 'dispatcher' # make edge rails happy
+
+      if Rails::VERSION::STRING >= "2.3"
+        @rack_middleware = true
+        require 'cgi/session'
+        CGI.class_eval <<-"end_eval"
+          def env_table
+            @env_table ||= ENV.to_hash
+          end
+        end_eval
+      else
+         @rack_middleware = false
+      end
 
-    # we don't want local error template output, which crashes anyway
+    rescue => e
+      $stderr.puts "failed to load application environment"
+      e.backtrace.each{|line| $stderr.puts line}
+      $stderr.puts "benchmarking aborted"
+      exit(-1)
+    end
+
+    # we don't want local error template output, which crashes anyway, when run under railsbench
     ActionController::Rescue.class_eval "def local_request?; false; end"
 
-    # make sure an error code gets returned for 1.1.6
+    # print backtrace and exit if action execution raises an exception
     ActionController::Rescue.class_eval <<-"end_eval"
       def rescue_action_in_public(exception)
-        case exception
-          when ActionController::RoutingError, ActionController::UnknownAction
-            render_text(IO.read(File.join(RAILS_ROOT, 'public', '404.html')), "404 Not Found")
-          else
-            render_text(IO.read(File.join(RAILS_ROOT, 'public', '500.html')), "500 Internal Error")
-        end
+        $stderr.puts "benchmarking aborted due to application error: " + exception.message
+        exception.backtrace.each{|line| $stderr.puts line}
+        $stderr.print "clearing database connections ..."
+        ActiveRecord::Base.send :clear_all_cached_connections! if ActiveRecord::Base.respond_to?(:clear_all_cached_connections)
+        ActiveRecord::Base.clear_all_connections! if ActiveRecord::Base.respond_to?(:clear_all_connections)
+        $stderr.puts
+        exit!(-1)
+      end
+    end_eval
+
+    # override rails ActiveRecord::Base#inspect to make profiles more readable
+    ActiveRecord::Base.class_eval <<-"end_eval"
+      def self.inspect
+        super
       end
     end_eval
 
@@ -68,16 +103,30 @@ class RailsBenchmark
       exit
     end
 
-    log_level = options[:log]
-    log_level = Logger::DEBUG if ARGV.include?('-log')
-    ARGV.each{|arg| arg =~ /-log=([a-zA-Z]*)/ && (log_level = eval("Logger::#{$1.upcase}")) }
+    logger_module = Logger
+    if defined?(Log4r) && RAILS_DEFAULT_LOGGER.is_a?(Log4r::Logger)
+      logger_module = Logger
+    end
+    default_log_level = logger_module.const_get("ERROR")
+    log_level = options[:log] || default_log_level
+    ARGV.each do |arg|
+        case arg
+        when '-log'
+          log_level = default_log_level
+        when '-log=(nil|none)'
+          log_level = nil
+        when /-log=([a-zA-Z]*)/
+          log_level = logger_module.const_get($1.upcase) rescue default_log_level
+        end
+    end
 
     if log_level
       RAILS_DEFAULT_LOGGER.level = log_level
-      #ActiveRecord::Base.logger.level = log_level
-      #ActionController::Base.logger.level = log_level
-      #ActionMailer::Base.logger = level = log_level if defined?(ActionMailer)
+      ActiveRecord::Base.logger.level = log_level
+      ActionController::Base.logger.level = log_level
+      ActionMailer::Base.logger = level = log_level if defined?(ActionMailer)
     else
+      RAILS_DEFAULT_LOGGER.level = logger_module.const_get "FATAL"
       ActiveRecord::Base.logger = nil
       ActionController::Base.logger = nil
       ActionMailer::Base.logger = nil if defined?(ActionMailer)
@@ -90,10 +139,12 @@ class RailsBenchmark
       ActionController::Base.perform_caching = true if ARGV.include?('-cache')
     end
 
-    if options.has_key?(:cache_template_loading)
-      ActionView::Base.cache_template_loading = options[:cache_template_loading]
-    else
-      ActionView::Base.cache_template_loading = true
+    if ActionView::Base.respond_to?(:cache_template_loading)
+      if options.has_key?(:cache_template_loading)
+        ActionView::Base.cache_template_loading = options[:cache_template_loading]
+      else
+        ActionView::Base.cache_template_loading = true
+      end
     end
 
     self.relative_url_root = options[:relative_url_root] || ''
@@ -107,25 +158,58 @@ class RailsBenchmark
   end
 
   def establish_test_session
-    session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS.stringify_keys
-    session_options = session_options.merge('new_session' => true)
-    @session = CGI::Session.new(Hash.new, session_options)
-    @session_data.each{ |k,v| @session[k] = v }
-    @session.update
-    @session_id = @session.session_id
+    if @rack_middleware
+      session_options = ActionController::Base.session_options
+      @session_id = ActiveSupport::SecureRandom.hex(16)
+      do_not_do_much = lambda do |env|
+        env["rack.session"] = @session_data
+        env["rack.session.options"] = {:id => @session_id}
+        [200, {}, ""]
+      end
+      @session_store = ActionController::Base.session_store.new(do_not_do_much, session_options)
+      @session_store.call({})
+    else
+      session_options = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS.stringify_keys
+      session_options = session_options.merge('new_session' => true)
+      @session = CGI::Session.new(Hash.new, session_options)
+      @session_data.each{ |k,v| @session[k] = v }
+      @session.update
+      @session_id = @session.session_id
+    end
   end
 
   def update_test_session_data(session_data)
-    dbman = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS[:database_manager]
-    old_session_data = dbman.new(@session).restore
-    new_session_data = old_session_data.merge(session_data || {})
-    new_session_data.each{ |k,v| @session[k] = v }
-    @session.update
+    if @rack_middleware
+      session_options = ActionController::Base.session_options
+      merge_url_specific_session_data = lambda do |env|
+        old_session_data = env["rack.session"]
+        # $stderr.puts "data in old session: #{old_session_data.inspect}"
+        new_session_data = old_session_data.merge(session_data || {})
+        # $stderr.puts "data in new session: #{new_session_data.inspect}"
+        env["rack.session"] = new_session_data
+        [200, {}, ""]
+      end
+      @session_store.instance_eval { @app = merge_url_specific_session_data }
+      env = {}
+      env["HTTP_COOKIE"] = cookie
+      # debugger
+      @session_store.call(env)
+    else
+      dbman = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS[:database_manager]
+      old_session_data = dbman.new(@session).restore
+      # $stderr.puts old_session_data.inspect
+      new_session_data = old_session_data.merge(session_data || {})
+      new_session_data.each{ |k,v| @session[k] = v }
+      @session.update
+    end
   end
 
   def delete_test_session
-    @session.delete
-    @session = nil
+    # no way to delete a session by going through the session adpater in rails 2.3
+    if @session
+      @session.delete
+      @session = nil
+    end
   end
 
   # can be redefined in subclasses to clean out test sessions
@@ -133,6 +217,7 @@ class RailsBenchmark
   end
 
   def setup_test_urls(name)
+    @benchmark = name
     @urls = BenchmarkSpec.load(name)
   end
 
@@ -143,22 +228,34 @@ class RailsBenchmark
   end
 
   def setup_request_env(entry)
+    # $stderr.puts entry.inspect
     ENV['REQUEST_URI'] = @relative_url_root + entry.uri
-    ENV['RAW_POST_DATA'] = nil
-    ENV['QUERY_STRING'] = nil
+    ENV.delete 'RAW_POST_DATA'
+    ENV.delete 'QUERY_STRING'
     case ENV['REQUEST_METHOD'] = (entry.method || 'get').upcase
     when 'GET'
-      query_data = escape_data(entry.query_string || '')
+      query_data = entry.query_string || ''
+      query_data = escape_data(query_data) unless entry.raw_data
       ENV['QUERY_STRING'] = query_data
     when 'POST'
-      query_data = escape_data(entry.post_data || '')
+      query_data = entry.post_data || ''
+      query_data = escape_data(query_data) unless entry.raw_data
       ENV['RAW_POST_DATA'] = query_data
     end
     ENV['CONTENT_LENGTH'] = query_data.length.to_s
-    ENV['HTTP_COOKIE'] = entry.new_session ? '' : "_session_id=#{@session_id}"
+    ENV['HTTP_COOKIE'] = entry.new_session ? '' : cookie
+    ENV['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest' if entry.xhr
+    # $stderr.puts entry.session_data.inspect
     update_test_session_data(entry.session_data) unless entry.new_session
   end
 
+  def before_dispatch_hook(entry)
+  end
+
+  def cookie
+    "#{@session_key}=#{@session_id}#{cookie_data}"
+  end
+
   def escape_data(str)
     str.split('&').map{|e| e.split('=').map{|e| CGI::escape e}.join('=')}.join('&')
   end
@@ -169,7 +266,7 @@ class RailsBenchmark
     @urls.each do |entry|
       error_exit "No uri given for benchmark entry: #{entry.inspect}" unless entry.uri
       setup_request_env(entry)
-      Dispatcher.dispatch
+      Dispatcher.dispatch(CGI.new)
     end
   end
 
@@ -183,7 +280,7 @@ class RailsBenchmark
         svl = SvlRubyPV.new
       elsif ARGV.include?('-svlMV')
         require 'svlRubyMV'
-        svl = SvlRubyMV.new
+        svl = SvlRubyMV
       end
     rescue LoadError
       # SVL dll not available, do nothing
@@ -194,12 +291,20 @@ class RailsBenchmark
     ARGV.each{|arg| ruby_prof=$1 if arg =~ /-ruby_prof=([^ ]*)/ }
     begin
       if ruby_prof
-        # redirect stderr
+        # redirect stderr (TODO: I can't remember why we don't do this later)
         if benchmark_file = ENV['RAILS_BENCHMARK_FILE']
           $stderr = File.open(benchmark_file, "w")
         end
         require 'ruby-prof'
-        RubyProf.clock_mode = RubyProf::WALL_TIME
+        measure_mode = "WALL_TIME"
+        ARGV.each{|arg| measure_mode=$1.upcase if arg =~ /-measure_mode=([^ ]*)/ }
+        if %w(PROCESS_TIME WALL_TIME CPU_TIME ALLOCATIONS MEMORY).include?(measure_mode)
+          RubyProf.measure_mode = RubyProf.const_get measure_mode
+        else
+          $stderr = STDERR
+          $stderr.puts "unsupported ruby_prof measure mode: #{measure_mode}"
+          exit(-1)
+        end
         RubyProf.start
       end
     rescue LoadError
@@ -230,14 +335,61 @@ class RailsBenchmark
       GC.log "number of requests processed: #{@urls.size * iterations}"
     end
 
+    # try to detect Ruby interpreter memory leaks (OS X)
+    if ARGV.include?('-leaks')
+      leaks_log = "#{ENV['RAILS_PERF_DATA']}/leaks.log"
+      leaks_command = "leaks -nocontext #{$$} >#{leaks_log}"
+      ENV.delete 'MallocStackLogging'
+      # $stderr.puts "executing '#{leaks_command}'"
+      raise "could not execute leaks command" unless system(leaks_command)
+      mallocs, leaks = *`head -n 2 #{leaks_log}`.split("\n").map{|l| l.gsub(/Process #{$$}: /, '')}
+      if mem_leaks = (leaks =~ /(\d+) leaks for (\d+) total leaked bytes/)
+        $stderr.puts "\n!!!!! memory leaks detected !!!!! (#{leaks_log})"
+        $stderr.puts "=" * leaks.length
+      end
+      if gc_stats
+        GC.log mallocs
+        GC.log leaks
+      end
+      $stderr.puts mallocs, leaks
+      $stderr.puts "=" * leaks.length if mem_leaks
+    end
+
     # stop data collection if necessary
     svl.stopDataCollection if svl
 
     if defined? RubyProf
+      GC.disable #ruby-pof 0.7.x crash workaround
       result = RubyProf.stop
-      # Print a flat profile to text
-      printer = RubyProf::GraphHtmlPrinter.new(result)
-      printer.print($stderr, ruby_prof.to_f)
+      GC.enable  #ruby-pof 0.7.x crash workaround
+      min_percent = ruby_prof.split('/')[0].to_f rescue 0.1
+      threshold = ruby_prof.split('/')[1].to_f rescue 1.0
+      profile_type = nil
+      ARGV.each{|arg| profile_type=$1 if arg =~ /-profile_type=([^ ]*)/ }
+      profile_type ||= 'stack'
+      printer =
+        case profile_type
+        when 'stack' then RubyProf::CallStackPrinter
+        when 'grind' then RubyProf::CallTreePrinter
+        when 'flat'  then RubyProf::FlatPrinter
+        when 'graph' then RubyProf::GraphHtmlPrinter
+        when 'multi' then RubyProf::MultiPrinter
+        else raise "unknown profile type: #{profile_type}"
+        end.new(result)
+      if profile_type == 'multi'
+        raise "you must specify a benchmark file when using multi printer" unless $stderr.is_a?(File)
+        $stderr.close
+        $stderr = STDERR
+        file_name = ENV['RAILS_BENCHMARK_FILE']
+        profile_name = File.basename(file_name).sub('.html','').sub(".#{profile_type}",'')
+        printer.print(:path => File.dirname(file_name),
+                      :profile => profile_name,
+                      :min_percent => min_percent, :threshold => threshold,
+                      :title => "call tree/graph for benchmark #{@benchmark}")
+      else
+        printer.print($stderr, :min_percent => min_percent, :threshold => threshold,
+                      :title => "call tree for benchmark #{@benchmark}")
+      end
     end
 
     delete_test_session
@@ -273,7 +425,8 @@ class RailsBenchmark
       GC.enable; GC.start; GC.disable
       request_count = 0
       n.times do
-        Dispatcher.dispatch
+        before_dispatch_hook(entry)
+        Dispatcher.dispatch(CGI.new)
         if (request_count += 1) == gc_frequency
           GC.enable; GC.start; GC.disable
           request_count = 0
@@ -286,7 +439,8 @@ class RailsBenchmark
     urls.each do |entry|
       setup_request_env(entry)
       n.times do
-        Dispatcher.dispatch
+        before_dispatch_hook(entry)
+        Dispatcher.dispatch(CGI.new)
       end
     end
   end
@@ -302,7 +456,8 @@ class RailsBenchmark
         GC.enable; GC.start; GC.disable
         GC.enable_stats  if gc_stats
         n.times do
-          Dispatcher.dispatch
+          before_dispatch_hook(entry)
+          Dispatcher.dispatch(CGI.new)
           if (request_count += 1) == gc_freq
             GC.enable; GC.start; GC.disable
             request_count = 0
@@ -327,7 +482,8 @@ class RailsBenchmark
       GC.enable_stats  if gc_stats
       test.report(entry.name) do
         n.times do
-          Dispatcher.dispatch
+          before_dispatch_hook(entry)
+          Dispatcher.dispatch(CGI.new)
         end
       end
     end
@@ -348,7 +504,8 @@ class RailsBenchmark
       n.times do
         urls.each do |entry|
           setup_request_env(entry)
-          Dispatcher.dispatch
+          before_dispatch_hook(entry)
+          Dispatcher.dispatch(CGI.new)
         end
       end
     end
@@ -370,7 +527,8 @@ class RailsBenchmark
       n.times do
         urls.each do |entry|
           setup_request_env(entry)
-          Dispatcher.dispatch
+          before_dispatch_hook(entry)
+          Dispatcher.dispatch(CGI.new)
           if (request_count += 1) == gc_frequency
             GC.enable; GC.start; GC.disable
             request_count = 0
@@ -391,7 +549,7 @@ class RailsBenchmarkWithActiveRecordStore < RailsBenchmark
 
   def initialize(options={})
     super(options)
-    @session_class = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS[:database_manager].session_class rescue CGI::Session::ActiveRecordStore
+    @session_class = ActionController::CgiRequest::DEFAULT_SESSION_OPTIONS[:database_manager].session_class rescue CGI::Session::ActiveRecordStore rescue ActiveRecord::SessionStore
   end
 
   def delete_new_test_sessions
@@ -403,7 +561,7 @@ end
 
 __END__
 
-#  Copyright (C) 2005, 2006, 2007  Stefan Kaes
+#  Copyright (C) 2005-2008  Stefan Kaes
 #
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by

data/lib/railsbench/version.rb

@@ -1,9 +1,9 @@
-module Railsbench #:nodoc:
-  module VERSION #:nodoc:
-    MAJOR = 0
-    MINOR = 9
-    TINY  = 2
-
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-end
+module Railsbench #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 9
+    TINY  = 8
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end