Munin contributed plugins

#!/usr/bin/perl

# -*- perl -*-

=head1 NAME

bandwidth_ - Wildcard-plugin to monitor total network traffic and

             predict 30 day bandwidth usage

=head1 CONFIGURATION

This is a wildcard plugin.  To monitor an interface, link

bandwidth_<interface> to this file.  E.g.

	ln -s /usr/share/munin/node/plugins-auto/bandwidth_ \

        /etc/munin/node.d/bandwidth_eth0

...will monitor eth0

Most likely usage is to monitor an interface connected to your ISP.

The suggest option will try and determine if you have any interfaces with a

public IP and if so it will suggest monitoring those interfaces.  If all

IP addresses are private the setup will have to be done manually.  Suggest

does not handle IPv6 addresses.

Environment Variables:

* monthlycap => monthly cap to draw warnings at in bytes

* uploadonly => if set display (and count against warnings) only upload bytes

=head1 USAGE

Any device found in /proc/net/dev can be monitored.  Examples include ipsec*,

eth*, irda* and lo.

Please note that aliases cannot be monitored with this plugin.

=head1 VERSION

$Id: bandwidth_,v 1.37 2012/01/23 20:04:33 root Exp $

=head1 AUTHOR

Sean Whitney

=head1 LICENSE

GPLv2

=head1 MAGIC MARKERS

 #%# family=contrib

 #%# capabilities=autoconf suggest

=head1 BUGS

I know that bandwidth is bits and base10 as opposed to bytes and base2.

However the purpose of this plugin it to monitor your monthly bandwidth

consumption to make sure you don't go over your ISP's peak.  ISP's seem

to be interested in expressing peaks in bytes....

=cut

use strict;

use Storable qw(store retrieve);

use Switch;

my $interface;

my $history;

my $counter_input;

my $counter_output;

my $input;

my $output;

my $uptime;

my $oldest_ts;

my $input_30days;

my $output_30days;

my $perf_ref = {};

my $count30  = 2592000;      # The number of seconds in 30 days

my $unix_ts  = time;

my $rollover = 4294967295;

my $monthlyCap = ($ENV{monthlycap} or 268435456000);

my $warnRate = $monthlyCap/$count30;

init();

sub autoconf {

    $0 =~ /bandwidth_(.+)*$/;

    $interface = $1;

    $history = "$ENV{MUNIN_PLUGSTATE}/bandwidth_$interface.state";

}

sub bit32or64 {

    if ( $input > $rollover || $output > $rollover ) {

        $rollover = 18446744073709551615;

    }

}

sub retrieve_history {

    return (undef) unless ( -r $history );

    my $store = retrieve($history);

    while ( my ( $key, $value ) = each(%$store) ) {

        if ( $unix_ts - $key < $count30 ) {

            $perf_ref->{$key} = $value;

        }

        if ( $key =~ /last/ ) {

            $perf_ref->{$key} = $value;

        }

    }

}

sub suggest {

    # This only works if one of your interfaces has a public IP,

    # Otherwise it will fail and you will have to set it manually

    # Multiple public IP addresses can be detected.  It won't

    # Detect IPv6 addresses.

    my $locate   = readpipe("locate -b '\\ifconfig'");

    my @ifconfig = readpipe($locate);

    my @old;

    my $net = "/proc/net/dev";

    my @interfaces;

    -f $net || die "Unable to read $net: $!";

    open( DEV, "<", $net ) || die "Unable to read $net: $!";

    while (<DEV>) {

        chomp;

        split;

        /Inter|face/ and next;

        split /:/;

        push( @interfaces, $_[0] );

    }

    close(DEV);

    foreach (@ifconfig) {

        if (/inet addr:([\d.]+)/) {

            $1

                =~ /^(127\.\d+|10\.\d+|172\.(1[6-9]|2\d|3[0-1])|192\.168)(\.\d+){2}$/

                and next;

            exists $interfaces[ $old[0] ] and print "$old[0]\n";

        }

        @old = split;

        chomp @old;

    }

    exit 0;

}

sub store_history {

    # Store the current values to the new old times

    $perf_ref->{$unix_ts} = {

        input  => $input,

        output => $output,

    };

    $perf_ref->{last} = {

        counter_input  => $counter_input,

        counter_output => $counter_output,

        uptime         => $uptime,

    };

    store( $perf_ref, $history ) || die "Unable to store $history: $!";

}

sub arg {

    defined( $ARGV[0] ) or return;

    switch ( $ARGV[0] ) {

        case 'autoconf' { print "yes\n"; exit 0; }

        case 'config'   { print_config(); }

        case 'suggest'  { suggest(); }

    }

}

sub print_config {

    print <<EOM;

graph_title Monthly Bandwidth average ($interface)

graph_vlabel Bytes (per sec)

average.label current 30 day average bytes/sec

monthly.label monthly project based on 30 day average

30dayusage.label monthly usage

average.info Your average network rate based (up to) the last 30 days of data

monthly.info Your projected monthly network rate based on your average network rate

30dayusage.info Your usage for the last 30 days.

graph_category network

graph_args  --base 1024 -l 0

graph_info This graph show your current average bandwidth usage and projected 30 day average based on your last 30 day usage.

average.warning $warnRate

monthly.warning $monthlyCap

30dayusage.warning $monthlyCap

EOM

    exit 0;

}

sub read_traffic {

    open( my $rx, "<", "/sys/class/net/$interface/statistics/rx_bytes" )

         || die "Unable to read: $!";

    $counter_input = <$rx>;

    chomp $counter_input;

    close($rx);

    open(my $tx , "<", "/sys/class/net/$interface/statistics/tx_bytes" )

         || die "Unable to read: $!";

        $counter_output = <$tx>;

	chomp $counter_output;

    close(DEV);

}

sub uptime {

    my $puptime = "/proc/uptime";

    open( TIME, "<", $puptime ) || die "Unable to read $puptime: $!";

    while (<TIME>) {

        my @arr = split;

        $uptime = $arr[0];

    }

    close(TIME);

    chomp $uptime;

}

sub update_stats {

    # First determine if this has ever run before.  If not set initial values

    # to 0.

    if ( defined $perf_ref->{last}->{uptime} ) {

        # Compute the new totals, caused by reboot.  As uptime is measures in

        # 64-bit jiffies, the chance of a counter rollover is remote

        if ( $perf_ref->{last}->{uptime} > $uptime ) {

            $input  = $counter_input;

            $output = $counter_output;

        }

        else {

            if ( $perf_ref->{last}->{counter_input} > $counter_input ) {

                $input =

                      $counter_input

                    + $rollover

                    - $perf_ref->{last}->{counter_input};

            }

            else {

                $input = $counter_input - $perf_ref->{last}->{counter_input};

            }

            if ( $perf_ref->{last}->{counter_output} > $counter_output ) {

                $output =

                      $counter_output

                    + $rollover

                    - $perf_ref->{last}->{counter_output};

            }

            else {

                $output =

                    $counter_output - $perf_ref->{last}->{counter_output};

            }

        }

    }

    else {

        $input  = 0;

        $output = 0;

    }

}

sub sum_old {

    $oldest_ts = $unix_ts;

    while ( my ( $key, $value ) = each(%$perf_ref) ) {

        $key =~ /last/ and next;

        $input_30days  += $perf_ref->{$key}->{'input'};

        $output_30days += $perf_ref->{$key}->{'output'};

        $key < $oldest_ts and $oldest_ts = $key

    }

    $input_30days  += $input;

    $output_30days += $output;

}

sub munin_output {

    my $period    = $unix_ts - $oldest_ts;

    return unless $period;  #can't estimate anything from a single point, so don't.

    my $total30   = $output_30days;

    $total30 += $input_30days unless $ENV{uploadonly};

    my $average30 = $total30 / $period;

    print "average.value  $average30\n";

    print "monthly.value " . $average30 * $count30 . "\n";

    print "30dayusage.value  $total30\n";

}

sub init {

    autoconf();

    arg();

    exit 2 unless defined $interface;

    retrieve_history();

    read_traffic();

    bit32or64();

    uptime();

    update_stats();

    sum_old();

    munin_output();

    store_history();

}