Come avere tail -f mostra output colorati

Mi piacerebbe essere in grado di adeguare l'output di un file di registro del server che contiene messaggi come:

INFO
SEVERE

ecc. e, se lo è SEVERE, mostra la linea in rosso; se lo è INFO, in verde. Che tipo di alias posso impostare per un tailcomando che mi aiuti a farlo?

Prova multitail . Questa è una übergeneralizzazione di tail -f. Puoi guardare più file in finestre separate, evidenziare le linee in base al loro contenuto e altro ancora.

multitail -c /path/to/log

I colori sono configurabili Se la combinazione di colori predefinita non funziona per te, scrivi la tua nel file di configurazione. Ad esempio, chiamare multitail -cS amir_log /path/to/logcon il seguente ~/.multitailrc:

colorscheme:amir_log
cs_re:green:INFO
cs_re:red:SEVERE

Un'altra soluzione, se ci si trova su un server in cui è scomodo installare strumenti non standard , è quella di combinare tail -fcon sed o awk per aggiungere sequenze di controllo di selezione del colore. Ciò richiede tail -fdi svuotare senza indugio la sua uscita standard anche quando la sua uscita standard è una pipe, non so se tutte le implementazioni lo fanno.

tail -f /path/to/log | awk '
  /INFO/ {print "\033[32m" $0 "\033[39m"}
  /SEVERE/ {print "\033[31m" $0 "\033[39m"}
'

o con sed

tail -f /path/to/log | sed --unbuffered \
    -e 's/\(.*INFO.*\)/\o033[32m\1\o033[39m/' \
    -e 's/\(.*SEVERE.*\)/\o033[31m\1\o033[39m/'

Se il tuo sed non è GNU sed, sostituiscilo \o033con un carattere di fuga letterale e rimuovilo --unbuffered.

Un'altra possibilità è quella di eseguire tail -fun buffer di shell Emacs e utilizzare le abilità di colorazione della sintassi di Emacs.

grc , il colorante generico è piuttosto interessante.

apt-get install grc

Basta fare

grc tail -f /var/log/apache2/error.log

e goditelo!

Lo troverai anche su GitHub .

Hai dato un'occhiata a ccze ? Hai la possibilità di personalizzare i colori predefiniti di alcune parole chiave utilizzando l'opzione -co direttamente nel tuo file di configurazione. Se lo schermo si cancella dopo la colorazione, è necessario utilizzare l'opzione -A.

Modificare:

Se desideri davvero che la linea completa sia colorata in rosso, puoi anche provare a:

$ tail -f myfile.log | perl -pe 's/.*SEVERE.*/\e[1;31m$&\e[0m/g'

\e[1;31mti darà il colore rosso. Se desideri un po 'di giallo, usa \e[1;33me per un uso verde \e[1;32m. Il \e[0mripristina il normale colore del testo.

Dai un'occhiata a lnav , il visualizzatore di file di registro avanzato.

Può anche stampare abbastanza vari formati.

Prima:

Dopo:

Puoi usare l' arcobaleno , che colora le linee in base alle espressioni regolari:

rainbow --red='SEVERE.*' --green='INFO.*' tail -f my-file.log

Viene inoltre fornito in bundle con configurazioni predefinite , ad esempio per i registri Tomcat:

rainbow --config=tomcat tail -f my-file.log

(disclaimer: sono l'autore)

Puoi usare colortail :

colortail -f /var/log/messages

Nota anche che se vuoi solo cercare un regex corrispondente, GNU grep con --colorfunzionerà, semplicemente esegui il pipe taildell'output attraverso quello.

Per ottenere un output colorato da comandi standard come grep, è necessario impostare questo aliasnel proprio.bashrc

# User specific aliases and functions
alias grep='grep --color=auto'

quando grep qualcosa nel tuo file vedi qualcosa del genere, (ma probabilmente in rosso):

[root @ linuxbox mydir] # grep "\ (INFO \ | SEVERE \)" / var / log / logname
questa voce è un INFO  
SEVERE questa voce è un avvertimento!
questa voce è un INFO 
questa voce è un INFO 
SEVERE questa voce è un avvertimento!

se vuoi usare tailo awke vuoi che il colore sopravviva ad una pipe, allora l'alias non è abbastanza e dovresti usare il --color=alwaysparametro, ad esempio:

[root @ linubox mydir] # grep --color = always "\ (INFO \ | SEVERE \)" / var / log / logname | coda -f | awk "{print $ 1}"
Questo 
GRAVE
Questo
Questo
GRAVE

Se vuoi un testo a colori con awkla storia è un po 'complesso ma più potente, ad esempio:

[root @ linubox mydir] # tail -f / var / log / messages | awk '{if ($ 5 ~ / INFO /) print "\ 033 [1; 32m" $ 0 "\ 033 [0m"; altrimenti if ($ 1 ~ / SEVERE /) print "\ 033 [1; 31m" $ 0 "\ 033 [0m"; altrimenti stampa $ 0} '
questa voce è un INFO  
SEVERE questa voce è un avvertimento!
questa è un'altra ENTRATA
questa voce è un INFO
questa è un'altra ENTRATA
questa voce è un INFO 
SEVERE questa voce è un avvertimento!

con ogni riga nel suo colore.

Esistono molti altri modi per ottenere testo colorato dalla shell con altri strumenti e sono ben descritti da altri membri.

Mi piace abbastanza il colorex . Semplice ma soddisfacente.

tail -f /var/log/syslog | colorex -G '[0-9]{2}:[0-9]{2}:[0-9]{2}' -b $(hostname)

Sulla base della risposta di @uloBasEI, ho provato a usare ... | perl ... | perl ..., ma la pipe di Linux diventa un po 'pazza ed è troppo lenta. Se metto tutte le regole in un solo perlcomando, funziona benissimo.

Ad esempio, crea un perlfile colorTail.pl come di seguito:

#!/usr/bin/perl -w

while(<STDIN>) {
    my $line = $_;
    chomp($line);
    for($line){
        s/==>.*<==/\e[1;44m$&\e[0m/gi; #tail multiples files name in blue background
        s/.*exception.*|at .*/\e[0;31m$&\e[0m/gi;  #java errors & stacktraces in red
        s/info.*/\e[1;32m$&\e[0m/gi; #info replacement in green
        s/warning.*/\e[1;33m$&\e[0m/gi; #warning replacement in yellow
    }
    print $line, "\n";
}

Usalo come:

tail -f *.log | perl colorTail.pl
tail -f *.log -f **/*.log | perl colorTail.pl

NOTA: puoi usarlo anche su MobaXTerm ! Basta scaricare il perlplug-in dal sito MobaXTerm .

tail -f /var/log/logname | source-highlight -f esc -s log

Una soluzione che funziona per colorare tutti i tipi di testo, non solo i file di registro, è uno strumento Python, ' colout '.

pip install colout
myprocess | colout REGEX_WITH_GROUPS color1,color2... [attr1,attr2...]

Dove qualsiasi testo nell'output di 'myprocess' che corrisponde al gruppo 1 del regex verrà colorato con color1, gruppo 2 con color2, ecc.

Per esempio:

tail -f /var/log/mylogfile | colout '^(\w+ \d+ [\d:]+)|(\w+\.py:\d+ .+\(\)): (.+)$' white,black,cyan bold,bold,normal

vale a dire che il primo gruppo regex (parentesi) corrisponde alla data iniziale nel file di registro, il secondo gruppo corrisponde a un nome di file, numero di riga e nome della funzione di Python e il terzo gruppo corrisponde al messaggio di registro che segue. Questo sembra:

Nota che le linee o parti di linee che non corrispondono a nessuna delle mie regex sono ancora echeggiate, quindi questo non è come 'grep --color' - nulla viene filtrato dall'output.

Ovviamente questo è abbastanza flessibile da poterlo utilizzare con qualsiasi processo, non solo per il loging dei file di log. Di solito ho appena tirato fuori una nuova regex al volo ogni volta che voglio colorare qualcosa. Per questo motivo, preferisco il colore a qualsiasi strumento personalizzato di colorazione dei file di log, perché ho solo bisogno di imparare uno strumento, indipendentemente da ciò che sto colorando: registrazione, output di test, sintassi evidenziando frammenti di codice nel terminale, ecc.

Spina senza vergogna: ho scritto uno strumento chiamato TxtStyle che fa qualcosa di simile alle opzioni menzionate in precedenza. Puoi eseguirlo come segue:

tail -f /var/log/syslog | txts --regex '\d+'

Puoi anche definire gli stili con nome nel file config ( ~/.txts.conf) e usarlo in questo modo:

ifconfig | txts --name ifconfig

(lo ifconfigstile è definito fuori dalla scatola)

grc di sicuro!

personalizza i tuoi collor con regex nel file: ~ .grc / conf.tail (o qualunque nome tu voglia)

regexp=.*(select .*)$
colours=unchanged,cyan
=====
regexp=.*(update .*)$
colours=unchanged,bold yellow
=====
regexp=.*(insert .*)$
colours=unchanged,bold yellow
=====
regexp=.*(emp=\d+).*
colours=unchanged,reverse green
=====
regexp=.*http.*/rest/contahub.cmds.(.*?)/(\w*).*$
colours=unchanged,green,magenta
=====
regexp=.*http.*/M/.*\.(.*?Facade)/(\w*).*$
colours=unchanged,underline green,underline magenta

riga di comando:

grc -c conf.tail tail -f log/tomcat/catalina.out

i risultati:

informazioni per la configurazione di grc: https://github.com/manjuraj/config/blob/master/.grc/sample.conf

Ho scritto una funzione bash che accetta fino a tre parametri e fa un filtro simile a grep su un file di testo, e stampa il testo sullo schermo a colori.

Vorrei anche vedere una funzione di coda che lo farebbe, ma non ne ho ancora trovata una.

Questa funzione può anche essere migliorata: apprezzerei qualsiasi aiuto su come migliorarla.

function multigrep(){

    #THIS WORKS - Recreate this, using input parameters
    #sed -En '/(App)|(Spe)/p' ./flashlog.txt;

    filename="/Users/stevewarren/Library/Preferences/Macromedia/Flash\ Player/Logs/flashlog.txt";
    paramString="";

    for element in "$@"
        do
            #echo $element;
            paramString="$paramString($element)|";
        done

    #TRIM FINAL | OFF PARAMSTRING
    paramString=${paramString:0:${#paramString}-1};

    #CREATE SED EXPRESSION - '/($1)|($2)|(...)/p'
    paramString="'/$paramString/p'";

    #CREATE SED FUNCTION, CALL ON FILE
    paramString="sed -En $paramString ./flashlog.txt"

    echo $paramString;
    echo "${txtbld}$(tput setaf 7)" > ./flashlog_output.txt;
    eval $paramString >> ./flashlog_output.txt;
    echo >> ./flashlog_output.txt;
    #cat ./flashlog_output.txt;

    cat ./flashlog_output.txt | while read LINE
    do

        [[  $1 && ${1-x} ]] && 
            if grep -q $1 <<<$LINE; then
                echo "$(tput setaf 3)$LINE"
            fi

        [[  $2 && ${2-x} ]] && 
            if grep -q $2 <<<$LINE; then
                echo "$(tput setaf 7)$LINE"
            fi


        [[  $3 && ${3-x} ]] && 
            if grep -q $3 <<<$LINE; then
                echo "$(tput setaf 6)$LINE"
            fi

    done
}

sicuro !

Ho scritto a lungo una funzione chiamata "egrepi", basata sulle definizioni delle 8 variabili di colore. Funziona SOLO come una funzione colorata "tail -f".

1. setColors

in primo luogo, le variabili di colore funzionano da chiamare inizialmente:

setColors ()
{
set -a
which printf >/dev/null 2>&1 && print=printf || print=print # Mandriva doesn't know about printf

hide='eval tput civis'
show='eval tput cnorm'
CLS=$(tput clear)
bel=$(tput bel)

case ${UNAME} in
AIX)
# text / foreground
N=$(${print} '\033[1;30m')
n=$(${print} '\033[0;30m')
R=$(${print} '\033[1;31m')
r=$(${print} '\033[0;31m')
G=$(${print} '\033[1;32m')
g=$(${print} '\033[0;32m')
Y=$(${print} '\033[1;33m')
y=$(${print} '\033[0;33m')
B=$(${print} '\033[1;34m')
b=$(${print} '\033[0;34m')
M=$(${print} '\033[1;35m')
m=$(${print} '\033[0;35m')
C=$(${print} '\033[1;36m')
c=$(${print} '\033[0;36m')
W=$(${print} '\033[1;37m')
w=$(${print} '\033[0;37m')
END=$(${print} '\033[0m')

# background
RN=$(${print} '\033[6;40m')
Rn=$(${print} '\033[40m')
RR=$(${print} '\033[6;41m')
Rr=$(${print} '\033[41m')
RG=$(${print} '\033[6;42m')
Rg=$(${print} '\033[42m')
RY=$(${print} '\033[6;43m')
Ry=$(${print} '\033[43m')
RB=$(${print} '\033[6;44m')
Rb=$(${print} '\033[44m')
RM=$(${print} '\033[6;45m')
Rm=$(${print} '\033[45m')
RC=$(${print} '\033[6;46m')
Rc=$(${print} '\033[46m')
RW=$(${print} '\033[6;47m')
Rw=$(${print} '\033[47m')

HIGH=$(tput bold)
SMUL=$(tput smul)
RMUL=$(tput rmul)
BLINK=$(tput blink)
REVERSE=$(tput smso)
REVERSO=$(tput rmso)
;;
*)
# text / foreground
n=$(tput setaf 0)
r=$(tput setaf 1)
g=$(tput setaf 2)
y=$(tput setaf 3)
b=$(tput setaf 4)
m=$(tput setaf 5)
c=$(tput setaf 6)
w=$(tput setaf 7)
N=$(tput setaf 8)
R=$(tput setaf 9)
G=$(tput setaf 10)
Y=$(tput setaf 11)
B=$(tput setaf 12)
M=$(tput setaf 13)
C=$(tput setaf 14)
W=$(tput setaf 15)
END=$(tput sgr0)

HIGH=$(tput bold)
SMUL=$(tput smul)
RMUL=$(tput rmul)
BLINK=$(tput blink)
REVERSE=$(tput smso)
REVERSO=$(tput rmso)

# background
Rn=$(tput setab 0)
Rr=$(tput setab 1)
Rg=$(tput setab 2)
Ry=$(tput setab 3)
Rb=$(tput setab 4)
Rm=$(tput setab 5)
Rc=$(tput setab 6)
Rw=$(tput setab 7)
RN=$(tput setab 8)
RR=$(tput setab 9)
RG=$(tput setab 10)
RY=$(tput setab 11)
RB=$(tput setab 12)
RM=$(tput setab 13)
RC=$(tput setab 14)
RW=$(tput setab 15)
;;
esac

BLUEf=${B}
BLUE=${b}
REDf=${R}
RED=${r}
GREENf=${G}
GREEN=${g}
YELLOWf=${Y}
YELLOW=${y}
MANGENTAf=${M}
MANGENTA=${m}
WHITEf=${W}
WHITE=${w}
CYANf=${C}
CYAN=${c}

OK="${RG}${n}OK${END}"
KO="${RR}${n}KO${END}"
NA="${N}NA${END}"

COLORIZE='eval sed -e "s/{END}/${END}/g" -e "s/{HIGH}/${HIGH}/g" -e "s/{SMUL}/${SMUL}/g" -e "s/{RMUL}/${RMUL}/g" -e "s/{BLINK}/${BLINK}/g" -e "s/{REVERSE}/${REVERSE}/g" -e "s/{REVERSO}/${REVERSO}/g"'
LOWS=' -e "s/{n}/${n}/g" -e "s/{r}/${r}/g" -e "s/{g}/${g}/g" -e "s/{y}/${y}/g" -e "s/{b}/${b}/g" -e "s/{m}/${m}/g" -e "s/{c}/${c}/g" -e "s/{w}/${w}/g"'
HIGHS=' -e "s/{N}/${N}/g" -e "s/{R}/${R}/g" -e "s/{G}/${G}/g" -e "s/{Y}/${Y}/g" -e "s/{B}/${B}/g" -e "s/{M}/${M}/g" -e "s/{C}/${C}/g" -e "s/{W}/${W}/g"'
REVLOWS=' -e "s/{Rn}/${Rn}/g" -e "s/{Rr}/${Rr}/g" -e "s/{Rg}/${Rg}/g" -e "s/{Ry}/${Ry}/g" -e "s/{Rb}/${Rb}/g" -e "s/{Rm}/${Rm}/g" -e "s/{Rc}/${Rc}/g" -e "s/{Rw}/${Rw}/g"'
REVHIGHS=' -e "s/{RN}/${RN}/g" -e "s/{RR}/${RR}/g" -e "s/{RG}/${RG}/g" -e "s/{RY}/${RY}/g" -e "s/{RB}/${RB}/g" -e "s/{RM}/${RM}/g" -e "s/{RC}/${RC}/g" -e "s/{RW}/${RW}/g"'
# COLORIZE Usage:
# command |${COLORIZE} ${LOWS} ${HIGHS} ${REVLOWS} ${REVHIGHS}

set +a
}

2. egrepi

e la funzione egrepi, efficace ed elegante: ciclo di colori tra 8 o più colori (le tue esigenze) E testato su 3 diversi sistemi operativi unix, con commenti:

# egrepi() egrep with 8 REVERSE cyclic colorations on regexps almost like egrep
# egrepi 
# current script will work for KSH88, KSH93, bash 2+, zsh, under AIX / Linux / SunOS
egrepi ()
{
args=$*
# colorList=wBcgymrN                                                # KSH93 or bash 3+, not for AIX
# set -A color                                                  # needed with older sh
color[0]=$Rw; color[1]=$RB; color[2]=$Rc; color[3]=$Rg; color[4]=$Ry; color[5]=$Rm; color[6]=$Rr; color[7]=$RN; # this is the only one AIX solution
i=0
unset argsToGrep argsSedColor argsPerlColor

for arg in ${args}
do
    [ "${arg}" == "." ] && arg=\\.                              # if you wanna grep "."
    # color=R${colorList:((${RANDOM: -1:1})):1}                     # bash RANDOMized colors
    # color=R${colorList:$i:1} && let i++ && ((i==8)) && i=0                # KSH93 or bash 3+, not for AIX
    argsToGrep="${argsToGrep}${argsToGrep:+|}${arg}"
    # argsSedColor="${argsSedColor} -e s#${arg}#$n${!color}&${w}#gI"            # AIX KSH88 do not recognise this fucking variable double expansion
    # argsSedColor="${argsSedColor} -e s#${arg}#$n${color[$i]}&${w}#gI"         # AIX neither do include sed with Ignore case
    argsPerlColor="${argsPerlColor}${argsPerlColor:+,}s#${arg}#$n${color[$i]}$&${END}#gi"   # So: gotta use perl
    let i+=1 && ((i==8)) && i=0                             # AIX KSH88 do not recognise "let i++"
done
# egrep -i "${argsToGrep}" | sed ${argsSedColor} | egrep -v "grep|sed"              # AIX sed incompatibility with Ignore case
# (($# > 0)) && (egrep -i "${argsToGrep}" | perl -p -e ${argsPerlColor}) || cat         # this line colors & grep the words, will NOT act as "tail -f"
(($# > 0)) && (perl -p -e ${argsPerlColor}) || cat                      # this line just colors the words
}

3. Utilizzo

comando | egrepi word1 .. wordN

Potresti anche dare un'occhiata a orologio :

tail -f /var/log/syslog | lwatch --input -

Per quanto riguarda i codici colore, userei tput:

red=$( tput -Txterm setaf 1 )
norm=$( tput -Txterm sgr0 )
bold=$( tput -Txterm bold )

Vedi per riferimento: man tput

Poi:

tail -F myfile.log | sed "s/\(.ERROR.*\)/$red$bold\1$norm/g"

Pubblica qualche tempo fa l'utilità Node Js - log-color-highlight

tail -f file | lch -red error warn -green success
lch -f file -red.bold error warn -underline.bgGreen success