File Coverage

blib/lib/Monitor/Simple.pm

Criterion	Covered	Total	%
statement	16	18	88.8
branch			n/a
condition			n/a
subroutine	6	6	100.0
pod			n/a
total	22	24	91.6

#-----------------------------------------------------------------
# Monitor::Simple
# Author: Martin Senger
# For copyright and disclaimer se below.
#
# ABSTRACT: Simple monitoring of applications and services
# PODNAME: Monitor::Simple
#-----------------------------------------------------------------

package Monitor::Simple;

use warnings;
use strict;

our $VERSION = '0.2.8'; # VERSION

# values returned by plugins (compatible with Nagios'
use constant {
    RETURN_OK       => 0,
    RETURN_WARNING  => 1,
    RETURN_CRITICAL => 2,
    RETURN_UNKNOWN  => 3,

    # ...and this is returned if the plugin cannot be started
    RETURN_FATAL    => -1,
};

# values used in configuration file for notifiers (in attribute "on")
use constant {
    NOTIFY_OK       => 'ok',
    NOTIFY_WARNING  => 'w',
    NOTIFY_CRITICAL => 'c',
    NOTIFY_UNKNOWN  => 'u',
    NOTIFY_ALL      => 'all',
    NOTIFY_ERRORS   => 'err',
    NOTIFY_NONE     => 'none',
};

use Monitor::Simple::Log;
use Monitor::Simple::Config;
use Monitor::Simple::UserAgent;
use Monitor::Simple::Utils;
use Monitor::Simple::Output;
use Monitor::Simple::Notifier;

use Carp;
use Log::Log4perl qw(:easy);
use Parallel::ForkManager;
use IO::CaptureOutput qw(capture_exec);
use File::Spec;
use Time::HiRes qw(time);


my $default_npp = 10; # maximum number of child processes in parallel

# -----------------------------------------------------------------
# The main loop checking all services as defined in the given
# configuration.
#
# Recognized arguments:
#    { config_file => $config_file,
#      npp         => ,
#      outputter   => instance of Monitor::Simple::Output,
#      filter      => hashref (keys are service IDS) or
#                     arrayref with service IDs, or
#                     scalar with just one service ID
#      nonotif     => boolean
#    }
# -----------------------------------------------------------------
sub check_services {
    my ($self, $args) = @_;

    # recognized arguments
    my $config;
    my $config_file;
    if ($args->{config_file}) {
        $config_file = $args->{config_file};
        $config = Monitor::Simple::Config->get_config ($config_file);
    } else {
        LOGDIE ("check_services: Missing argument 'config_file'. Cannot do anything.\n");
    }
    my $npp = ($args->{npp} || $default_npp);
    if ($npp < 1) {
        LOGWARN ("check_services: Argument 'npp' must be positive. Replaced by default value $default_npp.\n");
        $npp = $default_npp;
    }
    my $outputter = ($args->{outputter} || Monitor::Simple::Output->new (config   => $config));

    # optional filter tells which only services to check; filter can be
    # hashref or arrayref or scalar (all with service name(s) we wish
    # to check)
    my $filter = $args->{filter};
    if ($filter) {
        if (ref ($filter) eq 'ARRAY') {
            $filter = { map { $_ => 1 } @$filter };
        } elsif (ref ($filter) eq 'HASH') {
            # already done
        } else {
            $filter = { $filter => 1 };
        }
    }
    $filter = undef unless keys %$filter > 0;

    # before the main checking loop starts
    $outputter->header();
    my $notifier = Monitor::Simple::Notifier->new (config  => $config,
                                                   cfgfile => $config_file);

    # main loop
    INFO ('--- Checking started ---');
    my $start_time = time();
    my $pm = new Parallel::ForkManager ($npp);
    foreach my $service (@{ $config->{services} }) {

        # filtering of services
        next if $filter and not exists $filter->{ $service->{id} };

        # this does the fork and for the parent branch and continues the foreach loop
        $pm->start and next;

        # this is the child branch: execute an external plugin...
        my $command = $service->{plugin}->{command};
        unless (File::Spec->file_name_is_absolute ($command)) {
            my $plugins_dir = $config->{general}->{'plugins-dir'};
            if ($plugins_dir) {
                $command = File::Spec->catfile ($plugins_dir, $command);
            }
        }
        my @command = ($command,
                       Monitor::Simple::Config->create_plugin_args ($config_file,
                                                                    $config,
                                                                    $service->{id}));
        DEBUG ("Started: " . join (' ', @command));
        my ($stdout, $stderr, $success, $exit_code) = capture_exec (@command);

        # ...and make the result report
        print STDERR "$stderr\n" if $stderr;  # do not hide standard errors, if any
        my ($code, $msg) = Monitor::Simple::Utils->process_exit ($command, $exit_code, $stdout);
        $outputter->out ($service->{id}, $code, $msg);
        unless (exists $args->{nonotif} and $args->{nonotif}) {
            $notifier->notify ( { service => $service->{id},
                                  code    => $code,
                                  msg     => $msg } );
        }
        $pm->finish;
    }

    # here the parent branch continue when all child process have been
    # started; we need to wait untill all these processes finish -
    # otherwise we would create a "zombie" process in out operating
    # system
    $pm->wait_all_children();
    $outputter->footer();

    INFO ('--- Checking finished [' . (time() - $start_time) . ' s] ---');
}


1; # End of Monitor::Simple

__END__