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?
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.
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.
Jetez un œil à lnav , la visionneuse de fichiers journaux avancée.
Il peut également imprimer de nombreux formats.
Avant:
Après:
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)
Vous pouvez utiliser colortail :
colortail -f /var/log/messages
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.
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ÈRESi 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.
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)
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 .
tail -f /var/log/logname | source-highlight -f esc -s log
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:
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.
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: 
informations pour configurer grc: https://github.com/manjuraj/config/blob/master/.grc/sample.conf
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)
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 "$@"
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 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
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"
Vous voudrez peut-être aussi jeter un œil à lwatch :
tail -f /var/log/syslog | lwatch --input -
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