File Coverage

blib/lib/Log/File/Rolling.pm

Criterion	Covered	Total	%
statement	72	76	94.7
branch	17	24	70.8
condition	11	25	44.0
subroutine	12	12	100.0
pod	2	2	100.0
total	114	139	82.0

package Log::File::Rolling;

use 5.006001;
use strict;
use warnings;

use Time::Piece;
use Fcntl ':flock'; # import LOCK_* constants

our $VERSION = '0.101';



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

    my %p = @_;

    my $self = bless {}, $class;

    # base class initialization
    #$self->_basic_init(%p);

    $self->{timezone} = $p{timezone} || 'gmtime';
    die "unsupported timezone: '$self->{timezone}' (currently must be 'localtime' or 'gmtime')"
        if $self->{timezone} ne 'localtime' && $self->{timezone} ne 'gmtime';

    $self->{filename_format} = $p{filename};

    if (exists $p{current_symlink}) {
        $self->{current_symlink} = $p{current_symlink};
    }

    $self->{rolling_fh_pid} = $$;
    $self->_createFilename();
    $self->_rolling_open_file();

    return $self;
}

sub log { # parts borrowed from Log::Dispatch::FileRotate, Thanks!
    my $self = shift;
    my $message = shift;

    if ($self->_createFilename()) {
        $self->{rolling_fh_pid} = 'x'; # force reopen
    }

    if (defined $self->{fh} and ($self->{rolling_fh_pid}||'') eq $$ and defined fileno $self->{fh}) { # flock won't work after a fork()
        my $inode  = (stat($self->{fh}))[1];         # get real inode
        my $finode = (stat($self->{filename}))[1];   # Stat the name for comparision
        if(!defined($finode) || $inode != $finode) { # Oops someone moved things on us. So just reopen our log
            $self->_rolling_open_file;
        } elsif (!$self->{current_symlink_inited}) {
            $self->_update_current_symlink;
        }
        $self->_lock();
        my $fh = $self->{fh};
        print $fh $message;
        $self->_unlock();
    } else {
        $self->{rolling_fh_pid} = $$;
        $self->_rolling_open_file;
        $self->_lock();
        my $fh = $self->{fh};
        print $fh $message;
        $self->_unlock();
    }
}

sub _rolling_open_file {
    my $self = shift;

    open my $fh, '>>:raw', $self->{filename}
        or die "Cannot write to '$self->{filename}': $!";
    $self->{fh} = $fh;

    $self->_update_current_symlink;
}

sub _update_current_symlink {
    my $self = shift;

    return if !exists $self->{current_symlink};

    my $current_symlink_value = readlink($self->{current_symlink});

    if (!defined $current_symlink_value || $current_symlink_value ne $self->{filename}) {
        my $temp_symlink_file = "$self->{current_symlink}.temp$$";
        unlink($temp_symlink_file);

        symlink($self->{filename}, $temp_symlink_file)
            || die "unable to create symlink '$temp_symlink_file': $!";

        if (!rename($temp_symlink_file, $self->{current_symlink})) {
            unlink($temp_symlink_file);
            die "unable to overwrite symlink '$self->{current_symlink}': $!";
        }
    }

    $self->{current_symlink_inited} = 1;
}

sub _lock { # borrowed from Log::Dispatch::FileRotate, Thanks!
    my $self = shift;
    flock($self->{fh},LOCK_EX);
    # Make sure we are at the EOF
    seek($self->{fh}, 0, 2);
    return 1;
}

sub _unlock { # borrowed from Log::Dispatch::FileRotate, Thanks!
    my $self = shift;
    flock($self->{fh},LOCK_UN);
    return 1;
}


## Returns true if the filename changed
sub _createFilename {
    my $self = shift;

    my $time = time();
    return 0 if defined $self->{current_filename_time} && $time == $self->{current_filename_time};

    $self->{filename} = Time::Piece->${\$self->{timezone}}->strftime($self->{filename_format});
    $self->{current_filename_time} = $time;
    return 1;
}

1;




__END__