File Coverage

blib/lib/Net/Peep/Client/Logparser.pm

Criterion	Covered	Total	%
statement	81	212	38.2
branch	4	52	7.6
condition	8	48	16.6
subroutine	18	27	66.6
pod	0	10	0.0
total	111	349	31.8

package Net::Peep::Client::Logparser;

require 5.00503;
use strict;
# use warnings; # commented out for 5.005 compatibility
use Carp;
use Data::Dumper;
use File::Tail;
use Sys::Hostname;
use Net::Peep::Client;
use Net::Peep::Client::Logparser::Event;
use Net::Peep::BC;
use Net::Peep::Notifier;
use Net::Peep::Notification;

require Exporter;

use vars qw{ @ISA %EXPORT_TAGS @EXPORT_OK @EXPORT $VERSION };

@ISA = qw(Exporter Net::Peep::Client);
%EXPORT_TAGS = ( 'all' => [ qw( INTERVAL MAX_INTERVAL ADJUST_AFTER ) ] );
@EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
@EXPORT = qw( );
$VERSION = do { my @r = (q$Revision: 1.11 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r };

# These are in seconds and are the parameters for File::Tail

# File Tail uses the idea of intervals and predictions to try to keep
# blocking time at a maximum. These three parameters are the ones that
# people will want to tune for performance vs. load. The smaller the
# interval, the higher the load but faster events are picked up.

# The interval that File::Tail waits before checking the log
use constant INTERVAL => 0.1;
# The maximum interval that File::Tail will wait before checking the
# log
use constant MAX_INTERVAL => 1;
# The time after which File::Tail adjusts its predictions
use constant ADJUST_AFTER => 2;

use constant DEFAULT_PID_FILE => "/var/run/logparser.pid";

sub new {

	my $self = shift;
	my $class = ref($self) || $self;
	my $this = $class->SUPER::new();
	bless $this, $class;
	$this->{'EVENTS'} = [];
	$this->name('logparser');
	$this;

} # end sub new

sub getLogFiles {

	my $self = shift;
	my $conf = $self->conf();
	my $logfiles = $conf->optionExists('logfile') ? $conf->getOption('logfile') : '';
	my @logfiles = split ',\s*', $logfiles;
	return wantarray ? @logfiles : [@logfiles];

} # sub getLogFiles

sub getLogFileTails {

	my $self = shift;
	if ( ! exists $self->{"__LOGFILETAILS"} ) {

	my @logfiles = $self->getLogFiles();
	my @tailfiles;
	for my $logfile (@logfiles) {
		if (-e $logfile) {
			my $tail;
			eval { $tail =
				File::Tail->new(
						name => $logfile,
						interval => INTERVAL,
						maxinterval => MAX_INTERVAL,
						adjustafter => ADJUST_AFTER
						);
			};
			if ($@) {
				chomp $@;
				$self->logger()->log("Warning:  Error creating tail of logfile '$logfile':  $@");
			} else {
				push @tailfiles, $tail;
			}
		} else {
			$self->logger()->log("Warning:  Can't tail the log file '$logfile':  It doesn't exist.");
		}
	}

	$self->{"__LOGFILETAILS"} = \@tailfiles;

	}

	return wantarray ? @{$self->{"__LOGFILETAILS"}} : $self->{"__LOGFILETAILS"};

} # sub getLogFileTails

sub Start {

	my $self = shift;

	my $events = '';
	my $logfile = '';
	my $pidfile = DEFAULT_PID_FILE;
	my @groups = ();
	my @exclude = ();

	my %options = (
		'events=s' => \$events,
		'logfile=s' => \$logfile,
		'pidfile=s' => \$pidfile,
		'groups=s' => \@groups,
		'exclude=s' => \@exclude );

	$self->initialize(%options) || $self->pods();

	# register a parser for the logparser section of the configuration file

	$self->logger()->debug(9,"Registering parser ...");
	$self->parser(sub { my @text = @_; $self->parse(@text); });
	$self->logger()->debug(9,"\tParser registered ...");

	# have the client parse the configuration file and
	# get the configuration object which should be populated with the
	# standard command-line options and configuration information
	my $conf = $self->configure();

	unless ($conf->getOption('autodiscovery')) {
		$self->pods("Error:  Without autodiscovery you must provide a server and port option.")
			unless $conf->optionExists('server') && $conf->optionExists('port') &&
			       $conf->getOption('server') && $conf->getOption('port');
	}

	my @gotgroups = $self->getGroups();
	my @gotexclude = $self->getExcluded();
	$self->logger()->debug(1,"Recognized event groups are [@gotgroups]");
	$self->logger()->debug(1,"Excluded event groups are [@gotexclude]");

	# Check whether the pidfile option was set. If not, use the default
	unless ($conf->optionExists('pidfile')) {
		$self->logger()->debug(3,"No pid file specified. Using default [" . DEFAULT_PID_FILE . "]");
		$conf->setOption('pidfile', DEFAULT_PID_FILE);
	}

	$self->logger()->log("Scanning logs:");

	for my $logfile ($self->getLogFiles()) {
		$self->logger()->log("\t$logfile");
	}

	# Register a callback for the main loop
	$self->logger()->debug(9,"Registering callback ...");
	$self->callback(sub { $self->loop(); });
	$self->logger()->debug(9,"\tCallback registered ...");

	$self->MainLoop();

	return 1;

} # end sub Start

sub loop {

	my $self = shift;

	select(STDOUT);

	$| = 1; # autoflush

	my $nfound;

	my @logFileTails = $self->getLogFileTails();

	# call the peck method which, the first time it is called, will
	# instantiate a Net::Peep::BC object as necessary

	$self->peck();

	while (1) {

		$nfound = File::Tail::select(undef,undef,undef,60,@logFileTails);
		# hmmm ... don't quite understand what interval does ... [collin]
		unless ($nfound) {
			for my $filetail (@logFileTails) {
				$filetail->interval;
			}
		}

		for my $filetail (@logFileTails) {
			$self->tail($filetail->read) unless $filetail->predict;
		}
	}

	return 1;

} # end sub loop

sub peck {

	my $self = shift;

	my $configuration = $self->conf();

	unless (exists $self->{"__PEEP"}) {
		if ($configuration->getOptions()) {
			$self->{"__PEEP"} = Net::Peep::BC->new( $self->name(), $configuration );
		} else {
			confess "Error:  Expecting options to have been parsed by now.";
		}
	}

	return $self->{"__PEEP"};

} # end sub peck

sub tail {

    my $self = shift;
    my $line = shift;

    chomp $line;

    $self->logger()->debug(9,"Checking [$line] ...");

    my $conf = $self->conf();

    my $found = 0;

    # filter the events based on which groups or option letters
    # are specified
    my @events = grep $self->filter($_), $self->events();

    for my $event (@events) {

	# if we've already matched an event ignore the remaining events

	unless ($found) {

	    my $name = $event->name();
	    my $location = $event->location();
	    my $priority = $event->priority();
	    my $status = $event->notification();
	    my $regex = $event->regex();

	    $self->logger()->debug(9,"\tTrying to match regex [$regex] for event [$name]");

	    if ($line =~ /$regex/) {

		$self->logger()->debug(5,"$name:  $line");

		$self->peck()->send(
				    'logparser',
				    'type'       => 0,
				    'sound'      => $name,
				    'location'   => $location,
				    'priority'   => $priority,
				    'volume'     => 255
				    );

		my $notifier = new Net::Peep::Notifier;
		my $notification = new Net::Peep::Notification;

		$notification->client($self->name());
		$notification->hostname($Net::Peep::Notifier::HOSTNAME);
		$notification->status($status);
		$notification->datetime(time());
		$notification->message("${Net::Peep::Notifier::HOSTNAME}:  $name:  $line");

		$notifier->notify($notification);

		$found++;

	    }
	}
    }

    return 1;

} # end sub tail

sub parse {

    my $self = shift;
    my $client = $self->name() || confess "Cannot parse logparser events:  Client name attribute not set.";
    my @text = @_;

    my $conf = $self->conf() || confess "Cannot parse logparser events:  Configuration object not found.";

    $self->logger()->debug(1,"\t\tParsing events for client [$client] ...");

    $self->tempParseDefaults(@text);

    my @events = $self->getConfigSection('events',@text);

    my @version = $self->conf()->versionExists()
	? split /\./, $self->conf()->getVersion()
	    : ();

    if (@version && $version[0] >= 0 && $version[1] >= 4 && $version[2] > 3) {

	while (my $line = shift @events) {
	    next if $line =~ /^\s*#/ || $line =~ /^\s*$/;

	    my $name;
	    if ($line =~ /^\s*([\w-]+)\s+([\w-]+)\s+(\d+)\s+(\d+)\s+(\w+)\s+"(.*)"\s+([\w\-\.]+)/) {

		my $event = new Net::Peep::Client::Logparser::Event;
		$event->name($1);
		$event->group($2);
		$event->location($3);
		$event->priority($4);
		$event->notification($5);
		$event->regex($6);
		$event->hosts($7);

		$self->addEvent($event);
		$self->logger()->debug(1,"\t\t\tClient event [$1] added.");

	    }

	}

    } elsif (@version && $version[0] >= 0 && $version[1] >= 4 && $version[2] > 1) {

	while (my $line = shift @events) {
	    next if $line =~ /^\s*#/ || $line =~ /^\s*$/;

	    my $name;
	    if ($line =~ /^\s*([\w-]+)\s+([\w-]+)\s+([a-zA-Z])\s+(\d+)\s+(\d+)\s+"(.*)"/) {

		my $event = new Net::Peep::Client::Logparser::Event;
		$event->name($1);
		$event->group($2);
		$event->letter($3);
		$event->location($4);
		$event->priority($5);
		$event->regex($7);

		$self->addEvent($event);
		$self->logger()->debug(1,"\t\t\tClient event [$1] added.");

	    }

	}

    } else {

	while (my $line = shift @events) {
	    next if $line =~ /^\s*#/ || $line =~ /^\s*$/;

	    my $name;
	    if ($line =~ /([\w-]+)\s+([a-zA-Z])\s+(\d+)\s+(\d+)\s+"(.*)"/) {

		my $event = new Net::Peep::Client::Logparser::Event;
		$event->name($1);
		$event->letter($3);
		$event->location($4);
		$event->priority($5);
		$event->regex($7);

		$self->addEvent($event);
		$self->logger()->debug(1,"\t\t\tClient event [$1] added.");

	    }

	}

    }

    return @text;

} # end sub parse

sub addEvent {

    my $self = shift;
    my $event = shift || confess "Cannot add logparser event:  No event was provided.";
    push @{$self->{'EVENTS'}}, $event;
    return 1;

} # end sub addEvent

sub events {

    # return an array of events identified by calls to the event
    # method

    my $self = shift;
    return wantarray ? @{$self->{'EVENTS'}} : $self->{'EVENTS'};

} # events

1;

__END__