acunote-ruby-prof 0.9.2

data/lib/ruby-prof/call_tree_printer.rb

@@ -0,0 +1,133 @@
+require 'ruby-prof/abstract_printer'
+
+module RubyProf
+  # Generate profiling information in calltree format
+  # for use by kcachegrind and similar tools.
+
+  class CallTreePrinter  < AbstractPrinter
+    def print(output = STDOUT, options = {})
+      @output = output
+      setup_options(options)
+
+      # add a header - this information is somewhat arbitrary
+      @output << "events: "
+      case RubyProf.measure_mode
+        when RubyProf::PROCESS_TIME
+          @value_scale = RubyProf::CLOCKS_PER_SEC;
+          @output << 'process_time'
+        when RubyProf::WALL_TIME
+          @value_scale = 1_000_000
+          @output << 'wall_time'
+        when RubyProf.const_defined?(:CPU_TIME) && RubyProf::CPU_TIME
+          @value_scale = RubyProf.cpu_frequency
+          @output << 'cpu_time'
+        when RubyProf.const_defined?(:ALLOCATIONS) && RubyProf::ALLOCATIONS
+          @value_scale = 1
+          @output << 'allocations'
+        when RubyProf.const_defined?(:MEMORY) && RubyProf::MEMORY
+          @value_scale = 1
+          @output << 'memory'
+        when RubyProf.const_defined?(:GC_RUNS) && RubyProf::GC_RUNS
+          @value_scale = 1
+          @output << 'gc_runs'
+        when RubyProf.const_defined?(:GC_TIME) && RubyProf::GC_TIME
+          @value_scale = 1000000
+          @output << 'gc_time'
+        else
+          raise "Unknown measure mode: #{RubyProf.measure_mode}"
+      end
+      @output << "\n\n"
+
+      print_threads
+    end
+
+    def print_threads
+      @result.threads.each do |thread_id, methods|
+        print_methods(thread_id, methods)
+      end
+    end
+
+    def convert(value)
+      (value * @value_scale).round
+    end
+
+    def file(method)
+      File.expand_path(method.source_file)
+    end
+
+    def print_methods(thread_id, methods)
+      methods.reverse_each do |method|
+        # Print out the file and method name
+        @output << "fl=#{file(method)}\n"
+        @output << "fn=#{method_name(method)}\n"
+
+        # Now print out the function line number and its self time
+        @output << "#{method.line} #{convert(method.self_time)}\n"
+
+        # Now print out all the children methods
+        method.children.each do |callee|
+          @output << "cfl=#{file(callee.target)}\n"
+          @output << "cfn=#{method_name(callee.target)}\n"
+          @output << "calls=#{callee.called} #{callee.line}\n"
+
+          # Print out total times here!
+          @output << "#{callee.line} #{convert(callee.total_time)}\n"
+        end
+      @output << "\n"
+      end
+    end #end print_methods
+  end # end class
+
+  class CallTreePrinterWithoutAggregation < CallTreePrinter
+    def get_sequence_index(sequence)
+        @seq_cache ||= Hash.new
+        @seq_index ||= 1
+        sequence_array = sequence.split("->")
+        method_name = sequence_array.last
+        sequence = sequence_array.count>1 ? sequence_array[0..sequence_array.count - 2].join("->") : "root"
+        @seq_cache[method_name] = Hash.new unless @seq_cache.has_key?(method_name)
+        @seq_cache[method_name][sequence] = @seq_cache[method_name].keys.count+1 unless @seq_cache[method_name].include?(sequence)
+        @seq_cache[method_name][sequence]
+    end
+
+    def print_methods(thread_id, methods)
+        methods.reverse_each do |method|
+        parents = method.call_infos.map{|caller| caller if caller.parent}
+        children = method.children
+        call_tree = Hash.new
+        parents.each do |parent|
+            call_tree[parent] = Array.new
+            if parent
+                children.each do |child|
+                   call_tree[parent] << child if child.call_sequence.include?(parent.call_sequence)
+                end
+            else
+                call_tree[parent] = children
+            end
+        end
+
+        call_tree.each do |parent, children|
+            # Print out the file and method name
+            @output << "fl=#{file(method)}\n"
+            @output << (parent ? "fn=#{method.full_name}(#{get_sequence_index(parent.call_sequence)})\n" : "fn=#{method.full_name}\n")
+
+            # Now print out the function line number and its self time
+            @output << "#{method.line} #{convert(method.self_time)}\n"
+
+            # Now print out all the children methods
+            children.each do |callee|
+                @output << "cfl=#{file(callee.target)}\n"
+                @output << "cfn=#{callee.target.full_name}(#{get_sequence_index(callee.call_sequence)})\n"
+                @output << "calls=#{callee.called} #{callee.line}\n"
+
+                # Print out total times here!
+                @output << "#{callee.line} #{convert(callee.total_time)}\n"
+            end
+            @output << "\n"
+            end
+        end
+    end #end print_methods
+
+  end #end class
+
+end # end packages

data/lib/ruby-prof/dot_printer.rb

@@ -0,0 +1,153 @@
+require 'set'
+require 'ruby-prof/abstract_printer'
+
+module RubyProf
+  # Generates a graphviz graph in dot format.
+  # To use the dot printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::DotPrinter.new(result)
+  #   printer.print(STDOUT)
+  # 
+  # You can use either dot viewer such as GraphViz, or the dot command line tool
+  # to reformat the output into a wide variety of outputs:
+  # 
+  #   dot -Tpng graph.dot > graph.png
+  # 
+  class DotPrinter < RubyProf::AbstractPrinter  
+    CLASS_COLOR = '"#666666"'
+    EDGE_COLOR  = '"#666666"'
+    
+    # Creates the DotPrinter using a RubyProf::Result.
+    def initialize(result)
+      super(result)
+      @seen_methods = Set.new
+    end
+        
+    # Print a graph report to the provided output.
+    #  
+    # output - Any IO object, including STDOUT or a file. The default value is
+    # STDOUT.
+    #  
+    # options - Hash of print options.  See #setup_options 
+    #           for more information.
+    #
+    # When profiling results that cover a large number of method calls it
+    # helps to use the :min_percent option, for example:
+    #  
+    #   DotPrinter.new(result).print(STDOUT, :min_percent=>5)
+    # 
+    def print(output = STDOUT, options = {})
+      @output = output
+      setup_options(options)
+      
+      total_time = thread_times.values.inject{|a,b| a+b}
+      
+      puts 'digraph "Profile" {'
+      puts "label=\"#{mode_name} >=#{min_percent}%\\nTotal: #{total_time}\";"
+      puts "labelloc=t;"
+      puts "labeljust=l;"
+      print_threads
+      puts '}'
+    end
+
+    private 
+    
+    # Something of a hack, figure out which constant went with the
+    # RubyProf.measure_mode so that we can display it.  Otherwise it's easy to
+    # forget what measurement was made.
+    def mode_name
+      mode = RubyProf.constants.find{|c| RubyProf.const_get(c) == RubyProf.measure_mode}
+    end
+    
+    # Computes the total time per thread:
+    def thread_times
+      @thread_times ||= begin
+        times = {}
+        @result.threads.each do |thread_id, methods|
+          toplevel = methods.sort.last
+
+          total_time = toplevel.total_time
+          # This looks like a hack for very small times... from GraphPrinter
+          total_time = 0.01 if total_time == 0 
+          times[thread_id] = total_time
+        end
+        
+        times
+      end
+    end
+    
+    def print_threads
+      # sort assumes that spawned threads have higher object_ids
+      @result.threads.sort.each do |thread_id, methods|
+        puts "subgraph \"Thread #{thread_id}\" {"
+        
+        print_methods(thread_id, methods)
+        puts "}"
+        
+        print_classes(thread_id, methods)
+      end
+    end
+    
+    # Determines an ID to use to represent the subject in the Dot file.
+    def dot_id(subject)
+      subject.object_id
+    end
+    
+    def print_methods(thread_id, methods)
+      total_time = thread_times[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
+        name = method_name(method).split("#").last
+        puts "#{dot_id(method)} [label=\"#{name}\\n(#{total_percentage.round}%)\"];"
+        @seen_methods << method
+        print_edges(total_time, method)
+      end
+    end
+      
+    def print_classes(thread_id, methods)
+      grouped = {}
+      methods.each{|m| grouped[m.klass_name] ||= []; grouped[m.klass_name] << m}
+      grouped.each do |cls, methods2|
+        # Filter down to just seen methods
+        big_methods, small_methods  = methods2.partition{|m| @seen_methods.include? m}
+        
+        if !big_methods.empty?
+          puts "subgraph cluster_#{cls.object_id} {"
+          puts "label = \"#{cls}\";"
+          puts "fontcolor = #{CLASS_COLOR};"
+          puts "fontsize = 16;"
+          puts "color = #{CLASS_COLOR};"
+          big_methods.each do |m|
+            puts "#{m.object_id};"
+          end
+          puts "}"  
+        end        
+      end
+    end
+    
+    def print_edges(total_time, method)
+      method.aggregate_children.sort_by(&:total_time).reverse.each do |child|
+        
+        target_percentage = (child.target.total_time / total_time) * 100.0
+        next if target_percentage < min_percent
+        
+        # Get children method
+        puts "#{dot_id(method)} -> #{dot_id(child.target)} [label=\"#{child.called}/#{child.target.called}\" fontsize=10 fontcolor=#{EDGE_COLOR}];"
+      end
+    end
+    
+    # Silly little helper for printing to the @output
+    def puts(str)
+      @output.puts(str)
+    end
+    
+  end
+end

data/lib/ruby-prof/flat_printer.rb

@@ -0,0 +1,78 @@
+require 'ruby-prof/abstract_printer'
+
+module RubyProf
+  # Generates flat[link:files/examples/flat_txt.html] profile reports as text.
+  # To use the flat printer:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::FlatPrinter.new(result)
+  #   printer.print(STDOUT, 0)
+  #
+  class FlatPrinter < AbstractPrinter
+    # Print a flat profile 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
+      @result.threads.each do |thread_id, methods|
+        print_methods(thread_id, methods)
+        @output << "\n" * 2
+      end
+    end
+
+    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
+
+      # Now sort methods by largest self time,
+      # not total time like in other printouts
+      methods = methods.sort do |m1, m2|
+        m1.self_time <=> m2.self_time
+      end.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"
+
+      sum = 0
+      methods.each do |method|
+        self_percent = (method.self_time / total_time) * 100
+        next if self_percent < min_percent
+
+        sum += method.self_time
+        #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\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_name(method)                  # name
+                  ]
+      end
+    end
+  end
+end

data/lib/ruby-prof/flat_printer_with_line_numbers.rb

@@ -0,0 +1,72 @@
+require 'ruby-prof/abstract_printer'
+require 'pathname'
+module RubyProf
+  # Generates flat[link:files/examples/flat_txt.html] profile reports as text.
+  # To use the flat printer with line numbers:
+  #
+  #   result = RubyProf.profile do
+  #     [code to profile]
+  #   end
+  #
+  #   printer = RubyProf::FlatPrinterWithLineNumbers.new(result)
+  #   printer.print(STDOUT, 0)
+  #
+  class FlatPrinterWithLineNumbers < FlatPrinter
+
+    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
+
+      # Now sort methods by largest self time,
+      # not total time like in other printouts
+      methods = methods.sort do |m1, m2|
+        m1.self_time <=> m2.self_time
+      end.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"
+      sum = 0
+      methods.each do |method|
+        self_percent = (method.self_time / total_time) * 100
+        next if self_percent < min_percent
+
+        sum += method.self_time
+        #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
+                  ]
+         if method.source_file != 'ruby_runtime'
+           @output << "  %s:%s" % [File.expand_path(method.source_file), method.line]
+         end
+         @output << "\n\tcalled from: "
+
+         # make sure they're unique
+         method.call_infos.map{|ci|
+           if ci.parent && ci.parent.target.source_file != 'ruby_runtime'
+              [method_name(ci.parent.target), File.expand_path(ci.parent.target.source_file), ci.parent.target.line]
+           else
+              nil
+           end
+         }.compact.uniq.each{|args|
+             @output << " %s (%s:%s) " % args
+         }
+         @output << "\n\n"
+      end
+    end
+  end
+end
+

data/lib/ruby-prof/graph_html_printer.rb

@@ -0,0 +1,278 @@
+require 'ruby-prof/abstract_printer'
+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 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 GraphHtmlPrinter < AbstractPrinter
+    include ERB::Util
+
+    PERCENTAGE_WIDTH = 8
+    TIME_WIDTH = 10
+    CALL_WIDTH = 20
+
+    # 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
+
+    # Print a graph html 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)
+
+      filename = options[:filename]
+      template = filename ? File.read(filename).untaint : (options[:template] || self.template)
+      _erbout = @output
+      erb = ERB.new(template, nil, nil)
+      erb.filename = filename
+      @output << erb.result(binding)
+    end
+
+    def total_time(call_infos)
+      sum(call_infos.map{|ci| ci.total_time})
+    end
+
+    def sum(a)
+      a.inject(0.0){|s,t| s+=t}
+    end
+
+    # These methods should be private but then ERB doesn't
+    # work.  Turn off RDOC though
+    #--
+    def calculate_thread_times
+      # Cache thread times since this is an expensive
+      # operation with the required sorting
+      @overall_threads_time = 0.0
+      @thread_times = Hash.new
+      @result.threads.each do |thread_id, methods|
+        roots = methods.select{|m| m.root?}
+        thread_total_time = sum(roots.map{|r| self.total_time(r.call_infos)})
+        @overall_threads_time += thread_total_time
+        @thread_times[thread_id] = thread_total_time
+      end
+    end
+
+    def thread_time(thread_id)
+      @thread_times[thread_id]
+    end
+
+    def total_percent(thread_id, method)
+      overall_time = self.thread_time(thread_id)
+      (method.total_time/overall_time) * 100
+    end
+
+    def self_percent(method)
+      overall_time = self.thread_time(method.thread_id)
+      (method.self_time/overall_time) * 100
+    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_id, method)
+      if self.total_percent(thread_id, method) < min_percent
+        # Just return name
+        h method.full_name
+      else
+        href = '#' + method_href(thread_id, method)
+        "<a href=\"#{href}\">#{h method.full_name}</a>"
+      end
+    end
+
+    def method_href(thread_id, 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}?line=#{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;
+    }
+  </style>
+  </head>
+  <body>
+    <h1>Profile Report</h1>
+    <!-- Threads Table -->
+    <table>
+      <tr>
+        <th>Thread ID</th>
+        <th>Total Time</th>
+      </tr>
+      <% for thread_id in @result.threads.keys.sort %>
+      <tr>
+        <td><a href="#<%= thread_id %>"><%= thread_id %></a></td>
+        <td><%= thread_time(thread_id) %></td>
+      </tr>
+      <% end %>
+    </table>
+
+    <!-- Methods Tables -->
+    <% for thread_id in @result.threads.keys.sort
+         methods = @result.threads[thread_id]
+         total_time = thread_time(thread_id) %>
+      <h2><a name="<%= thread_id %>">Thread <%= thread_id %></a></h2>
+
+      <table>
+        <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>
+
+        <% min_time = @options[:min_time] || (@options[:nonzero] ? 0.005 : nil)
+           methods.sort.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_id, 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_id, method) %>"><%= 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_id, 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 %>
+      </table>
+    <% end %>
+  </body>
+</html>'
+    end
+  end
+end
+