head

Image

code

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

Lumberjack::Message::JSON - role to allow Lumberjack::Message to serialise/deserialise as JSON


=begin code

use Lumberjack;
use Lumberjack::Message::JSON;

my $message = Lumberjack::Message.new(message => 'this is a message');
$message does Lumberjack::Message::JSON;

my $str = $message.to-json;

...

my $new-message = (Lumberjack::Message but Lumberjack::Message::JSON).from-json($str);

# Alternatively the derived type can be provided as a constant:

constant JSONMessage = (Lumberjack::Message but Lumberjack::Message::JSON);

...

=end code


This is used by L<Lumberjack::Dispatcher::EventSource>, L<Lumberjack::Dispatcher::Proxy>,
L<Lumberjack::Application::PSGI> and L<Lumberjack::Application::WebSocket>
to serialise and deserialise the L<Lumberjack::Message> to/from JSON
for transport over HTTP or websockets.


It is implemented as role that can be mixed at run-time to existing
Message objects and to create a derived type to un-marshal to (see
the SYNOPSIS.)


Itself it uses C<JSON::Class> to provide C<to-json> and C<from-json>
and provides custom marshallers and un-marshallers to ensure that the
data is rendered meaningfully in JSON.


=begin code
{
   "backtrace" : [
      {
         "file" : "-e",
         "line" : 1,
         "subname" : "<unit>",
         "code" : {}
      }
   ],
   "message" : "this is a test",
   "class" : {
      "log-level" : 2,
      "is-logger" : false,
      "name" : "Any"
   },
   "level" : 2,
   "when" : "2016-04-12T00:18:34.435650+01:00"
}

=end code


Which reflects the L<Lumberjack::Message> fairly closely.  There may of course
be more backtrace frames.


The 'class' object in the JSON when de-serialised may cause a temporary type
to be created with the name provided if the type is not available on the
target system, if "is-logger" is true then it will have the C<Lumberjack::Logger>
applied and the log-level set. This is done so that the message will
appear the same as one created on the local system for a message received
from a remote logger.



use Lumberjack;
use JSON::Class;

role Lumberjack::Message::JSON does JSON::Class {

    has Bool $!been-monkeyed;

    sub marshal-class($v) {
        if $v ~~ Lumberjack::Logger {
            {
                name => $v.^name,
                log-level => $v.log-level.Int,
                is-logger    => True
            };
        }
        else {
            {
                name => $v.^name,
                log-level => Lumberjack.default-level.Int,
                is-logger    => False
            };
        }
    }

    sub unmarshal-class($v) {
        my $class = (try require ::($v<name>));

        my $t = ::($v<name>);
        if !$t && $t ~~ Failure {
            $class := Metamodel::ClassHOW.new_type(name => $v<name>);
            $class.^add_parent(Any);
            if $v<is-logger> {
                $class.^add_role(Lumberjack::Logger);
            }
            $class.^compose;
        }
        if $class ~~ Lumberjack::Logger {
            $class.log-level = Lumberjack::Level($v<log-level>);
        }
        $class;
    }


    method !add-marshallers() {
        my $when = self.^attributes.grep({$_.name eq '$!when'}).first;
        trait_mod:<is>($when, marshalled-by => 'Str');
        trait_mod:<is>($when, unmarshalled-by => -> $v { DateTime.new($v) });
        my $class = self.^attributes.grep({$_.name eq '$!class'}).first;
        trait_mod:<is>($class, marshalled-by => &marshal-class);
        trait_mod:<is>($class, unmarshalled-by => &unmarshal-class);
        my $level = self.^attributes.grep({ $_.name eq '$!level' }).first;
        trait_mod:<is>($level, marshalled-by => -> $v { $v.Int });
        trait_mod:<is>($level, unmarshalled-by => -> $v { Lumberjack::Level($v) });
    }

    method to-json( Bool :$pretty = True --> Str ) {
        self does JSON::Class;
        self!add-marshallers;
        self.JSON::Class::to-json(:$pretty);
    }
    method from-json($json --> Lumberjack::Message::JSON ) {
        self!add-marshallers;
        (self but JSON::Class).JSON::Class::from-json($json);
    }
}

# vim: expandtab shiftwidth=4 ft=raku


JSON

Lumberjack::Dispatcher::Syslog - syslog dispatcher for the the Lumberjack logger


=begin code

use Lumberjack;
use Lumberjack::Dispatcher::Syslog;

# Add the syslog dispatcher
Lumberjack.dispatchers.append: Lumberjack::Dispatcher::Syslog.new;

class MyClass does Lumberjack::Logger {
   method start() {
       self.log-info("Starting ...");
       ...
   }

   method do-stuff() {
      self.log-debug("Doing stuff ...");
      ...
      if $something-went-wrong {
         self.log-error("Something went wrong");
      }
   }
   method stop() {
       ...
       self.log-info("Stopped.");
   }
}

MyClass.log-level = Lumberjack::Debug;

=end code


This provides a dispatcher for
L<Lumberjack|https://github.com/jonathanstowe/Lumberjack> which allows
you to log to your system's C<syslog> facility, this may log to various
log files in, for instance, C</var/log> depending on the configuration
of the syslog daemon.  Because the actual logging daemon being used
may differ from system to system (there is syslog-ng, rsyslog, syslog
"classic" etc,) you will need to refer to the local documentation or a
system administrator to determine the actual logging behaviour. Some
systems may for instance just drop "debug" or "trace" messages in the
default configuration (or put them in separate files.)


As a "plugin" to C<Lumberjack> this has no methods of its own.  All of
the following configuration can be passed to the constructor prior
to adding it to the "dispatchers" list of C<Lumberjack>.


This is the string 'ident' of the logger, it defaults to the program
name.


This is the syslog facility which the logger will be opened for.  It
should be a value of the enumeration C<Log::Syslog::Native::LogFacility>,
it defaults to C<Local0>.  The "facility" is commonly used to determine
which file the logger will place the messages, you will need to check
the local configuration to determine the exact behaviour regarding the
different facilities.


This is the format that is used to format the message before sending
to the logger, this is described in the L<Lumberjack|https://github.com/jonathanstowe/Lumberjack/blob/master/Documentation.md#sub-format-message> documentation.


The default is "[%C - %S] : %M" which will emit "[<class> <method>] : <message>".


This is the integer callframe depth at which the formatter will try to
find the details of the execution frame of the log message.  The default
"4" should work in most cases but you may need to adjust it if you are
doing something more complicated and the subroutine name or filename
are wrong.


This is a Hash mapping the C<Lumberjack::Level> levels of the incoming
messages to the  C<Log::Syslog::Native::LogLevel> "priority" of the
syslog.  The default should be sufficient for most uses but you can
supply your own to work around a fixed configuration on your system.
The "priority" may influence where and indeed, if, a message will get
logged. The default mapping attempts to avoid using any priority that
typically gets sent to a console rather than files.


This is a matcher for the levels that this dispatcher wishes to handle,
as described in the C<Lumberjack> documentation.


This is a matcher for the classes that this dispatcher wishes to handle,
as described in the C<Lumberjack> documentaion. This and C<levels> may
be particularly useful in the syslog scenaria as it enables a mapping
of syslog "facilities" to different parts of an application.



use Lumberjack :FORMAT;
use Log::Syslog::Native;

class Lumberjack::Dispatcher::Syslog does Lumberjack::Dispatcher {

    has Log::Syslog::Native                 $!logger;
    has Str                                 $.ident         =   $*PROGRAM-NAME;
    has Log::Syslog::Native::LogFacility    $.facility      =   Log::Syslog::Native::Local0;
    has Str                                 $.format        =   "[%C - %S] : %M";
    has Int                                 $.callframes    =   4;

    has %.level-map =   Trace => Log::Syslog::Native::Debug,
                        Debug => Log::Syslog::Native::Debug,
                        Info  => Log::Syslog::Native::Info,
                        Warn  => Log::Syslog::Native::Warning,
                        Error => Log::Syslog::Native::Error,
                        Fatal => Log::Syslog::Native::Alert;


    method log(Lumberjack::Message $message) {
        if not $!logger.defined {
            $!logger = Log::Syslog::Native.new(facility => $!facility, ident => $!ident);
        }

        my $formatted-message = format-message($!format, $message, callframes => $!callframes);
        $!logger.log(%!level-map{$message.level}, $formatted-message);
    }
}
# vim: expandtab shiftwidth=4 ft=raku


Syslog

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

Lumberjack::Dispatcher::Syslog

image i_github_com_jonathanstowe_lumberjack_dispatcher_syslog_workflows_ci_badge_svg not found

Synopsis

Description

Installation

Support

Licence and copyright

Lumberjack::Dispatcher::Syslog v0.0.5

Authors

License

Dependencies

Test Dependencies

Provides

Documentation