tail -f, ma con numeri di riga

Sto cercando di vedere quante volte foo barappare /var/log/foo.logentro un tempo arbitrario su un server remoto, ma nulla di ciò che ho provato finora ha funzionato.

Ho già uno script timer che uso per tenere traccia di quanto tempo è passato da quando ho iniziato a fare la coda /var/log/foo.log, e ora vorrei solo un modo per dire quante volte foo barè apparso nell'output della coda.

Ho cercato su Google, ma non ho trovato nulla di pertinente nelle prime 10 pagine di risultati.

Ecco cosa ho provato con risultati frustranti:

## works on local machine, but doesn't work as expected on remote
tail -f /var/log/foo.log | grep foo\ bar | sed '='

## works on local, but not remote
tail -f /var/log/foo.log | grep foo\ bar | cat -n -

##  works on local, but not remote
tail -f /var/log/foo.log | grep foo\ bar | awk -F'\n' '{printf "[%d]> ", NR; print $1}'

Ho anche provato a scrivere una sceneggiatura di sed che avrebbe funzionato in questo modo tail -f, ma ho fatto progressi limitati a niente.

NOTA

il server remoto esegue una versione precedente di coreutils e l'aggiornamento è un'opzione, ma NON è in alcun modo la soluzione desiderata.

tail -f | nl

funziona per me ed è il primo a cui ho pensato: se vuoi davvero che le righe siano numerate da 1 e non con il numero di riga reale del file guardato. Se lo si desidera, aggiungere grepeventualmente al posto appropriato (prima o dopo nl). Tuttavia, ricorda che può verificarsi il buffering. Nel mio caso particolare, grepha l' --line-bufferedopzione, ma nlbuffer è l'output e non ha un'opzione per spegnerlo. Quindi la tail | nl | grepcombo non scorre davvero bene.

Detto ciò,

tail -f | grep -n pattern

funziona anche per me. La numerazione ricomincia dall'inizio del "tailing" anziché dall'inizio dell'intero file di registro.

Penso che sia meglio ..

less -N +F <filepath>

Puoi anche reindirizzare l'output less, ha una funzione di numero di riga, -Nche ti permetterebbe di scorrere avanti e indietro nel registro.

$ tail -f /var/log/foo.log | less -N

Esempio

  1 Jan 17 22:11:58 greeneggs fprintd[4323]: ** Message: entering main loop
  2 Jan 17 22:12:01 greeneggs su: (to root) saml on pts/5
  3 Jan 17 22:12:28 greeneggs fprintd[4323]: ** Message: No devices in use, exit
  4 Jan 17 22:12:56 greeneggs gnome-session[1876]: 22:12:56 | Git | personal_repo | Checking for remote changes...
  5 Jan 17 22:12:56 greeneggs gnome-session[1876]: 22:12:56 | Cmd | personal_repo | git rev-parse HEAD
  6 Jan 17 22:12:56 greeneggs gnome-session[1876]: 22:12:56 | Cmd | personal_repo | git ls-remote --heads --exit-code "ssh://sam@sparkleshare.jake      
  6 8us.org/home/sam/SparkleShare/personal_repo.git" master
  7 Jan 17 22:12:58 greeneggs gnome-session[1876]: X11 forwarding request failed on channel 1
  8 Jan 17 22:12:58 greeneggs gnome-session[1876]: 22:12:58 | Git | personal_repo | No remote changes, local+remote: 532213be48cce3b93cb177d409faa      
  8 03b71d0cfa5
  9 Jan 17 22:13:35 greeneggs gnome-session[1876]: 22:13:35 | ListenerTcp | Pinging tcp://notifications.sparkleshare.org:443/
 10 Jan 17 22:13:35 greeneggs gnome-session[1876]: 22:13:35 | ListenerTcp | Received pong from tcp://notifications.sparkleshare.org:443/

NOTA: prendere nota dell'output. Potrebbe piacerti o meno questa funzione, ma ci vorranno linee lunghe e le taglierai in modo che continuino sulla riga successiva, mantenendo comunque lo stesso numero di riga corrispondente. Trovo questa funzione inestimabile quando analizzo i file di registro che sono larghi! Puoi vedere l'effetto di questa funzione sulle linee 6 e 8 .

Per eseguire il grep delle nuove righe solo nel file di registro man mano che arrivano con il loro numero di riga, è possibile:

{
  initial_lines=$(wc -l)
  tail -n +1 -f | awk -v NR="$initial_lines" '/pattern/{print NR": "$0}'
} < file.log

(con mawk, ti consigliamo di aggiungere l' -Winteractiveopzione per impedire il suo buffering di input (!)).

wc -llegge le righe che erano già lì e le conta (i caratteri di nuova riga che significa che funziona ancora anche se l'ultima riga non è ancora piena), e poi noi tail -fgli altri (a partire da dove ha wcsmesso di leggere) e diciamo awkqual è il numero di riga di il primo che vede.

Se vuoi numerare dall'inizio avresti bisogno di grep -n da applicare a tutte le linee.

 tail -f -n100000000 filename.log | grep -n '' 

Se poi avessi voluto solo mostrare gli ultimi 10, avrei pensato di poter ricodificare il file:

 tail -f -n100000000 filename.log | grep -n '' | tail -n10

Il primo è utile, ma mostra un output eccessivo. Non so perché il secondo non funzioni.

Il comando cat -n [filename] | tailotterrà un conteggio rapido e visualizzerà i record più recenti se è quello che stai cercando.

L' -finterruttore lo rende persistente fino alla fuga, il che in realtà non sembra applicabile nel tuo scenario o è ridondante.

wc -l [filename] otterrà un conteggio delle linee nel bersaglio

wc -l [filenameprefix]* conterà tutte le righe in tutti i file corrispondenti allo schema e alla fine segnalerà anche un totale di riepilogo.

Dettagli più completi possono fornire risposte più complete.

È l'argomento no --lines(usato modi leggermente diversi, vedi sotto):

$ tail -f -n 25 /path/to/file.txt

$ tail -f --lines=25 /path/to/file.txt

Vedi anche l'aiuto:

$ tail --help