chrisa-ruby-dtrace 0.2.0

data/test/test_dof_providers.rb

@@ -0,0 +1,282 @@
+#
+# Ruby-Dtrace
+# (c) 2008 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace'
+require 'dtrace/dof'
+require 'test/unit'
+
+class TestDofProviders < Test::Unit::TestCase
+  include Dtrace::Dof::Constants
+  
+  def test_probe_no_args
+    f = Dtrace::Dof::File.new
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_STRTAB, 0)
+    s.data = ['test', 'main', 'test1']
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROBES, 1)
+    s.data = [
+              {
+                :noffs    => 1,
+                :enoffidx => 0,
+                :argidx   => 0,
+                :name     => 1,
+                :nenoffs  => 0,
+                :offidx   => 0,
+                :addr     => 0,
+                :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 = [ 36 ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRENOFFS, 4)
+    s.data = [ 0 ]
+    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
+    matches = 0
+    t.each_probe do |p|
+      if p.to_s == "test1#{$$}:testmodule:main:test"
+        matches += 1
+      end
+    end
+    assert_equal 1, matches
+
+  end
+
+  def test_probe_with_char_arg
+    f = Dtrace::Dof::File.new
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_STRTAB, 0)
+    s.data = ['test', 'char *', 'char *', 'main', 'test2']
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROBES, 1)
+    s.data = [
+              {
+                :nargv    => 6,
+                :noffs    => 1,
+                :xargv    => 13,
+                :enoffidx => 0,
+                :argidx   => 0,
+                :name     => 1,
+                :nenoffs  => 0,
+                :offidx   => 0,
+                :addr     => 0,
+                :nargc    => 1,
+                :func     => 20,
+                :xargc    => 1
+              },
+             ]
+    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 = [ 36 ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRENOFFS, 4)
+    s.data = [ 0 ]
+    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   => 25,
+      :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
+    matches = 0
+    t.each_probe do |p|
+      if p.to_s == "test2#{$$}:testmodule:main:test"
+        matches += 1
+      end
+    end
+    assert_equal 1, matches
+
+  end
+
+  def test_probe_with_int_arg
+    f = Dtrace::Dof::File.new
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_STRTAB, 0)
+    s.data = ['test', 'int', 'int', 'main', 'test3']
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROBES, 1)
+    s.data = [
+              {
+                :nargv    => 6,
+                :noffs    => 1,
+                :xargv    => 10,
+                :enoffidx => 0,
+                :argidx   => 0,
+                :name     => 1,
+                :nenoffs  => 0,
+                :offidx   => 0,
+                :addr     => 0,
+                :nargc    => 1,
+                :func     => 14,
+                :xargc    => 1
+              },
+             ]
+    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 = [ 36 ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRENOFFS, 4)
+    s.data = [ 36 ]
+    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   => 19,
+      :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
+    matches = 0
+    t.each_probe do |p|
+      if p.to_s == "test3#{$$}:testmodule:main:test"
+        matches += 1
+      end
+    end
+    assert_equal 1, matches
+
+  end
+
+  def test_probe_is_enabled
+    f = Dtrace::Dof::File.new
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_STRTAB, 0)
+    s.data = ['test', 'main', 'test4']
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROBES, 1)
+    s.data = [
+              {
+                :noffs    => 1,
+                :enoffidx => 0,
+                :argidx   => 0,
+                :name     => 1,
+                :nenoffs  => 0,
+                :offidx   => 0,
+                :addr     => 0,
+                :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 = [ 36 ]
+    f.sections << s
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PRENOFFS, 4)
+    s.data = [ 44 ]
+    f.sections << s
+    
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROVIDER, 5)
+    s.data = {
+      :name => 11,
+      :strtab   => 0,
+      :probes   => 1,
+      :prargs   => 2,
+      :proffs   => 3,
+      :prenoffs => 4,
+      :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
+    matches = 0
+    t.each_probe do |p|
+      if p.to_s == "test4#{$$}:testmodule:main:test"
+        matches += 1
+      end
+    end
+    assert_equal 1, matches
+
+  end
+
+end
+

data/test/test_dof_strtabs.rb

@@ -0,0 +1,92 @@
+#
+# Ruby-Dtrace
+# (c) 2008 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace'
+require 'dtrace/dof'
+require 'test/unit'
+
+class TestDofStrtabs < Test::Unit::TestCase
+  include Dtrace::Dof::Constants
+  
+  def test_strtab_stridxs
+    sec = Dtrace::Dof::Section::Strtab.new(1)
+    assert sec
+    
+    assert_equal 1, sec.add('foo')
+    assert_equal 5, sec.add('bar')
+    assert_equal 9, sec.add('baz')
+  end
+
+  def test_strtab_dof
+    f = Dtrace::Dof::File.new
+
+    strtab = Dtrace::Dof::Section::Strtab.new(0)
+    f.sections << strtab
+
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROBES, 1)
+    s.data = [
+              {
+                :name     => strtab.add('test'),
+                :func     => strtab.add('main'),
+                :noffs    => 1,
+                :enoffidx => 0,
+                :argidx   => 0,
+                :nenoffs  => 0,
+                :offidx   => 0,
+                :addr     => 0,
+                :nargc    => 0,
+                :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 = [ 36 ]
+    f.sections << s
+    
+    s = Dtrace::Dof::Section.new(DOF_SECT_PROVIDER, 4)
+    s.data = {
+      :strtab => 0,
+      :probes => 1,
+      :prargs => 2,
+      :proffs => 3,
+      :name => strtab.add('test'),
+      :provattr => { 
+        :name  => DTRACE_STABILITY_EVOLVING,
+        :data  => DTRACE_STABILITY_EVOLVING,
+        :class => DTRACE_STABILITY_EVOLVING 
+      },
+      :modattr  => { 
+        :name => DTRACE_STABILITY_PRIVATE,
+        :data => DTRACE_STABILITY_PRIVATE,
+        :class => DTRACE_STABILITY_EVOLVING 
+      },
+      :funcattr => { 
+        :name => DTRACE_STABILITY_PRIVATE,
+        :data => DTRACE_STABILITY_PRIVATE,
+        :class => DTRACE_STABILITY_EVOLVING
+      },
+      :nameattr => { 
+        :name => DTRACE_STABILITY_EVOLVING,
+        :data => DTRACE_STABILITY_EVOLVING,
+        :class => DTRACE_STABILITY_EVOLVING
+      },
+      :argsattr => {
+        :name => DTRACE_STABILITY_EVOLVING,
+        :data => DTRACE_STABILITY_EVOLVING,
+        :class => DTRACE_STABILITY_EVOLVING
+      },
+    }
+    f.sections << s
+
+    f.generate
+    Dtrace::Dof.loaddof(f, 'testmodule')
+  end
+
+end

data/test/test_dtrace.rb

@@ -0,0 +1,111 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace'
+require 'test/unit'
+
+# Tests for the Dtrace handle class
+
+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_bad_program
+    t = Dtrace.new
+    progtext = "blah blahb albhacasfas"
+    e = assert_raise Dtrace::Exception do
+      prog = t.compile progtext
+    end
+    assert_equal "probe description :::blah does not match any probes", e.message
+  end
+  
+end

data/test/test_dtrace_aggregates.rb

@@ -0,0 +1,56 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace'
+require 'test/unit'
+
+# Tests using the DTrace profile provider.
+
+class TestDtraceAggregates < Test::Unit::TestCase
+  def test_aggregate_group
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+    t.setopt("aggsize", "4m")
+
+    progtext =<<EOD
+profile-1000
+{ 
+  @a[execname] = count();
+  @b[execname] = count();
+}
+
+profile-1
+{
+  printa(@a);
+  printa(@b);
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go
+
+    sleep 3
+
+    c = Dtrace::Consumer.new(t)
+    assert c
+
+    data = []
+    c.consume_once do |d|
+      data << d
+    end
+    
+    assert data.length > 0
+    data.each do |d|
+      assert d
+      assert_equal Dtrace::Data, d.class
+      d.data.each do |agg|
+        assert_equal Dtrace::AggregateSet, agg.class
+      end
+    end
+
+  end
+
+end

data/test/test_dtrace_drops_errors.rb

@@ -0,0 +1,183 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace'
+require 'test/unit'
+
+# Tests for the DropData record.
+
+class TestDtraceDropsErrors < Test::Unit::TestCase
+
+  def test_drops
+    t = Dtrace.new 
+    t.setopt("bufsize", "512")
+    t.setopt("strsize", "1024")
+
+    # drp.DTRACEDROP_PRINCIPAL.d
+    progtext = <<EOD
+BEGIN
+{
+	trace("Harding");
+	trace("Hoover");
+	trace("Nixon");
+	trace("Bush");
+}
+
+BEGIN
+{
+	exit(0);
+}
+EOD
+
+    prog = t.compile progtext
+    prog.execute
+
+    c = Dtrace::Consumer.new(t)
+    assert c
+
+    i = 0
+    c.drophandler do |d| 
+      assert_match(/1 drop on CPU [0-9]+/, d.msg)
+      assert_equal "drop to principal buffer", d.kind
+      assert_not_nil d.cpu
+      assert_equal 1, d.drops
+      assert_not_nil d.total
+      i = 1
+    end
+
+    t.go
+    c.consume do |d|
+    end
+
+    assert_equal 1, i
+  end
+
+  def test_error_handler_too_late
+    t = Dtrace.new 
+    t.setopt("bufsize", "512")
+    t.setopt("strsize", "1024")
+
+    progtext = <<EOD
+BEGIN
+{
+   *(char *)NULL;
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go 
+
+    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(Dtrace::Exception) do
+      c.errhandler do |d|
+        # nothing
+      end
+    end
+
+  end
+
+  def test_errors
+    t = Dtrace.new 
+    t.setopt("bufsize", "512")
+    t.setopt("strsize", "1024")
+
+    progtext = <<EOD
+BEGIN
+{
+   *(char *)NULL;
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+
+    c = Dtrace::Consumer.new(t)
+    assert c
+
+    i = 0
+    c.errhandler do |d|
+      assert_match(/error on enabled probe ID [0-9]+ \(ID [0-9]+: dtrace:::BEGIN\): invalid address \(0x0\) in action #1 at DIF offset 16/, d.msg)
+      assert_not_nil d.cpu
+      assert d.action
+      assert d.offset
+      assert d.fault
+      assert_not_nil d.addr
+      i = 1
+    end
+
+    t.go
+    c.consume_once do |d|
+    end
+
+    assert_equal 1, i
+  end
+
+  def test_error_and_drop_handler
+
+    t = Dtrace.new 
+    t.setopt("bufsize", "512")
+    t.setopt("strsize", "1024")
+
+    progtext = <<EOD
+BEGIN
+{
+	trace("Harding");
+	trace("Hoover");
+	trace("Nixon");
+	trace("Bush");
+}
+
+BEGIN
+{
+   *(char *)NULL;
+}
+
+ERROR
+{
+    exit(0);
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+
+    c = Dtrace::Consumer.new(t)
+    assert c
+
+    errors = 0
+    c.errhandler do |d|
+      assert_match(/error on enabled probe ID [0-9]+ \(ID [0-9]+: dtrace:::BEGIN\): invalid address \(0x0\) in action #1 at DIF offset 16/, d.msg)
+      assert_not_nil d.cpu
+      assert d.action
+      assert d.offset
+      assert d.fault
+      assert_not_nil d.addr
+      errors = 1
+    end
+
+    drops = 0
+    c.drophandler do |d| 
+      assert_match(/1 drop on CPU [0-9]+/, d.msg)
+      assert_equal "drop to principal buffer", d.kind
+      assert_not_nil d.cpu
+      assert_equal 1, d.drops
+      assert_not_nil d.total
+      drops = 1
+    end
+
+    t.go
+    c.consume do |d|
+    end
+
+    assert_equal 1, errors
+    assert_equal 1, drops
+  end
+
+end