ruby-dtrace 0.0.6 → 0.2.8

data/test/test_dtrace.rb

@@ -28,6 +28,72 @@ class TestDtrace < Test::Unit::TestCase
     assert probe_count
   end
 
+  def test_list_probes_match
+    t = Dtrace.new
+    probe_count = 0
+    t.each_probe('syscall:::') do |probe|
+      assert probe.provider
+      assert probe.mod
+      assert probe.func
+      assert probe.name
+      probe_count += 1
+    end
+    assert probe_count
+  end
+
+  def test_list_probes_match_usdt
+    t = Dtrace.new
+    probe_count = 0
+    t.each_probe("pid#{$$}:::return") do |probe|
+      puts probe
+      assert probe.provider
+      assert probe.mod
+      assert probe.func
+      assert probe.name
+      probe_count += 1
+    end
+    assert probe_count
+  end
+
+  def test_list_probes_match_prog
+    t = Dtrace.new
+    
+    progtext = "syscall:::return
+   			{
+                          @calls[execname] = count();
+			  @fcalls[probefunc] = count();
+			}
+
+                syscall:::entry
+                /pid == $1/
+                {
+                   @calls[execname] = count();
+                   @fcalls[probefunc] = count();
+                }"
+    prog = t.compile(progtext, $$.to_s)
+    prog.execute
+
+    probe_count = 0
+    t.each_probe_prog(prog) do |probe|
+      assert probe.provider
+      assert probe.mod
+      assert probe.func
+      assert probe.name
+      probe_count += 1
+    end
+    assert probe_count
+  end
+
+  def test_list_probes_match_badpattern
+    t = Dtrace.new
+    probe_count = 0
+    assert_raises Dtrace::Exception do 
+      t.each_probe('syscall') do |probe|
+        nil
+      end
+    end
+  end
+
   def test_compile
     t = Dtrace.new
 
@@ -102,7 +168,7 @@ class TestDtrace < Test::Unit::TestCase
   def test_bad_program
     t = Dtrace.new
     progtext = "blah blahb albhacasfas"
-    e = assert_raise DtraceException do
+    e = assert_raise Dtrace::Exception do
       prog = t.compile progtext
     end
     assert_equal "probe description :::blah does not match any probes", e.message

data/test/test_dtrace_aggregates.rb

@@ -21,7 +21,7 @@ profile-1000
   @b[execname] = count();
 }
 
-profile-10
+profile-1
 {
   printa(@a);
   printa(@b);
@@ -32,9 +32,9 @@ EOD
     prog.execute
     t.go
 
-    sleep 1
+    sleep 3
 
-    c = DtraceConsumer.new(t)
+    c = Dtrace::Consumer.new(t)
     assert c
 
     data = []
@@ -45,9 +45,9 @@ EOD
     assert data.length > 0
     data.each do |d|
       assert d
-      assert_equal DtraceData, d.class
+      assert_equal Dtrace::Data, d.class
       d.data.each do |agg|
-        assert_equal DtraceAggregateSet, agg.class
+        assert_equal Dtrace::AggregateSet, agg.class
       end
     end
 

data/test/test_dtrace_drops_errors.rb

@@ -34,7 +34,7 @@ EOD
     prog = t.compile progtext
     prog.execute
 
-    c = DtraceConsumer.new(t)
+    c = Dtrace::Consumer.new(t)
     assert c
 
     i = 0
@@ -70,12 +70,12 @@ EOD
     prog.execute
     t.go 
 
-    c = DtraceConsumer.new(t)
+    c = Dtrace::Consumer.new(t)
     assert c
 
     # since we've already said "go", we now can't apply an error
     # handler (DTrace will let us, but won't call it).
-    assert_raise(DtraceException) do
+    assert_raise(Dtrace::Exception) do
       c.errhandler do |d|
         # nothing
       end
@@ -98,7 +98,7 @@ EOD
     prog = t.compile progtext
     prog.execute
 
-    c = DtraceConsumer.new(t)
+    c = Dtrace::Consumer.new(t)
     assert c
 
     i = 0
@@ -148,7 +148,7 @@ EOD
     prog = t.compile progtext
     prog.execute
 
-    c = DtraceConsumer.new(t)
+    c = Dtrace::Consumer.new(t)
     assert c
 
     errors = 0

data/test/test_dtrace_probe.rb

@@ -0,0 +1,385 @@
+#
+# Ruby-Dtrace
+# (c) 2008 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace'
+require 'dtrace/dof'
+require 'test/unit'
+
+class TestDtraceProbe < Test::Unit::TestCase
+  include Dtrace::Dof::Constants
+  
+  def test_probe
+    p = Dtrace::Probe.new(0)
+  end
+
+  def test_fire_probe
+    p = Dtrace::Probe.new(0)
+    p.fire
+  end
+
+  def test_is_probe_not_enabled
+    p = Dtrace::Probe.new(0)
+    assert !p.is_enabled?
+  end
+
+  def test_fire_probe_no_args
+    probe = Dtrace::Probe.new(0)
+    addr = probe.addr
+
+    f = Dtrace::Dof::File.new
+    f.allocate(4096)
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_STRTAB, 0)
+    s.data = ['args', 'main', 'testprobe']
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROBES, 1)
+    s.data = [
+              {
+                :noffs    => 1,
+                :enoffidx => 0,
+                :argidx   => 0,
+                :name     => 1,
+                :nenoffs  => 1,
+                :offidx   => 0,
+                :addr     => addr,
+                :nargc    => 0,
+                :func     => 6,
+                :xargc    => 0
+              },
+             ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRARGS, 2)
+    s.data = [ 0 ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROFFS, 3)
+    s.data = [ probe.probe_offset(f.addr, 0) ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRENOFFS, 4)
+    s.data = [ probe.is_enabled_offset(f.addr) ]
+    f.sections << s
+    
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROVIDER, 5)
+    s.data = {
+      :strtab   => 0,
+      :probes   => 1,
+      :prargs   => 2,
+      :proffs   => 3,
+      :prenoffs => 4,
+      :name     => 11,
+      :provattr => { :name => 5, :data => 5, :class => 5 },
+      :modattr  => { :name => 1, :data => 1, :class => 5 },
+      :funcattr => { :name => 1, :data => 1, :class => 5 },
+      :nameattr => { :name => 5, :data => 5, :class => 5 },
+      :argsattr => { :name => 5, :data => 5, :class => 5 }
+    }
+    f.sections << s
+
+    f.generate
+    Dtrace::Dof.loaddof(f, 'testmodule')
+  
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+
+    matches = 0
+    t.each_probe("testprobe#{$$}:testmodule:main:args") do |p|
+      matches += 1
+    end
+    assert_equal 1, matches
+
+    progtext = <<EOD
+test*:testmodule:main:args
+{
+  trace("fired!");
+}
+EOD
+
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    c = Dtrace::Consumer.new(t)
+
+    probe.fire
+
+    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_fire_probe_two_int_args
+    probe = Dtrace::Probe.new(2)
+    addr = probe.addr
+
+    f = Dtrace::Dof::File.new
+    f.allocate(4096)
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_STRTAB, 0)
+    s.data = ['test', 'main', 'tes2', 'int', 'int', 'int', 'int']
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROBES, 1)
+    s.data = [
+              {
+                :nargv    => 16,
+                :noffs    => 1,
+                :xargv    => 24,
+                :enoffidx => 0,
+                :argidx   => 0,
+                :name     => 1,
+                :nenoffs  => 1,
+                :offidx   => 0,
+                :addr     => addr,
+                :nargc    => 2,
+                :func     => 6,
+                :xargc    => 2
+              },
+             ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRARGS, 2)
+    s.data = [ 0, 1 ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROFFS, 3)
+    s.data = [ probe.probe_offset(f.addr, 2) ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRENOFFS, 4)
+    s.data = [ probe.is_enabled_offset(f.addr) ]
+    f.sections << s
+    
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROVIDER, 5)
+    s.data = {
+      :strtab   => 0,
+      :probes   => 1,
+      :prargs   => 2,
+      :proffs   => 3,
+      :prenoffs => 4,
+      :name     => 11,
+      :provattr => { :name => 5, :data => 5, :class => 5 },
+      :modattr  => { :name => 1, :data => 1, :class => 5 },
+      :funcattr => { :name => 1, :data => 1, :class => 5 },
+      :nameattr => { :name => 5, :data => 5, :class => 5 },
+      :argsattr => { :name => 5, :data => 5, :class => 5 }
+    }
+    f.sections << s
+
+    f.generate
+    Dtrace::Dof.loaddof(f, 'testmodule')
+
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+
+    progtext = <<EOD
+tes2*:testmodule:main:test
+{
+  trace(arg0);
+  trace(arg1);
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    c = Dtrace::Consumer.new(t)
+
+    probe.fire(41, 42)
+
+    data = []
+    c.consume_once do |d|
+      data << d
+    end
+
+    assert_equal 1, data.length
+    assert_equal 41, data[0].data[0].value
+    assert_equal 42, data[0].data[1].value
+  end
+
+  def test_fire_probe_two_charstar_args
+    probe = Dtrace::Probe.new(2)
+    addr = probe.addr
+
+    f = Dtrace::Dof::File.new
+    f.allocate(4096)
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_STRTAB, 0)
+    s.data = ['test', 'main', 'tes3', 'char *', 'char *', 'char *', 'char *']
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROBES, 1)
+    s.data = [
+              {
+                :nargv    => 16,
+                :noffs    => 1,
+                :xargv    => 30,
+                :enoffidx => 0,
+                :argidx   => 0,
+                :name     => 1,
+                :nenoffs  => 1,
+                :offidx   => 0,
+                :addr     => addr,
+                :nargc    => 2,
+                :func     => 6,
+                :xargc    => 2
+              },
+             ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRARGS, 2)
+    s.data = [ 0, 1 ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROFFS, 3)
+    s.data = [ probe.probe_offset(f.addr, 2) ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRENOFFS, 4)
+    s.data = [ probe.is_enabled_offset(f.addr) ]
+    f.sections << s
+    
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROVIDER, 5)
+    s.data = {
+      :strtab   => 0,
+      :probes   => 1,
+      :prargs   => 2,
+      :proffs   => 3,
+      :prenoffs => 4,
+      :name     => 11,
+      :provattr => { :name => 5, :data => 5, :class => 5 },
+      :modattr  => { :name => 1, :data => 1, :class => 5 },
+      :funcattr => { :name => 1, :data => 1, :class => 5 },
+      :nameattr => { :name => 5, :data => 5, :class => 5 },
+      :argsattr => { :name => 5, :data => 5, :class => 5 }
+    }
+    f.sections << s
+
+    f.generate
+    Dtrace::Dof.loaddof(f, 'testmodule')
+
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+
+    progtext = <<EOD
+tes3*:testmodule:main:test
+{
+  trace(copyinstr(arg0));
+  trace(copyinstr(arg1));
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    c = Dtrace::Consumer.new(t)
+
+    probe.fire('foo', 'bar')
+
+    data = []
+    c.consume_once do |d|
+      data << d
+    end
+
+    assert_equal 1, data.length
+    assert_equal 'foo', data[0].data[0].value
+    assert_equal 'bar', data[0].data[1].value
+  end
+
+  def test_probe_is_enabled
+    probe = Dtrace::Probe.new(0)
+    addr = probe.addr
+
+    f = Dtrace::Dof::File.new
+    f.allocate(4096)
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_STRTAB, 0)
+    s.data = ['test', 'main', 'tes4']
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROBES, 1)
+    s.data = [
+              {
+                :noffs    => 1,
+                :enoffidx => 0,
+                :argidx   => 0,
+                :name     => 1,
+                :nenoffs  => 1,
+                :offidx   => 0,
+                :addr     => addr,
+                :nargc    => 0,
+                :func     => 6,
+                :xargc    => 0
+              },
+             ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRARGS, 2)
+    s.data = [ 0 ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROFFS, 3)
+    s.data = [ probe.probe_offset(f.addr, 0) ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRENOFFS, 4)
+    s.data = [ probe.is_enabled_offset(f.addr) ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROVIDER, 5)
+    s.data = {
+      :strtab   => 0,
+      :probes   => 1,
+      :prargs   => 2,
+      :proffs   => 3,
+      :prenoffs => 4,
+      :name     => 11,
+      :provattr => { :name => 5, :data => 5, :class => 5 },
+      :modattr  => { :name => 1, :data => 1, :class => 5 },
+      :funcattr => { :name => 1, :data => 1, :class => 5 },
+      :nameattr => { :name => 5, :data => 5, :class => 5 },
+      :argsattr => { :name => 5, :data => 5, :class => 5 }
+    }
+    f.sections << s
+
+    f.generate
+    Dtrace::Dof.loaddof(f, 'testmodule')
+
+    assert !probe.is_enabled?
+
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+
+    progtext = <<EOD
+tes4*:testmodule:main:test
+{
+  trace("fired!");
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go
+    
+    assert probe.is_enabled?
+    
+    probe.fire
+
+    c = Dtrace::Consumer.new(t)
+    data = []
+    c.consume_once do |d|
+      data << d
+    end
+
+    assert_equal 1, data.length
+    assert_equal 'fired!', data[0].data[0].value
+  end
+
+end