[ViewVC] Diff of: cvs/AnyEvent/lib/AnyEvent/Log.pm

Comparing AnyEvent/lib/AnyEvent/Log.pm (file contents):
Revision 1.44 by root, Mon Sep 26 11:32:19 2011 UTC vs.
Revision 1.73 by root, Sun Apr 24 21:22:38 2022 UTC

 Simple uses:
    use AnyEvent;
+   AE::log fatal => "No config found, cannot continue!"; # never returns
+   AE::log alert => "The battery died!";
+   AE::log crit  => "The battery is too hot!";
+   AE::log error => "Division by zero attempted.";
+   AE::log warn  => "Couldn't delete the file.";
+   AE::log note  => "Attempted to create config, but config already exists.";
+   AE::log info  => "File soandso successfully deleted.";
+   AE::log debug => "the function returned 3";
    AE::log trace => "going to call function abc";
-   AE::log debug => "the function returned 3";
-   AE::log info  => "file soandso successfully deleted";
-   AE::log note  => "wanted to create config, but config was alraedy created";
-   AE::log warn  => "couldn't delete the file";
-   AE::log error => "failed to retrieve data";
-   AE::log crit  => "the battery temperature is too hot";
-   AE::log alert => "the battery died";
-   AE::log fatal => "no config found, cannot continue"; # never returns
 Log level overview:
    LVL NAME      SYSLOG   PERL  NOTE
     1  fatal     emerg    exit  system unusable, aborts program!
 "Complex" uses (for speed sensitive code, e.g. trace/debug messages):
    use AnyEvent::Log;
-   my $tracer = AnyEvent::Log::logger trace => \$my $trace;
+   my $tracer = AnyEvent::Log::logger trace => \my $trace;
    $tracer->("i am here") if $trace;
    $tracer->(sub { "lots of data: " . Dumper $self }) if $trace;
 Configuration (also look at the EXAMPLES section):
+   # set default logging level to suppress anything below "notice"
+   # i.e. enable logging at "notice" or above - the default is to
+   # to not log anything at all.
+   $AnyEvent::Log::FILTER->level ("notice");
    # set logging for the current package to errors and higher only
    AnyEvent::Log::ctx->level ("error");
-   # set logging level to suppress anything below "notice"
+   # enable logging for the current package, regardless of global logging level
-   $AnyEvent::Log::FILTER->level ("notice");
+   AnyEvent::Log::ctx->attach ($AnyEvent::Log::LOG);
+   # enable debug logging for module some::mod and enable logging by default
+   (AnyEvent::Log::ctx "some::mod")->level ("debug");
+   (AnyEvent::Log::ctx "some::mod")->attach ($AnyEvent::Log::LOG);
    # send all critical and higher priority messages to syslog,
    # regardless of (most) other settings
    $AnyEvent::Log::COLLECT->attach (new AnyEvent::Log::Ctx
       level         => "critical",
 attempt to be "the" logging solution or even "a" logging solution for
 AnyEvent - AnyEvent simply creates logging messages internally, and this
 module more or less exposes the mechanism, with some extra spiff to allow
 using it from other modules as well.
-Remember that the default verbosity level is C<0> (C<off>), so nothing
+Remember that the default verbosity level is C<4> (C<error>), so only
-will be logged, unless you set C<PERL_ANYEVENT_VERBOSE> to a higher number
+errors and more important messages will be logged, unless you set
-before starting your program, or change the logging level at runtime with
+C<PERL_ANYEVENT_VERBOSE> to a higher number before starting your program
-something like:
+(C<AE_VERBOSE=5> is recommended during development), or change the logging
+level at runtime with something like:
    use AnyEvent::Log;
    $AnyEvent::Log::FILTER->level ("info");
 The design goal behind this module was to keep it simple (and small),
-but make it powerful enough to be potentially useful for any module, and
+but make it powerful enough to be potentially useful for any module,
-extensive enough for the most common tasks, such as logging to multiple
+and extensive enough for the most common tasks, such as logging to
-targets, or being able to log into a database.
+multiple targets, or being able to log into a database.
 The module is also usable before AnyEvent itself is initialised, in which
 case some of the functionality might be reduced.
 The amount of documentation might indicate otherwise, but the runtime part
 is the "official" name, the second one the "syslog" name (if it differs)
 and the third one the "perl" name, suggesting (only!) that you log C<die>
 messages at C<error> priority. The NOTE column tries to provide some
 rationale on how to chose a logging level.
-As a rough guideline, levels 1..3 are primarily meant for users of
+As a rough guideline, levels 1..3 are primarily meant for users of the
-the program (admins, staff), and are the only logged to STDERR by
+program (admins, staff), and are the only ones logged to STDERR by
 default. Levels 4..6 are meant for users and developers alike, while
 levels 7..9 are usually meant for developers.
-You can normally only log a single message at highest priority level
+You can normally only log a message once at highest priority level (C<1>,
-(C<1>, C<fatal>), because logging a fatal message will also quit the
+C<fatal>), because logging a fatal message will also quit the program - so
-program - so use it sparingly :)
+use it sparingly :)
+For example, a program that finds an unknown switch on the commandline
+might well use a fatal logging level to tell users about it - the "system"
+in this case would be the program, or module.
 Some methods also offer some extra levels, such as C<0>, C<off>, C<none>
-or C<all> - these are only valid in the methods they are documented for.
+or C<all> - these are only valid for the methods that document them.
 =head1 LOGGING FUNCTIONS
-These functions allow you to log messages. They always use the caller's
+The following functions allow you to log messages. They always use the
-package as a "logging context". Also, the main logging function C<log> is
+caller's package as a "logging context". Also, the main logging function,
-callable as C<AnyEvent::log> or C<AE::log> when the C<AnyEvent> module is
+C<log>, is aliased to C<AnyEvent::log> and C<AE::log> when the C<AnyEvent>
-loaded.
+module is loaded.
 =over 4
 =cut
 package AnyEvent::Log;
 use Carp ();
 use POSIX ();
+# layout of a context
+#       0       1         2        3        4,    5
+# [$title, $level, %$slaves, &$logcb, &$fmtcb, $cap]
 use AnyEvent (); BEGIN { AnyEvent::common_sense }
 #use AnyEvent::Util (); need to load this in a delayed fashion, as it uses AE::log
 our $VERSION = $AnyEvent::VERSION;
 our ($COLLECT, $FILTER, $LOG);
 our ($now_int, $now_str1, $now_str2);
 # Format Time, not public - yet?
-sub ft($) {
+sub format_time($) {
    my $i = int $_[0];
    my $f = sprintf "%06d", 1e6 * ($_[0] - $i);
    ($now_int, $now_str1, $now_str2) = ($i, split /\x01/, POSIX::strftime "%Y-%m-%d %H:%M:%S.\x01 %z", localtime $i)
       if $now_int != $i;
 Last not least, C<$msg> might be a code reference, in which case it is
 supposed to return the message. It will be called only then the message
 actually gets logged, which is useful if it is costly to create the
 message in the first place.
+This function takes care of saving and restoring C<$!> and C<$@>, so you
+don't have to.
 Whether the given message will be logged depends on the maximum log level
 and the caller's package. The return value can be used to ensure that
 messages or not "lost" - for example, when L<AnyEvent::Debug> detects a
 runtime error it tries to log it at C<die> level, but if that message is
 };
 our @LEVEL2STR = qw(0 fatal alert crit error warn note info debug trace);
 # time, ctx, level, msg
-sub _format($$$$) {
+sub default_format($$$$) {
-   my $ts = ft $_[0];
+   my $ts = format_time $_[0];
    my $ct = " ";
    my @res;
    for (split /\n/, sprintf "%-5s %s: %s", $LEVEL2STR[$_[2]], $_[1][0], $_[3]) {
             ? $level+0
             : $STR2LEVEL{$level} || Carp::croak "$level: not a valid logging level, caught";
    my $mask = 1 << $level;
-   my ($success, %seen, @ctx, $now, $fmt);
+   my ($success, %seen, @ctx, $now, @fmt);
    do
       {
-         # skip if masked
+         # if !ref, then it's a level number
+         if (!ref $ctx) {
+            $level = $ctx;
-         if ($ctx->[1] & $mask && !$seen{$ctx+0}++) {
+         } elsif ($ctx->[1] & $mask and !$seen{$ctx+0}++) {
+            # logging/recursing into this context
+            # level cap
+            if ($ctx->[5] > $level) {
+               push @ctx, $level; # restore level when going up in tree
+               $level = $ctx->[5];
+            }
+            # log if log cb
             if ($ctx->[3]) {
                # logging target found
+               local ($!, $@);
                # now get raw message, unless we have it already
                unless ($now) {
                   $format = $format->() if ref $format;
                   $format = sprintf $format, @args if @args;
                };
                # format msg
                my $str = $ctx->[4]
                   ? $ctx->[4]($now, $_[0], $level, $format)
-                  : ($fmt ||= _format $now, $_[0], $level, $format);
+                  : ($fmt[$level] ||= default_format $now, $_[0], $level, $format);
                $success = 1;
                $ctx->[3]($str)
                   or push @ctx, values %{ $ctx->[2] }; # not consumed - propagate
 time on each log message. This only makes a difference for event loops
 that actually cache the time (such as L<EV> or L<AnyEvent::Loop>).
 This setting can be changed at any time by calling this function.
-Since C<AnyEvent::Log> has to work even before the L<AnyEvent> has been
+Since C<AnyEvent::Log> has to work even before L<AnyEvent> has been
 initialised, this switch will also decide whether to use C<CORE::time> or
 C<Time::HiRes::time> when logging a message before L<AnyEvent> becomes
 available.
+=item AnyEvent::Log::format_time $timestamp
+Formats a timestamp as returned by C<< AnyEvent->now >> or C<<
+AnyEvent->time >> or many other functions in the same way as
+C<AnyEvent::Log> does.
+In your main program (as opposed to in your module) you can override
+the default timestamp display format by loading this module and then
+redefining this function.
+Most commonly, this function can be used in formatting callbacks.
+=item AnyEvent::Log::default_format $time, $ctx, $level, $msg
+Format a log message using the given timestamp, logging context, log level
+and log message.
+This is the formatting function used to format messages when no custom
+function is provided.
+In your main program (as opposed to in your module) you can override the
+default message format by loading this module and then redefining this
+function.
+=item AnyEvent::Log::fatal_exit()
+This is the function that is called after logging a C<fatal> log
+message. It must not return.
+The default implementation simply calls C<exit 1>.
+In your main program (as opposed to in your module) you can override
+the fatal exit function by loading this module and then redefining this
+function. Make sure you don't return.
 =back
 =head1 LOGGING CONTEXTS
 context, so it does not matter (much) if there are cycles or if the
 message can arrive at the same context via multiple paths.
 =head2 DEFAULTS
-By default, all logging contexts have an full set of log levels ("all"), a
+By default, all logging contexts have a full set of log levels ("all"), a
 disabled logging callback and the default formatting callback.
 Package contexts have the package name as logging title by default.
 They have exactly one slave - the context of the "parent" package. The
 =item $ctx = AnyEvent::Log::ctx [$pkg]
 This function creates or returns a logging context (which is an object).
-If a package name is given, then the context for that packlage is
+If a package name is given, then the context for that package is
 returned. If it is called without any arguments, then the context for the
 callers package is returned (i.e. the same context as a C<AE::log> call
 would use).
 If C<undef> is given, then it creates a new anonymous context that is not
 package AnyEvent::Log::COLLECT;
 package AE::Log::COLLECT;
 package AnyEvent::Log::Ctx;
-#       0       1         2        3        4
-# [$title, $level, %$slaves, &$logcb, &$fmtcb]
 =item $ctx = new AnyEvent::Log::Ctx methodname => param...
 This is a convenience constructor that makes it simpler to construct
 anonymous logging contexts.
 =item $ctx->disable ($level[, $level...])
 Disables logging for the given levels, leaving all others unchanged.
+=item $ctx->cap ($level)
+Caps the maximum priority to the given level, for all messages logged
+to, or passing through, this context. That is, while this doesn't affect
+whether a message is logged or passed on, the maximum priority of messages
+will be limited to the specified level - messages with a higher priority
+will be set to the specified priority.
+Another way to view this is that C<< ->level >> filters out messages with
+a too low priority, while C<< ->cap >> modifies messages with a too high
+priority.
+This is useful when different log targets have different interpretations
+of priority. For example, for a specific command line program, a wrong
+command line switch might well result in a C<fatal> log message, while the
+same message, logged to syslog, is likely I<not> fatal to the system or
+syslog facility as a whole, but more likely a mere C<error>.
+This can be modeled by having a stderr logger that logs messages "as-is"
+and a syslog logger that logs messages with a level cap of, say, C<error>,
+or, for truly system-critical components, actually C<critical>.
 =cut
 sub _lvl_lst {
    map {
       $_ > 0 && $_ <= 9 ? $_+0
       : $_ eq "all"     ? (1 .. 9)
       : $STR2LEVEL{$_} || Carp::croak "$_: not a valid logging level, caught"
    } @_
 }
+sub _lvl {
+   $_[0] =~ /^(?:0|off|none)$/ ? 0 : (_lvl_lst $_[0])[-1]
+}
 our $NOP_CB = sub { 0 };
 sub levels {
    my $ctx = shift;
    $ctx->[1] = 0;
    AnyEvent::Log::_reassess;
 }
 sub level {
    my $ctx = shift;
-   my $lvl = $_[0] =~ /^(?:0|off|none)$/ ? 0 : (_lvl_lst $_[0])[-1];
-   $ctx->[1] =  ((1 << $lvl) - 1) << 1;
+   $ctx->[1] = ((1 << &_lvl) - 1) << 1;
    AnyEvent::Log::_reassess;
 }
 sub enable {
    my $ctx = shift;
    $ctx->[1] &= ~(1 << $_)
       for &_lvl_lst;
    AnyEvent::Log::_reassess;
 }
+sub cap {
+   my $ctx = shift;
+   $ctx->[5] = &_lvl;
+}
 =back
 =head3 SLAVE CONTEXTS
 The following methods attach and detach another logging context to a
 sub attach {
    my $ctx = shift;
    $ctx->[2]{$_+0} = $_
       for map { AnyEvent::Log::ctx $_ } @_;
+   AnyEvent::Log::_reassess;
 }
 sub detach {
    my $ctx = shift;
    delete $ctx->[2]{$_+0}
       for map { AnyEvent::Log::ctx $_ } @_;
+   AnyEvent::Log::_reassess;
 }
 sub slaves {
    undef $_[0][2];
    &attach;
+   AnyEvent::Log::_reassess;
 }
 =back
 =head3 LOG TARGETS
 the logging (which consists of formatting the message and printing it or
 whatever it wants to do with it).
 =over 4
-=item $ctx->log_cb ($cb->($str)
+=item $ctx->log_cb ($cb->($str))
 Replaces the logging callback on the context (C<undef> disables the
 logging callback).
 The logging callback is responsible for handling formatted log messages
 Replaces the formatting callback on the context (C<undef> restores the
 default formatter).
 The callback is passed the (possibly fractional) timestamp, the original
-logging context, the (numeric) logging level and the raw message string
+logging context (object, not title), the (numeric) logging level and
-and needs to return a formatted log message. In most cases this will be a
+the raw message string and needs to return a formatted log message. In
-string, but it could just as well be an array reference that just stores
+most cases this will be a string, but it could just as well be an array
-the values.
+reference that just stores the values.
-If, for some reason, you want to use C<caller> to find out more baout the
+If, for some reason, you want to use C<caller> to find out more about the
 logger then you should walk up the call stack until you are no longer
 inside the C<AnyEvent::Log> package.
+To implement your own logging callback, you might find the
+C<AnyEvent::Log::format_time> and C<AnyEvent::Log::default_format>
+functions useful.
+Example: format the message just as AnyEvent::Log would, by letting
+AnyEvent::Log do the work. This is a good basis to design a formatting
+callback that only changes minor aspects of the formatting.
+   $ctx->fmt_cb (sub {
+      my ($time, $ctx, $lvl, $msg) = @_;
+      AnyEvent::Log::default_format $time, $ctx, $lvl, $msg
+   });
 Example: format just the raw message, with numeric log level in angle
 brackets.
    $ctx->fmt_cb (sub {
       my ($time, $ctx, $lvl, $msg) = @_;
       "<$lvl>$msg\n"
    });
 Example: return an array reference with just the log values, and use
-C<PApp::SQL::sql_exec> to store the emssage in a database.
+C<PApp::SQL::sql_exec> to store the message in a database.
    $ctx->fmt_cb (sub { \@_ });
    $ctx->log_cb (sub {
       my ($msg) = @_;
 Sets the C<log_cb> to simply use C<CORE::warn> to report any messages
 (usually this logs to STDERR).
 =item $ctx->log_to_file ($path)
-Sets the C<log_cb> to log to a file (by appending), unbuffered.
+Sets the C<log_cb> to log to a file (by appending), unbuffered. The
+function might return before the log file has been opened or created.
 =item $ctx->log_to_path ($path)
 Same as C<< ->log_to_file >>, but opens the file for each message. This
 is much slower, but allows you to change/move/rename/delete the file at
       warn shift;
       0
    });
 }
+# this function is a good example of why threads are a must,
+# simply for priority inversion.
+sub _log_to_disk {
+   # eval'uating this at runtime saves 220kb rss - perl has become
+   # an insane memory waster.
+   eval q{ # poor man's autoloading {}
+      sub _log_to_disk {
+         my ($ctx, $path, $keepopen) = @_;
+         my $fh;
+         my @queue;
+         my $delay;
+         my $disable;
+         use AnyEvent::IO ();
+         my $kick = sub {
+            undef $delay;
+            return unless @queue;
+            $delay = 1;
+            # we pass $kick to $kick, so $kick itself doesn't keep a reference to $kick.
+            my $kick = shift;
+            # write one or more messages
+            my $write = sub {
+               # we write as many messages as have been queued
+               my $data = join "", @queue;
+               @queue = ();
+               AnyEvent::IO::aio_write $fh, $data, sub {
+                  $disable = 1;
+                  @_
+                     ? ($_[0] == length $data or AE::log 4 => "unable to write to logfile '$path': short write")
+                     :                           AE::log 4 => "unable to write to logfile '$path': $!";
+                  undef $disable;
+                  if ($keepopen) {
+                     $kick->($kick);
+                  } else {
+                     AnyEvent::IO::aio_close ($fh, sub {
+                        undef $fh;
+                        $kick->($kick);
+                     });
+                  }
+               };
+            };
+            if ($fh) {
+               $write->();
+            } else {
+               AnyEvent::IO::aio_open
+                  $path,
+                  AnyEvent::IO::O_CREAT | AnyEvent::IO::O_WRONLY | AnyEvent::IO::O_APPEND,
+                  0666,
+                  sub {
+                     $fh = shift
+                        or do {
+                           $disable = 1;
+                           AE::log 4 => "unable to open logfile '$path': $!";
+                           undef $disable;
+                           return;
+                        };
+                     $write->();
+                  }
+               ;
+            }
+         };
+         $ctx->log_cb (sub {
+            return if $disable;
+            push @queue, shift;
+            $kick->($kick) unless $delay;
+            0
+         });
+         $kick->($kick) if $keepopen; # initial open
+      };
+   };
+   die if $@;
+   &_log_to_disk
+}
 sub log_to_file {
    my ($ctx, $path) = @_;
-   open my $fh, ">>", $path
+   _log_to_disk $ctx, $path, 1;
-      or die "$path: $!";
-   $ctx->log_cb (sub {
-      syswrite $fh, shift;
-      0
-   });
 }
 sub log_to_path {
    my ($ctx, $path) = @_;
-   $ctx->log_cb (sub {
+   _log_to_disk $ctx, $path, 0;
-      open my $fh, ">>", $path
-         or die "$path: $!";
-      syswrite $fh, shift;
-      0
-   });
 }
 sub log_to_syslog {
    my ($ctx, $facility) = @_;
 =over 4
 =item $ctx->log ($level, $msg[, @params])
 Same as C<AnyEvent::Log::log>, but uses the given context as log context.
+Example: log a message in the context of another package.
+   (AnyEvent::Log::ctx "Other::Package")->log (warn => "heely bo");
 =item $logger = $ctx->logger ($level[, \$enabled])
 Same as C<AnyEvent::Log::logger>, but uses the given context as log
 context.
 Context names starting with a C<%> are anonymous contexts created when the
 name is first mentioned. The difference to package contexts is that by
 default they have no attached slaves.
+This makes it possible to create new log contexts that can be refered to
+multiple times by name within the same log specification.
 =item a perl package name
 Any other string references the logging context associated with the given
 Perl C<package>. In the unlikely case where you want to specify a package
 context that matches on of the other context name forms, you can add a
 =item C<nolog>
 Configures the context to not log anything by itself, which is the
 default. Same as C<< $ctx->log_cb (undef) >>.
+=item C<cap=>I<level>
+Caps logging messages entering this context at the given level, i.e.
+reduces the priority of messages with higher priority than this level. The
+default is C<0> (or C<off>), meaning the priority will not be touched.
 =item C<0> or C<off>
-Sets the logging level of the context ot C<0>, i.e. all messages will be
+Sets the logging level of the context to C<0>, i.e. all messages will be
 filtered out.
 =item C<all>
 Enables all logging levels, i.e. filtering will effectively be switched
 Attaches the named context as slave to the context.
 =item C<+>
-A line C<+> detaches all contexts, i.e. clears the slave list from the
+A lone C<+> detaches all contexts, i.e. clears the slave list from the
 context. Anonymous (C<%name>) contexts have no attached slaves by default,
 but package contexts have the parent context as slave by default.
 Example: log messages from My::Module to a file, do not send them to the
 default log collector.
    my $pkg = sub {
       $_[0] eq "log"              ? $LOG
       : $_[0] eq "filter"         ? $FILTER
       : $_[0] eq "collect"        ? $COLLECT
-      : $_[0] =~ /^%(.+)$/        ? ($anon{$1} ||= ctx undef)
+      : $_[0] =~ /^%(.+)$/        ? ($anon{$1} ||= do { my $ctx = ctx undef; $ctx->[0] = $_[0]; $ctx })
       : $_[0] =~ /^(.*?)(?:::)?$/ ? ctx "$1" # egad :/
       : die # never reached?
    };
    /\G[[:space:]]+/gc; # skip initial whitespace
       while (/\G((?:[^,:[:space:]]+|::|\\.)+)/gc) {
          for ("$1") {
             if ($_ eq "stderr"               ) { $ctx->log_to_warn;
             } elsif (/^file=(.+)/            ) { $ctx->log_to_file ("$1");
             } elsif (/^path=(.+)/            ) { $ctx->log_to_path ("$1");
-            } elsif (/syslog(?:=(.*))?/      ) { require Sys::Syslog; $ctx->log_to_syslog ($1);
+            } elsif (/^syslog(?:=(.*))?/     ) { require Sys::Syslog; $ctx->log_to_syslog ("$1");
             } elsif ($_ eq "nolog"           ) { $ctx->log_cb (undef);
+            } elsif (/^cap=(.+)/             ) { $ctx->cap ("$1");
             } elsif (/^\+(.+)$/              ) { $ctx->attach ($pkg->("$1"));
             } elsif ($_ eq "+"               ) { $ctx->slaves;
             } elsif ($_ eq "off" or $_ eq "0") { $ctx->level (0);
             } elsif ($_ eq "all"             ) { $ctx->level ("all");
             } elsif ($_ eq "level"           ) { $ctx->level ("all"); $level = "level";
    if (/\G(.+)/g) {
       die "PERL_ANYEVENT_LOG ($spec): parse error at '$1'\n";
    }
 }
-1;
 =head1 EXAMPLES
 This section shows some common configurations, both as code, and as
 C<PERL_ANYEVENT_LOG> string.
    PERL_ANYEVENT_LOG=%filelogger=file=/some/path:collect=+%filelogger
 In both cases, messages are still written to STDERR.
+=item Additionally log all messages with C<warn> and higher priority to
+C<syslog>, but cap at C<error>.
+This logs all messages to the default log target, but also logs messages
+with priority C<warn> or higher (and not filtered otherwise) to syslog
+facility C<user>. Messages with priority higher than C<error> will be
+logged with level C<error>.
+   $AnyEvent::Log::LOG->attach (
+      new AnyEvent::Log::Ctx
+         level  => "warn",
+         cap    => "error",
+         syslog => "user",
+   );
+   PERL_ANYEVENT_LOG=log=+%syslog:%syslog=warn,cap=error,syslog
 =item Write trace messages (only) from L<AnyEvent::Debug> to the default logging target(s).
 Attach the C<$AnyEvent::Log::LOG> context to the C<AnyEvent::Debug>
 context - this simply circumvents the global filtering for trace messages.
 assumes the log level for AnyEvent::Debug hasn't been changed from the
 default.
 =back
+=head1 ASYNCHRONOUS DISK I/O
+This module uses L<AnyEvent::IO> to actually write log messages (in
+C<log_to_file> and C<log_to_path>), so it doesn't block your program when
+the disk is busy and a non-blocking L<AnyEvent::IO> backend is available.
 =head1 AUTHOR
  Marc Lehmann <schmorp@schmorp.de>
- http://home.schmorp.de/
+ http://anyevent.schmorp.de
 =cut
+1

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent/Log.pm (file contents): Revision 1.44 by root, Mon Sep 26 11:32:19 2011 UTC vs. Revision 1.73 by root, Sun Apr 24 21:22:38 2022 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent/Log.pm (file contents):
Revision 1.44 by root, Mon Sep 26 11:32:19 2011 UTC vs.
Revision 1.73 by root, Sun Apr 24 21:22:38 2022 UTC