ruby-dtrace 0.0.4 → 0.0.5

data/History.txt

@@ -1,4 +1,11 @@
+== 0.0.4 / 2008-01-24
+
+ * Add DtraceErrData and DtraceDropData for access to error 
+   and drop information
+ * Fix interaction with Ruby's GC
+
 == 0.0.4 / 2008-01-14
+
  * Fix the very basic Rails plugin.
 
 == 0.0.3 / 2008-01-06

data/Manifest.txt

@@ -7,6 +7,8 @@ ext/dtrace_aggdata.c
 ext/dtrace_api.c
 ext/dtrace_api.h
 ext/dtrace_bufdata.c
+ext/dtrace_dropdata.c
+ext/dtrace_errdata.c
 ext/dtrace_hdl.c
 ext/dtrace_probe.c
 ext/dtrace_probedata.c
@@ -42,7 +44,9 @@ plugin/dtrace/test/dtrace_test.rb
 plugin/dtrace/views/dtrace/_report.rhtml
 test/test_dtrace.rb
 test/test_dtrace_aggregates.rb
+test/test_dtrace_drops_errors.rb
 test/test_dtrace_processes.rb
 test/test_dtrace_profile.rb
 test/test_dtrace_repeat.rb
 test/test_dtrace_rubyprobe.rb
+test/test_dtrace_typefilter.rb

data/ext/dtrace_api.c

@@ -13,6 +13,8 @@ VALUE cDtraceRecDesc;
 VALUE cDtraceProbeData;
 VALUE cDtraceBufData;
 VALUE cDtraceProcess;
+VALUE cDtraceDropData;
+VALUE cDtraceErrData;
 
 VALUE eDtraceException;
 
@@ -30,6 +32,8 @@ void Init_dtrace_api() {
   rb_define_method(cDtrace, "sleep",           dtrace_hdl_sleep,           0); // in dtrace_hdl.c
   rb_define_method(cDtrace, "work",            dtrace_hdl_work,           -1); // in dtrace_hdl.c
   rb_define_method(cDtrace, "buf_consumer",    dtrace_hdl_buf_consumer,    1); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "drop_consumer",   dtrace_hdl_drop_consumer,   1); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "err_consumer",    dtrace_hdl_err_consumer,    1); // in dtrace_hdl.c
   rb_define_method(cDtrace, "createprocess",   dtrace_hdl_createprocess,   1); // in dtrace_hdl.c
   rb_define_method(cDtrace, "grabprocess",     dtrace_hdl_grabprocess,     1); // in dtrace_hdl.c
   rb_define_alloc_func(cDtrace, dtrace_hdl_alloc);
@@ -83,6 +87,23 @@ void Init_dtrace_api() {
   rb_define_method(cDtraceRecDesc, "initialize",         dtracerecdesc_init,   0); // in dtrace_recdesc.c 
   rb_define_method(cDtraceRecDesc, "action",             dtracerecdesc_action, 0); // in dtrace_recdesc.c 
 
+  cDtraceDropData = rb_define_class("DtraceDropData", rb_cObject);
+  rb_define_method(cDtraceDropData, "initialize",  dtracedropdata_init,   0); // in dtrace_dropdata.c 
+  rb_define_method(cDtraceDropData, "cpu",         dtracedropdata_cpu,    0); // in dtrace_dropdata.c 
+  rb_define_method(cDtraceDropData, "drops",       dtracedropdata_drops,  0); // in dtrace_dropdata.c 
+  rb_define_method(cDtraceDropData, "total",       dtracedropdata_total,  0); // in dtrace_dropdata.c 
+  rb_define_method(cDtraceDropData, "msg",         dtracedropdata_msg,    0); // in dtrace_dropdata.c 
+  rb_define_method(cDtraceDropData, "kind",        dtracedropdata_kind,   0); // in dtrace_dropdata.c 
+
+  cDtraceErrData = rb_define_class("DtraceErrData", rb_cObject);
+  rb_define_method(cDtraceErrData, "initialize",  dtraceerrdata_init,    0); // in dtrace_errdata.c 
+  rb_define_method(cDtraceErrData, "cpu",         dtraceerrdata_cpu,     0); // in dtrace_errdata.c 
+  rb_define_method(cDtraceErrData, "action",      dtraceerrdata_action,  0); // in dtrace_errdata.c 
+  rb_define_method(cDtraceErrData, "offset",      dtraceerrdata_offset,  0); // in dtrace_errdata.c 
+  rb_define_method(cDtraceErrData, "fault",       dtraceerrdata_fault,   0); // in dtrace_errdata.c 
+  rb_define_method(cDtraceErrData, "addr",        dtraceerrdata_addr,    0); // in dtrace_errdata.c 
+  rb_define_method(cDtraceErrData, "msg",         dtraceerrdata_msg,     0); // in dtrace_errdata.c 
+
   eDtraceException = rb_define_class("DtraceException", rb_eStandardError);
 }
 

data/ext/dtrace_api.h

@@ -26,6 +26,18 @@ typedef struct dtrace_process {
   struct ps_prochandle *proc;
 } dtrace_process_t;
 
+/* Used to wrap up the DTrace handle, so we can keep references to the
+   various callbacks: we must mark them from the dtrace_hdl_mark
+   routine, which only gets a pointer to this structure. */
+typedef struct dtrace_handle {
+  dtrace_hdl_t *hdl;
+  VALUE probe;
+  VALUE rec;
+  VALUE buf;
+  VALUE err;
+  VALUE drop;
+} dtrace_handle_t;
+
 /* Handle missing RARRAY_LEN etc */
 #ifdef RARRAY_LEN
 static inline long   rb_str_len(VALUE s) {return RSTRING_LEN(s);}
@@ -49,7 +61,6 @@ VALUE dtraceaggdata_init(VALUE self);
 VALUE dtraceaggdata_value(VALUE self);
 VALUE dtraceaggdata_aggtype(VALUE self);
 
-void  dtrace_hdl_free (void *handle);
 VALUE dtrace_init(VALUE self);
 VALUE dtrace_hdl_alloc(VALUE klass);
 VALUE dtrace_each_probe(VALUE self);
@@ -62,6 +73,8 @@ VALUE dtrace_hdl_error(VALUE self);
 VALUE dtrace_hdl_sleep(VALUE self);
 VALUE dtrace_hdl_work(int argc, VALUE *argv, VALUE self);
 VALUE dtrace_hdl_buf_consumer(VALUE self, VALUE buf_consumer_proc);
+VALUE dtrace_hdl_drop_consumer(VALUE self, VALUE drop_consumer_proc);
+VALUE dtrace_hdl_err_consumer(VALUE self, VALUE err_consumer_proc);
 VALUE dtrace_hdl_createprocess(VALUE self, VALUE argv);
 VALUE dtrace_hdl_grabprocess(VALUE self, VALUE pid);
 
@@ -98,3 +111,18 @@ VALUE dtraceprograminfo_speculations_count(VALUE self);
 
 VALUE dtracerecdesc_init(VALUE self);
 VALUE dtracerecdesc_action(VALUE self);
+
+VALUE dtracedropdata_init(VALUE self);
+VALUE dtracedropdata_cpu(VALUE self);
+VALUE dtracedropdata_drops(VALUE self);
+VALUE dtracedropdata_total(VALUE self);
+VALUE dtracedropdata_msg(VALUE self);
+VALUE dtracedropdata_kind(VALUE self);
+
+VALUE dtraceerrdata_init(VALUE self);
+VALUE dtraceerrdata_cpu(VALUE self);
+VALUE dtraceerrdata_action(VALUE self);
+VALUE dtraceerrdata_offset(VALUE self);
+VALUE dtraceerrdata_fault(VALUE self);
+VALUE dtraceerrdata_addr(VALUE self);
+VALUE dtraceerrdata_msg(VALUE self);

data/ext/dtrace_dropdata.c

@@ -0,0 +1,131 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+RUBY_EXTERN VALUE eDtraceException;
+
+/* :nodoc: */
+VALUE dtracedropdata_init(VALUE self)
+{
+  dtrace_dropdata_t *data;
+
+  Data_Get_Struct(self, dtrace_dropdata_t, data);
+  return self;
+}
+
+/* Returns the CPU which generated this drop record */
+VALUE dtracedropdata_cpu(VALUE self)
+{
+  dtrace_dropdata_t *data;
+  processorid_t cpu;
+
+  Data_Get_Struct(self, dtrace_dropdata_t, data);
+  
+  if (data) {
+    cpu = data->dtdda_cpu;
+    return INT2FIX(cpu);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+/* Returns the number of records dropped in this drop record */
+VALUE dtracedropdata_drops(VALUE self)
+{
+  dtrace_dropdata_t *data;
+
+  Data_Get_Struct(self, dtrace_dropdata_t, data);
+  
+  if (data) {
+    return INT2FIX(data->dtdda_drops);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+/* Returns the number of records dropped in total */
+VALUE dtracedropdata_total(VALUE self)
+{
+  dtrace_dropdata_t *data;
+
+  Data_Get_Struct(self, dtrace_dropdata_t, data);
+  
+  if (data) {
+    return INT2FIX(data->dtdda_total);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+/* Returns a message from the DTrace library describing this drop
+   record. */
+VALUE dtracedropdata_msg(VALUE self)
+{
+  dtrace_dropdata_t *data;
+  
+  Data_Get_Struct(self, dtrace_dropdata_t, data);
+  
+  if (data) {
+    return rb_str_new2(data->dtdda_msg);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+/* Returns the reason for the drop (the "drop kind") */
+VALUE dtracedropdata_kind(VALUE self)
+{
+  dtrace_dropdata_t *data;
+  VALUE kind;
+
+  Data_Get_Struct(self, dtrace_dropdata_t, data);
+  
+  if (data) {
+    switch (data->dtdda_kind) {
+    case DTRACEDROP_PRINCIPAL:
+      kind = rb_str_new2("drop to principal buffer");
+      break;
+    case DTRACEDROP_AGGREGATION:
+      kind = rb_str_new2("drop to aggregation buffer");
+      break;
+    case DTRACEDROP_DYNAMIC:			
+      kind = rb_str_new2("dynamic drop");
+      break;
+    case DTRACEDROP_DYNRINSE:			
+      kind = rb_str_new2("dyn drop due to rinsing");
+      break;
+    case DTRACEDROP_DYNDIRTY:
+      kind = rb_str_new2("dyn drop due to dirty");
+      break;
+    case DTRACEDROP_SPEC:
+      kind = rb_str_new2("speculative drop");
+      break;
+    case DTRACEDROP_SPECBUSY:
+      kind = rb_str_new2("spec drop due to busy");
+      break;
+    case DTRACEDROP_SPECUNAVAIL:
+      kind = rb_str_new2("spec drop due to unavail");
+      break;
+    case DTRACEDROP_STKSTROVERFLOW:
+      kind = rb_str_new2("stack string tab overflow");
+      break;
+    case DTRACEDROP_DBLERROR:
+      kind = rb_str_new2("error in ERROR probe");
+      break;
+    default:
+      kind = rb_str_new2("unknown");
+      break;
+    }
+    return kind;
+  }
+  else {
+    return Qnil;
+  }
+}
+  

data/ext/dtrace_errdata.c

@@ -0,0 +1,110 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+RUBY_EXTERN VALUE eDtraceException;
+
+/* :nodoc: */
+VALUE dtraceerrdata_init(VALUE self)
+{
+  dtrace_errdata_t *data;
+
+  Data_Get_Struct(self, dtrace_errdata_t, data);
+  return self;
+}
+
+/* Returns the CPU which generated this err record */
+VALUE dtraceerrdata_cpu(VALUE self)
+{
+  dtrace_errdata_t *data;
+  processorid_t cpu;
+
+  Data_Get_Struct(self, dtrace_errdata_t, data);
+  
+  if (data) {
+    cpu = data->dteda_cpu;
+    return INT2FIX(cpu);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+/* Returns a the action producing the error */
+VALUE dtraceerrdata_action(VALUE self)
+{
+  dtrace_errdata_t *data;
+  
+  Data_Get_Struct(self, dtrace_errdata_t, data);
+  
+  if (data) {
+    return INT2FIX(data->dteda_action);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+/* Returns the offset of the error */
+VALUE dtraceerrdata_offset(VALUE self)
+{
+  dtrace_errdata_t *data;
+  
+  Data_Get_Struct(self, dtrace_errdata_t, data);
+  
+  if (data) {
+    return INT2FIX(data->dteda_offset);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+/* Returns fault represented by the error */
+VALUE dtraceerrdata_fault(VALUE self)
+{
+  dtrace_errdata_t *data;
+  
+  Data_Get_Struct(self, dtrace_errdata_t, data);
+  
+  if (data) {
+    return INT2FIX(data->dteda_fault);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+/* Returns the address of the fault if any */
+VALUE dtraceerrdata_addr(VALUE self)
+{
+  dtrace_errdata_t *data;
+  
+  Data_Get_Struct(self, dtrace_errdata_t, data);
+  
+  if (data) {
+    return INT2FIX(data->dteda_addr);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+/* Returns a message from the DTrace library describing this err
+   record. */
+VALUE dtraceerrdata_msg(VALUE self)
+{
+  dtrace_errdata_t *data;
+  
+  Data_Get_Struct(self, dtrace_errdata_t, data);
+  
+  if (data) {
+    return rb_str_new2(data->dteda_msg);
+  }
+  else {
+    return Qnil;
+  }
+}
+

data/ext/dtrace_hdl.c

@@ -13,34 +13,67 @@ RUBY_EXTERN VALUE cDtraceRecDesc;
 RUBY_EXTERN VALUE cDtraceProbeData;
 RUBY_EXTERN VALUE cDtraceBufData;
 RUBY_EXTERN VALUE cDtraceProcess;
+RUBY_EXTERN VALUE cDtraceDropData;
+RUBY_EXTERN VALUE cDtraceErrData;
 
-void dtrace_hdl_free (void *handle)
+static void dtrace_hdl_free(void *arg)
 {
-  if (handle)
-    dtrace_close(handle);
+  dtrace_handle_t *handle = (dtrace_handle_t *)arg;
+  
+  if (handle) {
+    dtrace_close(handle->hdl);
+    free(handle);
+  }
+}
+
+static void dtrace_hdl_mark(void *arg)
+{
+  dtrace_handle_t *handle = (dtrace_handle_t *)arg;
+
+  if (handle) {
+    rb_gc_mark(handle->probe);
+    rb_gc_mark(handle->rec);
+    rb_gc_mark(handle->buf);
+    rb_gc_mark(handle->err);
+    rb_gc_mark(handle->drop);
+  }
 }
 
 VALUE dtrace_hdl_alloc(VALUE klass)
 {
-  dtrace_hdl_t *handle;
+  dtrace_hdl_t *hdl;
+  dtrace_handle_t *handle;
   int err;
   VALUE obj;
   
-  handle = dtrace_open(DTRACE_VERSION, 0, &err);
+  hdl = dtrace_open(DTRACE_VERSION, 0, &err);
   
-  if (handle) {
+  if (hdl) {
     /*
      * Leopard's DTrace requires symbol resolution to be 
      * switched on explicitly 
      */ 
 #ifdef __APPLE__
-    (void) dtrace_setopt(handle, "stacksymbols", "enabled");
+    (void) dtrace_setopt(hdl, "stacksymbols", "enabled");
 #endif
 
     /* always request flowindent information */
-    (void) dtrace_setopt(handle, "flowindent", 0);
+    (void) dtrace_setopt(hdl, "flowindent", 0);
+
+    handle = ALLOC(dtrace_handle_t);
+    if (!handle) {
+      rb_raise(eDtraceException, "alloc failed");
+      return Qnil;
+    }
 
-    obj = Data_Wrap_Struct(klass, 0, dtrace_hdl_free, handle);
+    handle->hdl   = hdl;
+    handle->probe = Qnil;
+    handle->rec   = Qnil;
+    handle->buf   = Qnil;
+    handle->err   = Qnil;
+    handle->drop  = Qnil;
+
+    obj = Data_Wrap_Struct(klass, dtrace_hdl_mark, dtrace_hdl_free, handle);
     return obj;
   }
   else {
@@ -51,16 +84,16 @@ VALUE dtrace_hdl_alloc(VALUE klass)
 /* :nodoc: */
 VALUE dtrace_init(VALUE self)
 {
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
 
-  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  Data_Get_Struct(self, dtrace_handle_t, handle);
   if (handle)
     return self;
   else
     return Qnil;
 }
 
-int _dtrace_next_probe(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp, void *arg)
+int _dtrace_next_probe(dtrace_hdl_t *hdl, const dtrace_probedesc_t *pdp, void *arg)
 {
   VALUE probe;
 
@@ -78,10 +111,10 @@ int _dtrace_next_probe(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp, void *a
  */
 VALUE dtrace_each_probe(VALUE self)
 {
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
 
-  Data_Get_Struct(self, dtrace_hdl_t, handle);
-  (void) dtrace_probe_iter(handle, NULL, _dtrace_next_probe, NULL);
+  Data_Get_Struct(self, dtrace_handle_t, handle);
+  (void) dtrace_probe_iter(handle->hdl, NULL, _dtrace_next_probe, NULL);
 
   return self;
 }
@@ -97,7 +130,7 @@ VALUE dtrace_each_probe(VALUE self)
  */
 VALUE dtrace_strcompile(int argc, VALUE *argv, VALUE self)
 {
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
   dtrace_prog_t *program;
   VALUE dtrace_program;
 
@@ -112,6 +145,11 @@ VALUE dtrace_strcompile(int argc, VALUE *argv, VALUE self)
 
   dtrace_argc = rb_ary_len(dtrace_argv_array);
   dtrace_argv = ALLOC_N(char *, dtrace_argc + 1);
+  if (!dtrace_argv) {
+    rb_raise(eDtraceException, "alloc failed");
+    return Qnil;
+  }
+  
   for (i = 0; i < dtrace_argc; i++) {
     dtrace_argv[i + 1] = STR2CSTR(rb_ary_entry(dtrace_argv_array, i));
   }
@@ -119,18 +157,18 @@ VALUE dtrace_strcompile(int argc, VALUE *argv, VALUE self)
   dtrace_argv[0] = "ruby";
   dtrace_argc++;
 
-  Data_Get_Struct(self, dtrace_hdl_t, handle);
-  program = dtrace_program_strcompile(handle, STR2CSTR(dtrace_text),
+  Data_Get_Struct(self, dtrace_handle_t, handle);
+  program = dtrace_program_strcompile(handle->hdl, STR2CSTR(dtrace_text),
 				      DTRACE_PROBESPEC_NAME, DTRACE_C_PSPEC, 
 				      dtrace_argc, dtrace_argv);
 
   if (!program) {
-    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+    rb_raise(eDtraceException, dtrace_errmsg(handle->hdl, dtrace_errno(handle->hdl)));
     return Qnil;
   }
   else {
     dtrace_program = Data_Wrap_Struct(cDtraceProgram, 0, NULL, program);
-    rb_iv_set(dtrace_program, "@dtrace", self);
+    rb_iv_set(dtrace_program, "@handle", self);
     return dtrace_program;
   }
 }
@@ -143,11 +181,11 @@ VALUE dtrace_strcompile(int argc, VALUE *argv, VALUE self)
  */
 VALUE dtrace_hdl_go(VALUE self)
 {
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
 
-  Data_Get_Struct(self, dtrace_hdl_t, handle);
-  if (dtrace_go(handle) < 0) 
-    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+  Data_Get_Struct(self, dtrace_handle_t, handle);
+  if (dtrace_go(handle->hdl) < 0) 
+    rb_raise(eDtraceException, dtrace_errmsg(handle->hdl, dtrace_errno(handle->hdl)));
     
   return Qnil;
 }
@@ -163,12 +201,12 @@ VALUE dtrace_hdl_go(VALUE self)
  */
 VALUE dtrace_hdl_status(VALUE self)
 {
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
   int status;
 
-  Data_Get_Struct(self, dtrace_hdl_t, handle);
-  if ((status = dtrace_status(handle)) < 0) 
-    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+  Data_Get_Struct(self, dtrace_handle_t, handle);
+  if ((status = dtrace_status(handle->hdl)) < 0) 
+    rb_raise(eDtraceException, dtrace_errmsg(handle->hdl, dtrace_errno(handle->hdl)));
     
   return INT2FIX(status);
 }
@@ -183,20 +221,20 @@ VALUE dtrace_hdl_status(VALUE self)
  */
 VALUE dtrace_hdl_setopt(VALUE self, VALUE key, VALUE value)
 {
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
   int ret;
 
-  Data_Get_Struct(self, dtrace_hdl_t, handle);
-  
+  Data_Get_Struct(self, dtrace_handle_t, handle);
+
   if (NIL_P(value)) {
-    ret = dtrace_setopt(handle, STR2CSTR(key), 0);
+    ret = dtrace_setopt(handle->hdl, STR2CSTR(key), 0);
   }
   else {
-    ret = dtrace_setopt(handle, STR2CSTR(key), STR2CSTR(value));
+    ret = dtrace_setopt(handle->hdl, STR2CSTR(key), STR2CSTR(value));
   }
 
   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;
 }
@@ -207,11 +245,11 @@ VALUE dtrace_hdl_setopt(VALUE self, VALUE key, VALUE value)
  */
 VALUE dtrace_hdl_stop(VALUE self)
 {
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
 
-  Data_Get_Struct(self, dtrace_hdl_t, handle);
-  if (dtrace_stop(handle) < 0) 
-    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+  Data_Get_Struct(self, dtrace_handle_t, handle);
+  if (dtrace_stop(handle->hdl) < 0) 
+    rb_raise(eDtraceException, dtrace_errmsg(handle->hdl, dtrace_errno(handle->hdl)));
     
   return Qnil;
 }
@@ -221,11 +259,11 @@ VALUE dtrace_hdl_stop(VALUE self)
  */
 VALUE dtrace_hdl_error(VALUE self)
 {
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
   const char *error_string;
 
-  Data_Get_Struct(self, dtrace_hdl_t, handle);
-  error_string = dtrace_errmsg(handle, dtrace_errno(handle));
+  Data_Get_Struct(self, dtrace_handle_t, handle);
+  error_string = dtrace_errmsg(handle->hdl, dtrace_errno(handle->hdl));
   return rb_str_new2(error_string);
 }
 
@@ -235,10 +273,10 @@ VALUE dtrace_hdl_error(VALUE self)
  */
 VALUE dtrace_hdl_sleep(VALUE self)
 {
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
 
-  Data_Get_Struct(self, dtrace_hdl_t, handle);
-  dtrace_sleep(handle);
+  Data_Get_Struct(self, dtrace_handle_t, handle);
+  dtrace_sleep(handle->hdl);
   return Qnil;
 }
 
@@ -317,26 +355,31 @@ static int _buf_consumer(const dtrace_bufdata_t *bufdata, void *arg)
  */
 VALUE dtrace_hdl_work(int argc, VALUE *argv, VALUE self)
 {
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
   dtrace_workstatus_t status;
   dtrace_work_handlers_t handlers;
-  VALUE probe_consumer_proc;
-  VALUE rec_consumer_proc;
+  VALUE probe_consumer;
+  VALUE rec_consumer;
   
-  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  Data_Get_Struct(self, dtrace_handle_t, handle);
 
   /* handle args - probe_consumer_proc is mandatory, rec_consumer_proc
      is optional */
-  rb_scan_args(argc, argv, "11", &probe_consumer_proc, &rec_consumer_proc);
+  rb_scan_args(argc, argv, "11", &probe_consumer, &rec_consumer);
+
+  /* to mark during GC */
+  handle->probe = probe_consumer;
+  if (!NIL_P(rec_consumer))
+    handle->rec = rec_consumer;
 
   /* fill out the handlers struct */
-  handlers.probe  = probe_consumer_proc;
-  handlers.rec    = rec_consumer_proc;
+  handlers.probe  = probe_consumer;
+  handlers.rec    = rec_consumer;
   handlers.handle = self;
 
-  status = dtrace_work(handle, NULL, _probe_consumer, _rec_consumer, &handlers);
+  status = dtrace_work(handle->hdl, NULL, _probe_consumer, _rec_consumer, &handlers);
   if (status < 0)
-    rb_raise(eDtraceException, (dtrace_errmsg(handle, dtrace_errno(handle))));
+    rb_raise(eDtraceException, (dtrace_errmsg(handle->hdl, dtrace_errno(handle->hdl))));
 
   return INT2FIX(status);
 }  
@@ -346,12 +389,100 @@ VALUE dtrace_hdl_work(int argc, VALUE *argv, VALUE self)
  */
 VALUE dtrace_hdl_buf_consumer(VALUE self, VALUE buf_consumer)
 {
-  dtrace_hdl_t *handle;
-  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  dtrace_handle_t *handle;
+  Data_Get_Struct(self, dtrace_handle_t, handle);
+
+  /* to mark during GC */
+  handle->buf = buf_consumer;
 
   /* attach the buffered output handler */
-  if (dtrace_handle_buffered(handle, &_buf_consumer, (void *)buf_consumer) == -1) {
-    rb_raise(eDtraceException, "failed to establish buffered handler");
+  if (dtrace_handle_buffered(handle->hdl, &_buf_consumer, (void *)buf_consumer) == -1) {
+    rb_raise(eDtraceException, "failed to establish buffered handler: %s", 
+	     (dtrace_errmsg(handle->hdl, dtrace_errno(handle->hdl))));
+  }
+
+  return Qnil;
+}
+
+static int _drop_consumer(const dtrace_dropdata_t *dropdata, void *arg)
+{
+  VALUE proc;
+  VALUE dtracedropdata;
+
+  proc = (VALUE)arg;
+
+  if (!NIL_P(proc)) {
+    dtracedropdata = Data_Wrap_Struct(cDtraceDropData, 0, NULL, (dtrace_dropdata_t *)dropdata);
+    rb_funcall(proc, rb_intern("call"), 1, dtracedropdata);
+  }
+
+  return (DTRACE_HANDLE_OK);
+}
+
+/*
+ * Set up the drop-record handler for this handle. Takes a block,
+ * which will be called with any drop records returned by DTrace,
+ * represented by DtraceDropData objects.
+ */
+VALUE dtrace_hdl_drop_consumer(VALUE self, VALUE drop_consumer)
+{
+  dtrace_handle_t *handle;
+  Data_Get_Struct(self, dtrace_handle_t, handle);
+
+  /* to mark during GC */
+  handle->drop = drop_consumer;
+
+  /* attach the drop-record handler */
+  if (dtrace_handle_drop(handle->hdl, &_drop_consumer, (void *)drop_consumer) == -1) {
+    rb_raise(eDtraceException, "failed to establish drop-record handler");
+  }
+
+  return Qnil;
+}
+
+static int _err_consumer(const dtrace_errdata_t *errdata, void *arg)
+{
+  VALUE proc;
+  VALUE dtraceerrdata;
+
+  proc = (VALUE)arg;
+
+  /* guard against bad invocations where arg is not what we provided... */
+  if (TYPE(proc) == T_DATA) {
+    dtraceerrdata = Data_Wrap_Struct(cDtraceErrData, 0, NULL, (dtrace_errdata_t *)errdata);
+    rb_funcall(proc, rb_intern("call"), 1, dtraceerrdata);
+  }
+  else {
+    /* arg looked bad, throw an exception */
+    rb_raise(eDtraceException, "bad argument to _err_consumer: %p -> 0x%x type 0x%x\n", arg, proc, TYPE(proc));
+  }
+
+  return (DTRACE_HANDLE_OK);
+}
+
+/*
+ * Set up the err-record handler for this handle. Takes a block, which
+ * will be called with any error records returned by DTrace,
+ * represented by DTraceErrData records. 
+ */
+VALUE dtrace_hdl_err_consumer(VALUE self, VALUE err_consumer)
+{
+  dtrace_handle_t *handle;
+  void *arg;
+  Data_Get_Struct(self, dtrace_handle_t, handle);
+
+  if (dtrace_status(handle->hdl) != 0) {
+    rb_raise(eDtraceException, "too late to add error handler");
+    return Qnil;
+  }
+  
+  /* to mark during GC */
+  handle->err = err_consumer;
+
+  /* attach the err-record handler */
+  if (dtrace_handle_err(handle->hdl, &_err_consumer, (void *)err_consumer) == -1) {
+    rb_raise(eDtraceException, "failed to establish err-record handler: %s",
+	     dtrace_errmsg(handle->hdl, dtrace_errno(handle->hdl)));
   }
 
   return Qnil;
@@ -369,7 +500,7 @@ VALUE dtrace_hdl_buf_consumer(VALUE self, VALUE buf_consumer)
  */
 VALUE dtrace_hdl_createprocess(VALUE self, VALUE rb_argv)
 {
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
   struct ps_prochandle *P;
   char **argv;
   long len;
@@ -377,25 +508,34 @@ VALUE dtrace_hdl_createprocess(VALUE self, VALUE rb_argv)
   VALUE dtraceprocess;
   dtrace_process_t *process;
 
-  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  Data_Get_Struct(self, dtrace_handle_t, handle);
 
   len = rb_ary_len(rb_argv);
   argv = ALLOC_N(char *, len + 1);
+  if (!argv) {
+    rb_raise(eDtraceException, "alloc failed");
+    return Qnil;
+  }
 
   for (i = 0; i < len; i++) {
     argv[i] = STR2CSTR(rb_ary_entry(rb_argv, i));
   }
   argv[len] = NULL;
 
-  P = dtrace_proc_create(handle, argv[0], argv);
+  P = dtrace_proc_create(handle->hdl, argv[0], argv);
   free(argv);
   
   if (P == NULL) {
-    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+    rb_raise(eDtraceException, dtrace_errmsg(handle->hdl, dtrace_errno(handle->hdl)));
   }
   
   process = ALLOC(dtrace_process_t);
-  process->handle = handle;
+  if (!process) {
+    rb_raise(eDtraceException, "alloc failed");
+    return Qnil;
+  }
+
+  process->handle = handle->hdl;
   process->proc   = P;
 
   dtraceprocess = Data_Wrap_Struct(cDtraceProcess, 0, dtrace_process_release, (dtrace_process_t *)process);
@@ -410,21 +550,26 @@ VALUE dtrace_hdl_createprocess(VALUE self, VALUE rb_argv)
  */
 VALUE dtrace_hdl_grabprocess(VALUE self, VALUE pid)
 {
-  dtrace_hdl_t *handle;
+  dtrace_handle_t *handle;
   struct ps_prochandle *P;
   dtrace_process_t *process;
   VALUE dtraceprocess;
 
-  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  Data_Get_Struct(self, dtrace_handle_t, handle);
 
-  P = dtrace_proc_grab(handle, FIX2INT(pid), 0);
+  P = dtrace_proc_grab(handle->hdl, FIX2INT(pid), 0);
   
   if (P == NULL) {
-    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+    rb_raise(eDtraceException, dtrace_errmsg(handle->hdl, dtrace_errno(handle->hdl)));
   }
   
   process = ALLOC(dtrace_process_t);
-  process->handle = handle;
+  if (!process) {
+    rb_raise(eDtraceException, "alloc failed");
+    return Qnil;
+  }
+
+  process->handle = handle->hdl;
   process->proc   = P;
 
   dtraceprocess = Data_Wrap_Struct(cDtraceProcess, 0, dtrace_process_release, (dtrace_process_t *)process);