chrisa-ruby-dtrace 0.2.0

data/test/test_dtrace_probes.rb

@@ -0,0 +1,400 @@
+#
+# Ruby-Dtrace
+# (c) 2008 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace'
+require 'dtrace/provider'
+require 'test/unit'
+
+class TestDtraceProbes < Test::Unit::TestCase
+
+  def test_probe_no_args
+    Dtrace::Provider.create :foo1 do |p|
+      p.probe :bar
+    end
+    
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+
+    progtext = <<EOD
+foo1*:ruby:test_probe_no_args:bar
+{
+  trace("fired");
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    c = Dtrace::Consumer.new(t)
+
+    Dtrace::Probe::Foo1.bar do |p|
+      p.fire
+    end    
+
+    data = []
+    c.consume_once do |d|
+      data << d
+    end
+
+    assert_equal 1, data.length
+    assert_equal 'fired', data[0].data[0].value
+    
+  end
+  
+  def test_probe_one_int_arg
+    Dtrace::Provider.create :foo2 do |p|
+      p.probe :bar, :integer
+    end
+    
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+
+    progtext = <<EOD
+foo2*:ruby:test_probe_one_int_arg:bar
+{
+  trace(arg0);
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    c = Dtrace::Consumer.new(t)
+
+    Dtrace::Probe::Foo2.bar do |p|
+      p.fire(42)
+    end    
+
+    data = []
+    c.consume_once do |d|
+      data << d
+    end
+
+    assert_equal 1, data.length
+    assert_equal 42, data[0].data[0].value
+    
+  end
+
+  def test_multiple_probes_w_args
+    Dtrace::Provider.create :foo3 do |p|
+      p.probe :bar, :integer
+      p.probe :baz, :string
+    end
+    
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+
+    progtext = <<EOD
+foo3*:ruby:*:bar
+{
+  trace(arg0);
+}
+
+foo3*:ruby:*:baz
+{
+  trace(copyinstr(arg0));
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    c = Dtrace::Consumer.new(t)
+
+    Dtrace::Probe::Foo3.bar do |p|
+      p.fire(42)
+    end    
+
+    Dtrace::Probe::Foo3.baz do |p|
+      p.fire('fired!')
+    end    
+
+    data = []
+    c.consume_once do |d|
+      data << d
+    end
+
+    assert_equal 2, data.length
+    assert_equal 42, data[0].data[0].value
+    assert_equal 'fired!', data[1].data[0].value
+    
+  end
+
+  def test_multiple_probes_w_multiple_args
+    Dtrace::Provider.create :foo4 do |p|
+      p.probe :bar, :integer, :integer
+      p.probe :baz, :string, :string
+    end
+    
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+
+    progtext = <<EOD
+foo4*:ruby:*:bar
+{
+  trace(arg0);
+  trace(arg1);
+}
+
+foo4*:ruby:*:baz
+{
+  trace(copyinstr(arg0));
+  trace(copyinstr(arg1));
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    c = Dtrace::Consumer.new(t)
+
+    Dtrace::Probe::Foo4.bar do |p|
+      p.fire(42, 27)
+    end    
+
+    Dtrace::Probe::Foo4.baz do |p|
+      p.fire('fired!', 'again')
+    end    
+
+    data = []
+    c.consume_once do |d|
+      data << d
+    end
+
+    assert_equal 2, data.length
+    assert_equal 42, data[0].data[0].value
+    assert_equal 27, data[0].data[1].value
+    assert_equal 'fired!', data[1].data[0].value
+    assert_equal 'again', data[1].data[1].value
+    
+  end
+
+  def test_all_argcs
+    Dtrace::Provider.create :foo5 do |p|
+      p.probe :bar1, :integer
+      p.probe :bar2, :integer, :integer
+      p.probe :bar3, :integer, :integer, :integer
+      p.probe :bar4, :integer, :integer, :integer, :integer
+      p.probe :bar5, :integer, :integer, :integer, :integer,
+                     :integer
+      p.probe :bar6, :integer, :integer, :integer, :integer,
+                     :integer, :integer
+      p.probe :bar7, :integer, :integer, :integer, :integer,
+                     :integer, :integer, :integer
+      p.probe :bar8, :integer, :integer, :integer, :integer,
+                     :integer, :integer, :integer, :integer
+    end
+    
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+
+    progtext = <<EOD
+foo5*:ruby:*:bar1
+{
+  trace(arg0);
+
+}
+
+foo5*:ruby:*:bar2
+{
+  trace(arg0);
+  trace(arg1);
+
+}
+
+foo5*:ruby:*:bar3
+{
+  trace(arg0);
+  trace(arg1);
+  trace(arg2);
+
+}
+
+foo5*:ruby:*:bar4
+{
+  trace(arg0);
+  trace(arg1);
+  trace(arg2);
+  trace(arg3);
+
+}
+
+foo5*:ruby:*:bar5
+{
+  trace(arg0);
+  trace(arg1);
+  trace(arg2);
+  trace(arg3);
+  trace(arg4);
+}
+
+foo5*:ruby:*:bar6
+{
+  trace(arg0);
+  trace(arg1);
+  trace(arg2);
+  trace(arg3);
+  trace(arg4);
+  trace(arg5);
+}
+
+foo5*:ruby:*:bar7
+{
+  trace(arg0);
+  trace(arg1);
+  trace(arg2);
+  trace(arg3);
+  trace(arg4);
+  trace(arg5);
+  trace(arg6);
+}
+
+foo5*:ruby:*:bar8
+{
+  trace(arg0);
+  trace(arg1);
+  trace(arg2);
+  trace(arg3);
+  trace(arg4);
+  trace(arg5);
+  trace(arg6);
+  trace(arg7);
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    c = Dtrace::Consumer.new(t)
+    
+    Dtrace::Probe::Foo5.bar1 do |p|
+      p.fire(11)
+    end
+    Dtrace::Probe::Foo5.bar2 do |p|
+      p.fire(21, 22)
+    end
+    Dtrace::Probe::Foo5.bar3 do |p|
+      p.fire(31, 32, 33)
+    end
+    Dtrace::Probe::Foo5.bar4 do |p|
+      p.fire(41, 42, 43, 44)
+    end
+    Dtrace::Probe::Foo5.bar5 do |p|
+      p.fire(51, 52, 53, 54, 55)
+    end
+    Dtrace::Probe::Foo5.bar6 do |p|
+      p.fire(61, 62, 63, 64, 65, 66)
+    end
+    Dtrace::Probe::Foo5.bar7 do |p|
+      p.fire(71, 72, 73, 74, 75, 76, 77)
+    end
+   Dtrace::Probe::Foo5.bar8 do |p|
+     p.fire(81, 82, 83, 84, 85, 86, 87, 88)
+   end
+
+    data = []
+    c.consume_once do |d|
+      data << d
+    end
+
+    assert_equal 8, data.length
+
+    assert_equal 11, data[0].data[0].value
+
+    assert_equal 21, data[1].data[0].value
+    assert_equal 22, data[1].data[1].value
+
+    assert_equal 31, data[2].data[0].value
+    assert_equal 32, data[2].data[1].value
+    assert_equal 33, data[2].data[2].value
+
+    assert_equal 41, data[3].data[0].value
+    assert_equal 42, data[3].data[1].value
+    assert_equal 43, data[3].data[2].value
+    assert_equal 44, data[3].data[3].value
+
+    assert_equal 51, data[4].data[0].value
+    assert_equal 52, data[4].data[1].value
+    assert_equal 53, data[4].data[2].value
+    assert_equal 54, data[4].data[3].value
+    assert_equal 55, data[4].data[4].value
+
+    assert_equal 61, data[5].data[0].value
+    assert_equal 62, data[5].data[1].value
+    assert_equal 63, data[5].data[2].value
+    assert_equal 64, data[5].data[3].value
+    assert_equal 65, data[5].data[4].value
+    assert_equal 66, data[5].data[5].value
+
+    assert_equal 71, data[6].data[0].value
+    assert_equal 72, data[6].data[1].value
+    assert_equal 73, data[6].data[2].value
+    assert_equal 74, data[6].data[3].value
+    assert_equal 75, data[6].data[4].value
+    assert_equal 76, data[6].data[5].value
+    assert_equal 77, data[6].data[6].value
+
+    assert_equal 81, data[7].data[0].value
+    assert_equal 82, data[7].data[1].value
+    assert_equal 83, data[7].data[2].value
+    assert_equal 84, data[7].data[3].value
+    assert_equal 85, data[7].data[4].value
+    assert_equal 86, data[7].data[5].value
+    assert_equal 87, data[7].data[6].value
+    assert_equal 88, data[7].data[7].value
+    
+  end
+
+  def test_all_eight_args_chars
+    Dtrace::Provider.create :foo6 do |p|
+      p.probe :bar, :string, :string, :string, :string,
+                    :string, :string, :string, :string
+    end
+    
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+
+    progtext = <<EOD
+foo6*:ruby:*:bar
+{
+  trace(copyinstr(arg0));
+  trace(copyinstr(arg1));
+  trace(copyinstr(arg2));
+  trace(copyinstr(arg3));
+  trace(copyinstr(arg4));
+  trace(copyinstr(arg5));
+  trace(copyinstr(arg6));
+  trace(copyinstr(arg7));
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    c = Dtrace::Consumer.new(t)
+
+    Dtrace::Probe::Foo6.bar do |p|
+      p.fire('one',  'two', 'three', 'four',
+             'five', 'six', 'seven', 'eight')
+    end    
+
+    data = []
+    c.consume_once do |d|
+      data << d
+    end
+
+    assert_equal 1, data.length
+    assert_equal 'one',   data[0].data[0].value
+    assert_equal 'two',   data[0].data[1].value
+    assert_equal 'three', data[0].data[2].value
+    assert_equal 'four',  data[0].data[3].value
+    assert_equal 'five',  data[0].data[4].value
+    assert_equal 'six',   data[0].data[5].value
+    assert_equal 'seven', data[0].data[6].value
+    assert_equal 'eight', data[0].data[7].value
+    
+  end
+
+end

data/test/test_dtrace_processes.rb

@@ -0,0 +1,83 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace'
+require 'test/unit'
+
+# Tests for creating and grabbing processes.
+
+class TestDtraceProcesses < Test::Unit::TestCase
+
+  def test_createprocess
+
+    t = Dtrace.new 
+    t.setopt("bufsize", "8m")
+    t.setopt("aggsize", "4m")
+    t.setopt("stackframes", "5")
+    t.setopt("strsize", "131072")
+
+    progtext = <<EOD
+pid$target:*::entry,
+pid$target:*::return
+{
+  trace(pid);
+}
+EOD
+
+    p = t.createprocess([ '/usr/bin/true' ])
+    prog = t.compile(progtext)
+    prog.execute
+    t.go
+    p.continue
+
+    i = 0
+    c = Dtrace::Consumer.new(t)
+    c.consume do |d|
+      assert d
+      assert_equal "pid#{d.data[0].value}", d.probe.provider
+      i = i + 1
+      if i > 10
+        c.finish
+      end
+    end
+    assert i > 0
+  end
+
+  def test_grabprocess
+
+    t = Dtrace.new 
+    t.setopt("bufsize", "8m")
+    t.setopt("aggsize", "4m")
+    t.setopt("stackframes", "5")
+    t.setopt("strsize", "131072")
+
+    progtext = <<EOD
+pid$target:*::entry,
+pid$target:*::return
+{
+
+}
+EOD
+
+    pid = Kernel.fork { (0..9).each do sleep 1 end }
+    p = t.grabprocess(pid)
+    prog = t.compile(progtext)
+    prog.execute
+
+    t.go
+    p.continue
+
+    sleep 3
+
+    i = 0
+    c = Dtrace::Consumer.new(t)
+    c.consume_once do |d|
+      assert d
+      assert_equal "pid#{pid}", d.probe.provider
+      i = i + 1
+    end
+    assert i > 0
+  end
+end

data/test/test_dtrace_profile.rb

@@ -0,0 +1,232 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace'
+require 'test/unit'
+
+# Tests using the DTrace profile provider.
+
+class TestDtraceProfile < Test::Unit::TestCase
+  
+  def test_dprogram_run
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+    t.setopt("aggsize", "4m")
+
+    progtext = 'profile:::profile-1 { trace("foo"); }'
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    sleep 2
+
+    c = Dtrace::Consumer.new(t)
+    assert c
+
+    i = 0
+    c.consume do |d|
+      assert d
+      assert_equal "profile:::profile-1", d.probe.to_s
+      assert_not_nil d.cpu
+
+      d.data.each do |r|
+        assert_equal r.value, "foo"
+      end
+
+      i = i + 1
+      if i > 10
+        c.finish
+      end
+    end
+    assert i > 0
+  end
+    
+  def test_dprogram_aggregate
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+    t.setopt("aggsize", "4m")
+
+    progtext = <<EOD
+profile-1000
+{ 
+  @a[execname] = count(); 
+}
+
+profile-10
+{
+  printa(@a)
+}
+EOD
+
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    sleep 2
+
+    c = Dtrace::Consumer.new(t)
+
+    i = 0
+    c.consume do |d|
+      assert d
+      assert_not_nil d.cpu
+      assert_equal "profile:::profile-10", d.probe.to_s
+
+      d.data.each do |r|
+        assert_equal Dtrace::AggregateSet, r.class
+        r.data.each do |a|
+          assert_not_nil a.value
+          assert_not_nil a.tuple
+          assert_equal 1, a.tuple.length
+        end
+      end
+
+      i = i + 1
+      if i >= 10
+        c.finish
+      end
+    end
+    assert i > 0
+  end
+
+  def test_dprogram_printf
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+    t.setopt("aggsize", "4m")
+
+    progtext = <<EOD
+profile-1
+{ 
+  printf("execname: %s %s", execname, "foo")
+}
+EOD
+
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    sleep 2
+    
+    c = Dtrace::Consumer.new(t)
+
+    i = 0
+    c.consume do |d|
+      assert d
+      assert_not_nil d.cpu
+      assert_equal "profile:::profile-1", d.probe.to_s
+
+      i = i + 1
+      if i >= 10
+        c.finish
+      end
+    end
+    assert i > 0
+  end
+
+  def test_dprogram_aggregate_once
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+    t.setopt("aggsize", "4m")
+
+    progtext = <<EOD
+profile-1000hz
+{ 
+  @a[execname] = count(); 
+}
+
+END
+{
+  printa(@a)
+}
+EOD
+
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    sleep 2
+    
+    i = 0
+    c = Dtrace::Consumer.new(t)
+    c.consume_once do |d|
+      i = i + 1
+      assert d
+      assert_not_nil d.cpu
+      assert_equal "dtrace:::END", d.probe.to_s
+      
+      d.data.each do |r|
+        assert_equal Dtrace::AggregateSet, r.class
+        r.data.each do |a|
+          assert_not_nil a.value
+          assert_not_nil a.tuple
+          assert_equal 1, a.tuple.length
+        end
+      end
+    end
+    assert i > 0    
+  end
+  
+  def test_stack
+    t = Dtrace.new 
+    t.setopt("bufsize", "8m")
+    t.setopt("aggsize", "4m")
+    t.setopt("stackframes", "5")
+    t.setopt("strsize", "131072")
+
+    progtext = "profile-1 { trace(execname); stack(); }"
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    sleep 2
+
+    c = Dtrace::Consumer.new(t)
+    i = 0
+    c.consume do |d|
+      assert d
+      assert_not_nil d.cpu
+      assert_equal "profile:::profile-1", d.probe.to_s
+
+      assert_equal 2, d.data.length
+      assert_equal Dtrace::Record, d.data[0].class
+      assert_equal Dtrace::StackRecord, d.data[1].class
+      
+      i = i + 1
+      if i > 10
+        c.finish
+      end
+    end
+    assert i > 0
+  end
+
+  def test_ustack
+    t = Dtrace.new 
+    t.setopt("bufsize", "8m")
+    t.setopt("aggsize", "4m")
+    t.setopt("stackframes", "5")
+    t.setopt("strsize", "131072")
+
+    progtext = "profile-1 { trace(execname); ustack(); }"
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    sleep 2
+
+    c = Dtrace::Consumer.new(t)
+    i = 0
+    c.consume do |d|
+      assert d
+      assert_not_nil d.cpu
+      assert_equal "profile:::profile-1", d.probe.to_s
+
+      assert_equal 2, d.data.length
+      assert_equal Dtrace::Record, d.data[0].class
+      assert_equal Dtrace::StackRecord, d.data[1].class
+
+      i = i + 1
+      if i > 10
+        c.finish
+      end
+    end
+    assert i > 0
+  end
+
+end