package Log::Contextual;
+# ABSTRACT: Simple logging interface with a contextual log
+
use strict;
use warnings;
-our $VERSION = '0.006000';
-$VERSION = eval $VERSION
- if $VERSION =~ /_/; # numify for warning-free dev releases
-
my @levels = qw(debug trace warn info error fatal);
use Exporter::Declare;
use Data::Dumper::Concise;
use Scalar::Util 'blessed';
+use B qw(svref_2object);
+
+sub stash_name {
+ my ($coderef) = @_;
+ ref $coderef or return;
+ my $cv = B::svref_2object($coderef);
+ $cv->isa('B::CV') or return;
+ # bail out if GV is undefined
+ $cv->GV->isa('B::SPECIAL') and return;
+
+ return $cv->GV->STASH->NAME;
+}
+
my @dlog = ((map "Dlog_$_", @levels), (map "DlogS_$_", @levels));
my @log = ((map "log_$_", @levels), (map "logS_$_", @levels));
+sub _maybe_export {
+ my ($spec, $target, $name, $new_code) = @_;
+
+ if (my $code = $target->can($name)) {
+
+ # this will warn
+ $spec->add_export("&$name", $new_code)
+ unless (stash_name($code) eq __PACKAGE__);
+ } else {
+ $spec->add_export("&$name", $new_code)
+ }
+}
+
eval {
require Log::Log4perl;
die if $Log::Log4perl::VERSION < 1.29;
die ref($router) . " does not support set_logger()"
unless $router->does('Log::Contextual::Role::Router::SetLogger');
- $spec->add_export('&set_logger', sub { $router->set_logger(@_) })
+ _maybe_export($spec, $importer, 'set_logger',
+ sub { $router->set_logger(@_) },
+ );
}
if ($exports->{'&with_logger'}) {
die ref($router) . " does not support with_logger()"
unless $router->does('Log::Contextual::Role::Router::WithLogger');
- $spec->add_export('&with_logger', sub { $router->with_logger(@_) })
+ _maybe_export($spec, $importer, 'with_logger',
+ sub { $router->with_logger(@_) },
+ );
}
my @levels = @{$class->arg_levels($spec->config->{levels})};
for my $level (@levels) {
if ($spec->config->{log} || $exports->{"&log_$level"}) {
- $spec->add_export(
- "&log_$level",
+ _maybe_export(
+ $spec,
+ $importer,
+ "log_$level",
sub (&@) {
my ($code, @args) = @_;
$router->handle_log_request(
message_args => \@args,
);
return @args;
- });
+ },
+ );
}
if ($spec->config->{log} || $exports->{"&logS_$level"}) {
- $spec->add_export(
- "&logS_$level",
+ _maybe_export(
+ $spec,
+ $importer,
+ "logS_$level",
sub (&@) {
my ($code, @args) = @_;
$router->handle_log_request(
message_args => \@args,
);
return $args[0];
- });
+ },
+ );
}
if ($spec->config->{dlog} || $exports->{"&Dlog_$level"}) {
- $spec->add_export(
- "&Dlog_$level",
+ _maybe_export(
+ $spec,
+ $importer,
+ "Dlog_$level",
sub (&@) {
my ($code, @args) = @_;
my $wrapped = sub {
message_args => \@args,
);
return @args;
- });
+ },
+ );
}
if ($spec->config->{dlog} || $exports->{"&DlogS_$level"}) {
- $spec->add_export(
- "&DlogS_$level",
+ _maybe_export(
+ $spec,
+ $importer,
+ "DlogS_$level",
sub (&$) {
my ($code, $ref) = @_;
my $wrapped = sub {
__END__
-=head1 NAME
-
-Log::Contextual - Simple logging interface with a contextual log
-
=head1 SYNOPSIS
use Log::Contextual qw( :log :dlog set_logger with_logger );
C<Log::Contextual> chooses which logger to use based on L<< user defined C<CodeRef>s|/LOGGER CODEREF >>.
Normally you don't need to know this, but you can take advantage of it when you
-need to later
+need to later.
=item * Scalable
-If you just want to add logging to your extremely basic application, start with
+If you just want to add logging to your basic application, start with
L<Log::Contextual::SimpleLogger> and then as your needs grow you can switch to
L<Log::Dispatchouli> or L<Log::Dispatch> or L<Log::Log4perl> or whatever else.
while still allowing you to switch from one logger to another.
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
+but in general you should use a real logger instead. For something
more serious but not overly complicated, try L<Log::Dispatchouli> (see
L</SYNOPSIS> for example.)
except C<-package_logger> sets the logger for the current package.
Unlike L</-default_logger>, C<-package_logger> cannot be overridden with
-L</set_logger>.
+L</set_logger> or L</with_logger>.
package My::Package;
use Log::Contextual::SimpleLogger;
Note the C<< $_[1] || >> in C<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, or whatever. To be clear,
+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,
Anywhere a logger object can be passed, a coderef is accepted. This is so
that the user can use different logger objects based on runtime information.
-The logger coderef is passed the package of the caller the caller level the
+The logger coderef is passed the package of the caller, and the caller level the
coderef needs to use if it wants more caller information. The latter is in
a hashref to allow for more options in the future.
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.
-=head1 AUTHOR
-
-frew - Arthur Axel "fREW" Schmidt <frioux@gmail.com>
-
=head1 CONTRIBUTORS
=encoding utf8
mst - Matt S. Trout <mst@shadowcat.co.uk>
-=head1 COPYRIGHT
-
-Copyright (c) 2012 the Log::Contextual L</AUTHOR> and L</DESIGNER> as listed
-above.
-
-=head1 LICENSE
-
-This library is free software and may be distributed under the same terms as
-Perl 5 itself.
-
=cut
projects / p5sagit/Log-Contextual.git / blobdiff