NAME

VERSION

SYNOPSIS

 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 {

   my $minilogger = Log::Contextual::SimpleLogger->new({
     levels => [qw( trace debug )]
   });

   my @args = @_;

   with_logger $minilogger => sub {
     log_trace { 'foo entered' };
     my ($foo, $bar) = Dlog_trace { "params for foo: $_" } @args;
     # ...
     slog_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' };

DESCRIPTION

• Efficient

  The default logging functions take blocks, so if a log level is disabled, the block will not run:

   # the following won't run if debug is off
   log_debug { "the new count in the database is " . $rs->count };
      

  Similarly, the "D" prefixed methods only "Dumper" the input if the level is enabled.

• Handy

  The logging functions return their arguments, so you can stick them in the middle of expressions:

   for (log_debug { "downloading:\n" . join qq(\n), @_ } @urls) { ... }
      

• Generic

  "Log::Contextual" is an interface for all major loggers. If you log through "Log::Contextual" you will be able to swap underlying loggers later.

• Powerful

  "Log::Contextual" chooses which logger to use based on user defined "CodeRef"s. Normally you don't need to know this, but you can take advantage of it when you need to later.

• Scalable

  If you just want to add logging to your basic application, start with Log::Contextual::SimpleLogger and then as your needs grow you can switch to Log::Dispatchouli or Log::Dispatch or Log::Log4perl or whatever else.

This module is a simple interface to extensible logging. It exists to abstract your logging interface so that logging is as painless as possible, while still allowing you to switch from one logger to another.

It is bundled with a really basic logger, Log::Contextual::SimpleLogger, but in general you should use a real logger instead. For something more serious but not overly complicated, try Log::Dispatchouli (see "SYNOPSIS" for example.)

A WORK IN PROGRESS

 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.

IMPORT OPTIONS

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

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

 use Log::Contextual
   -levels => [qw( debug info notice warning error critical alert emergency )];

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

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

SETTING DEFAULT IMPORT OPTIONS

 use Log::Log4perl;
 use Log::Log4perl ':easy';
 BEGIN { Log::Log4perl->easy_init($DEBUG) }

 use Log::Contextual -logger => Log::Log4perl->get_logger;

You can set any of the import options for your whole project if you define your own "Log::Contextual" subclass as follows:

 package MyApp::Log::Contextual;

 use base 'Log::Contextual';

 use Log::Log4perl ':easy';
 Log::Log4perl->easy_init($DEBUG)

 sub arg_default_logger { $_[1] || Log::Log4perl->get_logger }
 sub arg_levels { [qw(debug trace warn info error fatal custom_level)] }
 sub default_import { ':log' }

 # or maybe instead of default_logger
 sub arg_package_logger { $_[1] }

 # and almost definitely not this, which is only here for completeness
 sub arg_logger { $_[1] }

Note the "$_[1] ||" in "arg_default_logger". All of these methods are passed the values passed in from the arguments to the subclass, so you can either throw them away, honor them, die on usage, etc. To be clear, if you define your subclass, and someone uses it as follows:

 use MyApp::Log::Contextual -default_logger => $foo,
                            -levels => [qw(bar baz biff)];

Your "arg_default_logger" method will get $foo and your "arg_levels" will get "[qw(bar baz biff)]";

Additionally, the "default_import" method is what happens if a user tries to use your subclass with no arguments. The default just dies, but if you'd like to change the default to import a tag merely return the tags you'd like to import. So the following will all work:

 sub default_import { ':log' }

 sub default_import { ':dlog' }

 sub default_import { qw(:dlog :log ) }

See Log::Contextual::Easy::Default for an example of a subclass of "Log::Contextual" that makes use of default import options.

FUNCTIONS

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

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

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

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

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

 my @friends = slog_trace 'friends list being generated.', generate_friend_list();

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

 my $friend = slogS_trace 'I only have one friend.', friend();

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

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

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

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

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

LOGGER CODEREF

Here is a basic example of a logger that exploits "caller" to reproduce the output of "warn" with a logger:

 my @caller_info;
 my $var_log = Log::Contextual::SimpleLogger->new({
    levels  => [qw(trace debug info warn error fatal)],
    coderef => sub { chomp($_[0]); warn "$_[0] at $caller_info[1] line $caller_info[2].\n" }
 });
 my $warn_faker = sub {
    my ($package, $args) = @_;
    @caller_info = caller($args->{caller_level});
    $var_log
 };
 set_logger($warn_faker);
 log_debug { 'test' };

The following is an example that uses the information passed to the logger coderef. It sets the global logger to $l3, the logger for the "A1" package to $l1, except the "lol" method in "A1" which uses the $l2 logger and lastly the logger for the "A2" package to $l2.

Note that it increases the caller level as it dispatches based on where the caller of the log function, not the log function itself.

 my $complex_dispatcher = do {

    my $l1 = ...;
    my $l2 = ...;
    my $l3 = ...;

    my %registry = (
       -logger => $l3,
       A1 => {
          -logger => $l1,
          lol     => $l2,
       },
       A2 => { -logger => $l2 },
    );

    sub {
       my ( $package, $info ) = @_;

       my $logger = $registry{'-logger'};
       if (my $r = $registry{$package}) {
          $logger = $r->{'-logger'} if $r->{'-logger'};
          my (undef, undef, undef, $sub) = caller($info->{caller_level} + 1);
          $sub =~ s/^\Q$package\E:://g;
          $logger = $r->{$sub} if $r->{$sub};
       }
       return $logger;
    }
 };

 set_logger $complex_dispatcher;

LOGGER INTERFACE

 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.

LOG ROUTING

"Log::Contextual" and packages that extend it will by default share a router singleton that implements the with_logger() and set_logger() functions and also respects the -logger, -package_logger, and -default_logger import options with their associated default value functions. The router singleton is available as the return value of the router() function. Users of Log::Contextual may overload router() to return instances of custom log routers that could for example work with loggers that use a different interface.

EXCEPTIONS AND ERROR HANDLING

Logging events are characterized as information, not flow control, and conflating the two results in negative design anti-patterns.

As such, "log_fatal" would at be better used to communicate information about a future failure, for example:

  if ( condition ) {
    log_fatal { "Bad Condition is true" };
    die My::Exception->new();
  }

This has a number of benefits:

• You're more likely to want to use useful Exception Objects and flow control instead of cheating with log messages.
• You're less likely to run a risk of losing what the actual problem was when some error occurs in your creation of the Exception Object
• You're less likely to run the risk of losing important log context due to exceptions occurring mid way through "die" unwinding and "exit" global destruction.

If you're still too lazy to use exceptions, then you can do what you probably want as follows:

  if ( ... ) {
    log_fatal { "Bad condition is true" };
    die "Bad condtion is true";
  }

Or for ":dlog" style:

  use Data::Dumper::Consise qw( Dumper );
  if ( ... ) {
    # Dlog_fatal but not
    my $reason = "Bad condtion is true because: " . Dumper($thing);
    log_fatal { $reason };
    die $reason;
  }

CONTRIBUTORS

triddle - Tyler Riddle <t.riddle@shadowcat.co.uk>

voj - Jakob Voß <voss@gbv.de>

DESIGNER

AUTHOR

COPYRIGHT AND LICENSE

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.