WishList: muninAggregator.2.pl

#!/usr/bin/perl -w
# muninAggregator - a cgi-bin which presents the same graph for multiple nodes
# and thus allows seeing the state of a whole farm of machines
#
# 20091020 - v1.00 - PaulM
# - it's all working and fairly tidy too
# 20091021 - v1.01 - PaulM
# - expands graph types by looking at munin's rrd files
#     which I'd already envisaged but Philipp Niemann requested it
#     so I took up the challenge
#
# released under GPL to the munin community with the authority of my CTO @taptu.com

use strict;
use CGI qw(:standard);
use POSIX ":sys_wait_h";
use FileHandle;
use Data::Dumper;

###############################################################################
# constants

# you'll need to tweak these to suit your installation
my $muninBaseUrl = ($ENV{'HTTPS'} eq 'on' ? 'https://' : 'http://') . $ENV{'SERVER_NAME'} . '/munin';
#my $muninBaseUrl = 'https://foo.example.com/munin';

my $muninDataFiles = '/var/lib/munin/db';

# most distros have it here
my $muninConf = '/etc/munin/munin.conf';
# but user self-builds might have it here:
#my $muninConf = '/usr/local/etc/munin/munin.conf';


## you shouldn't need to touch anything below this line! ##

# make the munin RRD names more human-friendly
# at some point it'd be cool to scan the munin directories and add any missing items
my %graphTypes = (
                    'apache_processes'          => 'Apache Processes'                   
                  , 'cpu'                       => 'CPU'                                        
                  , 'df'                        => 'Disk Usage'                         
                  , 'forks'                     => 'Fork rate'                          
                  , 'irqstats'                  => 'IRQ Statistics'                     
                  , 'interrupts'                => 'Interrupts & Context Switches'      
                  , 'iostat'                    => 'IOStat'                             
                  , 'log_sizes'                 => 'Log File Sizes'                             
                  , 'memory'                    => 'Memory Usage'                       
                  , 'omreport_fan_speed'        => 'OMSA Fan Speed'                     
                  , 'omreport_pwrmon_current'   => 'OMSA Power'                         
                  , 'omreport_temp'             => 'OMSA Temperature'                   
                  , 'processes'                 => 'Process count'                      
                  , 'vmstat'                    => 'VMStat process states'              
                 );

# make the munin time ranges more human-friendly
my %timeScales =
                (
                  'day'                         => '24 Hours'
                , 'week'                        => '7 days'
                , 'month'                       => '31 days'
                , 'year'                        => 'year'
                );

my $refreshRate = 10;   # default refresh rate

###############################################################################
# user-supplied url params
my $dbgLevel    = (defined(param('debugLevel')))        ? param('debugLevel')   : '0';
my $graphType   = (defined(param('graphType')))         ? param('graphType')    : '';
my $timeScale   = (defined(param('timeScale')))         ? param('timeScale')    : '';
my $nodeGroup   = (defined(param('nodeGroup')))         ? param('nodeGroup')    : '';
my $refresh     = (defined(param('refresh')))           ? param('refresh')      : 0;

###############################################################################
# writeSelectArray generates a select field of specified name with named options
# from a hash and pre-selects a specific value (if defined).
sub     writeSelectHash
{
        my ($name, $value, %options) = @_;

        print "<select name=\"$name\">\n";
        for my $option (sort keys %options)
        {
                print "\t<option value=\"" . $option . "\"";
                print " selected " if ((defined $option) && ($option eq $value));
                print ">" . $options{$option} . "</option>\n";
        }
        print "</select>"
}
###############################################################################
# writeSelectArray generates a select field of specified name with options
# from an array and pre-selects a specific value (if defined).
sub     writeSelectArray
{
        my ($name, $value, @options) = @_;

        print "<select name=\"$name\">\n";
        for my $option (sort @options)
        {
                print "\t<option value=\"" . $option . "\"";
                print " selected " if ((defined $option) && ($option eq $value));
                print ">" . $option . "</option>\n";
        }
        print "</select>"
}
###############################################################################
# generates a debug message in html-friendly form if the specified level is
# equal or higher than current global debug level
sub debugPrint
{
        my ($level, $dbgText) = @_;
        print "<i>Debug: $dbgText</i>\n<br />\n" if ($level >= $dbgLevel);
}

###############################################################################

# minimise delays writing to the browser
$| = 1;
STDERR->autoflush;          # already unbuffered in stdio



print "Content-type: text/html\n\n"
        . "<html>\n<head>\n";

print "\t<meta http-equiv=\"refresh\" content=\"$refreshRate\">\n" if (defined($refresh) && ($refresh));

print "\t<title>muninAggregator</title>\n"
        . "</head>\n"
        . "<body>\n";


if (!open(FH, "<$muninConf"))
{
        print "Sorry, an error occurred reading file $muninConf.\n<br />\nPlease check this script for errors\n";
}
else
{
        ##########
        # read the munin configuration file to extract groups and hosts and dbdir
        my %nodeGroups;
        my %nodesInGroups;
        while(<FH>)
        {
                chomp;
                if ($_ =~ /^\[(.*);(.*)\]$/)
                {
                        push @{$nodesInGroups{$1}}, $2;
                        $nodeGroups{$1} = 1;
                }
                elsif ($_ =~ /^\[(.*)\]$/)
                {
                        my $host = $1;
                        $host =~ /^([a-zA-Z0-9\-]*)\.(.*)$/;
                        push @{$nodesInGroups{$2}}, $host;
                        $nodeGroups{$1} = 1;
                }
                elsif ($_ =~ /^dbdir\s+(.*)$/)
                {
                        $muninDataFiles = $1;
                        #debugPrint(1, "munin data files are stored in $muninDataFiles");
                }
        }
        close(FH);

        ##########
        # expand the graphTypes table with any extra ones by looking in the 
        # munin data directories
        foreach my $group ( sort keys %nodeGroups )
        {
                if (-d "$muninDataFiles/$group")
                {
                        #debugPrint(1, "examining rrd files in $muninDataFiles/$group to populate the graphType hash");
                        chdir "$muninDataFiles/$group";
                        foreach my $rrdFile (<*>)
                        {
                                #debugPrint(1, "found $1  $2   $3");
                                if ($rrdFile =~ /^(.*)-(.*)-(.*)-(.*)$/ )
                                {
                                        if (!defined($graphTypes{$2}))
                                        {
                                                #debugPrint(0, "adding auto-derived graph type $2");
                                                $graphTypes{$2} = $2;
                                        }
                                }
                        }
                }
        }


        # present the graphing choices to the user as HTML form
        print "<form method=\"get\" action=\"\">\n";

        print "Check to refresh every 10 minutes: <input type=\"checkbox\" name=\"refresh\" value=\"1\" " . (defined($refresh) && ($refresh) ? "checked" : "") . "/><br />\n";

        print "Choose node group:&nbsp;";
        writeSelectArray("nodeGroup", $nodeGroup, keys %nodesInGroups);
        print "\n<br />\n";

        print "Choose graph type:&nbsp;";
        writeSelectHash("graphType", $graphType, %graphTypes);
        print "\n<br />\n";

        print "Choose time scale:&nbsp;";
        writeSelectHash("timeScale", $timeScale, %timeScales);
        print "\n<br />\n";

        print "\t<input type=\"submit\" name=\"go\" value=\"go\" />\n</form>\n\n";


        # can we render the table of graph images?
        # i.e. has user selected any graphs to show?
        if ($graphType ne '')
        {

                # get a list of nodes which have rrd files of selected type
                chdir("$muninDataFiles/$nodeGroup");
                my %rrdFilesByHost;
                for my $rrdFile (<*>)
                {
                        $rrdFilesByHost{$1} = 1 if ($rrdFile =~ /^(.*)-$graphType-(.*)-(.*)$/ );
                }

                # lets get rendering!
                print "<table>\n";
                my $graphCount = 0;
                foreach my $nodeName (sort @{$nodesInGroups{$nodeGroup}})
                {
                        $nodeName =~ /^([a-z0-9]*)\.(.*)$/;
                        print "\t<tr>\n" if (!($graphCount %2));
                        print "\t\t<td><b>$nodeName</b> <a href=\"$muninBaseUrl/$nodeGroup/$nodeName-$graphType.html\" target=munin_" . $nodeName . '_' .  $graphType . ">details</a><br />\n";

                        # check there's an rrd file for this host/group/type
                        if (!defined($rrdFilesByHost{$nodeName}))
                        {
                                print "<i>no graph of this type for this node</i>";
                        }
                        else
                        {
                                print "<img src=\"$muninBaseUrl/$nodeGroup/$nodeName-$graphType-$timeScale.png\" />\n\t\t</td>\n";
                        }
                        print "\t</tr>\n" if ($graphCount %1);
                        ++$graphCount;
                }
        }
        else
        {
                print "<i>No graph type chosen or program error</i><br />\n";
        }
}

print "</body>\n</html>\n";

# end of muninAggregator