hexLog
1.0.0-alpha.8
Hexlog enthält Protokollierungssystem, das von log4j in Haxe inspiriert ist
Weitere Informationen über Hexmachina finden Sie auf hexmachina.org
Anwendungen mit Hexlog -API fordern einen Protokoll mit einem bestimmten Namen vom LogManager an. Der LogManager finden den entsprechenden LoggerContext und erhalten dann den Logger daraus. Wenn der Protokoll erstellt werden muss, wird er dem Loggerconfig zugeordnet, der entweder enthält: a) der gleiche Name wie der Logger, b) den Namen eines übergeordneten Pakets oder c) den Stamm -Loggerconfig. LoggerConfig -Objekte werden aus Logger -Deklarationen in der Konfiguration erstellt. Der LoggerConfig ist den Logtargets zugeordnet, die die LogeVents tatsächlich liefern.
Der größte Vorteil der Verwendung von Hexlog gegenüber der trace ist die Fähigkeit, bestimmte Protokollanweisungen zu deaktivieren und gleichzeitig andere ohne Änderung gedruckt zu werden. Diese Fähigkeit geht davon aus, dass der Protokollierungsraum, dh der Raum aller möglichen Protokollierungsanweisungen, nach einigen von Entwicklern ausgewählten Kriterien eingestuft wird. Logger und Loggerconfigs werden als Entitäten bezeichnet. Logger-Namen sind Fallempfindlichkeit und folgen der hierarchischen Namensregel.
Benennung hierarchie
Ein Loggerconfig soll ein Vorfahr eines anderen Loggerconfig sein, wenn sein Name gefolgt von einem Punkt (
.) Ein Präfix eines Nachkommen -Logger -Namens ist. Ein Loggerconfig soll ein Elternteil eines Kinderloggerconfig sein, wenn es keine Vorfahren zwischen sich und dem Nachkommen loggerconfig gibt.
Beispielsweise ist die Loggerconfig namens "com.foo" ein übergeordnetes über das loggerconfig mit dem Namen "com.foo.Bar" . In ähnlicher Weise ist "hex" ein Elternteil von "hex.log" und ein Vorfahr von "hex.log.Logger" . Dieses Namensschema sollte den meisten Entwicklern bekannt sein. Der root loggerconfig befindet sich oben in der Hierarchie. Es ist insofern außergewöhnlich, als es immer existiert und Teil jeder Hierarchie ist. Ein Logger, der direkt mit dem Roo LoggerConfig verknüpft ist, kann wie folgt erhalten werden:
var rootLogger = LogManager . getLogger ( " " );
// or more simply
var rootLogger = LogManager . getRootLogger (); Alle anderen Holzfäller können mit der statischen Methode Logmanager.getLogger abgerufen werden, indem der Name des gewünschten Loggers übergeben wird.
Der LoggerContext fungiert als Ankerpunkt des Protokollierungssystems. Derzeit ist es nicht möglich, mehrere LoggerContexte zu haben, aber Sie können die LoggerContext -Implementierung ändern, indem Sie den Wert eines statischen Eigenschaft LogManager.context ändern.
Falls Sie die Protokollierung im Makrokontext verwenden möchten, können Sie bereits vorbereitete MacroLoggerContext verwenden, das vorkonfigurierte Nachrichtenfabrik und Nachrichten enthält, die speziell für Druckausdrücke entwickelt wurden.
LoggerContext hat eine aktive Configuration . Die Konfiguration enthält alle LogTargets, kontextweiten Filter und Loggerconfigs.
Wie bereits erwähnt, kann Logger erstellt werden, indem LogManager.getLogger aufgerufen wird. Der Logger selbst führt keine direkten Aktionen aus. Es hat einfach einen Namen und ist einem Loggerconfig zugeordnet. Es erweitert AbstractLogger und implementiert die erforderlichen Methoden. Da die Konfiguration geändert wird, können Protokollierer mit einem anderen Loggerconfig verbunden werden, wodurch ihr Verhalten geändert wird.
Aufrufen LogManage.getLogger -Methode mit demselben Namen gibt immer eine Referenz auf genau das gleiche Logger -Objekt zurück. Das bedeutet:
var x = LogManager . getLogger ( " something " );
var y = LogManager . getLogger ( " something " ); x und y beziehen sich auf genau dasselbe Logger -Objekt. ( x == y ist immer true )
Die Konfiguration der Hexlog -Umgebung erfolgt immer bei der Anwendungsinitialisierung.
Hexlog erleichtert es einfach, Logger nach Softwarekomponenten zu benennen. Dies kann erreicht werden, indem der Logger in jeder Klasse instanziiert wird, wobei der Logger -Name dem vollständig qualifizierten Namen der Klasse entspricht. Dies ist eine nützliche und unkomplizierte Methode zur Definition von Holzfällen. Da der Protokollausgang den Namen des Erzeugungs -Loggers trägt, erleichtert diese Benennungsstrategie die Identifizierung des Ursprungs der Protokollnachricht. Dies ist jedoch nur eine mögliche Strategie, Logger zu benennen, und Hexlog beschränkt die mögliche Reihe von Holzfällern nicht. Der Entwickler kann die Logger immer wie gewünscht benennen.
Für Convenience bietet Hexlog eine Reihe von Funktionen, die Sie importieren können, um getLogger -Anrufe automatisch zu generieren. Es ist besonders praktisch bei der Verwendung import.hx -Datei. (Siehe Beispiel)
Zusätzliche Convenience -Methoden sind getLoggerByClass und getLoggerByInstance , die im Makrokontext nützlich sind, in dem Sie die Hexlog Convenience -Klasse nicht verwenden können.
LoggerConfig -Objekte werden erstellt, wenn Protokollierer in der Protokollierungskonfiguration deklariert werden. Der LoggerConfig enthält eine Reihe von Filtern, die das Loggevent zulassen müssen, bevor es an LogTargets weitergegeben wird. Es enthält auch einen Verweis auf den Satz von Logtargets, mit denen das Ereignis verarbeitet werden sollte.
Zusätzlich zum automatischen Loglevel -Filter -Hexlog bietet Filter, die angewendet werden können:
Weitere Informationen zu Filtern und Filterung
Die Fähigkeit, Protokollierungsanforderungen selektiv zu aktivieren oder zu deaktivieren, ist nur ein Teil des Bildes. Mit Hexlog können Protokollierungsanfragen auf mehrere Ziele gedruckt werden. In Hexlog Speak heißt ein Ausgabeziel LogTarget.
Weitere Informationen zu Protokollzielen
Meistens möchten Benutzer nicht nur das Ausgangsziel, sondern auch das Ausgabeformat anpassen. Dies wird erreicht, indem ein Layout mit einem LogTarget in Verbindung gebracht wird. Das Layout ist für die Formatierung des Logevent nach den Wünschen des Benutzers verantwortlich, während ein Protokollziel das Senden der formatierten Ausgabe an sein Ziel sendet.
Weitere Informationen zu Layouts
Intern im System wird jede logarithmische Anweisung durch ein Nachrichtenobjekt dargestellt.
Weitere Informationen zu Nachrichten
// Getting logger
var logger = LogManager . getLogger ( " LoggerName " );
// Logging simple message
logger . debug ( " Some message " );
// Logging message with parameters
var name = " World " ;
logger . debug ( " Hello {} " , [ name ]);HexLog -KlasseWenn Sie vorhaben, sich ausgiebig zu protokollieren, ist es eine gute Praxis, zuerst nach Ihrer Klasse einen Looger zu erhalten und dann Ihre Nachrichten zu senden
import hex . log . HexLog . * ; // Import all convenience functions
// If you're planning to use logger extensively, first get logger for your class
var logger = getLogger ();
// Gets replaced with:
// var logger = hex.log.LogManager.getLogger("my.current.class");
logger . debug ( " Hello world! " ); // you can now use logger as usualWenn Sie nur eine einfache Debug -Erklärung benötigen und sich keine Sorgen über die Leistung machen können, können Sie noch mehr abstrahierte Funktionen verwenden.
import hex . log . HexLog . * ; // Import all convenience functions
debug ( " Hello world " );
info ( " Hello world " );
warn ( " Hello world " );
error ( " Hello world " );
fatal ( " Hello world " );
// Gets replaced with:
// hex.log.LogManager.getLogger("my.current.class").debug("Hello world");
// ... etc // -- You can see this working in hex.log.ConfigurationTest.hx
// Create a new configuration
var configuration = new BasicConfiguration ();
// Create log targets
var traceTarget = new TraceLogTarget ( " Trace " , null , new DefaultTraceLogLayout ());
// Create a logger config and add targets
// (at this point we can also add filters to the configuration etc.)
var lc1 : LoggerConfig = LoggerConfig . createLogger ( " hex " , LogLevel . WARN , null , null ); // Logger will only forward warnings and higher
lc1 . addLogTarget ( traceTarget , LogLevel . ALL , null ); // Target will accept every event that arrives (in this case only warnings+ will be forwarded from the logger anyway)
configuration . addLogger ( lc1 . name , lc1 ); // Add logger config to the configuration
// Apply the configuration
LoggerContext . getContext (). setConfiguration ( configuration );
// Now you can request loggers and log as much you want and they will follow the rules set above
var logger = LogManager . getLogger ( " hex " );
logger . debug ( " test " ); // Fitered by config -> nothing will happen
logger . warn ( " test " ); // will be logged
var logger2 = LogManager . getLogger ( " hex.log " );
logger2 . debug ( " test " ); // Fitered by parent config -> nothing will happen
logger2 . warn ( " test " ); // will be logged
// NOTE: By default root logger is set to LogLevel.ERROR
var logger3 = LogManager . getLogger ( " something " );
logger3 . debug ( " test " ); // Filtered by root logger -> nothing will happen
logger3 . error ( " test " ); // will be logged
