smartos-bin/feed_graphite_sys.pl

#!/usr/bin/perl

use strict;
use IO::Socket;
use Data::Dumper;

my $graphitehost = "graphite.open6hosting.com";
my $port = "2003";
my $hostname = "o6hsmartos16";
my $grupo = "joyent";

my %ipmistatus = (
    "CPU_Temp"  => "cpu_temp",
    "CPU_Temperature"  => "cpu_temp",
    "CPU1_Temperature"  => "cpu_temp",
    "+12V_"  => "12v",
    "12V"  => "12v",
    "12V_"  => "12v",
    "CPU_FAN1"  => "cpu_fan1",
    "CPU_FAN1_"  => "cpu_fan1",
    "FAN1" => "cpu_fan1",
    "FAN1_" => "cpu_fan1",
);

my %mdbstatus = (
    "Kernel_" => "kernel",
    "Boot_pages" => "boot_pages",
    "ZFS_File_Data_" => "zfs_file",
    "Anon_" => "anon",
    "Exec_and_libs_" => "exec_and_libs",
    "Page_cache" => "page_cache",
    "Free_(cachelist)" => "free_cachelist",
    "Free_(freelist)" => "free_freelist",
);

# create Socket
my $socket = IO::Socket::INET -> new
(
    PeerAddr => $graphitehost,   
    PeerPort => $port,
        Proto => "tcp",
        Type => SOCK_STREAM
) or die "Couldn't connect to $graphitehost:$port: $@ \n";

# enviaremos algo asi
# print $socket "$grupo.$hostname.vfsstat.read_s $estructura{read_s} $time\n";
sub enviadatos ($$$$)
{
    my $hash = shift;
    my $socket = shift;
    my $tabla = shift;
    my $tiempo = shift;

    while ( my ( $keys, $values ) = each %{$hash} )
    {
        print $socket "$grupo.$hostname.$tabla.$keys ${$hash}{$keys} $tiempo\n";
    }
}


########
#
# iostat
#
########


# numero de dispositivos
my $devices = `zpool list -v | grep -c "c[0-9]*" | tr -d '\n'`;

# r/s w/s kr/s kw/s read_t write_t
# iostat -xzr 10 2
# device,r/s,w/s,kr/s,kw/s,wait,actv,svc_t,%w,%b
# sd1,27.9,0.0,111.5,0.0,0.0,0.7,24.6,0,45
my $captura = `iostat -xr 15 2 | awk -F, '\$1 ~ /^sd[0-8]|blkdev/ { print \$1,\$2,\$3,\$4,\$5,\$7,\$8,\$9,\$10 }' | tail -n$devices`;

my @fields = split(" ", $captura);
my @wcfields = @fields;

my %estructura;
my $disco;

foreach (@fields)
{
    if ( $_ =~ /^sd[0-9]|blkdev[0-9]/ )
    {
        $disco = $_;
	shift @wcfields;
        $estructura{$disco}{r_s} = shift @wcfields;
        $estructura{$disco}{w_s} = shift @wcfields;
        $estructura{$disco}{kr_s} = shift @wcfields;
        $estructura{$disco}{kw_s} = shift @wcfields;
	if ( $estructura{$disco}{kr_s} > 0 && $estructura{$disco}{r_s} > 0 )
	{
        	$estructura{$disco}{ars} = $estructura{$disco}{kr_s} / $estructura{$disco}{r_s};
	}
	if ( $estructura{$disco}{kw_s} > 0 && $estructura{$disco}{w_s} > 0 )
	{
		$estructura{$disco}{awrs} = $estructura{$disco}{kw_s} / $estructura{$disco}{w_s};
	}
        $estructura{$disco}{actv} = shift @wcfields;
        $estructura{$disco}{svc_t} = shift @wcfields;
        $estructura{$disco}{w} = shift @wcfields;
        $estructura{$disco}{b} = shift @wcfields;
    }
}

my $time = time();

foreach $disco (keys %estructura)
{
    &enviadatos (\%{ $estructura{$disco} }, $socket, "iostat.$disco", $time);
}


########
#
# ziostat
#
########


# numero de zonas
my $zonas = `vmadm list -H state=running | wc -l | tr -d '\n'`;

$captura = `ziostat -Z -r 15 2 | awk -F, '\$1 ~ /^[0-9]/ { print \$7,\$1,\$2,\$3,\$4,\$5,\$6 }' | tail -n$zonas`;

@fields = split(" ", $captura);
@wcfields = @fields;

my %ziostat;
my $uuid;

foreach (@fields)
{
    if ( $_ =~ /.*[a-z].*/ )
	{
	    $uuid = $_;
	    shift @wcfields;
	    $ziostat{$uuid}{r_s} = shift @wcfields;
	    $ziostat{$uuid}{kr_s} = shift @wcfields;
	    $ziostat{$uuid}{actv} = shift @wcfields;
	    $ziostat{$uuid}{wsvc_t} = shift @wcfields;
	    $ziostat{$uuid}{asvc_t} = shift @wcfields;
	    $ziostat{$uuid}{b} = shift @wcfields;
	}
}

$time = time();

foreach $uuid (keys %ziostat)
{
    &enviadatos (\%{ $ziostat{$uuid} }, $socket, "ziostat.$uuid", $time);
}


########
#
# zonememstat
#
########

my $memcommand = `zonememstat -H | awk '{ print \$1,\$2,\$4,\$5,\$6 }'`;

my %zonememstat;
my @memfields = split(" ", $memcommand);
my @wcmemfields = @memfields;
my $memuuid;


foreach (@memfields)
{
	if ( $_ =~ /^([a-z0-9]{8}-|global)/ ) {
		$memuuid = $_;
		shift @wcmemfields;
		$zonememstat{$memuuid}{rss} = shift @wcmemfields;
		$zonememstat{$memuuid}{nover} = shift @wcmemfields;
		$zonememstat{$memuuid}{pout} = shift @wcmemfields;
		$zonememstat{$memuuid}{swap} = shift @wcmemfields;
	}
}

my $memtime = time();

foreach my $uuid (keys %zonememstat)
{
        &enviadatos ( \%{ $zonememstat{$uuid} }, $socket, "zonememstat.$uuid", $memtime );
}

########
#
# cerramos el descriptor
#
########

shutdown($socket,2);

########
#
# collect IPMI sensors
#
########

my $ipmicommand = "ipmitool sdr list | sed 's/|//g' | sed 's/ /_/' | awk '\$1 ~ /CPU_Temp/ || \$1 ~ /CPU1_Temp/ || \$1 ~ /CPU_FAN1/ || \$1 ~ /^FAN1/ || \$1 ~ /12V/ { print \$1,\$2 }'";

open(IPMI, "$ipmicommand |") or die("Could not execute '$ipmicommand': $!");

while (<IPMI>) {
    my ($k, $v) = (m/([\+\w\d]*).*?(\d+(?:\.\d+)?)/);
    next unless ($k);
    if (exists $ipmistatus{$k} ) {
	system("echo -n '$grupo.$hostname.ipmi.$ipmistatus{$k} $v $time' | nc -w 0 $graphitehost $port");
    }
}

close (IPMI);

########
#
# collect memstat mdb data 
#
########

my $mdbcommand = "mdb -ke '::memstat' | sed 's/ZFS File Data/ZFS_File_Data/' | sed 's/Exec and libs/Exec_and_libs/' | sed 's/ /_/' | awk '{ print \$1,\$3 }'";

open(MEMSTAT, "$mdbcommand |") or die("Could not execute '$mdbcommand': $!");

while (<MEMSTAT>) {
    my ($k, $v) = (m/([\w_()]+)\s+?(\d+)?/);
    next unless ($k);
    if (exists $mdbstatus{$k} ) {
        system("echo '$grupo.$hostname.memstat.$mdbstatus{$k} $v $time' | nc -w 0 $graphitehost $port");
    }
}

close (MEMSTAT);