ruby-prof 0.11.0.rc1 → 0.11.0.rc2

data/lib/ruby-prof/{flat_printer_with_line_numbers.rb → printers/flat_printer_with_line_numbers.rb}

@@ -12,21 +12,10 @@ module RubyProf
   #   printer.print(STDOUT, {})
   #
   class FlatPrinterWithLineNumbers < FlatPrinter
+    def print_methods(thread)
+      total_time = thread.top_method.total_time
 
-    def print_methods(thread_id, methods)
-      # Get total time
-      toplevel = methods.max
-      total_time = toplevel.total_time
-      if total_time == 0
-        total_time = 0.01
-      end
-
-      methods = methods.sort_by(&sort_method).reverse
-
-      @output << "Thread ID: %d\n" % thread_id
-      @output << "Total: %0.6f\n" % total_time
-      @output << "\n"
-      @output << " %self     total     self     wait    child    calls  name\n"
+      methods = thread.methods.sort_by(&sort_method).reverse
       sum = 0
       methods.each do |method|
         self_percent = (method.self_time / total_time) * 100
@@ -36,15 +25,16 @@ module RubyProf
         #self_time_called = method.called > 0 ? method.self_time/method.called : 0
         #total_time_called = method.called > 0? method.total_time/method.called : 0
 
-        @output << "%6.2f  %8.2f %8.2f %8.2f %8.2f %8d  %s " % [
-                      method.self_time / total_time * 100, # %self
-                      method.total_time,                   # total
-                      method.self_time,                    # self
-                      method.wait_time,                    # wait
-                      method.children_time,                # children
-                      method.called,                       # calls
-                      method_name(method),                 # name
-                  ]
+        @output << "%6.2f  %8.2f %8.2f %8.2f %8.2f %8d  %s%s \n" % [
+            method.self_time / total_time * 100, # %self
+            method.total_time,                   # total
+            method.self_time,                    # self
+            method.wait_time,                    # wait
+            method.children_time,                # children
+            method.called,                       # calls
+            method.recursive? ? "*" : " ",       # cycle
+            method_name(method)                  # name
+        ]
          if method.source_file != 'ruby_runtime'
            @output << "  %s:%s" % [File.expand_path(method.source_file), method.line]
          end
@@ -64,5 +54,4 @@ module RubyProf
       end
     end
   end
-end
-
+end

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

@@ -0,0 +1,248 @@
+# encoding: utf-8
+
+require 'erb'
+
+module RubyProf
+  # Generates graph[link:files/examples/graph_html.html] profile reports as html.
+  # To use the graph html printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::GraphHtmlPrinter.new(result)
+  #   printer.print(STDOUT, :min_percent=>0)
+  #
+  # The Graph printer takes the following options in its print methods:
+  #   :filename    - specify a file to use that contains the ERB
+  #                  template to use, instead of the built-in self.template
+  #
+  #   :template    - specify an ERB template to use, instead of the
+  #                  built-in self.template
+  #
+
+  class GraphHtmlPrinter < AbstractPrinter
+    include ERB::Util
+
+    PERCENTAGE_WIDTH = 8
+    TIME_WIDTH = 10
+    CALL_WIDTH = 20
+
+    def setup_options(options)
+      super(options)
+
+      filename = options[:filename]
+      template = filename ? File.read(filename).untaint : (options[:template] || self.template)
+      @erb = ERB.new(template, nil, nil)
+      @erb.filename = filename
+    end
+
+    def print(output = STDOUT, options = {})
+      @output = output
+      setup_options(options)
+      _erbout = @output
+      @output << @erb.result(binding)
+    end
+
+    # Creates a link to a method.  Note that we do not create
+    # links to methods which are under the min_perecent
+    # specified by the user, since they will not be
+    # printed out.
+    def create_link(thread, method)
+      overall_time = thread.top_method.total_time
+      total_percent = (method.total_time/overall_time) * 100
+      if total_percent < min_percent
+        # Just return name
+        h method.full_name
+      else
+        href = '#' + method_href(thread, method)
+        "<a href=\"#{href}\">#{h method.full_name}</a>"
+      end
+    end
+
+    def method_href(thread, method)
+      h(method.full_name.gsub(/[><#\.\?=:]/,"_") + "_" + thread.id.to_s)
+    end
+
+    def file_link(path, linenum)
+      srcfile = File.expand_path(path)
+      if srcfile =~ /\/ruby_runtime$/
+        ""
+      else
+        if RUBY_PLATFORM =~ /darwin/
+          "<a href=\"txmt://open?url=file://#{h srcfile}&line=#{linenum}\" title=\"#{h srcfile}:#{linenum}\">#{linenum}</a>"
+        else
+          "<a href=\"file://#{h srcfile}##{linenum}\" title=\"#{h srcfile}:#{linenum}\">#{linenum}</a>"
+        end
+      end
+    end
+
+    def template
+'
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+<head>
+  <style media="all" type="text/css">
+    table {
+      border-collapse: collapse;
+      border: 1px solid #CCC;
+      font-family: Verdana, Arial, Helvetica, sans-serif;
+      font-size: 9pt;
+      line-height: normal;
+      width: 100%;
+    }
+
+    th {
+      text-align: center;
+      border-top: 1px solid #FB7A31;
+      border-bottom: 1px solid #FB7A31;
+      background: #FFC;
+      padding: 0.3em;
+      border-left: 1px solid silver;
+    }
+
+    tr.break td {
+      border: 0;
+      border-top: 1px solid #FB7A31;
+      padding: 0;
+      margin: 0;
+    }
+
+    tr.method td {
+      font-weight: bold;
+    }
+
+    td {
+      padding: 0.3em;
+    }
+
+    td:first-child {
+      width: 190px;
+      }
+
+    td {
+      border-left: 1px solid #CCC;
+      text-align: center;
+    }
+
+    .method_name {
+      text-align: left;
+    }
+
+    tfoot td {
+      text-align: left;
+    }
+  </style>
+  </head>
+  <body>
+    <h1>Profile Report</h1>
+    <!-- Threads Table -->
+    <table>
+      <tr>
+        <th>Thread ID</th>
+        <th>Total Time</th>
+      </tr>
+      <% for thread in @result.threads %>
+      <tr>
+        <td><a href="#<%= thread.id %>"><%= thread.id %></a></td>
+        <td><%= thread.top_method.total_time %></td>
+      </tr>
+      <% end %>
+    </table>
+
+    <!-- Methods Tables -->
+    <% for thread in @result.threads
+         methods = thread.methods
+         total_time = thread.top_method.total_time %>
+      <h2><a name="<%= thread.id %>">Thread <%= thread.id %></a></h2>
+
+      <table>
+        <thead>
+          <tr>
+            <th><%= sprintf("%#{PERCENTAGE_WIDTH}s", "%Total") %></th>
+            <th><%= sprintf("%#{PERCENTAGE_WIDTH}s", "%Self") %></th>
+            <th><%= sprintf("%#{TIME_WIDTH}s", "Total") %></th>
+            <th><%= sprintf("%#{TIME_WIDTH}s", "Self") %></th>
+            <th><%= sprintf("%#{TIME_WIDTH}s", "Wait") %></th>
+            <th><%= sprintf("%#{TIME_WIDTH+2}s", "Child") %></th>
+            <th><%= sprintf("%#{CALL_WIDTH}s", "Calls") %></th>
+            <th class="method_name">Name</th>
+            <th>Line</th>
+          </tr>
+        </thead>
+
+        <tbody>
+          <% min_time = @options[:min_time] || (@options[:nonzero] ? 0.005 : nil)
+             methods.sort_by(&sort_method).reverse_each do |method|
+              total_percentage = (method.total_time/total_time) * 100
+              next if total_percentage < min_percent
+              next if min_time && method.total_time < min_time
+              self_percentage = (method.self_time/total_time) * 100 %>
+
+              <!-- Parents -->
+              <% for caller in method.aggregate_parents.sort_by(&:total_time)
+                   next unless caller.parent
+                   next if min_time && caller.total_time < min_time  %>
+                <tr>
+                  <td>&nbsp;</td>
+                  <td>&nbsp;</td>
+                  <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.total_time) %></td>
+                  <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.self_time) %></td>
+                  <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.wait_time) %></td>
+                  <td><%= sprintf("%#{TIME_WIDTH}.2f", caller.children_time) %></td>
+                  <% called = "#{caller.called}/#{method.called}" %>
+                  <td><%= sprintf("%#{CALL_WIDTH}s", called) %></td>
+                  <td class="method_name"><%= create_link(thread, caller.parent.target) %></td>
+                  <td><%= file_link(caller.parent.target.source_file, caller.line) %></td>
+                </tr>
+              <% end %>
+
+              <tr class="method">
+                <td><%= sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", total_percentage) %></td>
+                <td><%= sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", self_percentage) %></td>
+                <td><%= sprintf("%#{TIME_WIDTH}.2f", method.total_time) %></td>
+                <td><%= sprintf("%#{TIME_WIDTH}.2f", method.self_time) %></td>
+                <td><%= sprintf("%#{TIME_WIDTH}.2f", method.wait_time) %></td>
+                <td><%= sprintf("%#{TIME_WIDTH}.2f", method.children_time) %></td>
+                <td><%= sprintf("%#{CALL_WIDTH}i", method.called) %></td>
+                <td class="method_name">
+                  <a name="<%= method_href(thread, method) %>">
+                    <%= method.recursive? ? "*" : " "%><%= h method.full_name %>
+                  </a>
+                </td>
+                <td><%= file_link(method.source_file, method.line) %></td>
+              </tr>
+
+              <!-- Children -->
+              <% for callee in method.aggregate_children.sort_by(&:total_time).reverse %>
+              <%   next if min_time && callee.total_time < min_time  %>
+                <tr>
+                  <td>&nbsp;</td>
+                  <td>&nbsp;</td>
+                  <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.total_time) %></td>
+                  <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.self_time) %></td>
+                  <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.wait_time) %></td>
+                  <td><%= sprintf("%#{TIME_WIDTH}.2f", callee.children_time) %></td>
+                  <% called = "#{callee.called}/#{callee.target.called}" %>
+                  <td><%= sprintf("%#{CALL_WIDTH}s", called) %></td>
+                  <td class="method_name"><%= create_link(thread, callee.target) %></td>
+                  <td><%= file_link(method.source_file, callee.line) %></td>
+                </tr>
+              <% end %>
+              <!-- Create divider row -->
+              <tr class="break"><td colspan="9"></td></tr>
+          <% end %>
+        </tbody>
+        <tfoot>
+          <tr>
+            <td colspan="9">* in front of method name means it is recursively called</td>
+          </tr>
+        </tfoot>
+      </table>
+    <% end %>
+  </body>
+</html>'
+    end
+  end
+end
+

data/lib/ruby-prof/{graph_printer.rb → printers/graph_printer.rb}

@@ -18,60 +18,30 @@ module RubyProf
     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.max
-
-        thread_time = [top.total_time, 0.01].max
-
-        @thread_times[thread_id] = thread_time
-      end
-    end
+    private
 
-    # 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
+    def print_header(thread)
+      @output << "Thread ID: #{thread.id}\n"
+      @output << "Total Time: #{thread.top_method.total_time}\n"
+      @output << "Sort by: #{sort_method}\n"
+      @output << "\n"
 
-    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
+      # 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_methods(thread_id, methods)
+    def print_methods(thread)
+      total_time = thread.top_method.total_time
       # Sort methods from longest to shortest total time
-      methods = methods.sort_by(&sort_method)
-
-      toplevel = methods.last
-      total_time = toplevel.total_time
-      if total_time == 0
-        total_time = 0.01
-      end
-
-      print_heading(thread_id)
+      methods = thread.methods.sort_by(&sort_method)
 
       # Print each method in total time order
       methods.reverse_each do |method|
@@ -82,7 +52,7 @@ module RubyProf
 
         @output << "-" * 80 << "\n"
 
-        print_parents(thread_id, method)
+        print_parents(thread, method)
 
         # 1 is for % sign
         @output << sprintf("%#{PERCENTAGE_WIDTH-1}.2f\%", total_percentage)
@@ -92,7 +62,8 @@ module RubyProf
         @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))
+        @output << sprintf("     %s",  method.recursive? ? "*" : " ")
+        @output << sprintf("%s", method_name(method))
         if print_file
           @output << sprintf("  %s:%s", method.source_file, method.line)
         end
@@ -102,24 +73,7 @@ module RubyProf
       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)
+    def print_parents(thread, method)
       method.aggregate_parents.sort_by(&:total_time).each do |caller|
         next unless caller.parent
         @output << " " * 2 * PERCENTAGE_WIDTH
@@ -130,7 +84,7 @@ module RubyProf
 
         call_called = "#{caller.called}/#{method.called}"
         @output << sprintf("%#{CALL_WIDTH}s", call_called)
-        @output << sprintf("     %s", caller.parent.target.full_name)
+        @output << sprintf("      %s", caller.parent.target.full_name)
         @output << "\n"
       end
     end
@@ -148,10 +102,14 @@ module RubyProf
 
         call_called = "#{child.called}/#{child.target.called}"
         @output << sprintf("%#{CALL_WIDTH}s", call_called)
-        @output << sprintf("     %s", child.target.full_name)
+        @output << sprintf("      %s", child.target.full_name)
         @output << "\n"
       end
     end
-  end
-end
 
+    def print_footer(thread)
+      @output << "\n"
+      @output << "* in front of method name means it is recursively called\n"
+    end
+  end
+end