para

use v6.c;

use Log::Any::Adapter;
use Log::Any::Filter;
use Log::Any::Formatter;



head

A pipeline have to choose which Adapter will handle the log, depending on the
Log's attributes (category, severity, size of the message, etc.).


A pipeline is composed of elements, which contains an Adapter and possibly
a Filter, a Formatter and/or a Proxy.



class Log::Any::Pipeline {

	has @!adapters;

	has $.asynchronous = False;
	has Channel $!channel; # Channel used for asynchronicity

	method TWEAK {
		if $!asynchronous {
			$!channel = Channel.new;
			$!channel.Supply.tap( -> %params {
				self!dispatch-synchronous( |%params );
			} );
		}
	}

	method add( Log::Any::Adapter $a, Log::Any::Filter :$filter, Log::Any::Formatter :$formatter, :$continue-on-match = False ) {
		#note "{now} adding adapter $a.WHAT().^name()";
		my %elem = adapter => $a;

		if $filter.defined {
			%elem{'filter'} = $filter;
		}

		if $formatter.defined {
			%elem{'formatter'} = $formatter;
		}

		if $continue-on-match {
			%elem{'continue-on-match'} = True ;
		}

		push @!adapters, %elem;
	}



This method returns the next element of the pipeline wich is matching
the filter.


	method !get-available-adapters( :$msg, :$severity, :$category, :%extra-fields ) {

		return gather for @!adapters -> %elem {
			# Filter : check if the adapter meets the requirements
			with %elem{'filter'} {
				next unless %elem{'filter'}.filter( :$msg, :$severity, :$category, :%extra-fields );
			}
			# Without filter, it's ok
			take %elem;
		}

	}

	method dispatch( DateTime :$date-time!, :$msg!, :$severity!, :$category!, :%extra-fields ) {
		# note "Dispatching $msg, adapter count : @!adapters.elems(), asynchronicity $!asynchronous.perl() at {now}";

		if $!asynchronous {
			# note "async dispatch";
			$!channel.send( { :$date-time, :$msg, :$severity, :$category } );
		} else {
			# note "sync dispatch";
			return self!dispatch-synchronous( :$date-time, :$msg, :$severity, :$category, :%extra-fields );
		}
	}

	method !dispatch-synchronous( :$date-time!, :$msg! is copy, :$severity!, :$category!, :%extra-fields ) {
		for self!get-available-adapters(  :$msg, :$severity, :$category ) -> %elem {
			if %elem {
				# Escape newlines caracters in message
				$msg ~~ s:g/ \n /\\n/;

				# Formatter
				my $msgToHandle = $msg;
				if %elem{'formatter'} {
					$msgToHandle = %elem{'formatter'}.format( :$date-time, :$msg, :$category, :$severity, :%extra-fields );
				}

				# Proxies

				# Handling
				%elem{'adapter'}.handle( $msgToHandle );
			}
			last unless %elem{'continue-on-match'};
		}
	}

	method will-dispatch( :$severity, :$category, :%extra-fields ) returns Bool {
		return self!get-available-adapters( :$severity, :$category, :%extra-fields ).so;
	}

	# Dump the adapters
	multi method gist( Log::Any::Pipeline:D: ) {
		return 'Log::Any::Pipeline.new(adapters => ' ~ @!adapters.gist ~ ')';
	}

}


root

Adapter

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<AI|file:../mcp/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=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<Download | file:../download/index.podlite>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>

=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>
    =item2 L<Hand these documents to an AI assistant|file:../mcp/index.podlite>

=end nested
=begin nested :!nested
=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/>

=end nested
=end React


Built with L<Podlite|https://podlite.org> — the markup and publishing tools behind this site.


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