Una ricerca su un grande application.log può richiedere tempo, ma il cronometro da solo non indica se grep sta leggendo troppi file, visualizzando troppe righe o applicando un pattern costoso. Prima di confrontare i comandi, identifica il file, verifica che sia leggibile e stabile, quindi conserva una ricerca completa come riferimento. I percorsi qui sotto sono esempi da adattare al tuo sistema.
Identificare il file e stabilire una ricerca completa
Inizia confermando lo strumento, il percorso, la dimensione, la data di modifica e i tuoi diritti di lettura. Usa una copia congelata del registro se il servizio continua a scrivere al suo interno.
grep --version
test -f application.log && test -r application.log
stat -c '%n : %s byte, modifica %y' -- application.log
test -x /usr/bin/time
Il comando stat descrive l’obiettivo senza sfogliare il suo contenuto. Se un controllo fallisce, fermati: verifica il percorso o l’accesso al file invece di ampliare la ricerca all’intero sistema. I registri possono contenere indirizzi, identificatori o token; non copiare la loro uscita in uno spazio condiviso senza averla esaminata.
In seguito, avvia una ricerca esaustiva e leggibile:
grep -nF -e 'ERROR' -- application.log
rc=$?
printf 'Codice grep: %sn' "$rc"
-n aggiunge il numero di riga. -F interpreta ERROR come testo letterale. -e designa il pattern, e -- indica che gli argomenti successivi sono percorsi, anche se iniziano con un trattino. Per un file contenente errori, il comando visualizza ogni riga selezionata; il codice 0 significa che almeno una riga corrisponde. Il codice 1 significa che nessuna riga corrisponde. Il codice 2 segnala un errore, ad esempio un file mancante o illeggibile. Mantieni i diagnostic su stderr visibili: un risultato vuoto con un errore non è una ricerca riuscita.
Questo riferimento fissa il pattern e il corpus. Permette di verificare le modifiche successive invece di confondere un’uscita più corta con un’elaborazione più rapida.
Ridurre i file esaminati prima di cambiare il pattern
Se stai cercando solo nei registri di un servizio, nomina i suoi file anziché eseguire una ricorsione ampia. Per un elenco corto, passa direttamente i percorsi interessati a grep. Verificali in anticipo con test -f e test -r se la loro presenza o accesso non è garantito.
Per selezionare i file .log da un albero escludendo esplicitamente archives, ispeziona prima l’elenco:
find . -type d -name archives -prune -o -type f -name '*.log' -print
Dopo aver confermato che questo perimetro corrisponde bene alla questione, puoi passare i percorsi direttamente a grep:
find . -type d -name archives -prune -o -type f -name '*.log'
-exec grep -HnF -e 'ERROR' -- {} +
-prune impedisce a find di scendere nella cartella esclusa. -exec ... {} + raggruppa i percorsi in batch; non garantisce che una sola esecuzione sia sufficiente per un elenco molto grande. -H mantiene il nome del file nell’uscita, anche quando un batch contiene solo un file. I percorsi sono passati come argomenti, senza tagli errati sugli spazi. Mantieni stderr visibile: lo stato aggregato di find con -exec ... + non distingue sempre di per sé un’assenza di corrispondenza da un errore di grep in un batch. Un albero modificato durante la traversata non è uno snapshot.
Un’altra possibilità, con GNU grep, è una ricorsione mirata:
grep -rHnF --include='*.log' --exclude='*.gz'
--exclude-dir=archives -e 'ERROR' -- .
Le esclusioni sono visibili nel comando e devono rimanere da adattare ai file realmente utili. -r percorre le directory senza seguire i link simbolici incontrati durante la discesa; non sostituirlo con -R, che segue anche questi link e può ampliare il corpus. Escludere i file riduce il lavoro perché alcuni non vengono più cercati: non è un’ottimizzazione a risultati equivalenti. Un unico file molto voluminoso non è accorciato dall’esclusione di una directory.
Usare -F e la locale C senza cambiare le corrispondenze
Mantieni -F quando il pattern è una stringa letterale, come ERROR. Scegli -E se la necessità descrive una struttura, ad esempio un prefisso di riga seguito da un separatore. Non accumulare -F e -E: sono due modi diversi di interpretare il pattern. Non trasformare una ricerca letterale in espressione regolare solo con la speranza di guadagnare tempo.
Un elenco può anche essere letto con -f, una regola per riga. Per preparare un elenco di pattern per grep, verifica in particolare che non contenga righe vuote involontariamente: un pattern vuoto può selezionare tutte le righe.
Per un pattern ASCII sensibile al maiuscolo/minuscolo, LC_ALL=C è un candidato da confrontare:
LC_ALL=C grep -nF -e 'ERROR' -- application.log
La locale C può rendere alcuni trattamenti più efficienti, ma cambia anche le regole dei caratteri. Non è una conversione del file in UTF-8. I comportamenti legati ai caratteri Unicode, a -i, alle classi come [[:alpha:]] e agli intervalli come [a-z] possono differire. Non usare quindi questo prefisso se il significato del pattern dipende da queste regole; non esportarlo globalmente. Verifica le corrispondenze sul corpus interessato prima di interpretare un tempo. Se grep segnala che un file è binario, controlla perché grep tratta il file come binario prima di scegliere una risposta; non mascherare il problema con un’opzione di prestazioni.
Scegliere tra tutte le righe, un conteggio e una prima prova
Queste opzioni non rispondono allo stesso obiettivo. Un’uscita più corta non significa che grep abbia letto meno dati.
| Modalità | Risultato ottenuto | Momento di arresto | Cosa non prova |
|---|---|---|---|
| Ricerca completa | Tutte le righe selezionate | Dopo il percorso necessario del file | Che un altro pattern o corpus sarebbero equivalenti |
-m 1 |
Al massimo una riga selezionata per file | Dopo la prima corrispondenza di ogni file | Che le altre corrispondenze non esistano |
-l |
I nomi dei file che contengono una corrispondenza | Al primo match di ogni file | Il contenuto completo né il numero di righe |
-c |
Il numero di righe selezionate per file | Dopo il conteggio necessario | Il numero di occorrenze: due pattern su una riga contano come una riga |
-q |
Nessun risultato su stdout; codice 0 non appena un match | Alla prima corrispondenza | Una lettura esaustiva: un errore dopo il match può essere nascosto |
Scegli -m, -l o -q solo se la questione riguarda realmente una prima prova. -c riduce l’output, ma il conteggio completo richiede generalmente di esaminare il file. Nessuna di queste modalità dovrebbe essere temporizzata contro una ricerca esaustiva come se i risultati attesi fossero identici.
Distingere il ritardo di un pipe dal tempo di ricerca
--line-buffered chiede a grep di svuotare la sua uscita dopo ogni riga quando scrive in un pipe. Questo può ridurre l’attesa prima della visualizzazione in un flusso; non è un’accelerazione universale della lettura di un grande file. Il programma successivo nel pipe può anche tamponare la sua uscita. I messaggi di errore di grep rimangono su stderr.
Per controllare gli stati dei due comandi in Bash, copia PIPESTATUS immediatamente dopo il pipe, prima di qualsiasi altro comando:
grep -nF -e 'ERROR' -- application.log | wc -l
codes=("${PIPESTATUS[@]}")
printf 'grep=%s wc=%sn' "${codes[0]}" "${codes[1]}"
Il numero visualizzato da wc non sostituisce l’uscita di riferimento e il suo codice da solo non rivela un errore di grep. Per un registro in monitoraggio o trovare un errore con il suo contesto, il bisogno è diverso da un confronto di ricerca esaustiva.
Confrontare le uscite prima di confrontare i tempi
Misura in un laboratorio privato situato al di fuori dell’albero ricercato. mktemp crea un directory temporanea; verifica che la sua posizione sia affidabile e che disponga di abbastanza spazio per due uscite complete. Lavora su un file stabile. L’esempio confronta la stessa ricerca letterale, con e senza locale C:
laboratorio=$(mktemp -d "${TMPDIR:-$HOME}/grep-perf.XXXXXX") || exit 1
stat -c '%n : %s byte, modifica %y' -- application.log
/usr/bin/time -f 'real=%e user=%U sys=%S codice=%x'
grep -nF -e 'ERROR' -- application.log > "$laboratorio/reference.txt"
ref_rc=$?
/usr/bin/time -f 'real=%e user=%U sys=%S codice=%x'
env LC_ALL=C grep -nF -e 'ERROR' -- application.log > "$laboratorio/candidate.txt"
candidate_rc=$?
printf 'riferimento=%s candidato=%sn' "$ref_rc" "$candidate_rc"
cmp -- "$laboratorio/reference.txt" "$laboratorio/candidate.txt"
cmp_rc=$?
printf 'Comparazione: %sn' "$cmp_rc"
stat -c '%n : %s byte, modifica %y' -- application.log
/usr/bin/time esterno mostra il tempo reale (real), il tempo CPU utente e di sistema (user, sys), così come lo stato del comando. Le due uscite vanno in file distinti; i diagnostici rimangono visibili. Lo stato 0 di cmp significa che le uscite sono identiche, 1 che differiscono e 2 che la comparazione è fallita.
Non interpretare i tempi se le due ricerche non hanno lo stato atteso, che nessun diagnostico è apparso, che cmp restituisce 0 e che i metadati del file di ingresso sono coerenti prima e dopo. Un’uguaglianza su un ingresso non prova l’equivalenza per tutti i file futuri. Se ti aspetti delle corrispondenze, verifica anche una riga nota.
Ripeti le misurazioni in un ordine alternato: la cache di sistema, il carico e lo storage possono influenzare il risultato. Mantieni lo stesso perimetro, le stesse opzioni e le stesse uscite; non purgare la cache in produzione. Il guadagno non è misurato qui. Un’interruzione lascia uscite parziali, non una prova completa.
Il metodo presuppone file di testo ordinari e stabili. Una rotazione durante la ricerca, una riga gigante, un file compresso o binario, un registro attivo e la mancanza di spazio per i risultati impongono una diagnostica distinta. Per una verifica finale, rileggi i codici e confronta ancora i metadati di application.log prima di conservare i risultati.
Fonti da verificare
- Manuale GNU grep, comprese le sezioni sulle prestazioni, i controlli delle corrispondenze, l’uscita e i codici di ritorno.
- Manuale GNU coreutils, per
/usr/bin/timeestat.