Wie lässt man den Schwanz -f die farbige Ausgabe anzeigen?

Ich möchte in der Lage sein, die Ausgabe einer Server-Protokolldatei mit Nachrichten wie den folgenden zu beenden:

INFO
SEVERE

etc, und wenn es so ist SEVERE, zeige die Linie in rot; Wenn ja INFO, in grün. Welche Art von Alias ​​kann ich für einen tailBefehl einrichten, der mir dabei helfen würde?

Probieren Sie Multitail aus . Dies ist eine Übergeneralisierung von tail -f. Sie können mehrere Dateien in separaten Fenstern anzeigen, Zeilen anhand ihres Inhalts hervorheben und vieles mehr.

multitail -c /path/to/log

Die Farben sind konfigurierbar. Wenn das Standardfarbschema für Sie nicht funktioniert, schreiben Sie Ihr eigenes in die Konfigurationsdatei. Rufen Sie zum Beispiel multitail -cS amir_log /path/to/logmit folgendem Befehl an ~/.multitailrc:

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

Eine andere Lösung, wenn Sie sich auf einem Server befinden, auf dem es unpraktisch ist, nicht standardmäßige Tools zu installieren , besteht darin, sie tail -fmit sed oder awk zu kombinieren , um Farbauswahl-Steuerungssequenzen hinzuzufügen. Dazu muss tail -fdie Standardausgabe unverzüglich gelöscht werden, auch wenn es sich bei der Standardausgabe um eine Pipe handelt. Ich weiß nicht, ob dies bei allen Implementierungen der Fall ist.

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

oder mit sed

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

Wenn Ihr sed nicht GNU sed ist, ersetzen Sie es \o033durch ein Escape-Zeichen und entfernen Sie es --unbuffered.

Eine weitere Möglichkeit besteht darin, tail -fin einem Emacs- Shell-Puffer zu arbeiten und die Syntax-Färbemöglichkeiten von Emacs zu verwenden.

grc , der generische colorizer ist ziemlich cool.

apt-get install grc

Mach einfach

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

und genieße!

Sie finden es auch auf GitHub .

Haben Sie sich ccze angesehen ? Sie haben die Möglichkeit, die Standardfarben einiger Schlüsselwörter mithilfe der Option -coder direkt in Ihrer Konfigurationsdatei anzupassen . Wenn sich Ihr Bildschirm nach dem Einfärben aufhellt, müssen Sie die Option verwenden -A.

Bearbeiten:

Wenn Sie wirklich möchten, dass die gesamte Linie rot angezeigt wird, können Sie auch Folgendes ausprobieren:

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

\e[1;31mgibt dir die rote Farbe. Wenn Sie etwas Gelb möchten, verwenden Sie \e[1;33mund für Grüngebrauch \e[1;32m. Das \e[0mstellt die normale Textfarbe wieder her.

Schauen Sie sich lnav an , den erweiterten Viewer für Protokolldateien.

Es kann auch verschiedene Formate drucken.

Vor:

Nach:

Sie können rainbow verwenden , das Linien basierend auf regulären Ausdrücken koloriert:

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

Es wird auch mit vordefinierten Konfigurationen geliefert , zum Beispiel für Tomcat-Protokolle:

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

(Haftungsausschluss: Ich bin der Autor)

Sie können Colortail verwenden :

colortail -f /var/log/messages

Beachten Sie auch, dass GNU grep with funktioniert , wenn Sie nur nach einem passenden regulären Ausdruck suchen möchten --color- leiten Sie einfach Ihre tailAusgabe durch diesen.

Um eine farbige Ausgabe von Standardbefehlen wie zu erhalten grep, sollten Sie dies aliasin Ihrem einstellen.bashrc

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

Wenn Sie in Ihrer Datei nach etwas suchen, sehen Sie etwas in der Art (aber wahrscheinlich in rot):

[root @ linuxbox mydir] # grep "\ (INFO \ | SEVERE \)" / var / log / logname
Dieser Eintrag ist ein INFO  
SEVERE Dieser Eintrag ist eine Warnung!
Dieser Eintrag ist ein INFO 
Dieser Eintrag ist ein INFO 
SEVERE Dieser Eintrag ist eine Warnung!

Wenn Sie tailoder verwenden awkmöchten und möchten, dass die Farbe in einer Pipe erhalten bleibt, reicht der Alias ​​nicht aus, und Sie sollten den --color=alwaysParameter verwenden, zum Beispiel:

[root @ linubox mydir] # grep --color = immer "\ (INFO \ | SEVERE \)" / var / log / logname | Schwanz -f | awk '{print $ 1}'
diese 
SCHWER
diese
diese
SCHWER

Wenn Sie farbigen Text mit awkder Geschichte wollen, ist dieser etwas komplexer, aber leistungsfähiger, zum Beispiel:

[root @ linubox mydir] # tail -f / var / log / messages | awk '{if ($ 5 ~ / INFO /) print "\ 033 [1; 32m" $ 0 "\ 033 [0m"; sonst, wenn ($ 1 ~ / SEVERE /) "\ 033 [1; 31m" $ 0 "\ 033 [0m" druckt; sonst drucke $ 0} '
Dieser Eintrag ist ein INFO  
SEVERE Dieser Eintrag ist eine Warnung!
Dies ist ein weiterer Eintrag
Dieser Eintrag ist ein INFO
Dies ist ein weiterer Eintrag
Dieser Eintrag ist ein INFO 
SEVERE Dieser Eintrag ist eine Warnung!

mit jeder Linie in ihrer eigenen Farbe.

Es gibt viele andere Möglichkeiten, kolorierten Text mit anderen Werkzeugen aus der Shell zu holen, und sie werden von anderen Mitgliedern gut beschrieben.

Ich mag Colorex sehr . Einfach und doch befriedigend.

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

Basierend auf der Antwort von @uloBasEI habe ich versucht zu verwenden ... | perl ... | perl ..., aber die Linux-Pipe wird ein bisschen verrückt und ist zu langsam. Wenn ich alle Regeln in nur einem perlBefehl setze , funktioniert es gut.

Erstellen Sie zum Beispiel eine perlDatei colorTail.pl wie folgt :

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

Verwenden Sie es als:

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

HINWEIS: Sie können es auch auf MobaXTerm verwenden ! Laden Sie das perlPlug-in einfach von der MobaXTerm- Website herunter .

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

Eine Lösung zum Einfärben aller Arten von Text, nicht nur von Protokolldateien, ist das Python-Tool ' colout '.

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

Wobei jeder Text in der Ausgabe von 'myprocess', der mit Gruppe 1 des regulären Ausdrucks übereinstimmt, mit Farbe 1, Gruppe 2 mit Farbe 2 usw. gefärbt wird.

Zum Beispiel:

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

dh die erste reguläre Ausdrucksgruppe (parens) stimmt mit dem Anfangsdatum in der Protokolldatei überein, die zweite Gruppe stimmt mit einem Python-Dateinamen, einer Zeilennummer und einem Funktionsnamen überein, und die dritte Gruppe stimmt mit der Protokollmeldung überein, die danach kommt. Das sieht so aus:

Beachten Sie, dass Linien oder Teile von Linien, die mit keinem meiner regulären Ausdrücke übereinstimmen, weiterhin als Echo angezeigt werden. Dies entspricht also nicht 'grep --color' - nichts wird aus der Ausgabe herausgefiltert.

Offensichtlich ist dies flexibel genug, dass Sie es mit jedem Prozess verwenden können, nicht nur mit dem Tailing von Protokolldateien. Normalerweise ziehe ich jedes Mal, wenn ich etwas färben möchte, einen neuen Regex im Flug auf. Aus diesem Grund ziehe ich Colout jedem benutzerdefinierten Tool zum Färben von Protokolldateien vor, da ich nur ein Tool lernen muss, unabhängig davon, was ich färbe: Protokollierung, Testausgabe, Hervorheben von Codeausschnitten in der Syntax im Terminal usw.

Schamloser Plug: Ich habe ein Tool namens TxtStyle geschrieben , das etwas Ähnliches wie die zuvor erwähnten Optionen ausführt . Sie können es wie folgt ausführen:

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

Sie können auch benannte Stile in der Konfigurationsdatei ( ~/.txts.conf) definieren und wie folgt verwenden:

ifconfig | txts --name ifconfig

( ifconfigStil ist ab Werk definiert)

grc sicher!

Passe deine Collors mit Regex in der Datei an: ~ .grc / conf.tail (oder wie auch immer du willst)

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

Befehlszeile:

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

Ergebnisse:

Informationen zum Konfigurieren von grc: https://github.com/manjuraj/config/blob/master/.grc/sample.conf

Ich habe eine Bash-Funktion geschrieben, die bis zu drei Parameter akzeptiert, einen Grep-ähnlichen Filter für eine Textdatei ausführt und Text in Farbe auf dem Bildschirm ausgibt.

Ich würde auch gerne eine Tail-Funktion sehen, die dies tun würde, aber noch keine gefunden habe.

Diese Funktion kann auch verbessert werden - ich würde mich über jede Hilfe freuen, um sie zu verbessern.

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
}

sicher !

Ich habe lange eine Funktion namens "egrepi" geschrieben, basierend auf den 8 Farbvariablendefinitionen. Dies funktioniert NUR wie eine "Schwanz-F" -Farbfunktion.

1. setColors

Zunächst werden die Farbvariablen aufgerufen:

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

und die egrepi-Funktion, effektiv und elegant: Farbwechsel zwischen 8 oder mehr Farben (Ihre Bedürfnisse) UND getestet unter 3 verschiedenen Unix-Betriebssystemen, mit Kommentaren:

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

befehl | egrepi word1 .. wordN

Vielleicht möchten Sie auch einen Blick auf lwatch werfen :

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

Für die Farbcodes würde ich tput verwenden:

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

Siehe als Referenz: man tput

Dann:

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

Veröffentlicht vor einiger Zeit 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