rdp-jruby-prof 0.1.0.1

data/README

@@ -0,0 +1,53 @@
+
+jruby-prof
+==========
+
+Daniel Lucraft
+http://danlucraft.com/blog/2010/03/jruby-prof/
+
+This is a clone of ruby-prof for JRuby. It supports all the usual output
+modes, plus a call tree output mode. 
+
+The only measure mode it currently supports is wall time.
+
+*** NB. This is really new code. It probably has lots of bugs and things. - March 2010 ***
+
+INSTALL
+-------
+
+    $ jruby -S gem install jruby-prof
+    
+USAGE
+-----
+
+In your program:
+
+    require 'rubygems'
+    require 'jruby-prof'
+    
+    result = JRubyProf.profile do
+      # my stuff
+    end
+    
+    JRubyProf.print_flat_text(result, "flat.txt")
+    JRubyProf.print_graph_text(result, "graph.txt")
+    JRubyProf.print_graph_html(result, "graph.html")
+    JRubyProf.print_call_tree(result, "call_tree.txt")
+    JRubyProf.print_tree_html(result, "call_tree.html")
+
+In order to tell JRuby to send events to JRubyProf for processing, you must
+run your script with the debug flag on:
+
+    $ jruby --debug my_script.rb
+
+
+Or you can use its gem script:
+
+    $ jruby --debug -S jruby-prof scriptname.rb
+    
+Which will profile the entire script, create a local directory named "profile" and output one copy of each graph type there.
+
+LICENSE
+-------
+
+MIT

data/bin/jruby-prof

@@ -0,0 +1,23 @@
+    require 'rubygems'
+    require 'jruby-prof'
+    original_dir = Dir.pwd
+    
+    if ARGV.detect{|arg| arg == '-h' || arg == '--help'}
+      puts 'syntax: jruby --debug -S jruby-prof script_name arg1 arg2 arg3 (writes the several outputs available to profile/*)'
+      exit 1
+    end
+    
+    ruby_script = ARGV.shift
+    result = JRubyProf.profile {
+      require ruby_script
+    }
+
+    Dir.chdir(original_dir) do
+      require 'fileutils'
+      FileUtils.mkdir_p "profile"
+      JRubyProf.print_flat_text(result, "profile/flat.txt")
+      JRubyProf.print_graph_text(result, "profile/graph.txt")
+      JRubyProf.print_graph_html(result, "profile/graph.html")
+      JRubyProf.print_call_tree(result, "profile/call_tree.txt")
+      JRubyProf.print_tree_html(result, "profile/call_tree.html")
+    end

data/lib/jruby-prof.rb

@@ -0,0 +1,66 @@
+
+require 'java'
+require 'erb'
+
+require File.dirname(__FILE__) + "/jruby-prof.jar"
+
+import org.jruby.prof.JRubyProf
+
+require 'jruby-prof/abstract_printer'
+require 'jruby-prof/simple_tree_printer'
+require 'jruby-prof/flat_text_printer'
+require 'jruby-prof/graph_text_printer'
+require 'jruby-prof/graph_html_printer'
+require 'jruby-prof/invocation_set'
+require 'jruby-prof/method'
+require 'jruby-prof/tree_html_printer'
+
+require 'jruby-prof/profile_invocation'
+
+class JRubyProf
+  
+  def self.start
+    raise RuntimeError, "JRubyProf already running" if running?
+    start_tracing
+  end
+  
+  def self.stop
+    stop_tracing
+  end
+  
+  def self.running?
+    self.is_running
+  end
+  
+  def self.profile
+    raise ArgumentError, "profile requires a block" unless block_given?
+    start
+    yield
+    stop
+  end
+  
+  def self.print_call_tree(result, filename)
+    printer = SimpleTreePrinter.new(ThreadSet.new(result.values.to_a, JRubyProf.lastTracingDuration))
+    printer.print_to_file(filename)
+  end
+  
+  def self.print_tree_html(result, filename)
+    printer = TreeHtmlPrinter.new(ThreadSet.new(result.values.to_a, JRubyProf.lastTracingDuration))
+    printer.print_to_file(filename)
+  end
+  
+  def self.print_flat_text(result, filename)
+    printer = FlatTextPrinter.new(ThreadSet.new(result.values.to_a, JRubyProf.lastTracingDuration))
+    printer.print_to_file(filename)
+  end
+  
+  def self.print_graph_text(result, filename)
+    printer = GraphTextPrinter.new(ThreadSet.new(result.values.to_a, JRubyProf.lastTracingDuration))
+    printer.print_to_file(filename)
+  end
+
+  def self.print_graph_html(result, filename)
+    printer = GraphHtmlPrinter.new(ThreadSet.new(result.values.to_a, JRubyProf.lastTracingDuration))
+    printer.print_to_file(filename)
+  end
+end

data/lib/jruby-prof/abstract_printer.rb

@@ -0,0 +1,21 @@
+
+class JRubyProf
+  class AbstractPrinter
+    attr_reader :thread_set
+  
+    def initialize(thread_set, options={})
+      @thread_set = thread_set
+      @options = options
+    end
+    
+    def print_to_file(filename)
+      puts "Dumping trace to #{File.expand_path(filename)}"
+      File.open(filename, "w") do |f|
+        print_on(f)
+      end
+    end
+  end
+end
+
+
+

data/lib/jruby-prof/flat_text_printer.rb

@@ -0,0 +1,35 @@
+
+class JRubyProf
+  class FlatTextPrinter < AbstractPrinter
+    TABLE_HEADER = " %self  cumulative    total     self   children    calls self/call total/call  name"  
+    
+    def print_on(output)
+      thread_set.invocations.each_with_index do |invocation, i|
+        output.puts
+        output.puts "Thread #{i + 1} / #{thread_set.length}"
+        output.puts
+        methods = invocation.get_methods.values.sort_by {|m| m.duration }.reverse
+        output.puts TABLE_HEADER
+        total_duration = 0
+        rows = methods.map do |method|
+          total    = method.duration
+          children = method.childrens_duration
+          self_    = total - children
+          total_duration += self_ unless self_ < 0
+          next if method.name == "#"
+          [total, children, self_, method.count, method.name]
+        end
+        cumulative = 0
+        rows = rows.compact.sort_by {|r| r[2]}.reverse
+        rows.each do |row|
+          total, children, self_, count, name = *row
+          cumulative += self_
+          self_pc = (self_.to_f/total_duration)*100
+          self_per_call = self_.to_f/count
+          total_per_call = total.to_f/count
+          output.puts "#{("%2.2f" % self_pc).rjust(6)} #{cumulative.to_s.rjust(11)} #{total.to_s.rjust(8)}  #{self_.to_s.rjust(7)}  #{children.to_s.rjust(8)}   #{count.to_s.rjust(7)} #{("%2.2f" % self_per_call).to_s.rjust(9)} #{("%2.2f" % total_per_call).to_s.rjust(10)}  #{name}"
+        end
+      end
+    end
+  end
+end

data/lib/jruby-prof/graph_html_printer.rb

@@ -0,0 +1,123 @@
+
+class JRubyProf
+  class GraphHtmlPrinter < GraphTextPrinter
+    def print_on(output)
+      output.puts HEADER
+      total_duration = thread_set.duration
+      thread_set.invocations.each_with_index do |thread, i|
+        methods = thread.get_methods.values.sort_by {|m| m.duration }.reverse
+        output.puts "<h3>Thread #{i + 1}/#{thread_set.length}</h3>"
+        output.puts TABLE_HEADER
+        rows = methods.map do |method|
+          method.parent_contexts.each do |context|  
+            print_method(output, context, total_duration, false)
+          end
+          print_method(output, method, total_duration, true)
+          method.child_contexts.each do |context|  
+            print_method(output, context, total_duration, false)
+          end
+          output.puts <<-HTML
+            <tr class="break">
+              <td colspan="7"></td>
+            </tr>
+          HTML
+        end
+        output.puts TABLE_FOOTER
+      end
+      output.puts FOOTER
+    end
+
+    def print_method(output, method, total_duration, major_row)
+      return if method.name =~ /JRubyProf\.stop/
+      total    = method.duration
+      total_pc = (total.to_f/total_duration)*100
+      children = method.childrens_duration
+      self_    = total - children
+      self_pc  = (self_.to_f/total_duration)*100
+      calls    = method.count
+      name     = method.name
+      inv_id   = nil
+      template = File.read(File.join(File.dirname(__FILE__), "..", "..", "templates", "graph_row.html.erb"))
+      erb = ERB.new(template)
+      output.puts(erb.result(binding))
+    end
+    
+    def safe_name(name)
+      name.gsub("#", "_inst_").gsub(".", "_stat_")
+    end
+    
+    HEADER = <<HTML
+    <html>
+      <body>
+<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;
+    }
+
+    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;
+    }	
+  </style>
+</head>
+HTML
+
+  TABLE_HEADER = <<-HTML
+<table>
+  <tr>
+    <th>%total</th>
+    <th>%self</th>
+    <th>total</th>
+    <th>self</th>
+    <th>children</th>
+    <th>calls</th>
+    <th>Name</th>
+  </tr>
+HTML
+
+    TABLE_FOOTER = <<HTML
+</table>
+<br />
+<br />
+HTML
+
+    FOOTER = <<-HTML
+</body>
+</html>
+HTML
+    
+  end
+end

data/lib/jruby-prof/graph_text_printer.rb

@@ -0,0 +1,45 @@
+
+class JRubyProf
+  class GraphTextPrinter < AbstractPrinter
+    TABLE_HEADER = " %total    %self      total      self    children    calls   Name"
+    
+    def print_on(output)
+      thread_set.invocations.each_with_index do |invocation, i|
+        output.puts
+        output.puts "Thread #{i + 1} / #{thread_set.length}"
+        output.puts
+        methods = invocation.get_methods.values.sort_by {|m| m.duration }.reverse
+        output.puts TABLE_HEADER
+        output.puts "-"*100
+        total_duration = thread_set.duration
+        rows = methods.map do |method|
+          method.parent_contexts.each do |context|  
+            print_method(output, context, total_duration, false)
+          end
+          print_method(output, method, total_duration, true)
+          method.child_contexts.each do |context|  
+            print_method(output, context, total_duration, false)
+          end
+          output.puts "-"*100
+        end
+      end
+    end
+    
+    def print_method(output, method, total_duration, print_percents)
+      return if method.name =~ /JRubyProf\.stop/
+      total    = method.duration
+      total_pc = (total.to_f/total_duration)*100
+      children = method.childrens_duration
+      self_    = total - children
+      self_pc  = (self_.to_f/total_duration)*100
+      calls    = method.count
+      name     = method.name
+      if print_percents
+        output.print " #{("%2.2f" % total_pc).rjust(6)}% #{("%2.2f" % self_pc).rjust(6)}%"
+      else
+        output.print "                "
+      end
+      output.puts "#{total.to_s.rjust(11)} #{self_.to_s.rjust(9)} #{children.to_s.rjust(11)} #{calls.to_s.rjust(8)}  #{name}"
+    end
+  end
+end

data/lib/jruby-prof/invocation_set.rb

@@ -0,0 +1,34 @@
+
+class JRubyProf
+  class ThreadSet
+    attr_reader :invocations, :duration
+  
+    def initialize(invocations, duration)
+      @invocations = invocations.map do |inv|
+        c = inv
+        c = c.parent while c.parent
+        c
+      end
+      @duration = duration
+    end
+    
+    def length
+      invocations.length
+    end
+    
+    def top_level_duration
+      invocations.inject(0.0) do |m, inv| 
+        m + inv.childrens_duration
+      end
+    end
+    
+    def self.add_methods(h, inv, duration=nil, count=nil)
+      return if inv.name =~ /CachingCallSite\.stop_tracing/ or inv.name =~ /JRubyProf\.stop/
+      h[inv.name] ||= Method.new(inv.class_name, inv.method_name, inv.static?)
+      h[inv.name].add_invocation(inv)
+      inv.children.each do |child_inv|
+        add_methods(h, child_inv)
+      end
+    end
+  end
+end

data/lib/jruby-prof/method.rb

@@ -0,0 +1,107 @@
+
+class JRubyProf
+  class Method
+    attr_reader :class_name, :method_name, :invocations
+  
+    def initialize(class_name, method_name, static)
+      @class_name, @method_name, @static = class_name, method_name, static
+      @invocations = []
+    end
+    
+    def static?
+      @static
+    end
+    
+    def toplevel?
+      method_name == nil
+    end
+    
+    def add_invocation(inv)
+      invocations << inv
+    end
+    
+    def duration
+      if toplevel?
+        childrens_duration
+      else
+        invocations.inject(0) {|m, inv| m + inv.duration}
+      end
+    end
+    
+    def count
+      if toplevel?
+        1
+      else
+        invocations.inject(0) {|m, inv| m + inv.count}
+      end
+    end
+    
+    def childrens_duration
+      invocations.inject(0) {|m, inv| m + inv.children.inject(0) {|m1, inv1| m1 + inv1.duration }}
+    end
+    
+    def name
+      "#{class_name}#{static? ? "." : "#"}#{method_name || "toplevel"}"
+    end
+    
+    class CallContext
+      attr_accessor :name, :duration, :childrens_duration, :count
+      
+      def toplevel?
+        @name == "#"
+      end
+      
+      def name
+        toplevel? ? "#toplevel" : @name
+      end
+    
+      def initialize(name)
+        @name = name
+        @duration, @childrens_duration, @count = 0, 0, 0
+      end
+      
+      def duration
+        toplevel? ? @childrens_duration : @duration
+      end
+    end
+    
+    def child_contexts
+      @child_contexts ||= begin
+        h = {}
+        invocations.each do |inv| 
+          inv.children.each do |inv2|
+            h[inv2.name] ||= CallContext.new(inv2.name)
+            cc = h[inv2.name]
+            cc.duration           += inv2.duration
+            cc.childrens_duration += inv2.childrens_duration
+            cc.count              += inv2.count
+          end
+        end
+        h.values
+      end
+    end
+    
+    def parent_contexts
+      @parent_contexts ||= begin
+        h = {}
+        invocations.each do |inv| 
+          inv2 = inv.parent
+          next unless inv2
+          h[inv2.name] ||= CallContext.new(inv2.name)
+          cc = h[inv2.name]
+          cc.duration           += inv.duration
+          cc.childrens_duration += inv.childrens_duration
+          cc.count              += inv.count
+        end
+        h.values
+      end
+    end
+    
+    def inspect
+      "#<JRubyProf::Method #{class_name} #{method_name}>"
+    end
+  end
+end
+
+
+

data/lib/jruby-prof/profile_invocation.rb

@@ -0,0 +1,43 @@
+
+class JRubyProf
+  import org.jruby.prof.Invocation
+  class Invocation
+    alias :method_name  :methodName
+    alias :class_name   :className
+    
+    def name
+      "#{class_name}#{static? ? "." : "#"}#{method_name}"
+    end
+      
+    def childrens_duration
+      children.inject(0) {|m, inv| m + inv.duration}
+    end
+    
+    def static?
+      false
+    end
+    
+    def to_method
+      method = Method.new(class_name, method_name, static?)
+      method.add_invocation(self)
+      method
+    end
+    
+    def id
+      @id ||= Invocation.new_id
+    end
+    
+    def self.new_id
+      @id ||= 0
+      @id += 1
+      @id
+    end
+    
+    def get_methods
+      h = {}
+      ThreadSet.add_methods(h, self)
+      h
+    end
+  end
+end
+

data/lib/jruby-prof/simple_tree_printer.rb

@@ -0,0 +1,27 @@
+
+class JRubyProf
+  class SimpleTreePrinter < AbstractPrinter
+    def print_on(output)
+      thread_set.invocations.each_with_index do |invocation, i|
+        output.puts 
+        output.puts "*** Thread #{i + 1} / #{thread_set.length}"
+        output.puts 
+        dump_from_root(output, invocation)
+      end
+    end
+    
+    private
+    
+    def dump(f, inv, indent=0)
+      f.print(" "*indent)
+      f.puts "#{inv.name} - #{inv.duration}"
+      inv.children.each {|child_inv| dump(f, child_inv, indent + 2)}
+    end
+    
+    def dump_from_root(f, inv)
+      current = inv
+      current = current.parent while current.parent
+      dump(f, current)
+    end
+  end
+end

data/lib/jruby-prof/tree_html_printer.rb

@@ -0,0 +1,144 @@
+
+class JRubyProf
+  class TreeHtmlPrinter < AbstractPrinter
+    def print_on(output)
+      total_duration = thread_set.duration
+      output.puts HEADER
+      thread_set.invocations.each_with_index do |invocation, i|
+        all_invocations = []
+        get_invocations(all_invocations, invocation)
+        output.puts "<h3>Thread #{i + 1}/#{thread_set.length}</h3>"
+        output.puts TABLE_HEADER
+        all_invocations = all_invocations.sort_by {|i| m = i.to_method.duration }.reverse
+        all_invocations.each do |inv|
+          next if inv.name =~ /CachingCallSite\.stop_tracing/
+          next if inv.name =~ /JRubyProf\.stop/
+          next if inv.duration < 5
+          #next if inv.name == "#"
+          c = inv
+          parents = []
+          while c.parent
+            c = c.parent
+            parents << c
+          end
+          parents.reverse.each do |parent_inv|
+            print_invocation(output, parent_inv, total_duration, false)
+          end
+          print_invocation(output, inv, total_duration, true)
+          inv.children.each do |child_inv|
+            next if child_inv.name =~ /CachingCallSite\.stop_tracing/
+            print_invocation(output, child_inv, total_duration, false)
+          end
+          output.puts <<-HTML
+            <tr class="break">
+              <td colspan="7"></td>
+            </tr>
+          HTML
+        end
+        output.puts TABLE_FOOTER
+      end
+      output.puts FOOTER
+    end
+    
+    def get_invocations(arr, invocation)
+      arr << invocation
+      invocation.children.each do |inv|
+        get_invocations(arr, inv)
+      end
+    end
+    
+    def print_invocation(output, invocation, total_duration, major_row)
+      next if invocation.name =~ /JRubyProf\.stop/
+      method = invocation.to_method
+      total    = method.duration
+      total_pc = (total.to_f/total_duration)*100
+      children = method.childrens_duration
+      self_    = total - children
+      self_pc  = (self_.to_f/total_duration)*100
+      calls    = method.count
+      name     = method.name
+      inv_id   = invocation.id
+      template = File.read(File.join(File.dirname(__FILE__), "..", "..", "templates", "graph_row.html.erb"))
+      erb = ERB.new(template)
+      output.puts(erb.result(binding))
+    end
+    
+    def safe_name(name)
+      name.gsub("#", "_inst_").gsub(".", "_stat_")
+    end
+    
+    HEADER = <<HTML
+    <html>
+      <body>
+<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;
+    }
+
+    th {
+	    text-align: center;
+	    border-top: 1px solid #339;
+	    border-bottom: 1px solid #339;
+	    background: #CDF;
+	    padding: 0.3em;
+	    border-left: 1px solid silver;
+    }
+
+		tr.break td {
+		  border: 0;
+	    border-top: 1px solid #339;
+			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;
+    }	
+  </style>
+</head>
+HTML
+
+    TABLE_HEADER = <<-HTML
+<table>
+  <tr>
+    <th>%total</th>
+    <th>%self</th>
+    <th>total</th>
+    <th>self</th>
+    <th>children</th>
+    <th>calls</th>
+    <th>Name</th>
+  </tr>
+HTML
+
+    TABLE_FOOTER = <<HTML
+</table>
+<br />
+<br />
+HTML
+
+    FOOTER = <<-HTML
+</body>
+</html>
+HTML
+    
+  end
+end

data/src/org/jruby/prof/Invocation.java

@@ -0,0 +1,14 @@
+
+package org.jruby.prof;
+
+import java.util.*;
+public class Invocation {
+    public String className;
+    public String methodName;
+    public Invocation parent;
+    public boolean returned = false;
+    public long duration = 0;
+    public long count = 0;
+    public long startTimeCurrent;
+    public ArrayList<Invocation> children = new ArrayList<Invocation>();
+}

data/src/org/jruby/prof/JRubyProf.java

@@ -0,0 +1,94 @@
+
+package org.jruby.prof;
+
+import java.util.*;
+import org.jruby.Ruby;
+import org.jruby.runtime.ThreadContext;
+
+public class JRubyProf {
+
+    private static Map<ThreadContext, Invocation> currentInvocations;
+
+    public static ProfEventHook hook = null;
+    public static long startedTracingTime;
+    public static long lastTracingDuration;
+    
+    public static void startTracing() {
+        hook = new ProfEventHook();
+        Ruby.getGlobalRuntime().addEventHook(hook);
+        currentInvocations = Collections.synchronizedMap(new HashMap<ThreadContext, Invocation>());
+        shouldProfile = true;
+        startedTracingTime = System.currentTimeMillis();
+    }
+    
+    public static Map<ThreadContext, Invocation> stopTracing() {
+        shouldProfile = false;
+        Ruby.getGlobalRuntime().removeEventHook(hook);
+        hook = null;
+        lastTracingDuration = System.currentTimeMillis() - startedTracingTime;
+        for (ThreadContext context : currentInvocations.keySet()) {
+            Invocation inv = currentInvocations.get(context);
+            while (inv.parent != null)
+                inv = inv.parent;
+            currentInvocations.put(context, inv);
+        }
+        return currentInvocations;
+    }
+    
+    public static boolean isRunning() {
+        return shouldProfile;
+    }
+
+    private static boolean shouldProfile = false;
+    private boolean initProfileMethod = false;
+
+    public static synchronized void before(ThreadContext context, String className, String methodName) {
+        if (!shouldProfile) return;
+        Invocation inv = null;
+        if (currentInvocations.containsKey(context)) {
+            Invocation parent = currentInvocations.get(context);
+            for (Invocation subinv : parent.children) {
+                if (subinv.className.equals(className) && subinv.methodName.equals(methodName)) {
+                    inv = subinv;
+                }
+            }
+            if (inv == null) {
+                inv = new Invocation();
+                inv.parent = parent;
+                inv.className = className;
+                inv.methodName = methodName;
+                parent.children.add(inv);
+            }
+            currentInvocations.put(context, inv);
+            //System.out.printf("pushing %s %s to %s %s in %s\n", inv.className, inv.methodName, parent.className, parent.methodName, context.toString());
+            //System.out.printf("current for %s is %s %s\n", context.toString(), inv.className, inv.methodName);
+        }
+        else {
+            inv = new Invocation();
+            currentInvocations.put(context, inv);
+            //System.out.printf("current for %s is %s %s\n", context.toString(), inv.className, inv.methodName);
+            before(context, className, methodName);
+        }
+        inv.startTimeCurrent = System.currentTimeMillis();
+    }
+    
+    public static synchronized void after(ThreadContext context, String className, String methodName) {
+        if (!shouldProfile) return;
+        Invocation current = currentInvocations.get(context);
+        long time;
+        if (current == null) return;
+        time = System.currentTimeMillis() - current.startTimeCurrent;
+        if (current.startTimeCurrent == 0)
+            System.out.printf("warning, startTimeCurrent is 0 in after\n");
+        current.startTimeCurrent = 0;
+        current.duration += time;
+        current.returned = true;
+        current.count += 1;
+        if (current.parent != null) {
+            currentInvocations.put(context, current.parent);
+            //System.out.printf("popping: %s %s took %dms, now at %s %s\n", current.className, current.methodName, time, current.parent.className, current.parent.methodName);
+        }
+        //System.out.printf("current for %s is %s %s\n", context.toString(), current.parent.className, current.parent.methodName);
+    }
+
+}

data/src/org/jruby/prof/ProfEventHook.java

@@ -0,0 +1,49 @@
+
+package org.jruby.prof;
+
+import org.jruby.prof.JRubyProf;
+
+import org.jruby.RubyObject;
+import org.jruby.RubyModule;
+import org.jruby.MetaClass;
+import org.jruby.runtime.EventHook;
+import org.jruby.runtime.RubyEvent;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class ProfEventHook extends EventHook {
+    public void eventHandler(ThreadContext context, String eventName, String file, int line, String methodName, IRubyObject type) {
+        RubyModule module = (RubyModule) type;
+        String className;
+        if (module == null) {
+            className = "null";
+        }
+        else {
+            if (module instanceof MetaClass) {
+                IRubyObject obj = ((MetaClass) module).getAttached();
+                if (obj instanceof RubyModule) {
+                    module = (RubyModule) obj;
+                    className = "<Class::" + module.getName() + ">";
+                }
+                else if (obj instanceof RubyObject) {
+                    className = "<Instance::" + ((RubyObject) obj).getType().getName() + ">";
+                }
+                else {
+                    className = "unknown";
+                }
+            }
+            else {
+                className = module.getName();
+            }
+        }
+        //System.out.printf("eventHandler(_, %s, %s, %d, %s, %s)\n", eventName, file, line, methodName, className);
+        if (className.equals("<Class::Java::OrgJrubyProf::JRubyProf>")) return;
+        if (eventName.equals("call") || eventName.equals("c-call")) {
+            JRubyProf.before(context, className, methodName);
+        }
+        else if (eventName.equals("return") || eventName.equals("c-return")) {
+             JRubyProf.after(context, className, methodName);
+       }
+    }
+    public boolean isInterestedInEvent(RubyEvent event) { return true; }
+}

data/templates/graph_row.html.erb

@@ -0,0 +1,18 @@
+
+
+<tr class="<%= major_row ? "method" : "" %>">
+  <td><%= ("%2.2f%" % total_pc) if major_row %></td>
+  <td><%= ("%2.2f%" % self_pc) if major_row %></td>
+  <td><%= total/1000.0 %></td>
+  <td><%= self_/1000.0 %></td>
+  <td><%= children/1000.0 %></td>
+  <td><%= calls %></td>
+  <td>
+    <% if major_row %>
+      <a name="<%= safe_name(name) + (inv_id ? "_#{inv_id}" : "") %>"><%= name %></a>
+    <% else %>
+      <a href="#<%= safe_name(name) + (inv_id ? "_#{inv_id}" : "") %>"><%= name %></a>
+    <% end %>
+  </td>
+</tr>
+

data/test/basic_test.rb

@@ -0,0 +1,291 @@
+require 'test/unit'
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'jruby-prof'
+
+class C1
+  def C1.hello
+    sleep(0.1)
+  end
+  
+  def hello
+    sleep(0.2)
+  end
+end
+
+module M1
+  def hello
+    sleep(0.3)
+  end
+end
+
+class C2
+  include M1
+  extend M1
+end
+
+class C3
+  def hello
+    sleep(0.4)
+  end
+end
+
+module M4
+  def hello
+    sleep(0.5)
+  end
+end
+
+module M5
+  include M4
+  def goodbye
+    hello
+  end
+end
+
+class C6
+  include M5
+  def test
+    goodbye
+  end
+end
+
+class BasicTest < Test::Unit::TestCase
+  def setup
+    # Need to use wall time for this test due to the sleep calls
+    #RubyProf::measure_mode = RubyProf::WALL_TIME
+  end
+
+  def test_running
+    assert(!JRubyProf.running?)
+    JRubyProf.start
+    assert(JRubyProf.running?)
+    JRubyProf.stop
+    assert(!JRubyProf.running?)
+  end
+
+  def test_double_profile
+    JRubyProf.start
+    assert_raise(RuntimeError) do
+      JRubyProf.start
+    end
+  
+    assert_raise(RuntimeError) do
+      JRubyProf.profile do
+        puts 1
+      end
+    end
+    JRubyProf.stop
+  end
+  
+  def test_no_block
+    assert_raise(ArgumentError) do
+      JRubyProf.profile
+    end
+  end
+  
+  def test_class_methods
+    result = JRubyProf.profile do
+      C1.hello
+    end
+  
+    # Length should be 3:
+    #   BasicTest#test_class_methods
+    #   <Class::C1>#hello
+    #   Kernel#sleep
+  
+    methods = result.values.to_a.first.get_methods.values.sort_by {|m| m.name}
+    p methods
+    assert_equal(3, methods.length)
+  
+    # Check the names
+    assert_equal('BasicTest#test_class_methods', methods[0].name)
+    assert_equal('<Class::C1>#hello', methods[1].name)
+    assert_equal('Kernel#sleep', methods[2].name)
+  
+    # Check times
+    assert_in_delta(0.1, methods[0].total_time, 0.01)
+    assert_in_delta(0, methods[0].wait_time, 0.01)
+    assert_in_delta(0, methods[0].self_time, 0.01)
+  
+    assert_in_delta(0.1, methods[1].total_time, 0.01)
+    assert_in_delta(0, methods[1].wait_time, 0.01)
+    assert_in_delta(0, methods[1].self_time, 0.01)
+  
+    assert_in_delta(0.1, methods[2].total_time, 0.01)
+    assert_in_delta(0, methods[2].wait_time, 0.01)
+    assert_in_delta(0.1, methods[2].self_time, 0.01)
+  end
+  #
+  #if RUBY_VERSION < '1.9'
+  #  PARENT = Object
+  #else
+  #  PARENT = BasicObject
+  #end
+  #
+  #def test_instance_methods
+  #  result = RubyProf.profile do
+  #    C1.new.hello
+  #  end
+  #
+  #  # Methods called
+  #  #   BasicTest#test_instance_methods
+  #  #   Class.new
+  #  #   Class:Object#allocate
+  #  #   for Object#initialize
+  #  #   C1#hello
+  #  #   Kernel#sleep
+  #
+  #  methods = result.threads.values.first.sort.reverse
+  #  assert_equal(6, methods.length)
+  #  names = methods.map(&:full_name)
+  #  assert_equal('BasicTest#test_instance_methods', names[0])
+  #  assert_equal('C1#hello', names[1])
+  #  assert_equal('Kernel#sleep', names[2])
+  #  assert_equal('Class#new', names[3])
+  #  # order can differ
+  #  assert(names.include?("<Class::#{PARENT}>#allocate"))
+  #  assert(names.include?("#{PARENT}#initialize"))
+  #
+  #  # Check times
+  #  assert_in_delta(0.2, methods[0].total_time, 0.02)
+  #  assert_in_delta(0, methods[0].wait_time, 0.02)
+  #  assert_in_delta(0, methods[0].self_time, 0.02)
+  #
+  #  assert_in_delta(0.2, methods[1].total_time, 0.02)
+  #  assert_in_delta(0, methods[1].wait_time, 0.02)
+  #  assert_in_delta(0, methods[1].self_time, 0.02)
+  #
+  #  assert_in_delta(0.2, methods[2].total_time, 0.02)
+  #  assert_in_delta(0, methods[2].wait_time, 0.02)
+  #  assert_in_delta(0.2, methods[2].self_time, 0.02)
+  #
+  #  assert_in_delta(0, methods[3].total_time, 0.01)
+  #  assert_in_delta(0, methods[3].wait_time, 0.01)
+  #  assert_in_delta(0, methods[3].self_time, 0.01)
+  #
+  #  assert_in_delta(0, methods[4].total_time, 0.01)
+  #  assert_in_delta(0, methods[4].wait_time, 0.01)
+  #  assert_in_delta(0, methods[4].self_time, 0.01)
+  #
+  #  assert_in_delta(0, methods[5].total_time, 0.01)
+  #  assert_in_delta(0, methods[5].wait_time, 0.01)
+  #  assert_in_delta(0, methods[5].self_time, 0.01)
+  #end
+  #
+  #def test_module_methods
+  #  result = RubyProf.profile do
+  #    C2.hello
+  #  end
+  #
+  #  # Methods:
+  #  #   BasicTest#test_module_methods
+  #  #   M1#hello
+  #  #   Kernel#sleep
+  #
+  #  methods = result.threads.values.first.sort.reverse
+  #  assert_equal(3, methods.length)
+  #
+  #  assert_equal('BasicTest#test_module_methods', methods[0].full_name)
+  #  assert_equal('M1#hello', methods[1].full_name)
+  #  assert_equal('Kernel#sleep', methods[2].full_name)
+  #
+  #  # Check times
+  #  assert_in_delta(0.3, methods[0].total_time, 0.1)
+  #  assert_in_delta(0, methods[0].wait_time, 0.02)
+  #  assert_in_delta(0, methods[0].self_time, 0.02)
+  #
+  #  assert_in_delta(0.3, methods[1].total_time, 0.1)
+  #  assert_in_delta(0, methods[1].wait_time, 0.02)
+  #  assert_in_delta(0, methods[1].self_time, 0.02)
+  #
+  #  assert_in_delta(0.3, methods[2].total_time, 0.1)
+  #  assert_in_delta(0, methods[2].wait_time, 0.02)
+  #  assert_in_delta(0.3, methods[2].self_time, 0.1)
+  #end
+  #
+  #def test_module_instance_methods
+  #  result = RubyProf.profile do
+  #    C2.new.hello
+  #  end
+  #
+  #  # Methods:
+  #  #   BasicTest#test_module_instance_methods
+  #  #   Class#new
+  #  #   <Class::Object>#allocate
+  #  #   Object#initialize
+  #  #   M1#hello
+  #  #   Kernel#sleep
+  #
+  #  methods = result.threads.values.first.sort.reverse
+  #  assert_equal(6, methods.length)
+  #  names = methods.map(&:full_name)
+  #  assert_equal('BasicTest#test_module_instance_methods', names[0])
+  #  assert_equal('M1#hello', names[1])
+  #  assert_equal('Kernel#sleep', names[2])
+  #  assert_equal('Class#new', names[3])
+  #  assert(names.include?("<Class::#{PARENT}>#allocate"))
+  #  assert(names.include?("#{PARENT}#initialize"))
+  #  
+  #  # Check times
+  #  assert_in_delta(0.3, methods[0].total_time, 0.1)
+  #  assert_in_delta(0, methods[0].wait_time, 0.1)
+  #  assert_in_delta(0, methods[0].self_time, 0.1)
+  #
+  #  assert_in_delta(0.3, methods[1].total_time, 0.02)
+  #  assert_in_delta(0, methods[1].wait_time, 0.01)
+  #  assert_in_delta(0, methods[1].self_time, 0.01)
+  #
+  #  assert_in_delta(0.3, methods[2].total_time, 0.02)
+  #  assert_in_delta(0, methods[2].wait_time, 0.01)
+  #  assert_in_delta(0.3, methods[2].self_time, 0.02)
+  #
+  #  assert_in_delta(0, methods[3].total_time, 0.01)
+  #  assert_in_delta(0, methods[3].wait_time, 0.01)
+  #  assert_in_delta(0, methods[3].self_time, 0.01)
+  #
+  #  assert_in_delta(0, methods[4].total_time, 0.01)
+  #  assert_in_delta(0, methods[4].wait_time, 0.01)
+  #  assert_in_delta(0, methods[4].self_time, 0.01)
+  #
+  #  assert_in_delta(0, methods[5].total_time, 0.01)
+  #  assert_in_delta(0, methods[5].wait_time, 0.01)
+  #  assert_in_delta(0, methods[5].self_time, 0.01)
+  #end
+  #
+  #def test_singleton
+  #  c3 = C3.new
+  #
+  #  class << c3
+  #    def hello
+  #    end
+  #  end
+  #
+  #  result = RubyProf.profile do
+  #    c3.hello
+  #  end
+  #
+  #  methods = result.threads.values.first.sort.reverse
+  #  assert_equal(2, methods.length)
+  #
+  #  assert_equal('BasicTest#test_singleton', methods[0].full_name)
+  #  assert_equal('<Object::C3>#hello', methods[1].full_name)
+  #
+  #  assert_in_delta(0, methods[0].total_time, 0.01)
+  #  assert_in_delta(0, methods[0].wait_time, 0.01)
+  #  assert_in_delta(0, methods[0].self_time, 0.01)
+  #
+  #  assert_in_delta(0, methods[1].total_time, 0.01)
+  #  assert_in_delta(0, methods[1].wait_time, 0.01)
+  #  assert_in_delta(0, methods[1].self_time, 0.01)
+  #end
+  #
+  #def test_traceback
+  #  RubyProf.start
+  #  assert_raise(NoMethodError) do
+  #    RubyProf.xxx
+  #  end
+  #
+  #  RubyProf.stop
+  #end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: rdp-jruby-prof
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  - 1
+  version: 0.1.0.1
+platform: ruby
+authors: 
+- Daniel Lucraft
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-06 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: dan@fluentradical.com
+executables: 
+- jruby-prof
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- lib/jruby-prof/abstract_printer.rb
+- lib/jruby-prof/flat_text_printer.rb
+- lib/jruby-prof/graph_html_printer.rb
+- lib/jruby-prof/graph_text_printer.rb
+- lib/jruby-prof/invocation_set.rb
+- lib/jruby-prof/method.rb
+- lib/jruby-prof/profile_invocation.rb
+- lib/jruby-prof/simple_tree_printer.rb
+- lib/jruby-prof/tree_html_printer.rb
+- lib/jruby-prof.jar
+- lib/jruby-prof.rb
+- templates/graph_row.html.erb
+- src/org/jruby/prof/Invocation.java
+- src/org/jruby/prof/JRubyProf.java
+- src/org/jruby/prof/ProfEventHook.java
+- test/basic_test.rb
+- bin/jruby-prof
+has_rdoc: true
+homepage: http://danlucraft.com/blog
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Ruby level profiler for JRuby
+test_files: []
+