use strict;
use warnings;
-our $VERSION = '0.00100';
+our $VERSION = '0.00202';
require Exporter;
use Data::Dumper::Concise;
+use Scalar::Util 'blessed';
BEGIN { our @ISA = qw(Exporter) }
unless @_;
for my $idx ( 0 .. $#_ ) {
- if ( $_[$idx] eq '-logger' ) {
+ my $val = $_[$idx];
+ if ( defined $val && $val eq '-logger' ) {
set_logger($_[$idx + 1]);
splice @_, $idx, 2;
- last;
+ } elsif ( defined $val && $val eq '-package_logger' ) {
+ _set_package_logger_for(scalar caller, $_[$idx + 1]);
+ splice @_, $idx, 2;
+ } elsif ( defined $val && $val eq '-default_logger' ) {
+ _set_default_logger_for(scalar caller, $_[$idx + 1]);
+ splice @_, $idx, 2;
}
}
$package->export_to_level(1, $package, @_);
}
our $Get_Logger;
+our %Default_Logger;
+our %Package_Logger;
+
+sub _set_default_logger_for {
+ my $logger = $_[1];
+ if(ref $logger ne 'CODE') {
+ die 'logger was not a CodeRef or a logger object. Please try again.'
+ unless blessed($logger);
+ $logger = do { my $l = $logger; sub { $l } }
+ }
+ $Default_Logger{$_[0]} = $logger
+}
+
+sub _set_package_logger_for {
+ my $logger = $_[1];
+ if(ref $logger ne 'CODE') {
+ die 'logger was not a CodeRef or a logger object. Please try again.'
+ unless blessed($logger);
+ $logger = do { my $l = $logger; sub { $l } }
+ }
+ $Package_Logger{$_[0]} = $logger
+}
+
+sub _get_logger($) {
+ my $package = shift;
+ (
+ $Package_Logger{$package} ||
+ $Get_Logger ||
+ $Default_Logger{$package} ||
+ die q( no logger set! you can't try to log something without a logger! )
+ )->($package);
+}
sub set_logger {
my $logger = $_[0];
- $logger = do { my $l = $logger; sub { $l } }
- if ref $logger ne 'CODE';
+ if(ref $logger ne 'CODE') {
+ die 'logger was not a CodeRef or a logger object. Please try again.'
+ unless blessed($logger);
+ $logger = do { my $l = $logger; sub { $l } }
+ }
+
+ warn 'set_logger (or -logger) called more than once! This is a bad idea!'
+ if $Get_Logger;
$Get_Logger = $logger;
}
sub with_logger {
my $logger = $_[0];
- $logger = do { my $l = $logger; sub { $l } }
- if ref $logger ne 'CODE';
+ if(ref $logger ne 'CODE') {
+ die 'logger was not a CodeRef or a logger object. Please try again.'
+ unless blessed($logger);
+ $logger = do { my $l = $logger; sub { $l } }
+ }
local $Get_Logger = $logger;
$_[1]->();
}
+sub _do_log {
+ my $level = shift;
+ my $logger = shift;
+ my $code = shift;
+ my @values = @_;
-
-sub log_trace (&@) {
- my $log = $Get_Logger->();
- my $code = shift;
- $log->trace($code->(@_))
- if $log->is_trace;
- @_
-}
-
-sub log_debug (&@) {
- my $log = $Get_Logger->();
- my $code = shift;
- $log->debug($code->(@_))
- if $log->is_debug;
- @_
+ local $Log::Log4perl::caller_depth = ($Log::Log4perl::caller_depth || 0 ) + 2;
+ $logger->$level($code->(@_))
+ if $logger->${\"is_$level"};
+ @values
}
-sub log_info (&@) {
- my $log = $Get_Logger->();
- my $code = shift;
- $log->info($code->(@_))
- if $log->is_info;
- @_
-}
-
-sub log_warn (&@) {
- my $log = $Get_Logger->();
- my $code = shift;
- $log->warn($code->(@_))
- if $log->is_warn;
- @_
-}
+sub _do_logS {
+ my $level = shift;
+ my $logger = shift;
+ my $code = shift;
+ my $value = shift;
-sub log_error (&@) {
- my $log = $Get_Logger->();
- my $code = shift;
- $log->error($code->(@_))
- if $log->is_error;
- @_
-}
-
-sub log_fatal (&@) {
- my $log = $Get_Logger->();
- my $code = shift;
- $log->fatal($code->(@_))
- if $log->is_fatal;
- @_
-}
-
-
-sub logS_trace (&$) {
- my $log = $Get_Logger->();
- my $code = shift;
- my $value = shift;
- $log->trace($code->($value))
- if $log->is_trace;
- $value
-}
-
-sub logS_debug (&$) {
- my $log = $Get_Logger->();
- my $code = shift;
- my $value = shift;
- $log->debug($code->($value))
- if $log->is_debug;
- $value
-}
-
-sub logS_info (&$) {
- my $log = $Get_Logger->();
- my $code = shift;
- my $value = shift;
- $log->info($code->($value))
- if $log->is_info;
+ local $Log::Log4perl::caller_depth = ($Log::Log4perl::caller_depth || 0 ) + 2;
+ $logger->$level($code->($value))
+ if $logger->${\"is_$level"};
$value
}
-sub logS_warn (&$) {
- my $log = $Get_Logger->();
- my $code = shift;
- my $value = shift;
- $log->warn($code->($value))
- if $log->is_warn;
- $value
-}
-
-sub logS_error (&$) {
- my $log = $Get_Logger->();
- my $code = shift;
- my $value = shift;
- $log->error($code->($value))
- if $log->is_error;
- $value
-}
-
-sub logS_fatal (&$) {
- my $log = $Get_Logger->();
- my $code = shift;
- my $value = shift;
- $log->fatal($code->($value))
- if $log->is_fatal;
- $value
-}
+sub log_trace (&@) { _do_log( trace => _get_logger( caller ), shift @_, @_) }
+sub log_debug (&@) { _do_log( debug => _get_logger( caller ), shift @_, @_) }
+sub log_info (&@) { _do_log( info => _get_logger( caller ), shift @_, @_) }
+sub log_warn (&@) { _do_log( warn => _get_logger( caller ), shift @_, @_) }
+sub log_error (&@) { _do_log( error => _get_logger( caller ), shift @_, @_) }
+sub log_fatal (&@) { _do_log( fatal => _get_logger( caller ), shift @_, @_) }
+sub logS_trace (&$) { _do_logS( trace => _get_logger( caller ), $_[0], $_[1]) }
+sub logS_debug (&$) { _do_logS( debug => _get_logger( caller ), $_[0], $_[1]) }
+sub logS_info (&$) { _do_logS( info => _get_logger( caller ), $_[0], $_[1]) }
+sub logS_warn (&$) { _do_logS( warn => _get_logger( caller ), $_[0], $_[1]) }
+sub logS_error (&$) { _do_logS( error => _get_logger( caller ), $_[0], $_[1]) }
+sub logS_fatal (&$) { _do_logS( fatal => _get_logger( caller ), $_[0], $_[1]) }
sub Dlog_trace (&@) {
my $code = shift;
- my @values = @_;
- return log_trace {
- if (@values) {
- do { local $_ = Data::Dumper::Concise::Dumper @values; $code->() };
- } else {
- do { local $_ = '()'; $code->() };
- }
- } @values
+ local $_ = (@_?Data::Dumper::Concise::Dumper @_:'()');
+ return _do_log( trace => _get_logger( caller ), $code, @_ );
}
sub Dlog_debug (&@) {
my $code = shift;
- my @values = @_;
- log_debug {
- if (@values) {
- do { local $_ = Data::Dumper::Concise::Dumper @values; $code->() };
- } else {
- do { local $_ = '()'; $code->() };
- }
- } @values
+ local $_ = (@_?Data::Dumper::Concise::Dumper @_:'()');
+ return _do_log( debug => _get_logger( caller ), $code, @_ );
}
sub Dlog_info (&@) {
my $code = shift;
- my @values = @_;
- log_info {
- if (@values) {
- do { local $_ = Data::Dumper::Concise::Dumper @values; $code->() };
- } else {
- do { local $_ = '()'; $code->() };
- }
- } @values
+ local $_ = (@_?Data::Dumper::Concise::Dumper @_:'()');
+ return _do_log( info => _get_logger( caller ), $code, @_ );
}
sub Dlog_warn (&@) {
my $code = shift;
- my @values = @_;
- log_warn {
- if (@values) {
- do { local $_ = Data::Dumper::Concise::Dumper @values; $code->() };
- } else {
- do { local $_ = '()'; $code->() };
- }
- } @values
+ local $_ = (@_?Data::Dumper::Concise::Dumper @_:'()');
+ return _do_log( warn => _get_logger( caller ), $code, @_ );
}
sub Dlog_error (&@) {
my $code = shift;
- my @values = @_;
- log_error {
- if (@values) {
- do { local $_ = Data::Dumper::Concise::Dumper @values; $code->() };
- } else {
- do { local $_ = '()'; $code->() };
- }
- } @values
+ local $_ = (@_?Data::Dumper::Concise::Dumper @_:'()');
+ return _do_log( error => _get_logger( caller ), $code, @_ );
}
sub Dlog_fatal (&@) {
my $code = shift;
- my @values = @_;
- log_fatal {
- if (@values) {
- do { local $_ = Data::Dumper::Concise::Dumper @values; $code->() };
- } else {
- do { local $_ = '()'; $code->() };
- }
- } @values
+ local $_ = (@_?Data::Dumper::Concise::Dumper @_:'()');
+ return _do_log( fatal => _get_logger( caller ), $code, @_ );
}
-
sub DlogS_trace (&$) {
- my $code = $_[0];
- my $value = $_[1];
- logS_trace {
- do { local $_ = Data::Dumper::Concise::Dumper $value; $code->() };
- } $value
+ local $_ = Data::Dumper::Concise::Dumper $_[1];
+ _do_logS( trace => _get_logger( caller ), $_[0], $_[1] )
}
sub DlogS_debug (&$) {
- my $code = $_[0];
- my $value = $_[1];
- logS_debug {
- do { local $_ = Data::Dumper::Concise::Dumper $value; $code->() };
- } $value
+ local $_ = Data::Dumper::Concise::Dumper $_[1];
+ _do_logS( debug => _get_logger( caller ), $_[0], $_[1] )
}
sub DlogS_info (&$) {
- my $code = $_[0];
- my $value = $_[1];
- logS_info {
- do { local $_ = Data::Dumper::Concise::Dumper $value; $code->() };
- } $value
+ local $_ = Data::Dumper::Concise::Dumper $_[1];
+ _do_logS( info => _get_logger( caller ), $_[0], $_[1] )
}
sub DlogS_warn (&$) {
- my $code = $_[0];
- my $value = $_[1];
- logS_warn {
- do { local $_ = Data::Dumper::Concise::Dumper $value; $code->() };
- } $value
+ local $_ = Data::Dumper::Concise::Dumper $_[1];
+ _do_logS( warn => _get_logger( caller ), $_[0], $_[1] )
}
sub DlogS_error (&$) {
- my $code = $_[0];
- my $value = $_[1];
- logS_error {
- do { local $_ = Data::Dumper::Concise::Dumper $value; $code->() };
- } $value
+ local $_ = Data::Dumper::Concise::Dumper $_[1];
+ _do_logS( error => _get_logger( caller ), $_[0], $_[1] )
}
sub DlogS_fatal (&$) {
- my $code = $_[0];
- my $value = $_[1];
- logS_fatal {
- do { local $_ = Data::Dumper::Concise::Dumper $value; $code->() };
- } $value
+ local $_ = Data::Dumper::Concise::Dumper $_[1];
+ _do_logS( fatal => _get_logger( caller ), $_[0], $_[1] )
}
1;
=head1 SYNOPSIS
- use Log::Log4perl;
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 = sub { Log::Log4perl->get_logger };
+ my $logger = Log::Log4perl->get_logger;
- set_logger { $logger };
+ set_logger $logger;
log_debug { 'program started' };
});
}
+ foo();
+
+Beginning with version 1.008 L<Log::Dispatchouli> also works out of the box
+with C<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' };
+
=head1 DESCRIPTION
This module is a simple interface to extensible logging. It is bundled with a
really basic logger, L<Log::Contextual::SimpleLogger>, but in general you
should use a real logger instead of that. For something more serious but not
-overly complicated, take a look at L<Log::Dispatchouli>.
+overly complicated, try L<Log::Dispatchouli> (see L</SYNOPSIS> for example.)
=head1 OPTIONS
+=head2 -logger
+
When you import this module you may use C<-logger> as a shortcut for
L<set_logger>, for example:
BEGIN { $var_log = VarLogger->new }
use Log::Contextual qw( :dlog ), -logger => $var_log;
+=head2 -package_logger
+
+The C<-package_logger> import option is similar to the C<-logger> import option
+except C<-package_logger> sets the the logger for the current package.
+
+Unlike L</-default_logger>, C<-package_logger> cannot be overridden with
+L</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 L<Log::Contextual::WarnLogger> for your package logger.
+
+=head2 -default_logger
+
+The C<-default_logger> import option is similar to the C<-logger> import option
+except C<-default_logger> sets the the B<default> logger for the current package.
+
+Basically it sets the logger to be used if C<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'
+ });
+
=head1 A WORK IN PROGRESS
This module is certainly not complete, but we will not break the interface
my $logger = WarnLogger->new;
set_logger $logger;
-Arguments: Ref|CodeRef $returning_logger
+Arguments: C<Ref|CodeRef $returning_logger>
C<set_logger> will just set the current logger to whatever you pass it. It
expects a C<CodeRef>, but if you pass it something else it will wrap it in a
-C<CodeRef> for you.
+C<CodeRef> for you. C<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.
=head2 with_logger
}
};
-Arguments: Ref|CodeRef $returning_logger, CodeRef $to_execute
+Arguments: C<Ref|CodeRef $returning_logger, CodeRef $to_execute>
C<with_logger> sets the logger for the scope of the C<CodeRef> C<$to_execute>.
-As with L<set_logger>, C<with_logger> will wrap C<$returning_logger> with a
+As with L</set_logger>, C<with_logger> will wrap C<$returning_logger> with a
C<CodeRef> if needed.
=head2 log_$level
-Import Tag: ":log"
+Import Tag: C<:log>
-Arguments: CodeRef $returning_message
+Arguments: C<CodeRef $returning_message, @args>
All of the following six functions work the same except that a different method
is called on the underlying C<$logger> object. The basic pattern is:
- sub log_$level (&) {
+ sub log_$level (&@) {
if ($logger->is_$level) {
- $logger->$level(shift->());
+ $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
+L</Dlog_$level> functions.
+
=head3 log_trace
log_trace { 'entered method foo with args ' join q{,}, @args };
log_fatal { '1 is never equal to 0!' };
+=head2 logS_$level
+
+Import Tag: C<:log>
+
+Arguments: C<CodeRef $returning_message, Item $arg>
+
+This is really just a special case of the L</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: L</DlogS_$level>.
+
=head2 Dlog_$level
-Import Tag: ":dlog"
+Import Tag: C<:dlog>
-Arguments: CodeRef $returning_message, @args
+Arguments: C<CodeRef $returning_message, @args>
-All of the following six functions work the same as their L<log_$level>
+All of the following six functions work the same as their L</log_$level>
brethren, except they return what is passed into them and put the stringified
(with L<Data::Dumper::Concise>) version of their args into C<$_>. This means
you can do cool things like the following:
=head2 DlogS_$level
-Import Tag: ":dlog"
+Import Tag: C<:dlog>
-Arguments: CodeRef $returning_message, Item $arg
+Arguments: C<CodeRef $returning_message, Item $arg>
-All of the following six functions work the same as the related L<Dlog_$level>
-functions, except they only take a single scalar after the
-C<$returning_message> instead of slurping up (and also setting C<wantarray>)
-all the C<@args>
+Like L</logS_$level>, these functions are a special case of L</Dlog_$level>.
+They only take a single scalar after the C<$returning_message> instead of
+slurping up (and also setting C<wantarray>) all the C<@args>
my $pals_rs = DlogS_debug { "pals resultset: $_" }
$schema->resultset('Pals')->search({ perlers => 1 });
-=head3 DlogS_trace
-
- my ($foo, $bar) =
- DlogS_trace { "entered method foo with first arg $_" } $_[0], $_[1];
-
-=head3 DlogS_debug
-
- DlogS_debug { "random data structure: $_" } { foo => $bar };
-
-=head3 DlogS_info
-
- return DlogS_info { "html from method returned: $_" } "<html>...</html>";
-
-=head3 DlogS_warn
-
- DlogS_warn { "probably invalid value: $_" } $foo;
-
-=head3 DlogS_error
-
- DlogS_error { "non-numeric user input! ($_)" } $port;
-
-=head3 DlogS_fatal
-
- DlogS_fatal { '1 is never equal to 0!' } 'ZOMG ZOMG' if 1 == 0;
-
=head1 LOGGER INTERFACE
Because this module is ultimately pretty looking glue (glittery?) with the
projects / p5sagit/Log-Contextual.git / blobdiff