ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent/lib/AnyEvent/Log.pm
(Generate patch)

Comparing AnyEvent/lib/AnyEvent/Log.pm (file contents):
Revision 1.36 by root, Thu Aug 25 05:39:47 2011 UTC vs.
Revision 1.46 by root, Sun Oct 2 01:22:01 2011 UTC

… …
6 6
7Simple uses: 7Simple uses:
8 8
9 use AnyEvent; 9 use AnyEvent;
10 10
11 AE::log debug => "hit my knee"; 11 AE::log trace => "going to call function abc";
12 AE::log warn => "it's a bit too hot"; 12 AE::log debug => "the function returned 3";
13 AE::log error => "the flag was false!"; 13 AE::log info => "file soandso successfully deleted";
14 AE::log fatal => "the bit toggled! run!"; # never returns 14 AE::log note => "wanted to create config, but config was alraedy created";
15 AE::log warn => "couldn't delete the file";
16 AE::log error => "failed to retrieve data";
17 AE::log crit => "the battery temperature is too hot";
18 AE::log alert => "the battery died";
19 AE::log fatal => "no config found, cannot continue"; # never returns
15 20
21Log level overview:
22
23 LVL NAME SYSLOG PERL NOTE
24 1 fatal emerg exit system unusable, aborts program!
25 2 alert failure in primary system
26 3 critical crit failure in backup system
27 4 error err die non-urgent program errors, a bug
28 5 warn warning possible problem, not necessarily error
29 6 note notice unusual conditions
30 7 info normal messages, no action required
31 8 debug debugging messages for development
32 9 trace copious tracing output
33
16"Complex" uses (for speed sensitive code): 34"Complex" uses (for speed sensitive code, e.g. trace/debug messages):
17 35
18 use AnyEvent::Log; 36 use AnyEvent::Log;
19 37
20 my $tracer = AnyEvent::Log::logger trace => \$my $trace; 38 my $tracer = AnyEvent::Log::logger trace => \$my $trace;
21 39
… …
32 50
33 # send all critical and higher priority messages to syslog, 51 # send all critical and higher priority messages to syslog,
34 # regardless of (most) other settings 52 # regardless of (most) other settings
35 $AnyEvent::Log::COLLECT->attach (new AnyEvent::Log::Ctx 53 $AnyEvent::Log::COLLECT->attach (new AnyEvent::Log::Ctx
36 level => "critical", 54 level => "critical",
37 log_to_syslog => 0, 55 log_to_syslog => "user",
38 ); 56 );
39 57
40=head1 DESCRIPTION 58=head1 DESCRIPTION
41 59
42This module implements a relatively simple "logging framework". It doesn't 60This module implements a relatively simple "logging framework". It doesn't
… …
72numerical value". 90numerical value".
73 91
74Instead of specifying levels by name you can also specify them by aliases: 92Instead of specifying levels by name you can also specify them by aliases:
75 93
76 LVL NAME SYSLOG PERL NOTE 94 LVL NAME SYSLOG PERL NOTE
77 1 fatal emerg exit aborts program! 95 1 fatal emerg exit system unusable, aborts program!
78 2 alert 96 2 alert failure in primary system
79 3 critical crit 97 3 critical crit failure in backup system
80 4 error err die 98 4 error err die non-urgent program errors, a bug
81 5 warn warning 99 5 warn warning possible problem, not necessarily error
82 6 note notice 100 6 note notice unusual conditions
83 7 info 101 7 info normal messages, no action required
84 8 debug 102 8 debug debugging messages for development
85 9 trace 103 9 trace copious tracing output
86 104
87As you can see, some logging levels have multiple aliases - the first one 105As you can see, some logging levels have multiple aliases - the first one
88is the "official" name, the second one the "syslog" name (if it differs) 106is the "official" name, the second one the "syslog" name (if it differs)
89and the third one the "perl" name, suggesting that you log C<die> messages 107and the third one the "perl" name, suggesting (only!) that you log C<die>
90at C<error> priority. 108messages at C<error> priority. The NOTE column tries to provide some
109rationale on how to chose a logging level.
110
111As a rough guideline, levels 1..3 are primarily meant for users of
112the program (admins, staff), and are the only logged to STDERR by
113default. Levels 4..6 are meant for users and developers alike, while
114levels 7..9 are usually meant for developers.
91 115
92You can normally only log a single message at highest priority level 116You can normally only log a single message at highest priority level
93(C<1>, C<fatal>), because logging a fatal message will also quit the 117(C<1>, C<fatal>), because logging a fatal message will also quit the
94program - so use it sparingly :) 118program - so use it sparingly :)
95 119
… …
110package AnyEvent::Log; 134package AnyEvent::Log;
111 135
112use Carp (); 136use Carp ();
113use POSIX (); 137use POSIX ();
114 138
139# layout of a context
140# 0 1 2 3 4, 5
141# [$title, $level, %$slaves, &$logcb, &$fmtcb, $cap]
142
115use AnyEvent (); BEGIN { AnyEvent::common_sense } 143use AnyEvent (); BEGIN { AnyEvent::common_sense }
116use AnyEvent::Util (); 144#use AnyEvent::Util (); need to load this in a delayed fashion, as it uses AE::log
117 145
118our $VERSION = $AnyEvent::VERSION; 146our $VERSION = $AnyEvent::VERSION;
119 147
120our ($COLLECT, $FILTER, $LOG); 148our ($COLLECT, $FILTER, $LOG);
121 149
… …
151=item AnyEvent::Log::log $level, $msg[, @args] 179=item AnyEvent::Log::log $level, $msg[, @args]
152 180
153Requests logging of the given C<$msg> with the given log level, and 181Requests logging of the given C<$msg> with the given log level, and
154returns true if the message was logged I<somewhere>. 182returns true if the message was logged I<somewhere>.
155 183
156For C<fatal> log levels, the program will abort. 184For loglevel C<fatal>, the program will abort.
157 185
158If only a C<$msg> is given, it is logged as-is. With extra C<@args>, the 186If only a C<$msg> is given, it is logged as-is. With extra C<@args>, the
159C<$msg> is interpreted as an sprintf format string. 187C<$msg> is interpreted as an sprintf format string.
160 188
161The C<$msg> should not end with C<\n>, but may if that is convenient for 189The C<$msg> should not end with C<\n>, but may if that is convenient for
… …
163 191
164Last not least, C<$msg> might be a code reference, in which case it is 192Last not least, C<$msg> might be a code reference, in which case it is
165supposed to return the message. It will be called only then the message 193supposed to return the message. It will be called only then the message
166actually gets logged, which is useful if it is costly to create the 194actually gets logged, which is useful if it is costly to create the
167message in the first place. 195message in the first place.
196
197This function takes care of saving and restoring C<$!> and C<$@>, so you
198don't have to.
168 199
169Whether the given message will be logged depends on the maximum log level 200Whether the given message will be logged depends on the maximum log level
170and the caller's package. The return value can be used to ensure that 201and the caller's package. The return value can be used to ensure that
171messages or not "lost" - for example, when L<AnyEvent::Debug> detects a 202messages or not "lost" - for example, when L<AnyEvent::Debug> detects a
172runtime error it tries to log it at C<die> level, but if that message is 203runtime error it tries to log it at C<die> level, but if that message is
… …
206 info => 7, 237 info => 7,
207 debug => 8, 238 debug => 8,
208 trace => 9, 239 trace => 9,
209); 240);
210 241
211sub now () { time } 242our $TIME_EXACT;
243
244sub exact_time($) {
245 $TIME_EXACT = shift;
246 *_ts = $AnyEvent::MODEL
247 ? $TIME_EXACT ? \&AE::now : \&AE::time
248 : sub () { $TIME_EXACT ? do { require Time::HiRes; Time::HiRes::time () } : time };
249}
250
251BEGIN {
252 exact_time 0;
253}
212 254
213AnyEvent::post_detect { 255AnyEvent::post_detect {
214 *now = \&AE::now; 256 exact_time $TIME_EXACT;
215}; 257};
216 258
217our @LEVEL2STR = qw(0 fatal alert crit error warn note info debug trace); 259our @LEVEL2STR = qw(0 fatal alert crit error warn note info debug trace);
218 260
219# time, ctx, level, msg 261# time, ctx, level, msg
… …
229 } 271 }
230 272
231 join "", @res 273 join "", @res
232} 274}
233 275
276sub fatal_exit() {
277 exit 1;
278}
279
234sub _log { 280sub _log {
235 my ($ctx, $level, $format, @args) = @_; 281 my ($ctx, $level, $format, @args) = @_;
236 282
237 $level = $level > 0 && $level <= 9 283 $level = $level > 0 && $level <= 9
238 ? $level+0 284 ? $level+0
239 : $STR2LEVEL{$level} || Carp::croak "$level: not a valid logging level, caught"; 285 : $STR2LEVEL{$level} || Carp::croak "$level: not a valid logging level, caught";
240 286
241 my $mask = 1 << $level; 287 my $mask = 1 << $level;
242 288
243 my ($success, %seen, @ctx, $now, $fmt); 289 my ($success, %seen, @ctx, $now, @fmt);
244 290
245 do 291 do
246 { 292 {
247 # skip if masked 293 # if !ref, then it's a level number
294 if (!ref $ctx) {
295 $level = $ctx;
248 if ($ctx->[1] & $mask && !$seen{$ctx+0}++) { 296 } elsif ($ctx->[1] & $mask and !$seen{$ctx+0}++) {
297 # logging/recursing into this context
298
299 # level cap
300 if ($ctx->[5] > $level) {
301 push @ctx, $level; # restore level when going up in tree
302 $level = $ctx->[5];
303 }
304
305 # log if log cb
249 if ($ctx->[3]) { 306 if ($ctx->[3]) {
250 # logging target found 307 # logging target found
308
309 local ($!, $@);
251 310
252 # now get raw message, unless we have it already 311 # now get raw message, unless we have it already
253 unless ($now) { 312 unless ($now) {
254 $format = $format->() if ref $format; 313 $format = $format->() if ref $format;
255 $format = sprintf $format, @args if @args; 314 $format = sprintf $format, @args if @args;
256 $format =~ s/\n$//; 315 $format =~ s/\n$//;
257 $now = now; 316 $now = _ts;
258 }; 317 };
259 318
260 # format msg 319 # format msg
261 my $str = $ctx->[4] 320 my $str = $ctx->[4]
262 ? $ctx->[4]($now, $_[0], $level, $format) 321 ? $ctx->[4]($now, $_[0], $level, $format)
263 : ($fmt ||= _format $now, $_[0], $level, $format); 322 : ($fmt[$level] ||= _format $now, $_[0], $level, $format);
264 323
265 $success = 1; 324 $success = 1;
266 325
267 $ctx->[3]($str) 326 $ctx->[3]($str)
268 or push @ctx, values %{ $ctx->[2] }; # not consumed - propagate 327 or push @ctx, values %{ $ctx->[2] }; # not consumed - propagate
… …
271 } 330 }
272 } 331 }
273 } 332 }
274 while $ctx = pop @ctx; 333 while $ctx = pop @ctx;
275 334
276 exit 1 if $level <= 1; 335 fatal_exit if $level <= 1;
277 336
278 $success 337 $success
279} 338}
280 339
281sub log($$;@) { 340sub log($$;@) {
282 _log 341 _log
283 $CTX{ (caller)[0] } ||= _pkg_ctx +(caller)[0], 342 $CTX{ (caller)[0] } ||= _pkg_ctx +(caller)[0],
284 @_; 343 @_;
285} 344}
286 345
287*AnyEvent::log = *AE::log = \&log;
288
289=item $logger = AnyEvent::Log::logger $level[, \$enabled] 346=item $logger = AnyEvent::Log::logger $level[, \$enabled]
290 347
291Creates a code reference that, when called, acts as if the 348Creates a code reference that, when called, acts as if the
292C<AnyEvent::Log::log> function was called at this point with the given 349C<AnyEvent::Log::log> function was called at this point with the given
293level. C<$logger> is passed a C<$msg> and optional C<@args>, just as with 350level. C<$logger> is passed a C<$msg> and optional C<@args>, just as with
… …
357 414
358 $LOGGER{$logger+0} = $logger; 415 $LOGGER{$logger+0} = $logger;
359 416
360 _reassess $logger+0; 417 _reassess $logger+0;
361 418
419 require AnyEvent::Util unless $AnyEvent::Util::VERSION;
362 my $guard = AnyEvent::Util::guard { 420 my $guard = AnyEvent::Util::guard (sub {
363 # "clean up" 421 # "clean up"
364 delete $LOGGER{$logger+0}; 422 delete $LOGGER{$logger+0};
365 }; 423 });
366 424
367 sub { 425 sub {
368 $guard if 0; # keep guard alive, but don't cause runtime overhead 426 $guard if 0; # keep guard alive, but don't cause runtime overhead
369 427
370 _log $ctx, $level, @_ 428 _log $ctx, $level, @_
… …
375sub logger($;$) { 433sub logger($;$) {
376 _logger 434 _logger
377 $CTX{ (caller)[0] } ||= _pkg_ctx +(caller)[0], 435 $CTX{ (caller)[0] } ||= _pkg_ctx +(caller)[0],
378 @_ 436 @_
379} 437}
438
439=item AnyEvent::Log::exact_time $on
440
441By default, C<AnyEvent::Log> will use C<AE::now>, i.e. the cached
442eventloop time, for the log timestamps. After calling this function with a
443true value it will instead resort to C<AE::time>, i.e. fetch the current
444time on each log message. This only makes a difference for event loops
445that actually cache the time (such as L<EV> or L<AnyEvent::Loop>).
446
447This setting can be changed at any time by calling this function.
448
449Since C<AnyEvent::Log> has to work even before the L<AnyEvent> has been
450initialised, this switch will also decide whether to use C<CORE::time> or
451C<Time::HiRes::time> when logging a message before L<AnyEvent> becomes
452available.
380 453
381=back 454=back
382 455
383=head1 LOGGING CONTEXTS 456=head1 LOGGING CONTEXTS
384 457
… …
504This can be used to implement config-file (re-)loading: before loading a 577This can be used to implement config-file (re-)loading: before loading a
505configuration, reset all contexts. 578configuration, reset all contexts.
506 579
507=cut 580=cut
508 581
582our $ORIG_VERBOSE = $AnyEvent::VERBOSE;
583$AnyEvent::VERBOSE = 9;
584
509sub reset { 585sub reset {
510 # hard to kill complex data structures 586 # hard to kill complex data structures
511 # we "recreate" all package loggers and reset the hierarchy 587 # we "recreate" all package loggers and reset the hierarchy
512 while (my ($k, $v) = each %CTX) { 588 while (my ($k, $v) = each %CTX) {
513 @$v = ($k, (1 << 10) - 1 - 1, { }); 589 @$v = ($k, (1 << 10) - 1 - 1, { });
… …
522 $LOG->title ('$AnyEvent::Log::LOG'); 598 $LOG->title ('$AnyEvent::Log::LOG');
523 $LOG->log_to_warn; 599 $LOG->log_to_warn;
524 600
525 $FILTER->slaves ($LOG); 601 $FILTER->slaves ($LOG);
526 $FILTER->title ('$AnyEvent::Log::FILTER'); 602 $FILTER->title ('$AnyEvent::Log::FILTER');
527 $FILTER->level ($AnyEvent::VERBOSE); 603 $FILTER->level ($ORIG_VERBOSE);
528 604
529 $COLLECT->slaves ($FILTER); 605 $COLLECT->slaves ($FILTER);
530 $COLLECT->title ('$AnyEvent::Log::COLLECT'); 606 $COLLECT->title ('$AnyEvent::Log::COLLECT');
531 607
532 _reassess; 608 _reassess;
533} 609}
610
611# override AE::log/logger
612*AnyEvent::log = *AE::log = \&log;
613*AnyEvent::logger = *AE::logger = \&logger;
614
615# convert AnyEvent loggers to AnyEvent::Log loggers
616$_->[0] = ctx $_->[0] # convert "pkg" to "ctx"
617 for values %LOGGER;
534 618
535# create the default logger contexts 619# create the default logger contexts
536$LOG = ctx undef; 620$LOG = ctx undef;
537$FILTER = ctx undef; 621$FILTER = ctx undef;
538$COLLECT = ctx undef; 622$COLLECT = ctx undef;
… …
547package AnyEvent::Log::COLLECT; 631package AnyEvent::Log::COLLECT;
548package AE::Log::COLLECT; 632package AE::Log::COLLECT;
549 633
550package AnyEvent::Log::Ctx; 634package AnyEvent::Log::Ctx;
551 635
552# 0 1 2 3 4
553# [$title, $level, %$slaves, &$logcb, &$fmtcb]
554
555=item $ctx = new AnyEvent::Log::Ctx methodname => param... 636=item $ctx = new AnyEvent::Log::Ctx methodname => param...
556 637
557This is a convenience constructor that makes it simpler to construct 638This is a convenience constructor that makes it simpler to construct
558anonymous logging contexts. 639anonymous logging contexts.
559 640
… …
646 727
647=item $ctx->disable ($level[, $level...]) 728=item $ctx->disable ($level[, $level...])
648 729
649Disables logging for the given levels, leaving all others unchanged. 730Disables logging for the given levels, leaving all others unchanged.
650 731
732=item $ctx->cap ($level)
733
734Caps the maximum priority to the given level, for all messages logged
735to, or passing through, this context. That is, while this doesn't affect
736whether a message is logged or passed on, the maximum priority of messages
737will be limited to the specified level - messages with a higher priority
738will be set to the specified priority.
739
740Another way to view this is that C<< ->level >> filters out messages with
741a too low priority, while C<< ->cap >> modifies messages with a too high
742priority.
743
744This is useful when different log targets have different interpretations
745of priority. For example, for a specific command line program, a wrong
746command line switch might well result in a C<fatal> log message, while the
747same message, logged to syslog, is likely I<not> fatal to the system or
748syslog facility as a whole, but more likely a mere C<error>.
749
750This can be modeled by having a stderr logger that logs messages "as-is"
751and a syslog logger that logs messages with a level cap of, say, C<error>,
752or, for truly system-critical components, actually C<critical>.
753
651=cut 754=cut
652 755
653sub _lvl_lst { 756sub _lvl_lst {
654 map { 757 map {
655 $_ > 0 && $_ <= 9 ? $_+0 758 $_ > 0 && $_ <= 9 ? $_+0
656 : $_ eq "all" ? (1 .. 9) 759 : $_ eq "all" ? (1 .. 9)
657 : $STR2LEVEL{$_} || Carp::croak "$_: not a valid logging level, caught" 760 : $STR2LEVEL{$_} || Carp::croak "$_: not a valid logging level, caught"
658 } @_ 761 } @_
659} 762}
660 763
764sub _lvl {
765 $_[0] =~ /^(?:0|off|none)$/ ? 0 : (_lvl_lst $_[0])[-1]
766}
767
661our $NOP_CB = sub { 0 }; 768our $NOP_CB = sub { 0 };
662 769
663sub levels { 770sub levels {
664 my $ctx = shift; 771 my $ctx = shift;
665 $ctx->[1] = 0; 772 $ctx->[1] = 0;
… …
668 AnyEvent::Log::_reassess; 775 AnyEvent::Log::_reassess;
669} 776}
670 777
671sub level { 778sub level {
672 my $ctx = shift; 779 my $ctx = shift;
673 my $lvl = $_[0] =~ /^(?:0|off|none)$/ ? 0 : (_lvl_lst $_[0])[-1];
674
675 $ctx->[1] = ((1 << $lvl) - 1) << 1; 780 $ctx->[1] = ((1 << &_lvl) - 1) << 1;
676 AnyEvent::Log::_reassess; 781 AnyEvent::Log::_reassess;
677} 782}
678 783
679sub enable { 784sub enable {
680 my $ctx = shift; 785 my $ctx = shift;
… …
688 $ctx->[1] &= ~(1 << $_) 793 $ctx->[1] &= ~(1 << $_)
689 for &_lvl_lst; 794 for &_lvl_lst;
690 AnyEvent::Log::_reassess; 795 AnyEvent::Log::_reassess;
691} 796}
692 797
798sub cap {
799 my $ctx = shift;
800 $ctx->[5] = &_lvl;
801}
802
693=back 803=back
694 804
695=head3 SLAVE CONTEXTS 805=head3 SLAVE CONTEXTS
696 806
697The following methods attach and detach another logging context to a 807The following methods attach and detach another logging context to a
… …
837 947
838Needless(?) to say, if you do not want to be bitten by some evil person 948Needless(?) to say, if you do not want to be bitten by some evil person
839calling C<chdir>, the path should be absolute. Doesn't help with 949calling C<chdir>, the path should be absolute. Doesn't help with
840C<chroot>, but hey... 950C<chroot>, but hey...
841 951
842=item $ctx->log_to_syslog ([$log_flags]) 952=item $ctx->log_to_syslog ([$facility])
843 953
844Logs all messages via L<Sys::Syslog>, mapping C<trace> to C<debug> and all 954Logs all messages via L<Sys::Syslog>, mapping C<trace> to C<debug> and
845the others in the obvious way. If specified, then the C<$log_flags> are 955all the others in the obvious way. If specified, then the C<$facility> is
846simply or'ed onto the priority argument and can contain any C<LOG_xxx> 956used as the facility (C<user>, C<auth>, C<local0> and so on). The default
847flags valid for Sys::Syslog::syslog, except for the priority levels. 957facility is C<user>.
848 958
849Note that this function also sets a C<fmt_cb> - the logging part requires 959Note that this function also sets a C<fmt_cb> - the logging part requires
850an array reference with [$level, $str] as input. 960an array reference with [$level, $str] as input.
851 961
852=cut 962=cut
… …
895 0 1005 0
896 }); 1006 });
897} 1007}
898 1008
899sub log_to_syslog { 1009sub log_to_syslog {
900 my ($ctx, $flags) = @_; 1010 my ($ctx, $facility) = @_;
901 1011
902 require Sys::Syslog; 1012 require Sys::Syslog;
903 1013
904 $ctx->fmt_cb (sub { 1014 $ctx->fmt_cb (sub {
905 my $str = $_[3]; 1015 my $str = $_[3];
906 $str =~ s/\n(?=.)/\n+ /g; 1016 $str =~ s/\n(?=.)/\n+ /g;
907 1017
908 [$_[2], "($_[1][0]) $str"] 1018 [$_[2], "($_[1][0]) $str"]
909 }); 1019 });
910 1020
1021 $facility ||= "user";
1022
911 $ctx->log_cb (sub { 1023 $ctx->log_cb (sub {
912 my $lvl = $_[0][0] < 9 ? $_[0][0] : 8; 1024 my $lvl = $_[0][0] < 9 ? $_[0][0] : 8;
913 1025
914 Sys::Syslog::syslog ($flags | ($lvl - 1), $_) 1026 Sys::Syslog::syslog ("$facility|" . ($lvl - 1), $_)
915 for split /\n/, $_[0][1]; 1027 for split /\n/, $_[0][1];
916 1028
917 0 1029 0
918 }); 1030 });
919} 1031}
… …
1025=item C<nolog> 1137=item C<nolog>
1026 1138
1027Configures the context to not log anything by itself, which is the 1139Configures the context to not log anything by itself, which is the
1028default. Same as C<< $ctx->log_cb (undef) >>. 1140default. Same as C<< $ctx->log_cb (undef) >>.
1029 1141
1142=item C<cap=>I<level>
1143
1144Caps logging messages entering this context at the given level, i.e.
1145reduces the priority of messages with higher priority than this level. The
1146default is C<0> (or C<off>), meaning the priority will not be touched.
1147
1030=item C<0> or C<off> 1148=item C<0> or C<off>
1031 1149
1032Sets the logging level of the context ot C<0>, i.e. all messages will be 1150Sets the logging level of the context to C<0>, i.e. all messages will be
1033filtered out. 1151filtered out.
1034 1152
1035=item C<all> 1153=item C<all>
1036 1154
1037Enables all logging levels, i.e. filtering will effectively be switched 1155Enables all logging levels, i.e. filtering will effectively be switched
… …
1120 1238
1121 my $pkg = sub { 1239 my $pkg = sub {
1122 $_[0] eq "log" ? $LOG 1240 $_[0] eq "log" ? $LOG
1123 : $_[0] eq "filter" ? $FILTER 1241 : $_[0] eq "filter" ? $FILTER
1124 : $_[0] eq "collect" ? $COLLECT 1242 : $_[0] eq "collect" ? $COLLECT
1125 : $_[0] =~ /^%(.+)$/ ? ($anon{$1} ||= ctx undef) 1243 : $_[0] =~ /^%(.+)$/ ? ($anon{$1} ||= do { my $ctx = ctx undef; $ctx->[0] = $_[0]; $ctx })
1126 : $_[0] =~ /^(.*?)(?:::)?$/ ? ctx "$1" # egad :/ 1244 : $_[0] =~ /^(.*?)(?:::)?$/ ? ctx "$1" # egad :/
1127 : die # never reached? 1245 : die # never reached?
1128 }; 1246 };
1129 1247
1130 /\G[[:space:]]+/gc; # skip initial whitespace 1248 /\G[[:space:]]+/gc; # skip initial whitespace
… …
1136 while (/\G((?:[^,:[:space:]]+|::|\\.)+)/gc) { 1254 while (/\G((?:[^,:[:space:]]+|::|\\.)+)/gc) {
1137 for ("$1") { 1255 for ("$1") {
1138 if ($_ eq "stderr" ) { $ctx->log_to_warn; 1256 if ($_ eq "stderr" ) { $ctx->log_to_warn;
1139 } elsif (/^file=(.+)/ ) { $ctx->log_to_file ("$1"); 1257 } elsif (/^file=(.+)/ ) { $ctx->log_to_file ("$1");
1140 } elsif (/^path=(.+)/ ) { $ctx->log_to_path ("$1"); 1258 } elsif (/^path=(.+)/ ) { $ctx->log_to_path ("$1");
1141 } elsif (/syslog(?:=(.*))?/ ) { require Sys::Syslog; $ctx->log_to_syslog (eval "package Sys::Syslog; $1"); 1259 } elsif (/^syslog(?:=(.*))?/ ) { require Sys::Syslog; $ctx->log_to_syslog ("$1");
1142 } elsif ($_ eq "nolog" ) { $ctx->log_cb (undef); 1260 } elsif ($_ eq "nolog" ) { $ctx->log_cb (undef);
1261 } elsif (/^cap=(.+)/ ) { $ctx->cap ("$1");
1143 } elsif (/^\+(.+)$/ ) { $ctx->attach ($pkg->("$1")); 1262 } elsif (/^\+(.+)$/ ) { $ctx->attach ($pkg->("$1"));
1144 } elsif ($_ eq "+" ) { $ctx->slaves; 1263 } elsif ($_ eq "+" ) { $ctx->slaves;
1145 } elsif ($_ eq "off" or $_ eq "0") { $ctx->level (0); 1264 } elsif ($_ eq "off" or $_ eq "0") { $ctx->level (0);
1146 } elsif ($_ eq "all" ) { $ctx->level ("all"); 1265 } elsif ($_ eq "all" ) { $ctx->level ("all");
1147 } elsif ($_ eq "level" ) { $ctx->level ("all"); $level = "level"; 1266 } elsif ($_ eq "level" ) { $ctx->level ("all"); $level = "level";
… …
1199 1318
1200This writes them only when the global logging level allows it, because 1319This writes them only when the global logging level allows it, because
1201it is attached to the default context which is invoked I<after> global 1320it is attached to the default context which is invoked I<after> global
1202filtering. 1321filtering.
1203 1322
1204 $AnyEvent::Log::FILTER->attach 1323 $AnyEvent::Log::FILTER->attach (
1205 new AnyEvent::Log::Ctx log_to_file => $path); 1324 new AnyEvent::Log::Ctx log_to_file => $path);
1206 1325
1207 PERL_ANYEVENT_LOG=filter=+%filelogger:%filelogger=file=/some/path 1326 PERL_ANYEVENT_LOG=filter=+%filelogger:%filelogger=file=/some/path
1208 1327
1209This writes them regardless of the global logging level, because it is 1328This writes them regardless of the global logging level, because it is
… …
1215 1334
1216 PERL_ANYEVENT_LOG=%filelogger=file=/some/path:collect=+%filelogger 1335 PERL_ANYEVENT_LOG=%filelogger=file=/some/path:collect=+%filelogger
1217 1336
1218In both cases, messages are still written to STDERR. 1337In both cases, messages are still written to STDERR.
1219 1338
1339=item Additionally log all messages with C<warn> and higher priority to
1340C<syslog>, but cap at C<error>.
1341
1342This logs all messages to the default log target, but also logs messages
1343with priority C<warn> or higher (and not filtered otherwise) to syslog
1344facility C<user>. Messages with priority higher than C<error> will be
1345logged with level C<error>.
1346
1347 $AnyEvent::Log::LOG->attach (
1348 new AnyEvent::Log::Ctx
1349 level => "warn",
1350 cap => "error",
1351 syslog => "user",
1352 );
1353
1354 PERL_ANYEVENT_LOG=log=+%syslog:%syslog=warn,cap=error,syslog
1355
1220=item Write trace messages (only) from L<AnyEvent::Debug> to the default logging target(s). 1356=item Write trace messages (only) from L<AnyEvent::Debug> to the default logging target(s).
1221 1357
1222Attach the C<$AnyEvent::Log::LOG> context to the C<AnyEvent::Debug> 1358Attach the C<$AnyEvent::Log::LOG> context to the C<AnyEvent::Debug>
1223context - this simply circumvents the global filtering for trace messages. 1359context - this simply circumvents the global filtering for trace messages.
1224 1360

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines