Log::Minimal is Minimal but customizable log module.
Log::Simple is a Basic runtime logger.
A module to provide a unified approach to tracing.
This module is a simple interface to extensible logging. It is
bundled with a really basic logger, Log::Contextual::SimpleLogger, but
in general you should use a real logger instead of that. For
something more serious but not overly complicated, try
Log::Dispatchouli (see "SYNOPSIS" for example.)
The reason for this module is to abstract your logging interface so
that logging is as painless as possible, while still allowing you to
switch from one logger to another.
Perl module to rotate log files
Lvalue takes an object produced by some other package and wraps it
with lvalue functionality implemented with the object's original
getter and setter routines. Lvalue assumes its object uses the
relatively standard getter / setter idiom where any arguments is a
setter, and no arguments is a getter.
Memoize::ExpireLRU is a module that implements LRU expiration for Memoize.
`Memoizing' a function makes it faster by trading space for time. It
does this by caching the return values of the function in a table. If
you call the function again with the same arguments, memoize jumps in
and gives you the value out of the table, instead of letting the
function compute the value all over again.
Method::Alias is designed to be used as a pragma, to which you provide a
set of pairs of method names. Only very minimal checking is done, if you
wish to create infinite loops or what have you, you are more than
welcome to shoot yourself in the foot.
# Add a single method alias
use Method::Alias 'foo' => 'bar';
# Add several method aliases
use Method::Alias 'a' => 'b',
'c' => 'd',
'e' => 'f';
Luka is an exception handling and reporting framework. It's useful to look at it
as an event handling framework.
It comes from operational understanding of networks.
Scenario that Luka is addressing is following: on a network with multiple hosts
running multiple applications, it is very difficult to track operational status
of all the functionality that those applications and hosts are meant to deliver.
In order to make it easier, we decided to specify the error handling and
reporting data model that each component delivering functionality has to conform
to. What is a component? In most cases, it is a script, often run from cronjob,
in some cases it is a class in an application. In all cases, a component has to
successfully complete a task on which functionality of an application, or entire
network, relies on.
It is common practice that programmers choose their way of handling errors and
reporting. Luka is an attempt to standardize that process. Its primary goal is
to make it easier for smaller number of people to keep larger number of
applications and networks running.