ruby-prof 0.6.0-x86-mswin32-60

data/lib/ruby-prof/graph_printer.rb

@@ -0,0 +1,163 @@
+require 'ruby-prof/abstract_printer'
+
+module RubyProf
+  # Generates graph[link:files/examples/graph_txt.html] profile reports as text. 
+  # To use the graph printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::GraphPrinter.new(result, 5)
+  #   printer.print(STDOUT, 0)
+  #
+  # The constructor takes two arguments.  The first is
+  # a RubyProf::Result object generated from a profiling
+  # run.  The second is the minimum %total (the methods 
+  # total time divided by the overall total time) that
+  # a method must take for it to be printed out in 
+  # the report.  Use this parameter to eliminate methods
+  # that are not important to the overall profiling results.
+
+  class GraphPrinter < AbstractPrinter
+    PERCENTAGE_WIDTH = 8
+    TIME_WIDTH = 10
+    CALL_WIDTH = 17
+  
+    # Create a GraphPrinter.  Result is a RubyProf::Result  
+    # object generated from a profiling run.
+    def initialize(result)
+      super(result)
+      @thread_times = Hash.new
+      calculate_thread_times
+    end
+
+    def calculate_thread_times
+      # Cache thread times since this is an expensive
+      # operation with the required sorting      
+      @result.threads.each do |thread_id, methods|
+        top = methods.sort.last
+        
+        thread_time = 0.01
+        thread_time = top.total_time if top.total_time > 0
+
+        @thread_times[thread_id] = thread_time 
+      end
+    end
+    
+    # Print a graph report to the provided output.
+    # 
+    # output - Any IO oject, including STDOUT or a file. 
+    # The default value is STDOUT.
+    # 
+    # options - Hash of print options.  See #setup_options 
+    #           for more information.
+    #
+    def print(output = STDOUT, options = {})
+      @output = output
+      setup_options(options)
+      print_threads
+    end
+
+    private 
+    def print_threads
+      # sort assumes that spawned threads have higher object_ids
+      @result.threads.sort.each do |thread_id, methods|
+        print_methods(thread_id, methods)
+        @output << "\n" * 2
+      end
+    end
+    
+    def print_methods(thread_id, methods)
+      # Sort methods from longest to shortest total time
+      methods = methods.sort
+      
+      toplevel = methods.last
+      total_time = toplevel.total_time
+      if total_time == 0
+        total_time = 0.01
+      end
+      
+      print_heading(thread_id)
+    
+      # Print each method in total time order
+      methods.reverse_each do |method|
+        total_percentage = (method.total_time/total_time) * 100
+        self_percentage = (method.self_time/total_time) * 100
+        
+        next if total_percentage < min_percent
+        
+        @output << "-" * 80 << "\n"
+
+        print_parents(thread_id, method)
+    
+        # 1 is for % sign
+        @output << sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", total_percentage)
+        @output << sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", self_percentage)
+        @output << sprintf("%#{TIME_WIDTH}.2f", method.total_time)
+        @output << sprintf("%#{TIME_WIDTH}.2f", method.self_time)
+        @output << sprintf("%#{TIME_WIDTH}.2f", method.wait_time)
+        @output << sprintf("%#{TIME_WIDTH}.2f", method.children_time)
+        @output << sprintf("%#{CALL_WIDTH}i", method.called)
+        @output << sprintf("     %s", method_name(method))
+        if print_file
+          @output << sprintf("  %s:%s", method.source_file, method.line)
+        end          
+        @output << "\n"
+    
+        print_children(method)
+      end
+    end
+  
+    def print_heading(thread_id)
+      @output << "Thread ID: #{thread_id}\n"
+      @output << "Total Time: #{@thread_times[thread_id]}\n"
+      @output << "\n"
+      
+      # 1 is for % sign
+      @output << sprintf("%#{PERCENTAGE_WIDTH}s", "%total")
+      @output << sprintf("%#{PERCENTAGE_WIDTH}s", "%self")
+      @output << sprintf("%#{TIME_WIDTH}s", "total")
+      @output << sprintf("%#{TIME_WIDTH}s", "self")
+      @output << sprintf("%#{TIME_WIDTH}s", "wait")
+      @output << sprintf("%#{TIME_WIDTH}s", "child")
+      @output << sprintf("%#{CALL_WIDTH}s", "calls")
+      @output << "   Name"
+      @output << "\n"
+    end
+    
+    def print_parents(thread_id, method)
+      method.parents.each do |caller|
+        @output << " " * 2 * PERCENTAGE_WIDTH
+        @output << sprintf("%#{TIME_WIDTH}.2f", caller.total_time)
+        @output << sprintf("%#{TIME_WIDTH}.2f", caller.self_time)
+        @output << sprintf("%#{TIME_WIDTH}.2f", caller.wait_time)
+        @output << sprintf("%#{TIME_WIDTH}.2f", caller.children_time)
+    
+        call_called = "#{caller.called}/#{method.called}"
+        @output << sprintf("%#{CALL_WIDTH}s", call_called)
+        @output << sprintf("     %s", caller.target.full_name)
+        @output << "\n"
+      end
+    end
+  
+    def print_children(method)
+      method.children.each do |child|
+        # Get children method
+        
+        @output << " " * 2 * PERCENTAGE_WIDTH
+        
+        @output << sprintf("%#{TIME_WIDTH}.2f", child.total_time)
+        @output << sprintf("%#{TIME_WIDTH}.2f", child.self_time)
+        @output << sprintf("%#{TIME_WIDTH}.2f", child.wait_time)
+        @output << sprintf("%#{TIME_WIDTH}.2f", child.children_time)
+
+        call_called = "#{child.called}/#{child.target.called}"
+        @output << sprintf("%#{CALL_WIDTH}s", call_called)
+        @output << sprintf("     %s", child.target.full_name)
+        @output << "\n"
+      end
+    end
+  end
+end 
+

data/lib/ruby-prof/profile_test_case.rb

@@ -0,0 +1,80 @@
+# Make sure to first load the libraries we will override
+require 'test/unit'
+require 'ruby-prof'
+
+module Test
+  module Unit
+    class TestCase
+      
+      alias :run__profile__ :run
+      
+      def run(result, &block)
+        test_name = @method_name.to_sym
+        alias_test_name = (@method_name + '__profile__').to_sym
+        
+        self.class.class_eval("alias :#{alias_test_name} :#{test_name}")
+                
+        self.class.send(:define_method, test_name) do 
+          # Run the profiler        
+          RubyProf.start
+          __send__(alias_test_name)
+          result = RubyProf.stop
+      
+          create_output_directory
+            
+          # Get the result file name
+          file_name = name.gsub(/\(/, '_').gsub(/\)/, '')
+          file_name = self.underscore(file_name)
+          file_path = File.join(output_directory, file_name)
+          file_path += file_extension
+      
+          # Create a printer
+          printer = self.printer.new(result)
+    
+          # Write the results
+          File.open(file_path, 'w') do |file|
+            printer.print(file, min_percent)
+          end
+        end
+        
+        self.run__profile__(result, &block)
+      end
+      
+      # Taken from rails
+      def underscore(camel_cased_word)
+        camel_cased_word.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").downcase
+      end
+
+      # Add some additional methods
+      def min_percent
+        1
+      end
+      
+      def output_directory
+        # Put results in subdirectory called profile
+        File.join(Dir.getwd, 'profile')
+      end
+    
+      def create_output_directory
+        if not File.exist?(output_directory)
+          Dir.mkdir(output_directory)
+        end
+      end
+
+      def file_extension
+        if printer == RubyProf::FlatPrinter
+          '.html'
+        else
+          '.txt'
+        end
+      end
+    
+      def printer
+        RubyProf::GraphHtmlPrinter
+      end
+    end
+  end
+end

data/lib/ruby-prof/task.rb

@@ -0,0 +1,147 @@
+#!/usr/bin/env ruby
+
+require 'rake'
+require 'rake/testtask'
+require 'fileutils'
+
+module RubyProf
+
+  # Define a task library for profiling unit tests with ruby-prof.
+  #
+  # All of the options provided by
+  # the Rake:TestTask are supported except the loader
+  # which is set to ruby-prof.  For detailed information
+  # please refer to the Rake:TestTask documentation.
+  #
+  # ruby-prof specific options include:
+  #
+  #   output_dir - For each file specified an output 
+  #                file with profile information will be
+  #                written to the output directory.
+  #                By default, the output directory is
+  #                called "profile" and is created underneath
+  #                the current working directory.
+  #
+  #   printer - Specifies the output printer.  Valid values include
+  #             :flat, :graph, :graph_html and :call_tree.
+  #
+  #   min_percent - Methods that take less than the specified percent
+  #                 will not be written out.
+  #
+  # Example:
+  #   
+  #   require 'ruby-prof/task'
+  #   
+  #   RubyProf::ProfileTask.new do |t|
+  #     t.test_files = FileList['test/test*.rb']
+  #     t.output_dir = "c:/temp"
+  #     t.printer = :graph
+  #     t.min_percent = 10
+  #   end
+  #
+  # If rake is invoked with a "TEST=filename" command line option,
+  # then the list of test files will be overridden to include only the
+  # filename specified on the command line.  This provides an easy way
+  # to run just one test.
+  #
+  # If rake is invoked with a "TESTOPTS=options" command line option,
+  # then the given options are passed to the test process after a
+  # '--'.  This allows Test::Unit options to be passed to the test
+  # suite.
+  #
+  # Examples:
+  #
+  #   rake profile                           # run tests normally
+  #   rake profile TEST=just_one_file.rb     # run just one test file.
+  #   rake profile TESTOPTS="-v"             # run in verbose mode
+  #   rake profile TESTOPTS="--runner=fox"   # use the fox test runner
+  
+  class ProfileTask < Rake::TestTask
+    attr_accessor :output_dir 
+    attr_accessor :min_percent 
+    attr_accessor :printer
+    
+    def initialize(name = :profile)
+      super(name)
+    end
+    
+    # Create the tasks defined by this task lib.
+    def define
+      lib_path = @libs.join(File::PATH_SEPARATOR)
+      desc "Profile" + (@name==:profile ? "" : " for #{@name}")
+      
+      task @name do
+        create_output_directory
+        
+        @ruby_opts.unshift( "-I#{lib_path}" )
+        @ruby_opts.unshift( "-w" ) if @warning
+        @ruby_opts.push("-S ruby-prof")
+        @ruby_opts.push("--printer #{@printer}")
+        @ruby_opts.push("--min_percent #{@min_percent}")
+
+        file_list.each do |file_path|  
+          run_script(file_path)
+        end
+      end
+      self
+    end
+    
+    # Run script
+    def run_script(script_path)
+      run_code = ''
+      RakeFileUtils.verbose(@verbose) do
+        file_name = File.basename(script_path, File.extname(script_path))
+        case @printer
+          when :flat, :graph, :call_tree
+            file_name += ".txt"
+          when :graph_html
+            file_name += ".html"
+          else
+            file_name += ".txt"
+        end
+          
+        output_file_path = File.join(output_directory, file_name)
+          
+        command_line = @ruby_opts.join(" ") + 
+                      " --file=" + output_file_path +
+                      " " + script_path
+
+        puts "ruby " + command_line 
+        # We have to catch the exeption to continue on.  However,
+        # the error message will have been output to STDERR
+        # already by the time we get here so we don't have to
+        # do that again
+        begin
+          ruby command_line
+        rescue => e
+          STDOUT << e << "\n"
+          STDOUT.flush
+        end
+        puts ""
+        puts ""
+      end
+    end
+
+    def output_directory
+      File.expand_path(@output_dir)
+    end
+    
+    def create_output_directory
+      if not File.exist?(output_directory)
+        Dir.mkdir(output_directory)
+      end
+    end
+
+    def clean_output_directory
+      if File.exist?(output_directory)
+        files = Dir.glob(output_directory + '/*')
+        FileUtils.rm(files)
+      end
+    end
+    
+    def option_list # :nodoc:
+      ENV['OPTIONS'] || @options.join(" ") || ""
+    end
+  end
+end
+

data/lib/unprof.rb

@@ -0,0 +1,8 @@
+require "ruby-prof"
+
+at_exit {
+  result = RubyProf.stop
+  printer = RubyProf::FlatPrinter.new(result)
+  printer.print(STDOUT)
+}
+RubyProf.start

data/rails_plugin/ruby-prof/init.rb

@@ -0,0 +1,8 @@
+require 'profiling'
+
+# Grab log path from current rails configuration
+ActionController::Profiling::LOG_PATH = File.expand_path(File.dirname(config.log_path))
+
+ActionController::Base.class_eval do
+  include ActionController::Profiling
+end

data/rails_plugin/ruby-prof/lib/profiling.rb

@@ -0,0 +1,57 @@
+require 'ruby-prof'
+
+module ActionController #:nodoc:
+  # The ruby-prof module times the performance of actions and reports to the logger. If the Active Record
+  # package has been included, a separate timing section for database calls will be added as well.
+  module Profiling #:nodoc:
+    LOG_PATH = nil
+
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :perform_action, :profiling
+      end
+    end
+
+    def perform_action_with_profiling
+      # Profling could be running if this
+      # is a render_component call.
+      if RubyProf.running? or not logger 
+        perform_action_without_profiling
+      else
+        result = RubyProf.profile do
+          perform_action_without_profiling
+        end
+        
+        output = StringIO.new
+        output << " [#{complete_request_uri rescue "unknown"}]"
+        output << "\n\n"
+        
+        # Create a flat printer
+        printer = RubyProf::FlatPrinter.new(result)
+        
+        # Skip anything less than 1% - which is a lot of
+        # stuff in Rails. Don't print the source file
+        # its too noisy.
+        printer.print(output, {:min_percent => 1,
+                               :print_file => false})
+        logger.info(output.string)
+        
+        ## Example for Graph html printer
+        #printer = RubyProf::GraphHtmlPrinter.new(result)
+        #path = File.join(LOG_PATH, 'call_graph.html')
+        #File.open(path, 'w') do |file|
+          #printer.print(file, {:min_percent => 1,
+                               #:print_file => true})
+        #end   
+        
+        ## Used for KCacheGrind visualizations
+        #printer = RubyProf::CallTreePrinter.new(result)
+        #path = File.join(LOG_PATH, 'callgrind.out')
+        #File.open(path, 'w') do |file|
+          #printer.print(file, {:min_percent => 1,
+                               #:print_file => true})
+        #end          
+      end
+    end
+  end
+end