File Coverage

blib/lib/Log/Dispatch/SNMP.pm

Criterion	Covered	Total	%
statement	45	52	86.5
branch	5	10	50.0
condition	1	3	33.3
subroutine	11	12	91.6
pod	2	2	100.0
total	64	79	81.0

########################################
package Log::Dispatch::SNMP;
use Log::Dispatch::Output;
use base qw( Log::Dispatch::Output );
########################################
use strict;
use warnings;

use Net::SNMP qw(:asn1);
use Params::Validate qw(validate SCALAR);
use Carp qw(carp croak); #TODO: option to warn or die or do nothing on errors

our $VERSION = '0.02';

sub new {
    my $proto = shift;
    my $class = ref $proto || $proto;

    # new versions of Log::Dispatch may complain about unknown options,
    # so we take our options out of the equation (err.. hash)
    my %parameters = @_;
    my %snmp_parameters = ();
    foreach my $key (qw(ManagementHostTrapListenPort
                        ManagementHost
                        EnterpriseOID
                        LocalIPAddress
                        LocalTrapSendPort
                        GenericTrapType
                        SpecificTrapType
                        ApplicationTrapOID
                        CommunityString
                     )
    ) {
        if (exists $parameters{$key}) {
            $snmp_parameters{$key} = $parameters{$key};
            delete $parameters{$key};
        }
    }

    my $self = bless {}, $class;

    $self->_basic_init(%parameters);
    $self->_set_snmp_parameters(%snmp_parameters);
    $self->_start_snmp_session();

    return $self;
}

sub _set_snmp_parameters {
    my $self = shift;

    # validate user supplied parameters
    my %p = validate (@_, {
                'ManagementHostTrapListenPort' => { type    => SCALAR,
                                                    default => 162,
                                                  },
                'ManagementHost'     => { type => SCALAR },
                'EnterpriseOID'      => { type => SCALAR },
                'LocalIPAddress'     => { type => SCALAR },
                'LocalTrapSendPort'  => { type => SCALAR,
                                          default => 161,
                                        },
                'GenericTrapType'    => { type => SCALAR,
                                          default => 6,
                                        },
                'SpecificTrapType'   => { type => SCALAR },
                'ApplicationTrapOID' => { type => SCALAR },
                'CommunityString'    => { type => SCALAR,
                                          default => 'public',
                                        },
            });

    # put everything in the actual object
    foreach (keys %p) {
        $self->{$_} = $p{$_};
    }
}

sub _start_snmp_session {
    my $self = shift;
    my $error = '';

    ($self->{'session'}, $error) =
        Net::SNMP->session(
               -hostname    => $self->{'ManagementHost'},
               -port        => $self->{'ManagementHostTrapListenPort'},
               -version     => 'snmpv1', #TODO: make this configurable
               -community   => $self->{'CommunityString'},
               -nonblocking => 0,        #TODO: make this configurable
               -domain      => 'udp4',   #TODO: make this configurable
    );
    croak "error starting SNMP session: $error\n"
        unless $self->{'session'};
}

sub log_message {
    my $self = shift;
    my %p = @_;

    #TODO: This check is probably not necessary
    # or could be just plain wrong
    $self->_start_snmp_session()
        unless $self->{'session'};

    # first trio is always the EOID
    my @varbindlist = (
            $self->{'EnterpriseOID'},
            OBJECT_IDENTIFIER,
            $self->{'EnterpriseOID'},
    );

    # then we put the message itself on the varbind.
    # this is separate in order to easen the future
    # (planned) integration with a special Layout
    # "SnmpDelimitedConversionPatternLayout" for Log4perl.
    push @varbindlist, $self->{'ApplicationTrapOID'},
                       OCTET_STRING,
                       $p{'message'}
    ;

    if ( ! $self->{'session'}->trap(
                                -enterprise   => $self->{'EnterpriseOID'},
                                -generictrap  => $self->{'GenericTrapType'},
                                -specifictrap => $self->{'SpecificTrapType'},
                                -varbindlist  => \@varbindlist,
                            )
    ) {
        carp 'Error sending trap: ' . $self->{'session'}->error() . "\n";
    }
}

sub DESTROY {
    my $self = shift;
    if ($self->{'session'}) {
        $self->{'session'}->close();
    }
}

42;
__END__