ruby-dtrace 0.0.4 → 0.0.5

data/ext/dtrace_probedata.c

@@ -202,17 +202,17 @@ VALUE dtraceprobedata_each_record(VALUE self)
   dtrace_probedata_t *data;
   dtrace_eprobedesc_t *eprobe;
   dtrace_recdesc_t *rec;
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
   dtrace_actkind_t act;
   int i;
   caddr_t addr;
   VALUE dtracerecord;
-  VALUE dtracehandle;
+  VALUE dtrace;
   VALUE v;
 
   Data_Get_Struct(self, dtrace_probedata_t, data);
-  dtracehandle = rb_iv_get(self, "@handle");
-  Data_Get_Struct(dtracehandle, dtrace_hdl_t, handle);
+  dtrace = rb_iv_get(self, "@handle");
+  Data_Get_Struct(dtrace, dtrace_handle_t, handle);
 
   eprobe = data->dtpda_edesc;
   
@@ -228,8 +228,8 @@ VALUE dtraceprobedata_each_record(VALUE self)
       case DTRACEACT_USTACK:
       case DTRACEACT_JSTACK:
 	/* Stack records come from bufdata */
-	/* v = _handle_stack_record(handle, addr, rec); */
-	/* v = _handle_ustack_record(handle, addr, rec); */
+	/* v = _handle_stack_record(handle->hdl, addr, rec); */
+	/* v = _handle_ustack_record(handle->hdl, addr, rec); */
 	break;
       case DTRACEACT_PRINTA:
 	/* don't want the probedata record for a printa() action */

data/ext/dtrace_program.c

@@ -24,17 +24,22 @@ VALUE dtraceprogram_exec(VALUE self)
 {
   dtrace_prog_t *prog;
   dtrace_proginfo_t *proginfo;
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
   VALUE dtrace;
   VALUE dtraceprograminfo;
   int ret;
 
   Data_Get_Struct(self, dtrace_prog_t, prog);
-  dtrace = rb_iv_get(self, "@dtrace");
-  Data_Get_Struct(dtrace, dtrace_hdl_t, handle);
+  dtrace = rb_iv_get(self, "@handle");
+  Data_Get_Struct(dtrace, dtrace_handle_t, handle);
   
   proginfo = ALLOC(dtrace_proginfo_t);
-  ret = dtrace_program_exec(handle, prog, proginfo);
+  if (!proginfo) {
+    rb_raise(eDtraceException, "alloc failed");
+    return Qnil;
+  }
+
+  ret = dtrace_program_exec(handle->hdl, prog, proginfo);
 
   if (ret == 0) {
     dtraceprograminfo = Data_Wrap_Struct(cDtraceProgramInfo, 0, NULL, proginfo);
@@ -42,7 +47,7 @@ VALUE dtraceprogram_exec(VALUE self)
   }
 
   if (ret < 0)
-    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+    rb_raise(eDtraceException, dtrace_errmsg(handle->hdl, dtrace_errno(handle->hdl)));
   
   return Qnil;
 }

data/lib/dtrace.rb

@@ -63,7 +63,7 @@ require 'dtracedata'
 #   end
 
 class Dtrace
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 
   STATUS_NONE    = 0
   STATUS_OKAY    = 1

data/lib/dtraceconsumer.rb

@@ -41,8 +41,11 @@ class DtraceConsumer
 
   def initialize(t)
     @t = t
-    @curr = DtraceData.new
     @done = false
+    @types = []
+
+    @drophandler = nil
+    @errhandler = nil
   end
 
   private
@@ -69,7 +72,7 @@ class DtraceConsumer
       else
         @curr.finish
         block.call(@curr)
-        @curr = DtraceData.new
+        @curr = DtraceData.new(@types)
       end
     end
   end
@@ -85,9 +88,36 @@ class DtraceConsumer
       @curr.add_bufdata(buf)
     end
   end
+
+  def filter_types(types)
+    @types = types
+    @curr = DtraceData.new(types)
+  end
   
   public
 
+  # Provide a proc which will be executed when a drop record is
+  # received.
+  def drophandler(&block)
+    @drophandler = block
+    @t.drop_consumer(proc do |drop|
+                       if @drophandler
+                         @drophandler.call(drop)
+                       end
+                     end)
+  end
+
+  # Provide a proc which will be executed when an error record is
+  # received.
+  def errhandler(&block)
+    @errhandler = block
+    @t.err_consumer(proc do |err|
+                      if @errhandler
+                        @errhandler.call(err)
+                      end
+                    end)
+  end
+
   # Signals that the client wishes to stop consuming trace data. 
   def finish
     @t.stop
@@ -96,7 +126,17 @@ class DtraceConsumer
   
   # Waits for data from the D program, and yields the records returned
   # to the block given. Returns when the D program exits.
-  def consume(&block)
+  #
+  # Pass a list of classes to restrict the types of data returned,
+  # from:
+  #
+  # * DtraceRecord
+  # * DtracePrintfRecord
+  # * DtraceAggregateSet
+  # * DtraceStackRecord
+  #
+  def consume(*types, &block)
+    filter_types(types)
     @t.buf_consumer(buf_consumer)
     begin
       while(true) do
@@ -113,7 +153,17 @@ class DtraceConsumer
   end
   
   # Yields the data waiting from the current program, then returns.
-  def consume_once(&block)
+  #
+  # Pass a list of classes to restrict the types of data returned,
+  # from:
+  #
+  # * DtraceRecord
+  # * DtracePrintfRecord
+  # * DtraceAggregateSet
+  # * DtraceStackRecord
+  #
+  def consume_once(*types, &block)
+    filter_types(types)
     @t.buf_consumer(buf_consumer)
     @t.stop
     @t.work(probe_consumer, rec_consumer(block))

data/lib/dtracedata.rb

@@ -9,22 +9,29 @@ class DtraceData
   attr_reader :probe
   attr_reader :cpu, :indent, :prefix, :flow
 
-  def initialize
+  def initialize(types)
+    @types = types
     @data = []
     @curraggset = nil
     @curragg    = nil
   end
 
+  def add_data(d)
+    if @types.length == 0 || @types.include?(d.class)
+      @data << d
+    end
+  end
+
   def finish
     if @curraggset
-      @data << @curraggset
+      add_data(@curraggset)
       @curraggset = nil
     end
   end
 
   def add_recdata(rec)
     if @curraggset
-      @data << @curraggset
+      add_data(@curraggset)
       @curraggset = nil
     end
     if rec.action == "printa"
@@ -34,7 +41,7 @@ class DtraceData
 
   def add_probedata(probedata)
     probedata.each_record do |p|
-      @data << p
+      add_data(p)
     end
 
     # Record the probe that fired, and CPU/indent/prefix/flow
@@ -51,11 +58,11 @@ class DtraceData
     if r
       case r.class.to_s
       when DtraceStackRecord.to_s
-        @data << r
+        add_data(r)
       when DtraceRecord.to_s
-        @data << r
+        add_data(r)
       when DtracePrintfRecord.to_s
-        @data << r
+        add_data(r)
       when DtraceAggData.to_s
         if @curragg == nil
           @curragg = DtraceAggregate.new

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 = DtraceConsumer.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 = DtraceConsumer.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
+      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 = DtraceConsumer.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 = DtraceConsumer.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

data/test/test_dtrace_typefilter.rb

@@ -0,0 +1,108 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+require 'dtrace'
+require 'test/unit'
+
+# Tests for the feature allowing you to filter DtraceData types
+
+class TestDtraceTypefilter < Test::Unit::TestCase
+  def test_filter
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+    t.setopt("aggsize", "4m")
+
+    progtext =<<EOD
+profile-1000
+{ 
+  @a[execname] = count();
+  @b[execname] = count();
+}
+
+profile-10
+{
+  trace("foo");
+  printa(@a);
+  printf("bar");
+  printa(@b);
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go
+
+    sleep 1
+
+    c = DtraceConsumer.new(t)
+    assert c
+
+    data = []
+    c.consume_once(DtraceAggregateSet) do |d|
+      data << d
+    end
+    
+    assert data.length > 0
+    data.each do |d|
+      assert d
+      assert_equal DtraceData, d.class
+      d.data.each do |agg|
+        assert_equal DtraceAggregateSet, agg.class
+      end
+    end
+
+  end
+
+  def test_filter_two_classes
+    t = Dtrace.new 
+    t.setopt("bufsize", "4m")
+    t.setopt("aggsize", "4m")
+
+    progtext =<<EOD
+profile-1000
+{ 
+  @a[execname] = count();
+  @b[execname] = count();
+}
+
+profile-10
+{
+  trace("foo");
+  printa(@a);
+  printf("bar");
+  printa(@b);
+}
+EOD
+    
+    prog = t.compile progtext
+    prog.execute
+    t.go
+
+    sleep 1
+
+    c = DtraceConsumer.new(t)
+    assert c
+
+    data = []
+    c.consume_once(DtraceAggregateSet, DtracePrintfRecord) do |d|
+      data << d
+    end
+    
+    assert data.length > 0
+    data.each do |d|
+      assert d
+      assert_equal DtraceData, d.class
+      d.data.each do |r|
+        if r.respond_to?(:add_aggregate)
+          assert_equal DtraceAggregateSet, r.class
+        else
+          assert_equal DtracePrintfRecord, r.class
+        end
+      end
+    end
+
+  end
+
+end