File Coverage

blib/lib/MojoX/Log/Rotate.pm

Criterion	Covered	Total	%
statement	60	82	73.1
branch	12	20	60.0
condition	3	7	42.8
subroutine	6	10	60.0
pod	2	6	33.3
total	83	125	66.4

package MojoX::Log::Rotate;
$MojoX::Log::Rotate::VERSION = '1.222670';
# ABSTRACT: Makes mojolicious log file rotation easy
use Mojo::Base 'Mojo::Log', -signatures;
use Mojo::File;

has 'need_rotate_cb';
has 'rotate_cb';
has last_rotate => sub ($s) { $s->path && -f $s->path ? (stat $s->path)[10] : time() };
has frequency => 60 * 60 * 24; #every day

#for threading supports
has '_thread';
has '_queue';

sub new ($class, %params)  {
  my %p = map  { $_ => delete $params{$_} }
          grep { exists $params{$_} }
          qw(frequency how when threaded on_rotate);
  my $self = $class->SUPER::new(%params);

  $self->frequency($p{frequency}) if exists $p{frequency};
  $self->rotate_cb($p{how} // \&default_rotation_cb);
  $self->need_rotate_cb($p{when} // \&default_need_rotation_cb);
  $self->on(rotate => $p{on_rotate}) if exists $p{on_rotate};

  if($p{threaded}) {
    #force calculation of initial last_rotate;
    $self->last_rotate;
    $self->initialize_thread_support;
  }
  else{
    #inject our message subscrition on the top
    my $subscribers = $self->subscribers('message');
    $self->unsubscribe('message');
    $self->on(message => \&on_message_handler);
    $self->on(message => $_) for @$subscribers;
  }


  $self;
}

sub on_message_handler ($self, $level, @args) {
  my $cb_when = $self->need_rotate_cb;
  my $cb_how  = $self->rotate_cb;
  if($cb_when && $cb_how) {
    if(my $when_res = $cb_when->($self)) {
      $self->last_rotate( time() );
      my $how_res = $cb_how->($self, $when_res);
      $self->emit('rotate' => { how => $how_res, when => $when_res });
    }
  }
}

# must returns a false value when there is no need to rotate, or a true value.
# the returns value will be passed to the rotate_cb so that you can share data between callback.
sub default_need_rotation_cb ($self) {
  return unless $self->path;
  if(time - $self->last_rotate > $self->frequency ) {
    my $last_rotate = $self->last_rotate;
    return { last_rotate => $last_rotate };
  }
  return;
}

sub default_rotation_cb ($self, $when_res) {
  my $res = { }; #nothing to rotate
  if(my $handle = $self->handle) {
    if(-f $self->path) {
      my ($y, $m, $d, $h, $mi, $s) =  (localtime)[5, 4, 3, 2, 1, 0];
      my $suffix = sprintf("_%04d%02d%02d_%02d%02d%02d", $y+1900, $m+1, $d, $h, $mi, $s);
      my $new_name = $self->path =~ s/(\.[^.]+)$/$suffix$1/r;
      $handle->flush;
      $handle->close;
      Mojo::File->new($self->path)->move_to($new_name)
        or die "MojoX::Log::Rotation failed to move " . $self->path . " into $new_name : $!";
      $res = { rotated_file => $new_name };
    }
  }
  $self->handle(Mojo::File->new($self->path)->open('>>'));
  return $res;
}

sub initialize_thread_support ($self) {#may not works well with multiple loggers...
  eval 'use threads; use Thread::Queue; use Mojo::Util';
  my $q = Thread::Queue->new;
  my $appender = \&Mojo::Log::append;
  my $thlog = threads->create(sub {
      while(defined(my $job = $q->dequeue)) {
        $appender->($self, $job->{msg});
        on_message_handler($self, '', '');
      }
  });
  Mojo::Util::monkey_patch('Mojo::Log', 'append', sub {
      my ($self, $msg) = @_;
      $q->enqueue({type => 'msg', msg => $msg});
  });
  $self->_queue($q);
  $self->_thread($thlog);
}

sub stop ($self) {
  $self->_queue->end;
  $self->_thread->join;
}
1;

__END__