Log::Dispatch::Channels - Adds separate logging channels to Log::Dispatch

Log-Dispatch-Channels documentation Contained in the Log-Dispatch-Channels distribution.

Index

Code Index:

NAME

Top

Log::Dispatch::Channels - Adds separate logging channels to Log::Dispatch

VERSION

Top

version 0.01

SYNOPSIS

Top

  use Log::Dispatch::Channels;

  my $logger = Log::Dispatch::Channels->new;
  $logger->add_channel('foo');
  my $timestamper = sub { my %p = @_; return time . $p{message}; };
  $logger->add_channel('bar', callbacks => $timestamper);
  $logger->add(Log::Dispatch::File->new(channels  => 'foo',
                                        name      => 'foo',
                                        min_level => 'debug',
                                        filename  => 'foo.log'));
  $logger->add(Log::Dispatch::Null->new(channels  => 'bar',
                                        name      => 'bar',
                                        min_level => 'debug'));
  $logger->add(Log::Dispatch::File->new(channels  => [qw/foo bar/],
                                        name      => 'errors',
                                        min_level => 'error',
                                        filename  => 'error.log'));
  $logger->log(channels => 'foo', level => 'debug',
               message => 'For foo');
  $logger->log(channels => 'bar', level => 'error',
               message => 'For bar and errors');

DESCRIPTION

Top

This module manages a set of Log::Dispatch objects, treating them as separate message channels to which messages can be logged. These objects can share Log::Dispatch::Output objects, to allow for logging to multiple places simultaneously and automatically.

METHODS

Top

new()

Returns a new Log::Dispatch::Channels object.

add_channel($NAME, @ARGS)

Adds a new message channel named $NAME. This channel is actually a Log::Dispatch object, and @ARGS is forwarded on to the Log::Dispatch constructor.

remove_channel($NAME)

Removes the channel named $NAME and returns it.

add($OUTPUT[, channels => $NAMES])

Adds $OUTPUT (which is a Log::Dispatch::Output object), and also adds it to each channel named in $NAMES. $NAMES can be a string specifying a single channel, an arrayref of strings specifying multiple channels, or left out to add the output to all channels (this applies for each function taking a 'channels' argument).

remove($NAME)

Removes the output named $NAME from the object and from each of the channels, and then returns it.

log([channels => $NAMES,] %ARGS)

Forwards %ARGS on to the log method of each channel listed in $NAMES.

log_and_die([channels => $NAMES,] %ARGS)

Forwards %ARGS on to the log_and_die method of each channel listed in $NAMES.

log_and_croak([channels => $NAMES,] %ARGS)

Forwards %ARGS on to the log_and_croak method of each channel listed in $NAMES.

log_to(name => $NAME, %ARGS)

Forwards %ARGS on to the log method of the output named $NAME.

would_log($LEVEL[, channels => $NAMES])

Returns true if any channel named in $NAMES would log a message of level $LEVEL.

output($NAME)

Returns the Log::Dispatch::Output object named $NAME.

channel($NAME)

Returns the Log::Dispatch object named $NAME.

AUTHOR

Top

  Jesse Luehrs <doy at tozt dot net>

COPYRIGHT AND LICENSE

Top

This software is copyright (c) 2008 by Jesse Luehrs.

This is free software; you can redistribute it and/or modify it under the same terms as perl itself.

TODO

Top

Allow top level callbacks on the Log::Dispatcher::Channels object

SEE ALSO

Top

Log::Dispatch

BUGS

Top

No known bugs.

Please report any bugs through RT: email bug-log-dispatch-channels at rt.cpan.org, or browse to http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Log-Dispatch-Channels.

SUPPORT

Top

You can find this documentation for this module with the perldoc command.

    perldoc Log::Dispatch::Channels

You can also look for information at:

* AnnoCPAN: Annotated CPAN documentation

http://annocpan.org/dist/Log-Dispatch-Channels

* CPAN Ratings

http://cpanratings.perl.org/d/Log-Dispatch-Channels

* RT: CPAN's request tracker

http://rt.cpan.org/NoAuth/Bugs.html?Dist=Log-Dispatch-Channels

* Search CPAN

http://search.cpan.org/dist/Log-Dispatch-Channels

Log-Dispatch-Channels documentation Contained in the Log-Dispatch-Channels distribution. 
#!/usr/bin/perl
package Log::Dispatch::Channels;
our $VERSION = '0.01';

use strict;
use warnings;
use Log::Dispatch;
use Carp;

# ABSTRACT: Adds separate logging channels to Log::Dispatch



sub new {
    my $class = shift;

    my $self = bless {
        channels => {},
        outputs  => {},
    }, $class;

    return $self;
}


sub add_channel {
    my $self = shift;
    my $name = shift;

    carp "Channel $name already exists!"
        if exists $self->{channels}{$name};

    $self->{channels}{$name} = Log::Dispatch->new(@_);
}


sub remove_channel {
    my $self = shift;
    my $name = shift;

    return delete $self->{channels}{$name};
}

sub _forward_to_channels {
    my $self = shift;
    my $channels = shift;
    my $method = shift;
    my @channels = !defined $channels
                 ? (keys %{ $self->{channels} })
                 : ref $channels
                 ? @$channels
                 : ($channels);

    # XXX: sort of a hack - the return value is only used by would_log, which
    # just wants a boolean
    my $ret = 0;
    for my $channel (@channels) {
        if (exists $self->{channels}{$channel}) {
            my $methodret = $self->{channels}{$channel}->$method(@_);
            $ret ||= $methodret;
        }
        else {
            carp "Channel $channel doesn't exist";
        }
    }
    return $ret;
}


sub add {
    my $self = shift;
    my $output = shift;
    my %args = @_;

    carp "Output " . $output->name . " already exists!"
        if exists $self->{outputs}{$output->name};

    $self->_forward_to_channels($args{channels}, 'add', $output);
    $self->{outputs}{$output->name} = $output;
}


sub remove {
    my $self = shift;
    my $name = shift;
    my %args = @_;

    $self->_forward_to_channels(undef, 'remove', $name);
    return delete $self->{outputs}{$name};
}


sub log {
    my $self = shift;
    my %args = @_;
    my $channels = delete $args{channels};

    $self->_forward_to_channels($channels, 'log', %args);
}


sub log_and_die {
    my $self = shift;
    my %args = @_;
    my $channels = delete $args{channels};

    $self->_forward_to_channels($channels, 'log_and_die', %args);
}


sub log_and_croak {
    my $self = shift;
    my %args = @_;
    my $channels = delete $args{channels};

    $self->_forward_to_channels($channels, 'log_and_croak', %args);
}


sub log_to {
    my $self = shift;
    my %args = @_;
    my $output = delete $args{name};

    $self->{outputs}{$output}->log(%args);
}


sub would_log {
    my $self = shift;
    my $level = shift;
    my %args = @_;
    my $channels = delete $args{channels};

    return $self->_forward_to_channels($channels, 'would_log', $level);
}


sub output {
    my $self = shift;
    my $name = shift;

    return $self->{outputs}{$name} if exists $self->{outputs}{$name};
    return undef;
}


sub channel {
    my $self = shift;
    my $name = shift;

    return $self->{channels}{$name} if exists $self->{channels}{$name};
    return undef;
}


1;

__END__