ruby-dtrace 0.0.2 → 0.0.3

data/lib/dtraceaggregateset.rb

@@ -0,0 +1,17 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+class DtraceAggregateSet
+  attr_reader :data
+
+  def initialize
+    @data = Array.new
+  end
+  
+  def add_aggregate(agg)
+    @data << agg
+  end
+    
+end

data/lib/dtraceconsumer.rb

@@ -3,96 +3,120 @@
 # (c) 2007 Chris Andrews <chris@nodnol.org>
 #
 
+# A DtraceConsumer provides access to the data produced by the running
+# D program. Having compiled and executed a D program, you typically
+# create a DtraceConsumer, and wait for data. 
+#
+# You can either wait indefinitely for data, or consume all the data
+# waiting and then stop: if your D program consists of only of
+# aggregations, returned by printa() actions in the END block, this
+# will be the best approach. If you have a mix of trace() and printf()
+# actions elsewhere, you'll probably want to wait until interrupted,
+# the D program itself exits, or your program decides it has collected
+# enough data.
+#
+# The two approaches are implemented by the +consume+ and
+# +consume_once+ methods.
+#
+# The +consume+ and +consume_once+ methods accept a block to which is
+# yielded complete DtraceData objects, one for each probe which fires.
+#
+# You must have already started tracing when you call +consume+ or
+# +consume_once+, so the general structure will look like:
+#
+#   t = Dtrace.new
+#   progtext = "..."
+#   prog = t.compile progtext
+#   prog.execute
+#   t.go 
+#   c = DtraceConsumer.new(t)
+#   c.consume_once do |d|
+#     # handle DtraceData objects
+#     # ...
+#     # get bored:
+#     c.finish
+#   end
+
 class DtraceConsumer
 
   def initialize(t)
     @t = t
-    @curragg = DtraceAggregate.new
+    @curr = DtraceData.new
+    @done = false
   end
 
-  def consume
+  private
 
-    probe_consumer = proc do |probe|
-      yield probe
+  # The consumer callbacks:
+  #
+  # DtraceRecDesc   -> rec_consumer
+  # DtraceProbeData -> probe_consumer
+  # DtraceBufData   -> buf_consumer
+  #
+  # We expect a sequence of calls to these procs, and we accumulate
+  # data in the @curr DtraceData based on this:
+  #
+  # DtraceProbeData (initial callback for a probe firing)
+  # DtraceRecDesc 
+  # ...
+  # DtraceRecDesc = nil (end of data)
+  #
+  
+  def rec_consumer(block)
+    proc do |rec|
+      if rec
+        @curr.add_recdata(rec)
+      else
+        @curr.finish
+        block.call(@curr)
+        @curr = DtraceData.new
+      end
     end
-    
-    rec_consumer = proc do |rec|
-      #yield rec
+  end
+  
+  def probe_consumer
+    proc do |probe|
+      @curr.add_probedata(probe)
     end
-    
-    buf_consumer = proc do |buf|
-      r = buf.record
-      # buf records can be empty (trace();)
-      if r 
-        case r.class.to_s
-        when DtraceRecord.to_s
-          yield r
-        when DtraceAggData.to_s
-          case r.aggtype
-          when "tuple"
-            @curragg.tuple << r.value
-          when "value"
-            @curragg.value = r.value
-          when "last"
-            yield @curragg
-            @curragg = DtraceAggregate.new
-          end
+  end
 
-        end
-      end
-    end    
+  def buf_consumer
+    proc do |buf|
+      @curr.add_bufdata(buf)
+    end
+  end
   
-    @t.go
+  public
+
+  # Signals that the client wishes to stop consuming trace data. 
+  def finish
+    @t.stop
+    @done = true
+  end
+  
+  # Waits for data from the D program, and yields the records returned
+  # to the block given. Returns when the D program exits.
+  def consume(&block)
     @t.buf_consumer(buf_consumer)
     begin
       while(true) do
         @t.sleep
-        @t.work(probe_consumer, rec_consumer)
+        work = @t.work(probe_consumer, rec_consumer(block))
+        if (@done || work > 0)
+          break
+        end
       end
     ensure
       @t.stop
-      @t.work(probe_consumer, rec_consumer)
+      @t.work(probe_consumer)
     end
-    
   end
   
-  def consume_once
-    
-    probe_consumer = proc do |probe|
-      probe.each_record do |r|
-        yield r
-      end
-    end
-    
-    rec_consumer = proc do |rec|
-      #yield rec
-    end
-    
-    buf_consumer = proc do |buf|
-      r = buf.record
-      # buf records can be empty (trace();)
-      if r 
-        case r.class.to_s
-        when DtraceRecord.to_s
-          yield r
-        when DtraceAggData.to_s
-          case r.aggtype
-          when "tuple"
-            @curragg.tuple << r.value
-          when "value"
-            @curragg.value = r.value
-          when "last"
-            yield @curragg
-            @curragg = DtraceAggregate.new
-          end
-
-        end
-      end
-    end
-  
+  # Yields the data waiting from the current program, then returns.
+  def consume_once(&block)
     @t.buf_consumer(buf_consumer)
     @t.stop
-    @t.work(probe_consumer, rec_consumer)
+    @t.work(probe_consumer, rec_consumer(block))
   end
   
 end

data/lib/dtracedata.rb

@@ -0,0 +1,73 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+# The object returned from a consumer when a probe fires.  Accumulates
+# records from the callbacks, and is yielded when the data is complete.
+class DtraceData
+  attr_reader :data
+  attr_reader :probe
+  attr_reader :cpu, :indent, :prefix, :flow
+
+  def initialize
+    @data = []
+    @curraggset = nil
+    @curragg    = nil
+  end
+
+  def finish
+    if @curraggset
+      @data << @curraggset
+      @curraggset = nil
+    end
+  end
+
+  def add_recdata(rec)
+    if @curraggset
+      @data << @curraggset
+      @curraggset = nil
+    end
+    if rec.action == "printa"
+      @curraggset = DtraceAggregateSet.new
+    end
+  end
+
+  def add_probedata(probedata)
+    probedata.each_record do |p|
+      @data << p
+    end
+
+    # Record the probe that fired, and CPU/indent/prefix/flow
+    @probe  = probedata.probe
+    @cpu    = probedata.cpu
+    @indent = probedata.indent
+    @prefix = probedata.prefix
+    @flow   = probedata.flow
+  end
+  
+  def add_bufdata(buf)
+    r = buf.record
+    # buf records can be empty (trace();)
+    if r
+      case r.class.to_s
+      when DtraceStackRecord.to_s
+        @data << r
+      when DtraceRecord.to_s
+        @data << r
+      when DtracePrintfRecord.to_s
+        @data << r
+      when DtraceAggData.to_s
+        if @curragg == nil
+          @curragg = DtraceAggregate.new
+        end
+        if agg = @curragg.add_record(r)
+          if @curraggset
+            @curraggset.add_aggregate(@curragg)
+          end
+          @curragg = nil
+        end
+      end
+    end
+  end
+  
+end

data/lib/dtraceprintfrecord.rb

@@ -0,0 +1,8 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+# A DTrace record for the formatted part of a printf() action. 
+class DtracePrintfRecord
+  attr_accessor :value
+end

data/lib/dtraceprobedata.rb

@@ -13,4 +13,9 @@ class DtraceProbeData
     records
   end
 
+  def to_s
+    rs = self.records
+    rs.map {|r| r.value }.join ', '
+  end
+
 end

data/lib/dtracerecord.rb

@@ -2,7 +2,8 @@
 # Ruby-Dtrace
 # (c) 2007 Chris Andrews <chris@nodnol.org>
 #
-
+# A scalar DTrace record. Its value is as set by the DTrace action
+# which triggered it.
 class DtraceRecord
   attr_accessor :value
 end

data/lib/dtracestackrecord.rb

@@ -0,0 +1,29 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+# A record representing the result of a stack() or ustack()
+# action. Its value is a list of symbolic stack frames:
+# 
+#   #<DtraceStackRecord:0x14e24 @value=
+#           ["libSystem.B.dylib`__sysctl+0xa",
+#            "libdtrace.dylib`dt_aggregate_go+0x9a",
+#            "dtrace_api.bundle`dtrace_hdl_go+0x30",
+#            "libruby.1.dylib`rb_eval_string_wrap+0x40fd",
+#            "libruby.1.dylib`rb_eval_string_wrap+0x4cdb",
+#            ...
+#            "libruby.1.dylib`rb_apply+0x392",
+#            "libruby.1.dylib`rb_eval_string_wrap+0xe82"]>
+#
+class DtraceStackRecord
+  attr_reader :value
+
+  # Given a stack as a string returned from DTrace, set the value of
+  # this record to a list of stack frames.
+  def parse(raw)
+    frames = raw.split(/\n/)
+    @value = frames.map {|f| f.lstrip }.select {|f| f.length > 0 }
+  end
+
+end

data/plugin/dtrace/lib/dtracer.rb

@@ -3,7 +3,39 @@ require 'dtrace'
 class Dtracer
   
   def start_dtrace(pid)
-    progtext = 'ruby$1:::function-entry{ @a[strjoin(strjoin(copyinstr(arg0),"."),copyinstr(arg1))] = count(); } END { printa(@a); }'
+    progtext = <<EOD
+self string uri;
+
+pid$1::mysql_real_query:entry
+{
+        @queries[copyinstr(arg1)] = count();
+}
+
+ruby$1:::function-entry
+{
+        @rbclasses[this->class = copyinstr(arg0)] = count();
+        this->sep = strjoin(this->class, "#");
+        @rbmethods[strjoin(this->sep, copyinstr(arg1))] = count();
+}
+
+syscall:::entry
+{
+        @syscalls[probefunc] = count();
+}
+
+END
+{
+        printf("report:syscalls");
+        printa(@syscalls);
+        printf("report:rbclasses");
+        printa(@rbclasses);
+        printf("report:rbmethods");
+        printa(@rbmethods);
+        printf("report:queries");
+        printa(@queries);
+}
+
+EOD
 
     begin
       @d = Dtrace.new
@@ -27,12 +59,20 @@ class Dtracer
   def end_dtrace
     return {} unless @d
 
+    current_report = 'none'
     begin
       dtrace_report = Hash.new
       c = DtraceConsumer.new(@d)
       c.consume_once do |e|
         if e.respond_to? :tuple
-          dtrace_report[e.tuple.first] = e.value
+          dtrace_report[current_report][e.tuple.first] = e.value
+        elsif e.respond_to? :value
+          if e.value =~ /report:(.*)/
+            current_report = Regexp.last_match(1)
+            unless dtrace_report[current_report]
+              dtrace_report[current_report] = Hash.new
+            end
+          end
         end
       end
     rescue DtraceException => e

data/plugin/dtrace/views/dtrace/_report.rhtml

@@ -1,11 +1,56 @@
+<style type="text/css">
+
+</style>
+
 <div id="dtrace-report">
-  <p>...dtrace report...</p>
-  <table>
-    <% controller.dtrace_report.sort {|a,b| b[1] <=> a[1] }.each do |e| %>
+  <h2>DTrace Report</h2>
+
+  <% if controller.dtrace_report['queries'] %>
+  <h3>MySQL queries</h3>
+  <table class="report">
+    <% controller.dtrace_report['queries'].sort {|a,b| b[1] <=> a[1] }.each do |e| %>
     <tr>
       <td><%= e[0] %></td>
       <td><%= e[1] %></td>
     </tr>
     <% end %>
   </table>
+  <% end %>
+
+  <% if controller.dtrace_report['syscalls'] %>
+  <h3>System calls</h3>
+  <table class="report">
+    <% controller.dtrace_report['syscalls'].sort {|a,b| b[1] <=> a[1] }.each do |e| %>
+    <tr>
+      <td><%= e[0] %></td>
+      <td><%= e[1] %></td>
+    </tr>
+    <% end %>
+  </table>
+  <% end %>
+
+  <% if controller.dtrace_report['rbclasses'] %>
+  <h3>Ruby classes instantiated</h3>
+  <table class="report">
+    <% controller.dtrace_report['rbclasses'].sort {|a,b| b[1] <=> a[1] }.each do |e| %>
+    <tr>
+      <td><%= e[0] %></td>
+      <td><%= e[1] %></td>
+    </tr>
+    <% end %>
+  </table>
+  <% end %>
+
+  <% if controller.dtrace_report['rbmethods'] %>
+  <h3>Ruby methods called</h3>
+  <table class="report">
+    <% controller.dtrace_report['rbmethods'].sort {|a,b| b[1] <=> a[1] }.each do |e| %>
+    <tr>
+      <td><%= e[0] %></td>
+      <td><%= e[1] %></td>
+    </tr>
+    <% end %>
+  </table>
+  <% end %>
+
 </div>