File Coverage

blib/lib/MojoX/Logite.pm

Criterion	Covered	Total	%
statement	61	68	89.7
branch	15	24	62.5
condition	4	9	44.4
subroutine	13	14	92.8
pod	5	5	100.0
total	98	120	81.6

package MojoX::Logite;

use strict;
use warnings;

use Carp 'croak';

use base 'Mojo::Log';

use Mojo::Util qw (camelize);

our $VERSION = '0.01';

our $LOG_TABLE = 'LogiteTable';
our $LOG_IDX1 = $LOG_TABLE.'Idx1';
our $LOG_IDX2 = $LOG_TABLE.'Idx2';
our $LOG_SCHEMA = <
CREATE TABLE $LOG_TABLE (
                      l_id          INTEGER UNIQUE PRIMARY KEY AUTOINCREMENT,
                      l_who_app     TEXT DEFAULT NULL,
                      l_who_mod     TEXT DEFAULT NULL,
                      l_who_pos     TEXT DEFAULT NULL,
                      l_who_id      TEXT DEFAULT NULL,
                      l_what        TEXT DEFAULT NULL,
                      l_when        INTEGER NOT NULL,
                      l_level       CHAR(10) DEFAULT NULL
                      );
CREATE INDEX IF NOT EXISTS $LOG_IDX1 ON $LOG_TABLE (l_when);
CREATE INDEX IF NOT EXISTS $LOG_IDX2 ON $LOG_TABLE (l_level,l_who_app,l_who_mod);
SCHEMA

# some ORLite attributes
__PACKAGE__->attr('package' => 'MojoX::Logite');
__PACKAGE__->attr('prune' => 0);
__PACKAGE__->attr('user_version');
__PACKAGE__->attr('cache');
__PACKAGE__->attr('readonly');

__PACKAGE__->attr('app');

__PACKAGE__->attr('context_stack' => sub { [] });
__PACKAGE__->attr('context_map' => sub { {} });

sub new
{
  my $class = shift;

  my $self = $class->SUPER::new(@_);
  bless $self, $class;

  # ORLite dynamic stuff
  require ORLite;
  my %orlite_options = (
    file    => $self->path,
    package => $self->package,
    cleanup => 'VACUUM',
    create  => sub {
      my $dbh = shift;
      $dbh->do($LOG_SCHEMA);
      },
    tables => [ $LOG_TABLE ],
    prune  => $self->prune,
  );

  if ($self->user_version)
    {
      $orlite_options{ user_version } = $self->user_version;
      my $pkg = $self->package;
      no strict 'refs';
      ${"$pkg\::VERSION"} = $self->user_version;
    }
  $orlite_options{ cache } = $self->cache
    if ($self->cache);

  ORLite->import( \%orlite_options );

  return $self;
}

sub package_table
{
  my ($self) = @_;

  return $self->package.'::'.camelize($LOG_TABLE);
}

sub schema
{
  my ($self) = @_;

  return $LOG_SCHEMA;
}

# override log method
sub log
{
  my ($self, $level, @msgs) = @_;

  # Check log level
  $level = lc $level;
  return $self unless $level && $self->is_level($level);

  my $timestamp = time; # time in milliseconds
  my $msgs = join "\n",
    map { utf8::decode $_ unless utf8::is_utf8 $_;
          $self->_placeholders($_); } @msgs;

  # Caller
  my ($pkg, $line) = (caller())[0, 2];
  ($pkg, $line) = (caller(1))[0, 2] if $pkg eq ref $self or $pkg =~ m/Mojo::Log/;

  my %log_message = (
    'l_who_mod'  => $pkg,
    'l_who_pos'  => $line,
    'l_who_id'   => $$,
    'l_what'     => $msgs,
    'l_when'     => int($timestamp),
    'l_level'    => $level
    );

  $log_message{ 'l_who_app' } = $self->app
    if ($self->app);

  # Write
  $self->package_table->create( %log_message );

  return $self;
}

sub clear
{
  my ($self, $numdays) = @_;

  croak qq/Not a valid number of days $numdays/
    unless ($numdays =~ m/^\d+$/ && $numdays >= 0);

  my $package = $self->package_table;

  # Delete
  if ($numdays == 0)
    {
      $self->package_table->truncate;
    }
  else
    {
      $self->package_table->delete('WHERE t_when ts < strftime("%s","now", "-? day"); ', $numdays);
    }

  return $self;
}

sub _placeholders
{
  my ($self, $msg) = @_;

  $msg =~ s/%([xX])(?:{(.*?)})*/_replace($self, $1, $2);/gex;

  return $msg;
}

sub _replace
{
  my ($self, $what, $key) = @_;

  my $ret = "[undef]";

  if ($what eq 'x')
    {
      $ret = join " ", @{$self->context_stack}
        if (defined $self->context_stack->[-1]);
    }
  elsif ($what eq 'X')
    {
      $ret = $self->context_map->{$key}
        if (exists $self->context_map->{$key});
    }

  return $ret;
}

1;

__END__