Como ter cauda -f mostrar saída colorida


Respostas:


234

Experimente multitail . Esta é uma generalização de tail -f. Você pode assistir a vários arquivos em janelas separadas, destacar linhas com base no conteúdo e muito mais.

multitail -c /path/to/log

As cores são configuráveis. Se o esquema de cores padrão não funcionar, escreva seu próprio arquivo de configuração. Por exemplo, ligue multitail -cS amir_log /path/to/logcom o seguinte ~/.multitailrc:

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

Outra solução, se você estiver em um servidor onde é inconveniente instalar ferramentas não padrão , é combinar tail -fcom sed ou awk para adicionar sequências de controle de seleção de cores. Isso requer tail -fliberar sua saída padrão sem demora, mesmo quando sua saída padrão é um pipe, não sei se todas as implementações fazem isso.

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

ou com sed

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

Se seu sed não for GNU sed, substitua \o033por um caractere de escape literal e remova --unbuffered.

Outra possibilidade é executar tail -fum buffer de shell do Emacs e usar as habilidades de coloração de sintaxe do Emacs.


como você pode fazer isso sed? (desculpe-me por ser preguiçoso e não descobrir isso por conta própria!) Mas você poderia adicionar um sedexemplo também.
Ali

5
O Ali Sed é menos conveniente porque não possui uma sintaxe para o caractere de escape, você precisa literalmente no script ou usar um método de citação de shell para trabalhar. Recomendamos que você use o awk.
Gilles

8
@Gilles Em sua tail -fcom awkcódigo, se uma cadeia não tem INFO e GRAVE , a string é não ser impressa. Como também posso imprimir as seqüências restantes ? (A seqüência de caracteres não precisa ser colorido)
Benjamin

6
@ Benjamin Adicione ; nextantes das chaves de fechamento para pular o processamento adicional e uma nova linha de processamento 1 {print}no final ( 1significa sempre).
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

120

grc , o corante genérico é bem legal.

apt-get install grc

Apenas faça

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

e aproveitar!

Você também o encontrará no GitHub .


2
Era exatamente disso que eu precisava: leve e simples. A coloração não é exatamente correta para meus tipos de log (logs personalizados), mas qualquer coloração facilita o acompanhamento de um log.
rennat 21/10

Para mim 'grc' nos erros do Debian lançados com: OSError: [Erro 13] Permissão negada. Também depende da instalação do Python, por isso não é muito leve, a menos que você já o tenha. Eu descobri que 'ccze' funciona muito melhor, ex. 'tail -f -n 50 /var/log/starbound-server.log | ccze -A '.
precisa

1
As configurações padrão do grc no Ubuntu não eram boas para syslogs ou mail.log. Não é fácil entender como personalizá-lo.
Lepe

1
Eu achei a maneira mais rápida e fácil de colorir do que a multitail. Acabei de fazer uma instalação rápida via fonte no meu sistema CentOS e atualizei minha vida. Também instalarei nos meus outros sistemas.
zeeshan

4
Isso parece muito terrível em registros nginx i.imgur.com/aJbIOfL.png
MPEN

51

Você já deu uma olhada no ccze ? Você tem a possibilidade de personalizar as cores padrão de algumas palavras-chave usando a opção -cou diretamente no seu arquivo de configuração. Se sua tela é limpar depois de colorir você deve usar a opção -A.

Editar:

Se você realmente deseja que a linha completa seja colorida em vermelho, tente também o seguinte:

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

\e[1;31mvai te dar a cor vermelha. Se você quiser um pouco de amarelo, use \e[1;33me para verde \e[1;32m. O \e[0mrestaura a cor do texto normal.


1
Isso não funciona no Mac - eu estou votando porque funciona no Linux.
Amir Afghani 01/03

Voto positivo porque, embora o truque perl / ansi não o faça, o ccze o faz.
Shadur

1
Você pode também fazer o seu terminal enviar um alerta ou "beep", adicionando \007ao fim do regex, assim: perl -pe 's/(ERROR)/\033[31m$1\033[0m\007/g;'. Isso funciona de maneira impressionante se você estiver usando o tmux com set -g bell-action any, nesse caso, se o seu log estiver em outra janela, o nome dessa janela será alertado sempre que o regex encontrar uma correspondência.
jonyamo

@AmirAfghani Este é um site linux / unix SE, portanto, não sei por que você pensou que funcionaria no mac.
BЈовић

1
@ Bћовић Mac é um Unix.
Chris Baixo

34

Dê uma olhada no lnav , o visualizador avançado de arquivos de log.

INAV INAV

Também pode imprimir vários formatos.

Antes:

lnav-before-pretty

Depois de:

lnav-pretty


Adição muito interessante ao kit de ferramentas de análise de log. Obrigado pela sugestão.
Patrik Alienus

24

Você pode usar o arco-íris , que colore linhas com base em expressões regulares:

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

Ele também vem com configurações predefinidas , por exemplo, para logs do Tomcat:

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

(aviso: eu sou o autor)


2
Tentei a maioria das outras soluções oferecidas a essa pergunta, mas o arco-íris foi o único que funcionou igualmente bem em sol, aix, linux, termux, darwin e cygwin - os 6 (!) Ambientes que uso diariamente. Todos os outros envolveram processos difíceis de compilação não portátil para pelo menos algumas plataformas.
Stabledog 17/05/19

1
rainbowé incrível. Você é o autor? Nesse caso, edite sua resposta com essa atribuição.
bispo

sim, desculpe, editado
nicoulaj 20/09

15

Você pode usar o colortail :

colortail -f /var/log/messages

2
+1 disponível nos repositórios do Ubuntu. O que eu gosto no colortail em comparação ao ccze é que você pode personalizar livremente seus padrões usando o RegEx. Cores disponíveis: preto, preto brilhante, branco, branco brilhante, magenta, brilhante magenta, ciano, brilhante ciano, verde, verde brilhante, amarelo, amarelo brilhante, vermelho, brilhante, azul, azul brilhante. Infelizmente, não há como definir cores ousadas ou outras como laranja.
Lepe

Gostaria de corrigir um ponto sobre o meu comentário anterior: "brilhante" + cores inclui "negrito" (algumas cores vão realmente olhar mais brilhante também)
Lepe

Eu tentei isso no Ubuntu 18 e não funcionou. A configuração é de várias etapas e as instruções são ambíguas. Ainda não tenho certeza de que foi a parte que eu errei; a última parte pode ficar mais clara "Depois disso, você pode copiar e editar os arquivos de configuração de exemplo para outro lugar. Eu os tenho em ~ / .colortail /"
Dawoodjee

Basta instalar o colortail com, apt install colortaile ele deve funcionar sem editar ~ / .colortail / também.
Kartik M

11

Observe também que, se você quiser apenas procurar um regex correspondente, o GNU grep with --colorfuncionará - basta canalizar sua tailsaída por isso.


O OP só queria destacar a saída, não filtrá-la. Grep não mostrará linhas não correspondentes ...
Coderer

3
Se você disser grep  -A9999  -B9999 regex, ele mostrará todas as linhas, a menos que você tenha 10.000 linhas não correspondentes seguidas. Use algo como GREP_COLORS="ms=31:sl=33:cx=32" grep -A9999 -B9999 SEVEREpara mostrar a palavra SEVEREem vermelho, as demais linhas SEVERAS em amarelo e todas as outras linhas (não SEVERAS) (até 9999) em verde.
G-Man

Você pode precisar passar --color=alwayspara grep em vez de apenas --color, dependendo da ordem do seu pipe, mas sim, isso funciona (GNU coreutils) 8.27 instalado na minha caixa.
Hank Schultz

7

Para obter saída colorida de comandos padrão como grep, você deve configurá-lo aliasem seu.bashrc

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

quando você grep algo em seu arquivo, você vê algo parecido com isto (mas provavelmente em vermelho):

[root @ linuxbox mydir] # grep "\ (INFO \ | SEVERE \)" / var / log / logname
esta entrada é uma INFO  
SEVERE esta entrada é um aviso!
esta entrada é uma INFO 
esta entrada é uma INFO 
SEVERE esta entrada é um aviso!

se quiser usar tailoue awkdesejar que a cor sobreviva a um pipe, o alias não será suficiente e você deverá usar o --color=alwaysparâmetro, por exemplo:

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

Se você deseja que o texto colorido awkda história seja um pouco complexo, mas mais poderoso, por exemplo:

[root @ linubox mydir] # tail -f / var / log / messages | awk '{if ($ 5 ~ / INFO /) imprime "\ 033 [1; 32m" $ 0 "\ 033 [0m"; caso contrário, se ($ 1 ~ / SEVERE /) imprimir "\ 033 [1; 31m" $ 0 "\ 033 [0m"; mais imprima $ 0} '
esta entrada é uma INFO  
SEVERE esta entrada é um aviso!
essa é outra ENTRADA
esta entrada é uma informação
essa é outra ENTRADA
esta entrada é uma INFO 
SEVERE esta entrada é um aviso!

com cada linha em sua própria cor.

Há muitas outras maneiras de obter texto colorido do shell com outras ferramentas e elas são bem descritas por outros membros.


7

Eu gosto bastante de colorex . Simples, mas satisfatório.

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

12
como isso é simples?
Eliran Malka

6

Com base na resposta @uloBasEI, tentei usar ... | perl ... | perl ..., mas o pipe do Linux fica um pouco louco e é muito lento. Se eu colocar todas as regras em apenas um perlcomando, funcionará bem.

Por exemplo, crie um perlarquivo colorTail.pl como abaixo:

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

Use-o como:

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

NOTA: você também pode usá-lo no MobaXTerm ! Basta baixar o perlplug-in no site MobaXTerm .


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

7
source-highlightnão é um comando amplamente instalado; portanto, você deve pelo menos fornecer um link para o site do projeto.
Gilles

Disponível no Fedora 19.
sjas

E o Ubuntu 12.10.
sjas

Parece legal. É um pacote grande comparado aos outros nesta lista (26MB). Ele suporta uma enorme lista de idiomas. Pode ser personalizado modificando os arquivos de configuração localizados em: /usr/share/source-highlight/*.lang (Ubuntu). Se você precisar de algo simples, escolha ccze ou colortail.
Lepe

parece que depende de impulso, que é de cerca de 462MB
ecsos

3

Uma solução que funciona para colorir todos os tipos de texto, não apenas os arquivos de log, é uma ferramenta Python, ' colout '.

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

Onde qualquer texto na saída de 'myprocess' que corresponda ao grupo 1 da regex será colorido com cor1, grupo 2 com cor2, etc.

Por exemplo:

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

ou seja, o primeiro grupo regex (parens) corresponde à data inicial no arquivo de log, o segundo grupo corresponde a um nome de arquivo python, número de linha e nome de função, e o terceiro grupo corresponde à mensagem de log que vem depois disso. Isto parece com:

arquivo de log com formatação colorida

Observe que linhas ou partes de linhas que não correspondem a nenhuma da minha regex ainda são ecoadas, portanto, isso não é como 'grep --color' - nada é filtrado para fora da saída.

Obviamente, isso é flexível o suficiente para que você possa usá-lo com qualquer processo, e não apenas com arquivos de log finais. Normalmente, eu apenas preparo um novo regex rapidamente, sempre que quiser colorir alguma coisa. Por esse motivo, prefiro o colout a qualquer ferramenta personalizada para colorir arquivos de log, porque só preciso aprender uma ferramenta, independentemente do que estiver colorindo: registro, saída de teste, sintaxe destacando trechos de código no terminal etc.


1
Eu não vi uma única resposta que modificou o arquivo de log de origem
Dani_l

@Dani_l Você está certo! No momento em que escrevi isso, devo ter me confundido alternando entre essa e uma pergunta semelhante, para a qual muitas das respostas eram sobre como configurar o log, de modo que os caracteres ANSI fossem gravados diretamente no próprio arquivo de log. Excluirei essa reclamação da minha resposta.
Jonathan Hartley

2

Plugue sem vergonha: escrevi uma ferramenta chamada TxtStyle que faz algo semelhante às opções mencionadas anteriormente. Você pode executá-lo da seguinte maneira:

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

Você também pode definir estilos nomeados no arquivo de configuração ( ~/.txts.conf) e usá-lo da seguinte maneira:

ifconfig | txts --name ifconfig

(o ifconfigestilo é definido imediatamente)


2

grc com certeza!

personalize seus collors com regex no arquivo: ~ .grc / conf.tail (ou qualquer nome que você quiser)

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

linha de comando:

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

resultados: captura de tela

informações para configurar o grc: https://github.com/manjuraj/config/blob/master/.grc/sample.conf


1

Eu escrevi uma função bash que aceita até três parâmetros e cria um filtro do tipo grep em um arquivo de texto e envia o texto para a tela em cores.

Eu também gostaria de ver uma função de cauda que faria isso, mas ainda não a encontrei.

Essa função também pode ser aprimorada - eu apreciaria qualquer ajuda sobre como torná-la melhor.

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
}

1

certo !

Escrevi há muito tempo uma função chamada "egrepi", com base nas definições de 8 variáveis ​​de cores. Isso funciona somente como uma função colorida "tail -f".

1. setColors

primeiro, as variáveis ​​de cores funcionam para serem chamadas inicialmente:


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

e a função egrepi, eficaz e elegante: alternando cores entre 8 ou mais cores (suas necessidades) E testado em 3 sistemas operacionais unix diferentes, com comentários:


# 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



1

Quanto aos códigos de cores, eu usaria tput:

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

Veja para referência: man tput

Então:

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

Ótimo, obrigado. Funciona como um encanto com funções de shell padrão.
22418 vquintans

0

Publicado há algum tempo Utilitário Node Js - log-color-realce

tail -f file | lch -red error warn -green success
lch -f file -red.bold error warn -underline.bgGreen success
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.