Jak ustawić tail -f wyświetlać kolorowe wydruki

Chciałbym móc dopasować dane wyjściowe pliku dziennika serwera zawierającego komunikaty takie jak:

INFO
SEVERE

itd., a jeśli tak SEVERE, pokaż linię na czerwono; jeśli jest INFOw kolorze zielonym. Jaki alias mogę ustawić dla tailpolecenia, które pomogłoby mi to zrobić?

Wypróbuj multitail . To jest übergeneralizacja tail -f. Możesz oglądać wiele plików w osobnych oknach, wyróżniać linie na podstawie ich zawartości i nie tylko.

multitail -c /path/to/log

Kolory są konfigurowalne. Jeśli domyślny schemat kolorów nie działa, napisz swój własny w pliku konfiguracyjnym. Na przykład zadzwoń multitail -cS amir_log /path/to/logw następujący sposób ~/.multitailrc:

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

Innym rozwiązaniem, jeśli korzystasz z serwera, na którym instalowanie niestandardowych narzędzi jest niewygodne , to połączenie go tail -fz sed lub awk w celu dodania sekwencji kontrolnych wyboru koloru. Wymaga tail -fto bezzwłocznego opróżnienia standardowego wyjścia, nawet jeśli standardowym wyjściem jest potok, nie wiem czy wszystkie implementacje to robią.

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

lub z sed

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

Jeśli twój sed nie jest GNU sed, zastąp \o033go dosłownie znakiem ucieczki i usuń --unbuffered.

Jeszcze inną możliwością jest uruchomienie tail -fw buforze powłoki Emacsa i użycie zdolności kolorowania składni Emacsa.

grc , ogólny kolorysta jest całkiem fajny.

apt-get install grc

Po prostu zrób

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

i baw się dobrze!

Znajdziesz go również na GitHub .

Czy oglądałeś ccze ? Istnieje możliwość dostosowania domyślnych kolorów niektórych słów kluczowych za pomocą opcji -club bezpośrednio w pliku konfiguracyjnym. Jeśli ekran jest wyczyszczony po kolorowaniu, musisz użyć opcji -A.

Edytować:

Jeśli naprawdę chcesz mieć całą linię w kolorze czerwonym, możesz również spróbować:

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

\e[1;31mda ci czerwony kolor. Jeśli chcesz żółty, użyj \e[1;33mi do zielonego \e[1;32m. \e[0mPrzywraca normalny kolor tekstu.

Spójrz na lnav , zaawansowaną przeglądarkę plików dziennika.

Może także ładnie drukować różne formaty.

Przed:

Po:

Możesz użyć tęczy , która koloruje linie na podstawie wyrażeń regularnych:

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

Jest również dostarczany z predefiniowanymi konfiguracjami , na przykład dla dzienników Tomcat:

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

(wyłączenie odpowiedzialności: Jestem autorem)

Możesz użyć colortail :

colortail -f /var/log/messages

Zauważ też, że jeśli chcesz po prostu znaleźć jeden pasujący regex, GNU grep z --colorzadziała - po prostu prześlij tailprzez niego wynik.

Aby uzyskać kolorowe wyjście ze standardowych poleceń, takich jak grep, powinieneś ustawić to aliasw swoim.bashrc

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

kiedy grepujesz coś w swoim pliku, widzisz coś takiego (ale prawdopodobnie na czerwono):

[root @ linuxbox mydir] # grep "\ (INFO \ | SEVERE \)" / var / log / logname
ten wpis jest WIELKIMI INFORMACJAMI 
 ten wpis jest ostrzeżeniem!
ten wpis jest INFO 
ten wpis jest INFO 
SEVERE ten wpis jest ostrzeżeniem!

jeśli chcesz użyć taillub awkchcesz, aby kolor przetrwał w rurze, alias nie jest wystarczający i powinieneś użyć --color=alwaysparametru, na przykład:

[root @ linubox mydir] # grep --color = always "\ (INFO \ | SEVERE \)" / var / log / logname | tail -f | awk „{drukuj 1 $}”
to 
SILNY
to
to
SILNY

Jeśli chcesz, aby kolorowy tekst z awkhistorią był nieco złożony, ale bardziej wydajny, na przykład:

[root @ linubox mydir] # tail -f / var / log / messages | awk '{if (5 $ ~ / INFO /) print "\ 033 [1; 32m" $ 0 "\ 033 [0m"; w przeciwnym razie, jeśli ($ 1 ~ / SEVERE /) wydrukuje "\ 033 [1; 31m" $ 0 "\ 033 [0m"; w przeciwnym razie wydrukuj 0 USD}
ten wpis jest WIELKIMI INFORMACJAMI  
ten wpis jest ostrzeżeniem!
to kolejny WEJŚCIE
ten wpis jest INFO
to kolejny WEJŚCIE
ten wpis jest 
WIELKIMI INFORMACJAMI ten wpis jest ostrzeżeniem!

z każdą linią we własnym kolorze.

Istnieje wiele innych sposobów na uzyskanie kolorowego tekstu z powłoki za pomocą innych narzędzi i są one dobrze opisane przez innych członków.

Bardzo lubię colorex . Proste, ale satysfakcjonujące.

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

Opierając się na odpowiedzi @uloBasEI, próbowałem użyć ... | perl ... | perl ..., ale potok Linux trochę zwariował i jest zbyt wolny. Jeśli umieściłem wszystkie reguły w jednym perlpoleceniu, to działa dobrze.

Na przykład utwórz perlplik colorTail.pl jak poniżej:

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

Użyj go jako:

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

UWAGA: możesz używać go również w MobaXTerm ! Wystarczy pobrać perlwtyczkę ze strony MobaXTerm .

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

Jednym z rozwiązań, które działa do kolorowania wszelkiego rodzaju tekstu, nie tylko plików dziennika, jest narzędzie Pythona „ colout ”.

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

Gdzie dowolny tekst na wyjściu „myprocess”, który pasuje do grupy 1 wyrażenia regularnego, będzie pokolorowany kolorem 1, grupa 2 kolorem 2 itd.

Na przykład:

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

tzn. pierwsza grupa wyrażeń regularnych (parens) odpowiada początkowej dacie w pliku dziennika, druga grupa odpowiada nazwie pliku python, numerowi wiersza i nazwie funkcji, a trzecia grupa odpowiada późniejszemu komunikatowi dziennika. To wygląda jak:

Zauważ, że linie lub części linii, które nie pasują do żadnego z moich wyrażeń regularnych, są nadal powtarzane, więc to nie jest jak „grep - kolor” - nic nie jest odfiltrowywane z wyniku.

Oczywiście jest to na tyle elastyczne, że można go używać z dowolnym procesem, nie tylko dostosowywaniem plików dziennika. Zwykle robię nowe wyrażenie regularne w locie za każdym razem, gdy chcę coś pokolorować. Z tego powodu wolę narzędzie colout niż dowolne niestandardowe narzędzie do kolorowania plików dziennika, ponieważ muszę nauczyć się tylko jednego narzędzia, niezależnie od tego, co koloruję: rejestrowanie, testowanie danych wyjściowych, podświetlanie składni fragmentów kodu w terminalu itp.

Bezwstydna wtyczka: napisałem narzędzie o nazwie TxtStyle, które robi coś podobnego do wspomnianych wcześniej opcji. Możesz uruchomić go w następujący sposób:

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

Możesz także zdefiniować nazwane style w pliku konfiguracyjnym ( ~/.txts.conf) i używać go w następujący sposób:

ifconfig | txts --name ifconfig

( ifconfigstyl jest zdefiniowany po wyjęciu z pudełka)

Napisałem funkcję bash, która akceptuje do trzech parametrów i robi filtr typu grep na pliku tekstowym i wyświetla tekst na ekranie w kolorze.

Chciałbym również zobaczyć funkcję ogona, która by to zrobiła, ale jeszcze jej nie znalazłem.

Tę funkcję można również ulepszyć - byłbym wdzięczny za wszelką pomoc, jak ją ulepszyć.

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
}

pewnie !

Długo pisałem funkcję o nazwie „egrepi”, opartą na 8 definicjach zmiennych kolorów. Działa TYLKO w potokach jak funkcja w kolorze „tail-f”.

1. setColors

po pierwsze funkcja zmiennych kolorów, którą należy wywołać na początku:

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

oraz funkcja egrepi, skuteczna i elegancka: przełączanie kolorów między 8 lub więcej kolorami (twoje potrzeby) ORAZ przetestowane w 3 różnych systemach operacyjnych UNIX z komentarzami:

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

polecenie | egrepi word1 .. wordN

Możesz także rzucić okiem na zegarek :

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

grc na pewno!

dostosuj swoje kolektory za pomocą wyrażenia regularnego w pliku: ~ .grc / conf.tail (lub dowolną inną nazwę)

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

wiersz poleceń:

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

wyniki:

informacje na temat konfigurowania grc: https://github.com/manjuraj/config/blob/master/.grc/sample.conf

Jeśli chodzi o kody kolorów, użyłbym tput:

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

Zobacz w celach informacyjnych: man tput

Następnie:

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

Publikuje jakiś czas temu narzędzie Node Js - log-color-highlight

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