Universal Logging System

Log files can be searched for lines which match specific patterns. Matching lines are parsed and variables are filled with matching expressions. Output actions can contain these variables in executable commands.

lfa4uls = logfile adapter for ULS = Logfileadapter

Appended lines of constantly growing log files can be searched for regular expressions. Based on given format descriptions, the matching lines are parsed and defined variables or placeholders are set. These variables can be embedded in action definitions for output, in which the whole matching line can, e.g., be sent to the ULS-server or be written to another log file or be sent via e-mail.

The lfa4uls does not need to be used in conjunction with the ULS-server, but can also be used as a stand-alone solution for log file parsing and processing.

The regular expressions are processed by the lfa4uls accordingly to POSIX.2 (1003.2). See also:

man 7 regex

You may start the logfile adapter to parse a logfile once and write out the found matches or you start it as daemon to tail the given logfile and parse each appended line.

lfa4uls [-?] [-a|-A] [-c <conffile>] [-d <def>] [-D|-Dp <pidfile>] [-g]
        [-H <num>] [-s|-S] [-u] [-U] [-v <reg>|-vf <vfile>] [-f <inputformat>]
        [-r] [-t <sec>|-T <sec>] [-N <sec>]
        [-l <lreg>|-lf <lfile>|-la] [-lw <loutfmt>] [-L <logaction>]
        [-o <outputfile>] [-oh <header>] [-V]
        [-I <inputdir> | <inputfiles> ...]

translate the remaining text

Protokolldateien können mit dem lfa4uls ausgewertet und durchsucht werden.

lfa4uls = logfile adapter for ULS = Logfileadapter

Mit dem lfa4uls können die Inhalte von stetig wachsenden Protokolldateien zeilenweise nach Textmustern (regulären Ausdrücken) durchsucht werden. Zeilen, die einem Textmuster entsprechen, werden nach einer Formatbeschreibung (inputformat, iformat) ausgewertet. Die Ergebnisse dieser Auswertung stehen für die Weiterverarbeitung (action) in der Ausgabe zur Verfügung, zB können diese Zeilen dann an das ULS geschickt werden. Die Ausgaben können auch direkt in eine Datei geschrieben werden, z. B. im ULS-Tabellenformat.

Trotz der Bezeichnung lfa4uls, kann er unabhängig vom ULS eingesetzt werden. Bei der Weiterverarbeitung in der Ausgabe können beliebige Kommandos verwendet werden.

Ablaufbeschreibung

Für jede neu hinzukommende Zeile werden folgende Aktionen durchgeführt:

• passt die Zeile zum regulären Ausdruck von vreg, dann diese Zeile ignorieren ⇒ auf nächste Zeile warten
• passt die Zeile zu einem regulären Ausdruck von reg0..reg99 oder reg0+..reg99+, dann die Zeile parsen mit iformat0..99 und entsprechende action0..action99 ausführen ⇒ wenn reg0+..reg99+, dann weiter vergleichen, sonst auf nächste Zeile warten
• ist ereg_all = 1, dann eaction ausführen ⇒ auf nächste Zeile warten
• passt die Zeile zum regulären Ausdruck von ereg, dann die Zeile parsen mit inputformat und eaction ausführen ⇒ auf nächste Zeile warten
• ist wreg_all = 1, dann waction ausführen ⇒ auf nächste Zeile warten
• passt die Zeile zum regulären Ausdruck von wreg, dann die Zeile parsen mit inputformat und waction ausführen ⇒ auf nächste Zeile warten
• ist lreg_all = 1, dann laction ausführen ⇒ auf nächste Zeile warten
• passt die Zeile zum regulären Ausdruck von lreg, dann die Zeile parsen mit inputformat und laction ausführen ⇒ auf nächste Zeile warten
• wenn keine der obigen Bedingungen erfüllt sind, dann wird die Zeile ignoriert ⇒ auf nächste Zeile warten

Zu allen direkt eingetragenen regulären Ausdrücken reg?[+] kann auch eine Datei reg_file?[+] angegeben werden, die mehrere Zeilen mit jeweils einem regulären Ausdruck enthalten können. Die regulären Ausdrücke werden bei der Anwendung von reg_file? logisch ODER verknüpft. Es wird entweder reg? oder reg_file? verwendet, der letzte Eintrag in der Konfigurationsdatei entscheidet.

A mixture of command line parameters and entries in a configuration file <conffile> is supported.

Show a help page.

All lines of <inputfile> are searched from the beginning to the end and lfa4uls will wait for new lines.

Like -a, but lfa4uls terminates when the end of the file is reached.

Complete path of the configuration file <conffile>.

Defines variables like -d “%h=Hostname” or -d “%5=System”.

Start lfa4uls as daemon.

Start lfa4uls as daemon and write its PID to file <pid_file>.

Format for parsing the lines of the <inputfile>.

Ignore the special meaning of '[]{}()' in regular expressions.

Number of lines that can be aggregated.

Define the regular expression, which fires the 'log' action.

Each line fires the 'log' action.

Like -l <regexp> but read the regular expressions from file <regexp_file>.

Define the output line format <outputfmt> for 'log' action.

Action for each line matching the 'log' condition.

Ignore equal lines within <sec> seconds.

Output is appended to file name.

Print the actions, do not execute them.

Print the actions, lfa4uls terminates when the end of the file is reached.

Look for new lines in <inputfiles> after <sec> seconds. Default is 5s.

Start reading from the beginning of the <inputfile> every <sec> seconds.

Print timestamps in coordinated universal time.

Read timestamps in coordinated universal time.

Ignore lines with matching regular expressions.

Ignore lines with matching regular expressions read from <regexp_file>.

Show version of this

Specify the complete path of the <inputfiles> which shall be parsed.

The confoguration file defines all parsing and output actions. It may be mixed with the usage of command line parameters. This is the complete description, you may prefer to advance to the Usage section below for a more practical approach.

lfa4uls_configuration.txt

#
# Konfigurationsdatei für lfa4uls
#

# Der Input kann aus mehreren Dateien gelesen werden 
#   * "inputfile": Dateipfad
#   * "inputfilepattern": Suchmuster (Es sind nur * und ? als Wildcards erlaubt, aber auch für Directories)
#
# oder einem Programm
#   * "inputcommand"
#
# oder es koennen
#   * ganze Verzeichnisse "inputdir", optional mit allen Unterverzeichnissen überwacht werden
# 
# Die Möglichkeiten können nicht kombiniert werden.


# ----- FILE -----

# es können bis zu 100 Dateien überwacht werden, die als feste Dateinamen oder Suchmuster angeben werden
# d. h. inputfile und inputfilepattern darf mehrfach angegeben werden

# feste Dateinamen
#
# Zu überwachende Dateien, jede Datei mit "inputfile = "
inputfile = /var/log/messages

# Dateinamen nach Muster (alle)
#
# Alle Dateien, die dem Muster entspreche werden gescannt
inputfiles = /var/log/m*

# Dateien nach Muster (nur eine)
#
# Wenn der Name der Logdatei nicht feststeht. 
# Es wird die erste Datei, die zum Muster passt überwacht.
# Wenn die Datei gelöscht oder komprimiert wird, dann wird erneut gesucht.
# 
inputfilepattern = /var/log/prod/logfile*.log

# Die Suchreihenfolge kann geändert werden:
# inputfilepatternsort = U|FN|O|N
#    U : unsortier - Reihenfolge des Betriebssysstems
#    FN: bei Restart die neueste, dann chronologisch aufsteigend
#    O : Bei Restart die äteste, dann chronologisch aufsteigend
#    N : bei Restart die neueste, dann die neueste
inputfilepatternsort = FN

# zyklische Suche nach neuen Dateien:
# inputfilepatternsearch = <Sekunden>
#   es wird alle <Sekunden> Sekunden nach neueren Dateien als die aktuelle gesucht.
#   unabhängig von inputfilepatternsort wird auf die neueste Datei gewechselt
inputfilepatternsearch = 60


# ----- Protokolldatei ----
#
# logfile: Ausgabedatei
# logfile = <Protokollpfad>
logfile = /tmp/lfa4uls_test.log
#
# loglevel: Aktionen, die geloggt werden sollen
# loglevel = <Liste der zu protokollierenden Aktionen>
#   mögliche Aktionen:
#     NONE            Nichts
#     ERROR           Errors
#     WARNING         Warnings
#     FILE            öffnen und schließen von Dateien
#     MATCH           gefundene Zeilen
#     ACTION          ausgelöste Aktionen
#     WRITE           geschriebene Zeilen
#     SYSLOG          Zeilen an Syslog
#     STORE           gespeicherte Daten
#     STORESEND       versenden der gespeicherten Daten
#     CANCEL          ausgelöste "cancel"
#     SCHEDULEACTION  ausgeführte Schedule Aktionen
#     SCHEDULEWRITE   geschriebene Schedule Zeilen
#     ALL             Alles
loglevel = ERROR WARNING


# ----- Ausgabedatei -----
#
# Daten können direkt im ULS Format in eine Ausgabedatei geschrieben werden.
outputfile = /tmp/lfaulsdata.uls
#
# outputfileheader: jede Ausgabedatei mit einem Header versehen. Z. B. um den Zeichensatz zu setzen
outputfileheader = L;;;;;;latin1
#
# writequoting: Sonderzeichen in Variablen quoten. Das erste Zeichen ist das Quotingzeichen, das allen
#               Zeichen aus writequoting bei Variablenersetzungen und "write" vorangestellt wird.
writequoting = \"

# ----- automatisches Versenden der Ausgabedatei -----
#
# Es kann eine Aktion definiert werden, die zeitgesteuert ausgeführt wird,
# nachdem Daten in die Ausgabedatei geschrieben wurden
#
# sendoutputfilesecs: Zeit in Sekunden, die nach dem ersten Schreiben gewartet wird,
# bis die Datei versendet wird
sendoutputfilesecs = 180
#
# sendoutputfile: auszuführendes Programm, es können die gleichen Codes wie bei der Ausgabe verwendet werden
sendoutputfile = send2uls "%O"

# ----- zwischenspeichern von Zeilen -----
# storepath: Pfad, unter dem Zeilen mit "store" zwischengespeichert werden
storepath = /tmp/lfa4uls_store


# ----- PROGRAM -----
#
# Es wird von stdout eines Programmes gelesen.
inputcommand = netstat -nlt


# ----- Variablen -----
#
# Beim Parsen von Zeilen stehen folgende Variablen zur Verfügung:
%h - Hostname
%q - Quelle
%W - String bis zum Zeilenende
%V - String bis zum Zeilenende, bei der Erkennung von Dubletten werden Zahlen ignoriert
%0 bis %9 - freie Variablen
# die Variablen %h, %q und %0 - %9 können global vorbelegt werden:
set <varname>=<value>

# ----- DIRECTORY -----
# Für die Directory-Funktionen wird I-Notify verwendet, das unter Windows nicht zur Verfügung steht.
#
# Zu überwachendes Verzeichnis (nicht zusammen mit inputfile oder inputfilepattern)
inputdir = /var/log

# inputdir_num_subdirs wenn auf größer 1 gesetzt, dann werden bis zu inputdir_num_subdirs Unterverzeichniss mit überwacht
inputdir_num_subdirs = 50

# inputdir_num_files: Anzahl gleichzeitig offener Dateien, die überwacht werden.
# std ist 300
inputdir_num_files = 100

# dirfilepattern legt die Dateien fest, die Zeilenweise ausgewertet werden. Hist und consolidate ist noch nicht möglich.
dirfilepattern = *.log

# dirfilepipepattern: Dateien, die nach dem schließen an Kommando gesendet werden
# dirfilepipecmd: Dateien werden an STDIN des CMDs gesendet.
#                 Es können Parameter mit Codes verwendet werden. Die Codes %p, %P und Datumswerte sind gesezt,
#                 die anderen Codes sind nur gesetzt, wenn die Datei auch bei dirfilepattern ausgewählt ist.
dirfilepipepattern = *.dat
dirfilepipecmd = send_compressed_file %p %P

# dirfileclosepattern  Das Schließen von Dateien überwachen
# dirfileclosecmd      CMD ausführen, Parameter siehe dirfilepipecmd
# dirfileclosewrite    angegebenen Text in Ausgabedatei schreiben, Codes wie bei dirfilepipecmd
dirfileclosepattern = *.info
dirfileclosecmd = echo "Datei %P wurde geschlossen"
dirfileclosewrite = V;%F %T;%h;LFA;Dirmon;Close;%P;_

# dirfilecreatepattern  Anlegen von Dateien monitoren
# dirfilecreatecmd
# dirfilecreatewrite

# dirfiledeletepattern  Löschen von Dateien monitoren
# dirfiledeletecmd
# dirfiledeletewrite

# dirfilemodifypattern  Ändern von Dateien monitoren
# dirfilemodifycmd
# dirfilemodifywrite

# dirfilemovedfrompattern  Wegmoven von Dateien monitoren
# dirfilemovedfromcmd
# dirfilemovedfromwrite

# dirfilemovedtopattern  Hinmoven von Dateien monitoren
#                       (Wird eine Datei umbenannt, gibt es ein movedfrom und ein movedto)
#                       (Wird eine Datei von einem Verzeichnis in ein anderes gemoved, dann
#                        werden movedfrom und movedto nur für überwachte Verzeichnisse generiert)
# dirfilemovedtocmd
# dirfilemovedtowrite

# dirfileopenpattern  Öffnen von Dateien monitoren
# dirfileopencmd
# dirfileopenwrite


# ----- LINE FORMAT -----
#
# ----- INPUT FORMAT -----

inputformat = %t %h %q: %sValue1: %1, Value2: %2, %W

# <inputformat> beschreibt, wie die Zeilen des <inputfile> zu interpretieren sind.
# Dabei sind KEINE regulaeren Asdruecke moeglich, nur feste Strings.
# Die Groß-/Kleinschreibung kann durch das Anfügen des Zeichens '|' ans '=' ignoriert werden:

inputformat =| %t %h %q: %svalue1: %1, value2: %2, %W


# Folgende Codes koennen zum Parsen der Zeilen benutzt werden:
# %%      => %
# %[<CHARS>] => ein beliebiges Zeichen aus <CHARS>
# %s      => ein String (wird verworfen)
# %.<n>s  => <n> Zeichen (werden verworfen)
# %t      => Datum im Format: MMM TT hh:mm:ss (Monat Tag Stunde:Minute:Sekunde)
#             oder im Format: YYYY-MM-DD[T ]hh:mm:ss[.ssssss][+-hh:mm]
# %c      => ein Zeichen (wird verworfen)
# %.<n>c  => <n> Zeichen (werden verworfen)
# %h      => Host
# %q      => Quelle, Besonderheit bei %q: Ausdrücke, die in '()', '[]' oder '{}' stehen gelten bei der Wiederarlarmierung als identisch.
# %W      => Meldung (gelesen wird bis zum Zeilenende)
# %D      => Datum im Format: DD.MM.YY oder DD.MM.YYYY
# %F      => Datum im Format: YYYY-MM-DD
# %T      => Zeit im Format: hh:mm:ss
# %d      => Tag
# %m      => Monat
# %b      => Monatsname (erste drei Zeichen)
# %y      => Jahr (zweistellig)
# %Y      => Jahr (vierstellig)
# %H      => Stunde
# %M      => Minute
# %S      => Sekunde
# %0      => Variable 0
# %.<n>:0 => <n> Zeichen in Variable 0
# %1      => Variable 1
# %.<n>:1 => <n> Zeichen in Variable 1
# ...
# %9      => Variable 9
# %.<n>:9 => <n> Zeichen in Variable 9
#
# Leerzeichen zwischen den Codes ersetzen soviele white-spaces
# wie moeglich.
#
# Die meisten Codes stehen in den ?action und ?write fuer eine Ausgabe zur Verfuegung,
# siehe ACTION FORMAT.

# ----- ACTION und WRITE FORMAT -----
#
# In <?action>, <action?>, <?write> und <write?> koennen Ergebnisse des Parsens der
# Zeilen verwendet werden. Folgende Codes können dafuer verwendet werden:
# alle Codes des Inputfomates ohne %t, %s, %s* und %c
#
# %y => Jahr im Format YY
# %Y => Jahr im Format YYYY
# %b => Monatsname (erste drei Zeichen)
# %d => Tag (01..31)
# %m => Monat (01..12)
# %n => Anzahl gleicher Zeilen, die nicht ausgegeben wurden (sum_hist_secs > 0)
# %N => wie %n, aber nur, wenn > 0. Bei consolidate Anzahl der aufsummierten Zeilen
# %F => Datum im Format: YYYY-MM-DD
# %z => die ganze Zeile
# %l => Gesamtzahl bisher gelesener Zeilen
# %L => gelesene Zeilen seit letzter Ausgabe mit %L
# %C => Änderungsdatum der Datei im Format YYYY-MM-DD hh:mm:ss
# %B => Größe der Datei in Bytes (wenn von CMD oder Stdin gelesen wird, dann 0)
# %p => Dateiname der überwachten Datei
# %{p,<c>,<start>[,[<end>][,<str>[,<lstr>]]]} => Dateiname nach Zeichen <c> trennen und Teil des Dateinamens
#                                            von <start> bis <end> und ggf. <c> durch <str> ersetzen.
#                                            Ist nur <start> angegeben, nur dieses Element des Dateinamens.
#                                            0 als <end> ist bis zum Ende.
#                                            -1 als <end> ist bis zum vorletzten
#                                            ist <lstr> angegeben, wird das letzte <c> durch <lstr> ersetzt.
#                                            (keine Funktion bei -1 als <end>)
# %P => kompletter Pfad der überwachten Datei
# %{P,<start>[,[<end>][,<str>[,<lstr>]]]} => Teil des Pfades von <start> bis <end> und ggf. '/' durch <str> ersetzen.
#                                            Ist nur <start> angegeben, nur dieses Element des Pfades.
#                                            0 als <end> ist bis zum Ende.
#                                            -1 als <end> ist bis zum vorletzten
#                                            0 als <start> auch am Anfang des Pfades '/' bzw. <str> ausgeben
#                                            ist <lstr> angegeben, wird der letzte '/' durch <lstr> ersetzt.
#                                            (keine Funktion bei -1 als <end>)
# %O => kompletter Pfad der Ausgabedatei, wenn gesetzt
# %0 … %9 => Variablen 0-9
# %{<n>,HASH[,<len>]}       => gehaschte Variable 0-9 mit Länge <len> bzw. 8 wenn <len> nicht angegeben
#
# ----- Wenn „consolidate“ gesetzt, dann ist -----
#
# %N                     => Anzahl der Zeilen
# %{<n>,SUM[,<fmt>]}     => Summe über Variable <n>
# %{<n>,AVG[,<fmt>]}     => Mittelwert der Variable <n>
# %{<n>,MIN[,<fmt>]}     => Minimum der Variable <n>
# %{<n>,MAX[,<fmt>]}     => Maximum der Variable <n>
# %{<n>,FIR[ST][,<fmt>]} => erster Wert der Variablen <n>
# %{<n>,LAS[T][,<fmt>]}  => letzter Wert der Variablen <n>
# %{FIRSTDATE,<datfmt>}  => Datum der zuerst gelesenen Zeile
# %{LASTDATE,<datfmt>}   => Datum der zuletzt gelesenen Zeile
# %{TIMERANGE}           => Sekunden von erster bis letzter Zeile
# %{TIMEDIFF}            => Zeitdifferenz zur letzten Meldung in Sekunden
#                       <fmt> ist optionales Ausgabeformat im Format [<a>][.<b>]: Mindestbreite <a> und <b> Nachkommastellen
#                       <datfmt> Datumsformat wie bei Ausgabe mit %[abdDFHmMsSTwyY] z. B.: "%Y-%m-%d %H:%M:%S"

# ----- IGNORE -----
#
# Regulaeren Ausdruck fuer Zeilen definieren, die verworfen werden.
#
# vreg = INFO|MARK
#
# mit "ignore case"
#
# vreg =| info|warn
#
# Oder Datei mit regulaeren Ausdruecken angeben
#
# vreg_file = ignore_regexps_list.txt
# vreg_file =| ignore_regexps_list_ignore_case.txt

# ------ identische Zeilen ignorieren -----
# Sekunden, in denen gleiche Zeilen nicht noch einmal auslösen
#
# hist_secs = <seconds>
# 


# ----- REG[<n>] -----
# 
# 100 Moeglichkeiten mit einem regulaeren Ausdruck bestimmte Zeilen 
# herauszusuchen, diese mit eigenem Format (Standard ist <inputformat>) 
# zu Parsen und eine eigene Aktion auszuloesen. Wird eine Zeile
# gefunden, wird abgebrochen, außer das Schlüsselwort endet mit einem '+'

# Jeder Block muss mit einem der folgenden Schlüsselwörter beginnen
# reg        = zu suchende Reg-EXP
# reg+       = zu suchende Reg-EXP und weiter mit nächstem Block
# !reg       = nicht zu suchende Reg-EXP
# !reg+      = nicht zu suchende Reg-EXP und weiter mit nächstem Block
# regsplit   = zu suchende Reg-EXP, mit Blöcken, nach denen getrennt wird
# regsplit+  = wie regsplit und weiter mit nächsten Block
# reg_file   = zu suchende Reg-EXPs werden aus Datei gelesen
# reg_file+  = ... und weiter mit nächstem Block
# !reg_file  = nicht zu suchende Reg-EXPs werden aus Datei gelesen
# !reg_file+ = ... und weiter mit nächstem Block


# die folgenden Definitionen beziehen sich auf das Schlüsselwort am Beginn des Blockes

# iformat    = Inputformat wenn angegeben, sonst gilt globales inputformat (nicht bei regsplit)
# splitvars  = Zuordnung der Variablen zum regsplit

# hist_secs = <s> individuelle Einstellung für diesen Block
#                 gleiche Zeilen werden für <s> Sekunden unterdrückt. Die erste passende Zeile wird ausgegeben.

# sum_hist = <CONSFMT> bestimmt Anzahl identischer Zeilen gruppiert nach den Variablen. (count distinct mit %N als Anzahl)

# consolidate = <CONSFMT|CONSFMT2> fasst alle Zeilen des Musters zu einer Meldung zusammen. Es wird über alle Eingabedateien aufsummiert.
# Zusätzlich werden dann die Variablen aufsummiert, so dass Min, Max, Count, Sum und
# Average über die Variablen ausgegeben werden kann.
# <CONSFMT>:
#            <n>/<m>[s|m|h]<SFLE>: <n> 0-59
#              <m> Anzahl s|m|h
#              s|m|h Sekunden, Minuten, Stunden, def. ist m
#              <SFLE> Zeitstempelflag: S: Start, F: First, L: Last, E: End, def. ist E
# Bedeutung: Beginnend mit <n> wird alle <m> s|m|h eine Zeile ausgegeben.
# Beispiele:
# 0/5m -> alle 5 Minuten eine Zeile
# 3/10s -> alle 10 Sekunden (3, 13, 23, 33, 43, 53) eine Zeile
#
# <CONSFMT2>:
# <m><smh><FL>: <smh> für Sekunden, Minute, Stunden, <m> Anzahl
#               F|L first/last
# Bedeutung: Es wird auf pasende Zeilen gewartet, dann wird alle
# <m> Sekunden/Minuten/Stunden ein konsolidierter Wert         
# ausgegeben. Der Zeitstempel des Wertes ist der der ersten
# Zeile bei <FL> = F und der der letzten Zeile bei <FL> = L    
#   wenn consolidate gesetzt, dann wird Zeile erst nach Ablauf der Sekunden
#   ausgegeben oder bei SIGHUP|SIGUSR1    

# nread       = n Folgezeilen zusätzlich lesen
# nreadreg    = Folgezeilen, die Reg-EXP entsprechen lesen
# nread!reg   = Folgezeilen, die Reg-EXP nicht entsprechen lesen
# nreadtoreg  = Folgezeilen lesen, bis Reg-EXP gefunden
#               nreadtoreg liest die gefundene Zeile ein, nread!reg nicht
# nreadformat = Inputformat der Folgezeilen
# nreadaction = Auszuführende Aktion der Folgenzeilen
# nreadwrite  = Ausgabemuster der Folgezeilen für Ausgabedatei

# action      = auszuführende Aktion
# write       = Ausgabemuster für Ausgabedatei
# syslog      = an Syslog senden, Format: <priority>, <Ausgabe>
#                 <priority>: LOG_DEBUG|LOG_INFO|LOG_NOTICE|LOG_WARNING|LOG_ERR|LOG_CRIT|LOG_ALERT|LOG_EMERG
# store       = Ausgabeformat beim Schreiben in Temp-Datei (unter storepath)

# storesecs    = <seconds> - Sekunden, nach denen zwischengespeicherte Zeilen (store) gesendet werden
# storesendreg = <regexp>  - oder Regular-Expression, bei der die zwischengespeicherten Zeilen gesendet werden

# cancelreg    = <regexp>  - Regular-Expression, bei der zwischengespeicherte Zeilen gelöscht werden und
#                            konsolidierte Zeilen zurückgesetzt werden

# ----- Einschränkung der reg<n> für verschiedene Logdateien -----
#
# Die anzuwendenden reg<n> können pro "inputfile" bzw. "inputfilepattern" eingeschränkt werden.
# Dazu wird vor den entsprechenden "inputfile" und "inputfilepattern" Zeilen der Gültigkeitsbereich definiert:
#
# setregrange = <start> - <end>
#
# für die nun folgenden "input*" Zeilen gelten nur die reg<start> - reg<end>


# ----- LOG -----
#
# Regulaeren Ausdruck und Aktion fuer "Logging" (Info)

lreg_all    = 1
# lreg        = log
# lreg_file   =
laction     = echo 'Info: %z'
# lwrite    =

# alle [nread][!]reg[_file][+], iformat, nreadformat
# und lreg[_file]
# konnen durch anfügen eines '|' ans '=' auf "ignore case" geschaltet werden.

# ----- STAT -----
#
# Ausgabe statistischer Daten nach Zeit
ssched  = <SCHEDFORMAT>
swrite  = 
saction = 
# <SCHEDFORMAT>: <n>/<m>[s|m|h]<se>
#                <n>: Startzeitpunkt
#                <m>: Intervall in Einheite s/m/h, def. ist m
#                <se>: Zeitstempelflag: S: Start, E: End, def. ist E
# Bedeutung: Beginnend mit <n> wird alle <m> s|m|h eine Zeile ausgegeben. Siehe auch <CONSFMT>
#            Bei mehreren überwachten Dateien wird swrite und saction pro Datei ausgeführt,
#            so dass zur Unterscheidung %p oder %P im Text enthalten sein sollte.

This chapter describes the basic usage of the lfa4uls. One log file is searched for lines containing matches to given pattern.

Each new line is parsed, variables may be set to expressions.

This is a basic configuration file:

# ----- FILE -----
#
# file to search
inputfile = /var/log/messages

# ----- LINE FORMAT -----
#
inputformat = %t %h %q: %W

# <inputformat> defines the parsing rule for each line of the <inputfile>.
# Each line is eaten character by character and you cannot use regular 
# expressions, see 'reg' in the `Advanced Usage 1`_ below.

# You may use the following special directives:
# %%      => %
# %s      => discard an expression up to the next white space
# %.<n>s  => discard <n> non white space characters
# %t      => Date in the format: MMM DD hh:mm:ss
#              or in the format: YYYY-MM-DD[T ]hh:mm:ss[.ssssss][+-hh:mm]
# %c      => discard one character
# %.<n>c  => discard <n> characters
# %h      => set %h to the expression from current position to last non white space character
# %q      => set %q to the expression from current position to last non white space character
# %W      => set %h to the expression from current position to end of line
# %D      => set %D to the date in the format: DD.MM.YY or DD.MM.YYYY
# %F      => set %F to the date in the format: YYYY-MM-DD
# %T      => set %T to the time in the format: hh:mm:ss
# %d      => set %d to the day
# %m      => set %m to the month
# %b      => set %b to the three character month name
# %y      => set %y to the year, two digits
# %Y      => set %Y to the year, four digits
# %H      => set %H to the hour
# %M      => set %M to the minute
# %S      => set %S to the seconds
# %0      => set %0 to the expression up to last non white space character
# %.<n>:0 => set %0 to the next <n> characters
# %1      => set %1 to the expression up to last non white space character
# %.<n>:1 => set %1 to the next <n> characters
# ...
# %9      => set %9 to the expression up to last non white space character
# %.<n>:9 => set %9 to the next <n> characters
#
# One white space in the <inputformat> will eat as many white spaces as possible.

FIXME

# Die meisten Codes stehen in den ?action und ?write fuer eine Ausgabe zur Verfuegung,
# siehe ACTION FORMAT.

# ----- ACTION und WRITE FORMAT -----
# In <?action>, <action?>, <?write> und <write?> koennen Ergebnisse des Parsens der
# Zeilen verwendet werden. Folgende Codes können dafuer verwendet werden:
# alle Codes des Inputfomates ohne %t, %s, %s* und %c
#
# %y => Jahr im Format JJ
# %Y => Jahr im Format JJJJ
# %b => Monatsname (erste drei Zeichen)
# %d => Tag (01..31)
# %m => Monat (01..12)
# %n => Anzahl gleicher Zeilen, die nicht ausgegeben wurden (sum_hist_secs > 0)
# %N => wie %n, aber nur, wenn > 0
# %F => Datum im Format: YYYY-MM-DD
# %z => die ganze Zeile
# %p => Dateiname der überwachten Datei
# %P => kompletter Pfad der überwachten Datei
# %0 … %9 => Variablen 0-9

# ----- IGNORE -----
#
# Regulaeren Ausdruck fuer Zeilen definieren, die verworfen werden.
#
# vreg = INFO|MARK
#
# Oder Datei mit regulaeren Ausdruecken angeben
#
# vreg_file = ignore_regexps_list.txt

# ----- ERROR -----
#
# Regulaeren Ausdruck und Aktion fuer "Fehler"

# ereg_all    = 1
# ereg        = error
# ereg_file   =
# eaction     = echo 'Error: %z'
# ewrite      =

# ----- WARN -----
#
# Regulaeren Ausdruck und Aktion fuer "Warnung"

# wreg_all    = 1
# wreg        = warn
# wreg_file   =
# waction     = echo 'Warnung: %z'
# wwrite      =

# ----- LOG -----
#
# Regulaeren Ausdruck und Aktion fuer "Logging" (Info)

lreg_all    = 1
# lreg        = log
# lreg_file   =
laction     = echo 'Info: %z'
# lwrite    =

Für jede neu hinzukommende Zeile werden folgende Aktionen durchgeführt:

1. passt die Zeile zum regulären Ausdruck von vreg, dann diese Zeile ignorieren ⇒ auf nächste Zeile warten
2. passt die Zeile zu einem regulären Ausdruck von reg0..reg99 oder reg0+..reg99+, dann die Zeile parsen mit iformat0..99 und entsprechende action0..action99 ausführen ⇒ wenn reg0+..reg99+, dann weiter vergleichen, sonst auf nächste Zeile warten
3. ist ereg_all = 1, dann eaction ausführen ⇒ auf nächste Zeile warten
4. passt die Zeile zum regulären Ausdruck von ereg, dann die Zeile parsen mit inputformat und eaction ausführen ⇒ auf nächste Zeile warten
5. ist wreg_all = 1, dann waction ausführen ⇒ auf nächste Zeile warten
6. passt die Zeile zum regulären Ausdruck von wreg, dann die Zeile parsen mit inputformat und waction ausführen ⇒ auf nächste Zeile warten
7. ist lreg_all = 1, dann laction ausführen ⇒ auf nächste Zeile warten
8. passt die Zeile zum regulären Ausdruck von lreg, dann die Zeile parsen mit inputformat und laction ausführen ⇒ auf nächste Zeile warten
9. wenn keine der obigen Bedingungen erfüllt sind, dann wird die Zeile ignoriert ⇒ auf nächste Zeile warten

Zu allen direkt eingetragenen regulären Ausdrücken reg?[+] kann auch eine Datei reg_file?[+] angegeben werden, die mehrere Zeilen mit jeweils einem regulären Ausdruck enthalten können. Die regulären Ausdrücke werden bei der Anwendung von reg_file? logisch ODER verknüpft. Es wird entweder reg? oder reg_file? verwendet, der letzte Eintrag in der Konfigurationsdatei entscheidet.

Erklärung für Buchstaben, die verschiedenen Parametern voranstehen:

• v = herausfiltern (wie egrep -v) und verwerfen
• e = error
• w = warning
• l = logging

Mit dieser (logischen) Unterscheidung können verschiedene Aktionen für verschiedene reguläre Ausdrücke ausgeführt werden.

Ein einfaches Beispiel zum Auswerten der knldiag.err Protokolldatei einer MAX DB Datenbank.

Auszug aus der “/var/log/knldiag.err”:

/var/log/knldiag.err

2008-07-08 01:58:03 10953     11561 COMMUNIC Connected  T209 local 21792
2008-07-08 01:58:03 10953     11560 COMMUNIC Releasing  T209
2008-07-08 01:58:03 10953     12827 COMMUNIC wait for connection T209
+++++++++++++++++++++++++++++++++++++++ Kernel Exit ++++++++++++++++++++++++++++
2008-07-08 02:49:38     0     11987 dump_rte rtedump written to file 'rtedump'
2008-07-08 02:49:38     0 ERR 12005 DBCRASH  Kernel exited with core and exit status...
2008-07-08 02:49:38     0 ERR 12012 DBCRASH  No stack backtrace since signal handler...
2008-07-08 02:49:38     0 ERR 12009 DBCRASH  Kernel exited due to signal 11(SIGSEGV)
2008-07-08 02:49:38     0     12808 DBSTATE  Flushing knltrace pages
2008-07-08 02:49:39     0 WNG 11824 COMMUNIC Releasing  T206 kernel abort
2008-07-08 02:49:39     0 WNG 11824 COMMUNIC Releasing  T207 kernel abort
2008-07-08 02:49:39     0 WNG 11824 COMMUNIC Releasing  T212 kernel abort
...

Interessant sind die Zeilen mit “ERR”, das sind fatale Fehler und sollen protokolliert werden. Dazu die passende Konfigurationsdatei:

/tmp/lfa4uls_my.conf

# inputfile = /var/log/knldiag.err

# %F = YYYY-MM-DD
# %T = hh:mm:ss
# %W = der ganze Rest
inputformat = %F %T %W

# Alle Zeilen, die ERR enthalten
ereg = ERR

# Gebe die ganze Zeile auf stdout aus
eaction = echo %z

Test: Starte den lfa4uls direkt in der Kommandozeile (nicht als Dämon), zeige die Aktionen nur an (-s), starte das Durchsuchen der Datei (<inputfile>) vom Beginn an(-a), mit der Konfigurationsdatei (-c /tmp/lfa4uls_my.conf)::

lfa4uls -s -a -c /tmp/lfa4uls_my.conf

Obiger Aufruf bietet sich an, um Konfigurationen zu testen. Die Ausgabe passend zu obiger /var/log/knldiag.err ist::

echo 2008-07-08 02:49:38     0 ERR 12005 DBCRASH  Kernel exited with core and exit...
echo 2008-07-08 02:49:38     0 ERR 12012 DBCRASH  No stack backtrace since signal...
echo 2008-07-08 02:49:38     0 ERR 12009 DBCRASH  Kernel exited due to signal 11(SIGS...

lfa4uls steht dann am Ende der Datei und wartet auf weitere Zeilen. Abbrechen mit Ctrl-C. Evtl -S (nicht am Ende der Datei auf weitere Zeilen warten) anstelle von -s.

Hat man die gewünschten Ergebnisse durch obige Tests erhalten, kann dies dann hinterlegt werden, sodass der lfa4uls als Dämon beim Booten des Rechners gleich mit gestartet wird. Dazu wird eine Konfigurationsdatei im Ordner /etc/uls/lfa4uls.d angelegt:

vi /etc/uls/lfa4uls.d/my.conf
...
LFA4ULSCONF=/tmp/lfa4uls_my.conf

Keine Leerzeichen vor oder nach dem '='-Zeichen verwenden! Es sind keine Leerzeichen in der Pfadangabe erlaubt!

Und den lfa4uls neu starten::

/etc/init.d/lfa4uls restart [my]

In der Prozessstatusliste finden sich dann zwei Prozesse:

ps -ef | fgrep lfa
...
root ... 00:00:00 /usr/local/bin/lfa4uls -D -c /etc/uls/lfa4uls_messages.conf
root ... 00:00:00 /usr/local/bin/lfa4uls -D -c /tmp/lfa4uls_my.conf