statgrab 0.1

data/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.mkdn

@@ -0,0 +1,68 @@
+Statgrab for Ruby
+=================
+
+Ruby bindings to the libstatgrab portable system statistics library.
+
+- [Releases on Rubyforge][1]
+- [Ticket tracking on Lighthouse][2]
+- [API documentation][3]
+
+Git repositories:
+
+- [Github][4]
+- [Gitorious][5]
+- [Rubyforge][6]
+
+[1]: http://rubyforge.org/projects/statgrab/
+[2]: http://amazing.lighthouseapp.com/projects/11473-statgrab-for-ruby/
+[3]: http://statgrab.rubyforge.org/doc/
+[4]: http://github.com/dag/ruby-statgrab/tree/master
+[5]: http://gitorious.org/projects/ruby-statgrab
+[6]: http://rubyforge.org/scm/?group_id=6160
+
+
+Building and installing
+-----------------------
+
+First, make sure libstatgrab is installed on your system.
+
+Follow these procedures to build and install manually:
+
+    ruby extconf.rb
+    make
+    su
+    make install
+
+Or if you prefer, install remotely from Rubyforge via Rubygems:
+
+    su
+    gem install statgrab
+
+
+Sample program
+--------------
+
+    require 'statgrab'
+    begin
+      sg = Statgrab.new
+      puts "CPU Usage: %.1f%%" % sg.cpu_percents[:user]
+    rescue Statgrab::Exception => e
+      puts "Error! %s" % e.message
+    end
+
+
+Licensing
+---------
+
+Copyright 2008 Dag Odenhall <dag.odenhall@gmail.com>
+
+Licensed under the Apache License, Version 2.0 (the "License").
+You may obtain a copy of the License at
+
+   <http://www.apache.org/licenses/LICENSE-2.0>
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+have_library("statgrab")
+create_makefile("statgrab")

data/statgrab.c

@@ -0,0 +1,1120 @@
+/*
+ * Copyright 2008 Dag Odenhall <dag.odenhall@gmail.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ruby.h>
+#include <statgrab.h>
+#include <string.h>
+
+VALUE cStatgrab;
+VALUE eStatgrabException;
+VALUE eStatgrabAsprintfError;
+VALUE eStatgrabDevicesError;
+VALUE eStatgrabDevstatGetdevsError;
+VALUE eStatgrabDevstatSelectdevsError;
+VALUE eStatgrabDiskinfoError;
+VALUE eStatgrabEnoentError;
+VALUE eStatgrabGetifaddrsError;
+VALUE eStatgrabGetmntinfoError;
+VALUE eStatgrabGetpagesizeError;
+VALUE eStatgrabHostError;
+VALUE eStatgrabKstatDataLookupError;
+VALUE eStatgrabKstatLookupError;
+VALUE eStatgrabKstatOpenError;
+VALUE eStatgrabKstatReadError;
+VALUE eStatgrabKvmGetswapinfoError;
+VALUE eStatgrabKvmOpenfilesError;
+VALUE eStatgrabMallocError;
+VALUE eStatgrabMemstatusError;
+VALUE eStatgrabOpenError;
+VALUE eStatgrabOpendirError;
+VALUE eStatgrabParseError;
+VALUE eStatgrabPdhaddError;
+VALUE eStatgrabPdhcollectError;
+VALUE eStatgrabPdhopenError;
+VALUE eStatgrabPdhreadError;
+VALUE eStatgrabPermissionError;
+VALUE eStatgrabPstatError;
+VALUE eStatgrabSetegidError;
+VALUE eStatgrabSeteuidError;
+VALUE eStatgrabSetmntentError;
+VALUE eStatgrabSocketError;
+VALUE eStatgrabSwapctlError;
+VALUE eStatgrabSysconfError;
+VALUE eStatgrabSysctlError;
+VALUE eStatgrabSysctlbynameError;
+VALUE eStatgrabSysctlnametomibError;
+VALUE eStatgrabUnameError;
+VALUE eStatgrabUnsupportedError;
+VALUE eStatgrabXswVerMismatchError;
+
+/*
+ * Get the latest error from statgrab and, if there is one,
+ * raise the corresponding Ruby exception with the error message.
+ * Only used internally.
+ */
+static void
+statgrab_handle_error(void)
+{
+	sg_error err_num;
+	err_num = sg_get_error();
+
+	switch(err_num) {
+	case SG_ERROR_NONE:
+		return;
+	case SG_ERROR_ASPRINTF:
+		rb_raise(eStatgrabAsprintfError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_DEVICES:
+		rb_raise(eStatgrabDevicesError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_DEVSTAT_GETDEVS:
+		rb_raise(eStatgrabDevstatGetdevsError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_DEVSTAT_SELECTDEVS:
+		rb_raise(eStatgrabDevstatSelectdevsError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_DISKINFO:
+		rb_raise(eStatgrabDiskinfoError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_ENOENT:
+		rb_raise(eStatgrabEnoentError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_GETIFADDRS:
+		rb_raise(eStatgrabGetifaddrsError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_GETMNTINFO:
+		rb_raise(eStatgrabGetmntinfoError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_GETPAGESIZE:
+		rb_raise(eStatgrabGetpagesizeError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_HOST:
+		rb_raise(eStatgrabHostError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_KSTAT_DATA_LOOKUP:
+		rb_raise(eStatgrabKstatDataLookupError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_KSTAT_LOOKUP:
+		rb_raise(eStatgrabKstatLookupError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_KSTAT_OPEN:
+		rb_raise(eStatgrabKstatOpenError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_KSTAT_READ:
+		rb_raise(eStatgrabKstatReadError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_KVM_GETSWAPINFO:
+		rb_raise(eStatgrabKvmGetswapinfoError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_KVM_OPENFILES:
+		rb_raise(eStatgrabKvmOpenfilesError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_MALLOC:
+		rb_raise(eStatgrabMallocError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_MEMSTATUS:
+		rb_raise(eStatgrabMemstatusError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_OPEN:
+		rb_raise(eStatgrabOpenError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_OPENDIR:
+		rb_raise(eStatgrabOpendirError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_PARSE:
+		rb_raise(eStatgrabParseError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_PDHADD:
+		rb_raise(eStatgrabPdhaddError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_PDHCOLLECT:
+		rb_raise(eStatgrabPdhcollectError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_PDHOPEN:
+		rb_raise(eStatgrabPdhopenError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_PDHREAD:
+		rb_raise(eStatgrabPdhreadError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_PERMISSION:
+		rb_raise(eStatgrabPermissionError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_PSTAT:
+		rb_raise(eStatgrabPstatError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_SETEGID:
+		rb_raise(eStatgrabSetegidError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_SETEUID:
+		rb_raise(eStatgrabSeteuidError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_SETMNTENT:
+		rb_raise(eStatgrabSetmntentError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_SOCKET:
+		rb_raise(eStatgrabSocketError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_SWAPCTL:
+		rb_raise(eStatgrabSwapctlError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_SYSCONF:
+		rb_raise(eStatgrabSysconfError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_SYSCTL:
+		rb_raise(eStatgrabSysctlError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_SYSCTLBYNAME:
+		rb_raise(eStatgrabSysctlbynameError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_SYSCTLNAMETOMIB:
+		rb_raise(eStatgrabSysctlnametomibError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_UNAME:
+		rb_raise(eStatgrabUnameError, "%s", sg_str_error(err_num));
+		break;
+	case SG_ERROR_UNSUPPORTED:
+		rb_raise(eStatgrabUnsupportedError, "%s",
+				sg_str_error(err_num));
+		break;
+	case SG_ERROR_XSW_VER_MISMATCH:
+		rb_raise(eStatgrabXswVerMismatchError, "%s",
+				sg_str_error(err_num));
+		break;
+	}
+}
+
+/*
+ * call-seq:
+ *   Statgrab.new(drop_privileges=true)
+ *
+ * Set privileges and prepare connections, and then drop privileges.
+ * See <tt>statgrab(3)</tt> manpage.
+ */
+static VALUE
+statgrab_initialize(VALUE self, VALUE args)
+{
+	if (sg_init())
+		statgrab_handle_error();
+
+	if (rb_ary_shift(args) != Qfalse && sg_drop_privileges())
+		statgrab_handle_error();
+
+	return self;
+}
+
+/*
+ * CPU usage as ticks spent in different states,
+ * see <tt>sg_get_cpu_stats(3)</tt> manpage.
+ */
+static VALUE
+statgrab_cpu_stats(VALUE self)
+{
+	sg_cpu_stats *stats;
+	VALUE info, time_at;
+
+	if ((stats = sg_get_cpu_stats()) == NULL)
+		statgrab_handle_error();
+
+	info = rb_hash_new();
+	rb_hash_aset(info, ID2SYM(rb_intern("user")), INT2NUM(stats->user));
+	rb_hash_aset(info, ID2SYM(rb_intern("kernel")),
+			INT2NUM(stats->kernel));
+	rb_hash_aset(info, ID2SYM(rb_intern("idle")), INT2NUM(stats->idle));
+	rb_hash_aset(info, ID2SYM(rb_intern("iowait")),
+			INT2NUM(stats->iowait));
+	rb_hash_aset(info, ID2SYM(rb_intern("swap")), INT2NUM(stats->swap));
+	rb_hash_aset(info, ID2SYM(rb_intern("nice")), INT2NUM(stats->nice));
+	rb_hash_aset(info, ID2SYM(rb_intern("systime")),
+			INT2NUM(stats->systime));
+
+	time_at = rb_funcall(rb_cTime, rb_intern("at"), 1,
+			INT2NUM(stats->systime));
+	rb_hash_aset(info, ID2SYM(rb_intern("time")), time_at);
+
+	return info;
+}
+
+/*
+ * CPU usage as ticks spent since last call,
+ * see <tt>sg_get_cpu_stats_diff(3)</tt> manpage.
+ */
+static VALUE
+statgrab_cpu_stats_diff(VALUE self)
+{
+	sg_cpu_stats *stats;
+	VALUE info, time_at;
+
+	if ((stats = sg_get_cpu_stats_diff()) == NULL)
+		statgrab_handle_error();
+
+	info = rb_hash_new();
+	rb_hash_aset(info, ID2SYM(rb_intern("user")), INT2NUM(stats->user));
+	rb_hash_aset(info, ID2SYM(rb_intern("kernel")),
+			INT2NUM(stats->kernel));
+	rb_hash_aset(info, ID2SYM(rb_intern("idle")), INT2NUM(stats->idle));
+	rb_hash_aset(info, ID2SYM(rb_intern("iowait")),
+			INT2NUM(stats->iowait));
+	rb_hash_aset(info, ID2SYM(rb_intern("swap")), INT2NUM(stats->swap));
+	rb_hash_aset(info, ID2SYM(rb_intern("nice")), INT2NUM(stats->nice));
+	rb_hash_aset(info, ID2SYM(rb_intern("systime")),
+			INT2NUM(stats->systime));
+
+	time_at = rb_funcall(rb_cTime, rb_intern("at"), 1,
+			INT2NUM(stats->systime));
+	rb_hash_aset(info, ID2SYM(rb_intern("time")), time_at);
+
+	return info;
+}
+
+/*
+ * CPU usage as ticks difference in percents,
+ * see <tt>sg_get_cpu_percents(3)</tt> manpage.
+ */
+static VALUE
+statgrab_cpu_percents(VALUE self)
+{
+	sg_cpu_percents *percents;
+	VALUE info, time_now;
+
+	if ((percents = sg_get_cpu_percents()) == NULL)
+		statgrab_handle_error();
+
+	info = rb_hash_new();
+	rb_hash_aset(info, ID2SYM(rb_intern("user")),
+			rb_float_new(percents->user));
+	rb_hash_aset(info, ID2SYM(rb_intern("kernel")),
+			rb_float_new(percents->kernel));
+	rb_hash_aset(info, ID2SYM(rb_intern("idle")),
+			rb_float_new(percents->idle));
+	rb_hash_aset(info, ID2SYM(rb_intern("iowait")),
+			rb_float_new(percents->iowait));
+	rb_hash_aset(info, ID2SYM(rb_intern("swap")),
+			rb_float_new(percents->swap));
+	rb_hash_aset(info, ID2SYM(rb_intern("nice")),
+			rb_float_new(percents->nice));
+	rb_hash_aset(info, ID2SYM(rb_intern("time_taken")),
+			INT2NUM(percents->time_taken));
+
+	time_now = rb_funcall(rb_cTime, rb_intern("now"), 0);
+	rb_hash_aset(info, ID2SYM(rb_intern("last_call")),
+			rb_funcall(time_now, rb_intern("-"), 1,
+				INT2NUM(percents->time_taken)));
+
+	return info;
+}
+
+/*
+ * Disk I/O statistics, see <tt>sg_get_disk_io_stats(3)</tt> manpage.
+ */
+static VALUE
+statgrab_disk_io_stats(VALUE self)
+{
+	int entries, i;
+	sg_disk_io_stats *stats;
+	VALUE arr, info, time_at;
+
+	if ((stats = sg_get_disk_io_stats(&entries)) == NULL)
+		statgrab_handle_error();
+
+	arr = rb_ary_new();
+	for (i = 0; i < entries; i++) {
+		info = rb_hash_new();
+		rb_hash_aset(info, ID2SYM(rb_intern("disk_name")),
+				rb_str_new2(stats[i].disk_name));
+		rb_hash_aset(info, ID2SYM(rb_intern("read_bytes")),
+				INT2NUM(stats[i].read_bytes/1024));
+		rb_hash_aset(info, ID2SYM(rb_intern("write_bytes")),
+				INT2NUM(stats[i].write_bytes/1024));
+		rb_hash_aset(info, ID2SYM(rb_intern("systime")),
+				INT2NUM(stats[i].systime));
+
+		time_at = rb_funcall(rb_cTime, rb_intern("at"), 1,
+				INT2NUM(stats[i].systime));
+		rb_hash_aset(info, ID2SYM(rb_intern("time")), time_at);
+
+		rb_ary_push(arr, info);
+	}
+
+	return arr;
+}
+
+/*
+ * Disk I/O statistics difference since last call,
+ * see <tt>sg_get_disk_io_stats_diff(3)</tt> manpage.
+ */
+static VALUE
+statgrab_disk_io_stats_diff(VALUE self)
+{
+	int entries, i;
+	sg_disk_io_stats *stats;
+	VALUE arr, info, time_now;
+
+	if ((stats = sg_get_disk_io_stats_diff(&entries)) == NULL)
+		statgrab_handle_error();
+
+	arr = rb_ary_new();
+	for(i = 0; i < entries; i++) {
+		info = rb_hash_new();
+		rb_hash_aset(info, ID2SYM(rb_intern("disk_name")),
+				rb_str_new2(stats[i].disk_name));
+		rb_hash_aset(info, ID2SYM(rb_intern("read_bytes")),
+				INT2NUM(stats[i].read_bytes/1024));
+		rb_hash_aset(info, ID2SYM(rb_intern("write_bytes")),
+				INT2NUM(stats[i].write_bytes/1024));
+		rb_hash_aset(info, ID2SYM(rb_intern("systime")),
+				INT2NUM(stats[i].systime));
+
+		time_now = rb_funcall(rb_cTime, rb_intern("now"), 0);
+		rb_hash_aset(info, ID2SYM(rb_intern("last_call")),
+				rb_funcall(time_now, rb_intern("-"), 1,
+					INT2NUM(stats[i].systime)));
+
+		rb_ary_push(arr, info);
+	}
+
+	return arr;
+}
+
+/*
+ * Filesystem statistics, see <tt>sg_get_fs_stats(3)</tt> manpage.
+ */
+static VALUE
+statgrab_fs_stats(VALUE self)
+{
+	int entries, i;
+	sg_fs_stats *stats;
+	VALUE arr, info;
+
+	if ((stats = sg_get_fs_stats(&entries)) == NULL)
+		statgrab_handle_error();
+
+	arr = rb_ary_new();
+	for (i = 0; i < entries; i++) {
+		info = rb_hash_new();
+		rb_hash_aset(info, ID2SYM(rb_intern("device_name")),
+				rb_str_new2(stats[i].device_name));
+		rb_hash_aset(info, ID2SYM(rb_intern("fs_type")),
+				rb_str_new2(stats[i].fs_type));
+		rb_hash_aset(info, ID2SYM(rb_intern("mnt_point")),
+				rb_str_new2(stats[i].mnt_point));
+		rb_hash_aset(info, ID2SYM(rb_intern("size")),
+				INT2NUM(stats[i].size/1024));
+		rb_hash_aset(info, ID2SYM(rb_intern("used")),
+				INT2NUM(stats[i].used/1024));
+		rb_hash_aset(info, ID2SYM(rb_intern("avail")),
+				INT2NUM(stats[i].avail/1024));
+		rb_hash_aset(info, ID2SYM(rb_intern("total_inodes")),
+				INT2NUM(stats[i].total_inodes));
+		rb_hash_aset(info, ID2SYM(rb_intern("used_inodes")),
+				INT2NUM(stats[i].used_inodes));
+		rb_hash_aset(info, ID2SYM(rb_intern("free_inodes")),
+				INT2NUM(stats[i].free_inodes));
+		rb_hash_aset(info, ID2SYM(rb_intern("avail_blocks")),
+				INT2NUM(stats[i].avail_blocks));
+		rb_hash_aset(info, ID2SYM(rb_intern("io_size")),
+				INT2NUM(stats[i].io_size));
+		rb_hash_aset(info, ID2SYM(rb_intern("block_size")),
+				INT2NUM(stats[i].block_size));
+		rb_hash_aset(info, ID2SYM(rb_intern("total_blocks")),
+				INT2NUM(stats[i].total_blocks));
+		rb_hash_aset(info, ID2SYM(rb_intern("free_blocks")),
+				INT2NUM(stats[i].free_blocks));
+		rb_hash_aset(info, ID2SYM(rb_intern("used_blocks")),
+				INT2NUM(stats[i].used_blocks));
+		rb_hash_aset(info, ID2SYM(rb_intern("avail_blocks")),
+				INT2NUM(stats[i].avail_blocks));
+
+		rb_ary_push(arr, info);
+	}
+
+	return arr;
+}
+
+/*
+ * General operating system statistics,
+ * see <tt>sg_get_host_info(3)</tt> manpage.
+ */
+static VALUE
+statgrab_host_info(VALUE self)
+{
+	sg_host_info *host;
+	VALUE info, time_now;
+
+	if ((host = sg_get_host_info()) == NULL)
+		statgrab_handle_error();
+
+	info = rb_hash_new();
+	rb_hash_aset(info, ID2SYM(rb_intern("os_name")),
+			rb_str_new2(host->os_name));
+	rb_hash_aset(info, ID2SYM(rb_intern("os_release")),
+			rb_str_new2(host->os_release));
+	rb_hash_aset(info, ID2SYM(rb_intern("os_version")),
+			rb_str_new2(host->os_version));
+	rb_hash_aset(info, ID2SYM(rb_intern("platform")),
+			rb_str_new2(host->platform));
+	rb_hash_aset(info, ID2SYM(rb_intern("hostname")),
+			rb_str_new2(host->hostname));
+	rb_hash_aset(info, ID2SYM(rb_intern("uptime")),
+			INT2NUM(host->uptime));
+
+	time_now = rb_funcall(rb_cTime, rb_intern("now"), 0);
+	rb_hash_aset(info, ID2SYM(rb_intern("booted")),
+			rb_funcall(time_now, rb_intern("-"), 1,
+				INT2NUM(host->uptime)));
+
+	return info;
+}
+
+/*
+ * System load, see <tt>sg_get_load_stats(3)</tt> manpage.
+ */
+static VALUE
+statgrab_load_stats(VALUE self)
+{
+	sg_load_stats *load;
+	VALUE info;
+
+	if ((load = sg_get_load_stats()) == NULL)
+		statgrab_handle_error();
+
+	info = rb_hash_new();
+	rb_hash_aset(info, ID2SYM(rb_intern("min1")),
+			rb_float_new(load->min1));
+	rb_hash_aset(info, ID2SYM(rb_intern("min5")),
+			rb_float_new(load->min5));
+	rb_hash_aset(info, ID2SYM(rb_intern("min15")),
+			rb_float_new(load->min15));
+
+	return info;
+}
+
+/*
+ * Memory statistics, see <tt>sg_get_mem_stats(3)</tt> manpage.
+ */
+static VALUE
+statgrab_mem_stats(VALUE self)
+{
+	sg_mem_stats *stats;
+	VALUE info;
+
+	if ((stats = sg_get_mem_stats()) == NULL)
+		statgrab_handle_error();
+
+	info = rb_hash_new();
+	rb_hash_aset(info, ID2SYM(rb_intern("total")),
+			INT2NUM(stats->total/1024));
+	rb_hash_aset(info, ID2SYM(rb_intern("free")),
+			INT2NUM(stats->free/1024));
+	rb_hash_aset(info, ID2SYM(rb_intern("used")),
+			INT2NUM(stats->used/1024));
+	rb_hash_aset(info, ID2SYM(rb_intern("cache")),
+			INT2NUM(stats->cache/1024));
+
+	return info;
+}
+
+/*
+ * Swap statistics, see <tt>sg_get_swap_stats(3)</tt> manpage.
+ */
+static VALUE
+statgrab_swap_stats(VALUE self)
+{
+	sg_swap_stats *stats;
+	VALUE info;
+
+	if ((stats = sg_get_swap_stats()) == NULL)
+		statgrab_handle_error();
+
+	info = rb_hash_new();
+	rb_hash_aset(info, ID2SYM(rb_intern("total")),
+			INT2NUM(stats->total/1024));
+	rb_hash_aset(info, ID2SYM(rb_intern("used")),
+			INT2NUM(stats->used/1024));
+	rb_hash_aset(info, ID2SYM(rb_intern("free")),
+			INT2NUM(stats->free/1024));
+
+	return info;
+}
+
+/*
+ * Network statistics, see <tt>sg_get_network_io_stats(3)</tt> manpage.
+ */
+static VALUE
+statgrab_network_io_stats(VALUE self)
+{
+	int entries, i;
+	sg_network_io_stats *stats;
+	VALUE arr, info, time_at;
+
+	if ((stats = sg_get_network_io_stats(&entries)) == NULL)
+		statgrab_handle_error();
+
+	arr = rb_ary_new();
+	for (i = 0; i < entries; i++) {
+		info = rb_hash_new();
+		rb_hash_aset(info, ID2SYM(rb_intern("interface_name")),
+				rb_str_new2(stats[i].interface_name));
+		rb_hash_aset(info, ID2SYM(rb_intern("tx")),
+				INT2NUM(stats[i].tx/1024));
+		rb_hash_aset(info, ID2SYM(rb_intern("rx")),
+				INT2NUM(stats[i].rx/1024));
+		rb_hash_aset(info, ID2SYM(rb_intern("ipackets")),
+				INT2NUM(stats[i].ipackets));
+		rb_hash_aset(info, ID2SYM(rb_intern("opackets")),
+				INT2NUM(stats[i].opackets));
+		rb_hash_aset(info, ID2SYM(rb_intern("ierrors")),
+				INT2NUM(stats[i].ierrors));
+		rb_hash_aset(info, ID2SYM(rb_intern("oerrors")),
+				INT2NUM(stats[i].oerrors));
+		rb_hash_aset(info, ID2SYM(rb_intern("collisions")),
+				INT2NUM(stats[i].collisions));
+		rb_hash_aset(info, ID2SYM(rb_intern("systime")),
+				INT2NUM(stats[i].systime));
+
+		time_at = rb_funcall(rb_cTime, rb_intern("at"), 1,
+				INT2NUM(stats[i].systime));
+		rb_hash_aset(info, ID2SYM(rb_intern("time")), time_at);
+
+		rb_ary_push(arr, info);
+	}
+
+	return arr;
+}
+
+/*
+ * Network statistics difference since last call,
+ * see <tt>sg_get_network_io_stats_diff(3)</tt> manpage.
+ */
+static VALUE
+statgrab_network_io_stats_diff(VALUE self)
+{
+	int entries, i;
+	sg_network_io_stats *stats;
+	VALUE arr, info, time_now;
+
+	if ((stats = sg_get_network_io_stats_diff(&entries)) == NULL)
+		statgrab_handle_error();
+
+	arr = rb_ary_new();
+	for (i = 0; i < entries; i++) {
+		info = rb_hash_new();
+		rb_hash_aset(info, ID2SYM(rb_intern("interface_name")),
+				rb_str_new2(stats[i].interface_name));
+		rb_hash_aset(info, ID2SYM(rb_intern("tx")),
+				INT2NUM(stats[i].tx/1024));
+		rb_hash_aset(info, ID2SYM(rb_intern("rx")),
+				INT2NUM(stats[i].rx/1024));
+		rb_hash_aset(info, ID2SYM(rb_intern("ipackets")),
+				INT2NUM(stats[i].ipackets));
+		rb_hash_aset(info, ID2SYM(rb_intern("opackets")),
+				INT2NUM(stats[i].opackets));
+		rb_hash_aset(info, ID2SYM(rb_intern("ierrors")),
+				INT2NUM(stats[i].ierrors));
+		rb_hash_aset(info, ID2SYM(rb_intern("oerrors")),
+				INT2NUM(stats[i].oerrors));
+		rb_hash_aset(info, ID2SYM(rb_intern("collisions")),
+				INT2NUM(stats[i].collisions));
+		rb_hash_aset(info, ID2SYM(rb_intern("systime")),
+				INT2NUM(stats[i].systime));
+
+		time_now = rb_funcall(rb_cTime, rb_intern("now"), 0);
+		rb_hash_aset(info, ID2SYM(rb_intern("last_call")),
+				rb_funcall(time_now, rb_intern("-"), 1,
+					INT2NUM(stats[i].systime)));
+
+		rb_ary_push(arr, info);
+	}
+
+	return arr;
+}
+
+/*
+ * Network interface statistics,
+ * see <tt>sg_get_network_iface_stats(3)</tt> manpage.
+ */
+static VALUE
+statgrab_network_iface_stats(VALUE self)
+{
+	int entries, i;
+	sg_network_iface_stats *stats;
+	VALUE arr, info;
+
+	if ((stats = sg_get_network_iface_stats(&entries)) == NULL)
+		statgrab_handle_error();
+
+	arr = rb_ary_new();
+	for (i = 0; i < entries; i++) {
+		info = rb_hash_new();
+		rb_hash_aset(info, ID2SYM(rb_intern("interface_name")),
+				rb_str_new2(stats[i].interface_name));
+		rb_hash_aset(info, ID2SYM(rb_intern("speed")),
+				INT2FIX(stats[i].speed));
+
+		switch(stats[i].duplex) {
+		case SG_IFACE_DUPLEX_FULL:
+			rb_hash_aset(info, ID2SYM(rb_intern("duplex")),
+					ID2SYM(rb_intern("full")));
+			break;
+		case SG_IFACE_DUPLEX_HALF:
+			rb_hash_aset(info, ID2SYM(rb_intern("duplex")),
+					ID2SYM(rb_intern("half")));
+			break;
+		case SG_IFACE_DUPLEX_UNKNOWN:
+			rb_hash_aset(info, ID2SYM(rb_intern("duplex")),
+					ID2SYM(rb_intern("unknown")));
+			break;
+		}
+
+		if (stats[i].up)
+			rb_hash_aset(info, ID2SYM(rb_intern("up")), Qtrue);
+		else
+			rb_hash_aset(info, ID2SYM(rb_intern("up")), Qfalse);
+
+		rb_ary_push(arr, info);
+	}
+
+	return arr;
+}
+
+/*
+ * Paging statistics, see <tt>sg_get_page_stats(3)</tt> manpage.
+ */
+static VALUE
+statgrab_page_stats(VALUE self)
+{
+	sg_page_stats *stats;
+	VALUE info, time_at;
+
+	if ((stats = sg_get_page_stats()) == NULL)
+		statgrab_handle_error();
+
+	info = rb_hash_new();
+	rb_hash_aset(info, ID2SYM(rb_intern("pages_pagein")),
+			INT2NUM(stats->pages_pagein));
+	rb_hash_aset(info, ID2SYM(rb_intern("pages_pageout")),
+			INT2NUM(stats->pages_pageout));
+	rb_hash_aset(info, ID2SYM(rb_intern("systime")),
+			INT2NUM(stats->systime));
+
+	time_at = rb_funcall(rb_cTime, rb_intern("at"), 1,
+			INT2NUM(stats->systime));
+	rb_hash_aset(info, ID2SYM(rb_intern("time")), time_at);
+
+	return info;
+}
+
+/*
+ * Paging statistics difference since last call,
+ * see <tt>sg_get_page_stats(3)</tt> manpage.
+ */
+static VALUE
+statgrab_page_stats_diff(VALUE self)
+{
+	sg_page_stats *stats;
+	VALUE info, time_now;
+
+	if ((stats = sg_get_page_stats_diff()) == NULL)
+		statgrab_handle_error();
+
+	info = rb_hash_new();
+	rb_hash_aset(info, ID2SYM(rb_intern("pages_pagein")),
+			INT2NUM(stats->pages_pagein));
+	rb_hash_aset(info, ID2SYM(rb_intern("pages_pageout")),
+			INT2NUM(stats->pages_pageout));
+	rb_hash_aset(info, ID2SYM(rb_intern("systime")),
+			INT2NUM(stats->systime));
+
+	time_now = rb_funcall(rb_cTime, rb_intern("now"), 0);
+	rb_hash_aset(info, ID2SYM(rb_intern("last_call")),
+			rb_funcall(time_now, rb_intern("-"), 1,
+				INT2NUM(stats->systime)));
+
+	return info;
+}
+
+/*
+ * Process statistics, see <tt>sg_get_process_stats(3)</tt> manpage.
+ *
+ * The +sg_process_compare_+ family of related functions is intentionally
+ * left out in this binding - it can be done with Enumerable#sort_by in Ruby.
+ * The following example corresponds to the <tt>qsort()</tt> example in the
+ * <tt>sg_get_process_stats(3)</tt> manpage:
+ *
+ *   ps.sort_by {|p| p[:pid] }
+ */
+static VALUE
+statgrab_process_stats(VALUE self)
+{
+	int entries, i;
+	sg_process_stats *stats;
+	VALUE arr, info, time_now;
+
+	if ((stats = sg_get_process_stats(&entries)) == NULL)
+		statgrab_handle_error();
+
+	arr = rb_ary_new();
+	for (i = 0; i < entries; i++) {
+		info = rb_hash_new();
+		rb_hash_aset(info, ID2SYM(rb_intern("process_name")),
+				rb_str_new2(stats[i].process_name));
+
+		if (stats[i].proctitle != NULL)
+			rb_hash_aset(info, ID2SYM(rb_intern("proctitle")),
+					rb_str_new2(stats[i].proctitle));
+
+		rb_hash_aset(info, ID2SYM(rb_intern("pid")),
+				INT2FIX(stats[i].pid));
+		rb_hash_aset(info, ID2SYM(rb_intern("parent")),
+				INT2FIX(stats[i].parent));
+		rb_hash_aset(info, ID2SYM(rb_intern("pgid")),
+				INT2FIX(stats[i].pgid));
+		rb_hash_aset(info, ID2SYM(rb_intern("uid")),
+				INT2FIX(stats[i].uid));
+		rb_hash_aset(info, ID2SYM(rb_intern("euid")),
+				INT2FIX(stats[i].euid));
+		rb_hash_aset(info, ID2SYM(rb_intern("gid")),
+				INT2FIX(stats[i].gid));
+		rb_hash_aset(info, ID2SYM(rb_intern("egid")),
+				INT2FIX(stats[i].egid));
+		rb_hash_aset(info, ID2SYM(rb_intern("proc_size")),
+				INT2NUM(stats[i].proc_size/1024));
+		rb_hash_aset(info, ID2SYM(rb_intern("proc_resident")),
+				INT2NUM(stats[i].proc_resident/1024));
+		rb_hash_aset(info, ID2SYM(rb_intern("time_spent")),
+				INT2NUM(stats[i].time_spent));
+		rb_hash_aset(info, ID2SYM(rb_intern("cpu_percent")),
+				INT2NUM(stats[i].cpu_percent));
+		rb_hash_aset(info, ID2SYM(rb_intern("nice")),
+				INT2NUM(stats[i].nice));
+
+		switch(stats[i].state) {
+		case SG_PROCESS_STATE_RUNNING:
+			rb_hash_aset(info, ID2SYM(rb_intern("state")),
+					ID2SYM(rb_intern("running")));
+			break;
+		case SG_PROCESS_STATE_SLEEPING:
+			rb_hash_aset(info, ID2SYM(rb_intern("state")),
+					ID2SYM(rb_intern("sleeping")));
+			break;
+		case SG_PROCESS_STATE_STOPPED:
+			rb_hash_aset(info, ID2SYM(rb_intern("state")),
+					ID2SYM(rb_intern("stopped")));
+			break;
+		case SG_PROCESS_STATE_ZOMBIE:
+			rb_hash_aset(info, ID2SYM(rb_intern("state")),
+					ID2SYM(rb_intern("zombie")));
+			break;
+		case SG_PROCESS_STATE_UNKNOWN:
+			rb_hash_aset(info, ID2SYM(rb_intern("state")),
+					ID2SYM(rb_intern("unknown")));
+			break;
+		}
+
+		time_now = rb_funcall(rb_cTime, rb_intern("now"), 0);
+		rb_hash_aset(info, ID2SYM(rb_intern("started")),
+				rb_funcall(time_now, rb_intern("-"), 1,
+					INT2NUM(stats[i].time_spent)));
+
+		rb_ary_push(arr, info);
+	}
+
+	return arr;
+}
+
+/*
+ * Brief process count for different states,
+ * see <tt>sg_get_process_count(3)</tt> manpage.
+ */
+static VALUE
+statgrab_process_count(VALUE self)
+{
+	sg_process_count *count;
+	VALUE info;
+
+	if ((count = sg_get_process_count()) == NULL)
+		statgrab_handle_error();
+
+	info = rb_hash_new();
+	rb_hash_aset(info, ID2SYM(rb_intern("total")),
+			INT2FIX(count->total));
+	rb_hash_aset(info, ID2SYM(rb_intern("running")),
+			INT2FIX(count->running));
+	rb_hash_aset(info, ID2SYM(rb_intern("sleeping")),
+			INT2FIX(count->sleeping));
+	rb_hash_aset(info, ID2SYM(rb_intern("stopped")),
+			INT2FIX(count->stopped));
+	rb_hash_aset(info, ID2SYM(rb_intern("zombie")),
+			INT2FIX(count->zombie));
+
+	return info;
+}
+
+/*
+ * The current logged in users,
+ * see <tt>sg_get_user_stats(3)</tt> manpage.
+ *
+ * Returns an array of login names.
+ */
+static VALUE
+statgrab_user_stats(VALUE self)
+{
+	int i;
+	char *names, *token, *saveptr;
+	sg_user_stats *stats;
+	VALUE arr;
+
+	if ((stats = sg_get_user_stats()) == NULL)
+		statgrab_handle_error();
+
+	arr = rb_ary_new();
+	for (i = 0, names = stats->name_list; i < stats->num_entries;
+			i++, names = NULL) {
+		token = strtok_r(names, " ", &saveptr);
+		rb_ary_push(arr, rb_str_new2(token));
+	}
+
+	return arr;
+}
+
+void
+Init_statgrab(void)
+{
+	/*
+	 * = Statgrab for Ruby
+	 *
+	 * Bindings to the libstatgrab portable system statistics library.
+	 *
+	 * == API
+	 *
+	 * All instance methods except user_stats return symbol hashes or
+	 * arrays of symbol hashes corresponding to their C struct
+	 * counterparts, see libstatgrab manuals for reference. Also, +enum+
+	 * datatypes are represented as lowercased symbols with namespacing
+	 * cut off, e.g. +SG_IFACE_DUPLEX_FULL+ becomes <tt>:full</tt>.
+	 * Errors are handled and raises corresponding exceptions, all
+	 * inheriting from Statgrab::Exception. Byte values are represented
+	 * in kilobytes.
+	 *
+	 * == Sample program
+	 *
+	 *   require 'statgrab'
+	 *   begin
+	 *     sg = Statgrab.new
+	 *     puts "CPU Usage: %.1f%%" % sg.cpu_percents[:user]
+	 *   rescue Statgrab::Exception => e
+	 *     puts "Error! %s" % e.message
+	 *   end
+	 */
+	cStatgrab = rb_define_class("Statgrab", rb_cObject);
+
+	rb_define_const(cStatgrab, "VERSION", rb_str_new2("0.1"));
+
+	/*
+	 * Raised when a statgrab function failed and an error was set.
+	 */
+	eStatgrabException = rb_define_class_under(cStatgrab,
+			"Exception", rb_eException);
+	eStatgrabAsprintfError = rb_define_class_under(cStatgrab,
+			"AsprintfError", eStatgrabException);
+	eStatgrabDevicesError = rb_define_class_under(cStatgrab,
+			"DevicesError", eStatgrabException);
+	eStatgrabDevstatGetdevsError = rb_define_class_under(cStatgrab,
+			"DevstatGetdevsError", eStatgrabException);
+	eStatgrabDevstatSelectdevsError = rb_define_class_under(cStatgrab,
+			"DevstatSelectdevsError", eStatgrabException);
+	eStatgrabDiskinfoError = rb_define_class_under(cStatgrab,
+			"DiskinfoError", eStatgrabException);
+	eStatgrabEnoentError = rb_define_class_under(cStatgrab,
+			"EnoentError", eStatgrabException);
+	eStatgrabGetifaddrsError = rb_define_class_under(cStatgrab,
+			"GetifaddrsError", eStatgrabException);
+	eStatgrabGetmntinfoError = rb_define_class_under(cStatgrab,
+			"GetmntinfoError", eStatgrabException);
+	eStatgrabGetpagesizeError = rb_define_class_under(cStatgrab,
+			"GetpagesizeError", eStatgrabException);
+	eStatgrabHostError = rb_define_class_under(cStatgrab,
+			"HostError", eStatgrabException);
+	eStatgrabKstatDataLookupError = rb_define_class_under(cStatgrab,
+			"KstatDataLookupError", eStatgrabException);
+	eStatgrabKstatLookupError = rb_define_class_under(cStatgrab,
+			"KstatLookupError", eStatgrabException);
+	eStatgrabKstatOpenError = rb_define_class_under(cStatgrab,
+			"KstatOpenError", eStatgrabException);
+	eStatgrabKstatReadError = rb_define_class_under(cStatgrab,
+			"KstatReadError", eStatgrabException);
+	eStatgrabKvmGetswapinfoError = rb_define_class_under(cStatgrab,
+			"KvmGetswapinfoError", eStatgrabException);
+	eStatgrabKvmOpenfilesError = rb_define_class_under(cStatgrab,
+			"KvmOpenfilesError", eStatgrabException);
+	eStatgrabMallocError = rb_define_class_under(cStatgrab,
+			"MallocError", eStatgrabException);
+	eStatgrabMemstatusError = rb_define_class_under(cStatgrab,
+			"MemstatusError", eStatgrabException);
+	eStatgrabOpenError = rb_define_class_under(cStatgrab, "OpenError",
+			eStatgrabException);
+	eStatgrabOpendirError = rb_define_class_under(cStatgrab,
+			"OpendirError", eStatgrabException);
+	eStatgrabParseError = rb_define_class_under(cStatgrab,
+			"ParseError", eStatgrabException);
+	eStatgrabPdhaddError = rb_define_class_under(cStatgrab,
+			"PdhaddError", eStatgrabException);
+	eStatgrabPdhcollectError = rb_define_class_under(cStatgrab,
+			"PdhcollectError", eStatgrabException);
+	eStatgrabPdhopenError = rb_define_class_under(cStatgrab,
+			"PdhopenError", eStatgrabException);
+	eStatgrabPdhreadError = rb_define_class_under(cStatgrab,
+			"PdhreadError", eStatgrabException);
+	eStatgrabPermissionError = rb_define_class_under(cStatgrab,
+			"PermissionError", eStatgrabException);
+	eStatgrabPstatError = rb_define_class_under(cStatgrab,
+			"PstatError", eStatgrabException);
+	eStatgrabSetegidError = rb_define_class_under(cStatgrab,
+			"SetegidError", eStatgrabException);
+	eStatgrabSeteuidError = rb_define_class_under(cStatgrab,
+			"SeteuidError", eStatgrabException);
+	eStatgrabSetmntentError = rb_define_class_under(cStatgrab,
+			"SetmntentError", eStatgrabException);
+	eStatgrabSocketError = rb_define_class_under(cStatgrab,
+			"SocketError", eStatgrabException);
+	eStatgrabSwapctlError = rb_define_class_under(cStatgrab,
+			"SwapctlError", eStatgrabException);
+	eStatgrabSysconfError = rb_define_class_under(cStatgrab,
+			"SysconfError", eStatgrabException);
+	eStatgrabSysctlError = rb_define_class_under(cStatgrab,
+			"SysctlError", eStatgrabException);
+	eStatgrabSysctlbynameError = rb_define_class_under(cStatgrab,
+			"SysctlbynameError", eStatgrabException);
+	eStatgrabSysctlnametomibError = rb_define_class_under(cStatgrab,
+			"SysctlnametomibError", eStatgrabException);
+	eStatgrabUnameError = rb_define_class_under(cStatgrab,
+			"UnameError", eStatgrabException);
+	eStatgrabUnsupportedError = rb_define_class_under(cStatgrab,
+			"UnsupportedError", eStatgrabException);
+	eStatgrabXswVerMismatchError = rb_define_class_under(cStatgrab,
+			"XswVerMismatchError", eStatgrabException);
+
+	/*
+	 * Methods
+	 */
+	rb_define_method(cStatgrab, "initialize", statgrab_initialize, -2);
+
+	rb_define_method(cStatgrab, "cpu_stats", statgrab_cpu_stats, 0);
+	rb_define_alias(cStatgrab, "cpu", "cpu_stats");
+
+	rb_define_method(cStatgrab, "cpu_stats_diff",
+			statgrab_cpu_stats_diff, 0);
+	rb_define_alias(cStatgrab, "cpu_difference", "cpu_stats_diff");
+
+	rb_define_method(cStatgrab, "cpu_percents",
+			statgrab_cpu_percents, 0);
+
+	rb_define_method(cStatgrab, "disk_io_stats",
+			statgrab_disk_io_stats, 0);
+	rb_define_alias(cStatgrab, "disk_io", "disk_io_stats");
+
+	rb_define_method(cStatgrab, "disk_io_stats_diff",
+			statgrab_disk_io_stats_diff, 0);
+	rb_define_alias(cStatgrab, "disk_io_difference",
+			"disk_io_stats_diff");
+
+	rb_define_method(cStatgrab, "fs_stats", statgrab_fs_stats, 0);
+	rb_define_alias(cStatgrab, "fs", "fs_stats");
+	rb_define_alias(cStatgrab, "file_system", "fs_stats");
+
+	rb_define_method(cStatgrab, "host_info", statgrab_host_info, 0);
+	rb_define_alias(cStatgrab, "host", "host_info");
+	rb_define_alias(cStatgrab, "system", "host_info");
+
+	rb_define_method(cStatgrab, "load_stats", statgrab_load_stats, 0);
+	rb_define_alias(cStatgrab, "load", "load_stats");
+	rb_define_alias(cStatgrab, "loadavg", "load_stats");
+	rb_define_alias(cStatgrab, "load_average", "load_stats");
+	rb_define_alias(cStatgrab, "system_load", "load_stats");
+
+	rb_define_method(cStatgrab, "mem_stats", statgrab_mem_stats, 0);
+	rb_define_alias(cStatgrab, "memory", "mem_stats");
+
+	rb_define_method(cStatgrab, "swap_stats", statgrab_swap_stats, 0);
+	rb_define_alias(cStatgrab, "swap", "swap_stats");
+
+	rb_define_method(cStatgrab, "network_io_stats",
+			statgrab_network_io_stats, 0);
+	rb_define_alias(cStatgrab, "network_io", "network_io_stats");
+	rb_define_alias(cStatgrab, "net_io", "network_io_stats");
+	rb_define_alias(cStatgrab, "network", "network_io_stats");
+	rb_define_alias(cStatgrab, "net", "network_io_stats");
+
+	rb_define_method(cStatgrab, "network_io_stats_diff",
+			statgrab_network_io_stats_diff, 0);
+	rb_define_alias(cStatgrab, "network_io_difference",
+			"network_io_stats_diff");
+	rb_define_alias(cStatgrab, "network_difference",
+			"network_io_stats_diff");
+	rb_define_alias(cStatgrab, "net_difference",
+			"network_io_stats_diff");
+
+	rb_define_method(cStatgrab, "network_iface_stats",
+			statgrab_network_iface_stats, 0);
+	rb_define_alias(cStatgrab, "network_iface", "network_iface_stats");
+	rb_define_alias(cStatgrab, "net_iface", "network_iface_stats");
+	rb_define_alias(cStatgrab, "iface", "network_iface_stats");
+
+	rb_define_method(cStatgrab, "page_stats", statgrab_page_stats, 0);
+	rb_define_alias(cStatgrab, "page", "page_stats");
+	rb_define_alias(cStatgrab, "pages", "page_stats");
+
+	rb_define_method(cStatgrab, "page_stats_diff",
+			statgrab_page_stats_diff, 0);
+	rb_define_alias(cStatgrab, "page_difference", "page_stats_diff");
+
+	rb_define_method(cStatgrab, "process_stats",
+			statgrab_process_stats, 0);
+	rb_define_alias(cStatgrab, "process", "process_stats");
+	rb_define_alias(cStatgrab, "processes", "process_stats");
+	rb_define_alias(cStatgrab, "proc", "process_stats");
+	rb_define_alias(cStatgrab, "ps", "process_stats");
+
+	rb_define_method(cStatgrab, "process_count",
+			statgrab_process_count, 0);
+	rb_define_alias(cStatgrab, "proc_count", "process_count");
+
+	rb_define_method(cStatgrab, "user_stats",
+			statgrab_user_stats, 0);
+	rb_define_alias(cStatgrab, "users", "user_stats");
+}
+
+/*
+ * vim: ts=8 sw=8 noet
+ */