Citiți jurnalele în timp real cu bash

Am asta în jurnalele de sistem:

27 februarie 02:53:51 Latitude-E6430 rsyslogd: acțiune în sus 7
27 februarie 02:53:51 Latitude-E6430 rsyslogd: acțiune în jos B
27 februarie 02:53:51 Latitude-E6430 rsyslogd: acțiune până U
....etc

Vreau să fac un script care monitorizează jurnalele cu normă întreagă ca serviciu, dar nu știu cum să fac condiția.

1 - Că atunci când citești, rând cu rând, să-l păstrezi într-o variabilă.

2 - citire variabilă dacă găsește în linie, cuvintele [rsyslogd] și [7] arată [echo „Găsit” ]

Ar fi o buclă să citiți fișierul linie cu linie, căutând acel model de cuvinte.

Exemplu de Script

path_full_log="/home/full.log"


funcția reader_time_real(){

    while read full_log; do
        chek7=$(cat $full_log | grep "rsyslogdd" | grep 7 )
            dacă [[ $? = 0 ]]; atunci 
                ecou „Găsit 7”;

            fi

        chekB=$(cat $full_log | grep "rsyslogdd" | grep B )
            dacă [[ $? = 0 ]]; atunci 
                ecou „Găsit B”;

            fi
    terminat < $path_full_log
}

Am realizat următorul script, care se actualizează în fiecare secundă și evidențiază orice noi intrări de jurnal. De asemenea, definește zona în care ar trebui să fie afișat jurnalul (cu codul succese și logcols variabile), deci este făcut pentru a fi utilizat într-o fereastră de terminal de dimensiune fixă ​​(o folosesc în interiorul tmux).

Probabil că ați putea modifica acest script pentru a evidenția numai liniile care se potrivesc unui anumit criteriu, așa cum indicați.

#!/bin/bash

# Variabilele de configurare inițială
rezultate=31
logcols=127

# Definiția funcției locale
printnew() {
  clar
  echo -e „\e[0;30;47m”
  hightail=$(coada -n "$logrows" /var/log/syslog | cut -b "1-$logcols")
  echo -ne "${hightail}\e[0m"
}

printdif() {
  (( newrows = logrows - logdiff ))
  clar
  normtail=$(coada -n "$logrows" /var/log/syslog | head -n "$newrows" | cut -b "1-$logcols")
  echo -n "$normtail"
  echo -e „\e[0;30;47m”
  hightail=$(coada -n "$logdiff" /var/log/syslog | cut -b "1-$logcols")
  echo -ne "${hightail}\e[0m"
}

printold() {
  clar
  normtail=$(coada -n "$logrows" /var/log/syslog | cut -b "1-$logcols")
  echo -n "$normtail"
}

# Buclă în fiecare secundă
în timp ce adevărat
do
  dormi 1 &

  # Citiți dimensiunile jurnalului
  logsize=$(wc -l /var/log/syslog | cut -d ' ' -f1)
  (( logdiff = dimensiunea log - presize ))

  # Dacă mai mult de $logrows linii sunt noi
  if (( logdiff > „$logrows” ))
  atunci
    printnew
    redesenare=1
  # Dacă mai puțin de $logrows linii, dar mai mult de 0 linii sunt noi
  elif (( logdiff > 0 ))
  atunci
    printdif
    redesenare=1
  # Dacă nu există linii noi
  altfel
    dacă [[ "$redesenează" -eq 1 ]]
    atunci
      printold
      redesenare=0
    fi
  fi

  presize="$logsize"
  așteptați # pentru somn
Terminat

Scriptul este realizat având în vedere 3 scenarii:

1. Întregul conținut al succese este nou - totul este evidențiat (printnew).
2. Unele linii din jurnal sunt noi - acestea sunt evidențiate (printdif).
3. Fără linii noi de jurnal - nimic nu este evidențiat (printold).

Disclaimer: Codul ar putea fi probabil optimizat, dar, în general, sunt mai preocupat ca codul meu să fie lizibil, mai degrabă decât cât mai condensat posibil.

Scriptul tău nu este potrivit pentru a face ceea ce vrei să faci. Citește fișierul o singură dată, dar complet. Dacă treceți în buclă, nu veți obține doar rezultate noi și ar fi un coșmar de performanță.

De asemenea, aveți o utilizare inutilă a pisică, tu grep un șir fix cu un model regex și salvați rezultatul într-o variabilă pe care nu o mai utilizați. De asemenea, nu ar trebui să utilizați variabile cu nume de fișier fără ghilimele.

Utilizare coada -f | grep --line-buffered:

coada -fn0 „$path_full_log” \
| grep -F --line-buffered 'rsyslogdd' \
| grep -Eo --line-buffered '(7|B)' \
| în timp ce linia de citire; do
      echo „Găsit $line”
  Terminat

Sau folosind xargs:

coada -fn0 „$path_full_log” \
| grep -F --line-buffered 'rsyslogdd' \
| grep -Eo --line-buffered '(7|B)' \
| xargs -I{} echo „Găsit {}”

• coada -fn0 citește linii noi ale fișierului când sunt adăugate.
• grep -F caută un șir fix în acea linie.
• --line-buffered spune grep pentru a citi liniile când vin în loc să aștepte sfârșitul fluxului de intrare, care este implicit.
• grep -Eo caută ERE model (-E) (7|B) și scoate numai șirul potrivit (-o).
• în timp ce linia citită sau xargs -I{} preia acea ieșire și rulează comanda pe ieșire (aici: ecou).