riemann-babbler 1.0.8.8 → 1.1.0pre2

data/.gitignore

@@ -2,3 +2,4 @@ pkg/
 .idea
 .rvmrc
 *.swp
+Makefile

data/Gemfile

@@ -6,9 +6,8 @@ gem 'logger'
 gem 'trollop'
 gem 'sys-filesystem'
 gem 'rest-client'
+gem 'sequel'
 gem 'net-ping'
-gem 'file-tail'
-gem 'sys-proctable'
 
 gem 'rspec'
 gem 'rake'

data/Gemfile.lock

@@ -8,8 +8,6 @@ GEM
       yamler (>= 0.1.0)
     diff-lcs (1.2.2)
     ffi (1.4.0)
-    file-tail (1.0.12)
-      tins (~> 0.5)
     logger (1.2.8)
     method_source (0.8.1)
     mime-types (1.21)
@@ -35,11 +33,10 @@ GEM
     rspec-expectations (2.13.0)
       diff-lcs (>= 1.1.3, < 2.0)
     rspec-mocks (2.13.0)
+    sequel (3.46.0)
     slop (3.4.3)
     sys-filesystem (1.1.0)
       ffi
-    sys-proctable (0.9.3)
-    tins (0.8.0)
     trollop (2.0)
     yamler (0.1.0)
 
@@ -49,7 +46,6 @@ PLATFORMS
 DEPENDENCIES
   awesome_print
   configatron
-  file-tail
   logger
   net-ping
   pry
@@ -57,6 +53,6 @@ DEPENDENCIES
   rest-client
   riemann-client
   rspec
+  sequel
   sys-filesystem
-  sys-proctable
   trollop

data/README.md

@@ -1,5 +1,13 @@
 [![Build Status](https://travis-ci.org/vadv/riemann-babbler.png)](https://travis-ci.org/vadv/riemann-babbler)
 
+### Beware!
+Currently I'm working on c-ext from zabbix. 
+It's not all fully working :)
+Use stable gem please!
+```
+gem "riemann-babbler", "~> 1.0.7.3"
+```
+
 ### Install
 ```
 gem install riemann-babbler

data/Rakefile

@@ -1 +1,14 @@
+require 'rspec/core/rake_task'
 require 'bundler/gem_tasks'
+
+RSpec::Core::RakeTask.new('spec')
+task :build do
+  Dir.chdir('ext/sysinfo') do
+    output = `ruby extconf.rb`
+    raise output unless $? == 0
+    output = `make`
+    raise output unless $? == 0
+  end
+end
+
+task :spec => :build

data/bin/riemann-babbler

@@ -1,12 +1,11 @@
 #!/usr/bin/env ruby
-# coding: utf-8
+#encoding: utf-8
 
 require 'trollop'
 require 'configatron'
 
-$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-require 'riemann/babbler/version'
-require 'riemann/babbler/start'
+require File.expand_path('../../lib/riemann/version', __FILE__)
+require File.expand_path('../../lib/start', __FILE__)
 
 opts = Trollop::options do
   version "Riemann babbler #{Riemann::Babbler::VERSION}"

data/config.yml

@@ -40,6 +40,7 @@ plugins:
 
   net:
     service: net
+    interval: 60
 
   cpufan:
     service: cpufan
@@ -56,9 +57,6 @@ plugins:
   megacli:
     service: megacli
 
-  twcli:
-    interval: 300
-
   nginx:
     service: nginx
 

data/ext/sysinfo/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('sysinfo/sysinfo')

data/ext/sysinfo/sysinfo.c

@@ -0,0 +1,476 @@
+#include "sysinfo.h"
+#include <ruby.h>
+#include <sys/sysinfo.h>
+#include <sys/statvfs.h>
+
+/*  Begin FS Part  */
+static void	get_fs_size_stat(const char *fs, uint64_t *total, uint64_t *free,
+		uint64_t *used, double *pfree, double *pused)
+{
+	struct statvfs	s;
+
+	if (0 != statvfs(fs, &s))
+		rb_raise(rb_eRuntimeError, "statvfs call");
+
+	if (total)
+		*total = (uint64_t)s.f_blocks * s.f_frsize;
+	if (free)
+		*free = (uint64_t)s.f_bavail * s.f_frsize;
+	if (used)
+		*used = (uint64_t)(s.f_blocks - s.f_bfree) * s.f_frsize;
+	if (pfree)
+	{
+		if (0 != s.f_blocks - s.f_bfree + s.f_bavail)
+			*pfree = (double)(100.0 * s.f_bavail) /
+					(s.f_blocks - s.f_bfree + s.f_bavail);
+		else
+			*pfree = 0;
+	}
+	if (pused)
+	{
+		if (0 != s.f_blocks - s.f_bfree + s.f_bavail)
+			*pused = 100.0 - (double)(100.0 * s.f_bavail) /
+					(s.f_blocks - s.f_bfree + s.f_bavail);
+		else
+			*pused = 0;
+	}
+}
+
+static int	VFS_FS_USED(VALUE self, VALUE mount)
+{
+	uint64_t	value = 0;
+	get_fs_size_stat(RSTRING_PTR(mount), NULL, NULL, &value, NULL, NULL);
+	return INT2NUM(value);
+}
+
+static int	VFS_FS_TOTAL(VALUE self, VALUE mount)
+{
+	uint64_t	value = 0;
+	get_fs_size_stat(RSTRING_PTR(mount), &value, NULL, NULL, NULL, NULL);
+	return INT2NUM(value);
+}
+
+static int	VFS_FS_FREE(VALUE self, VALUE mount)
+{
+	uint64_t	value = 0;
+	get_fs_size_stat(RSTRING_PTR(mount), NULL, &value, NULL, NULL, NULL);
+	return INT2NUM(value);
+}
+
+static int	VFS_FS_PFREE(VALUE self, VALUE mount)
+{
+	double	value = 0;
+	get_fs_size_stat(RSTRING_PTR(mount), NULL, NULL, NULL, &value, NULL);
+	return rb_float_new(value);
+}
+
+static int	VFS_FS_PUSED(VALUE self, VALUE mount)
+{
+	double	value = 0;
+	get_fs_size_stat(RSTRING_PTR(mount), NULL, NULL, NULL, NULL, &value);
+	return INT2NUM(value);
+}
+
+/* ---------- INODE ---------- */
+union _val {
+  unsigned long long ul_val;
+  double d_val;
+};
+
+static void get_fs_inodes_stat(const char *fs, int type,union  _val * val)
+{
+  struct statvfs   s;
+  if ( statvfs( fs, &s) != 0 )
+  {
+    rb_raise(rb_eRuntimeError, "statvfs call");
+  }
+  switch(type)
+  {
+    case 1: val->ul_val = (unsigned long long )(s.f_files); break;
+    case 2: val->ul_val  = (unsigned long long )(s.f_favail); break;
+    case 3: val->ul_val = (unsigned long long )(s.f_files - s.f_favail); break;
+    case 4:
+        	if (0 != s.f_files){
+            	val->d_val = (100.0 * (s.f_files - s.f_favail)) / s.f_files;
+        	} else
+            	*(double *)val = 0;
+            break;
+  }
+}
+
+static int	VFS_FS_INODE_PUSED(VALUE self, VALUE mount)
+{
+	union _val val;
+	get_fs_inodes_stat(RSTRING_PTR(mount), 4, &val );
+	return rb_float_new(val.d_val);
+}
+
+static int	VFS_FS_INODE_USED(VALUE self, VALUE mount)
+{
+	union _val val;
+	get_fs_inodes_stat(RSTRING_PTR(mount), 3, &val );
+	return INT2NUM(val.ul_val);
+}
+
+static int	VFS_FS_INODE_FREE(VALUE self, VALUE mount)
+{
+	union _val val;
+	get_fs_inodes_stat(RSTRING_PTR(mount), 2, &val );
+	return INT2NUM(val.ul_val);
+}
+
+static int	VFS_FS_INODE_TOTAL(VALUE self, VALUE mount)
+{
+	union _val val;
+	get_fs_inodes_stat(RSTRING_PTR(mount), 1, &val );
+	return INT2NUM(val.ul_val);
+}
+
+/*  End FS Part  */
+
+/* Begin Memory Part */
+static int	VM_MEMORY_CACHED(VALUE self)
+{
+	FILE	*f;
+	char	*t;
+	char	c[MAX_STRING_LEN];
+	uint64_t	res = 0;
+
+	if(NULL == (f = fopen("/proc/meminfo","r") ))
+	{
+		rb_raise(rb_eRuntimeError, "fail to read /proc/meminfo");
+	}
+	while(NULL!=fgets(c,MAX_STRING_LEN,f))
+	{
+		if(strncmp(c,"Cached:",7) == 0)
+		{
+			t=(char *)strtok(c," ");
+			t=(char *)strtok(NULL," ");
+			sscanf(t, FS_UI64, &res );
+			t=(char *)strtok(NULL," ");
+
+			if(strcasecmp(t,"kb"))		res <<= 10;
+			else if(strcasecmp(t, "mb"))	res <<= 20;
+			else if(strcasecmp(t, "gb"))	res <<= 30;
+			else if(strcasecmp(t, "tb"))	res <<= 40;
+
+			break;
+		}
+	}
+	fclose(f);
+	return INT2NUM(res);
+}
+
+static int	VM_MEMORY_BUFFERS(VALUE self)
+{
+	struct sysinfo info;
+	if( 0 == sysinfo(&info))
+	{
+		return INT2NUM(info.bufferram);
+	}
+	else
+		rb_raise(rb_eRuntimeError, "sysinfo call");
+}
+
+static int	VM_MEMORY_SHARED(VALUE self)
+{
+	struct sysinfo info;
+	if( 0 == sysinfo(&info))
+	{
+		return INT2NUM(info.sharedram);
+	}
+	else
+		rb_raise(rb_eRuntimeError, "sysinfo call");
+}
+
+static int	VM_MEMORY_TOTAL(VALUE self)
+{
+	struct sysinfo info;
+	if( 0 == sysinfo(&info))
+	{
+		return INT2NUM(info.totalram);
+	}
+	else
+		rb_raise(rb_eRuntimeError, "sysinfo call");
+}
+
+static int	VM_MEMORY_FREE(VALUE self)
+{
+	struct sysinfo info;
+	if( 0 == sysinfo(&info))
+	{
+		return INT2NUM(info.freeram);
+	}
+	else
+		rb_raise(rb_eRuntimeError, "sysinfo call");
+}
+static int      VM_MEMORY_AVAILABLE(VALUE self)
+{
+	struct sysinfo info;
+	if( 0 == sysinfo(&info))
+	{
+		return INT2NUM(info.freeram + info.bufferram + VM_MEMORY_CACHED(self));
+	}
+	else
+		rb_raise(rb_eRuntimeError, "sysinfo call");
+}
+/* End Memory Part */
+
+/* Begin Net Part */
+typedef struct
+{
+	uint64_t ibytes;
+	uint64_t ipackets;
+	uint64_t ierr;
+	uint64_t idrop;
+	uint64_t obytes;
+	uint64_t opackets;
+	uint64_t oerr;
+	uint64_t odrop;
+	uint64_t colls;
+}
+net_stat_t;
+
+
+static void	get_net_stat(const char *if_name, net_stat_t *result)
+{
+	char line[MAX_STRING_LEN];
+	char name[MAX_STRING_LEN];
+
+	uint64_t tmp = 0;
+
+	FILE *f;
+	char	*p;
+
+	if(NULL != (f = fopen("/proc/net/dev","r") ))
+	{
+		while(fgets(line,MAX_STRING_LEN,f) != NULL)
+		{
+			p = strstr(line,":");
+			if(p) p[0]='\t';
+
+			if(sscanf(line,"%s\t" FS_UI64 "\t" FS_UI64 "\t" FS_UI64 "\t" FS_UI64 "\t" FS_UI64 "\t"
+					FS_UI64 "\t" FS_UI64 "\t" FS_UI64 "\t \
+					" FS_UI64 "\t" FS_UI64 "\t" FS_UI64 "\t" FS_UI64 "\t" FS_UI64 "\t"
+					FS_UI64 "\t" FS_UI64 "\t" FS_UI64 "\n",
+				name,
+				&(result->ibytes),	/* bytes */
+				&(result->ipackets),	/* packets */
+				&(result->ierr),	/* errs */
+				&(result->idrop),	/* drop */
+				&(tmp),			/* fifo */
+				&(tmp),			/* frame */
+				&(tmp),			/* compressed */
+				&(tmp),			/* multicast */
+				&(result->obytes),	/* bytes */
+				&(result->opackets),	/* packets*/
+				&(result->oerr),	/* errs */
+				&(result->odrop),	/* drop */
+				&(tmp),			/* fifo */
+				&(result->colls),	/* icolls */
+				&(tmp),			/* carrier */
+				&(tmp)			/* compressed */
+				) == 17)
+			{
+				if(strncmp(name, if_name, MAX_STRING_LEN) == 0)
+				{
+					break;
+				}
+			}
+		}
+		fclose(f);
+	}
+}
+
+int	NET_IF_IN(VALUE self, VALUE my_if_name, VALUE my_mode)
+{
+	net_stat_t	ns;
+
+	char *if_name = RSTRING_PTR(my_if_name);
+	char *mode = RSTRING_PTR(my_mode);
+
+	get_net_stat(if_name, &ns);
+	if(strncmp(mode, "bytes", MAX_STRING_LEN) == 0)
+	{
+		return INT2NUM(ns.ibytes);
+	}
+	else if(strncmp(mode, "packets", MAX_STRING_LEN) == 0)
+	{
+		return INT2NUM(ns.ipackets);
+	}
+	else if(strncmp(mode, "errors", MAX_STRING_LEN) == 0)
+	{
+		return INT2NUM(ns.ierr);
+	}
+	else if(strncmp(mode, "dropped", MAX_STRING_LEN) == 0)
+	{
+		return INT2NUM(ns.idrop);
+	}
+	else
+		rb_raise(rb_eRuntimeError, "give me mode");
+}
+
+int	NET_IF_OUT(VALUE self, VALUE my_if_name, VALUE my_mode)
+{
+	net_stat_t	ns;
+
+	char *if_name = RSTRING_PTR(my_if_name);
+	char *mode = RSTRING_PTR(my_mode);
+
+	get_net_stat(if_name, &ns);
+
+	if (strncmp(mode, "bytes", MAX_STRING_LEN) == 0)
+	{
+		return INT2NUM(ns.obytes);
+	}
+	else if(strncmp(mode, "packets", MAX_STRING_LEN) == 0)
+	{
+		return INT2NUM(ns.opackets);
+	}
+	else if(strncmp(mode, "errors", MAX_STRING_LEN) == 0)
+	{
+		return INT2NUM(ns.oerr);
+	}
+	else if(strncmp(mode, "dropped", MAX_STRING_LEN) == 0)
+	{
+		return INT2NUM(ns.odrop);
+	}
+	else
+		rb_raise(rb_eRuntimeError, "give me mode");
+}
+
+int	NET_IF_TOTAL(VALUE self, VALUE my_if_name, VALUE my_mode)
+{
+	net_stat_t	ns;
+
+	char *if_name = RSTRING_PTR(my_if_name);
+	char *mode = RSTRING_PTR(my_mode);
+
+	get_net_stat(if_name, &ns);
+	if(strncmp(mode, "bytes", MAX_STRING_LEN) == 0)
+	{
+		return INT2NUM(ns.obytes + ns.ibytes);
+	}
+	else if(strncmp(mode, "packets", MAX_STRING_LEN) == 0)
+	{
+		return INT2NUM(ns.opackets + ns.ipackets);
+	}
+	else if(strncmp(mode, "errors", MAX_STRING_LEN) == 0)
+	{
+		return INT2NUM(ns.oerr + ns.ierr);
+	}
+	else if(strncmp(mode, "dropped", MAX_STRING_LEN) == 0)
+	{
+		return INT2NUM(ns.odrop + ns.idrop);
+	}
+	else
+		rb_raise(rb_eRuntimeError, "give me mode");
+}
+
+int	NET_IF_COLLISIONS(VALUE self, VALUE my_if_name)
+{
+	net_stat_t	ns;
+	char *if_name = RSTRING_PTR(my_if_name);
+
+	get_net_stat(if_name, &ns);
+	return INT2NUM(ns.odrop);
+}
+
+/* End Net Part */
+
+/* Begin Cpu Part */
+int SYSTEM_CPU_SWITCHES(VALUE self)
+{
+	char		line[MAX_STRING_LEN], name[32];
+	uint64_t	value = 0;
+	FILE		*f;
+
+	if (NULL == (f = fopen("/proc/stat", "r")))
+		rb_raise(rb_eRuntimeError, "Can't open /proc/stat");
+
+	while (NULL != fgets(line, sizeof(line), f))
+	{
+		if (2 != sscanf(line, "%s " FS_UI64, name, &value))
+			continue;
+
+		if (0 == strcmp(name, "ctxt"))
+		{
+			return INT2NUM(value);
+			break;
+		}
+	}
+	fclose(f);
+}
+/* End Cpu Part */
+
+void Init_sysinfo(void) {
+ 
+  VALUE mSI = rb_define_module("SysInfo");
+  VALUE mFS = rb_define_module_under(mSI, "FS");
+  VALUE cBlock = rb_define_class_under(mFS, "Block", rb_cObject);
+  VALUE cInode = rb_define_class_under(mFS, "Inode", rb_cObject);
+  VALUE cMem = rb_define_class_under(mSI, "Memory", rb_cObject);
+  VALUE cNet = rb_define_class_under(mSI, "Net", rb_cObject);
+  VALUE cCpu = rb_define_class_under(mSI, "Cpu", rb_cObject);
+
+  rb_define_singleton_method(cBlock,
+    "used", VFS_FS_USED, 1);
+
+  rb_define_singleton_method(cBlock,
+    "free", VFS_FS_FREE, 1);
+
+  rb_define_singleton_method(cBlock,
+    "total", VFS_FS_TOTAL, 1);
+
+  rb_define_singleton_method(cBlock,
+    "pfree", VFS_FS_PFREE, 1);
+
+  rb_define_singleton_method(cBlock,
+    "pused", VFS_FS_PUSED, 1);
+
+  rb_define_singleton_method(cInode,
+    "used", VFS_FS_INODE_USED, 1);
+
+  rb_define_singleton_method(cInode,
+    "free", VFS_FS_INODE_FREE, 1);
+
+  rb_define_singleton_method(cInode,
+    "total", VFS_FS_INODE_TOTAL, 1);
+
+  rb_define_singleton_method(cInode,
+    "pused", VFS_FS_INODE_PUSED, 1);
+
+  rb_define_singleton_method(cMem,
+    "cached", VM_MEMORY_CACHED, 0);
+
+  rb_define_singleton_method(cMem,
+    "buffers", VM_MEMORY_BUFFERS, 0);
+
+  rb_define_singleton_method(cMem,
+    "shared", VM_MEMORY_SHARED, 0);
+
+  rb_define_singleton_method(cMem,
+    "total", VM_MEMORY_TOTAL, 0);
+
+  rb_define_singleton_method(cMem,
+    "free", VM_MEMORY_FREE, 0);
+
+  rb_define_singleton_method(cMem,
+    "avaiable", VM_MEMORY_AVAILABLE, 0);
+
+  rb_define_singleton_method(cNet,
+    "in", NET_IF_IN, 2);
+
+  rb_define_singleton_method(cNet,
+    "out", NET_IF_OUT, 2);
+
+  rb_define_singleton_method(cNet,
+    "total", NET_IF_TOTAL, 2);
+
+  rb_define_singleton_method(cNet,
+    "collisions", NET_IF_COLLISIONS, 1);
+
+  rb_define_singleton_method(cCpu,
+    "switches", SYSTEM_CPU_SWITCHES, 0);  
+
+}

data/ext/sysinfo/sysinfo.h

@@ -0,0 +1,2 @@
+#define MAX_STRING_LEN		2048
+#define FS_UI64 "%I64u"

data/lib/riemann/{babbler.rb → babbler/plugin.rb}

@@ -1,14 +1,15 @@
-# encoding: utf-8
+#encoding: utf-8
 
-require 'riemann/babbler/support/plugin_helpers'
+require File.expand_path('../support/plugin_helpers', __FILE__)
 require 'riemann/client'
 require 'open3'
 require 'timeout'
 require 'rest_client'
 require 'socket'
 require 'net/ping'
-require 'file/tail'
-require 'riemann/babbler/support/monkey_patches'
+require 'sequel'
+require 'riemann/babbler/sysinfo'
+require File.expand_path('../support/monkey_patches', __FILE__)
 
 
 # Базовое описание плагина
@@ -65,9 +66,9 @@ module Riemann
     def report_with_diff(event)
       current_metric = event[:metric]
       if @storage.has_key?(event[:service])
-        unless current_metric + @storage[event[:service]] > 2**64
-          event[:metric] = current_metric - @storage[event[:service]]
-        end unless @storage[event[:service]].nil?
+        next if @storage[ event[:service] ].nil?
+        next if current_metric + @storage[ event[:service] ] > 2**64
+        event[:metric] = current_metric - @storage[ event[:service] ]
       end
       @storage[ event[:service] ] = current_metric
       event.delete(:as_diff)
@@ -100,7 +101,7 @@ module Riemann
       if plugin.run.nil?
         true
       else
-        plugin.run ? true : false
+        plugin.run == true ? true : false
       end
     end
 

data/lib/riemann/babbler/plugins/cpu.rb

@@ -2,17 +2,13 @@
 
 class Riemann::Babbler::Cpu < Riemann::Babbler
 
-  def desc
-    "#{shell('ps -eo pcpu,pid,cmd --sort -pcpu | head -3').chomp}"
-  end
-
   def init
     @old_cpu = Hash.new
   end
 
   def collect
     array = Array.new
-    description = desc
+    description = 'Cpu usage'
     File.read('/proc/stat').split("\n").each do |cpu_line|
 
       # проверяем есть строчка /cpu\d+/ или /cpu / и сграбливаем это в переменную

data/lib/riemann/babbler/plugins/{cpu_fan.rb → cpufan.rb}

@@ -1,4 +1,4 @@
-class Riemann::Babbler::CpuFan < Riemann::Babbler
+class Riemann::Babbler::Cpufan < Riemann::Babbler
 
   def init
     plugin.set_default(:service, 'cpufan')
@@ -13,7 +13,7 @@ class Riemann::Babbler::CpuFan < Riemann::Babbler
   end
 
   def collect
-    { :service => plugin.service, :metric => shell(plugin.cmd).to_i, :description => 'CPU Fan Speed'}
+    { :service => plugin.service, :metric => shell(plugin.cmd).to_i, :description => "CPU Fan Speed" }
   end
 
 end

data/lib/riemann/babbler/plugins/{cpu_temp.rb → cputemp.rb}

@@ -1,4 +1,4 @@
-class Riemann::Babbler::CpuTemp < Riemann::Babbler
+class Riemann::Babbler::Cputemp < Riemann::Babbler
 
   def init
     plugin.set_default(:service, 'cputemp')
@@ -13,7 +13,7 @@ class Riemann::Babbler::CpuTemp < Riemann::Babbler
   end
 
   def collect
-    { :service => plugin.service, :metric => shell(plugin.cmd).to_i, :description => 'CPU Temperature'}
+    { :service => plugin.service, :metric => shell(plugin.cmd).to_i, :description => "CPU Temperature" }
   end
 
 end

data/lib/riemann/babbler/plugins/disk.rb

@@ -2,9 +2,6 @@
 
 class Riemann::Babbler::Disk < Riemann::Babbler
 
-  require 'sys/filesystem'
-  include Sys
-
   NOT_MONITORING_FS = %w(sysfs nfs devpts squashfs proc devtmpfs)
 
   def collect
@@ -18,13 +15,12 @@ class Riemann::Babbler::Disk < Riemann::Babbler
     end
     disk = Array.new
     monit_points.each do |point|
-      point_stat = Filesystem.stat point
       human_point = point == '/' ? '/root' : point
       human_point = human_point.gsub(/^\//, '').gsub(/\//, '_')
-      disk << { :service => plugin.service + " #{human_point} % block", :description => "Disk usage #{point}, %", :metric => (1- point_stat.blocks_available.to_f/point_stat.blocks).round(2) * 100 } unless point_stat.blocks == 0
-      disk << { :service => plugin.service + " #{human_point} % inode", :description => "Disk usage #{point}, inodes %", :metric => (1 - point_stat.files_available.to_f/point_stat.files).round(2) * 100 } unless point_stat.files == 0
-      disk << { :service => plugin.service + " #{human_point} abs free", :description => "Disk free #{point}, B", :metric =>  point_stat.blocks_free * point_stat.block_size, :state => 'ok'}
-      disk << { :service => plugin.service + " #{human_point} abs total", :description => "Disk space #{point}, B",  :metric =>  point_stat.blocks * point_stat.block_size, :state => 'ok'}
+      disk << { :service => plugin.service + " #{human_point} % block", :description => "Disk usage #{point}, %", :metric => SysInfo::FS::Block.pused(point) }
+      disk << { :service => plugin.service + " #{human_point} % inode", :description => "Disk usage #{point}, inodes %", :metric => SysInfo::FS::Inode.pused(point)}
+      disk << { :service => plugin.service + " #{human_point} abs free", :description => "Disk free #{point}, B", :metric =>  SysInfo::FS::Block.total(point), :state => 'ok'}
+      disk << { :service => plugin.service + " #{human_point} abs total", :description => "Disk space #{point}, B",  :metric =>  SysInfo::FS::Inode.total(point), :state => 'ok'}
     end
     disk
   end

data/lib/riemann/babbler/plugins/exim4.rb

@@ -13,7 +13,7 @@ class Riemann::Babbler::Exim4 < Riemann::Babbler
   end
 
   def collect
-    { :service => plugin.service, :metric => shell(plugin.cmd).to_i, :description => 'Exim4: count frozen mails'}
+    { :service => plugin.service, :metric => shell(plugin.cmd).to_i, :description => "Exim4: count frozen mails" }
   end
 
 end

data/lib/riemann/babbler/plugins/http.rb

@@ -24,9 +24,9 @@ class Riemann::Babbler::Http < Riemann::Babbler
     command += " --max-time #{plugin.max_time} --fail"
     command += " #{plugin.url} -o /dev/null"
 
-    out = shell(command).to_i
+    out = shell(command)
 
-    if out != plugin.http_code
+    if out.to_i != plugin.http_code
       metric = 1
     else
       metric = 0

data/lib/riemann/babbler/plugins/mdadm.rb

@@ -14,8 +14,8 @@ class Riemann::Babbler::Mdadm < Riemann::Babbler
     file = File.read('/proc/mdstat').split("\n")
     status = Array.new
     file.each_with_index do |line, index|
-      next unless line.include? '_'
-      device = file[index-1].split(':')[0].strip
+      next unless line.include? "_"
+      device = file[index-1].split(":")[0].strip
       status << { :service => plugin.service + " #{device}", :metric => 1, :description => "mdadm failed device #{device}" }
     end
     status

data/lib/riemann/babbler/plugins/{mega_cli.rb → megacli.rb}

@@ -12,7 +12,7 @@ class Riemann::Babbler::MegaCli < Riemann::Babbler
   end
 
   def collect
-    {:service => plugin.service, :metric => shell(plugin.cmd).to_i, :description => 'MegaCli status'}
+    {:service => plugin.service, :metric => shell(plugin.cmd).to_i, :description => "MegaCli status" }
   end
 
 end

data/lib/riemann/babbler/plugins/memory.rb

@@ -3,31 +3,17 @@
 class Riemann::Babbler::Memory < Riemann::Babbler
 
   def collect
-    m = File.read('/proc/meminfo').split(/\n/).inject({}) { |info, line|
-      x = line.split(/:?\s+/)
-      info[x[0]] = x[1].to_i
-      info
-    }
-    free = m['MemFree'].to_i * 1024
-    cached =m['Cached'].to_i * 1024
-    buffers =m['Buffers'].to_i * 1024
-    total = m['MemTotal'].to_i * 1024
-    used = total - free
-    free_bc = free + buffers + cached
-
+    total = SysInfo::Memory.total
+    free_bc = SysInfo::Memory.free + SysInfo::Memory.buffers + SysInfo::Memory.cached
     fraction = 1 - (free_bc.to_f / total)
-    swap_fraction = m['SwapTotal'] == 0 ? 0 : 1 - m['SwapFree'].to_f/m['SwapTotal']
-
-    desc = "#{shell('ps -eo pmem,pid,cmd --sort -pmem | head -3').chomp}"
     [
       { :service => plugin.service + ' % free', :description => 'Memory usage, %', :metric => fraction.round(2) * 100 },
-      { :service => plugin.service + ' % swap', :description => 'Swap usage, %', :metric => swap_fraction.round(2) * 100 },
-      { :service => plugin.service + ' abs free', :description => "Memory free (kB)\n\n #{desc}", :metric => free, :state => 'ok' },
-      { :service => plugin.service + ' abs total', :description => "Memory total (kB)\n\n #{desc}", :metric => total, :state => 'ok' },
-      { :service => plugin.service + ' abs cached', :description => "Memory usage, cached (kB)\n\n #{desc}",  :metric => cached, :state => 'ok' },
-      { :service => plugin.service + ' abs buffers', :description => "Memory usage, buffers (kB)\n\n #{desc}", :metric => buffers, :state => 'ok' },
-      { :service => plugin.service + ' abs used', :description => "Memory usage, used (kB)\n\n #{desc}", :metric => used , :state => 'ok' },
-      { :service => plugin.service + ' abs free_bc', :description => "Memory usage with cache и buffers (kB)\n\n #{desc}", :metric => free_bc , :state => 'ok' }
+      { :service => plugin.service + ' abs free', :description => "Memory free (Bytes)", :metric => SysInfo::Memory.free, :state => 'ok' },
+      { :service => plugin.service + ' abs total', :description => "Memory total (Bytes)", :metric => total, :state => 'ok' },
+      { :service => plugin.service + ' abs cached', :description => "Memory usage, cached (Bytes)",  :metric => SysInfo::Memory.cached, :state => 'ok' },
+      { :service => plugin.service + ' abs buffers', :description => "Memory usage, buffers (Bytes)", :metric => SysInfo::Memory.buffers, :state => 'ok' },
+      { :service => plugin.service + ' abs used', :description => "Memory usage, used (Bytes)", :metric => SysInfo::Memory.total - SysInfo::Memory.free , :state => 'ok' },
+      { :service => plugin.service + ' abs free_bc', :description => "Memory usage with cache и buffers (Bytes)", :metric => free_bc , :state => 'ok' }
     ]
   end
 

data/lib/riemann/babbler/plugins/net.rb

@@ -1,21 +1,5 @@
 class Riemann::Babbler::Net < Riemann::Babbler
 
-  WORDS = ['rx bytes',
-           'rx packets',
-           'rx errs',
-           'rx drop',
-           'rx fifo',
-           'rx frame',
-           'rx compressed',
-           'rx multicast',
-           'tx bytes',
-           'tx packets',
-           'tx drops',
-           'tx fifo',
-           'tx colls',
-           'tx carrier',
-           'tx compressed']
-
   def collect
     f = File.read('/proc/net/dev')
     status = Array.new
@@ -23,13 +7,9 @@ class Riemann::Babbler::Net < Riemann::Babbler
       iface = line.split(':')[0].strip
       iface.gsub!(/\./, '_')
       next unless line =~ /(\w*)\:\s*([\s\d]+)\s*/
-      WORDS.map do |service|
-        "#{plugin.service} #{iface} #{service}"
-      end.zip(
-        $2.split(/\s+/).map { |str| str.to_i }
-      ).each do |service, value|
-        status << { :service => service, :metric => value, :as_diff => true}
-      end
+      status << { :service => "#{plugin.service} #{iface} bytes out", :metric => SysInfo::Net.out(iface, 'bytes'), :as_diff => true }
+      status << { :service => "#{plugin.service} #{iface} bytes in", :metric => SysInfo::Net.in(iface, 'bytes'), :as_diff => true }
+      status << { :service => "#{plugin.service} #{iface} bytes errors", :metric => SysInfo::Net.total(iface, 'errors'), :state => 'ok' }
     end
     status
   end

data/lib/riemann/babbler/plugins/netstat.rb

@@ -0,0 +1,15 @@
+class Riemann::Babbler::Netstat < Riemann::Babbler
+
+  def init
+    plugin.set_default(:service, 'netstat')
+    plugin.set_default(:interval, 60)
+    plugin.set_default(:port, 80)
+    plugin.states.set_default(:warning, 300)
+    plugin.states.set_default(:critical, 400)
+  end
+
+  def collect
+    count = shell("netstat -nat4 | egrep -e ':#{plugin.port}\s'  | grep ESTA | wc -l").to_i
+    {:service => "#{plugin.service} tcp #{plugin.port}", :metric => count, :description => "count established connects: #{count} to port #{plugin.port}"}
+  end
+end

data/lib/riemann/babbler/plugins/nginx.rb

@@ -1,7 +1,16 @@
 class Riemann::Babbler::Nginx < Riemann::Babbler
 
-  NGINX_STATUS_1 = %W(accepts handled requests)
-  NGINX_STATUS_2 = %W(reading writing waiting)
+    NGINX_STATUS_1 = [
+      'accepts',
+      'handled',
+      'requests'
+    ]
+
+    NGINX_STATUS_2 = [
+      'reading',
+      'writing',
+      'waiting'
+    ]
 
   def init
     plugin.set_default(:service, 'nginx')
@@ -21,7 +30,7 @@ class Riemann::Babbler::Nginx < Riemann::Babbler
       status << { :service => plugin.service + " #{NGINX_STATUS_1[index]}", :metric => value.to_i, :as_diff => true }
     end
     # line[0]: Active connections: XXXX
-    status << { :service => plugin.service + ' active', :metric => lines[0].split(':')[1].strip.to_i }
+    status << { :service => plugin.service + " active", :metric => lines[0].split(":")[1].strip.to_i }
     # lines[3]: Reading: 0 Writing: 1 Waiting: 0
     lines[3].scan(/\d+/).each_with_index do |value, index|
       status << { :service => plugin.service + " #{NGINX_STATUS_2[index]}", :metric => value.to_i }

data/lib/riemann/babbler/plugins/runit.rb

@@ -15,16 +15,14 @@ class Riemann::Babbler::Runit < Riemann::Babbler
     status = Array.new
     Dir.glob('/etc/service/*').each do |srv|
       next if plugin.not_monit.include? srv
-      human_srv = ' ' + srv.gsub(/\/etc\/service\//, '')
+      human_srv = ' ' + srv.gsub(/\/etc\/service\//,"")
       stat_file = File.join(srv, 'supervise', 'stat')
       next unless File.exists? stat_file
       if File.read( stat_file ).strip == 'run'
-        @status_history.delete human_srv
+        @status_history.delete "human_srv"
         status << {:service => plugin.service + human_srv , :state => 'ok', :description => "runit service #{human_srv} running"}
       else
-        if @status_history.include? human_srv 
-          status << {:service => plugin.service + human_srv , :state => 'critical', :description => "runit service #{human_srv} not running"}
-        end
+        status << {:service => plugin.service + human_srv , :state => 'critical', :description => "runit service #{human_srv} not running"} if @status_history.include? human_srv 
         @status_history << human_srv unless @status_history.include? human_srv
       end
     end

data/lib/riemann/babbler/support/monkey_patches.rb

@@ -1,9 +1,9 @@
 module Beefcake
   class Buffer
     
-    def initialize(buf='')
+    def initialize(buf="")
       if buf.respond_to?(:force_encoding)
-        self.buf = buf.force_encoding('BINARY')
+        self.buf = buf.force_encoding("BINARY")
       else
         self.buf = buf
       end
@@ -12,7 +12,7 @@ module Beefcake
     def append_string(s)
       append_uint64(s.length)
       if s.respond_to?(:force_encoding)
-        self << s.force_encoding('BINARY')
+        self << s.force_encoding("BINARY")
       else
         self << s
       end

data/lib/riemann/babbler/support/plugin_helpers.rb

@@ -43,25 +43,6 @@ module Riemann
       end
     end
 
-    def file_grep(filename, regexp, max_lines=100)
-      readed_lines = 0
-      lines = Array.new
-      begin
-        Timeout::timeout(plugin_timeout) do
-          File::Tail::Logfile.open(file, :backward => 0) do |log|
-            log.tail do |line|
-              readed_lines += 1
-              lines << line if line.match?(regexp)
-              return lines if readed_lines >= max_lines
-            end
-          end
-        end
-      rescue => e
-        helper_error("#{e.class} #{e}\n#{e.backtrace.join "\n"}")
-      end
-      return lines
-    end
-
     def tcp_port_aviable?(ip, port)
       begin
         Timeout::timeout(plugin_timeout) do
@@ -74,9 +55,8 @@ module Riemann
           end
         end
       rescue Timeout::Error
-        return false
       end
-      false
+      return false
     end
 
     # http rest

data/lib/riemann/babbler/sysinfo.rb

@@ -0,0 +1 @@
+require 'sysinfo/sysinfo'

data/lib/riemann/{babbler/version.rb → version.rb}

@@ -1,5 +1,5 @@
 module Riemann
   class Babbler
-    VERSION = '1.0.8.8'
+    VERSION = '1.1.0pre2'
   end
 end

data/lib/{riemann/babbler/start.rb → start.rb}

@@ -2,8 +2,8 @@ require 'yaml'
 require 'logger'
 require 'resolv'
 
-require 'riemann/babbler/support/deep_merge'
-require 'riemann/babbler'
+require File.expand_path('../riemann/babbler/support/deep_merge', __FILE__)
+require File.expand_path('../riemann/babbler/plugin', __FILE__)
 
 class Riemann::Babbler::Starter
 
@@ -37,7 +37,7 @@ class Riemann::Babbler::Starter
       logger.warn "Can't load config file #{opts[:config]}"
       Hash.new
     end
-    config_default = YAML.load_file( File.expand_path('../../../../config.yml', __FILE__) )
+    config_default = YAML.load_file( File.expand_path('../../config.yml', __FILE__) )
     config_from_file = config_default.deep_merge( config_file )
     config.configure_from_hash config_from_file
   end
@@ -61,7 +61,7 @@ class Riemann::Babbler::Starter
 
   def load_plugins
     plugins = Array.new
-    default_plugins_dir = File.expand_path('../plugins/', __FILE__)
+    default_plugins_dir = File.expand_path('../riemann/babbler/plugins/', __FILE__)
     Dir.glob( default_plugins_dir + '/*.rb') do |file|
       plugins <<  file
     end
@@ -140,7 +140,6 @@ class Riemann::Babbler::Starter
   def start_plugins!
     plugin_threads = started_plugins.map do |plugin|
       Thread.new {
-        logger.unknown "Start plugin #{plugin}"
         plugin.new( config, logger, $riemann ).run
       }
     end

data/riemann-babbler.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/riemann/babbler/version', __FILE__)
+require File.expand_path('../lib/riemann/version', __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = 'riemann-babbler'
@@ -7,19 +7,20 @@ Gem::Specification.new do |s|
   s.authors     = ['Vasiliev D.V.']
   s.email       = %w(vadv.mkn@gmail.com)
   s.homepage    = 'https://github.com/vadv/riemann-babbler'
-  s.summary     = %q{Plugin manager for riemann.}
-  s.description = %q{Plugin manager for riemann.}
+  s.summary     = %q{Riemann health checker.}
+  s.description = %q{Some plugins manager for riemann.}
   s.licenses    = %w(MIT)
   
   s.add_dependency('riemann-client')
   s.add_dependency('configatron')
   s.add_dependency('logger')
   s.add_dependency('trollop')
-  s.add_dependency('sys-filesystem')
+  #s.add_dependency('sys-filesystem')
   s.add_dependency('rest-client')
   s.add_dependency('net-ping')
-  s.add_dependency('file-tail')
-  s.add_dependency('sys-proctable')
+  s.add_dependency('sequel')
+
+  s.extensions = ['ext/sysinfo/extconf.rb']
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/spec/default.rb

@@ -1,7 +1,8 @@
 #encoding: utf-8
 
-require 'riemann/babbler'
-require 'riemann/babbler/start'
+$: << File.dirname(__FILE__) + '/../ext/sysinfo'
+require 'riemann/babbler/plugin'
+require 'start'
 require 'configatron'
 
 opts = Hash.new

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: riemann-babbler
 version: !ruby/object:Gem::Version
-  version: 1.0.8.8
-  prerelease: 
+  version: 1.1.0pre2
+  prerelease: 5
 platform: ruby
 authors:
 - Vasiliev D.V.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-22 00:00:00.000000000 Z
+date: 2013-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: riemann-client
@@ -75,22 +75,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: sys-filesystem
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
@@ -124,23 +108,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: file-tail
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: sys-proctable
+  name: sequel
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -155,12 +123,13 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Plugin manager for riemann.
+description: Some plugins manager for riemann.
 email:
 - vadv.mkn@gmail.com
 executables:
 - riemann-babbler
-extensions: []
+extensions:
+- ext/sysinfo/extconf.rb
 extra_rdoc_files: []
 files:
 - .gitignore
@@ -172,29 +141,31 @@ files:
 - Rakefile
 - bin/riemann-babbler
 - config.yml
-- lib/riemann/babbler.rb
+- ext/sysinfo/extconf.rb
+- ext/sysinfo/sysinfo.c
+- ext/sysinfo/sysinfo.h
+- lib/riemann/babbler/plugin.rb
 - lib/riemann/babbler/plugins/cpu.rb
-- lib/riemann/babbler/plugins/cpu_fan.rb
-- lib/riemann/babbler/plugins/cpu_temp.rb
+- lib/riemann/babbler/plugins/cpufan.rb
+- lib/riemann/babbler/plugins/cputemp.rb
 - lib/riemann/babbler/plugins/disk.rb
 - lib/riemann/babbler/plugins/dummy.rb
 - lib/riemann/babbler/plugins/exim4.rb
 - lib/riemann/babbler/plugins/http.rb
 - lib/riemann/babbler/plugins/la.rb
 - lib/riemann/babbler/plugins/mdadm.rb
-- lib/riemann/babbler/plugins/mega_cli.rb
+- lib/riemann/babbler/plugins/megacli.rb
 - lib/riemann/babbler/plugins/memory.rb
 - lib/riemann/babbler/plugins/net.rb
-- lib/riemann/babbler/plugins/net_stat.rb
+- lib/riemann/babbler/plugins/netstat.rb
 - lib/riemann/babbler/plugins/nginx.rb
 - lib/riemann/babbler/plugins/runit.rb
-- lib/riemann/babbler/plugins/status_file.rb
-- lib/riemann/babbler/plugins/tw_cli.rb
-- lib/riemann/babbler/start.rb
 - lib/riemann/babbler/support/deep_merge.rb
 - lib/riemann/babbler/support/monkey_patches.rb
 - lib/riemann/babbler/support/plugin_helpers.rb
-- lib/riemann/babbler/version.rb
+- lib/riemann/babbler/sysinfo.rb
+- lib/riemann/version.rb
+- lib/start.rb
 - riemann-babbler.gemspec
 - spec/config.yml
 - spec/default.rb
@@ -214,16 +185,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: Plugin manager for riemann.
+summary: Riemann health checker.
 test_files:
 - spec/config.yml
 - spec/default.rb
-has_rdoc: 

data/lib/riemann/babbler/plugins/net_stat.rb

@@ -1,33 +0,0 @@
-class Riemann::Babbler::NetStat < Riemann::Babbler
-
-  def init
-    plugin.set_default(:service, 'netstat')
-    plugin.set_default(:interval, 5)
-    plugin.set_default(:ports, [80, 3994])
-    plugin.states.set_default(:warning, nil)
-    plugin.states.set_default(:critical, nil)
-  end
-
-  def get_conn_count
-    filter = nil
-    plugin.ports.each do |port|
-      if filter == nil
-        filter = "\\( src *:#{port}"
-      else
-        filter += " or src *:#{port}"
-      end
-    end
-    filter += " \\) and not dst 127.0.0.1:*"
-    cmd = "ss -t -4 -n state established " + filter + " | wc -l"
-    shell(cmd).to_i - 1
-  end
-
-  def collect
-    count = get_conn_count()
-    {
-      :service => "#{plugin.service} tcp #{plugin.ports.join(', ')}",
-      :metric => count, 
-      :description => "count established connects: #{count} to ports #{plugin.ports.join(', ')}"
-    }
-  end
-end

data/lib/riemann/babbler/plugins/status_file.rb

@@ -1,23 +0,0 @@
-class Riemann::Babbler::StatusFile < Riemann::Babbler
-
-  def init
-    plugin.set_default(:service, 'check state file')
-    plugin.states.set_default(:critical, 1)
-    plugin.set_default(:file, '/var/tmp/error.txt')
-    plugin.set_default(:interval, 60)
-    plugin.set_default(:max_lines, 100)
-    plugin.set_default(:report_lines, 5)
-  end
-
-  def collect
-    return [] unless File.exists? plugin.file
-    content = File.read(plugin.file).split("\n").delete_if {|x| x.strip.empty? }
-    {
-        :service => plugin.service + " #{plugin.file}",
-        :description => content.last(plugin.report_lines).join("\n"),
-        :metric => content.count
-    }
-  end
-
-end
-

data/lib/riemann/babbler/plugins/tw_cli.rb

@@ -1,22 +0,0 @@
-class Riemann::Babbler::TwCli < Riemann::Babbler
-
-  def init
-    plugin.set_default(:service, 'twcli')
-    plugin.set_default(:cmd, "/usr/sbin/tw_cli /$(/usr/sbin/tw_cli show | grep ^c | cut -f1 -d' ') show | egrep '^[upb]' | grep -v ' OK ' | grep -v ' VERIFYING ' | grep -v ' VERIFY-PAUSED ' | wc -l")
-    plugin.states.set_default(:critical, 1)
-    plugin.set_default(:interval, 300)
-  end
-
-  def run_plugin
-    File.exists? '/usr/sbin/tw_cli'
-  end
-
-  def collect
-    { 
-      :service => plugin.service,
-      :metric => shell(plugin.cmd).to_i,
-      :description => 'Hardware raid tw_cli status'
-    }
-  end
-
-end