Logs in realtime volgen en streamingwaarschuwingen
Volg en filter live logstreams om waarschuwingen te activeren zodra foutpatronen verschijnen.
Logs in realtime volgen en streamingwaarschuwingen is een gratis De Linux-opdrachtregel en Bash-scripting beheersen-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject De Linux-opdrachtregel en Bash-scripting beheersen. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus De Linux-opdrachtregel en Bash-scripting beheersen bevat in totaal 4 lessen.
Waarom realtime logboeken volgen belangrijk is
In productiesystemen groeien logboekbestanden voortdurend. Als je wacht met het bekijken van logboeken totdat er een probleem wordt gemeld, heeft de uitvaltijd je al schade berokkend. Met realtime logboeken volgen kun je gebeurtenissen bekijken op het moment dat ze worden weggeschreven, zodat je direct kunt reageren op storingen, beveiligingsgebeurtenissen en verslechterde prestaties.
- Webservers schrijven één regel per aanvraag — fouten verschijnen onmiddellijk
- Applicatiedaemons loggen stacktraces zodra er een uitzondering optreedt
- Authenticatiesystemen registreren mislukte aanmeldpogingen in realtime
Het fundamentele Unix-hulpmiddel hiervoor is tail -f, gecombineerd met filter- en waarschuwingshulpmiddelen om onbewerkte logboekstromen om te zetten in bruikbare signalen.
tail -f: een live logboek volgen
tail -f (volgen) houdt het bestand geopend en drukt nieuwe regels af zodra ze eraan worden toegevoegd. Dit is het eenvoudigste en meest algemeen beschikbare hulpmiddel voor realtime logboeken.
Veelgebruikte patronen:
tail -f /var/log/syslog— het systeemlogboek volgentail -n 50 -f app.log— de laatste 50 regels weergeven en daarna volgentail -f /var/log/nginx/access.log— nginx-aanvragen live volgen
Druk op Ctrl+C om te stoppen. Het proces blijft actief totdat je het annuleert of de terminal wordt gesloten.
#!/usr/bin/env bash
# Simulate a live log and follow it
LOGFILE='/tmp/demo_app.log'
# Write a header
echo '[INFO] Application started' >> "$LOGFILE"
# In a real scenario you would run:
# tail -f "$LOGFILE"
# Below we demonstrate tail showing the last 3 lines then exit
tail -n 3 "$LOGFILE"tail -F: logboekrotatie overleven
Veel systemen roteren logboekbestanden om middernacht of wanneer ze een bepaalde grootte bereiken. Wanneer dat gebeurt, krijgt het oorspronkelijke bestand een nieuwe naam (bijvoorbeeld app.log.1) en wordt een nieuw app.log aangemaakt. Met tail -f blijf je stilletjes het oude, hernoemde bestand lezen en mis je alle nieuwe uitvoer.
tail -F (hoofdletter F) lost dit op door de bestandsnaam te bewaken in plaats van de bestandsdescriptor. Wanneer het bestand verdwijnt en opnieuw verschijnt, opent tail -F het automatisch opnieuw en gaat het verder met volgen.
- Gebruik in productiescripts altijd liever
tail -Fdantail -f - Werkt met logrotate, newsyslog en Docker-logstuurprogramma's die bestanden roteren
# Follow nginx access log, surviving log rotation
tail -F /var/log/nginx/access.log
# Follow multiple files simultaneously
tail -F /var/log/nginx/access.log /var/log/nginx/error.logDe stroom filteren met grep
Een druk logboek onbewerkt volgen is overweldigend — een actieve webserver kan honderden regels per seconde schrijven. Leid de uitvoer van tail -F door naar grep om alleen de patronen te isoleren die je nodig hebt.
Belangrijke opties voor grep op een stroom:
--line-buffered— elke overeenkomende regel onmiddellijk doorgeven in plaats van te bufferen; vereist in pijplijnen, anders wordt de uitvoer vertraagd of gaat deze verloren-i— hoofdletterongevoelig zoeken-E— uitgebreide reguliere expressies voor alternatieven (error|warn|crit)-v— zoekresultaat omkeren (regels uitsluiten)
# Show only ERROR and WARN lines from a live application log
tail -F /var/log/myapp/app.log | grep --line-buffered -Ei 'error|warn|critical'
# Follow nginx and exclude health-check requests
tail -F /var/log/nginx/access.log | grep --line-buffered -v '/health'Tijdstempels en context toevoegen met awk
Logboekregels bevatten soms niet de context die helpt bij het eerste onderzoek. Je kunt de stroom realtime verrijken met awk — door een lokale tijdstempel toe te voegen, velden te extraheren of de uitvoer leesbaarder te formatteren.
awk werkt ook in streamingmodus (met buffering per regel) wanneer de invoer via een pijplijn wordt aangeleverd. Daardoor kun je het zonder extra opties veilig in live pijplijnen gebruiken.
# Prepend a reception timestamp to every ERROR line
tail -F /var/log/myapp/app.log | \
grep --line-buffered -i 'error' | \
awk '{ print strftime("[%Y-%m-%d %H:%M:%S]"), $0; fflush() }'
# Extract HTTP status code (field 9) and URL (field 7) from nginx combined log
tail -F /var/log/nginx/access.log | \
awk '{ print $9, $7; fflush() }' | \
grep --line-buffered '^5'Waarschuwingen versturen met Slack-webhooks
Filteren is maar de helft van het werk — zodra je een foutpatroon detecteert, moet je iemand waarschuwen. Met een inkomende Slack-webhook kun je met één curl-aanroep een bericht naar een kanaal sturen, zonder Slack-SDK en zonder andere inloggegevens dan de webhook-URL.
Het patroon is: filter de stroom en verstuur voor elke overeenkomende regel een HTTP POST.
#!/usr/bin/env bash
# Real-time alert: send every ERROR line to a Slack channel
LOGFILE='/var/log/myapp/app.log'
WEBHOOK_URL='https://hooks.slack.com/services/T000/B000/XXXX'
tail -F "$LOGFILE" | grep --line-buffered -i 'error' | while IFS= read -r line; do
payload=$(printf '{"text":"*[ERROR ALERT]*\n%s"}' "$line")
curl -s -o /dev/null -X POST -H 'Content-Type: application/json' \
-d "$payload" "$WEBHOOK_URL"
doneWaarschuwingen begrenzen om ruis te voorkomen
Een lawine aan logboekmeldingen kan duizenden foutregels per minuut genereren. Als je per regel één Slack-bericht verstuurt, overspoel je het kanaal en raken mensen waarschuwingenmoe. Je hebt snelheidsbegrenzing nodig — activeer de waarschuwing en onderdruk daarna verdere meldingen gedurende een afkoelperiode.
Dit bereik je met een eenvoudig tijdstempelbestand: registreer wanneer de laatste waarschuwing is verstuurd en sla het versturen over als de afkoelperiode nog niet is verstreken.
#!/usr/bin/env bash
# Alert on ERROR lines but no more than once every 60 seconds
LOGFILE='/var/log/myapp/app.log'
WEBHOOK_URL='https://hooks.slack.com/services/T000/B000/XXXX'
COOLDOWN=60
LAST_ALERT_FILE='/tmp/last_alert_ts'
tail -F "$LOGFILE" | grep --line-buffered -i 'error' | while IFS= read -r line; do
now=$(date +%s)
last=0
[ -f "$LAST_ALERT_FILE" ] && last=$(cat "$LAST_ALERT_FILE")
if (( now - last >= COOLDOWN )); then
echo "$now" > "$LAST_ALERT_FILE"
payload=$(printf '{"text":"*[ERROR ALERT]*\n%s"}' "$line")
curl -s -o /dev/null -X POST -H 'Content-Type: application/json' \
-d "$payload" "$WEBHOOK_URL"
echo "[$(date)] Alert sent: $line"
else
echo "[$(date)] Suppressed (cooldown): $line"
fi
doneFoutpieken tellen met een verschuivend venster
Soms is één foutregel niet betekenisvol — maar 20 fouten in 30 seconden vormen wel een ernstig probleem. Met een teller voor een verschuivend venster kun je alleen waarschuwingen activeren wanneer een drempelwaarde voor de foutfrequentie wordt overschreden, waardoor je minder valse positieven krijgt.
Bij deze techniek sla je de epoch-tijdstempel van elke overeenkomende gebeurtenis op in een tijdelijk bestand. Vervolgens tel je hoeveel gebeurtenissen binnen het venster vallen voordat je beslist of je een waarschuwing verstuurt.
#!/usr/bin/env bash
# Alert when more than 10 errors occur within any 60-second window
LOGFILE='/var/log/myapp/app.log'
WINDOW=60
THRESHOLD=10
TS_FILE='/tmp/error_timestamps'
WEBHOOK_URL='https://hooks.slack.com/services/T000/B000/XXXX'
tail -F "$LOGFILE" | grep --line-buffered -i 'error' | while IFS= read -r line; do
now=$(date +%s)
echo "$now" >> "$TS_FILE"
# Keep only timestamps within the window
cutoff=$(( now - WINDOW ))
tmp=$(mktemp)
awk -v c="$cutoff" '$1 > c' "$TS_FILE" > "$tmp" && mv "$tmp" "$TS_FILE"
count=$(wc -l < "$TS_FILE")
if (( count > THRESHOLD )); then
msg="*[BURST ALERT]* ${count} errors in ${WINDOW}s — last: ${line}"
curl -s -o /dev/null -X POST -H 'Content-Type: application/json' \
-d "{\"text\":\"$msg\"}" "$WEBHOOK_URL"
# Clear to avoid re-alerting until next burst
> "$TS_FILE"
fi
donejournalctl -f: systemd-journals volgen
Op moderne Linux-systemen (RHEL, Ubuntu 20.04+, Debian 10+) schrijven services naar het systemd-journal in plaats van naar gewone tekstbestanden. journalctl -f is voor het journal het equivalent van tail -F.
Handige opties:
-u myapp.service— alleen een specifieke eenheid volgen-p err— filteren op prioriteit (emerg, alert, crit, err, warning, notice, info, debug)--since '5 min ago'— beginnen vanaf een relatieve tijd-o json— gestructureerde JSON-uitvoer genereren voor verwerking door machines
# Follow only error-and-above entries for nginx
journalctl -f -u nginx.service -p err
# Stream journal as JSON and extract MESSAGE field with jq
journalctl -f -u myapp.service -o json | \
jq --unbuffered -r 'select(.PRIORITY <= "3") | .MESSAGE'multitail en kleurgecodeerde bewaking van meerdere bronnen
Wanneer je meerdere logboekbronnen tegelijk moet volgen, splitst multitail de terminal op in deelvensters — elk deelvenster volgt een ander bestand of commando — met optionele kleurcodering op basis van patronen.
Als multitail niet is geïnstalleerd, is een lichtgewicht alternatief zonder afhankelijkheden in Bash om elke stroom van de naam van de bron te voorzien en ze samen te voegen tot één overzicht.
# multitail: watch nginx access + error + app log in split panes
# (requires: apt install multitail or brew install multitail)
multitail /var/log/nginx/access.log /var/log/nginx/error.log /var/log/myapp/app.log
# Pure-Bash alternative — merge three streams with labeled prefixes
(
tail -F /var/log/nginx/access.log | sed --unbuffered 's/^/[nginx-access] /' &
tail -F /var/log/nginx/error.log | sed --unbuffered 's/^/[nginx-error] /' &
tail -F /var/log/myapp/app.log | sed --unbuffered 's/^/[myapp] /' &
wait
)Een zelfstandige waarschuwingsdaemon bouwen
Als je alles uit deze les samenbrengt, moet een waarschuwingsdaemon voor productiegebruik het volgende doen:
- Het logboekbestand robuust volgen met
tail -F - Op kritieke patronen filteren met gebufferde
grep - Meldingen begrenzen om waarschuwingenmoeheid te voorkomen
- De eigen activiteit loggen, zodat je kunt controleren wat er is verstuurd
- Draaien als achtergrondproces dat door systemd of een supervisor wordt beheerd
Het onderstaande script is een minimale maar complete daemon die je in /usr/local/bin/ kunt plaatsen en met systemd kunt beheren.
#!/usr/bin/env bash
# log_alert_daemon.sh — tail a log and fire Slack alerts with cooldown
set -euo pipefail
LOGFILE=${1:-'/var/log/myapp/app.log'}
PATTERN=${2:-'error|critical|fatal'}
WEBHOOK_URL=${SLACK_WEBHOOK_URL:?'Set SLACK_WEBHOOK_URL env var'}
COOLDOWN=${ALERT_COOLDOWN:-120}
DAEMON_LOG='/var/log/log_alert_daemon.log'
LAST_SENT_FILE='/tmp/log_alert_last_sent'
log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$DAEMON_LOG"; }
log "Starting alert daemon: watching $LOGFILE for pattern: $PATTERN"
tail -F "$LOGFILE" | grep --line-buffered -Ei "$PATTERN" | while IFS= read -r line; do
now=$(date +%s)
last=0
[ -f "$LAST_SENT_FILE" ] && last=$(cat "$LAST_SENT_FILE")
if (( now - last >= COOLDOWN )); then
echo "$now" > "$LAST_SENT_FILE"
msg=$(printf '{"text":"*[ALERT]* %s\n%s"}' "$(hostname)" "$line")
if curl -s -o /dev/null -w '%{http_code}' -X POST \
-H 'Content-Type: application/json' -d "$msg" "$WEBHOOK_URL" | grep -q '^200$'; then
log "Alert sent: $line"
else
log "Alert FAILED to send: $line"
fi
else
log "Suppressed (cooldown ${COOLDOWN}s): $line"
fi
doneKenniscontrole: streamingpijplijnen voor logboeken
Test je begrip van realtime logboeken volgen en waarschuwingen via een stroom.
Een Bash-pijplijn volgt een logboekbestand en verstuurt voor elke overeenkomende regel een Slack-waarschuwing. Tijdens een lawine aan logboekmeldingen worden in 10 seconden 3.000 foutregels geschreven. Welke enkele wijziging voorkomt het best dat het script het Slack-kanaal overspoelt met 3.000 berichten?
Samenvatting van de les: realtime logboeken volgen en waarschuwingen via een stroom
In deze les heb je vanaf de basis een complete pijplijn voor realtime observatie van logboeken opgebouwd:
- tail -F volgt een logboekbestand op naam en overleeft logboekrotatie — gebruik het in productie altijd liever dan
tail -f - grep --line-buffered filtert de live stroom zonder latentie te introduceren; voeg deze optie altijd toe aan grep-opdrachten in een pijplijn
- awk met fflush() verrijkt elke regel op een streamingveilige manier met tijdstempels of geëxtraheerde velden
- Slack-webhooks via curl leveren waarschuwingen met één HTTP POST — er is geen SDK nodig
- Afkoelbestanden voorkomen waarschuwingenmoeheid tijdens lawines aan logboekmeldingen door een minimuminterval tussen meldingen af te dwingen
- Tellers met een verschuivend venster detecteren foutpieken (waarschuwingen op basis van de frequentie) in plaats van op elke afzonderlijke regel te reageren
- journalctl -f is het systeemeigen equivalent van tail -F voor systemd, met ingebouwde prioriteitsfiltering en JSON-uitvoer
- Een zelfstandige waarschuwingsdaemon combineert al deze patronen en kan voor betrouwbaarheid in productie door systemd worden beheerd
Deze basisbouwstenen vormen samen de basis van elke aangepaste pijplijn voor observatie — er is geen externe agent nodig.
Leer Bash met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 22
- Lessen
- 88
Veelgestelde vragen
Is de les “Logs in realtime volgen en streamingwaarschuwingen” gratis?
Ja — de volledige tekst van “Logs in realtime volgen en streamingwaarschuwingen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus De Linux-opdrachtregel en Bash-scripting beheersen wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus De Linux-opdrachtregel en Bash-scripting beheersen bevat in totaal 4 lessen.
Wat leer ik in “Logs in realtime volgen en streamingwaarschuwingen”?
Volg en filter live logstreams om waarschuwingen te activeren zodra foutpatronen verschijnen. Je oefent met De Linux-opdrachtregel en Bash-scripting beheersen door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met De Linux-opdrachtregel en Bash-scripting beheersen te beginnen?
Ervaring vooraf is niet nodig. De Linux-opdrachtregel en Bash-scripting beheersen op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Logs in realtime volgen en streamingwaarschuwingen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over De Linux-opdrachtregel en Bash-scripting beheersen?
Ja. Elke les over De Linux-opdrachtregel en Bash-scripting beheersen bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Web- en applicatielogs op grote schaal parseren
- Logs in realtime volgen en streamingwaarschuwingen
- journald doorzoeken met journalctl in scripts
- Statistieken en histogrammen uit logstreams berekenen