0Pricing
Linux Command Line & Bash Scripting Mastery · Pelajaran

Mengikuti Log secara Real-Time dan Mengalirkan Peringatan

Ikuti dan saring aliran log langsung untuk memicu peringatan segera setelah pola error muncul.

Mengikuti Log secara Real-Time dan Mengalirkan Peringatan adalah pelajaran Linux Command Line & Bash Scripting Mastery gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Linux Command Line & Bash Scripting Mastery, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Mengapa Mengikuti Log Secara Real-Time Itu Penting

Dalam sistem produksi, file log terus bertambah. Menunggu hingga masalah dilaporkan sebelum memeriksa log berarti waktu henti sudah telanjur merugikan Anda. Mengikuti log secara real-time memungkinkan Anda mengamati kejadian saat ditulis, sehingga Anda dapat segera menanggapi kegagalan, kejadian keamanan, dan penurunan kinerja.

  • Server web menulis satu baris untuk setiap permintaan — galat muncul seketika
  • Daemon aplikasi mencatat jejak tumpukan saat pengecualian terjadi
  • Sistem autentikasi mencatat upaya login yang gagal secara real-time

Alat Unix dasar untuk keperluan ini adalah tail -f, yang dipadukan dengan utilitas penyaringan dan pemberian peringatan untuk mengubah aliran log mentah menjadi sinyal yang dapat ditindaklanjuti.

tail -f: Mengikuti Log Langsung

tail -f (ikuti) mempertahankan file tetap terbuka dan mencetak baris baru saat ditambahkan. Ini adalah alat log real-time yang paling sederhana dan tersedia hampir di semua sistem.

Pola penggunaan umum:

  • tail -f /var/log/syslog — ikuti log sistem
  • tail -n 50 -f app.log — tampilkan 50 baris terakhir lalu ikuti
  • tail -f /var/log/nginx/access.log — ikuti permintaan nginx secara langsung

Tekan Ctrl+C untuk berhenti. Proses tetap terhubung hingga Anda membatalkannya atau terminal ditutup.

#!/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: Tetap Berjalan Saat Log Dirotasi

Banyak sistem merotasi file log pada tengah malam atau saat ukurannya mencapai batas tertentu. Saat itu terjadi, file asli diganti namanya (misalnya app.log.1) dan app.log baru dibuat. Dengan tail -f, Anda tanpa sadar tetap membaca file lama yang telah diganti nama dan melewatkan semua keluaran baru.

tail -F (F kapital) mengatasi hal ini dengan mengawasi nama file, bukan deskriptor file. Saat file menghilang lalu muncul kembali, tail -F otomatis membukanya kembali dan melanjutkan pengikutan.

  • Selalu pilih tail -F daripada tail -f dalam skrip produksi
  • Berfungsi dengan logrotate, newsyslog, dan pengandar log Docker yang merotasi file
# 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.log

Menyaring Aliran dengan grep

Mengikuti log mentah yang sibuk dapat membuat kewalahan — server web aktif dapat menulis ratusan baris per detik. Teruskan keluaran tail -F ke grep untuk mengisolasi hanya pola yang Anda perlukan.

Opsi utama untuk grep pada aliran:

  • --line-buffered — segera keluarkan setiap baris yang cocok, bukan menyimpannya dalam penyangga; wajib dalam pipeline, jika tidak, keluaran akan tertunda atau hilang
  • -i — pencocokan tanpa membedakan huruf besar-kecil
  • -E — regex diperluas untuk alternasi (error|warn|crit)
  • -v — balikkan pencocokan (kecualikan baris)
# 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'

Menambahkan Cap Waktu dan Konteks dengan awk

Baris log terkadang tidak memiliki konteks yang membantu dalam triase. Anda dapat memperkaya aliran secara real-time menggunakan awk — menambahkan cap waktu lokal, mengekstrak bidang, atau memformat ulang keluaran agar lebih mudah dibaca.

awk juga berjalan dalam mode streaming (dengan penyanggaan per baris) saat disalurkan, sehingga aman digunakan dalam pipeline langsung tanpa opsi tambahan.

# 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'

Mengirim Peringatan dengan Webhook Slack

Penyaringan hanyalah separuh pekerjaan — setelah mendeteksi pola galat, Anda perlu memberi tahu seseorang. Webhook masuk Slack memungkinkan Anda mengirim pesan ke suatu kanal dengan satu pemanggilan curl, tanpa memerlukan SDK Slack atau kredensial selain URL webhook.

Polanya adalah: saring aliran, lalu untuk setiap baris yang cocok kirimkan 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"
done

Membatasi Laju Peringatan untuk Mencegah Kebisingan

Banjir log dapat menghasilkan ribuan baris galat per menit. Mengirim satu pesan Slack untuk setiap baris akan membanjiri kanal dan menyebabkan kelelahan akibat peringatan. Anda memerlukan pembatasan laju — picu peringatan, lalu tekan notifikasi berikutnya selama periode jeda.

Hal ini dapat dilakukan dengan file cap waktu sederhana: catat kapan peringatan terakhir dikirim, lalu jangan memicu peringatan jika jeda belum berlalu.

#!/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
done

Menghitung Ledakan Galat dengan Jendela Geser

Terkadang satu baris galat tidak berarti — tetapi 20 galat dalam 30 detik adalah masalah serius. Penghitung berjendela geser memungkinkan Anda memicu peringatan hanya saat ambang laju galat terlampaui, sehingga mengurangi positif palsu.

Teknik ini menyimpan cap waktu epoch setiap kejadian yang cocok dalam file sementara, lalu menghitung berapa banyak yang berada dalam jendela tersebut sebelum memutuskan apakah akan mengirim peringatan.

#!/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
done

journalctl -f: Mengikuti Jurnal systemd

Pada sistem Linux modern (RHEL, Ubuntu 20.04+, Debian 10+), layanan menulis ke jurnal systemd, bukan ke file teks biasa. journalctl -f adalah padanan tail -F untuk jurnal.

Opsi yang berguna:

  • -u myapp.service — ikuti hanya unit tertentu
  • -p err — saring berdasarkan prioritas (emerg, alert, crit, err, warning, notice, info, debug)
  • --since '5 min ago' — mulai dari waktu relatif
  • -o json — keluaran JSON terstruktur untuk penguraian oleh mesin
# 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 dan Pemantauan Multi-Sumber Berkode Warna

Saat Anda perlu mengawasi beberapa sumber log secara bersamaan, multitail membagi terminal menjadi beberapa panel — masing-masing mengikuti file atau perintah yang berbeda — dengan pengodean warna opsional berdasarkan pola.

Jika multitail belum terpasang, alternatif ringan yang sepenuhnya menggunakan BASH adalah memberi awalan nama sumber pada setiap aliran lalu menggabungkannya menjadi satu tampilan.

# 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
)

Membangun Daemon Peringatan Mandiri

Dengan menggabungkan semua hal dalam pelajaran ini, daemon peringatan yang layak untuk produksi seharusnya:

  • Mengikuti file log dengan andal menggunakan tail -F
  • Menyaring pola kritis dengan grep yang menggunakan penyangga
  • Membatasi laju notifikasi untuk menghindari kelelahan akibat peringatan
  • Mencatat aktivitasnya sendiri agar Anda dapat mengaudit apa yang telah dikirim
  • Berjalan sebagai proses latar belakang yang dikelola oleh systemd atau pengawas

Skrip di bawah ini adalah daemon minimal tetapi lengkap yang dapat Anda letakkan di /usr/local/bin/ dan kelola dengan systemd.

#!/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
done

Pemeriksaan Pengetahuan: Pipeline Log Streaming

Uji pemahaman Anda tentang pengikutan log real-time dan peringatan streaming.

Sebuah pipeline Bash mengikuti file log dan mengirimkan peringatan Slack untuk setiap baris yang cocok. Saat terjadi banjir log, 3.000 baris galat ditulis dalam 10 detik. Perubahan tunggal apa yang paling baik mencegah skrip membanjiri kanal Slack dengan 3.000 pesan?

Ringkasan Pelajaran: Pengikutan Log Real-Time dan Peringatan Streaming

Dalam pelajaran ini, Anda membangun pipeline observabilitas log real-time yang lengkap dari prinsip dasar:

  • tail -F mengikuti file log berdasarkan nama dan tetap berjalan saat log dirotasi — selalu pilih ini daripada tail -f dalam produksi
  • grep --line-buffered menyaring aliran langsung tanpa menambahkan latensi; selalu tambahkan opsi ini dalam perintah grep yang disalurkan
  • awk dengan fflush() memperkaya setiap baris dengan cap waktu atau bidang yang diekstrak secara aman untuk streaming
  • Webhook Slack melalui curl mengirimkan peringatan dengan satu HTTP POST — SDK tidak diperlukan
  • File jeda mencegah kelelahan akibat peringatan selama banjir log dengan memberlakukan interval minimum antarnotifikasi
  • Penghitung berjendela geser mendeteksi ledakan galat (peringatan berbasis laju), bukan bereaksi terhadap setiap baris secara terpisah
  • journalctl -f adalah padanan bawaan systemd untuk tail -F, dengan penyaringan prioritas dan keluaran JSON bawaan
  • Skrip daemon peringatan mandiri menggabungkan semua pola ini dan dapat dikelola oleh systemd untuk keandalan produksi

Primitif ini dapat dikomposisikan menjadi dasar setiap pipeline observabilitas khusus — agen pihak ketiga tidak diperlukan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengikuti Log secara Real-Time dan Mengalirkan Peringatan” gratis?

Ya — teks lengkap “Mengikuti Log secara Real-Time dan Mengalirkan Peringatan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Linux Command Line & Bash Scripting Mastery, upgrade ke CoddyKit PRO. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Mengikuti Log secara Real-Time dan Mengalirkan Peringatan”?

Ikuti dan saring aliran log langsung untuk memicu peringatan segera setelah pola error muncul. Kamu berlatih Linux Command Line & Bash Scripting Mastery dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Linux Command Line & Bash Scripting Mastery?

Tidak diperlukan pengalaman sebelumnya. Linux Command Line & Bash Scripting Mastery di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Mengikuti Log secara Real-Time dan Mengalirkan Peringatan” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Linux Command Line & Bash Scripting Mastery ini?

Ya. Setiap pelajaran Linux Command Line & Bash Scripting Mastery menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Mengurai Log Web dan Aplikasi dalam Skala Besar
  2. Mengikuti Log secara Real-Time dan Mengalirkan Peringatan
  3. Mengkueri journald dengan journalctl dalam Skrip
  4. Menghitung Metrik dan Histogram dari Aliran Log
← Kembali ke Linux Command Line & Bash Scripting Mastery