it-swarm.it

Come fare in modo che tail -f mostri un output colorato

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 è SEVERE, mostra la linea in rosso; se è INFO, in verde. Che tipo di alias posso impostare per un comando tail che mi possa aiutare a fare questo?

277
Amir Afghani

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, chiama multitail -cS amir_log /path/to/log con 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 , è combinare tail -f con sed o awk per aggiungere sequenze di controllo di selezione del colore. Questo richiede tail -f per 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 la tua sed non è GNU sed, sostituisci \o033 da un carattere letterale di escape e rimuovi --unbuffered.

Un'altra possibilità è eseguire tail -f in un Emacs Buffer di shell e usa 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 .

127
thias

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

Edit:

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;31m ti darà il colore rosso. Se desideri un po 'di giallo, usa \e[1;33m e per uso ecologico \e[1;32m. Il \e[0m ripristina il normale colore del testo.

52
uloBasEI

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

lnavlnav

Può anche stampare abbastanza vari formati.

Prima:

lnav-before-pretty

Dopo:

lnav-pretty

38
bagonyi

Puoi usare Rainbow , 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)

25
nicoulaj

Puoi usare colortail :

colortail -f /var/log/messages
16
Kartik M

Nota anche che se vuoi solo cercare no regex corrispondente, GNU grep con --color funzionerà - basta reindirizzare il tuo output tail attraverso quello.

12
mattdm

Per ottenere un output colorato da comandi standard come grep, dovresti impostare questo alias nel tuo .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 è una INFORMAZIONIACUTO questa voce è un avvertimento! 
 questa voce è un INFORMAZIONI
 questa voce è una INFORMAZIONIACUTO questa voce è un avvertimento!

se vuoi usare tail o awk e vuoi che il colore sopravviva a una pipe, allora l'alias non è abbastanza e dovresti usare --color=always parametro, ad esempio:

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

Se vuoi un testo a colori con awk la storia è un po 'complessa 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"; else print $ 0} '
 questa voce è una INFORMAZIONISEMPRE questa voce è un avvertimento!
 questa è un'altra ENTRATA 
questa voce è un INFO
 questa è un'altra ENTRATA 
questa voce è un INFOSEMPRE questa voce è un avvertimento!

con ogni riga nel suo colore.

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

9
tombolinux

Mi piace molto colorex . Semplice ma soddisfacente.

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

Sulla base della risposta @uloBasEI, ho provato a utilizzare ... | Perl ... | Perl ..., ma Linux pipe diventa un po 'pazzo ed è troppo lento. Se inserisco tutte le regole in un solo comando Perl, funziona perfettamente.

Ad esempio, crea un file PerlcolorTail.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 Perl plug-in dal sito MobaXTerm .

6
surfealokesea
tail -f /var/log/logname | source-highlight -f esc -s log
3
user5771

Una soluzione che funziona per colorare tutti i tipi di testo, non solo i file di registro, è un 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

cioè il primo gruppo regex (parentesi) corrisponde alla data iniziale nel file di registro, il secondo gruppo corrisponde a python nomefile, numero di riga e nome della funzione, e il terzo gruppo corrisponde al messaggio di registro che viene dopo Questo sembra:

logfile with colored formatting

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.

3
Jonathan Hartley

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

risultati: screenshot

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

2
Flavio

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 di configurazione (~/.txts.conf) e usalo così:

ifconfig | txts --name ifconfig

(ifconfig lo stile è definito fuori dalla scatola)

2
armandino

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 "[email protected]"
        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
}
1
Steve Warren

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
}

. Utilizzo

comando | egrepi Word1 .. wordN

1
scavenger

Per quanto riguarda i codici colore, userei tput:

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

Vedere per riferimento: man tput

Poi:

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

Potresti anche dare un'occhiata a orologio :

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

1
Michael Krupp

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

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