Comment avoir tail -f show color output

J'aimerais pouvoir rédiger la sortie d'un fichier journal du serveur contenant des messages tels que:

INFO
SEVERE

etc, et si c'est le cas SEVERE, affichez la ligne en rouge; si c'est INFOen vert. Quel type d'alias puis-je configurer pour une tailcommande qui m'aiderait à le faire?

Essayez le multitail . C'est une übergeneralization of tail -f. Vous pouvez regarder plusieurs fichiers dans des fenêtres séparées, mettre en évidence des lignes en fonction de leur contenu, etc.

multitail -c /path/to/log

Les couleurs sont configurables. Si le jeu de couleurs par défaut ne fonctionne pas pour vous, écrivez le vôtre dans le fichier de configuration. Par exemple, appelez multitail -cS amir_log /path/to/logavec ce qui suit ~/.multitailrc:

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

Une autre solution, si vous êtes sur un serveur où il est gênant d'installer des outils non standard , consiste à combiner tail -favec sed ou awk pour ajouter des séquences de contrôle de sélection de couleur. Cela nécessite tail -fde vider sa sortie standard sans délai même lorsque sa sortie standard est un tuyau, je ne sais pas si toutes les implémentations le font.

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

ou avec sed

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

Si votre sed n'est pas GNU sed, remplacez-le \o033par un caractère d'échappement littéral et supprimez-le --unbuffered.

Une autre possibilité consiste à exécuter tail -fdans un tampon shell Emacs et à utiliser les capacités de coloration syntaxique d’Emacs.

grc , le colorant générique est assez cool.

apt-get install grc

Il suffit de faire

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

et apprécie!

Vous le trouverez également sur GitHub .

Avez-vous examiné ccze ? Vous avez la possibilité de personnaliser les couleurs par défaut de certains mots-clés à l'aide de l'option -cou directement dans votre fichier de configuration. Si votre écran s'efface après la colorisation, vous devez utiliser l'option -A.

Modifier:

Si vous souhaitez vraiment que la ligne complète soit colorée en rouge, vous pouvez également essayer les éléments suivants:

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

\e[1;31mvous donnera la couleur rouge. Si vous voulez un peu de jaune, l' utilisation \e[1;33m, et pour une utilisation verte \e[1;32m. Le \e[0mrestaure la couleur normale du texte.

Jetez un coup d’œil à lnav , l’afficheur avancé de fichiers journaux.

Il peut également imprimer divers formats.

Avant:

Après:

Vous pouvez utiliser rainbow , qui colorise les lignes en fonction d'expressions régulières:

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

Il est également fourni avec des configurations prédéfinies , par exemple pour les journaux Tomcat:

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

(disclaimer: je suis l'auteur)

Vous pouvez utiliser colortail :

colortail -f /var/log/messages

Notez également que si vous voulez juste chercher une expression rationnelle correspondante, GNU grep --colorfonctionnera - liez simplement votre tailsortie à travers cela.

Pour obtenir une sortie colorée à partir de commandes standard grep, vous devez définir ceci aliasdans votre.bashrc

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

quand vous grep quelque chose dans votre fichier vous voyez quelque chose comme ceci (mais probablement en rouge):

[root @ linuxbox mydir] # grep "\ (INFO \ | SEVERE \)" / var / log / logname
cette entrée est une info  
grave cette entrée est un avertissement!
cette entrée est une INFO 
cette entrée est une INFO 
SEVERE cette entrée est un avertissement!

si vous voulez utiliser tailou awket que la couleur reste dans un tube, l'alias ne suffit pas et vous devez utiliser le --color=alwaysparamètre, par exemple:

[root @ linubox mydir] # grep --color = toujours "\ (INFO \ | SEVERE \)" / var / log / logname | queue -f | awk '{print $ 1}'
cette 
SÉVÈRE
cette
cette
SÉVÈRE

Si vous voulez que le texte en couleur avec awkl'histoire soit un peu complexe mais plus puissant, par exemple:

[root @ linubox mydir] # tail -f / var / log / messages | awk '{if ($ 5 ~ / INFO /) print "\ 033 [1; 32m" $ 0 "\ 033 [0m"; else if ($ 1 ~ / SEVERE /) affiche "\ 033 [1; 31m" $ 0 "\ 033 [0m"; sinon imprimer $ 0} '
cette entrée est une INFO  
SEVERE cette entrée est un avertissement!
c'est une autre entrée
cette entrée est une INFO
c'est une autre entrée
cette entrée est une info 
grave cette entrée est un avertissement!

avec chaque ligne dans sa propre couleur.

Il existe de nombreuses autres manières d’obtenir un texte colorisé à partir d’un shell avec d’autres outils et ils sont bien décrits par les autres membres.

J'aime assez colorex . Simple mais satisfaisant.

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

Sur la base de la réponse @uloBasEI, j'ai essayé de l'utiliser ... | perl ... | perl ..., mais le pipe Linux devient un peu fou et est trop lent. Si je mets toutes les règles dans une seule perlcommande, cela fonctionne bien.

Par exemple, créez un perlfichier colorTail.pl comme ci-dessous:

#!/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";
}

Utilisez-le comme:

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

NOTE: vous pouvez aussi l'utiliser sur MobaXTerm ! Il suffit de télécharger le perlplug-in à partir du site MobaXTerm .

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

Une solution qui fonctionne pour colorer toutes sortes de texte, et pas seulement les fichiers journaux, est un outil Python, " colout ".

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

Où tout texte dans la sortie de 'myprocess' qui correspond au groupe 1 de la regex sera coloré avec color1, le groupe 2 avec color2, etc.

Par exemple:

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

c'est-à-dire que le premier groupe de regex (parent) correspond à la date initiale dans le fichier journal, le deuxième groupe correspond au nom de fichier python, au numéro de ligne et au nom de la fonction, et le troisième groupe correspond au message de journal qui suit. Cela ressemble à:

Notez que les lignes ou parties de lignes qui ne correspondent à aucune de mes expressions rationnelles sont toujours répercutées. Ce n'est donc pas comme 'grep --color' - rien n'est filtré dans la sortie.

De toute évidence, cela est suffisamment flexible pour que vous puissiez l’utiliser avec n’importe quel processus, pas seulement avec les fichiers journaux. Habituellement, je crée simplement une nouvelle regex à la volée chaque fois que je veux coloriser quelque chose. Pour cette raison, je préfère colout à tout outil de coloration de fichier journal personnalisé, car je n'ai besoin d'apprendre qu'un seul outil, quel que soit le processus de coloration: journalisation, sortie de test, coloration syntaxique d'extraits de code dans le terminal, etc.

Prise sans scrupule : j'ai écrit un outil appelé TxtStyle qui fait quelque chose de similaire aux options mentionnées précédemment. Vous pouvez l'exécuter comme suit:

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

Vous pouvez également définir des styles nommés dans le fichier de configuration ( ~/.txts.conf) et les utiliser comme suit:

ifconfig | txts --name ifconfig

(le ifconfigstyle est défini hors de la boîte)

grc à coup sûr!

personnalisez vos collaborateurs avec regex dans le fichier: ~ .grc / conf.tail (ou le nom de votre choix)

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

ligne de commande:

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

résultats:

info pour configurer grc: https://github.com/manjuraj/config/blob/master/.grc/sample.conf

J'ai écrit une fonction bash qui accepte jusqu'à trois paramètres et effectue un filtre de type grep sur un fichier texte et affiche le texte à l'écran en couleur.

J'aimerais aussi voir une fonction de queue qui ferait cela, mais je n'en ai pas encore trouvé.

Cette fonction peut également être améliorée - j'apprécierais toute aide sur la façon de l'améliorer.

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
}

sûr !

J'ai longtemps écrit une fonction appelée "egrepi", basée sur les 8 définitions de variables de couleur. Cela fonctionne UNIQUEMENT comme une fonction colorée "tail -f".

1. setColors

tout d'abord, les variables de couleur doivent être appelées en premier:

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

et la fonction egrepi, efficace et élégante: le cycle de couleur entre 8 couleurs ou plus (vos besoins) ET testé sous 3 systèmes d’exploitation unix différents, avec les commentaires suivants:

# 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. utilisation

commande | egrepi word1 .. wordN

Vous voudrez peut-être aussi jeter un coup d'œil à lwatch :

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

En ce qui concerne les codes de couleur, j’utiliserais tput:

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

Voir pour référence: man tput

Ensuite:

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

Publie il y a quelque temps l'utilitaire Node Js - log-color-highlight

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