Cómo hacer que la cola muestre salida en color

Me gustaría poder adaptar la salida de un archivo de registro del servidor que tiene mensajes como:

INFO
SEVERE

etc., y si es así SEVERE, muestre la línea en rojo; si es INFOen verde ¿Qué tipo de alias puedo configurar para un tailcomando que me ayudaría a hacer esto?

Prueba multitail . Esta es una übergeneralización de tail -f. Puede ver varios archivos en ventanas separadas, resaltar líneas en función de su contenido y más.

multitail -c /path/to/log

Los colores son configurables. Si el esquema de color predeterminado no funciona para usted, escriba el suyo en el archivo de configuración. Por ejemplo, llame multitail -cS amir_log /path/to/logcon lo siguiente ~/.multitailrc:

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

Otra solución, si está en un servidor donde es inconveniente instalar herramientas no estándar , es combinarlo tail -fcon sed o awk para agregar secuencias de control de selección de color. Esto requiere tail -flimpiar su salida estándar sin demora, incluso cuando su salida estándar es una tubería, no sé si todas las implementaciones hacen esto.

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/'

Si su sed no es GNU sed, reemplácelo \o033por un carácter de escape literal y elimínelo --unbuffered.

Otra posibilidad es ejecutar tail -fen un búfer de shell Emacs y usar las habilidades de coloración de sintaxis de Emacs.

grc , el colorante genérico es genial.

apt-get install grc

Solo haz

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

¡y disfrutar!

También lo encontrarás en GitHub .

¿Has echado un vistazo a ccze ? Tiene la posibilidad de personalizar los colores predeterminados de algunas palabras clave utilizando la opción -co directamente en su archivo de configuración. Si su pantalla se está limpiando después de colorear, debe usar la opción -A.

Editar:

Si realmente desea que la línea completa se coloree en rojo, también puede probar lo siguiente:

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

\e[1;31mte dará el color rojo. Si desea un poco de amarillo, use \e[1;33my para uso verde \e[1;32m. El \e[0mrestaura el color normal del texto.

Eche un vistazo a lnav , el visor avanzado de archivos de registro.

También puede imprimir varios formatos.

Antes de:

Después:

Puede usar el arco iris , que colorea líneas basadas en expresiones regulares:

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

También viene incluido con configuraciones predefinidas , por ejemplo para los registros de Tomcat:

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

(descargo de responsabilidad: yo soy el autor)

Puedes usar colortail :

colortail -f /var/log/messages

También tenga en cuenta que si solo desea buscar una expresión regular coincidente, GNU grep --colorfuncionará, simplemente canalice su tailsalida a través de eso.

Para obtener resultados coloreados de comandos estándar como grep, debe configurar esto aliasen su.bashrc

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

cuando grep algo en su archivo verá algo como esto (pero probablemente en rojo):

[root @ linuxbox mydir] # grep "\ (INFO \ | SEVERE \)" / var / log / logname
esta entrada es una INFORMACIÓN  
GRAVE ¡ esta entrada es una advertencia!
esta entrada es una INFORMACIÓN 
esta entrada es una INFORMACIÓN 
GRAVE ¡ esta entrada es una advertencia!

si quiere usar tailo awky quiere que el color sobreviva a una tubería, entonces el alias no es suficiente y debe usar el --color=alwaysparámetro, por ejemplo:

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

Si desea que el texto en color con awkla historia sea un poco complejo pero más potente, por ejemplo:

[root @ linubox mydir] # tail -f / var / log / messages | awk '{if ($ 5 ~ / INFO /) print "\ 033 [1; 32m" $ 0 "\ 033 [0m"; de lo contrario, si ($ 1 ~ / SEVERE /) imprime "\ 033 [1; 31m" $ 0 "\ 033 [0m"; sino imprimir $ 0} '
esta entrada es una INFORMACIÓN  
GRAVE ¡esta entrada es una advertencia!
esta es otra ENTRADA
esta entrada es una INFO
esta es otra ENTRADA
esta entrada es una INFORMACIÓN 
GRAVE ¡esta entrada es una advertencia!

con cada línea en su propio color.

Hay muchas otras formas de obtener texto coloreado del shell con otras herramientas y otros miembros los describen bien.

Me gusta bastante el colorex . Simple, pero satisfactorio.

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

Basado en la respuesta de @uloBasEI, intenté usarlo ... | perl ... | perl ..., pero Linux pipe se vuelve un poco loco y es demasiado lento. Si pongo todas las reglas en un solo perlcomando, funciona bien.

Por ejemplo, cree un perlarchivo colorTail.pl como se muestra a continuación:

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

Úselo como:

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

NOTA: ¡también puede usarlo en MobaXTerm ! Simplemente descargue el perlcomplemento del sitio MobaXTerm .

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

Una solución que funciona para colorear todo tipo de texto, no solo archivos de registro, es una herramienta de Python, ' colout '.

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

Donde cualquier texto en la salida de 'myprocess' que coincida con el grupo 1 de la expresión regular se coloreará con color1, grupo 2 con color2, etc.

Por ejemplo:

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

es decir, el primer grupo de expresiones regulares (parens) coincide con la fecha inicial en el archivo de registro, el segundo grupo coincide con un nombre de archivo de Python, número de línea y nombre de función, y el tercer grupo coincide con el mensaje de registro que viene después de eso. Esto se ve así:

Tenga en cuenta que las líneas o partes de líneas que no coinciden con ninguna de mis expresiones regulares todavía tienen eco, por lo que esto no es como 'grep --color': nada se filtra de la salida.

Obviamente, esto es lo suficientemente flexible como para que pueda usarlo con cualquier proceso, no solo siguiendo archivos de registro. Por lo general, solo preparo una nueva expresión regular sobre la marcha cada vez que quiero colorear algo. Por esta razón, prefiero colout a cualquier herramienta personalizada para colorear archivos de registro, porque solo necesito aprender una herramienta, independientemente de lo que esté coloreando: registro, salida de prueba, fragmentos de código de resaltado de sintaxis en el terminal, etc.

Plug descarado: escribí una herramienta llamada TxtStyle que hace algo similar a las opciones mencionadas anteriormente. Puede ejecutarlo de la siguiente manera:

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

También puede definir estilos con nombre en el archivo de configuración ( ~/.txts.conf) y usarlo así:

ifconfig | txts --name ifconfig

(el ifconfigestilo se define fuera de la caja)

grc seguro!

Personalice sus collors con expresiones regulares en el archivo: ~ .grc / conf.tail (o el nombre que desee)

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

línea de comando:

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

resultados:

información para configurar grc: https://github.com/manjuraj/config/blob/master/.grc/sample.conf

Escribí una función bash que acepta hasta tres parámetros y hace un filtro grep en un archivo de texto, y envía el texto a la pantalla en color.

También me gustaría ver una función de cola que haga esto, pero aún no he encontrado una.

Esta función también se puede mejorar: agradecería cualquier ayuda sobre cómo mejorarla.

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
}

seguro !

Escribí durante mucho tiempo una función llamada "egrepi", basada en las 8 definiciones de variables de color. Esto funciona ÚNICAMENTE canalizado como una función coloreada "tail -f".

1. setColors

primero, las variables de color funcionan al principio:

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

y la función egrepi, efectiva y elegante: ciclo de color entre 8 o más colores (sus necesidades) Y probado en 3 sistemas operativos Unix diferentes, con comentarios:

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

comando | egrepi word1 .. wordN

También es posible que desee echar un vistazo a lwatch :

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

En cuanto a los códigos de color, usaría tput:

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

Ver para referencia: man tput

Entonces:

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

Publicado hace algún tiempo Node Js utility - log-color-highlight

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