vmstat 1.0.0 → 1.1.0

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in vmstat.gemspec
 gemspec
+
+gem 'rb-fsevent', '~> 0.9.1' if RUBY_PLATFORM =~ /darwin/

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/README.md

@@ -7,17 +7,20 @@ This is a focused and fast library to get system information like:
 * _CPU_ (user, system, nice, idle)
 * _Load_ Average
 * _Disk_ (type, disk path, free bytes, total bytes, ...)
+* _Boot time_
 * _Current Task_ (used bytes and usage time *MAC OS X ONLY*)
 
 *It currently supports:*
 
 * FreeBSD
 * MacOS X
+* Linux (>= 2.6)
 
 *It might support (but not tested):*
 
 * OpenBSD
 * NetBSD
+* Older versions of linux
 
 ## Installation
 
@@ -35,10 +38,10 @@ Or install it yourself as:
 
 ## Usage
 
-Just require the library and make a snapshot or use the distinct methods to just capture parts of the statistics.
+Just require the library and make a snapshot or use the distinct methods to just capture parts of the statistics. For further information have a look at the [rdoc](http://rdoc.info/gems/vmstat/frames).
 
 	require "vmstat"
-	require "pp"
+	
 	Vmstat.snapshot # => #<Vmstat::Snapshot:0x007fe5f22df660
 	#	 @at=2012-10-09 21:48:57 +0200,
 	#	 @boot_time=2012-10-09 18:42:37 +0200,
@@ -136,6 +139,13 @@ Just require the library and make a snapshot or use the distinct methods to just
 	#	   user_time_ms=28,
 	#	   system_time_ms=83>>
 
+## Todo
+
+* Swap information
+* Reduce the number of memory information gatherd
+* Support more platforms (hp ux, aix, solaris, ...)
+* Server performance information (open file handles, cache sizes, ...)
+
 ## Contributing
 
 1. Fork it

data/ext/vmstat/extconf.rb

@@ -1,3 +1,60 @@
 require 'mkmf'
 
+# posix.h
+have_header 'unistd.h'
+have_func 'getpagesize'
+have_header 'stdlib.h'
+have_func 'getloadavg'
+
+# mach.h
+have_header 'mach/mach.h'
+have_header 'mach/mach_host.h'
+have_func 'host_processor_info'
+have_func 'mach_host_self'
+have_func 'mach_task_self'
+have_func 'vm_deallocate'
+have_func 'mach_error_string'
+have_func 'task_info'
+mach_headers = ['mach/mach.h', 'mach/mach_host.h']
+have_const 'KERN_SUCCESS', mach_headers
+have_const 'TASK_BASIC_INFO', mach_headers
+have_const 'HOST_VM_INFO', mach_headers
+have_const 'CPU_STATE_MAX', mach_headers
+have_const 'PROCESSOR_CPU_LOAD_INFO', mach_headers
+have_const 'CPU_STATE_USER', mach_headers
+have_const 'CPU_STATE_SYSTEM', mach_headers
+have_const 'CPU_STATE_NICE', mach_headers
+have_const 'CPU_STATE_IDLE', mach_headers
+
+# statfs.h
+have_header 'sys/param.h'
+have_header 'sys/mount.h'
+have_header 'sys/statfs.h'
+have_func 'statfs'
+
+# sysctl.h
+sys_headers = ['unistd.h', 'sys/sysctl.h', 'sys/types.h', 'sys/socket.h',
+           'net/if.h', 'net/if_mib.h', 'net/if_types.h']
+sys_headers.each { |header| have_header header }
+have_func 'getloadavg'
+have_func 'sysctl'
+have_type 'struct ifmibdata', sys_headers
+have_const 'CTL_NET', sys_headers
+have_const 'PF_LINK', sys_headers
+have_const 'NETLINK_GENERIC', sys_headers
+have_const 'IFMIB_IFDATA', sys_headers
+have_const 'IFDATA_GENERAL', sys_headers
+have_const 'CTL_KERN', sys_headers
+have_const 'KERN_BOOTTIME', sys_headers
+
+# bsd.h
+# only if we have *bsd like stats check for sysctlbyname
+if xsystem 'sysctl vm.stats.vm.v_page_size'
+  have_header 'sys/sysctl.h'
+  have_header 'sys/types.h'
+  have_func 'sysctlbyname'
+end
+
+create_header
+
 create_makefile 'vmstat/vmstat'

data/ext/vmstat/hw/bsd.h

@@ -0,0 +1,88 @@
+#if defined(HAVE_SYS_SYSCTL_H) && defined(HAVE_SYS_TYPES_H) && \
+    defined(HAVE_SYSCTLBYNAME)
+#include <vmstat.h>
+#include <sys/sysctl.h>
+#include <sys/types.h>
+
+// helper methods
+int system_int(const char *);
+unsigned long long system_ull(const char *);
+
+typedef struct {
+  long user;
+  long nice;
+  long system;
+  long intr;
+  long idle;
+} cpu_time_t;
+
+#ifndef VMSTAT_CPU
+#define VMSTAT_CPU
+VALUE vmstat_cpu(VALUE self) {
+  VALUE cpus = rb_ary_new();
+  int cpu_count = system_int("hw.ncpu");
+  size_t len = sizeof(cpu_time_t) * cpu_count;
+  cpu_time_t * cp_times = ALLOC_N(cpu_time_t, cpu_count);
+  cpu_time_t * cp_time;
+  int i;
+  
+  if (sysctlbyname("kern.cp_times", cp_times, &len, NULL, 0) == 0) {
+    for (i = 0; i < cpu_count; i++) {
+      cp_time = &cp_times[i];
+      VALUE cpu = rb_funcall(rb_path2class("Vmstat::Cpu"),
+                  rb_intern("new"), 5, ULL2NUM(i),
+                                       ULL2NUM(cp_time->user),
+                                       ULL2NUM(cp_time->system + cp_time->intr),
+                                       ULL2NUM(cp_time->nice),
+                                       ULL2NUM(cp_time->idle));
+      rb_ary_push(cpus, cpu);
+    }
+  }
+
+  free(cp_times);
+  
+  return cpus;
+}
+#endif
+
+#ifndef VMSTAT_MEMORY
+#define VMSTAT_MEMORY
+VALUE vmstat_memory(VALUE self) {
+  VALUE memory = rb_funcall(rb_path2class("Vmstat::Memory"),
+                 rb_intern("new"), 15, ULL2NUM(system_ull("vm.stats.vm.v_page_size")),
+                                       ULL2NUM(system_ull("vm.stats.vm.v_active_count")),
+                                       ULL2NUM(system_ull("vm.stats.vm.v_wire_count")),
+                                       ULL2NUM(system_ull("vm.stats.vm.v_inactive_count")),
+                                       ULL2NUM(system_ull("vm.stats.vm.v_free_count")),
+                                       ULL2NUM(Qnil),
+                                       ULL2NUM(Qnil),
+                                       ULL2NUM(system_ull("vm.stats.misc.zero_page_count")),
+                                       ULL2NUM(system_ull("vm.stats.vm.v_reactivated")),
+                                       ULL2NUM(Qnil),
+                                       ULL2NUM(Qnil),
+                                       ULL2NUM(system_ull("vm.stats.vm.v_vm_faults")),
+                                       ULL2NUM(system_ull("vm.stats.vm.v_cow_faults")),
+                                       ULL2NUM(Qnil),
+                                       ULL2NUM(Qnil));
+  return memory;
+}
+
+int system_int(const char * name) {
+  int number;
+  size_t number_size = sizeof(number);
+  sysctlbyname(name, &number, &number_size, NULL, 0);
+  return number;
+}
+
+unsigned long long system_ull(const char * name) {
+  long number;
+  size_t number_size = sizeof(number);
+  if (sysctlbyname(name, &number, &number_size, NULL, 0) == -1) {
+    perror("sysctlbyname");
+    return -1;
+  } else {
+    return number;
+  }
+}
+#endif
+#endif

data/ext/vmstat/hw/mach.h

@@ -0,0 +1,107 @@
+#if defined(HAVE_MACH_MACH_H)
+#include <vmstat.h>
+#include <mach/mach.h>
+#include <mach/mach_host.h>
+
+#ifndef VMSTAT_CPU
+#define VMSTAT_CPU
+VALUE vmstat_cpu(VALUE self) {
+  VALUE cpus = rb_ary_new();
+  processor_info_array_t cpuInfo;
+  mach_msg_type_number_t numCpuInfo;
+  natural_t numCPUsU = 0U;
+  kern_return_t err = host_processor_info(mach_host_self(),
+    PROCESSOR_CPU_LOAD_INFO, &numCPUsU, &cpuInfo, &numCpuInfo);
+
+  if(err == KERN_SUCCESS) {
+    unsigned i;
+
+    for(i = 0U; i < numCPUsU; ++i) {
+      int pos = CPU_STATE_MAX * i;
+      VALUE cpu = rb_funcall(rb_path2class("Vmstat::Cpu"),
+                  rb_intern("new"), 5, ULL2NUM(i),
+                                       ULL2NUM(cpuInfo[pos + CPU_STATE_USER]),
+                                       ULL2NUM(cpuInfo[pos + CPU_STATE_SYSTEM]),
+                                       ULL2NUM(cpuInfo[pos + CPU_STATE_NICE]),
+                                       ULL2NUM(cpuInfo[pos + CPU_STATE_IDLE]));
+      rb_ary_push(cpus, cpu);
+    }
+
+    err = vm_deallocate(mach_task_self(), (vm_address_t)cpuInfo,
+                        (vm_size_t)sizeof(*cpuInfo) * numCpuInfo);
+    if (err != KERN_SUCCESS) {
+      rb_bug("vm_deallocate: %s\n", mach_error_string(err));
+    }
+  }
+  
+  return cpus;
+}
+#endif
+
+#ifndef VMSTAT_MEMORY
+#define VMSTAT_MEMORY
+VALUE vmstat_memory(VALUE self) {
+  VALUE memory = Qnil;
+  vm_size_t pagesize;
+  uint host_count = HOST_VM_INFO_COUNT;
+  kern_return_t err;
+  vm_statistics_data_t vm_stat;
+  
+  err = host_page_size(mach_host_self(), &pagesize);
+  if (err == KERN_SUCCESS) {
+    err = host_statistics(mach_host_self(), HOST_VM_INFO,
+                          (host_info_t)&vm_stat, &host_count);
+    if (err == KERN_SUCCESS) {
+      memory = rb_funcall(rb_path2class("Vmstat::Memory"),
+               rb_intern("new"), 15, ULL2NUM(pagesize),
+                                     ULL2NUM(vm_stat.active_count),
+                                     ULL2NUM(vm_stat.inactive_count),
+                                     ULL2NUM(vm_stat.wire_count),
+                                     ULL2NUM(vm_stat.free_count),
+                                     ULL2NUM(vm_stat.pageins),
+                                     ULL2NUM(vm_stat.pageouts),
+                                     ULL2NUM(vm_stat.zero_fill_count),
+                                     ULL2NUM(vm_stat.reactivations),
+                                     ULL2NUM(vm_stat.purgeable_count),
+                                     ULL2NUM(vm_stat.purges),
+                                     ULL2NUM(vm_stat.faults),
+                                     ULL2NUM(vm_stat.cow_faults),
+                                     ULL2NUM(vm_stat.lookups),
+                                     ULL2NUM(vm_stat.hits));
+    }
+
+    err = vm_deallocate(mach_task_self(), (vm_address_t)pagesize,
+                        (vm_size_t)host_count);
+    if (err != KERN_SUCCESS) {
+      rb_bug("vm_deallocate: %s\n", mach_error_string(err));
+    }
+  }
+
+  return memory;
+}
+#endif
+
+#ifndef VMSTAT_TASK
+#define VMSTAT_TASK
+VALUE vmstat_task(VALUE self) {
+  VALUE task = Qnil;
+  struct task_basic_info info;
+  kern_return_t err;
+  mach_msg_type_number_t size = sizeof(info);
+
+  err = task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&info, &size);
+  if (err == KERN_SUCCESS) {
+    task = rb_funcall(rb_path2class("Vmstat::Task"),
+           rb_intern("new"), 5, LONG2NUM(info.suspend_count),
+                                LONG2NUM(info.virtual_size),
+                                LONG2NUM(info.resident_size),
+                                LONG2NUM(info.user_time.seconds * 1000 + info.user_time.microseconds),
+                                LONG2NUM(info.system_time.seconds * 1000 + info.system_time.microseconds));
+  } else {
+    rb_bug("task_info: %s\n", mach_error_string(err));
+  }
+
+  return task;
+}
+#endif
+#endif

data/ext/vmstat/hw/posix.h

@@ -0,0 +1,29 @@
+#if defined(HAVE_UNISTD_H) && defined(HAVE_GETPAGESIZE)
+#include <unistd.h>
+
+#ifndef VMSTAT_PAGESIZE
+#define VMSTAT_PAGESIZE
+VALUE vmstat_pagesize(VALUE self) {
+  return INT2NUM(getpagesize());
+}
+#endif
+#endif
+
+#if defined(HAVE_STDLIB_H) && defined(HAVE_GETLOADAVG)
+#ifndef VMSTAT_LOAD_AVERAGE
+#define VMSTAT_LOAD_AVERAGE
+VALUE vmstat_load_average(VALUE self) {
+  VALUE load = Qnil;
+  double loadavg[AVGCOUNT];
+
+  getloadavg(&loadavg[0], AVGCOUNT);
+
+  load = rb_funcall(rb_path2class("Vmstat::LoadAverage"),
+         rb_intern("new"), 3, rb_float_new(loadavg[0]),
+                              rb_float_new(loadavg[1]),
+                              rb_float_new(loadavg[2]));
+
+  return load;
+}
+#endif
+#endif

data/ext/vmstat/hw/statfs.h

@@ -0,0 +1,41 @@
+#if defined(HAVE_SYS_PARAM_H) && defined(HAVE_SYS_MOUNT_H) && defined(HAVE_STATFS)
+#include <vmstat.h>
+#include <sys/param.h>
+#include <sys/mount.h>
+
+// on linux require statfs too
+#if defined(HAVE_SYS_STATFS_H)
+#include <sys/statfs.h>
+#endif
+
+#ifndef VMSTAT_DISK
+#define VMSTAT_DISK
+VALUE vmstat_disk(VALUE self, VALUE path) {
+  VALUE disk = Qnil;
+  struct statfs stat;
+
+  if (statfs(StringValueCStr(path), &stat) != -1) {
+#if defined(HAVE_SYS_STATFS_H)
+    disk = rb_funcall(rb_path2class("Vmstat::LinuxDisk"),
+           rb_intern("new"), 6, ULL2NUM(stat.f_type),
+                                path,
+                                ULL2NUM(stat.f_bsize),
+                                ULL2NUM(stat.f_bfree),
+                                ULL2NUM(stat.f_bavail),
+                                ULL2NUM(stat.f_blocks));
+#else
+    disk = rb_funcall(rb_path2class("Vmstat::Disk"),
+           rb_intern("new"), 7, ID2SYM(rb_intern(stat.f_fstypename)),
+                                rb_str_new(stat.f_mntfromname, strlen(stat.f_mntfromname)),
+                                rb_str_new(stat.f_mntonname, strlen(stat.f_mntonname)),
+                                ULL2NUM(stat.f_bsize),
+                                ULL2NUM(stat.f_bfree),
+                                ULL2NUM(stat.f_bavail),
+                                ULL2NUM(stat.f_blocks));
+#endif
+  }
+
+  return disk;
+}
+#endif
+#endif

data/ext/vmstat/hw/sysctl.h

@@ -0,0 +1,72 @@
+#if defined(HAVE_SYS_SYSCTL_H) && \
+    defined(HAVE_SYS_TYPES_H) && \
+    defined(HAVE_SYS_SOCKET_H) && \
+    defined(HAVE_NET_IF_H) && \
+    defined(HAVE_NET_IF_MIB_H) && \
+    defined(HAVE_NET_IF_TYPES_H) && \
+    defined(HAVE_GETLOADAVG) && \
+    defined(HAVE_SYSCTL) && \
+    defined(HAVE_TYPE_STRUCT_IFMIBDATA) && \
+    defined(HAVE_CONST_CTL_NET) && \
+    defined(HAVE_CONST_PF_LINK) && \
+    defined(HAVE_CONST_NETLINK_GENERIC) && \
+    defined(HAVE_CONST_IFMIB_IFDATA) && \
+    defined(HAVE_CONST_IFDATA_GENERAL) && \
+    defined(HAVE_CONST_CTL_KERN) && \
+    defined(HAVE_CONST_KERN_BOOTTIME)
+#include <vmstat.h>
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#include <net/if_mib.h>
+#include <net/if_types.h>
+
+#ifndef VMSTAT_NETWORK_INTERFACES
+#define VMSTAT_NETWORK_INTERFACES
+VALUE vmstat_network_interfaces(VALUE self) {
+  VALUE devices = rb_ary_new();
+  int i, err;
+  struct ifmibdata mibdata;
+  size_t len = sizeof(mibdata);
+  int ifmib_path[] = {
+    CTL_NET, PF_LINK, NETLINK_GENERIC, IFMIB_IFDATA, -1, IFDATA_GENERAL
+  };
+
+  for (i = 1, err = 0; err == 0; i++) {
+    ifmib_path[4] = i; // set the current row
+    err = sysctl(ifmib_path, 6, &mibdata, &len, NULL, 0);
+    if (err == 0) {
+      VALUE device = rb_funcall(rb_path2class("Vmstat::NetworkInterface"),
+                     rb_intern("new"), 7, ID2SYM(rb_intern(mibdata.ifmd_name)),
+                                          ULL2NUM(mibdata.ifmd_data.ifi_ibytes),
+                                          ULL2NUM(mibdata.ifmd_data.ifi_ierrors),
+                                          ULL2NUM(mibdata.ifmd_data.ifi_iqdrops),
+                                          ULL2NUM(mibdata.ifmd_data.ifi_obytes),
+                                          ULL2NUM(mibdata.ifmd_data.ifi_oerrors),
+                                          ULL2NUM(mibdata.ifmd_data.ifi_type));
+
+      rb_ary_push(devices, device);
+    }
+  }
+
+  return devices;
+}
+#endif
+
+#ifndef VMSTAT_BOOT_TIME
+#define VMSTAT_BOOT_TIME
+static int BOOT_TIME_MIB[] = { CTL_KERN, KERN_BOOTTIME };
+
+VALUE vmstat_boot_time(VALUE self) {
+  struct timeval tv;
+  size_t size = sizeof(tv);
+
+  if (sysctl(BOOT_TIME_MIB, 2, &tv, &size, NULL, 0) == 0) {
+    return rb_time_new(tv.tv_sec, tv.tv_usec);
+  } else {
+    return Qnil;
+  }
+}
+#endif
+#endif