Cómo hacer que la cola muestre salida en color

265

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?

Amir Afghani
fuente
una línea sed: stackoverflow.com/a/14691971/52074
Trevor Boyd Smith

Respuestas:

235

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.

Gilles
fuente
¿Cómo puedes hacer esto sed? (lo siento por ser flojo y no resolverlo yo mismo!) Pero, ¿podría agregar un sedejemplo también?
Ali
55
@Ali Sed es menos conveniente porque no tiene una sintaxis para el carácter de escape, debe tenerlo literalmente en el script o usar un método de comillas para trabajarlo. Recomiendo que use awk.
Gilles
8
@Gilles En su código tail -fwith awk, si una cadena no tiene INFO y SEVERE , la cadena no se imprimirá. ¿Cómo puedo imprimir las permanecer cadenas tampoco? (La cuerda no necesita ser coloreada)
Benjamin
66
@Benjamin Agregue ; nextantes de las llaves de cierre para omitir el procesamiento adicional y una nueva línea de procesamiento 1 {print}al final ( 1significa siempre).
Gilles
3
sed --unbuffered -e 's/\(.*FATAL.*\)/\o033[1;31m\1\o033[0;39m/' -e 's/\(.*ERROR.*\)/\o033[31m\1\o033[39m/' -e 's/\(.*WARN.*\)/\o033[33m\1\o033[39m/' -e 's/\(.*INFO.*\)/\o033[32m\1\o033[39m/' -e 's/\(.*DEBUG.*\)/\o033[34m\1\o033[39m/' -e 's/\(.*TRACE.*\)/\o033[30m\1\o033[39m/' -e 's/\(.*[Ee]xception.*\)/\o033[1;39m\1\o033[0;39m/'
DmitrySandalov
121

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 .

thias
fuente
2
Esto es exactamente lo que necesitaba: ligero y simple. El color no es exactamente el adecuado para mis tipos de registro (registros personalizados), pero cualquier color me facilita seguir un registro.
rennat
Para mí 'grc' en errores de Debian con: OSError: [Errno 13] Permiso denegado. También depende de que Python esté instalado, por lo que no es relativamente liviano a menos que ya lo tenga. He encontrado que 'ccze' funciona mucho mejor, ej. 'tail -f -n 50 /var/log/starbound-server.log | ccze -A '.
Daniel Sokolowski, el
1
La configuración predeterminada de grc en Ubuntu no se muestra bien para syslogs o mail.log. No es fácil entender cómo personalizarlo.
lepe
1
Encontré una forma más rápida y fácil de colorear que el multitail. Acabo de hacer una instalación rápida a través de la fuente en mi sistema CentOS y actualicé mi vida. También se instalará en mis otros sistemas.
zeeshan
44
Esto se ve bastante terrible en los registros de nginx i.imgur.com/aJbIOfL.png
mpen
51

¿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.

uloBasEI
fuente
1
Esto no funciona en Mac: lo estoy votando porque funciona en Linux.
Amir Afghani
Upvoting porque si bien el truco perl / ansi podría no serlo, ccze sí.
Shadur
1
También puede hacer que su terminal de enviar una alerta o "bip" añadiendo \007al final de la expresión regular, así: perl -pe 's/(ERROR)/\033[31m$1\033[0m\007/g;'. Esto funciona de maravilla si está utilizando tmux con set -g bell-action any, en cuyo caso si su registro sigue en otra ventana, el nombre de esa ventana alertará cada vez que la expresión regular encuentre una coincidencia.
jonyamo
@AmirAfghani Este es un sitio SE de Linux / Unix, por lo tanto, no estoy seguro de por qué pensaste que funcionaría en Mac.
B 4овић
1
@ BЈовић Mac es un Unix.
Chris Down
34

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

lnav lnav

También puede imprimir varios formatos.

Antes de:

lnav-before-pretty

Después:

lnav-pretty

Bagonyi
fuente
Una adición realmente genial al kit de herramientas de análisis de registro. Gracias por la sugerencia.
Patrik Alienus
24

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)

nicoulaj
fuente
2
Intenté la mayoría de las otras soluciones ofrecidas para esta pregunta, pero Rainbow fue la única que funcionó igualmente bien en Sun, Aix, Linux, Termux, Darwin y Cygwin: los 6 (!) Entornos que uso a diario. Todos los demás involucraron procesos de construcción no portátiles difíciles para al menos algunas plataformas.
Stabledog
1
rainbowes increíble. ¿Eres el autor? Si es así, edite su respuesta con esa atribución.
obispo
sí, lo siento, editado
nicoulaj
15

Puedes usar colortail :

colortail -f /var/log/messages
Kartik M
fuente
2
+1 disponible en repositorios de Ubuntu. Lo que me gusta de colortail en comparación con ccze es que puede personalizar libremente sus patrones con RegEx. Colores disponibles: negro, negro brillante, blanco, blanco brillante, magenta, magenta brillante, cian, cian brillante, verde, verde brillante, amarillo, amarillo brillante, rojo, rojo brillante, azul, azul brillante. Lamentablemente, no hay forma de establecer colores llamativos u otros colores como el naranja.
lepe
Me gustaría corregir un punto sobre mi comentario anterior: "brillante" + color incluye "negrita" (algunos colores también se verán más brillantes)
lepe
Intenté esto en Ubuntu 18 y no funcionó. La configuración es de varios pasos y las instrucciones son ambiguas. Todavía no estoy seguro de que esa es la parte que me equivoqué; la última parte puede aclararse "Después de eso es posible que desee copiar y editar los archivos de configuración de ejemplo en otro lugar. Los tengo en ~ / .colortail /"
Dawoodjee
Simplemente instale colortail con, apt install colortaily debería funcionar sin editar ~ / .colortail / también.
Kartik M
11

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.

mattdm
fuente
El OP solo quería resaltar la salida, no filtrarla. Grep no mostrará líneas que no coincidan ...
Coderer
3
Si dice grep  -A9999  -B9999 regex, mostrará todas las líneas a menos que tenga 10,000 líneas no coincidentes en una fila. Use algo como GREP_COLORS="ms=31:sl=33:cx=32" grep -A9999 -B9999 SEVEREmostrar la palabra SEVEREen rojo, el resto de las líneas SEVERAS en amarillo y todas las demás líneas (no SEVERAS) (hasta 9999) en verde.
G-Man el
Es posible que deba pasar --color=alwaysa grep en lugar de solo --color, dependiendo del orden de su tubería, pero sí, esto funciona a la cola (GNU coreutils) 8.27 instalado en mi caja.
Hank Schultz
7

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.

Tombolinux
fuente
7

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)
Brian M. Hunt
fuente
12
¿Cómo es eso simple?
Eliran Malka
6

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 .

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

fuente
77
source-highlightno es un comando ampliamente instalado, por lo que al menos debería dar un enlace al sitio del proyecto.
Gilles
Disponible en Fedora 19.
sjas
Y Ubuntu 12.10.
sjas
Se ve bien. Es un gran paquete en comparación con otros en esta lista (26 MB). Es compatible con una gran lista de idiomas. Se puede personalizar modificando los archivos de configuración ubicados en: /usr/share/source-highlight/*.lang (Ubuntu). Si necesita algo simple, vaya con ccze o colortail.
lepe
parece que depende del impulso, que ronda los 462 MB
ecsos
3

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

archivo de registro con formato de color

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.

Jonathan Hartley
fuente
1
No he visto una sola respuesta que modifique el archivo de registro de origen
Dani_l
@Dani_l ¡Tienes razón! En el momento en que escribí esto, debo haberme confundido al pasar de esta pregunta a otra similar, a la que muchas de las respuestas se referían a cómo configurar el registro de modo que los caracteres ANSI se escribieran directamente en el archivo de registro. Eliminaré esa queja de mi respuesta.
Jonathan Hartley
2

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)

Armandino
fuente
2

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: captura de pantalla

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

Flavio
fuente
1

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
}
Steve Warren
fuente
1

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

carroñero
fuente
1

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

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

Michael Krupp
fuente
1

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"
Fabien Bouleau
fuente
Muchas gracias. Funciona como un encanto con funciones estándar de shell.
vquintans
0

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
gliviu
fuente