ruby-dtrace 0.0.1

data/History.txt

@@ -0,0 +1,3 @@
+== 0.0.1 / 2007-12-01
+
+ * Initial public release.

data/Manifest.txt

@@ -0,0 +1,28 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+ext/dtrace_aggregate.c
+ext/dtrace_api.c
+ext/dtrace_api.h
+ext/dtrace_hdl.c
+ext/dtrace_probe.c
+ext/dtrace_program.c
+ext/dtrace_programinfo.c
+ext/dtrace_recdesc.c
+ext/extconf.rb
+lib/dtrace.rb
+plugin/dtrace/README
+plugin/dtrace/Rakefile
+plugin/dtrace/bin/dtracer.rb
+plugin/dtrace/init.rb
+plugin/dtrace/lib/dtrace_helper.rb
+plugin/dtrace/lib/dtrace_report.rb
+plugin/dtrace/lib/dtrace_tracer.rb
+plugin/dtrace/lib/dtracer.rb
+plugin/dtrace/lib/dtracer_client.rb
+plugin/dtrace/public/stylesheets/dtrace.css
+plugin/dtrace/tasks/dtrace.rake
+plugin/dtrace/test/dtrace_test.rb
+plugin/dtrace/views/dtrace/_report.rhtml
+test/test_dtrace.rb

data/README.txt

@@ -0,0 +1,60 @@
+ruby-dtrace is Ruby bindings for Dtrace, which lets you write D-based
+programs in Ruby. It doesn't provide D probes for Ruby, but you can
+use it with the probes found in the Joyent and Apple builds of Ruby.
+
+== FEATURES
+  
+* Access to the D API
+* Probe metadata
+* Run D programs
+* Access aggregates
+
+== SYNOPSIS
+
+    t = Dtrace.new
+    dprog = "ruby*:::function-entry{ @[copyinstr(arg1)] = count(); }"
+    prog = t.compile dprog
+    prog.execute
+    t.go
+
+    [...]
+
+    t.stop
+    t.aggregate_snap
+    t.each_aggregate do |agg|
+      (0..(agg.num_records - 1)).each do |i|
+        rec = agg[i]
+      end
+    end        
+
+== REQUIREMENTS
+
+* A platform with Dtrace support (OpenSolaris, Mac OS X 10.5 Leopard tested, possibly also FreeBSD).
+* root, or some/all of the dtrace privileges on Solaris: dtrace_user, dtrace_proc and dtrace_kernel.
+
+== INSTALL
+
+ $ sudo gem install ruby-dtrace
+
+== LICENSE
+
+Copyright (c) 2007 Chris Andrews <chris@nodnol.org>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,30 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/dtrace'
+
+Hoe.new('ruby-dtrace', Dtrace::VERSION) do |p|
+  p.rubyforge_name = 'ruby-dtrace'
+  p.author = 'Chris Andrews'
+  p.email = 'chris@nodnol.org'
+  p.summary = 'Ruby bindings for libdtrace'
+  p.description = <<EOD
+ruby-dtrace is Ruby bindings for Dtrace, which lets you write D-based
+programs in Ruby. It doesn't provide D probes for Ruby, but you can
+use it with the probes found in the Joyent and Apple builds of Ruby.
+EOD
+  p.spec_extras = {:extensions => ['ext/extconf.rb']}
+  p.url = "http://ruby-dtrace.rubyforge.org/"
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+desc "Uses extconf.rb and make to build the extension"
+task :extensions do
+  Dir.chdir('ext')
+  system("ruby extconf.rb")
+  system("make")
+  Dir.chdir('..')
+end
+
+# vim: syntax=Ruby

data/ext/dtrace_aggregate.c

@@ -0,0 +1,150 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+RUBY_EXTERN VALUE cDtraceProbe;
+RUBY_EXTERN VALUE cDtraceRecDesc;
+
+/* :nodoc: */
+VALUE dtraceaggdata_init(VALUE self)
+{
+  dtrace_aggdata_t *aggdata;
+
+  Data_Get_Struct(self, dtrace_aggdata_t, aggdata);
+  return self;
+}
+
+/*
+ * Returns the description of this aggregate.
+ */
+VALUE dtraceaggdata_desc(VALUE self)
+{
+  VALUE string;
+  dtrace_aggdata_t *aggdata;
+  dtrace_aggdesc_t *aggdesc;
+  dtrace_recdesc_t *nrec, *irec;  
+  char *name, c[256];
+
+  Data_Get_Struct(self, dtrace_aggdata_t, aggdata);
+
+  aggdesc = aggdata->dtada_desc;
+  nrec = &aggdesc->dtagd_rec[1];
+  irec = &aggdesc->dtagd_rec[2];
+
+  name = aggdata->dtada_data + nrec->dtrd_offset;
+  string = rb_str_new2(name);
+  return string;
+}
+
+/*
+ * Returns the value of this aggregate.
+ */
+VALUE dtraceaggdata_value(VALUE self)
+{
+  dtrace_aggdata_t *aggdata;
+  dtrace_aggdesc_t *aggdesc;
+  dtrace_recdesc_t *nrec, *irec;  
+
+  Data_Get_Struct(self, dtrace_aggdata_t, aggdata);
+
+  aggdesc = aggdata->dtada_desc;
+  nrec = &aggdesc->dtagd_rec[1];
+  irec = &aggdesc->dtagd_rec[2];
+
+  uint64_t n = *((uint64_t *)(aggdata->dtada_data + irec->dtrd_offset));
+
+  return INT2FIX(n);
+}
+
+/*
+ * Returns the size of this aggregate.
+ */
+VALUE dtraceaggdata_size(VALUE self)
+{
+  dtrace_aggdata_t *aggdata;
+
+  Data_Get_Struct(self, dtrace_aggdata_t, aggdata);
+
+  return INT2FIX(aggdata->dtada_size);
+}
+
+/*
+ * Yields each record for this aggregate.
+ */
+VALUE dtraceaggdata_each_record(VALUE self)
+{
+  VALUE dtracerecdesc;
+  dtrace_aggdata_t *aggdata;
+  dtrace_aggdesc_t *aggdesc;
+  dtrace_recdesc_t *rec;
+  int i;
+  caddr_t data;
+
+  Data_Get_Struct(self, dtrace_aggdata_t, aggdata);
+  aggdesc = aggdata->dtada_desc;
+
+  for (i = 0; i < aggdesc->dtagd_nrecs; i++) {
+    rec = &aggdesc->dtagd_rec[i]; 
+    dtracerecdesc = Data_Wrap_Struct(cDtraceRecDesc, 0, NULL, rec);
+    rb_iv_set(dtracerecdesc, "@aggdata", self);
+    rb_yield(dtracerecdesc);
+  }
+
+  return Qnil;
+} 
+
+/*
+ * Return the number of records in this aggregate.
+ */
+VALUE dtraceaggdata_num_records(VALUE self)
+{
+  VALUE dtracerecdesc;
+  dtrace_aggdata_t *aggdata;
+  dtrace_aggdesc_t *aggdesc;
+
+  Data_Get_Struct(self, dtrace_aggdata_t, aggdata);
+  aggdesc = aggdata->dtada_desc;
+
+  return INT2FIX(aggdesc->dtagd_nrecs);
+} 
+
+/* 
+ * Access the array of records in this aggregate.
+ */
+VALUE dtraceaggdata_record(VALUE self, VALUE index)
+{
+  VALUE dtracerecdesc;
+  dtrace_aggdata_t *aggdata;
+  dtrace_aggdesc_t *aggdesc;
+  dtrace_recdesc_t *rec;
+  int i;
+
+  Data_Get_Struct(self, dtrace_aggdata_t, aggdata);
+  aggdesc = aggdata->dtada_desc;
+
+  i = FIX2INT(index);
+  if (i >= aggdesc->dtagd_nrecs) 
+    return Qnil;
+  else {
+    rec = &aggdesc->dtagd_rec[i]; 
+    dtracerecdesc = Data_Wrap_Struct(cDtraceRecDesc, 0, NULL, rec);
+    rb_iv_set(dtracerecdesc, "@aggdata", self);
+    return dtracerecdesc;
+  }
+} 
+
+/*
+ * Return the probe associated with this aggregate.
+ */
+VALUE dtraceaggdata_probe(VALUE self)
+{
+  VALUE probe;
+  dtrace_aggdata_t *aggdata;
+
+  Data_Get_Struct(self, dtrace_aggdata_t, aggdata);
+  probe = Data_Wrap_Struct(cDtraceProbe, 0, NULL, (dtrace_probedesc_t *)aggdata->dtada_pdesc);
+  
+  return probe;
+}

data/ext/dtrace_api.c

@@ -0,0 +1,69 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+VALUE cDtrace;
+VALUE cDtraceProbe;
+VALUE cDtraceProgram;
+VALUE cDtraceProgramInfo;
+VALUE cDtraceAggData;
+VALUE cDtraceRecDesc;
+
+VALUE eDtraceException;
+
+void Init_dtrace_api() {
+
+  cDtrace = rb_define_class("Dtrace",          rb_cObject);
+  rb_define_method(cDtrace, "initialize",      dtrace_init,                0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "each_probe",      dtrace_each_probe,          0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "compile",         dtrace_strcompile,         -1); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "stop",            dtrace_hdl_stop,            0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "status",          dtrace_hdl_status,          0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "go",              dtrace_hdl_go,              0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "each_aggregate",  dtrace_hdl_each_aggregate,  0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "aggregate_print", dtrace_hdl_aggregate_print, 0); // in dtrace_hdl.c
+  rb_define_method(cDtrace, "aggregate_snap",  dtrace_hdl_aggregate_snap,  0); // in dtrace_hdl.c
+  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_alloc_func(cDtrace, dtrace_hdl_alloc);
+
+  cDtraceProbe = rb_define_class("DtraceProbe", rb_cObject);
+  rb_define_method(cDtraceProbe, "initialize", dtraceprobe_init,     0); // in dtrace_probe.c
+  rb_define_method(cDtraceProbe, "probe_id",   dtraceprobe_probe_id, 0); // in dtrace_probe.c
+  rb_define_method(cDtraceProbe, "provider",   dtraceprobe_provider, 0); // in dtrace_probe.c
+  rb_define_method(cDtraceProbe, "mod",        dtraceprobe_mod,      0); // in dtrace_probe.c
+  rb_define_method(cDtraceProbe, "func",       dtraceprobe_func,     0); // in dtrace_probe.c
+  rb_define_method(cDtraceProbe, "name",       dtraceprobe_name,     0); // in dtrace_probe.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
+  rb_define_method(cDtraceProgram, "info",               dtraceprogram_info, 0); // in dtrace_program.c
+
+  cDtraceProgramInfo = rb_define_class("DtraceProgramInfo", rb_cObject);
+  rb_define_method(cDtraceProgramInfo, "initialize",         dtraceprograminfo_init,               0); // in dtrace_programinfo.c 
+  rb_define_method(cDtraceProgramInfo, "aggregates_count",   dtraceprograminfo_aggregates_count,   0); // in dtrace_programinfo.c
+  rb_define_method(cDtraceProgramInfo, "recgens_count",      dtraceprograminfo_recgens_count,      0); // in dtrace_programinfo.c
+  rb_define_method(cDtraceProgramInfo, "matches_count",      dtraceprograminfo_matches_count,      0); // in dtrace_programinfo.c
+  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
+
+  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

@@ -0,0 +1,53 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+/* this is a full path because the ruby-dtrace probes add a "dtrace.h"
+ * in the same directory as ruby.h, and we must avoid loading that...
+ */
+#include "/usr/include/dtrace.h"
+#include "ruby.h"
+
+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);
+
+void  dtrace_hdl_free (void *handle);
+VALUE dtrace_hdl_alloc(VALUE klass);
+VALUE dtrace_init(VALUE self);
+VALUE dtrace_each_probe(VALUE self);
+VALUE dtrace_strcompile(int argc, VALUE *argv, VALUE self);
+VALUE dtrace_hdl_go(VALUE self);
+VALUE dtrace_hdl_status(VALUE self);
+VALUE dtrace_hdl_setopt(VALUE self, VALUE key, VALUE value);
+VALUE dtrace_hdl_stop(VALUE self);
+VALUE dtrace_hdl_each_aggregate(VALUE self);
+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 dtraceprobe_init(VALUE self);
+VALUE dtraceprobe_probe_id(VALUE self);
+VALUE dtraceprobe_provider(VALUE self);
+VALUE dtraceprobe_mod(VALUE self);
+VALUE dtraceprobe_func(VALUE self);
+VALUE dtraceprobe_name(VALUE self);
+
+VALUE dtraceprogram_init(VALUE self);
+VALUE dtraceprogram_exec(VALUE self);
+VALUE dtraceprogram_info(VALUE self);
+
+VALUE dtraceprograminfo_init(VALUE self);
+VALUE dtraceprograminfo_aggregates_count(VALUE self);
+VALUE dtraceprograminfo_recgens_count(VALUE self);
+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_hdl.c

@@ -0,0 +1,280 @@
+/* Ruby-Dtrace
+ * (c) 2007 Chris Andrews <chris@nodnol.org>
+ */
+
+#include "dtrace_api.h"
+
+RUBY_EXTERN VALUE eDtraceException;
+RUBY_EXTERN VALUE cDtraceProbe;
+RUBY_EXTERN VALUE cDtraceProgram;
+RUBY_EXTERN VALUE cDtraceAggData;
+
+void dtrace_hdl_free (void *handle)
+{
+  dtrace_close(handle);
+}
+
+VALUE dtrace_hdl_alloc(VALUE klass)
+{
+  dtrace_hdl_t *handle;
+  int err;
+  VALUE obj;
+  
+  handle = dtrace_open(DTRACE_VERSION, 0, &err);
+  
+  if (handle) {
+    obj = Data_Wrap_Struct(klass, 0, dtrace_hdl_free, handle);
+    return obj;
+  }
+  else {
+    rb_raise(eDtraceException, "unable to open dtrace (not root?)");
+  }
+}
+
+/* :nodoc: */
+VALUE dtrace_init(VALUE self)
+{
+  dtrace_hdl_t *handle;
+
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  if (handle)
+    return self;
+  else
+    return Qnil;
+}
+
+int _dtrace_next_probe(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp, void *arg)
+{
+  VALUE probe;
+
+  probe = Data_Wrap_Struct(cDtraceProbe, 0, NULL, (dtrace_probedesc_t *)pdp);
+
+  rb_yield(probe);
+  return 0;
+}
+
+/*
+ * Yields each probe found on the system. 
+ * (equivalent to dtrace -l)
+ *
+ * Each probe is represented by a DtraceProbe object
+ */
+VALUE dtrace_each_probe(VALUE self)
+{
+  dtrace_hdl_t *handle;
+
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  (void) dtrace_probe_iter(handle, NULL, _dtrace_next_probe, NULL);
+
+  return self;
+}
+
+/*
+ * Compile a D program. 
+ *
+ * Arguments:
+ * * The program text to compile
+ * * (Optionally) any arguments required by the program
+ *
+ * Raises a DtraceException if the program cannot be compiled.
+ */
+VALUE dtrace_strcompile(int argc, VALUE *argv, VALUE self)
+{
+  dtrace_hdl_t *handle;
+  dtrace_prog_t *program;
+  VALUE dtrace_program;
+
+  VALUE dtrace_text;
+  int dtrace_argc;
+  VALUE dtrace_argv_array;
+
+  char **dtrace_argv;
+  int i;
+
+  rb_scan_args(argc, argv, "1*", &dtrace_text, &dtrace_argv_array);
+
+  dtrace_argc = FIX2INT(rb_funcall(dtrace_argv_array, rb_intern("length"), 0));
+  dtrace_argv = ALLOC_N(char *, dtrace_argc + 1);
+  for (i = 0; i < dtrace_argc; i++) {
+    dtrace_argv[i + 1] = STR2CSTR(rb_ary_entry(dtrace_argv_array, i));
+  }
+
+  dtrace_argv[0] = "ruby";
+  dtrace_argc++;
+
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  program = dtrace_program_strcompile(handle, STR2CSTR(dtrace_text),
+				      DTRACE_PROBESPEC_NAME, DTRACE_C_PSPEC, 
+				      dtrace_argc, dtrace_argv);
+
+  if (!program) {
+    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+    return Qnil;
+  }
+  else {
+    dtrace_program = Data_Wrap_Struct(cDtraceProgram, 0, NULL, program);
+    rb_iv_set(dtrace_program, "@dtrace", self);
+    return dtrace_program;
+  }
+}
+
+/*
+ * Start tracing. Must be called once a program has been successfully
+ * compiled and executed.
+ * 
+ * Raises a DtraceException on any error.
+ */
+VALUE dtrace_hdl_go(VALUE self)
+{
+  dtrace_hdl_t *handle;
+
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  if (dtrace_go(handle) < 0) 
+    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+    
+  return Qnil;
+}
+
+/* 
+ * Returns the status of the DTrace handle.
+ *
+ * Status values are defined as:
+ * 
+ * * 0 - none
+ * * 1 - ok
+ * * 4 - stopped
+ */
+VALUE dtrace_hdl_status(VALUE self)
+{
+  dtrace_hdl_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)));
+    
+  return INT2FIX(status);
+}
+
+/* 
+ * Set an option on the DTrace handle. 
+ * 
+ * Options which may be set:
+ * 
+ * * aggsize
+ * * bufsize
+ */
+VALUE dtrace_hdl_setopt(VALUE self, VALUE key, VALUE value)
+{
+  dtrace_hdl_t *handle;
+  int ret;
+
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  
+  if (NIL_P(value)) {
+    ret = dtrace_setopt(handle, STR2CSTR(key), 0);
+  }
+  else {
+    ret = dtrace_setopt(handle, STR2CSTR(key), STR2CSTR(value));
+  }
+
+  if (ret < 0) 
+    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+    
+  return Qnil;
+}
+
+/* Stop tracing. 
+ *
+ * Must be called after go has been called to start tracing.
+ */
+VALUE dtrace_hdl_stop(VALUE self)
+{
+  dtrace_hdl_t *handle;
+
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  if (dtrace_stop(handle) < 0) 
+    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+    
+  return Qnil;
+}
+
+int _agg_walk_yield(const dtrace_aggdata_t *data, void *arg)
+{
+  VALUE aggdata;
+
+  aggdata = Data_Wrap_Struct(cDtraceAggData, 0, NULL, (dtrace_aggdata_t *)data);
+
+  rb_yield(aggdata);
+  return (DTRACE_AGGWALK_NEXT);
+}
+
+/*
+ * Yields each aggregate in turn. 
+ * 
+ * Aggregates are represented by a DtraceAggregate object.
+ */
+VALUE dtrace_hdl_each_aggregate(VALUE self)
+{
+  dtrace_hdl_t *handle;
+
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  if (dtrace_aggregate_walk_keyvarsorted(handle, _agg_walk_yield, NULL) < 0)
+    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+    
+  return Qnil;    
+}
+
+/* 
+ * Uses libdtrace to print a summary of aggregates to STDERR.
+ */
+VALUE dtrace_hdl_aggregate_print(VALUE self)
+{
+  dtrace_hdl_t *handle;
+
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  if (dtrace_aggregate_print(handle, stderr, NULL) < 0)
+    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+    
+  return Qnil;
+}
+
+/*
+ * Take a snapshot of the current aggregate values.
+ */
+VALUE dtrace_hdl_aggregate_snap(VALUE self)
+{
+  dtrace_hdl_t *handle;
+
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  if (dtrace_aggregate_snap(handle) < 0) 
+    rb_raise(eDtraceException, dtrace_errmsg(handle, dtrace_errno(handle)));
+    
+  return Qnil;
+}
+
+/*
+ * Clear the current aggregate snapshot.
+ */
+VALUE dtrace_hdl_aggregate_clear(VALUE self)
+{
+  dtrace_hdl_t *handle;
+
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  dtrace_aggregate_clear(handle);
+  return Qnil;
+}
+
+/* 
+ * Return the most recent DTrace error.
+ */
+VALUE dtrace_hdl_error(VALUE self)
+{
+  dtrace_hdl_t *handle;
+  const char *error_string;
+
+  Data_Get_Struct(self, dtrace_hdl_t, handle);
+  error_string = dtrace_errmsg(handle, dtrace_errno(handle));
+  return rb_str_new2(error_string);
+}
+