Log::Contextual - Simple logging interface with a contextual log

 use Log::Contextual qw( :log :dlog set_logger with_logger );
 use Log::Contextual::SimpleLogger;
 use Log::Log4perl ':easy';
 Log::Log4perl->easy_init($DEBUG);




 my $logger  = Log::Log4perl->get_logger;

 set_logger $logger;

 log_debug { 'program started' };

 sub foo {
   with_logger(Log::Contextual::SimpleLogger->new({
       levels => [qw( trace debug )]
     }) => sub {
     log_trace { 'foo entered' };
     my ($foo, $bar) = Dlog_trace { "params for foo: $_" } @_;
     # ...
     log_trace { 'foo left' };
   });
 }

 foo();

Beginning with version 1.008 Log::Dispatchouli also works out of the box with Log::Contextual:

 use Log::Contextual qw( :log :dlog set_logger );
 use Log::Dispatchouli;
 my $ld = Log::Dispatchouli->new({
    ident     => 'slrtbrfst',
    to_stderr => 1,
    debug     => 1,
 });

 set_logger $ld;

 log_debug { 'program started' };

This module is a simple interface to extensible logging. It is bundled with a really basic logger, Log::Contextual::SimpleLogger, but in general you should use a real logger instead of that. For something more serious but not overly complicated, try Log::Dispatchouli (see SYNOPSIS for example.)

When you import this module you may use -logger as a shortcut for set_logger, for example:

 use Log::Contextual::SimpleLogger;
 use Log::Contextual qw( :dlog ),
   -logger => Log::Contextual::SimpleLogger->new({ levels => [qw( debug )] });

sometimes you might want to have the logger handy for other stuff, in which case you might try something like the following:

 my $var_log;
 BEGIN { $var_log = VarLogger->new }
 use Log::Contextual qw( :dlog ), -logger => $var_log;

The -package_logger import option is similar to the -logger import option except -package_logger sets the the logger for the current package.

Unlike -default_logger, -package_logger cannot be overridden with set_logger.

 package My::Package;
 use Log::Contextual::SimpleLogger;
 use Log::Contextual qw( :log ),
   -package_logger => Log::Contextual::WarnLogger->new({
      env_prefix => 'MY_PACKAGE'
   });

If you are interested in using this package for a module you are putting on CPAN we recommend Log::Contextual::WarnLogger for your package logger.

The -default_logger import option is similar to the -logger import option except -default_logger sets the the default logger for the current package.

Basically it sets the logger to be used if set_logger is never called; so

 package My::Package;
 use Log::Contextual::SimpleLogger;
 use Log::Contextual qw( :log ),
   -default_logger => Log::Contextual::WarnLogger->new({
      env_prefix => 'MY_PACKAGE'
   });

This module is certainly not complete, but we will not break the interface lightly, so I would say it's safe to use in production code. The main result from that at this point is that doing:

 use Log::Contextual;

will die as we do not yet know what the defaults should be. If it turns out that nearly everyone uses the :log tag and :dlog is really rare, we'll probably make :log the default. But only time and usage will tell.

 my $logger = WarnLogger->new;
 set_logger $logger;

Arguments: Ref|CodeRef $returning_logger

set_logger will just set the current logger to whatever you pass it. It expects a CodeRef, but if you pass it something else it will wrap it in a CodeRef for you. set_logger is really meant only to be called from a top-level script. To avoid foot-shooting the function will warn if you call it more than once.

 my $logger = WarnLogger->new;
 with_logger $logger => sub {
    if (1 == 0) {
       log_fatal { 'Non Logical Universe Detected' };
    } else {
       log_info  { 'All is good' };
    }
 };

Arguments: Ref|CodeRef $returning_logger, CodeRef $to_execute

with_logger sets the logger for the scope of the CodeRef $to_execute. As with set_logger, with_logger will wrap $returning_logger with a CodeRef if needed.

Import Tag: :log

Arguments: CodeRef $returning_message, @args

All of the following six functions work the same except that a different method is called on the underlying $logger object. The basic pattern is:

 sub log_$level (&@) {
   if ($logger->is_$level) {
     $logger->$level(shift->(@_));
   }
   @_
 }

Note that the function returns it's arguments. This can be used in a number of ways, but often it's convenient just for partial inspection of passthrough data

 my @friends = log_trace {
   'friends list being generated, data from first friend: ' .
     Dumper($_[0]->TO_JSON)
 } generate_friend_list();

If you want complete inspection of passthrough data, take a look at the Dlog_$level functions.

 log_trace { 'entered method foo with args ' join q{,}, @args };

 log_debug { 'entered method foo' };

 log_info { 'started process foo' };

 log_warn { 'possible misconfiguration at line 10' };

 log_error { 'non-numeric user input!' };

 log_fatal { '1 is never equal to 0!' };

Import Tag: :log

Arguments: CodeRef $returning_message, Item $arg

This is really just a special case of the log_$level functions. It forces scalar context when that is what you need. Other than that it works exactly same:

 my $friend = logS_trace {
   'I only have one friend: ' .  Dumper($_[0]->TO_JSON)
 } friend();

See also: DlogS_$level.

Import Tag: :dlog

Arguments: CodeRef $returning_message, @args

All of the following six functions work the same as their log_$level brethren, except they return what is passed into them and put the stringified (with Data::Dumper::Concise) version of their args into $_. This means you can do cool things like the following:

 my @nicks = Dlog_debug { "names: $_" } map $_->value, $frew->names->all;

and the output might look something like:

 names: "fREW"
 "fRIOUX"
 "fROOH"
 "fRUE"
 "fiSMBoC"

 my ($foo, $bar) = Dlog_trace { "entered method foo with args: $_" } @_;

 Dlog_debug { "random data structure: $_" } { foo => $bar };

 return Dlog_info { "html from method returned: $_" } "<html>...</html>";

 Dlog_warn { "probably invalid value: $_" } $foo;

 Dlog_error { "non-numeric user input! ($_)" } $port;

 Dlog_fatal { '1 is never equal to 0!' } 'ZOMG ZOMG' if 1 == 0;

Import Tag: :dlog

Arguments: CodeRef $returning_message, Item $arg

Like logS_$level, these functions are a special case of Dlog_$level. They only take a single scalar after the $returning_message instead of slurping up (and also setting wantarray) all the @args

 my $pals_rs = DlogS_debug { "pals resultset: $_" }
   $schema->resultset('Pals')->search({ perlers => 1 });

Because this module is ultimately pretty looking glue (glittery?) with the awesome benefit of the Contextual part, users will often want to make their favorite logger work with it. The following are the methods that should be implemented in the logger:

 is_trace
 is_debug
 is_info
 is_warn
 is_error
 is_fatal
 trace
 debug
 info
 warn
 error
 fatal

The first six merely need to return true if that level is enabled. The latter six take the results of whatever the user returned from their coderef and log them. For a basic example see Log::Contextual::SimpleLogger.

frew - Arthur Axel "fREW" Schmidt <frioux@gmail.com>

mst - Matt S. Trout <mst@shadowcat.co.uk>

Copyright (c) 2010 the Log::Contextual AUTHOR and DESIGNER as listed above.

This library is free software and may be distributed under the same terms as Perl 5 itself.