ruby-dtrace 0.0.1

data/plugin/dtrace/lib/dtracer_client.rb

@@ -0,0 +1,18 @@
+require 'drb'
+
+class DtracerClient
+
+  def initialize
+    DRb.start_service
+    @tracer = DRbObject.new(nil, 'druby://localhost:2999')  
+  end
+
+  def start_dtrace(pid)
+    @tracer.start_dtrace(pid)
+  end
+  
+  def end_dtrace
+    @tracer.end_dtrace
+  end
+  
+end

data/plugin/dtrace/public/stylesheets/dtrace.css

@@ -0,0 +1,48 @@
+body {
+  margin-bottom:25px;
+}
+
+#dtrace {
+  width:100%;
+}
+
+#dtrace td, #dtrace th, #dtrace div, #dtrace p {
+  text-align:left;
+}
+
+#dtrace a,
+#dtrace a:visited {
+  color:#005;
+  text-decoration:none;
+}
+
+#dtrace a:hover,
+#dtrace a:active {
+  text-decoration:underline;
+}
+
+#dtrace .dtrace-tab {
+  background-color:#fff;
+  padding:1em;
+  margin:0;
+}
+
+#dtrace-tabs {
+  width:100%;
+  height:25px;
+  margin:0; padding:0;
+  list-style-type:none;
+  background:#000;
+}
+
+#dtrace-tabs li {
+  float:left;
+}
+
+#dtrace-tabs li a,
+#dtrace-tabs li a:visited {
+  display:block;
+  line-height:25px;
+  margin:0 1em;
+  color:#fff;
+}

data/plugin/dtrace/tasks/dtrace.rake

@@ -0,0 +1,52 @@
+namespace :dtrace do
+
+  desc 'Set up dtrace in your rails application'
+  task :setup do
+    ['dtracer'].each do |script|
+      script_dest = "#{RAILS_ROOT}/script/#{script}"
+      script_src = File.dirname(__FILE__) + "/../bin/#{script}.rb"
+      
+      FileUtils.chmod 0774, script_src
+      
+      unless File.exists?(script_dest)
+        puts "Copying acts_as_encrypted script #{script}.rb to #{script_dest}"
+        FileUtils.cp_r(script_src, script_dest)
+      end
+    end
+
+    ['stylesheets/dtrace.css'].each do |asset|
+      asset_dest = "#{RAILS_ROOT}/public/#{asset}"
+      asset_src = File.dirname(__FILE__) + "/../public/#{asset}"
+      
+      FileUtils.chmod 0774, asset_src
+      
+      unless File.exists?(asset_dest)
+        puts "Copying acts_as_encrypted asset #{asset} to #{asset_dest}"
+        FileUtils.cp_r(asset_src, asset_dest)
+      end
+    end
+  end
+  
+  desc 'Remove dtrace from your rails application'
+  task :remove do 
+    ['dtracer'].each do |script|
+      script_dest = "#{RAILS_ROOT}/script/#{script}"
+
+      if File.exists?(script_dest)
+        puts "Removing #{script_dest} ..."
+        FileUtils.rm(script_dest, :force => true)
+      end
+    end
+
+    ['stylesheets/dtrace.css'].each do |asset|
+      asset_dest = "#{RAILS_ROOT}/public/#{asset}"
+
+      if File.exists?(asset_dest)
+        puts "Removing #{asset_dest} ..."
+        FileUtils.rm(asset_dest, :force => true)
+      end
+    end
+  end
+
+end
+    

data/plugin/dtrace/test/dtrace_test.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+
+class DtraceTest < Test::Unit::TestCase
+  # Replace this with your real tests.
+  def test_this_plugin
+    flunk
+  end
+end

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

@@ -0,0 +1,11 @@
+<div id="dtrace-report">
+  <p>...dtrace report...</p>
+  <table>
+    <% controller.dtrace_report.sort {|a,b| b[1] <=> a[1] }.each do |e| %>
+    <tr>
+      <td><%= e[0] %></td>
+      <td><%= e[1] %></td>
+    </tr>
+    <% end %>
+  </table>
+</div>

data/test/test_dtrace.rb

@@ -0,0 +1,415 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace'
+require 'test/unit'
+
+class TestDtrace < Test::Unit::TestCase
+  def test_dtrace
+    t = Dtrace.new
+    assert_equal Object, Dtrace.superclass
+    assert_equal Dtrace, t.class
+  end
+
+  def test_list_probes
+    t = Dtrace.new
+    probe_count = 0
+    t.each_probe do |probe|
+      assert probe.provider
+      assert probe.mod
+      assert probe.func
+      assert probe.name
+      probe_count += 1
+    end
+    assert probe_count
+  end
+
+  def test_compile
+    t = Dtrace.new
+
+    progtext = "syscall:::entry
+   			{
+                          @calls[execname] = count();
+			  @fcalls[probefunc] = count();
+			}"
+
+    prog = t.compile progtext
+    assert prog
+    prog.execute
+
+    info = prog.info
+    assert info
+    assert info.aggregates_count
+    assert_equal 0, info.speculations_count
+    assert info.recgens_count
+    assert info.matches_count
+  end
+  
+  def test_compile_with_args
+    t = Dtrace.new
+
+    progtext = "syscall:::entry
+                /pid == $1/
+                {
+                   @calls[execname] = count();
+                   @fcalls[probefunc] = count();
+                }"
+
+    prog = t.compile(progtext, $$.to_s)
+    assert prog
+    prog.execute
+
+    info = prog.info
+    assert info
+    assert_equal 2,   info.aggregates_count
+    assert_equal 0,   info.speculations_count
+    assert_equal 4,   info.recgens_count
+    
+    # matches_count is platform dependent
+    assert info.matches_count
+  end
+      
+  def test_run
+    t = Dtrace.new
+
+    t.setopt("aggsize", "4m")
+    t.setopt("bufsize", "4m")
+
+    progtext = "syscall:::entry
+   			{
+                          @calls[execname] = count();
+			  @fcalls[probefunc] = count();
+			}"
+
+    prog = t.compile progtext
+    assert prog
+    prog.execute
+    assert_equal 0, t.status # none
+
+    t.go
+
+    assert_equal 1, t.status # ok
+    sleep 1
+    assert_equal 1, t.status # ok
+    t.stop
+    assert_equal 4, t.status # stopped
+  end
+
+  def test_aggregate_print
+    t = Dtrace.new
+
+    t.setopt("aggsize", "4m")
+    t.setopt("bufsize", "4m")
+
+    progtext = "syscall:::entry
+   			{
+                          @calls[execname] = count();
+			  @fcalls[probefunc] = count();
+			}"
+
+    prog = t.compile progtext
+    assert prog
+    prog.execute
+
+    t.go
+    sleep 1
+    t.stop
+
+    t.aggregate_snap
+    t.aggregate_print
+  end
+
+  def test_aggregate_walk
+    t = Dtrace.new
+
+    t.setopt("aggsize", "4m")
+    t.setopt("bufsize", "4m")
+
+    progtext = "syscall:::entry
+   			{
+			  @fcalls[probefunc] = count();
+                          @calls[execname] = count();
+			}"
+
+    prog = t.compile progtext
+    assert prog
+    prog.execute
+
+    t.go
+    sleep 1
+    t.stop
+
+    t.aggregate_snap
+    
+    t.each_aggregate do |agg|
+      agg.each_record do |rec|
+        assert rec
+        assert rec.data
+      end
+    end
+  end
+
+  def test_aggregate_record_array
+    t = Dtrace.new
+
+    t.setopt("aggsize", "4m")
+    t.setopt("bufsize", "4m")
+
+    progtext = "syscall:::entry
+   			{
+                          @calls[execname] = count();
+			}"
+
+    prog = t.compile progtext
+    assert prog
+    prog.execute
+
+    t.go
+    sleep 1
+    t.stop
+
+    t.aggregate_snap
+    
+    t.each_aggregate do |agg|
+      assert agg
+      assert agg.num_records
+      (0..(agg.num_records - 1)).each do |i|
+        rec = agg[i]
+        assert rec.data
+      end
+    end
+  end
+
+  def test_aggregate_record_array_continuous
+    t = Dtrace.new
+
+    t.setopt("aggsize", "4m")
+    t.setopt("bufsize", "4m")
+
+    progtext = "syscall:::entry
+   			{
+                          @calls[execname] = count();
+			}"
+
+    prog = t.compile progtext
+    assert prog
+    prog.execute
+
+    t.go
+
+    (1..10).each do 
+      sleep 1
+      t.aggregate_snap
+      
+      t.each_aggregate do |agg|
+        assert agg
+        assert agg.num_records
+        (0..(agg.num_records - 1)).each do |i|
+          rec = agg[i]
+          assert rec.data
+        end
+      end
+      t.aggregate_clear
+    end
+
+    t.stop
+  end
+
+  def test_bad_program
+    t = Dtrace.new
+    progtext = "blah blahb albhacasfas"
+    e = assert_raise DtraceException do
+      prog = t.compile progtext
+    end
+    assert_equal "probe description :::blah does not match any probes", e.message
+  end
+
+  def test_rubys_own_dtrace
+    t = Dtrace.new
+
+    t.setopt("aggsize", "4m")
+    t.setopt("bufsize", "4m")
+
+    progtext = "ruby*:::function-entry{ @[copyinstr(arg1)] = count(); }"
+
+    prog = t.compile progtext
+    assert prog
+    prog.execute
+
+    t.go
+
+    foo = 0
+    (1..1000).each do |i|
+      foo = foo + i
+    end
+    
+    t.stop
+    t.aggregate_snap
+    
+    t.each_aggregate do |agg|
+      assert agg
+      assert agg.num_records
+      (0..(agg.num_records - 1)).each do |i|
+        rec = agg[i]
+        assert rec.data
+      end
+    end
+  end
+
+  def test_multiple_programs
+    t = Dtrace.new
+
+    t.setopt("aggsize", "4m")
+    t.setopt("bufsize", "4m")
+
+    progtext = "syscall:::entry
+   		{
+                    @calls[execname] = count();
+                }"
+
+    prog1 = t.compile progtext
+    assert prog1
+
+    progtext = "syscall:::entry
+   		{
+			  @fcalls[probefunc] = count();
+                }"
+
+    prog2 = t.compile progtext
+    assert prog2
+
+    prog1.execute
+    prog2.execute
+
+    info1 = prog1.info
+    assert info1
+    assert_equal 1,   info1.aggregates_count
+    assert_equal 0,   info1.speculations_count
+    assert_equal 2,   info1.recgens_count
+    assert            info1.matches_count
+
+    info2 = prog2.info
+    assert info2
+    assert_equal 1,   info2.aggregates_count
+    assert_equal 0,   info2.speculations_count
+    assert_equal 2,   info2.recgens_count
+    assert            info2.matches_count
+
+    t.go
+    sleep 2
+    t.stop
+    t.aggregate_snap
+    
+    t.each_aggregate do |agg|
+      assert agg
+      assert agg.num_records
+      (0..(agg.num_records - 1)).each do |i|
+        rec = agg[i]
+        assert rec.data
+      end
+    end
+  end
+
+  def test_multiple_runs
+    t = Dtrace.new
+    t.setopt("aggsize", "4m")
+    t.setopt("bufsize", "4m")
+
+    progtext = "ruby*:::function-entry{ @[copyinstr(arg1)] = count(); }"
+
+    prog = t.compile progtext
+    assert prog
+    prog.execute
+
+    t.go
+
+    foo = 0
+    (1..1000).each do |i|
+      foo = foo + i
+    end
+    
+    t.stop
+    t.aggregate_snap
+    
+    t.each_aggregate do |agg|
+      assert agg
+      assert agg.num_records
+      (0..(agg.num_records - 1)).each do |i|
+        rec = agg[i]
+        assert rec.data
+      end
+    end
+
+    t = Dtrace.new
+    t.setopt("aggsize", "4m")
+    t.setopt("bufsize", "4m")
+
+    prog = t.compile progtext
+    assert prog
+
+    prog.execute
+
+    t.go
+
+    foo = 0
+    (1..1000).each do |i|
+      foo = foo + i
+    end
+    
+    t.stop
+    t.aggregate_snap
+    
+    t.each_aggregate do |agg|
+      assert agg
+      assert agg.num_records
+      (0..(agg.num_records - 1)).each do |i|
+        rec = agg[i]
+        assert rec.data
+      end
+    end
+
+  end
+
+  def test_aggdata_probe
+    t = Dtrace.new
+
+    t.setopt("aggsize", "4m")
+    t.setopt("bufsize", "4m")
+
+    progtext = "ruby*:::function-entry{ @[copyinstr(arg1)] = count(); }"
+
+    prog = t.compile progtext
+    assert prog
+    prog.execute
+
+    t.go
+
+    foo = 0
+    (1..1000).each do |i|
+      foo = foo + i
+    end
+
+    t.stop
+
+    t.aggregate_snap
+    
+    t.each_aggregate do |agg|
+
+      probe = agg.probe
+      assert probe.provider
+      assert probe.mod
+      assert probe.func
+      assert probe.name
+      
+      agg.each_record do |rec|
+        assert rec
+        assert rec.data
+      end
+    end
+
+
+  end
+  
+end