Log::Fine::Logger - Main logging object

    use Log::Fine;
    use Log::Fine::Logger;

    # get a new logging object
    my $log = Log::Fine->logger("mylogger");

    # alternatively, specify a custom map
    my $log = Log::Fine->logger("mylogger", "Syslog");

    # register a handle
    $log->registerHandle( Log::Fine::Handle::Console->new() );

    # log a message
    $log->log(DEBG, "This is a really cool module!");

    # illustrate use of the log skip API
    package Some::Package::That::Overrides::Log::Fine::Logger;

    use base qw( Log::Fine::Logger );

    sub log
    {
        my $self = shift;
        my $lvl  = shift;
        my $msg  = shift;

        # do some custom stuff to message

        # make sure the formatter logs the correct calling method.
        $self->incrSkip();
        $self->SUPER::log($lvl, $msg);
        $self->decrSkip();

    } # log()

    perldoc Log::Fine

  $Id: 127903180f3b98bf23dd379f25bf110fc0e8b435 $

	The BSD License

use strict;
use warnings;

package Log::Fine::Logger;

use base qw( Log::Fine );

use Log::Fine;

our $VERSION = $Log::Fine::VERSION;

# Constant: LOG_SKIP_DEFAULT
#
# By default, calls to caller() will be given a stack frame of 2.

use constant LOG_SKIP_DEFAULT => 2;

# --------------------------------------------------------------------

sub decrSkip { return --$_[0]->{_skip}; }          # decrSkip()

sub incrSkip { return ++$_[0]->{_skip}; }          # incrSkip()

sub log
{

        my $self = shift;
        my $lvl  = shift;
        my $msg  = shift;

        # see if we have any handles defined
        $self->_fatal("No handles defined!")
            unless (    defined $self->{_handles}
                    and ref $self->{_handles} eq "ARRAY"
                    and scalar @{ $self->{_handles} } > 0);

        # iterate through each handle, logging as appropriate
        foreach my $handle (@{ $self->{_handles} }) {
                $handle->msgWrite($lvl, $msg, $self->{_skip})
                    if $handle->isLoggable($lvl);
        }

        # Victory
        return $self;

}          # log()

sub registerHandle
{

        my $self   = shift;
        my $handle = shift;

        # validate handle
        $self->_fatal(
                    "first argument must be a valid Log::Fine::Handle object\n")
            unless (defined $handle
                    and $handle->isa("Log::Fine::Handle"));

        # initialize handles if we haven't already
        $self->{_handles} = []
            unless (defined $self->{_handles}
                    and ref $self->{_handles} eq "ARRAY");

        # save the handle
        push @{ $self->{_handles} }, $handle;

        return $self;

}          # registerHandle()

sub skip
{

        my $self = shift;
        my $val  = shift;

        # if we are given a value, then set skip
        $self->{_skip} = $val
            if (defined $val and $val =~ /^\d+$/);

        return $self->{_skip};

}          # skip()

# --------------------------------------------------------------------

##
# Initializes our object

sub _init
{

        my $self = shift;

        # validate name
        $self->_fatal("Loggers need names!")
            unless (defined $self->{name} and $self->{name} =~ /^\w+$/);

        # set logskip if necessary
        $self->{_skip} = LOG_SKIP_DEFAULT
            unless ($self->{_skip} and $self->{_skip} =~ /\d+/);

        return $self;

}          # _init()

1;          # End of Log::Fine::Logger