ruby-dtrace 0.0.1 → 0.0.2

data/ext/dtrace_probedata.c

@@ -0,0 +1,129 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+RUBY_EXTERN VALUE eDtraceException;
+RUBY_EXTERN VALUE cDtraceProbe;
+
+/* :nodoc: */
+VALUE dtraceprobedata_init(VALUE self)
+{
+  dtrace_probedata_t *data;
+
+  Data_Get_Struct(self, dtrace_probedata_t, data);
+  return self;
+}
+
+VALUE dtraceprobedata_probedesc(VALUE self)
+{
+  dtrace_probedata_t *data;
+  dtrace_probedesc_t *pdp;
+  VALUE probe;
+
+  Data_Get_Struct(self, dtrace_probedata_t, data);
+
+  pdp = data->dtpda_pdesc;
+  probe = Data_Wrap_Struct(cDtraceProbe, 0, NULL, (dtrace_probedesc_t *)pdp);
+
+  return probe;
+}
+
+static VALUE _handle_stack_record(const caddr_t addr, const dtrace_recdesc_t *rec)
+{
+  dtrace_actkind_t act;
+  uint64_t *pc;
+  pid_t pid = -1;
+  int size; /* size of raw bytes not including trailing zeros */
+  int i; /* index of last non-zero byte */
+  VALUE raw;
+
+  for (i = rec->dtrd_size - 1; (i >= 0) && !addr[i]; --i) {
+  }
+  size = (i + 1);
+
+  raw = rb_ary_new();
+  for (i = 0; i < size; i++)
+    rb_ary_push(raw, INT2FIX(addr[i]));
+
+  act = rec->dtrd_action;
+  switch (act) {
+  case DTRACEACT_STACK:
+    break;
+  case DTRACEACT_USTACK:
+  case DTRACEACT_JSTACK:
+    /* Get pid of user process */
+    pc = (uint64_t *)(uintptr_t)addr;
+    pid = (pid_t)*pc;
+    break;
+  default:
+    rb_raise(eDtraceException, "Expected stack action, got %d\n", act);
+  }
+
+  return raw;
+}
+
+static int
+_is_stack_action(dtrace_actkind_t act)
+{
+  int stack_action;
+  switch (act) {
+  case DTRACEACT_STACK:
+  case DTRACEACT_USTACK:
+  case DTRACEACT_JSTACK:
+    stack_action = 1;
+    break;
+  default:
+    stack_action = 0;
+  }
+  return (stack_action);
+}
+
+VALUE dtraceprobedata_each_record(VALUE self)
+{
+  dtrace_probedata_t *data;
+  dtrace_eprobedesc_t *eprobe;
+  dtrace_recdesc_t *rec;
+  int i;
+  VALUE dtracerecord;
+  VALUE v;
+  caddr_t addr;
+
+  Data_Get_Struct(self, dtrace_probedata_t, data);
+  eprobe = data->dtpda_edesc;
+  
+  for (i = 0; i < eprobe->dtepd_nrecs; i++) {
+    rec = &eprobe->dtepd_rec[i];
+    if (rec->dtrd_size > 0) {
+      addr = data->dtpda_data + rec->dtrd_offset;
+	
+      if (_is_stack_action(rec->dtrd_action)) {
+	v = _handle_stack_record(addr, rec);
+      }
+      else {
+	switch (rec->dtrd_size) {
+	case 1:
+	  v = INT2FIX((int)(*((uint8_t *)addr)));
+	  break;
+	case 2:
+	  v = INT2FIX((int)(*((uint16_t *)addr)));
+	  break;
+	case 4:
+	  v = INT2FIX(*((int32_t *)addr));
+	  break;
+	case 8:
+	  v = INT2FIX(*((int64_t *)addr));
+	  break;
+	default:
+	  v = handle_bytedata(addr, rec->dtrd_size);
+	  break;
+	}
+      }
+	
+      dtracerecord = rb_class_new_instance(0, NULL, rb_path2class("DtraceRecord"));
+      rb_iv_set(dtracerecord, "@value", v);
+      rb_yield(dtracerecord);
+    }
+  }
+}

data/ext/dtrace_recdesc.c

@@ -13,26 +13,3 @@ VALUE dtracerecdesc_init(VALUE self)
   return self;
 }
 
-/*
- * Return the data for this record.
- */
-VALUE dtracerecdesc_data(VALUE self)
-{
-  VALUE dtraceaggdata;
-  dtrace_recdesc_t *recdesc;
-  dtrace_aggdata_t *aggdata;
-
-  Data_Get_Struct(self, dtrace_recdesc_t, recdesc);
-
-  dtraceaggdata = rb_iv_get(self, "@aggdata");
-  Data_Get_Struct(dtraceaggdata, dtrace_aggdata_t, aggdata);
-  
-  if (recdesc->dtrd_size == 256) {
-    char *c = aggdata->dtada_data + recdesc->dtrd_offset;
-    return rb_str_new2(c);
-  }
-  else {
-    uint64_t n = *((uint64_t *)(aggdata->dtada_data + recdesc->dtrd_offset));
-    return INT2FIX(n);
-  }
-}

data/ext/dtrace_util.c

@@ -0,0 +1,91 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+RUBY_EXTERN VALUE eDtraceException;
+
+/*
+ * Most of this function lifted from libdtrace/common/dt_consume.c
+ * dt_print_bytes().
+ */
+VALUE handle_bytedata(caddr_t addr, uint32_t nbytes)
+{
+  /*
+   * If the byte stream is a series of printable characters, followed by
+   * a terminating byte, we print it out as a string.  Otherwise, we
+   * assume that it's something else and just print the bytes.
+   */
+  int i, j;
+  char *c = addr;
+
+  VALUE robj;
+
+  if (nbytes == 0) {
+    return rb_str_new2("");
+  }
+
+  for (i = 0; i < nbytes; i++) {
+    /*
+     * We define a "printable character" to be one for which
+     * isprint(3C) returns non-zero, isspace(3C) returns non-zero,
+     * or a character which is either backspace or the bell.
+     * Backspace and the bell are regrettably special because
+     * they fail the first two tests -- and yet they are entirely
+     * printable.  These are the only two control characters that
+     * have meaning for the terminal and for which isprint(3C) and
+     * isspace(3C) return 0.
+     */
+    if (isprint(c[i]) || isspace(c[i]) ||
+	c[i] == '\b' || c[i] == '\a')
+      continue;
+
+    if (c[i] == '\0' && i > 0) {
+      /*
+       * This looks like it might be a string.  Before we
+       * assume that it is indeed a string, check the
+       * remainder of the byte range; if it contains
+       * additional non-nul characters, we'll assume that
+       * it's a binary stream that just happens to look like
+       * a string.
+       */
+      for (j = i + 1; j < nbytes; j++) {
+	if (c[j] != '\0')
+	  break;
+      }
+
+      if (j != nbytes)
+	break;
+
+      /* It's a string */
+      return (rb_str_new2((char *)addr));
+    }
+
+    break;
+  }
+
+  if (i == nbytes) {
+    /*
+     * The byte range is all printable characters, but there is
+     * no trailing nul byte.  We'll assume that it's a string.
+     */
+    char *s = malloc(nbytes + 1);
+    if (!s) {
+      rb_raise(eDtraceException, "out of memory: failed to allocate string value");
+      return (Qnil);
+    }
+    (void) strncpy(s, c, nbytes);
+    s[nbytes] = '\0';
+    robj = rb_str_new2(s);
+    free(s);
+    return (robj);
+  }
+
+  /* return byte array */
+  robj = rb_ary_new();
+  for (i = 0; i < nbytes; i++)
+    rb_ary_push(robj, INT2FIX(addr[i]));
+
+  return (robj);
+}  

data/ext/extconf.rb

@@ -1,4 +1,4 @@
 require 'mkmf'
-$CFLAGS += " -D_LONGLONG_TYPE"
+$CFLAGS += " -D_LONGLONG_TYPE -g"
 have_library("dtrace", "dtrace_open")
 create_makefile("dtrace_api")

data/lib/dtrace.rb

@@ -4,8 +4,13 @@
 #
 
 require 'dtrace_api'
+require 'dtracerecord'
+require 'dtraceconsumer'
+require 'dtraceaggregate'
+require 'dtraceprobedata'
+require 'dtraceprobe'
 
 class Dtrace
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end
 

data/lib/dtraceaggregate.rb

@@ -0,0 +1,13 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+class DtraceAggregate
+  attr_accessor :value, :tuple
+
+  def initialize
+    @tuple = Array.new
+  end
+
+end

data/lib/dtraceconsumer.rb

@@ -0,0 +1,99 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+class DtraceConsumer
+
+  def initialize(t)
+    @t = t
+    @curragg = DtraceAggregate.new
+  end
+
+  def consume
+
+    probe_consumer = proc do |probe|
+      yield probe
+    end
+    
+    rec_consumer = proc do |rec|
+      #yield rec
+    end
+    
+    buf_consumer = proc do |buf|
+      r = buf.record
+      # buf records can be empty (trace();)
+      if r 
+        case r.class.to_s
+        when DtraceRecord.to_s
+          yield r
+        when DtraceAggData.to_s
+          case r.aggtype
+          when "tuple"
+            @curragg.tuple << r.value
+          when "value"
+            @curragg.value = r.value
+          when "last"
+            yield @curragg
+            @curragg = DtraceAggregate.new
+          end
+
+        end
+      end
+    end    
+  
+    @t.go
+    @t.buf_consumer(buf_consumer)
+    begin
+      while(true) do
+        @t.sleep
+        @t.work(probe_consumer, rec_consumer)
+      end
+    ensure
+      @t.stop
+      @t.work(probe_consumer, rec_consumer)
+    end
+    
+  end
+  
+  def consume_once
+    
+    probe_consumer = proc do |probe|
+      probe.each_record do |r|
+        yield r
+      end
+    end
+    
+    rec_consumer = proc do |rec|
+      #yield rec
+    end
+    
+    buf_consumer = proc do |buf|
+      r = buf.record
+      # buf records can be empty (trace();)
+      if r 
+        case r.class.to_s
+        when DtraceRecord.to_s
+          yield r
+        when DtraceAggData.to_s
+          case r.aggtype
+          when "tuple"
+            @curragg.tuple << r.value
+          when "value"
+            @curragg.value = r.value
+          when "last"
+            yield @curragg
+            @curragg = DtraceAggregate.new
+          end
+
+        end
+      end
+    end
+  
+    @t.buf_consumer(buf_consumer)
+    @t.stop
+    @t.work(probe_consumer, rec_consumer)
+  end
+  
+end
+

data/lib/dtraceprobe.rb

@@ -0,0 +1,13 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+class DtraceProbe
+  
+  def to_s
+    "#{provider}:#{mod}:#{func}:#{name}"
+  end
+  
+end
+    

data/lib/dtraceprobedata.rb

@@ -0,0 +1,16 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+class DtraceProbeData
+
+  def records
+    records = Array.new
+    self.each_record do |rec|
+      records << rec
+    end
+    records
+  end
+
+end

data/lib/dtracerecord.rb

@@ -0,0 +1,8 @@
+#
+# Ruby-Dtrace
+# (c) 2007 Chris Andrews <chris@nodnol.org>
+#
+
+class DtraceRecord
+  attr_accessor :value
+end

data/plugin/dtrace/lib/dtracer.rb

@@ -3,7 +3,7 @@ require 'dtrace'
 class Dtracer
   
   def start_dtrace(pid)
-    progtext = 'ruby$1:::function-entry{ @[strjoin(strjoin(copyinstr(arg0),"."),copyinstr(arg1))] = count(); }'
+    progtext = 'ruby$1:::function-entry{ @a[strjoin(strjoin(copyinstr(arg0),"."),copyinstr(arg1))] = count(); } END { printa(@a); }'
 
     begin
       @d = Dtrace.new
@@ -28,11 +28,12 @@ class Dtracer
     return {} unless @d
 
     begin
-      @d.stop
-      @d.aggregate_snap
       dtrace_report = Hash.new
-      @d.each_aggregate do |agg|
-        dtrace_report[agg[1].data] = agg[2].data
+      c = DtraceConsumer.new(@d)
+      c.consume_once do |e|
+        if e.respond_to? :tuple
+          dtrace_report[e.tuple.first] = e.value
+        end
       end
     rescue DtraceException => e
       puts "end: #{e.message}"