TP-Link Omada per Syslog mit Fluent Bit und OpenObserve auswerten
Wer im Homelab ein Netzwerk mit TP-Link Omada betreibt, hat im Controller zwar eine Übersicht über Clients und Geräte. Für eine längere Historie, eigene Auswertungen oder Alarme reicht das aber schnell nicht mehr aus. Gerade Firewall-Blocks, WLAN-Anmeldungen oder Roaming-Vorgänge möchte man gerne zentral und durchsuchbar ablegen.
Omada kann dafür alle Meldungen per Syslog an einen zentralen Server senden. Dort nimmt Fluent Bit die Daten an, bereitet sie auf und schreibt sie nach OpenObserve. In OpenObserve werden die Meldungen per VRL-Funktion in Felder zerlegt und in einem Dashboard ausgewertet.
In diesem Beitrag zeige ich Schritt für Schritt:
- Welche Daten Omada per Syslog sendet und wo die Fallstricke liegen
- Einrichtung von Fluent Bit mit eigenem Parser und Lua-Filter
- Aufteilung in zwei Streams für Client-Verkehr und Ereignisse
- Zerlegung der Meldungen mit VRL-Funktionen in OpenObserve
- Anreicherung blockierter IP-Adressen mit GeoIP (Land, Stadt, Provider)
- Aufbau eines Dashboards mit Weltkarte

Ziel des Setups
Das Ziel ist eine zentrale, durchsuchbare Auswertung aller Omada-Meldungen mit folgenden Eigenschaften:
- Fluent Bit als zentraler Syslog-Empfänger
- Vollständige Zerlegung der gebündelten AP-Pakete
- Getrennte Streams für Client-Verkehr und Ereignisse
- Korrekte Zeitstempel, auch bei falsch eingestellter Uhrzeit auf den APs
- Firewall-Blocks mit Land, Stadt und Provider der Quell-IP
- WLAN-Anmeldungen, Trennungen und Roaming mit Client-, AP- und SSID-Namen
- Dashboard mit Weltkarte, Client-Verzeichnis und Firewall-Übersicht
Architektur
Fluent Bit läuft auf demselben Host wie OpenObserve. Die Konfiguration liegt im Standardverzeichnis:
/etc/fluent-bit
├── fluent-bit.conf
├── parsers.conf
└── omada_split.luaIn OpenObserve entstehen zwei Streams mit je einer Pipeline und einer Funktion:
network_tplink_omada_flows → pl_network_tplink_omada_flows → norm_network_tplink_omada_flows
network_tplink_omada → pl_network_tplink_omada → norm_network_tplink_omadaDie Namen folgen dem Schema <kategorie>_<hersteller>_<produkt>. Funktionen beginnen mit norm_, Pipelines mit pl_.
Die Trennung in zwei Streams hat einen einfachen Grund: Der Client-Verkehr der Access Points erzeugt rund 1 Million Einträge pro Tag, die Ereignisse nur einige hundert. Der Verkehr bekommt deshalb eine kurze Aufbewahrungszeit, die Ereignisse eine lange.
Voraussetzungen
Für dieses Setup werden folgende Komponenten vorausgesetzt:
- TP-Link Omada mit Controller (Software, OC200/OC300 oder Cloud), Gateway und Access Points
- Ein Linux-Server mit Fluent Bit (getestet mit Version 5.1)
- Eine laufende OpenObserve-Instanz
- Optional: MaxMind-Tabellen
maxmind_cityundmaxmind_asnin OpenObserve für GeoIP - UDP-Port
5514vom Omada-Netz zum Fluent-Bit-Host erreichbar
Beispiel-Adressen in diesem Beitrag:
openobserve.domain.tld # OpenObserve
192.168.1.10 # Fluent-Bit-HostTeil 1: Was Omada per Syslog sendet
Remote Logging in Omada aktivieren
Im Omada Controller wird in den Site-Einstellungen unter Services → Remote Logging der Syslog-Server eingetragen. Die genaue Bezeichnung kann je nach Controller-Version leicht abweichen.
- Syslog-Server:
192.168.1.10 - Port:
5514
Danach senden Gateway, Access Points und Controller ihre Meldungen an Fluent Bit.
Drei Absender, drei Formate
Auf einem einzigen Port kommen drei völlig unterschiedliche Formate an. Ein einzelner Standard-Parser reicht deshalb nicht aus.
Absender | Format | Inhalt |
|---|---|---|
Access Points | RFC 3164, rund 12 Einträge pro Paket, getrennt durch | Client-Verkehr: Client-MAC, Quell- und Ziel-IP, Protokoll, Ports |
Gateway | RFC 3164 mit zweitem Zeitstempel, Modul und Level | Firewall-ACL, DHCP |
Controller | RFC-5424-ähnlich, Leerzeichen in Zeit und Hostname | Client online/offline, Roaming, DHCP |
Access Points
Ein einzelner Eintrag sieht so aus:
[1792692377.958731137] AP MAC=aa:bb:cc:00:00:01 MAC SRC=aa:bb:cc:00:00:02 IP SRC=192.168.10.20 IP DST=192.168.10.5 IP proto=6 SPT=51234 DPT=443Die Zahl in eckigen Klammern ist ein Unix-Zeitstempel. Er ist wichtiger als die Uhrzeit im Syslog-Header, dazu später mehr.
Gateway
Firewall-Blocks kommen als Schlüssel-Wert-Liste:
<13>Oct 22 20:13:26 ER7406: 2026-10-22 20:13:26 firewall<5>: [ACL]GATEWAY=…,DESC=1009206213,ACTION=Block,SRC=203.0.113.10,DST=192.168.20.5,PROTO=TCP,Sport=34818,Dport=443Controller
Der Controller liefert die lesbarsten Meldungen, inklusive Client-, AP- und SSID-Namen:
<142>1 2026-10-22 20:22:00 Omada Controller - - - [client:sensor-01:AA-BB-CC-00-00-03] is roaming from [ap:AP Flur:…][Channel 11] to [ap:AP Garten:…][Channel 6] with SSID "Heimnetz"Die Fallstricke
Beim Aufbau sind mir einige Besonderheiten begegnet, die man kennen sollte:
- Mehrere Einträge pro Paket: Die APs bündeln etwa 12 Einträge in ein UDP-Paket. Ein Parser mit
.*endet beim ersten Zeilenumbruch, und von jedem Paket bleibt nur der erste Eintrag übrig. - IP-Fragmentierung: Die AP-Pakete sind rund 1.750 Byte groß und werden fragmentiert. Für Fluent Bit ist das kein Problem, für einen Mitschnitt mit tcpdump schon (siehe Fehlersuche).
- Falsche Uhrzeit: Bei mir schreiben vier von fünf APs eine Stunde zu früh in den Syslog-Header. Der Unix-Zeitstempel im Eintrag ist bei allen korrekt.
- Ungültiges RFC 5424: Der Controller schreibt Leerzeichen in Zeitstempel und Hostname. Standard-Parser scheitern daran.
- DHCP doppelt: Gateway und Controller melden dieselben DHCP-Vergaben.
Teil 2: Fluent Bit einrichten
Parser für ganze Pakete anlegen
Der Parser muss das komplette UDP-Paket übernehmen, auch über Zeilenumbrüche hinweg. Dazu wird er in der parsers.conf ergänzt:
nano /etc/fluent-bit/parsers.confInhalt:
[PARSER]
Name raw-datagram
Format regex
Regex (?<message>[\s\S]+)Erklärung
[\s\S]+passt auf jedes Zeichen, auch auf Zeilenumbrüche- Mit
.*würde der Parser beim ersten\r\naufhören und alle weiteren Einträge im Paket verwerfen - Der Syslog-Header bleibt erhalten und wird später in OpenObserve ausgewertet
Lua-Filter zum Zerlegen der AP-Pakete erstellen
Der Lua-Filter teilt jedes AP-Paket in einzelne Datensätze auf. Meldungen von Gateway und Controller reicht er unverändert durch.
nano /etc/fluent-bit/omada_split.luaInhalt:
-- omada_split.lua – Fluent-Bit-Filter für TP-Link Omada
-- Zerlegt die gebündelten Client-Traffic-Einträge der Access Points
-- in einen Datensatz pro Eintrag.
function split_omada(tag, ts, record)
local msg = record["message"]
if type(msg) ~= "string" or not string.find(msg, "AP MAC=", 1, true) then
return 0, ts, record
end
msg = string.gsub(msg, "%z", "")
local hdr_time = string.match(msg, "^<%d+>(%a%a%a +%d+ %d+:%d+:%d+) ")
-- vollständige Einträge enden mit \r\n
local segments, pos = {}, 1
while true do
local s, e = string.find(msg, "\r\n", pos, true)
if not s then break end
table.insert(segments, string.sub(msg, pos, s - 1))
pos = e + 1
end
local tail = string.sub(msg, pos)
local truncated = string.find(tail, "%S") ~= nil
if #segments == 0 then
table.insert(segments, tail)
truncated = false
end
local out = {}
for _, seg in ipairs(segments) do
local entry = string.match(seg, "(%[%d+%.%d+%] AP MAC=.*)$")
if entry then
local r = {}
for k, v in pairs(record) do r[k] = v end
r["message"] = entry
r["omada_type"] = "flow"
if hdr_time then r["syslog_time"] = hdr_time end
table.insert(out, r)
end
end
if #out == 0 then return 0, ts, record end
out[1]["batch_first"] = true
out[1]["batch_entries"] = #out
if truncated then out[#out]["batch_truncated"] = true end
return 2, ts, out
endRechte setzen:
chmod 644 /etc/fluent-bit/omada_split.luaErklärung
return 2, ts, outmit einer Liste erzeugt in Fluent Bit mehrere einzelne Datensätzeomada_type = flowmarkiert die Einträge für die spätere Aufteilungsyslog_timeübernimmt die Uhrzeit aus dem Header, damit die Abweichung je AP sichtbar wirdbatch_first,batch_entriesundbatch_truncatedsind Kontrollwerte für unvollständige Pakete
💡 Wichtig: Fehlt die Lua-Datei oder ist sie nicht lesbar, startet Fluent Bit gar nicht. Damit fallen auch alle anderen Quellen aus.
Input, Filter und Outputs konfigurieren
nano /etc/fluent-bit/fluent-bit.confInhalt:
# TP-Link Omada: Access Points, Gateway, Controller (Port 5514)
[INPUT]
Name syslog
Listen 0.0.0.0
Port 5514
Mode udp
Parser raw-datagram
Tag omada
Buffer_Chunk_Size 64KB
Buffer_Max_Size 64KB
Mem_Buf_Limit 10MB
Source_Address_Key source_address
# AP-Pakete in einzelne Einträge zerlegen
[FILTER]
Name lua
Match omada
script /etc/fluent-bit/omada_split.lua
call split_omada
# Client-Verkehr in einen eigenen Stream
[FILTER]
Name rewrite_tag
Match omada
Rule $omada_type ^flow$ omada.flows false
Emitter_Name re_emitted_omada_flows
Emitter_Mem_Buf_Limit 20MB
[OUTPUT]
Name http
Alias o2_omada_events
Match omada
URI /api/default/network_tplink_omada/_json
Host openobserve.domain.tld
Port 443
tls On
Format json
Json_date_key _timestamp
Json_date_format iso8601
HTTP_User <BENUTZER>
HTTP_Passwd ${O2_PASSWORD}
compress gzip
[OUTPUT]
Name http
Alias o2_omada_flows
Match omada.flows
URI /api/default/network_tplink_omada_flows/_json
Host openobserve.domain.tld
Port 443
tls On
Format json
Json_date_key _timestamp
Json_date_format iso8601
HTTP_User <BENUTZER>
HTTP_Passwd ${O2_PASSWORD}
compress gzipErklärung
Source_Address_Keyschreibt die Absender-IP in jeden Datensatz. So ist später sichtbar, welcher AP was gemeldet hat.- Die Reihenfolge der Filter ist wichtig: erst Lua, dann
rewrite_tag rewrite_tagvergibt dem Client-Verkehr den Tagomada.flows. Dasfalseam Ende verwirft das Original, damit kein Eintrag doppelt ankommt.Match omadagreift nur genau auf diesen Tag, nicht aufomada.flowsAliasgibt den Outputs lesbare Namen in den Metriken${O2_PASSWORD}liest das Passwort aus einer Umgebungsvariable, zum Beispiel aus/etc/default/fluent-bit
Das Passwort sollte niemals im Klartext in der Konfiguration stehen oder in Git landen.
Konfiguration prüfen und Fluent Bit starten
Vor jedem Neustart lohnt sich ein Trockenlauf:
/opt/fluent-bit/bin/fluent-bit -c /etc/fluent-bit/fluent-bit.conf --dry-runDanach neu starten:
systemctl restart fluent-bitLogs prüfen:
journalctl -u fluent-bit --since "-1min" --no-pager | grep -E 'error|lua|emitter'Im Log sollte der Emitter re_emitted_omada_flows initialisiert werden, ohne error-Zeilen.
Teil 3: OpenObserve einrichten
In OpenObserve werden die Rohmeldungen per VRL-Funktion in Felder zerlegt. Jede Funktion hängt in einer Pipeline, die den Stream als Quelle und als Ziel verwendet. Jede Funktion schreibt außerdem ein Feld norm_version. Daran lässt sich sofort erkennen, welche Fassung einen Datensatz verarbeitet hat.
Funktion für den Client-Verkehr
Die Funktion wird in OpenObserve unter Pipelines → Funktionen angelegt.
Name:
norm_network_tplink_omada_flowsInhalt:
# norm_network_tplink_omada_flows
# Ein Client-Traffic-Eintrag eines Access Points je Datensatz:
# [1792692377.958731137] AP MAC=<ap> MAC SRC=<client> IP SRC=<ip> IP DST=<ip>
# IP proto=<n> [SPT=<n> DPT=<n>]
# Ergebnis: event = client_flow; event fehlt → Zeile nicht erkannt
.norm_version = "2026-10-22c"
msg = to_string(.message) ?? ""
if exists(.source_address) {
sa, serr = parse_regex(.source_address, r'(?P<ip>[0-9a-fA-F:.]+):\d+$')
if serr == null { .ap_ip = sa.ip }
}
p, err = parse_regex(msg, r'^\[(?P<epoch>\d+)\.(?P<frac>\d+)\] AP MAC=(?P<ap>\S+) MAC SRC=(?P<cmac>\S+) IP SRC=(?P<src>\S+) IP DST=(?P<dst>\S+) IP proto=(?P<proto>\d+)(?: SPT=(?P<spt>\d+) DPT=(?P<dpt>\d+))?\s*$')
if err == null {
.event = "client_flow"
# Zeitstempel aus der Epoche des AP – die Uhrzeit im Syslog-Header
# ist bei manchen APs falsch
ep = to_int(p.epoch) ?? 0
us = to_int(slice(string!(p.frac) + "000000", 0, 6) ?? "0") ?? 0
._timestamp = ep * 1000000 + us
.ap_mac = downcase(string!(p.ap))
.client_mac = downcase(string!(p.cmac))
.src_ip = p.src
.dst_ip = p.dst
proto = to_int(p.proto) ?? -1
.ip_proto = proto
.proto_name = if proto == 6 { "tcp" } else if proto == 17 { "udp" } else if proto == 1 { "icmp" } else if proto == 2 { "igmp" } else if proto == 58 { "icmpv6" } else { to_string(proto) }
svc = null
if p.spt != null {
spt = to_int(p.spt) ?? 0
dpt = to_int(p.dpt) ?? 0
.src_port = spt
.dst_port = dpt
# Dienst-Port: der kleinere der beiden Ports
svc = if dpt <= spt { dpt } else { spt }
.service_port = svc
.is_server_reply = spt < dpt
}
names = {"20": "ftp-data", "21": "ftp", "22": "ssh", "23": "telnet", "25": "smtp", "53": "dns", "67": "dhcp", "68": "dhcp", "69": "tftp",
"80": "http", "110": "pop3", "123": "ntp", "137": "netbios", "138": "netbios", "139": "netbios", "143": "imap", "161": "snmp",
"389": "ldap", "443": "https", "445": "smb", "465": "smtps", "514": "syslog", "554": "rtsp", "587": "submission", "636": "ldaps",
"853": "dns-over-tls", "993": "imaps", "995": "pop3s", "1400": "sonos", "1883": "mqtt", "1900": "ssdp", "2323": "telnet-alt",
"3389": "rdp", "3478": "stun", "5060": "sip", "5353": "mdns", "5355": "llmnr", "5683": "coap", "6053": "esphome-api",
"8006": "proxmox", "8080": "http-alt", "8123": "home-assistant", "8443": "https-alt", "8883": "mqtts", "51820": "wireguard"}
if svc != null {
.service = get(names, [to_string(svc)]) ?? null
} else if proto != 6 && proto != 17 {
.service = .proto_name
}
# Zielbereich
d = string!(p.dst)
.dst_scope = if starts_with(d, "224.") || starts_with(d, "239.") || match(d, r'^2(2[4-9]|3\d)\.') || starts_with(d, "ff") {
"multicast"
} else if d == "255.255.255.255" || ends_with(d, ".255") {
"broadcast"
} else if is_ipv4(d) && (ip_cidr_contains!("10.0.0.0/8", d) || ip_cidr_contains!("172.16.0.0/12", d) || ip_cidr_contains!("192.168.0.0/16", d)) {
"lan"
} else if is_ipv4(d) && (ip_cidr_contains!("169.254.0.0/16", d) || ip_cidr_contains!("127.0.0.0/8", d)) {
"lokal"
} else if is_ipv6(d) && (ip_cidr_contains!("fc00::/7", d) || ip_cidr_contains!("fe80::/10", d)) {
"lan"
} else {
"extern"
}
# zufällige (private) MAC-Adresse: Bit "lokal verwaltet" gesetzt
first = parse_int(slice(.client_mac, 0, 2) ?? "00", base: 16) ?? 0
.client_mac_random = mod(first, 4) >= 2
# Uhrzeit im Syslog-Header gegen Epoche: Abweichung des AP in Stunden
if exists(.syslog_time) {
# RFC 3164 kennt kein Jahr → Jahr aus der AP-Epoche ergänzen
yr = format_timestamp!(from_unix_timestamp!(ep), format: "%Y")
ht, herr = parse_timestamp(string!(.syslog_time) + " " + yr, "%b %e %H:%M:%S %Y", timezone: "Europe/Berlin")
if herr == null {
.ap_clock_offset_h = round((to_unix_timestamp(ht) - ep) / 3600.0)
}
}
}
.Erklärung der Felder
_timestamp- Zeitpunkt aus dem Unix-Zeitstempel des AP, nicht aus dem Syslog-Headerap_ip,ap_mac- Access Point, der den Eintrag gemeldet hatclient_mac,src_ip,dst_ip- Client und Zielproto_name- tcp, udp, icmp oder igmpservice_port,service- Dienst aus dem kleineren der beiden Ports, da Antwortpakete eines Servers den Dienst-Port als Quellport tragendst_scope- lan, extern, multicast, broadcast oder lokalclient_mac_random- private, zufällige MAC-Adresse, wie sie Smartphones verwendenap_clock_offset_h- Abweichung der Header-Uhr in Stunden, Sollwert 0
Funktion für Ereignisse mit GeoIP
Die zweite Funktion erkennt Gateway und Controller am Format und ordnet jede Meldung einem Ereignistyp zu. Für Firewall-Blocks mit öffentlicher Quell-IP fragt sie zusätzlich die MaxMind-Tabellen ab.
Name:
norm_network_tplink_omadaInhalt:
# norm_network_tplink_omada
# Gateway (RFC 3164 mit eingebetteter Zeit) und Controller (RFC-5424-ähnlich)
# Ergebnis: event = firewall_block | firewall_allow | dhcp_lease | dhcp_reject |
# client_connect | client_disconnect | client_roam | auth_failure |
# login | omada_event; event fehlt → Kopf nicht erkannt
.norm_version = "2026-10-22c"
raw = to_string(.message) ?? ""
.raw_message = raw
if exists(.source_address) {
sa, serr = parse_regex(.source_address, r'(?P<ip>[0-9a-fA-F:.]+):\d+$')
if serr == null { .sender_ip = sa.ip }
}
sev_names = ["emergency", "alert", "critical", "error", "warning", "notice", "info", "debug"]
text = null
gw, gerr = parse_regex(raw, r'^<(?P<pri>\d+)>(?P<hts>\w{3} +\d+ [\d:]+) (?P<host>[^\s:]+): (?P<ts>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) (?P<module>[\w.-]+)<(?P<lvl>\d)>: (?P<msg>.*)$')
if gerr == null {
.source_type = "gateway"
.device_name = gw.host
.module = gw.module
lvl = to_int(gw.lvl) ?? 6
.log_level = get(sev_names, [lvl]) ?? null
ts, terr = parse_timestamp(string!(gw.ts), "%Y-%m-%d %H:%M:%S", timezone: "Europe/Berlin")
if terr == null { ._timestamp = to_unix_timestamp(ts, unit: "microseconds") }
.syslog_pri = to_int(gw.pri) ?? null
text = gw.msg
} else {
ct, cerr = parse_regex(raw, r'^<(?P<pri>\d+)>1 (?P<ts>\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2})\S* (?P<host>.+?)(?: -){3} ?(?P<msg>.*)$')
if cerr == null {
.source_type = "controller"
.device_name = ct.host
pri = to_int(ct.pri) ?? 6
.syslog_pri = pri
.log_level = get(sev_names, [mod(pri, 8)]) ?? null
ts, terr = parse_timestamp(replace(string!(ct.ts), "T", " "), "%Y-%m-%d %H:%M:%S", timezone: "Europe/Berlin")
if terr == null { ._timestamp = to_unix_timestamp(ts, unit: "microseconds") }
text = ct.msg
}
}
if text != null {
t = string!(text)
tg, tgerr = parse_regex(t, r'^\[(?P<tag>[A-Z]+)\](?P<rest>.*)$')
if tgerr == null {
.omada_tag = tg.tag
t = string!(tg.rest)
}
t = strip_whitespace(t)
.message = t
# Client: [client:<Name>:<MAC>] oder [client:<MAC>]
cl, clerr = parse_regex(t, r'\[client:(?:(?P<name>[^\]]*?):)?(?P<mac>[0-9A-Fa-f]{2}(?:[:-][0-9A-Fa-f]{2}){5})\]')
if clerr == null {
.client_mac = downcase(replace(string!(cl.mac), "-", ":"))
if cl.name != null && cl.name != "" && downcase(replace(string!(cl.name), "-", ":")) != .client_mac {
.client_name = cl.name
}
}
ipm, iperr = parse_regex(t, r'\(IP: (?P<ip>[0-9a-fA-F:.]+)\)')
if iperr == null { .client_ip = ipm.ip }
if .omada_tag == "ACL" {
# Firewall (ACL)
kv = parse_key_value(t, key_value_delimiter: "=", field_delimiter: ",") ?? {}
act = downcase(to_string(kv.ACTION) ?? "")
.event = if act == "block" || act == "deny" || act == "drop" { "firewall_block" } else { "firewall_allow" }
.fw_action = act
.fw_rule_id = kv.DESC
.gateway_mac = downcase(replace(to_string(kv.GATEWAY) ?? "", "-", ":"))
.src_mac = downcase(to_string(kv.SRC_MAC) ?? "")
.dst_mac = downcase(to_string(kv.DST_MAC) ?? "")
.src_ip = kv.SRC
.dst_ip = kv.DST
.ip_proto = downcase(to_string(kv.PROTO) ?? "")
.src_port = to_int(kv.Sport) ?? null
.dst_port = to_int(kv.Dport) ?? null
sip = to_string(kv.SRC) ?? ""
priv4 = ["10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16", "127.0.0.0/8", "169.254.0.0/16",
"100.64.0.0/10", "0.0.0.0/8", "224.0.0.0/4", "240.0.0.0/4"]
priv6 = ["fc00::/7", "fe80::/10", "::1/128", "ff00::/8", "::/128"]
pub = (is_ipv4(sip) && !(ip_cidr_contains(priv4, sip) ?? true)) || (is_ipv6(sip) && !(ip_cidr_contains(priv6, sip) ?? true))
.src_scope = if pub { "extern" } else { "lan" }
del(.client_ip)
# GeoIP/ASN der öffentlichen Quelle (MaxMind), fehlertolerant
if pub {
city, gerr = get_enrichment_table_record("maxmind_city", {"ip": sip})
if gerr == null {
.geo_latitude = city.latitude
.geo_longitude = city.longitude
country = city.country_name
if country == null { country = city.country }
if country == null { country = city.country_names.de }
if country == null { country = city.country_names.en }
if country != null && country != "" { .geo_country = country }
code = city.country_iso_code
if code == null { code = city.country_code }
if code == null { code = city.iso_code }
if code != null { .geo_country_code = upcase(to_string(code) ?? "") }
cty = city.city_name
if cty == null { cty = city.city }
if cty == null { cty = city.city_names.de }
if cty == null { cty = city.city_names.en }
if cty != null && cty != "" { .geo_city = cty }
# .geo_debug = encode_json(city)
}
asn, aerr = get_enrichment_table_record("maxmind_asn", {"ip": sip})
if aerr == null {
.geo_asn = to_int(asn.autonomous_system_number) ?? null
.geo_org = asn.autonomous_system_organization
}
}
} else if contains(t, "DHCP Server allocated") {
.event = "dhcp_lease"
dl, dlerr = parse_regex(t, r'allocated IP address (?P<ip>[0-9a-fA-F:.]+)')
if dlerr == null { .client_ip = dl.ip }
} else if contains(t, "DHCP Server rejected") {
.event = "dhcp_reject"
} else if contains(t, "is roaming from") {
.event = "client_roam"
.connection_type = "wireless"
rm, rerr = parse_regex(t, r'is roaming from \[ap:(?P<n1>.*?):(?P<m1>[0-9A-Fa-f]{2}(?:[:-][0-9A-Fa-f]{2}){5})\]\[Channel (?P<c1>\d+)\] to \[ap:(?P<n2>.*?):(?P<m2>[0-9A-Fa-f]{2}(?:[:-][0-9A-Fa-f]{2}){5})\]\[Channel (?P<c2>\d+)\](?: with SSID "(?P<ssid>[^"]*)")?')
if rerr == null {
.ap_name_from = rm.n1
.ap_mac_from = downcase(replace(string!(rm.m1), "-", ":"))
.channel_from = to_int(rm.c1) ?? null
.ap_name = rm.n2
.ap_mac = downcase(replace(string!(rm.m2), "-", ":"))
.channel = to_int(rm.c2) ?? null
.ssid = rm.ssid
}
} else if contains(t, "went online") {
.event = "client_connect"
w, werr = parse_regex(t, r'went online on \[ap:(?P<n>.*?):(?P<m>[0-9A-Fa-f]{2}(?:[:-][0-9A-Fa-f]{2}){5})\](?: with SSID "(?P<ssid>[^"]*)")?(?: on channel (?P<ch>\d+))?')
if werr == null {
.connection_type = "wireless"
.ap_name = w.n
.ap_mac = downcase(replace(string!(w.m), "-", ":"))
.ssid = w.ssid
if w.ch != null { .channel = to_int(w.ch) ?? null }
} else {
sw, swerr = parse_regex(t, r'went online on \[switch:(?P<n>.*?):(?P<m>[0-9A-Fa-f]{2}(?:[:-][0-9A-Fa-f]{2}){5})\](?: on (?P<net>.+?) network)?')
if swerr == null {
.connection_type = "wired"
.switch_name = sw.n
.switch_mac = downcase(replace(string!(sw.m), "-", ":"))
.network = sw.net
}
}
} else if contains(t, "went offline") {
.event = "client_disconnect"
of, oferr = parse_regex(t, r'went offline from (?:network )?"(?P<net>[^"]*)" on \[(?P<dt>ap|switch):(?P<n>.*?):(?P<m>[0-9A-Fa-f]{2}(?:[:-][0-9A-Fa-f]{2}){5})\]')
if oferr == null {
if of.dt == "ap" {
.connection_type = "wireless"
.ssid = of.net
.ap_name = of.n
.ap_mac = downcase(replace(string!(of.m), "-", ":"))
} else {
.connection_type = "wired"
.network = of.net
.switch_name = of.n
.switch_mac = downcase(replace(string!(of.m), "-", ":"))
}
}
# Verbindungsdauer "2d3h49m" → Minuten, Datenmenge "12.5MBytes" → Bytes
cm, cmerr = parse_regex(t, r'connected time:\s*(?:(?P<d>\d+)d)?\s*(?:(?P<h>\d+)h)?\s*(?:(?P<m>\d+)m)?\s*(?:(?P<s>\d+)s)?')
if cmerr == null {
mins = (to_int(cm.d) ?? 0) * 1440 + (to_int(cm.h) ?? 0) * 60 + (to_int(cm.m) ?? 0)
.connected_minutes = mins
}
tb, tberr = parse_regex(t, r'traffic:\s*(?P<v>[\d.]+)\s*(?P<u>[KMGT]?)B')
if tberr == null {
f = to_float(tb.v) ?? 0.0
u = string!(tb.u)
mult = if u == "K" { 1024.0 } else if u == "M" { 1048576.0 } else if u == "G" { 1073741824.0 } else if u == "T" { 1099511627776.0 } else { 1.0 }
.traffic_bytes = to_int(f * mult)
}
} else {
tl = downcase(t)
.event = if match(tl, r'fail|denied|invalid|wrong password|incorrect|reject') {
"auth_failure"
} else if match(tl, r'log(ged)? ?in|log(ged)? ?out') {
"login"
} else {
"omada_event"
}
}
}
.Erklärung der Ereignisse
firewall_block- vom Gateway per ACL verworfene Verbindung, mitsrc_ip,dst_ip,dst_port,fw_rule_idund Geo-Felderndhcp_lease,dhcp_reject- DHCP-Vergabe bzw. Ablehnung mitclient_macundclient_ipclient_connect,client_disconnect- Client online/offline mitclient_name,ap_nameoderswitch_name,ssidodernetworkclient_roam- Wechsel zwischen APs mitap_name_from,ap_name,channel_fromundchannelomada_event- nicht zugeordnete Meldung, Kandidat für ein neues Muster
💡
Wichtig: get_enrichment_table_record wird bewusst ohne ! aufgerufen. Mit ! bricht die Funktion bei jeder IP ohne MaxMind-Treffer ab, und die Pipeline schreibt für jeden Datensatz einen Fehler.
Pipelines anlegen
Für jeden Stream wird unter Pipelines eine Echtzeit-Pipeline angelegt:
pl_network_tplink_omada_flows- Quelle und Zielnetwork_tplink_omada_flows, dazwischennorm_network_tplink_omada_flows

pl_network_tplink_omada- Quelle und Zielnetwork_tplink_omada, dazwischennorm_network_tplink_omada

Nach jeder Änderung an einer Funktion sollte die zugehörige Pipeline einmal geöffnet und gespeichert werden. So verwendet sie sicher die neue Fassung.

Schema-Seeds einspielen
Felder wie channel_from oder geo_asn tauchen nur selten auf. Bis sie das erste Mal vorkommen, kennt OpenObserve sie nicht, und Dashboard-Panels melden „No field named …“. Ein Seed ist ein einzelner Datensatz mit allen Feldern im richtigen Typ.
nano seed_network_tplink_omada.jsonInhalt:
[{"event": "schema_seed", "norm_version": "", "message": "", "raw_message": "", "source_address": "", "sender_ip": "", "source_type": "", "device_name": "", "module": "", "log_level": "", "syslog_pri": 0, "omada_tag": "", "client_mac": "", "client_ip": "", "client_name": "", "connection_type": "", "ap_name": "", "ap_mac": "", "ap_name_from": "", "ap_mac_from": "", "channel": 0, "channel_from": 0, "ssid": "", "switch_name": "", "switch_mac": "", "network": "", "connected_minutes": 0, "traffic_bytes": 0, "fw_action": "", "fw_rule_id": "", "gateway_mac": "", "src_mac": "", "dst_mac": "", "src_ip": "", "dst_ip": "", "ip_proto": "", "src_port": 0, "dst_port": 0, "src_scope": "", "geo_country": "", "geo_country_code": "", "geo_city": "", "geo_latitude": 0.0, "geo_longitude": 0.0, "geo_asn": 0, "geo_org": ""}]nano seed_network_tplink_omada_flows.jsonInhalt:
[{"event": "schema_seed", "norm_version": "", "message": "", "source_address": "", "ap_ip": "", "ap_mac": "", "client_mac": "", "client_mac_random": false, "src_ip": "", "dst_ip": "", "ip_proto": 0, "proto_name": "", "src_port": 0, "dst_port": 0, "service_port": 0, "service": "", "is_server_reply": false, "dst_scope": "", "ap_clock_offset_h": 0.0, "syslog_time": "", "omada_type": "", "batch_first": false, "batch_entries": 0, "batch_truncated": false}]Eingespielt werden beide Seeds über die Ingest-API:
read -rsp 'OpenObserve-Passwort: ' O2_PASSWORD; echo
for s in network_tplink_omada network_tplink_omada_flows; do
curl -s -u "<BENUTZER>:${O2_PASSWORD}" \
-H 'Content-Type: application/json' \
--data-binary @"seed_${s}.json" \
"https://openobserve.domain.tld/api/default/${s}/_json"
echo
done
unset O2_PASSWORDDie Antwort muss "successful":1 enthalten. Da der Seed event = 'schema_seed' trägt, filtern ihn alle Dashboard-Abfragen heraus.
Aufbewahrungszeit setzen
Unter Streams wird für network_tplink_omada_flows eine kurze Aufbewahrungszeit eingestellt, zum Beispiel 31 Tage. Bei rund 1 Million Einträgen pro Tag hält das den Speicherbedarf überschaubar. Der Stream network_tplink_omada kann deutlich länger aufbewahrt werden.

Teil 4: Dashboard aufbauen


Das Dashboard liest beide Streams. Bei mir besteht es aus 42 Panels in sechs Tabs:
| Tab | Inhalt |
|---|---|
| Überblick | Kennzahlen (Einträge, Clients, APs, externe Ziele, Firewall-Blocks), Verkehr je AP, Ereignisse nach Typ, AP-Tabelle mit Uhr-Abweichung |
| Clients | Top-Clients, Clients je AP, Anteil zufälliger MACs, Clients an mehreren APs |
| Ziele & Dienste | häufigste Dienste, externe Ziele, Server im LAN, unsichere Dienste, DNS am lokalen Server vorbei |
| Verbindungen | Online/Offline/Roaming über Zeit, Client-Verzeichnis, Roaming-Historie mit Kanälen, häufig getrennte Clients |
| Firewall | Weltkarte, Blocks nach Land und Provider, Top blockierte Quellen, blockierte Ziele mit Regel-ID |
| Ereignisse | letzte Meldungen, DHCP-Zuordnungen, Anmeldefehler, nicht zerlegte Meldungen |
Die Panels verwenden eigene SQL-Abfragen (Custom SQL). Drei Beispiele zeigen das Prinzip.
Weltkarte der Firewall-Blocks

Paneltyp: Geo Map
SELECT geo_latitude AS latitude, geo_longitude AS longitude, COUNT(*) AS weight
FROM "network_tplink_omada"
WHERE event = 'firewall_block' AND geo_latitude IS NOT NULL
GROUP BY latitude, longitudeIm Panel werden latitude, longitude und weight den gleichnamigen Feldern der Karte zugeordnet. Die Punktgröße zeigt dann die Anzahl der Blocks.
Top blockierte Quellen

Paneltyp: Table
SELECT src_ip, MAX(geo_country) AS land, MAX(geo_city) AS stadt, MAX(geo_org) AS provider,
COUNT(*) AS blocks, COUNT(DISTINCT src_port) AS verbindungen,
to_timestamp_micros(MAX(_timestamp)) AS zuletzt
FROM "network_tplink_omada"
WHERE event = 'firewall_block'
GROUP BY src_ip
ORDER BY blocks DESC
LIMIT 50Mehrere Blocks mit demselben Quellport sind TCP-Wiederholungen derselben Verbindung. Deshalb zählt verbindungen die verschiedenen Quellports.
Client-Verzeichnis

Paneltyp: Table
SELECT client_mac, MAX(client_name) AS name, MAX(client_ip) AS ip,
MAX(COALESCE(ap_name, switch_name)) AS anschluss,
MAX(COALESCE(ssid, network)) AS netz,
to_timestamp_micros(MAX(_timestamp)) AS zuletzt
FROM "network_tplink_omada"
WHERE client_mac IS NOT NULL
AND event IN ('client_connect', 'client_disconnect', 'client_roam', 'dhcp_lease')
GROUP BY client_mac
ORDER BY zuletzt DESCDas Verzeichnis verbindet die Namen aus den Controller-Meldungen mit den IP-Adressen aus DHCP. So entsteht eine Liste aller Geräte mit Name, IP und letztem Anschlusspunkt.
💡 Wichtig: DHCP-Vergaben melden Gateway und Controller doppelt. In DHCP-Auswertungen sollte deshalb zusätzlich source_type = 'gateway' gefiltert werden.
Fehlersuche
Fluent Bit startet nicht
Im Log steht:
[filter:lua:lua.2] cannot access script '/etc/fluent-bit/omada_split.lua'
[engine] filter initialization failedTypische Ursachen:
- Lua-Datei fehlt oder liegt im falschen Verzeichnis
- Fluent Bit läuft nicht als root und darf die Datei nicht lesen
Prüfen:
ls -l /etc/fluent-bit/omada_split.lua
systemctl show fluent-bit -p UserPro AP-Paket kommt nur ein Eintrag an
Wahrscheinliche Ursache: Der Parser verwendet .* statt [\s\S]+ und endet beim ersten Zeilenumbruch.
Prüfen lässt sich das direkt in OpenObserve:
SELECT ap_ip, AVG(batch_entries) AS eintraege_je_paket, COUNT(*) AS pakete
FROM "network_tplink_omada_flows"
WHERE batch_first = true
GROUP BY ap_ipErwartet werden etwa 10 bis 12 Einträge pro Paket.
Pakete erscheinen im Mitschnitt abgeschnitten
Wer die AP-Pakete mit tcpdump prüft, sieht mit diesem Filter nur 1472 Byte pro Paket und einen abgeschnittenen letzten Eintrag:
tcpdump -i any -nn -s 0 -w /tmp/omada.pcap udp port 5514Das ist kein Datenverlust. Die Pakete werden IP-fragmentiert, und nur das erste Fragment trägt einen UDP-Header. Der Filter udp port 5514 verwirft deshalb alle Folgefragmente. Der Kernel setzt die Fragmente korrekt zusammen, und Fluent Bit erhält vollständige Pakete.
Besser ist ein Filter auf die IP-Adresse des Access Points:
tcpdump -i any -nn -s 0 -w /tmp/omada.pcap host <AP-IP>Uhrzeit der APs weicht ab
Im Dashboard zeigt die Spalte ap_clock_offset_h eine Abweichung von einer Stunde. Die Daten selbst sind korrekt, weil der Zeitstempel aus dem Eintrag stammt. Die Ursache ist eine falsche Zeitzonen- oder Sommerzeit-Einstellung am AP.
Dashboard meldet „No field named …“
Der Schema-Seed wurde noch nicht eingespielt. Das betrifft vor allem Felder, die selten vorkommen, etwa channel_from, geo_asn oder batch_truncated.
Geo-Felder bleiben leer
Typische Ursachen:
- Die Tabellen
maxmind_cityundmaxmind_asnfehlen in OpenObserve - Die Pipeline verwendet noch eine alte Fassung der Funktion
- Die Länderfelder heißen in der eigenen MaxMind-Tabelle anders
Im letzten Fall wird in der Funktion die Zeile # .geo_debug = encode_json(city) einkommentiert. Das Feld geo_debug zeigt dann die tatsächlichen Schlüssel.
Meldungen landen als omada_event
Der Controller hat eine Meldung geschickt, für die es noch kein Muster gibt. Die Tabelle „Unbekannte Meldungen“ im Dashboard zeigt diese Fälle. Daraus lässt sich ein neuer Zweig in der Funktion ableiten.
Schnelle Admin-Shortlist (Daily Use)
Für den Betrieb sehr nützlich:
# Konfiguration prüfen, ohne Fluent Bit neu zu starten
/opt/fluent-bit/bin/fluent-bit -c /etc/fluent-bit/fluent-bit.conf --dry-run
# Fehler und Warnungen der letzten Minuten
journalctl -u fluent-bit --since "-10min" --no-pager | grep -iE 'error|warn'
# Kommen Omada-Pakete überhaupt an? (je Absender-IP)
timeout 60 tcpdump -i any -nn host <AP-IP> or host <GATEWAY-IP> | awk '{print $3}' | sort | uniq -cPrüfen, ob die Pipeline die aktuelle Funktion verwendet:
SELECT norm_version, COUNT(*) AS anzahl
FROM "network_tplink_omada"
GROUP BY norm_versionFazit
Mit Fluent Bit, einem kleinen Lua-Filter und zwei VRL-Funktionen lässt sich das Syslog von TP-Link Omada vollständig in OpenObserve auswerten. Fluent Bit übernimmt den Empfang, zerlegt die gebündelten AP-Pakete und trennt Client-Verkehr von Ereignissen. OpenObserve zerlegt die Meldungen in Felder, reichert Firewall-Blocks mit GeoIP an und stellt alles in einem Dashboard dar.
Die wichtigste Erkenntnis aus dem Aufbau: Jede Annahme über das Format sollte gegen echte Daten geprüft werden. Bei mir waren die gebündelten AP-Pakete, die falsche AP-Uhrzeit und das ungültige RFC 5424 des Controllers erst im Mitschnitt sichtbar. Mehrere Muster für die Controller-Meldungen haben sich erst an einem 15-minütigen Mitschnitt mit echtem Verkehr ergeben.
Schon nach wenigen Minuten zeigt das Dashboard Dinge, die im Controller untergehen: Geräte, die DNS am lokalen Server vorbei auflösen, unverschlüsselte Verbindungen ins Internet oder Scanner, die an der Firewall abprallen. Damit entsteht eine solide Grundlage für Alarme und eine langfristige Auswertung des eigenen Netzes.