ruby-dtrace 0.0.1 → 0.0.2

data/History.txt

@@ -1,3 +1,10 @@
+== 0.0.2 / 2007-12-07
+
+ * Implement the dtrace_work-based API
+ * Add a "Consumer" class
+ * Update Rails plugin to use new API
+
 == 0.0.1 / 2007-12-01
 
  * Initial public release.
+

data/Manifest.txt

@@ -2,16 +2,24 @@ History.txt
 Manifest.txt
 README.txt
 Rakefile
-ext/dtrace_aggregate.c
+ext/dtrace_aggdata.c
 ext/dtrace_api.c
 ext/dtrace_api.h
+ext/dtrace_bufdata.c
 ext/dtrace_hdl.c
 ext/dtrace_probe.c
+ext/dtrace_probedata.c
 ext/dtrace_program.c
 ext/dtrace_programinfo.c
 ext/dtrace_recdesc.c
+ext/dtrace_util.c
 ext/extconf.rb
 lib/dtrace.rb
+lib/dtraceaggregate.rb
+lib/dtraceconsumer.rb
+lib/dtraceprobe.rb
+lib/dtraceprobedata.rb
+lib/dtracerecord.rb
 plugin/dtrace/README
 plugin/dtrace/Rakefile
 plugin/dtrace/bin/dtracer.rb
@@ -26,3 +34,4 @@ plugin/dtrace/tasks/dtrace.rake
 plugin/dtrace/test/dtrace_test.rb
 plugin/dtrace/views/dtrace/_report.rhtml
 test/test_dtrace.rb
+test/test_dtrace_workapi.rb

data/Rakefile

@@ -2,7 +2,9 @@
 
 require 'rubygems'
 require 'hoe'
-require './lib/dtrace'
+
+$: << './lib'
+require 'dtrace'
 
 Hoe.new('ruby-dtrace', Dtrace::VERSION) do |p|
   p.rubyforge_name = 'ruby-dtrace'

data/ext/dtrace_aggdata.c

@@ -0,0 +1,139 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+RUBY_EXTERN VALUE eDtraceException;
+
+/* :nodoc: */
+VALUE dtraceaggdata_init(VALUE self)
+{
+  dtrace_bufdata_t *data;
+
+  Data_Get_Struct(self, dtrace_bufdata_t, data);
+  return self;
+}
+
+
+VALUE dtraceaggdata_value(VALUE self)
+{
+  dtrace_bufdata_t *bufdata;
+  const dtrace_aggdata_t *aggdata;
+  const dtrace_aggdesc_t *aggdesc;
+  const dtrace_recdesc_t *rec;
+  const char *s;
+  dtrace_actkind_t act = DTRACEACT_NONE;
+  int64_t aggid;
+  uint64_t normal;
+  caddr_t addr;
+  int64_t value;
+  VALUE v = Qnil;
+
+  Data_Get_Struct(self, dtrace_bufdata_t, bufdata);
+  aggdata = bufdata->dtbda_aggdata;
+  s = bufdata->dtbda_buffered;
+  rec = bufdata->dtbda_recdesc;
+  
+  if (aggdata == NULL) {
+    rb_raise(eDtraceException, "null aggdata");
+    return Qnil;
+  }
+
+  aggdesc = aggdata->dtada_desc;
+
+  if (aggdesc == NULL) {
+    rb_raise(eDtraceException, "null aggdesc");
+    return Qnil;
+  }
+
+  aggid = *((int64_t *)(aggdata->dtada_data +
+			aggdesc->dtagd_rec[0].dtrd_offset));
+  if (aggid < 0) {
+    rb_raise(eDtraceException, "negative aggregation ID");
+    return Qnil;
+  }
+
+  act = rec->dtrd_action;
+
+  if (bufdata->dtbda_flags & DTRACE_BUFDATA_AGGKEY) {
+  
+    switch (act) {
+    case DTRACEACT_STACK:
+    case DTRACEACT_USTACK:
+    case DTRACEACT_JSTACK:
+      /* todo */
+      break;
+    case DTRACEACT_USYM:
+    case DTRACEACT_UADDR:
+    case DTRACEACT_UMOD:
+    case DTRACEACT_SYM:
+    case DTRACEACT_MOD:
+      /* todo */
+      break;
+    default:
+      v = handle_bytedata((aggdata->dtada_data + rec->dtrd_offset), rec->dtrd_size);
+    }
+  
+    
+  } else if (bufdata->dtbda_flags & DTRACE_BUFDATA_AGGVAL) {
+    
+    normal = aggdata->dtada_normal;
+    addr = aggdata->dtada_data + rec->dtrd_offset;
+
+    if (act == DTRACEAGG_AVG) {
+      uint64_t *data = (uint64_t *)addr;
+      value = (data[0] ? (long long)(data[1] / normal / data[0]) : 0);
+    } else {
+      value = (*((int64_t *)addr)) / normal;
+    }
+
+    if (act == DTRACEAGG_QUANTIZE || act == DTRACEAGG_LQUANTIZE) {
+      v = Qnil; // dtj_new_distribution(data, rec, jc);
+    } else {
+      switch (act) {
+      case DTRACEAGG_COUNT:
+	if (value < 0)
+	  rb_raise(eDtraceException, "count value is negative");
+	v = INT2FIX(value);
+	break;
+      case DTRACEAGG_AVG:
+      case DTRACEAGG_MIN:
+      case DTRACEAGG_MAX:
+      case DTRACEAGG_SUM:
+	v = INT2FIX(value);
+	break;
+      default:
+	v = Qnil;
+	rb_raise(eDtraceException, "unexpected aggregation action: %d", act);
+      }
+    }
+
+  } else if (bufdata->dtbda_flags & DTRACE_BUFDATA_AGGVAL) {
+
+    v = Qnil;
+
+  }
+
+  return v;
+}
+
+VALUE dtraceaggdata_aggtype(VALUE self)
+{
+  dtrace_bufdata_t *bufdata;
+  VALUE v;
+
+  Data_Get_Struct(self, dtrace_bufdata_t, bufdata);
+
+  if (bufdata->dtbda_flags & DTRACE_BUFDATA_AGGKEY)
+    v = rb_str_new2("tuple");
+  else if (bufdata->dtbda_flags & DTRACE_BUFDATA_AGGVAL)
+    v = rb_str_new2("value");
+  else if (bufdata->dtbda_flags & DTRACE_BUFDATA_AGGLAST)
+    v = rb_str_new2("last");
+  else
+    v = rb_str_new2("unknown");
+
+  return v;
+}
+  

data/ext/dtrace_api.c

@@ -10,6 +10,8 @@ VALUE cDtraceProgram;
 VALUE cDtraceProgramInfo;
 VALUE cDtraceAggData;
 VALUE cDtraceRecDesc;
+VALUE cDtraceProbeData;
+VALUE cDtraceBufData;
 
 VALUE eDtraceException;
 
@@ -28,6 +30,9 @@ void Init_dtrace_api() {
   rb_define_method(cDtrace, "aggregate_clear", dtrace_hdl_aggregate_clear, 0); // in dtrace_hdl.c
   rb_define_method(cDtrace, "error",           dtrace_hdl_error,           0); // in dtrace_hdl.c
   rb_define_method(cDtrace, "setopt",          dtrace_hdl_setopt,          2); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "sleep",           dtrace_hdl_sleep,           0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "work",            dtrace_hdl_work,            2); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "buf_consumer",    dtrace_hdl_buf_consumer,    1); // in dtrace_hdl.c
   rb_define_alloc_func(cDtrace, dtrace_hdl_alloc);
 
   cDtraceProbe = rb_define_class("DtraceProbe", rb_cObject);
@@ -38,6 +43,15 @@ void Init_dtrace_api() {
   rb_define_method(cDtraceProbe, "func",       dtraceprobe_func,     0); // in dtrace_probe.c
   rb_define_method(cDtraceProbe, "name",       dtraceprobe_name,     0); // in dtrace_probe.c
 
+  cDtraceProbeData = rb_define_class("DtraceProbeData", rb_cObject);
+  rb_define_method(cDtraceProbeData, "initialize",  dtraceprobedata_init,        0); // in dtrace_probedata.c
+  rb_define_method(cDtraceProbeData, "probedesc",   dtraceprobedata_probedesc,   0); // in dtrace_probedata.c
+  rb_define_method(cDtraceProbeData, "each_record", dtraceprobedata_each_record, 0); // in dtrace_probedata.c
+
+  cDtraceBufData = rb_define_class("DtraceBufData", rb_cObject);
+  rb_define_method(cDtraceBufData, "initialize",  dtracebufdata_init,   0); // in dtrace_bufdata.c
+  rb_define_method(cDtraceBufData, "record",      dtracebufdata_record, 0); // in dtrace_bufdata.c
+
   cDtraceProgram = rb_define_class("DtraceProgram", rb_cObject);
   rb_define_method(cDtraceProgram, "initialize",         dtraceprogram_init, 0); // in dtrace_program.c
   rb_define_method(cDtraceProgram, "execute",            dtraceprogram_exec, 0); // in dtrace_program.c
@@ -51,18 +65,12 @@ void Init_dtrace_api() {
   rb_define_method(cDtraceProgramInfo, "speculations_count", dtraceprograminfo_speculations_count, 0); // in dtrace_programinfo.c
 
   cDtraceAggData = rb_define_class("DtraceAggData", rb_cObject);
-  rb_define_method(cDtraceAggData, "initialize",         dtraceaggdata_init,        0); // in dtrace_aggregate.c 
-  rb_define_method(cDtraceAggData, "desc",               dtraceaggdata_desc,        0); // in dtrace_aggregate.c 
-  rb_define_method(cDtraceAggData, "value",              dtraceaggdata_value,       0); // in dtrace_aggregate.c 
-  rb_define_method(cDtraceAggData, "size",               dtraceaggdata_size,        0); // in dtrace_aggregate.c 
-  rb_define_method(cDtraceAggData, "each_record",        dtraceaggdata_each_record, 0); // in dtrace_aggregate.c 
-  rb_define_method(cDtraceAggData, "num_records",        dtraceaggdata_num_records, 0); // in dtrace_aggregate.c
-  rb_define_method(cDtraceAggData, "[]",                 dtraceaggdata_record,      1); // in dtrace_aggregate.c
-  rb_define_method(cDtraceAggData, "probe",              dtraceaggdata_probe,       0); // in dtrace_aggregate.c
+  rb_define_method(cDtraceAggData, "initialize",         dtraceaggdata_init,    0); // in dtrace_aggdata.c 
+  rb_define_method(cDtraceAggData, "value",              dtraceaggdata_value,   0); // in dtrace_aggdata.c
+  rb_define_method(cDtraceAggData, "aggtype",            dtraceaggdata_aggtype, 0); // in dtrace_aggdata.c
 
   cDtraceRecDesc = rb_define_class("DtraceRecDesc", rb_cObject);
   rb_define_method(cDtraceRecDesc, "initialize",         dtracerecdesc_init, 0); // in dtrace_recdesc.c 
-  rb_define_method(cDtraceRecDesc, "data",               dtracerecdesc_data, 0); // in dtrace_recdesc.c   
 
   eDtraceException = rb_define_class("DtraceException", rb_eStandardError);
 }

data/ext/dtrace_api.h

@@ -8,14 +8,11 @@
 #include "/usr/include/dtrace.h"
 #include "ruby.h"
 
+VALUE handle_bytedata(caddr_t addr, uint32_t nbytes);
+
 VALUE dtraceaggdata_init(VALUE self);
-VALUE dtraceaggdata_desc(VALUE self);
 VALUE dtraceaggdata_value(VALUE self);
-VALUE dtraceaggdata_size(VALUE self);
-VALUE dtraceaggdata_each_record(VALUE self);
-VALUE dtraceaggdata_num_records(VALUE self);
-VALUE dtraceaggdata_record(VALUE self, VALUE index);
-VALUE dtraceaggdata_probe(VALUE self);
+VALUE dtraceaggdata_aggtype(VALUE self);
 
 void  dtrace_hdl_free (void *handle);
 VALUE dtrace_hdl_alloc(VALUE klass);
@@ -31,6 +28,11 @@ VALUE dtrace_hdl_aggregate_print(VALUE self);
 VALUE dtrace_hdl_aggregate_snap(VALUE self);
 VALUE dtrace_hdl_aggregate_clear(VALUE self);
 VALUE dtrace_hdl_error(VALUE self);
+VALUE dtrace_hdl_sleep(VALUE self);
+VALUE dtrace_hdl_work(VALUE self, 
+		      VALUE probe_consumer_proc, 
+		      VALUE rec_consumer_proc);
+VALUE dtrace_hdl_buf_consumer(VALUE self, VALUE buf_consumer_proc);
 
 VALUE dtraceprobe_init(VALUE self);
 VALUE dtraceprobe_probe_id(VALUE self);
@@ -39,6 +41,13 @@ VALUE dtraceprobe_mod(VALUE self);
 VALUE dtraceprobe_func(VALUE self);
 VALUE dtraceprobe_name(VALUE self);
 
+VALUE dtraceprobedata_init(VALUE self);
+VALUE dtraceprobedata_probedesc(VALUE self);
+VALUE dtraceprobedata_each_record(VALUE self);
+
+VALUE dtracebufdata_init(VALUE self);
+VALUE dtracebufdata_record(VALUE self);
+
 VALUE dtraceprogram_init(VALUE self);
 VALUE dtraceprogram_exec(VALUE self);
 VALUE dtraceprogram_info(VALUE self);
@@ -50,4 +59,3 @@ VALUE dtraceprograminfo_matches_count(VALUE self);
 VALUE dtraceprograminfo_speculations_count(VALUE self);
 
 VALUE dtracerecdesc_init(VALUE self);
-VALUE dtracerecdesc_data(VALUE self);

data/ext/dtrace_bufdata.c

@@ -0,0 +1,91 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+RUBY_EXTERN VALUE eDtraceException;
+RUBY_EXTERN VALUE cDtraceAggData;
+RUBY_EXTERN VALUE cDtraceRecDesc;
+
+/* :nodoc: */
+VALUE dtracebufdata_init(VALUE self)
+{
+  dtrace_bufdata_t *data;
+
+  Data_Get_Struct(self, dtrace_bufdata_t, data);
+  return self;
+}
+
+VALUE dtracebufdata_record(VALUE self)
+{
+  dtrace_bufdata_t *bufdata;
+  const dtrace_recdesc_t *rec;
+  dtrace_actkind_t act = DTRACEACT_NONE;
+  const char *s;
+  VALUE v = Qnil;
+  VALUE dtracerecord;
+  VALUE dtraceaggdata;
+  VALUE dtracerecdesc;
+
+  Data_Get_Struct(self, dtrace_bufdata_t, bufdata);
+  
+  if (bufdata->dtbda_aggdata) {
+    dtraceaggdata = Data_Wrap_Struct(cDtraceAggData, 0, NULL, (dtrace_bufdata_t *)bufdata);
+    return dtraceaggdata;
+  }
+
+  s = bufdata->dtbda_buffered;
+  if (s == NULL) {
+    return Qnil;
+  }
+  
+  rec = bufdata->dtbda_recdesc;
+  if (rec) {
+    act = rec->dtrd_action;
+  }
+  
+  switch (act) {
+  case DTRACEACT_DIFEXPR:
+    /* trace() action */
+    break;
+  case DTRACEACT_PRINTF:
+    /*
+     * Only the formatted string was not available to dtj_chewrec(),
+     * so we attach that now.
+     */
+    v = rb_str_new2(s);
+    break;
+  case DTRACEACT_STACK:
+  case DTRACEACT_USTACK:
+  case DTRACEACT_JSTACK:
+    /* stand-alone stack(), ustack(), or jstack() action */
+    v = rb_str_new2(s);
+    break;
+  case DTRACEACT_USYM:
+  case DTRACEACT_UADDR:
+  case DTRACEACT_UMOD:
+  case DTRACEACT_SYM:
+  case DTRACEACT_MOD:
+    v = rb_str_new2(s);
+    break;
+  case DTRACEACT_PRINTA:
+    v = rb_str_new2(s);
+    break;
+  default:
+    /*
+     * The record handle defers nothing else to this
+     * bufhandler.
+     */
+    break;
+  }
+
+  if (!NIL_P(v)) {
+    dtracerecord = rb_class_new_instance(0, NULL, rb_path2class("DtraceRecord"));
+    rb_iv_set(dtracerecord, "@value", v);
+    return (dtracerecord);
+  }
+  else {
+    return Qnil;
+  }
+}

data/ext/dtrace_hdl.c

@@ -8,6 +8,9 @@ RUBY_EXTERN VALUE eDtraceException;
 RUBY_EXTERN VALUE cDtraceProbe;
 RUBY_EXTERN VALUE cDtraceProgram;
 RUBY_EXTERN VALUE cDtraceAggData;
+RUBY_EXTERN VALUE cDtraceRecDesc;
+RUBY_EXTERN VALUE cDtraceProbeData;
+RUBY_EXTERN VALUE cDtraceBufData;
 
 void dtrace_hdl_free (void *handle)
 {
@@ -278,3 +281,101 @@ VALUE dtrace_hdl_error(VALUE self)
   return rb_str_new2(error_string);
 }
 
+/*
+ * Sleep until we need to wake up to honour D options controlling
+ * consumption rates.
+ */
+VALUE dtrace_hdl_sleep(VALUE self)
+{
+  dtrace_hdl_t *handle;
+
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  dtrace_sleep(handle);
+  return Qnil;
+}
+
+typedef struct dtrace_work_handlers {
+  VALUE probe;
+  VALUE rec;
+} dtrace_work_handlers_t;
+
+static int _probe_consumer(const dtrace_probedata_t *data, void *arg)
+{
+  VALUE proc;
+  dtrace_work_handlers_t handlers;
+  VALUE probedata;
+
+  handlers = *(dtrace_work_handlers_t *) arg;
+  proc = handlers.probe;
+
+  probedata = Data_Wrap_Struct(cDtraceProbeData, 0, NULL, (dtrace_probedata_t *)data);
+  rb_funcall(proc, rb_intern("call"), 1, probedata);
+  
+  return (DTRACE_CONSUME_THIS);
+}
+
+static int _rec_consumer(const dtrace_probedata_t *data, const dtrace_recdesc_t *rec, void *arg)
+{
+  VALUE proc;
+  dtrace_work_handlers_t handlers;
+  VALUE recdesc;
+
+  handlers = *(dtrace_work_handlers_t *) arg;
+  proc = handlers.rec;
+
+  recdesc = Data_Wrap_Struct(cDtraceRecDesc, 0, NULL, (dtrace_recdesc_t *)rec);
+  rb_funcall(proc, rb_intern("call"), 1, recdesc);
+
+  return (DTRACE_CONSUME_THIS);
+}
+
+static int _buf_consumer(const dtrace_bufdata_t *bufdata, void *arg)
+{
+  VALUE proc;
+  VALUE dtracebufdata;
+
+  proc = (VALUE)arg;
+
+  dtracebufdata = Data_Wrap_Struct(cDtraceBufData, 0, NULL, (dtrace_bufdata_t *)bufdata);
+  rb_funcall(proc, rb_intern("call"), 1, dtracebufdata);
+
+  return (DTRACE_HANDLE_OK);
+}
+
+/*
+ * Process any data waiting from the D program.
+ */
+VALUE dtrace_hdl_work(VALUE self, 
+		      VALUE probe_consumer_proc, 
+		      VALUE rec_consumer_proc)
+{
+  dtrace_hdl_t *handle;
+  dtrace_workstatus_t status;
+  dtrace_work_handlers_t handlers;
+  
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+
+  /* fill out the handlers struct */
+  handlers.probe = probe_consumer_proc;
+  handlers.rec   = rec_consumer_proc;
+
+  status = dtrace_work(handle, NULL, _probe_consumer, _rec_consumer, &handlers);
+
+  return INT2FIX(status);
+}  
+
+/*
+ * Set up the buffered output handler for this handle.
+ */
+VALUE dtrace_hdl_buf_consumer(VALUE self, VALUE buf_consumer)
+{
+  dtrace_hdl_t *handle;
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+
+  /* attach the buffered output handler */
+  if (dtrace_handle_buffered(handle, &_buf_consumer, (void *)buf_consumer) == -1) {
+    rb_raise(eDtraceException, "failed to establish buffered handler");
+  }
+
+  return Qnil;
+}