head

code

item

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

This provides a simple, perhaps naive,interface to the POSIX syslog
facility found on most Unix-like systems.


It should be enough to get you started with simple logging to your
system's log files, though exactly what files those might be and how
they are logged is a function of the system configuration and the exact
logging software that is being used.


This does not provide logging to a remote syslog server, nor does
it provide syslog style logging to platforms that do not provide a
C<syslog()> function in their standard runtime library.


Log::Syslog::Native - access to POSIX syslog facility


NAME

=begin code

   use Log::Syslog::Native;

   my $logger = Log::Syslog::Native.new(facility => Log::Syslog::Native::Mail);

   $logger.warning("Couldn't activate wormhole interface");

=end code


SYNOPSIS

DESCRIPTION

METHODS

There are provided a number of methods to post a log at a given priority.


All of these can take a C<sprintf> format and a list of values. The C<sprintf>
may throw an exception if a mismatch between format and supplied values is
detected or if there is an un-recognised C<%> format code in the format.


Whilst the POSIX C<syslog> function is documented to be able to accept a
format and a variadic list of values, this is currently emulated with Raku's
builtin C<sprintf> due to a native call limitation  so the acceptable format
string may differ from the system documentation.


The C<enum>s documented below will need to be used fully qualified with
C<Log::Syslog::Native::> from user code.


method new(Str :$ident, Int :$option, Facility :$facility)


The constructor for the object.  C<ident> will set the identity field
for the log messages and default to C<$*PROGRAM-NAME>.  C<option> is the
OR of log option enum values as described below, it defaults to C<Pid +|
ODelay> which for most purposes should not need changing.  C<facility>
is a value of the C<Facility> enum as described below, it defaults to
C<Local0> and setting it may, depending on the syslog configuration on
your system, alter how and where the messages are logged to.



class Log::Syslog::Native:ver<0.1.0>:auth<github:jonathanstowe>:api<1.0> {



These correspond to the log C<priority> and will typically be passed to the
C<log> method. The exact meaning of the priorites may depend on the
system's logging configuration, but the descriptions come from the syslog.h.



    enum LogLevel <Emergency Alert Critical Error Warning Notice Info Debug>;



A value of this type may be supplied to the C<facility> argument of the
constructor, depending on the configuration of the logging system different
values may cause the message to be logged in a different manner. Clearly some
of these refer to actual facilities that may not even exist on a modern
system and may be repurposed if you have access to the configuration.


Messages generated internally by syslogd


Security/authorization messages (private)



    enum LogFacility (
                        :Kernel( 0 +< 3),
                        :User( 1 +< 3),
                        :Mail( 2 +< 3),
                        :Daemon( 3 +< 3),
                        :Auth( 4 +< 3),
                        :Syslog( 5 +< 3),
                        :Lpr( 6 +< 3),
                        :News( 7 +< 3),
                        :Uucp( 8 +< 3),
                        :Cron( 9 +< 3),
                        :Authpriv( 10 +< 3),
                        :Ftp( 11 +< 3),
                        :Local0( 16 +< 3),
                        :Local1( 17 +< 3),
                        :Local2( 18 +< 3),
                        :Local3( 19 +< 3),
                        :Local4( 20 +< 3),
                        :Local5( 21 +< 3),
                        :Local6( 22 +< 3),
                        :Local7( 23 +< 3) );



A binary OR of these values can be passed to the C<option> argument of the
constructor, though a sensible set of defaults is provided.


Delay open until first syslog() (default)


Don't wait for console forks: DEPRECATED



    enum LogOptions (
                        :Pid(0x01),
                        :Console(0x02),
                        :ODelay(0x04),
                        :NDelay(0x08),
                        :NoWait(0x10),
                        :Perror(0x20));

    has Str $.ident    = $*PROGRAM-NAME;
    has Int $.option   = Pid +| ODelay;
    has Int $.facility = Local0;

    sub _syslog(int32, Str) is native is symbol('syslog') { ... }
    sub _openlog(Str, int32, int32) is native is symbol('openlog') { ... }
    sub _closelog() is native is symbol('closelog') { ... }

    submethod BUILD(:$!ident = $*PROGRAM-NAME, :$option, :$facility) {
        $!option = $option // Pid +| ODelay;
        $!facility = $facility // Local0;
        my $i = explicitly-manage($!ident);
        _openlog($i, $!option, $!facility);
    }

    #| log at priority C<Emergency>
    #| Depending on your syslog configuration this may output to all logged
    #| in terminals so should probably be used sparingly
    method emergency(Str $format, *@args) {
        self.log(Emergency, $format, @args);
    }

    #| log at priority C<Alert>
    method alert(Str $format, *@args) {
        self.log(Alert, $format, @args);
    }

    #| log at priority C<Critical>
    method critical(Str $format, *@args) {
        self.log(Critical, $format, @args);
    }

    #| log at priority C<Error>
    method error(Str $format, *@args) {
        self.log(Error, $format, @args);
    }

    #| log at priority C<Warning>
    method warning(Str $format, *@args) {
        self.log(Warning, $format, @args);
    }

    #| log at priority C<Notice>
    method notice(Str $format, *@args) {
        self.log(Notice, $format, @args);
    }

    #| log at priority C<Info>
    method info(Str $format, *@args) {
        self.log(Info, $format, @args);
    }

    #| log at priority C<Debug>
    method debug(Str $format, *@args) {
        self.log(Info, $format, @args);
    }

    #| log at given C<$priority>
    method log(LogLevel $priority, Str $format, *@args ) {
        my $mess = sprintf $format, @args;
        _syslog($priority.Int, $mess);

    }

    submethod DESTROY {
        _closelog();
    }
}
# vim: expandtab shiftwidth=4 ft=raku


The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

log reader

current features

usage

todo

authors

Log::Reader v1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation