ruby-dtrace-consumer 0.4.0

data/test/test_dtrace.rb

@@ -0,0 +1,155 @@
+require 'test_helper'
+
+# Tests for the DTrace handle class
+
+class TestDTrace < DTraceTest
+
+  def test_dtrace
+    assert_equal Object, DTrace.superclass
+    assert_equal DTrace, @dtp.class
+  end
+
+  def test_list_probes
+    probe_count = 0
+    @dtp.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_list_probes_match
+    probe_count = 0
+    @dtp.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
+    probe_count = 0
+    @dtp.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
+    progtext = "syscall:::return
+   			{
+                          @calls[execname] = count();
+			  @fcalls[probefunc] = count();
+			}
+
+                syscall:::entry
+                /pid == $1/
+                {
+                   @calls[execname] = count();
+                   @fcalls[probefunc] = count();
+                }"
+    prog = @dtp.compile(progtext, $$.to_s)
+    prog.execute
+
+    probe_count = 0
+    @dtp.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
+    probe_count = 0
+    assert_raises DTrace::Exception do
+      @dtp.each_probe('syscall') do |probe|
+        nil
+      end
+    end
+  end
+
+  def test_compile
+    progtext = "syscall:::entry
+   			{
+                          @calls[execname] = count();
+			  @fcalls[probefunc] = count();
+			}"
+
+    prog = @dtp.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
+    progtext = "syscall:::entry
+                /pid == $1/
+                {
+                   @calls[execname] = count();
+                   @fcalls[probefunc] = count();
+                }"
+
+    prog = @dtp.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
+    progtext = "syscall:::entry
+   			{
+                          @calls[execname] = count();
+			  @fcalls[probefunc] = count();
+			}"
+
+    prog = @dtp.compile progtext
+    assert prog
+    prog.execute
+    assert_equal 0, @dtp.status # none
+
+    @dtp.go
+
+    assert_equal 1, @dtp.status # ok
+    sleep 1
+    assert_equal 1, @dtp.status # ok
+    @dtp.stop
+    assert_equal 4, @dtp.status # stopped
+  end
+
+  def test_bad_program
+    progtext = "blah blahb albhacasfas"
+    e = assert_raise DTrace::Exception do
+      prog = @dtp.compile progtext
+    end
+    assert_equal "probe description :::blah does not match any probes", e.message
+  end
+
+end

data/test/test_gc.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class TestGc < DTraceTest
+
+  def test_gc_after_close
+    @dtp.close
+    @dtp = nil
+    GC.start
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,20 @@
+require 'dtrace'
+require 'test/unit'
+
+class DTraceTest < Test::Unit::TestCase
+
+  def setup
+    @dtp = DTrace.new
+    @dtp.setopt("bufsize", "4m")
+    @dtp.setopt("aggsize", "4m")
+  end
+
+  def teardown
+    @dtp.close unless @dtp.nil?
+  end
+
+  def test_nothing
+    assert(1)
+  end
+
+end

data/test/test_helper.rb~

@@ -0,0 +1,16 @@
+require 'dtrace'
+require 'test/unit'
+
+class DTraceTest < Test::Unit::TestCase
+
+  def setup
+    @dtp = DTrace.new
+    @dtp.setopt("bufsize", "4m")
+    @dtp.setopt("aggsize", "4m")
+  end
+
+  def teardown
+    @dtp.close unless @dtp.nil?
+  end
+
+end

data/test/test_legacy_consumer.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+# Tests using the DTrace profile provider.
+
+class TestLegacyConsumer < DTraceTest
+
+  def test_aggregate_group
+    progtext =<<EOD
+profile-1000
+{
+  @a[execname] = count();
+  @b[execname] = count();
+}
+
+profile-1
+{
+  printa(@a);
+  printa(@b);
+}
+EOD
+
+    prog = @dtp.compile progtext
+    prog.execute
+    @dtp.go
+
+    sleep 3
+
+    c = DTraceConsumer.new(@dtp)
+    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_probedata.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+# Tests for trace()d data.
+
+class TestProbedata < DTraceTest
+
+  def test_longlongs
+    code = <<D
+profile-100
+{
+  trace(walltimestamp);
+}
+D
+    @dtp.compile(code).execute
+    @dtp.go
+
+    c = DTrace::Consumer.new(@dtp)
+    assert c
+
+    i = 0
+    c.consume do |d|
+      wallts = d.data[0].value
+      assert wallts > 2**32
+      i = i + 1
+      if i > 10
+        c.finish
+      end
+    end
+  end
+end

data/test/test_processes.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+# Tests for creating and grabbing processes.
+
+class TestDTraceProcesses < DTraceTest
+
+  def test_createprocess
+    progtext = <<EOD
+pid$target:*::entry,
+pid$target:*::return
+{
+  trace(pid);
+}
+EOD
+
+    p = @dtp.createprocess([ '/usr/bin/true' ])
+    prog = @dtp.compile(progtext)
+    prog.execute
+    @dtp.go
+    p.continue
+
+    i = 0
+    c = DTrace::Consumer.new(@dtp)
+    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
+    pid = Kernel.fork { exec '/bin/sleep', '2' }
+
+    progtext = <<EOD
+pid$target:::entry,
+pid$target:::return
+{
+  trace(execname);
+}
+EOD
+
+    p = @dtp.grabprocess(pid)
+    prog = @dtp.compile(progtext)
+    prog.execute
+
+    @dtp.go
+    p.continue
+
+    records = 0
+    c = DTrace::Consumer.new(@dtp)
+    c.consume do |d|
+      assert d
+      assert_equal "pid#{pid}", d.probe.provider
+      records = records + 1
+      c.finish
+    end
+    assert records > 0
+
+    Process.waitpid(pid, 0)
+  end
+end

data/test/test_profile.rb

@@ -0,0 +1,198 @@
+require 'test_helper'
+
+# Tests using the DTrace profile provider.
+
+class TestProfile < DTraceTest
+
+  def test_dprogram_run
+    progtext = 'profile:::profile-1 { trace("foo"); }'
+
+    prog = @dtp.compile progtext
+    prog.execute
+    @dtp.go
+    sleep 2
+
+    c = DTrace::Consumer.new(@dtp)
+    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
+    progtext = <<EOD
+profile-1000
+{
+  @a[execname] = count();
+}
+
+profile-10
+{
+  printa(@a)
+}
+EOD
+
+    prog = @dtp.compile progtext
+    prog.execute
+    @dtp.go
+    sleep 2
+
+    c = DTrace::Consumer.new(@dtp)
+
+    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
+    progtext = <<EOD
+profile-1
+{
+  printf("execname: %s %s", execname, "foo")
+}
+EOD
+
+    prog = @dtp.compile progtext
+    prog.execute
+    @dtp.go
+    sleep 2
+
+    c = DTrace::Consumer.new(@dtp)
+
+    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
+    progtext = <<EOD
+profile-1000hz
+{
+  @a[execname] = count();
+}
+
+END
+{
+  printa(@a)
+}
+EOD
+
+    prog = @dtp.compile progtext
+    prog.execute
+    @dtp.go
+    sleep 2
+
+    i = 0
+    c = DTrace::Consumer.new(@dtp)
+    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
+    progtext = "profile-1 { trace(execname); stack(); }"
+    prog = @dtp.compile progtext
+    prog.execute
+    @dtp.go
+    sleep 2
+
+    c = DTrace::Consumer.new(@dtp)
+    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
+    progtext = "profile-1 { trace(execname); ustack(); }"
+    prog = @dtp.compile progtext
+    prog.execute
+    @dtp.go
+    sleep 2
+
+    c = DTrace::Consumer.new(@dtp)
+    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