it-swarm-eu.dev

Comment afficher la sortie colorée tail -f

Je voudrais pouvoir suivre la sortie d'un fichier journal de serveur qui contient des messages comme:

INFO
SEVERE

etc, et si c'est SEVERE, affichez la ligne en rouge; si c'est INFO, en vert. Quel type d'alias puis-je configurer pour une commande tail qui pourrait m'aider à le faire?

277
Amir Afghani

Essayez ( multitail . Il s'agit d'une übergénéralisation de tail -f. Vous pouvez regarder plusieurs fichiers dans des fenêtres distinctes, mettre en surbrillance 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/log avec 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 n'est pas pratique d'installer des outils non - standard , est de combiner tail -f avec sed ou awk pour ajouter des séquences de contrôle de sélection des couleurs. Cela nécessite tail -f pour vider sa sortie standard sans délai même lorsque sa sortie standard est un tube, 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 \o033 par un caractère d'échappement littéral et supprimez --unbuffered.

Une autre possibilité consiste à exécuter tail -f dans un Emacs tampon Shell et utiliser les capacités de coloration syntaxique d'Emacs.

grc , le colorant générique est plutôt cool.

apt-get install grc

Fais juste

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

et apprécie!

Vous le trouverez également sur GitHub .

127
thias

Avez-vous jeté un coup d'œil à ccze ? Vous avez la possibilité de personnaliser les couleurs par défaut de certains mots clés en utilisant l'option -c ou 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;31m vous donnera la couleur rouge. Si vous souhaitez du jaune, utilisez \e[1;33m, et pour une utilisation écologique \e[1;32m. Le \e[0m restaure la couleur normale du texte.

52
uloBasEI

Jetez un œil à lnav , la visionneuse de fichiers journaux avancée.

lnavlnav

Il peut également imprimer de nombreux formats.

Avant:

lnav-before-pretty

Après:

lnav-pretty

38
bagonyi

Vous pouvez utiliser Rainbow , qui colorise les lignes en fonction des expressions régulières:

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

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

Rainbow --config=Tomcat tail -f my-file.log

(Avertissement: je suis l'auteur)

25
nicoulaj

Vous pouvez utiliser colortail :

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

Notez également que si vous souhaitez simplement rechercher n expression rationnelle correspondante, GNU grep avec --color fonctionnera - il suffit de diriger votre sortie tail à travers cela.

12
mattdm

Pour obtenir une sortie colorée à partir de commandes standard comme grep, vous devez définir ce alias dans votre .bashrc

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

lorsque vous grep quelque chose dans votre fichier, vous voyez quelque chose comme ça, (mais probablement en rouge):

[root @ linuxbox mydir] # grep "\ (INFO\| SEVERE \)" /var/log/logname[.____.[ cette entrée est un INFOSÉVÈRE cette entrée est un avertissement! 
 cette entrée est un INFO
 cette entrée est un INFOSÉVÈRE cette entrée est un avertissement!

si vous souhaitez utiliser tail ou awk et que la couleur doit survivre à un tuyau, l'alias n'est pas suffisant et vous devez utiliser le --color=always paramètre, par exemple:

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

Si vous voulez du texte en couleur avec awk l'histoire est un peu complexe mais plus puissante, par exemple:

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

avec chaque ligne dans sa propre couleur.

Il existe de nombreuses autres façons d'obtenir du texte colorisé à partir de Shell avec d'autres outils et ils sont bien décrits par les autres membres.

9
tombolinux

J'aime bien colorex . Simple mais satisfaisant.

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

Sur la base de la réponse @uloBasEI, j'ai essayé d'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 commande Perl, cela fonctionne très bien.

Par exemple, créez un fichier PerlcolorTail.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

REMARQUE: vous pouvez également l'utiliser sur MobaXTerm ! Il suffit de télécharger le plug-in Perl depuis le site MobaXTerm .

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

Une solution qui fonctionne pour colorer toutes sortes de texte, pas seulement les fichiers journaux, est un 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 l'expression régulière sera coloré avec color1, 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 d'expression régulière (parens) correspond à la date initiale dans le fichier journal, le deuxième groupe correspond à un python nom de fichier, numéro de ligne et nom de la fonction, et le troisième groupe correspond au message de journal qui vient après Cela ressemble à ceci:

logfile with colored formatting

Notez que les lignes ou parties de lignes qui ne correspondent à aucun de mes regex sont toujours répercutées, donc ce n'est pas comme 'grep --color' - rien n'est filtré hors de la sortie.

De toute évidence, cela est suffisamment flexible pour que vous puissiez l'utiliser avec n'importe quel processus, pas seulement avec des fichiers journaux. Habituellement, je prépare un nouveau 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, indépendamment de ce que je colore: journalisation, sortie de test, syntaxe mettant en évidence des extraits de code dans le terminal, etc.

3
Jonathan Hartley

grc à coup sûr!

personnalisez vos collors avec regex dans le fichier: ~ .grc/conf.tail (ou quel que soit le nom que vous voulez)

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: screenshot

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

2
Flavio

Plug sans vergogne: 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 utilisez-le comme ceci:

ifconfig | txts --name ifconfig

(ifconfig le style est défini par défaut)

2
armandino

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

J'aimerais également 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 pour 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 "[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

sûr !

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

1. SetColors

tout d'abord, la fonction des variables de couleur à appeler dans un premier temps:


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: cycle de couleurs entre 8 couleurs ou plus (vos besoins) ET testé sous 3 OS Unix différents, avec commentaires:


# 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
}

. Utilisation

commande | egrepi Word1 .. wordN

1
scavenger

Quant aux codes couleurs, j'utiliserais tput:

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

Voir pour référence: man tput

Alors:

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

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

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

1
Michael Krupp

Publie il y a quelque temps Node Utilitaire 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