Konfiguration
Es gibt insgesamt drei Wege, tinylog zu konfigurieren: über eine Properties-Datei, über System-Properties (können als
Properties-Datei
Die Konfiguration des Loggers mittels einer Properties-Datei ist für produktive Umgebungen der empfohlene Weg, tinylog zu konfigurieren. Die Properties-Datei sollte "tinylog.properties" heißen und im Default-Package liegen. Dazu reicht es in den gängigen IDEs wie z. B. Eclipse und Netbeans aus, die Datei "tinylog.properties" in das "src/"-Verzeichnis abzulegen. In auf Maven basierenden Projekten liegt "tinylog.properties" typischerweise unter "src/main/resources".
Liegt die Properties-Datei woanders, so kann dies tinylog über das System-Property "tinylog.configuration" mitgeteilt werden (z. B. "-Dtinylog.configuration=c:\conf\tinylog.properties"). Seit tinylog 1.2 kann anstatt einem Pfad zu einer lokalen Datei auch eine URL angegeben werden, um die Konfiguration beispielsweise übers Netzwerk zu laden. Alternativ ist auch möglich, Properties-Dateien programmatisch über den Configurator zu laden.
Beispiel für eine Properties-Datei:
tinylog.writer = file tinylog.writer.filename = log.txt tinylog.level = warning
Auf Wunsch kann tinylog die Properties-Datei beobachten und Änderungen automatisch, also während der Laufzeit, übernehmen. Dazu muss das Property "tinylog.configuration.observe" auf "true" gesetzt werden. Das Property kann einfach in der Properties-Datei gesetzt oder als System-Property beim Programmstart übergeben werden.
In OSGi-Anwendungen, wie z. B. Eclipse RCP, ist der einfachste Weg, ein Fragment für das tinylog-Bundle anzulegen und in diesem Fragment die Datei "tinylog.properties" in das Default-Package abzulegen.
System-Properties
System-Properties sind vor allem für Entwickler interessant, da auf diesem Weg die Konfiguration aus der Properties-Datei überschrieben werden kann. In den gängigen IDEs, wie z. B. Eclipse und Netbeans, kann man System-Properties einfach beim Start als "-D"-Parameter übergeben. System-Properties ermöglichen es beispielsweise, in produktiven Umgebungen Trace- und Debug-Log-Einträge zu aktivieren und somit einen Fehler leichter finden zu können.
Beispiel:
-Dtinylog.writer=file -Dtinylog.writer.filename=log.txt -Dtinylog.level=trace
Fluent-API
In speziellen Fällen kann es sinnvoll sein, tinylog programmatisch zu konfigurieren oder zur Laufzeit die Konfiguration zu ändern. Hierzu gibt es eine Fluent-API. Diese gewährleistet, dass neue Konfigurationen immer atomar gesetzt werden. Das heißt, dass alle Änderungen auf einmal aktiv werden, selbst bei multithreaded Programmen. Die Klasse, um tinylog zu konfigurieren, ist der Configurator.
Beispiel:
Configurator.defaultConfig()
.writer(new FileWriter("log.txt"))
.level(Level.WARNING)
.activate();
Configurator.defaultConfig() nimmt die Standard-Konfiguration und Configurator.currentConfig() die aktuelle Konfiguration als Grundlage.
Einstellungen
Locale
Die Locale wird z. B. zum Formatieren eines Datums oder von Zahlen verwendet. Wenn die Locale nicht oder auf "null" gesetzt wird, wird die Default-Locale der JVM verwendet.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.locale = <Locale> Beispiel: tinylog.locale = de_DE |
Definition: -Dtinylog.locale=<Locale> Beispiel: -Dtinylog.locale=de_DE |
Methoden-Signatur: Configurator.locale(Locale locale)Beispiel: Configurator.currentConfig()
.locale(Locale.GERMANY)
.activate(); |
Logging-Format
Das Logging-Format ist ein Pattern, das das Ausgabeformat der Log-Einträge beschreibt. Das Standard-Pattern ist
| Platzhalter | Beschreibung |
|---|---|
| {class} | Vollständiger Name der Klasse inklusive Package, aus der der Log-Eintrag stammt |
| {class_name} | Name der Klasse (ohne Package), aus der der Log-Eintrag stammt |
| {context:key} | Wert aus dem Logging-Context (Key ist der Schlüssel des Mappings) |
| {date} | Datum und Uhrzeit der Erstellung des Log-Eintrags Der Platzhalter kann optional ein Datums-Pattern wie z. B. "{date:yyyy-MM-dd HH:mm:ss}" enthalten. Das Datums-Pattern ist kompatibel mit SimpleDateFormat. Seit tinylog 1.3 können auch unter Java 9 Mikrosekunden und Nanosekunden wie im DateTimeFormatter definiert ausgegeben werden. |
| {file} | Dateiname der Java-Quelltext-Datei, aus der der Log-Eintrag stammt |
| {level} | Logging-Level des erstellten Log-Eintrags |
| {line} | Nummer der Zeile, in der der Log-Eintrag erstellt wurde |
| {message} | Text des erzeugten Log-Eintrags |
| {method} | Name der Methode, aus der der Log-Eintrag stammt |
| {package} | Package, aus dem der Log-Eintrag stammt |
| {pid} | Prozess-ID der Anwendung |
| {thread} | Name des aktiven Threads |
| {thread_id} | ID des aktiven Threads |
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.format = <Pattern> Beispiel: tinylog.format = {level}: {class}.{method}()\t{message} |
Definition: -Dtinylog.format=<Pattern> Beispiel: "-Dtinylog.format={level}: {class}.{method}()\t{message}" |
Methoden-Signatur: Configurator.formatPattern(String formatPattern)Beispiel: Configurator.currentConfig()
.formatPattern("{level}: {class}.{method}()\t{message}")
.activate(); |
Bei Bedarf kann für einzelne oder gruppierte Platzhalter eine Mindestgröße definiert werden. So ist es zum Beispiel möglich, Platzhalter als Spalten auszugeben.
| Properties | Parameters | Java Code |
|---|---|---|
Beispiel: tinylog.format = {{level}:|min-size=8} {message} |
Beispiel: "-Dtinylog.format={{level}:|min-size=8} {message}" |
Beispiel: Configurator.currentConfig()
.formatPattern("{{level}:|min-size=8} {message}")
.activate(); |
Seit tinylog 1.1 kann die Einrücktiefe nach Zeilenumbrüchen definiert werden. Dies ermöglicht zum Beispiel den Stack-Trace von Exceptions um eine feste Anzahl von Leerzeichen einzurücken. Jedes Tab am Zeilenanfang wird ebenfalls durch die definierte Anzahl an Leerzeichen ersetzt. Dadurch werden die eigentlichen Stack-Traces um die doppelte definierte Anzahl an Leerzeichen eingerückt und die Beschreibung von (Cause-)Exceptions um die einfache Anzahl.
| Properties | Parameters | Java Code |
|---|---|---|
Beispiel: tinylog.format = {level}: {message|indent=4} |
Beispiel: "-Dtinylog.format={level}: {message|indent=4}" |
Beispiel: Configurator.currentConfig()
.formatPattern("{level}: {message|indent=4}")
.activate(); |
Bei der Verwendung von mehreren Writers kann bei Bedarf für einzelne ein eigenes Logging-Format definiert werden.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.writer* = <Name> tinylog.writer*.format = <Pattern> Beispiel: tinylog.writer1 = console
tinylog.writer1.format = {level}: {message}
tinylog.writer2 = file
tinylog.writer2.filename = log.txt
tinylog.writer2.format = {class}.{method}()\t{message} |
Definition: -Dtinylog.writer*=<Name> -Dtinylog.writer*.format=<Pattern> Beispiel: -Dtinylog.writer1=console
"-Dtinylog.writer1.format={level}: {message}"
-Dtinylog.writer2=file
-Dtinylog.writer2.filename=log.txt
"-Dtinylog.writer2.format={class}.{method}()\t{message}" |
Methoden-Signatur: Configurator.writer(Writer writer, String formatPattern).addWriter(Writer writer, String formatPattern)Beispiel: Configurator.currentConfig()
.writer(new ConsoleWriter(), "{level}: {message}")
.addWriter(new FileWriter("log.txt"), "{class}.{method}()\t{message}")
.activate(); |
Logging-Level
tinylog unterstützt fünf verschiedene Logging-Level: TRACE < DEBUG < INFO < WARNING < ERROR. Standardmäßig ist das Level INFO aktiv. Das bedeutet, dass nur Log-Einträge mit dem Logging-Level INFO und höher (INFO, WARNING und ERROR) ausgegeben und alle anderen Log-Einträge (TRACE und DEBUG) ignoriert werden. Das Logging-Level kann auch auf OFF gesetzt werden, um das Loggen zu deaktivieren.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.level = <Logging-Level> Beispiel: tinylog.level = debug |
Definition: -Dtinylog.level=<Logging-Level> Beispiel: -Dtinylog.level=debug |
Methoden-Signatur: Configurator.level(Level level)Beispiel: Configurator.currentConfig()
.level(Level.DEBUG)
.activate(); |
Bei Bedarf kann für einzelne Packages oder Klassen ein abweichendes Logging-Level gesetzt werden.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.level@<Package oder Klasse> = <Logging-Level> Beispiel: tinylog.level@org.pmw.tinylog = trace |
Definition: -Dtinylog.level@<Package oder Klasse>=<Logging-Level> Beispiel: -Dtinylog.level@org.pmw.tinylog=trace |
Methoden-Signatur: Configurator.level(String packageOrClass, Level level)Beispiel: Configurator.currentConfig()
.level("org.pmw.tinylog", Level.TRACE)
.activate(); |
Bei der Verwendung von mehreren Writers kann bei Bedarf für einzelne ein separates Logging-Level definiert werden. Der Writer gibt dann nur Log-Einträge mit dem definierten oder höherem Logging-Level aus.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.writer* = <Name> tinylog.writer*.level = <Logging-Level> Beispiel: tinylog.writer1 = console tinylog.writer1.level = trace tinylog.writer2 = file tinylog.writer2.filename = log.txt tinylog.writer2.level = info |
Definition: -Dtinylog.writer*=<Name> -Dtinylog.writer*.level=<Logging-Level> Beispiel: -Dtinylog.writer1=console -Dtinylog.writer1.level=trace -Dtinylog.writer2=file -Dtinylog.writer2.filename=log.txt -Dtinylog.writer2.level=info |
Methoden-Signatur: Configurator.writer(Writer writer, Level level).addWriter(Writer writer, Level level)Beispiel: Configurator.currentConfig()
.writer(new ConsoleWriter(), Level.TRACE)
.addWriter(new FileWriter("log.txt"), Level.INFO)
.activate(); |
Stack-Traces einschränken
Die Anzahl der maximal ausgegebenen Zeilen eines Strack-Traces einer Exception kann beschränkt werden, damit die Logs nicht zu groß werden. Der Standard-Maximalwert ist "40". Mit dem Wert "-1" kann die Beschränkung aufgehoben und mit dem Wert "0" Stack-Traces komplett deaktiviert werden.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.stacktrace = <Max. Zeilen> Beispiel: tinylog.stacktrace = 100 |
Definition: -Dtinylog.stacktrace=<Max. Zeilen> Beispiel: -Dtinylog.stacktrace=100 |
Methoden-Signatur: Configurator.maxStackTraceElements(int maxStackTraceElements)Beispiel: Configurator.currentConfig()
.maxStackTraceElements(100)
.activate(); |
Writers
Ein Writer ist für die Ausgabe der Log-Einträge zuständig (z. B. in eine Log-Datei oder in die Konsole). Standardmäßig werden die Log-Einträge in der Konsole ausgegeben. In tinylog sind sechs Writers enthalten.
| Writer | Name | Beschreibung |
|---|---|---|
| ConsoleWriter | console | Schreibt Log-Einträge in die Konsole |
| FileWriter | file | Schreibt Log-Einträge in eine angegebene Datei |
| JdbcWriter | jdbc | Speichert Log-Einträge in eine SQL-Datenbank |
| LogcatWriter | logcat | Leitet Log-Einträge an Androids natives Logging-System weiter |
| RollingFileWriter | rollingfile | Wie der FileWriter, aber nutzt rotierend mehrere Log-Dateien |
| SharedFileWriter | sharedfile | Unterstützt das Schreiben von mehreren Instanzen einer Anwendung in dieselbe Datei |
| null | null | Alle Log-Einträge verschwinden im "Nichts" |
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.writer = <Name oder null> Beispiel: tinylog.writer = console |
Definition: -Dtinylog.writer=<Name oder null> Beispiel: -Dtinylog.writer=console |
Methoden-Signatur: Configurator.writer(Writer writer)Beispiel: Configurator.currentConfig()
.writer(new ConsoleWriter())
.activate(); |
Es können beliebig viele Writers aktiviert werden. So ist es beispielsweise möglich, Log-Einträge gleichzeitig in die Konsole und in eine Log-Datei auszugeben.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.writer* = <Name> Beispiel: tinylog.writer1 = console tinylog.writer2 = file tinylog.writer2.filename = log.txt |
Definition: -Dtinylog.writer*=<Name> Beispiel: -Dtinylog.writer1=console -Dtinylog.writer2=file -Dtinylog.writer2.filename=log.txt |
Methoden-Signatur: Configurator.writer(Writer writer).addWriter(Writer writer)Beispiel: Configurator.currentConfig()
.writer(new ConsoleWriter())
.addWriter(new FileWriter("log.txt"))
.activate(); |
Optional können einzelne Writers mit separatem Logging-Format und/oder Logging-Level versehen werden.
ConsoleWriter
Der ConsoleWriter ist der Standard-Writer und schreibt Log-Einträge in die Konsole. Standardmäßig werden Warnungen und Fehler werden im Error-Stream (System.err), alle anderen Logging-Level im Standard-Output-Stream (System.out) ausgegeben. Der ConsoleWriter kann ab tinylog 1.3 auch so konfiguriert werden, dass alle Log-Einträge unabhängig des Logging-Levels immer im selben Stream ausgegeben werden.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.writer = <name>
tinylog.writer.stream = <stream> (optional)Beispiel: tinylog.writer = console tinylog.writer.stream = err | Definition: -Dtinylog.writer=<name>
-Dtinylog.writer.stream=<stream> (optional)Beispiel: -Dtinylog.writer=console -Dtinylog.writer.stream=err |
Methoden-Signatur: Configurator.writer(Writer writer)Beispiel: Configurator.currentConfig()
.writer(new ConsoleWriter())
.activate(); |
FileWriter
Der FileWriter schreibt Log-Einträge in eine definierte Datei. Das Schreiben kann optional gepuffert erfolgen, was vor allem im Zusammenspiel mit dem Writing-Thread deutlich performanter ist. Gepuffertes Schreiben kann allerdings dazu führen, dass beim Absturz der JVM möglicherweise die letzten - und damit die wichtigsten - Log-Einträge verloren gehen.
Eine bereits existierende Log-Datei wird standardmäßig beim Start überschrieben. Seit tinylog 1.1 ist es möglich Log-Dateien durch das Aktivieren des Append-Modus fortzusetzen.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.writer = <Name> tinylog.writer.filename = <Dateiname> tinylog.writer.buffered = <puffern> (default: false) tinylog.writer.append = <fortsetzen> (default: false) Beispiel: tinylog.writer = file tinylog.writer.filename = log.txt tinylog.writer.buffered = true tinylog.writer.append = false |
Definition: -Dtinylog.writer=<Name> -Dtinylog.writer.filename=<Dateiname> -Dtinylog.writer.buffered=<puffern> (default: false) -Dtinylog.writer.append=<fortsetzen> (default: false) Beispiel: -Dtinylog.writer=file -Dtinylog.writer.filename=log.txt -Dtinylog.writer.buffered=true -Dtinylog.writer.append=false |
Methoden-Signatur: Configurator.writer(Writer writer)Beispiel: Configurator.currentConfig()
.writer(new FileWriter("log.txt", true, false))
.activate(); |
JdbcWriter
Der JdbcWriter schreibt Log-Einträge in eine SQL-Datenbank. Die Inserts können optional im Batch-Modus erfolgen, was vor allem im Zusammenspiel mit dem Writing-Thread deutlich performanter ist. Der Batch-Modus führt allerdings zu verzögerten Inserts, was dazu führen kann, dass beim Absturz der JVM möglicherweise die letzten - und damit die wichtigsten - Log-Einträge verloren gehen.
Mit tinylog 1.2 werden Java-EE-Data-Sources sowie die automatische Wiederherstellung der Verbindung zur Datenbank nach einem Verbindungsabbruch unterstützt. Zur Aktivierung der automatischen Verbindungswiederherstellung genügt es die Zeitspanne zwischen zwei Verbindungsversuchen einzustellen. URLs von Data-Sources können genau wie JDBC-URLs definiert werden. tinylog erkannt anhand der URL automatisch, ob es sich um eine Date-Source oder JDBC handelt. Benutzername und Passwort brauchen für Date-Sources nicht in tinylog gesetzt zu werden, da diese üblicherweise bereits in der Data-Source selbst definiert wurden.
Zur Vermeidung von Sicherheitslücken durch SQL-Injections, werden PreparedStatements genutzt.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.writer = <Name> tinylog.writer.url = <JDBC oder Data-Source> tinylog.writer.reconnect = <Sekunden> (default: aus) tinylog.writer.table = <Tabellenname> tinylog.writer.columns = <Spalten> (default: aus Tabelle) tinylog.writer.values = <Werte zu loggen> tinylog.writer.batch = <Batch-Modus> (default: false) tinylog.writer.username = <Benutzername> (falls vorhanden) tinylog.writer.password = <Passwort> (falls vorhanden) Beispiel: tinylog.writer = jdbc tinylog.writer.url = jdbc:h2:mem:mydb tinylog.writer.table = LOG_ENTRIES_TABLE tinylog.writer.columns = COLUMN_A, COLUMN_B tinylog.writer.values = LEVEL, MESSAGE |
Definition: -Dtinylog.writer=<Name> -Dtinylog.writer.url=<JDBC oder Data-Source> -Dtinylog.writer.reconnect=<Sekunden> (default: aus) -Dtinylog.writer.table=<Tabellenname> -Dtinylog.writer.columns=<Spalten> (default: aus Tabelle) -Dtinylog.writer.values=<Werte zu loggen> -Dtinylog.writer.batch=<Batch-Modus> (default: false) -Dtinylog.writer.username=<Benutzername> (falls vorhanden) -Dtinylog.writer.password=<Passwort> (falls vorhanden) Beispiel: -Dtinylog.writer=jdbc -Dtinylog.writer.url=jdbc:h2:mem:mydb -Dtinylog.writer.table=LOG_ENTRIES_TABLE -Dtinylog.writer.columns=COLUMN_A, COLUMN_B -Dtinylog.writer.values LEVEL, MESSAGE |
Methoden-Signatur: Configurator.writer(Writer writer)Beispiel: Configurator.currentConfig()
.writer(new JdbcWriter("jdbc:h2:mem:mydb", "LOG_ENTRIES_TABLE", Arrays.asList("COLUMN_A", "COLUMN_B"), Arrays.asList(Value.LEVEL, Value.MESSAGE)))
.activate(); |
Folgende Werte können ausgegeben werden:
| Name | Beschreibung |
|---|---|
| CLASS | Vollständiger Name der Klasse inklusive Package, aus der der Log-Eintrag stammt |
| CLASS_NAME | Name der Klasse (ohne Package), aus der der Log-Eintrag stammt |
| CONTEXT | Alle im Logging-Context gesetzten Werte (neu in tinylog 1.1) |
| DATE | Datum und Uhrzeit der Erstellung des Log-Eintrags |
| EXCEPTION | Geworfene Exception (null, wenn keine Exception geworfen wurde) |
| FILE | Dateiname der Java-Quelltext-Datei, aus der der Log-Eintrag stammt |
| LEVEL | Logging-Level des erstellten Log-Eintrags |
| LINE | Nummer der Zeile, in der der Log-Eintrag erstellt wurde |
| MESSAGE | Text des erzeugten Log-Eintrags |
| METHOD | Name der Methode, aus der der Log-Eintrag stammt |
| PACKAGE | Package, aus dem der Log-Eintrag stammt |
| PROCESS_ID | Prozess-ID der Anwendung |
| RENDERED_LOG_ENTRY | Vollständig gerenderter Log-Eintrag, wie er bei textbasierten Ausgaben verwendet wird |
| THREAD_ID | ID des aktiven Threads |
| THREAD_NAME | Name des aktiven Threads |
LogcatWriter
Der LogcatWriter leitet Log-Einträge an Androids natives Logging-System (bekannt als logcat) weiter. Dieser Writer kann ausschließlich unter Android verwendet werden und ist neu in tinylog 1.2. Standardmäßig wird der Name der Klasse (ohne Package), aus der der Log-Eintrag stammt, als Tag für logcat verwendet.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.writer = <name>
tinylog.writer.tag = <tag> (default: Name der Klasse)Beispiel: tinylog.writer = logcat tinylog.writer.tag = MyApp | Definition: -Dtinylog.writer=<name>
-Dtinylog.writer.tag=<tag> (default: Name der Klasse)Beispiel: -Dtinylog.writer=logcat -Dtinylog.writer.tag=MyApp |
Methoden-Signatur: Configurator.writer(Writer writer)Beispiel: Configurator.currentConfig()
.writer(new LogcatWriter())
.activate(); |
RollingFileWriter
Der RollingFileWriter schreibt Log-Einträge in eine definierte Datei. Dabei kann in regelmäßigen Abständen eine neue Log-Datei begonnen werden. Alte Log-Dateien werden als Backup aufbewahrt. Um das Vergeben von eindeutigen Namen kümmert sich ein Labeler. Standardmäßig werden die Log-Dateien durchnummeriert. Wann eine neue Log-Datei begonnen werden soll, kann über Policies definiert werden. Wenn nichts anderes eingestellt wurde, wird bei jedem Start eine neue Log-Datei begonnen.
Das Schreiben in die Log-Datei kann optional gepuffert erfolgen, was vor allem im Zusammenspiel mit dem Writing-Thread deutlich performanter ist. Gepuffertes Schreiben kann allerdings dazu führen, dass beim Absturz der JVM möglicherweise die letzten - und damit die wichtigsten - Log-Einträge verloren gehen.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.writer = <Name> tinylog.writer.filename = <Dateiname> tinylog.writer.buffered = <puffern> (default: false) tinylog.writer.backups = <Anzahl der Backups> tinylog.writer.label = <Labeler> (default: count) tinylog.writer.policies = <Policies> (default: startup) Beispiel: tinylog.writer = rollingfile tinylog.writer.filename = log.txt tinylog.writer.backups = 10 tinylog.writer.label = timestamp tinylog.writer.policies = startup, size: 10KB |
Definition: -Dtinylog.writer=<Name> -Dtinylog.writer.filename=<Dateiname> -Dtinylog.writer.buffered=<puffern> (default: false) -Dtinylog.writer.backups=<Anzahl der Backups> -Dtinylog.writer.label=<Labeler> (default: count) -Dtinylog.writer.policies=<Policies> (default: startup) Beispiel: -Dtinylog.writer=rollingfile -Dtinylog.writer.filename=log.txt -Dtinylog.writer.backups=10 -Dtinylog.writer.label = timestamp "-Dtinylog.writer.policies=startup, size: 10KB" |
Methoden-Signatur: RollingFileWriter(String filename, int backups, Policy... policies)Beispiel: Configurator.currentConfig()
.writer(new RollingFileWriter("log.txt", 10, new TimestampLabeler(), new StartupPolicy(), new SizePolicy(10 * 1024)))
.activate(); |
Labelers
Der RollingFileWriter unterstützt Labelers, die archivierte Log-Dateien nach einem definierten Schema benennen. Standardmäßig ist der CountLabeler aktiv.
| Labeler | Name | Beschreibung |
|---|---|---|
| CountLabeler | count | Nummeriert Backups durch (z. B. "log.0.txt" für das aktuellste Backup, "log.1.txt" für das zweit-aktuellste usw.) |
| ProcessIdLabeler | pid | Fügt die Prozess-ID der Anwendung zum Dateinamen hinzu (z. B. "log.1836.txt", wenn die Prozess-ID 1836 lautet) und stellt so sicher, dass jede aktive Instanz der Anwendung eine eigene Log-Datei erhält |
| TimestampLabeler | timestamp | Fügt einem Timestamp zum Dateinamen hinzu (z. B. "log.2012-08-20 08-22-31.txt") Der Timestamp kann über ein Datums-Pattern definiert werden (z. B. "timestamp: yyyy-MM-dd HH-mm-ss"). Das Datums-Pattern ist kompatibel mit SimpleDateFormat und ab tinylog 1.3 unter Java 9 auch mit DateTimeFormatter. |
Policies
Über Policies, kann definiert werden, wann der RollingFileWriter eine neue Log-Datei beginnen soll. Es können beliebig viele Policies miteinander verknüpft werden.
| Policy | Name | Beschreibung |
|---|---|---|
| CountPolicy | count | Beginnt eine neue Log-Datei, sobald die aktuelle Log-Datei die gewünschte Anzahl an Log-Einträgen erreicht hat (z. B. "count: 1000") |
| StartupPolicy | startup | Erzeugt bei jedem Start eine neue Log-Datei (z. B. "startup") |
| SizePolicy | size | Beginnt eine neue Log-Datei, sobald die aktuelle Log-Datei die gewünschte Größe erreicht hat (z. B. "size: 32KB") |
| HourlyPolicy | hourly | Beginnt zur jeden vollen Stunde eine neue Log-Datei (z. B. "hourly") |
| DailyPolicy | daily | Beginnt täglich eine neue Log-Datei (z. B. "daily: 03:00" oder einfach nur "daily" für täglich um Mitternacht) |
| WeeklyPolicy | weekly | Beginnt wöchentlich eine neue Log-Datei (z. B. "weekly: monday" für montagmorgens um 00:00 Uhr) |
| MonthlyPolicy | monthly | Beginnt monatlich eine neue Log-Datei (z. B. "monthly" für jeden 1. eines neuen Monats) |
| YearlyPolicy | yearly | Beginnt jährlich eine neue Log-Datei (z. B. "yearly" für jährlich am 01.01. oder "yearly: july" für den 01.07.) |
SharedFileWriter
Der SharedFileWriter schreibt Log-Einträge in eine definierte Datei. Dabei können mehrere aktive Instanzen einer Anwendung gleichzeitig in dieselbe Log-Datei schreiben. Eine Alternative ist die Verwendung des RollingFileWriter mit dem ProcessIdLabeler, um für jede aktive Instanz der Anwendung eine eigene Log-Datei zu erstellen. Für Anwendungen, bei denen nie mehr als eine Instanz existiert, ist der FileWriter deutlich schneller.
Eine bereits existierende Log-Datei wird standardmäßig beim Start überschrieben, wenn diese noch nicht in Benutzung ist. Weitere Prozesse werden sich immer anschließen, ohne dass vorhandene Log-Einträge überschrieben werden. Seit tinylog 1.1 ist es durch das Aktivieren des Append-Moduses möglich, Log-Dateien immer fortzusetzen. Aufgrund von Limitierungen der JVM funktioniert das Deaktivieren des Append-Modus nur unter Windows. Falls tinylog ein anderes Betriebssystem erkennt, wird der Append-Modus automatisch aktiviert.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.writer = <Name>
tinylog.writer.filename = <Dateiname>
tinylog.writer.append = <fortsetzen> (default: false)Beispiel: tinylog.writer = sharedfile tinylog.writer.filename = log.txt tinylog.writer.append = true |
Definition: -Dtinylog.writer=<Name>
-Dtinylog.writer.filename=<Dateiname>
-Dtinylog.writer.append=<fortsetzen> (default: false)Beispiel: -Dtinylog.writer=sharedfile -Dtinylog.writer.filename=log.txt -Dtinylog.writer.append=true |
Methoden-Signatur: Configurator.writer(Writer writer)Beispiel: Configurator.currentConfig()
.writer(new SharedFileWriter("log.txt", true))
.activate(); |
Writing-Thread
Writers können in einem separaten Thread ausgeführt werden. Dies hat den Vorteil, dass die eigentliche Anwendung nicht durch langsame Schreib-Operationen blockiert wird. Standardmäßig läuft der Writing-Thread mit niedriger
In Standard-Java-Applikationen ist es üblich, den Writing-Thread an den Main-Thread oder einen anderen langlaufenden Thread zu koppeln. Der Writing-Thread beendet sich dann automatisch mit dem anderen Thread. In Java-EE-Applikationen existiert kein standardisierter langlaufender Thread. Bewährt hat sich in diesem Fall den Writing-Thread manuell über einen ServletContextListener herunterzufahren, anstatt an einen anderen Thread zu koppeln. Dazu kann der zu beobachtende Thread auf null gesetzt und die statische Methode Configurator.shutdownWritingThread() gerufen werden.
| Properties | Parameter | Programmatisch |
|---|---|---|
Definition: tinylog.writingthread = <true oder false> tinylog.writingthread.observe = <Thread> (default: main) tinylog.writingthread.priority = <Priorität> (default: 2) Beispiel: tinylog.writingthread = true tinylog.writingthread.observe = null tinylog.writingthread.priority = 1 |
Definition: -Dtinylog.writingthread=<true oder false> -Dtinylog.writingthread.observe=<Thread> (default: main) -Dtinylog.writingthread.priority=<Priorität> (default: 2) Beispiel: -Dtinylog.writingthread=true -Dtinylog.writingthread.observe=null -Dtinylog.writingthread.priority=1 |
Methoden-Signatur: Configurator.writingThread(String threadToObserve, int priority)Beispiel: Configurator.currentConfig()
.writingThread("main", 1)
.activate(); |