Robot
/
contrib-munin
mirror of https://github.com/munin-monitoring/contrib.git
2
0
Fork 0
Code Issues Releases Wiki Activity
contrib-munin/plugins/network/interfaces_linux_multi

619 lines
16 KiB
Perl
Executable File
Raw Blame History

#! /usr/bin/perl
########################################################################
# Copyright (c) 2012, Adrien Urban
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the
# distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
########################################################################
# #
# WARNING WARNING WARNING WARNING WARNING WARNING #
# #
# This plugin does not work properly with multiple master #
# #
########################################################################
#
# multigraph, supersampling, detailed interfaces statistics
#
# require: ifconfig
# linux only for now. Would need to implement way to gather the same
# data for other ifconfig usage and output.
# require: Time::HiRes
#
# ENV (default):
# MUNIN_PLUGSTATE - pid and cache files gets there
#
# ENV (user defined):
# MUNIN_UPDATERATE - rate at which to update (default: 1s)
# MUNIN_CACHEFLUSH_RATE - flush data every N batch (default: 1)
# MUNIN_IFCONFIG - path for ifconfig (default /sbin/ifconfig)
#
# MUNIN_IF_INCLUDE - list of interfaces to graph (all by default)
# MUNIN_IF_EXCLUDE - exclude all of those interfaces (none by default)
# MUNIN_GRAPH_BYTES - do graph bytes per seconds (default: yes)
# MUNIN_GRAPH_PACKETS - do graph packets per seconds (default: yes)
# MUNIN_GRAPH_ERRORS - do graph errors (default: yes)
#
# Parent graphs: none
# child graphs: per interface - bytes, packets, errors
# interfaces/XXX/{bw,pkt,err}
#
# Known bugs:
#
# Multi-Master
# If there are many masters, the data is only sent once. Each master will
# only have part of the data.
#
# Everlasting
# The daemon is launched on first config/fetch. A touch of the pidfile is
# done on every following config/fetch. The daemon should check if the
# pidfile is recent (configurable) enough, and stop itself if not.
#
# Graph Order
# There is currently (2.0.6) noway to order childgraphs.
#
# RRD file
# The master currently (2.0.6) generate rrd file for aggregate values, and
# complains that no data is provided for them (but the graph still works
# fine)
#
#%# family=auto
#%# capabilities=autoconf
use strict;
use warnings;
use Time::HiRes;
use IO::Handle;
my $plugin = $0;
$plugin =~ s/.*\///;
# quick failsafe
if (!defined $ENV{MUNIN_PLUGSTATE}) {
die "This plugin should be run via munin. Try munin-run $plugin\n";
}
########################################################################
# If you want to change something, it's probably doable here
#
sub pidfile() { "$ENV{MUNIN_PLUGSTATE}/munin.$plugin.pid" }
sub cachefile() { "$ENV{MUNIN_PLUGSTATE}/munin.$plugin.cache" }
sub graph_section() { "system:network" }
sub graph_name() { "interfaces" }
#sub graph_title() { "interfaces" }
#sub graph_title_all() { "Overall CPU usage" }
#sub graph_title_n($) { "CPU#" . shift . " usage" }
sub acquire_name() { "<$plugin> collecting information" }
# Default update rate. Can be changed by configuration.
my $update_rate = 1;
# default flush interval. Can be changed by configuration.
my $flush_interval = 1;
# default ifconfig command. Can be changed by configuration
my $ifconfig = '/sbin/ifconfig';
########################################################################
# if you need to change something after that line, It should probably be
# changed to be configurable above it.
#
if (defined $ENV{MUNIN_UPDATERATE}) {
if ($ENV{MUNIN_UPDATERATE} =~ /^[1-9][0-9]*$/) {
$update_rate = int($ENV{MUNIN_UPDATERATE});
} else {
print STDERR "Invalid update_rate: $ENV{MUNIN_UPDATERATE}";
}
}
if (defined $ENV{MUNIN_CACHEFLUSH_RATE}) {
if ($ENV{MUNIN_CACHEFLUSH_RATE} =~ /^[0-9]+$/) {
$flush_interval = int($ENV{MUNIN_CACHEFLUSH_RATE});
} else {
print STDERR "Invalid flush rate: $ENV{MUNIN_CACHEFLUSH_RATE}";
}
}
if (defined $ENV{MUNIN_IFCONFIG}) {
if (-f $ENV{MUNIN_IFCONFIG}) {
print STDERR "MUNIN_IFCONFIG: file not found: $ENV{MUNIN_IFCONFIG}";
} else {
$ifconfig = defined $ENV{MUNIN_IFCONFIG};
}
}
my $include_list = undef;
if (defined $ENV{MUNIN_IF_INCLUDE}) {
$include_list = [ split(/[[:space:]]+/, $ENV{MUNIN_IF_INCLUDE}) ];
if (0 == scalar (@$include_list)) {
$include_list = undef;
} elsif ('' eq $include_list->[0]) {
shift @$include_list;
}
}
my $exclude_list = undef;
if (defined $ENV{MUNIN_IF_EXCLUDE}) {
$exclude_list = [ split(/[[:space:]]+/, $ENV{MUNIN_IF_EXCLUDE}) ];
if (0 == scalar (@$exclude_list)) {
$exclude_list = undef;
} elsif ('' eq $exclude_list->[0]) {
shift @$exclude_list;
}
}
sub configbool($) {
my $str = shift;
if ($str =~ /^(y(es)?|1|t(rue)?)$/i) {
return 1;
}
if ($str =~ /^(no?|0|f(alse)?)$/i) {
return 0;
}
print STDERR "$str: unrecognized bool\n";
return 1;
}
my $should_graph = {
'bytes' => 1,
'packets' => 1,
'errors' => 1,
};
if (defined $ENV{MUNIN_GRAPH_BYTES}) {
$should_graph->{'bytes'} = configbool($ENV{MUNIN_GRAPH_BYTES});
}
if (defined $ENV{MUNIN_GRAPH_PACKETS}) {
$should_graph->{'packets'} = configbool($ENV{MUNIN_GRAPH_PACKETS});
}
if (defined $ENV{MUNIN_GRAPH_ERRORS}) {
$should_graph->{'errors'} = configbool($ENV{MUNIN_GRAPH_ERRORS});
}
unless ($should_graph->{bytes} or $should_graph->{packets}
or $should_graph->{errors}) {
die "Nothing to graph!";
}
########################################################################
# Base functions, specific to what we really try to do here.
#
sub included_interface($)
{
my $if = shift;
if (defined $exclude_list) {
foreach my $ifl (@$exclude_list) {
return 0 if ($if =~ /^($ifl)$/);
}
}
if (defined $include_list) {
foreach my $ifl (@$include_list) {
return 1 if ($if =~ /^($ifl)$/);
}
return 0;
}
return 1;
}
sub if_to_name($)
{
my $if = shift;
$if =~ s/[^A-Za-z0-9]/_/g;
return $if;
}
sub get_data()
{
open IFCONFIG, "-|", $ifconfig or
die "open: $ifconfig|: $!\n";
my $data = {};
my $current_if = undef;
while (<IFCONFIG>) {
if (/^([^[:space:]]+)/) {
$current_if = $1;
if (!included_interface($current_if)) {
$current_if = undef;
next
}
$data->{$current_if} = {};
next; # nothing else on that line
}
next if (!defined $current_if);
if (/RX packets:([0-9]+) errors:([0-9]+) dropped:([0-9]+) overruns:([0-9]+) frame:([0-9]+)/) {
$data->{$current_if}{'rx_pkt'} = $1;
$data->{$current_if}{'rx_err'} = $2;
$data->{$current_if}{'rx_drp'} = $3;
$data->{$current_if}{'rx_ovr'} = $4;
$data->{$current_if}{'rx_frm'} = $5;
next;
}
if (/TX packets:([0-9]+) errors:([0-9]+) dropped:([0-9]+) overruns:([0-9]+) carrier:([0-9]+)/) {
$data->{$current_if}{'tx_pkt'} = $1;
$data->{$current_if}{'tx_err'} = $2;
$data->{$current_if}{'tx_drp'} = $3;
$data->{$current_if}{'tx_ovr'} = $4;
$data->{$current_if}{'tx_car'} = $5;
next;
}
if (/RX bytes:([0-9]+) \([^)]*\) TX bytes:([0-9]+) /) {
$data->{$current_if}{'rx_byt'} = $1;
$data->{$current_if}{'tx_byt'} = $2;
}
}
close IFCONFIG;
return $data;
}
# values names, from a data line
sub get_data_names($)
{
my $line = shift;
my $name = $line->[0];
my $count = scalar(@$line) - 2; # 2: name, and timestamp
if ($name =~ /\.(bps|pkt)$/ and 2 == $count) {
return [ 'rx', 'tx' ];
}
if ($name =~ /\.err$/ and 8 == $count) {
return [ 'rxerr', 'txerr', 'rxdrp', 'txdrp',
'rxovr', 'txovr', 'rxfrm', 'txcar', ];
}
# no idea what it is ? corrupted data
return undef;
}
sub collect_info_once($$)
{
my $fh = shift;
my $now = shift;
my $data = get_data();
foreach my $if (keys %$data) {
my $name = if_to_name($if);
my $d = $data->{$if};
if ($should_graph->{'bytes'}) {
print $fh <<EOF;
$name.bps $now $d->{'rx_byt'} $d->{'tx_byt'}
EOF
#$name.byt $now rx $d->{'rx_byt'}
#$name.byt $now tx $d->{'tx_byt'}
}
if ($should_graph->{'packets'}) {
print $fh <<EOF;
$name.pkt $now $d->{'rx_pkt'} $d->{'tx_pkt'}
EOF
#$name.pkt $now rx $d->{'rx_pkt'}
#$name.pkt $now tx $d->{'tx_pkt'}
}
if ($should_graph->{'errors'}) {
print $fh <<EOF;
$name.err $now $d->{'rx_err'} $d->{'tx_err'} $d->{'rx_drp'} $d->{'tx_drp'} $d->{'rx_ovr'} $d->{'tx_ovr'} $d->{'rx_frm'} $d->{'tx_car'}
EOF
#$name.err $now rxerr $d->{'rx_err'}
#$name.err $now txerr $d->{'tx_err'}
#$name.err $now rxdrp $d->{'rx_drp'}
#$name.err $now txdrp $d->{'tx_drp'}
#$name.err $now rxovr $d->{'rx_ovr'}
#$name.err $now txovr $d->{'tx_ovr'}
#$name.err $now rxfrm $d->{'rx_frm'}
#$name.err $now txcar $d->{'tx_car'}
}
}
}
sub show_config()
{
my $data = get_data();
my $graph_order = "graph_order";
foreach my $if (sort keys %$data) {
my $name = if_to_name($if);
$graph_order .= " ${name}_bps=${name}.bps.tx";
}
print <<EOF;
multigraph @{[ graph_name() ]}
graph_category @{[ graph_section() ]}
graph_title overall bits per seconds
graph_vlabel bits per seconds
update_rate 1
graph_data_size custom 1d, 10s for 1w, 1m for 1t, 5m for 1y
graph_args --base 1000
$graph_order
EOF
my $style = 'AREA';
foreach my $if (keys %$data) {
my $name = if_to_name($if);
print <<EOF;
${name}_bps.label $if bps out
${name}_bps.draw $style
${name}_bps.cdef ${name}_bps,8,*
EOF
$style = 'STACK';
}
foreach my $if (keys %$data) {
my $name = if_to_name($if);
print <<EOF;
multigraph @{[ graph_name() ]}.@{[ if_to_name($if) ]}
graph_title $if traffic
graph_vlabel kbits/s and pkt/s
graph_order bpsrx=bps.rx bpstx=bps.tx pktrx=pkt.rx pkttx=pkt.tx
bpsrx.label $if kbps in
bpsrx.draw AREA
bpsrx.cdef bpsrx,-125,/
bpstx.label $if kbps out
bpstx.draw AREA
bpstx.cdef bpstx,125,*
pktrx.label $if pkt/s in
pktrx.draw LINE1
pktrx.cdef pktrx,-1,*
pkttx.label $if pkt/s out
pkttx.draw LINE1
EOF
#foo.negative bar
if ($should_graph->{'bytes'}) {
print <<EOF;
multigraph @{[ graph_name() ]}.@{[ if_to_name($if) ]}.bps
graph_title $if - bits per seconds
graph_vlabel bits per seconds
graph_args --base 1000
graph_scale no
update_rate 1
graph_data_size custom 1d, 10s for 1w, 1m for 1t, 5m for 1y
rx.label bps received
rx.type DERIVE
rx.min 0
rx.cdef rx,8,*
tx.label bps sent
tx.type DERIVE
tx.min 0
tx.cdef tx,8,*
EOF
}
if ($should_graph->{'packets'}) {
print <<EOF;
multigraph @{[ graph_name() ]}.@{[ if_to_name($if) ]}.pkt
graph_title $if - packets per seconds
graph_vlabel packets per seconds
graph_args --base 1000
graph_scale no
update_rate 1
graph_data_size custom 1d, 10s for 1w, 1m for 1t, 5m for 1y
rx.label packets per second received
rx.type DERIVE
rx.min 0
tx.label packets per second sent
tx.type DERIVE
tx.min 0
EOF
}
if ($should_graph->{'errors'}) {
print <<EOF;
multigraph @{[ graph_name() ]}.@{[ if_to_name($if) ]}.err
graph_title $if - errors
graph_vlabel errors
graph_scale no
update_rate 1
graph_data_size custom 1d, 10s for 1w, 1m for 1t, 5m for 1y
graph_order rxerr txerr rxdrp txdrp rxovr txovr rxfrm txcar
rxerr.label errors per second (in)
rxerr.type DERIVE
rxerr.min 0
txerr.label errors per second (out)
txerr.type DERIVE
txerr.min 0
rxdrp.label drop per second (in)
rxdrp.type DERIVE
rxdrp.min 0
txdrp.label drop per second (out)
txdrp.type DERIVE
txdrp.min 0
rxovr.label overruns per second (in)
rxovr.type DERIVE
rxovr.min 0
txovr.label overruns per second (out)
txovr.type DERIVE
txovr.min 0
rxfrm.label frame per second (in)
rxfrm.type DERIVE
rxfrm.min 0
txcar.label carrier per second (out)
txcar.type DERIVE
txcar.min 0
EOF
}
}
}
sub check_req()
{
my $data = get_data();
if (0 != scalar(keys %$data)) {
return 1;
}
return 0;
}
########################################################################
# beyond that line, it should be generic stuffs, not dependent on what
# you are trying to graph
#
sub check_running() {
if (-f pidfile()) {
my $pid = undef;
if (open FILE, "<", pidfile()) {
$pid = <FILE>;
close FILE;
chomp $pid;
}
if ($pid) {
# does not exist ? kill it
if (kill 0, $pid) {
return 1;
}
}
unlink(pidfile());
}
return 0;
}
# FIXME: should also trap kill sigint and sigterm
# FIXME: check pidfile got touched recently
sub collect_loop() {
$0 = acquire_name();
$0 = "<$plugin> collecting information";
# write our pid
open PIDFILE, '>', pidfile() or die "open: @{[ pidfile() ]}: $!\n";
print PIDFILE $$, "\n";
close PIDFILE;
# open cache
my $fh_cache;
open $fh_cache, ">>", cachefile() or
die "open: @{[ cachefile() ]}: $!\n";
my @tick = Time::HiRes::gettimeofday();
my $flush_count = 0;
while (1) {
collect_info_once($fh_cache, $tick[0]);
if ($flush_interval) {
if ($flush_interval == ++$flush_count) {
$fh_cache->flush();
$flush_count = 0;
}
}
my @now = Time::HiRes::gettimeofday();
# when should the next tick be ?
$tick[0] += $update_rate;
# how long until next tick ?
my $diff = ($tick[0] - $now[0]) * 1000000
+ $tick[1] - $now[1];
if ($diff <= 0) {
# next tick already passed ? damn!
@tick = @now;
} else {
# sleep what remains
Time::HiRes::usleep($diff);
}
}
unlink(pidfile());
unlink(cachefile());
}
# launch daemon if not running
# notify the daemon we still need it (touch its pid)
sub daemon_alive() {
if (check_running()) {
my $atime;
my $mtime;
$atime = $mtime = time;
utime $atime, $mtime, pidfile();
} else {
if (0 == fork()) {
close(STDIN);
close(STDOUT);
close(STDERR);
open STDIN, "<", "/dev/null";
open STDOUT, ">", "/dev/null";
open STDERR, ">", "/dev/null";
collect_loop();
exit(0);
}
}
}
sub run_autoconf() {
if (check_req()) {
print "yes\n";
} else {
print "no\n";
}
}
sub run_config() {
daemon_alive();
show_config();
}
sub fetch_showline($) {
my $line = shift;
my $names = get_data_names($line);
# don't display anything if we don't like what it is
return unless (defined $names);
my $graph = shift @$line;
my $time = shift @$line;
foreach my $value (@$line) {
my $name = shift @$names;
print <<EOF;
$name.value $time:$value
EOF
}
}
sub run_fetch() {
daemon_alive();
if (open CACHE, "+<", cachefile()) {
my $data = {};
while (<CACHE>) {
chomp;
my $field = [];
@$field = split(/ /);
if (not defined $data->{$field->[0]}) {
$data->{$field->[0]} = [];
}
push @{$data->{$field->[0]}}, $field;
}
# finished reading ? truncate it right away
truncate CACHE, 0;
close CACHE;
foreach my $graph (keys %$data) {
print <<EOF;
multigraph @{[ graph_name() ]}.$graph
EOF
foreach my $line (@{$data->{$graph}}) {
fetch_showline($line);
}
}
}
}
my $cmd = 'fetch';
if (defined $ARGV[0]) {
$cmd = $ARGV[0];
}
if ('fetch' eq $cmd) {
run_fetch();
} elsif ('config' eq $cmd) {
run_config();
} elsif ('autoconf' eq $cmd) {
run_autoconf();
} elsif ('daemon' eq $cmd) {
run_daemon();
} else {
print STDERR <<EOF;
$0: unrecognized command
Usage:
$0 autoconf - check if we have everything we need
$0 config - show plugin configuration
$0 fetch - fetch latest data
$0 daemon - launch daemon
EOF
exit(1);
}
exit(0);
Reference in New Issue View Git Blame Copy Permalink