ruby-prof 0.13.1 → 1.4.2

data/lib/ruby-prof/printers/multi_printer.rb

@@ -1,56 +1,127 @@
-# encoding: utf-8
-
-module RubyProf
-  # Helper class to simplify printing profiles of several types from
-  # one profiling run. Currently prints a flat profile, a callgrind
-  # profile, a call stack profile and a graph profile.
-  class MultiPrinter
-    def initialize(result)
-      @stack_printer = CallStackPrinter.new(result)
-      @graph_printer = GraphHtmlPrinter.new(result)
-      @tree_printer = CallTreePrinter.new(result)
-      @flat_printer = FlatPrinter.new(result)
-    end
-
-    # create profile files under options[:path] or the current
-    # directory. options[:profile] is used as the base name for the
-    # pofile file, defaults to "profile".
-    def print(options)
-      @profile = options.delete(:profile) || "profile"
-      @directory = options.delete(:path) || File.expand_path(".")
-      File.open(stack_profile, "w") do |f|
-        @stack_printer.print(f, options.merge(:graph => "#{@profile}.graph.html"))
-      end
-      File.open(graph_profile, "w") do |f|
-        @graph_printer.print(f, options)
-      end
-      File.open(tree_profile, "w") do |f|
-        @tree_printer.print(f, options)
-      end
-      File.open(flat_profile, "w") do |f|
-        @flat_printer.print(f, options)
-      end
-    end
-
-    # the name of the call stack profile file
-    def stack_profile
-      "#{@directory}/#{@profile}.stack.html"
-    end
-
-    # the name of the graph profile file
-    def graph_profile
-      "#{@directory}/#{@profile}.graph.html"
-    end
-
-    # the name of the callgrind profile file
-    def tree_profile
-      "#{@directory}/#{@profile}.grind.dat"
-    end
-
-    # the name of the flat profile file
-    def flat_profile
-      "#{@directory}/#{@profile}.flat.txt"
-    end
-
-  end
-end
+# encoding: utf-8
+
+module RubyProf
+  # Helper class to simplify printing profiles of several types from
+  # one profiling run. Currently prints a flat profile, a callgrind
+  # profile, a call stack profile and a graph profile.
+  class MultiPrinter
+    def initialize(result, printers = [:flat, :graph_html])
+      @flat_printer = FlatPrinter.new(result) if printers.include?(:flat)
+
+      @graph_printer = GraphPrinter.new(result) if printers.include?(:graph)
+      @graph_html_printer = GraphHtmlPrinter.new(result) if printers.include?(:graph_html)
+
+      @tree_printer = CallTreePrinter.new(result) if printers.include?(:tree)
+      @call_info_printer = CallInfoPrinter.new(result) if printers.include?(:call_tree)
+
+      @stack_printer = CallStackPrinter.new(result) if printers.include?(:stack)
+      @dot_printer = DotPrinter.new(result) if printers.include?(:dot)
+    end
+
+    def self.needs_dir?
+      true
+    end
+
+    # create profile files under options[:path] or the current
+    # directory. options[:profile] is used as the base name for the
+    # profile file, defaults to "profile".
+    def print(options)
+      validate_print_params(options)
+
+      @profile = options.delete(:profile) || "profile"
+      @directory = options.delete(:path) || File.expand_path(".")
+
+      print_to_flat(options) if @flat_printer
+
+      print_to_graph(options) if @graph_printer
+      print_to_graph_html(options) if @graph_html_printer
+
+      print_to_stack(options) if @stack_printer
+      print_to_call_info(options) if @call_info_printer
+      print_to_tree(options) if @tree_printer
+      print_to_dot(options) if @dot_printer
+    end
+
+    # the name of the flat profile file
+    def flat_report
+      "#{@directory}/#{@profile}.flat.txt"
+    end
+
+    # the name of the graph profile file
+    def graph_report
+      "#{@directory}/#{@profile}.graph.txt"
+    end
+
+    def graph_html_report
+      "#{@directory}/#{@profile}.graph.html"
+    end
+
+    # the name of the callinfo profile file
+    def call_info_report
+      "#{@directory}/#{@profile}.call_tree.txt"
+    end
+
+    # the name of the callgrind profile file
+    def tree_report
+      "#{@directory}/#{@profile}.callgrind.out.#{$$}"
+    end
+
+    # the name of the call stack profile file
+    def stack_report
+      "#{@directory}/#{@profile}.stack.html"
+    end
+
+    # the name of the call stack profile file
+    def dot_report
+      "#{@directory}/#{@profile}.dot"
+    end
+
+    def print_to_flat(options)
+      File.open(flat_report, "wb") do |file|
+        @flat_printer.print(file, options)
+      end
+    end
+
+    def print_to_graph(options)
+      File.open(graph_report, "wb") do |file|
+        @graph_printer.print(file, options)
+      end
+    end
+
+    def print_to_graph_html(options)
+      File.open(graph_html_report, "wb") do |file|
+        @graph_html_printer.print(file, options)
+      end
+    end
+
+    def print_to_call_info(options)
+      File.open(call_info_report, "wb") do |file|
+        @call_info_printer.print(file, options)
+      end
+    end
+
+    def print_to_tree(options)
+      @tree_printer.print(options.merge(:path => @directory, :profile => @profile))
+    end
+
+    def print_to_stack(options)
+      File.open(stack_report, "wb") do |file|
+        @stack_printer.print(file, options.merge(:graph => "#{@profile}.graph.html"))
+      end
+    end
+
+    def print_to_dot(options)
+      File.open(dot_report, "wb") do |file|
+        @dot_printer.print(file, options)
+      end
+    end
+
+    def validate_print_params(options)
+      if options.is_a?(IO)
+        raise ArgumentError, "#{self.class.name}#print cannot print to IO objects"
+      elsif !options.is_a?(Hash)
+        raise ArgumentError, "#{self.class.name}#print requires an options hash"
+      end
+    end
+  end
+end

data/lib/ruby-prof/profile.rb

@@ -1,77 +1,37 @@
-# encoding: utf-8
-
-require 'set'
-module RubyProf
-  class Profile
-    # This method gets called once profiling has been completed
-    # but before results are returned to the user.  Thus it provides
-    # a hook to do any necessary post-processing on the call graph.
-    def post_process
-      self.threads.each do |thread|
-        detect_recursion(thread)
-      end
-    end
-
-    # This method detect recursive calls in the call graph.
-    def detect_recursion(thread)
-      visited_methods = Hash.new do |hash, key|
-        hash[key] = 0
-      end
-
-      visitor = CallInfoVisitor.new(thread)
-      visitor.visit do |call_info, event|
-        case event
-        when :enter
-          visited_methods[call_info.target] += 1
-          call_info.recursive = (visited_methods[call_info.target] > 1)
-        when :exit
-          visited_methods[call_info.target] -= 1
-          if visited_methods[call_info.target] == 0
-            visited_methods.delete(call_info.target)
-          end
-        end
-      end
-    end
-
-    # eliminate some calls from the graph by merging the information into callers.
-    # matchers can be a list of strings or regular expressions or the name of a file containing regexps.
-    def eliminate_methods!(matchers)
-      matchers = read_regexps_from_file(matchers) if matchers.is_a?(String)
-      eliminated = []
-      threads.each do |thread|
-        matchers.each{ |matcher| eliminated.concat(eliminate_methods(thread.methods, matcher)) }
-      end
-      eliminated
-    end
-
-    private
-
-    # read regexps from file
-    def read_regexps_from_file(file_name)
-      matchers = []
-      File.open(file_name).each_line do |l|
-        next if (l =~ /^(#.*|\s*)$/) # emtpy lines and lines starting with #
-        matchers << Regexp.new(l.strip)
-      end
-    end
-
-    # eliminate methods matching matcher
-    def eliminate_methods(methods, matcher)
-      eliminated = []
-      i = 0
-      while i < methods.size
-        method_info = methods[i]
-        method_name = method_info.full_name
-        if matcher === method_name
-          raise "can't eliminate root method" if method_info.root?
-          eliminated << methods.delete_at(i)
-          method_info.eliminate!
-        else
-          i += 1
-        end
-      end
-      eliminated
-    end
-
-  end
-end
+# encoding: utf-8
+
+require 'ruby-prof/exclude_common_methods'
+
+module RubyProf
+  class Profile
+    # :nodoc:
+    def measure_mode_string
+      case self.measure_mode
+        when WALL_TIME
+          "wall_time"
+        when PROCESS_TIME
+          "process_time"
+        when ALLOCATIONS
+          "allocations"
+        when MEMORY
+          "memory"
+      end
+    end
+
+    # Hides methods that, when represented as a call graph, have
+    # extremely large in and out degrees and make navigation impossible.
+    def exclude_common_methods!
+      ExcludeCommonMethods.apply!(self)
+    end
+
+    def exclude_methods!(mod, *method_or_methods)
+      [method_or_methods].flatten.each do |name|
+        exclude_method!(mod, name)
+      end
+    end
+
+    def exclude_singleton_methods!(mod, *method_or_methods)
+      exclude_methods!(mod.singleton_class, *method_or_methods)
+    end
+  end
+end

data/lib/ruby-prof/rack.rb

@@ -7,42 +7,89 @@ module Rack
       @app = app
       @options = options
       @options[:min_percent] ||= 1
+
       @tmpdir = options[:path] || Dir.tmpdir
+      FileUtils.mkdir_p(@tmpdir)
+
       @printer_klasses = @options[:printers]  || {::RubyProf::FlatPrinter => 'flat.txt',
                                                   ::RubyProf::GraphPrinter => 'graph.txt',
                                                   ::RubyProf::GraphHtmlPrinter => 'graph.html',
                                                   ::RubyProf::CallStackPrinter => 'call_stack.html'}
 
-      @skip_paths = options[:skip_paths] || [%r{^/assets}, %r{\.css$}, %r{\.js$}, %r{\.png$}, %r{\.jpeg$}, %r{\.jpg$}, %r{\.gif$}]
+      @skip_paths = options[:skip_paths] || [%r{^/assets}, %r{\.(css|js|png|jpeg|jpg|gif)$}]
+      @only_paths = options[:only_paths]
     end
 
     def call(env)
       request = Rack::Request.new(env)
 
-      if @skip_paths.any? {|skip_path| skip_path =~ request.path}
-        @app.call(env)
-      else
-        result = nil
-        data = ::RubyProf::Profile.profile do
-          result = @app.call(env)
+      if should_profile?(request.path)
+        begin
+          result = nil
+          data = ::RubyProf::Profile.profile(profiling_options) do
+            result = @app.call(env)
+          end
+
+          path = request.path.gsub('/', '-')
+          path.slice!(0)
+
+          print(data, path)
+          result
         end
+      else
+        @app.call(env)
+      end
+    end
 
-        path = request.path.gsub('/', '-')
-        path.slice!(0)
+    private
 
-        print(data, path)
-        result
+    def should_profile?(path)
+      return false if paths_match?(path, @skip_paths)
+
+      @only_paths ? paths_match?(path, @only_paths) : true
+    end
+
+    def paths_match?(path, paths)
+      paths.any? { |skip_path| skip_path =~ path }
+    end
+
+    def profiling_options
+      options = {}
+      options[:measure_mode] = ::RubyProf.measure_mode
+      options[:exclude_threads] =
+        if @options[:ignore_existing_threads]
+          Thread.list.select{|t| t != Thread.current}
+        else
+          ::RubyProf.exclude_threads
+        end
+      if @options[:request_thread_only]
+        options[:include_threads] = [Thread.current]
+      end
+      if @options[:merge_fibers]
+        options[:merge_fibers] = true
       end
+      options
     end
 
     def print(data, path)
       @printer_klasses.each do |printer_klass, base_name|
         printer = printer_klass.new(data)
-        file_name = ::File.join(@tmpdir, "#{path}-#{base_name}")
-        ::File.open(file_name, 'wb') do |file|
-          printer.print(file, @options)
+
+        if base_name.respond_to?(:call)
+          base_name = base_name.call
+        end
+
+        if printer_klass == ::RubyProf::MultiPrinter
+          printer.print(@options.merge(:profile => "#{path}-#{base_name}"))
+        elsif printer_klass == ::RubyProf::CallTreePrinter
+          printer.print(@options.merge(:profile => "#{path}-#{base_name}"))
+        else
+          file_name = ::File.join(@tmpdir, "#{path}-#{base_name}")
+          ::File.open(file_name, 'wb') do |file|
+            printer.print(file, @options)
+          end
         end
       end
     end
   end
-end
+end

data/lib/ruby-prof/task.rb

@@ -1,147 +1,147 @@
-#!/usr/bin/env ruby
-# encoding: utf-8
-
-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
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+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