Log::Fine::Handle::File - Output log messages to a file

    use Log::Fine;
    use Log::Fine::Handle::File;

    # Get a new logger
    my $log = Log::Fine->logger("foo");

    # register a file handle (default values shown)
    my $handle = Log::Fine::Handle::File
        ->new( name => 'file0',
               mask => LOGMASK_EMERG | LOGMASK_ALERT | LOGMASK_CRIT | LOGMASK_ERR | LOGMASK_WARNING | LOGMASK_NOTICE | LOGMASK_INFO,
               dir  => "/var/log",
               file => "myapp.log",
               autoflush => 0 );

    # register the handle
    $log->registerHandle($handle);

    # log something
    $log->(INFO, "Opened new log handle");

    perldoc Log::Fine

  $Id: 7d48f55551c9b717fcea78f283b1ddfccff37d8a $

	The BSD License

use strict;
use warnings;

package Log::Fine::Handle::File;

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

use File::Basename;
use File::Spec::Functions;
use FileHandle;
use Log::Fine;

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

sub fileHandle
{

        my $self = shift;

        # if we already have a file handle defined, return it
        return $self->{_filehandle}
            if (    defined $self->{_filehandle}
                and $self->{_filehandle}->isa("IO::File")
                and defined fileno($self->{_filehandle}));

        # generate file name
        my $filename = catdir($self->{dir}, $self->{file});

        # otherwise create a new one
        $self->{_filehandle} = FileHandle->new(">> " . $filename);

        $self->_fatal("Unable to open log file $filename : $!\n")
            unless defined $self->{_filehandle};

        # set autoflush if necessary
        $self->{_filehandle}->autoflush($self->{autoflush});

        # return the newly created file handle
        return $self->{_filehandle};

}          # fileHandle()

sub msgWrite
{

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

        # grab a ref to our file handle
        my $fh = $self->fileHandle();

        # if we have a formatter defined, then use that, otherwise, just
        # print the raw message
        $msg = $self->{formatter}->format($lvl, $msg, $skip)
            if defined $self->{formatter};

        # print the message to the log file
        print $fh $msg;

        # if autoclose is set, then close the file handle.  This will
        # force the creation of a new filehandle next time this method
        # is called
        $self->fileHandle()->close() if $self->{autoclose};

        # Victory!
        return $self;

}          # msgWrite()

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

##
# Initializes our object

sub _init
{

        my $self = shift;

        # call the super object
        $self->SUPER::_init();

        # default directory is the current directory
        $self->{dir} = "./"
            unless (defined $self->{dir} and -d $self->{dir});

        # default file name is the name of the invoking program
        # suffixed with ".log"
        $self->{file} = basename $0 . ".log"
            unless defined $self->{file};

        # autoflush is disabled by default
        $self->{autoflush} = 0
            unless defined $self->{autoflush};

        # autoclose is disabled by default
        $self->{autoclose} = 0
            unless defined $self->{autoclose};

        # Victory!
        return $self;

}          # _init()

##
# called when this object is destroyed

sub DESTROY
{

        my $self = shift;

        # close our filehandle if necessary.
        $self->{_filehandle}->close()
            if (defined $self->{_filehandle}
                and $self->{_filehandle}->isa("IO::File"));

}          # DESTROY

1;          # End of Log::Fine::Handle::File