it-swarm.com.de

Wie man Schwanz -f farbige Ausgabe zeigen lässt

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

INFO
SEVERE

etc, und wenn es SEVERE ist, zeigen Sie die Linie in rot; wenn es INFO ist, in grün. Welche Art von Alias ​​kann ich für einen Befehl tail einrichten, der mir dabei helfen würde?

277
Amir Afghani

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 beispielsweise multitail -cS amir_log /path/to/log Mit dem folgenden ~/.multitailrc Auf:

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 - Standardtools zu installieren, besteht darin, tail -f Mit sed oder zu kombinieren awk, um Steuersequenzen für die Farbauswahl hinzuzufügen. Dies erfordert, dass tail -f Seine Standardausgabe unverzüglich leert, selbst wenn seine Standardausgabe eine Pipe ist. Ich weiß nicht, ob alle Implementierungen dies tun.

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 \o033 Durch ein wörtliches Escapezeichen und entfernen Sie --unbuffered.

Eine weitere Möglichkeit besteht darin, tail -f In einem Emacs Shell-Puffer auszuführen und die Syntax-Farbfähigkeiten von Emacs zu verwenden.

grc , der generische Colourizer 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 .

127
thias

Haben Sie sich ccze angesehen? Sie haben die Möglichkeit, die Standardfarben einiger Schlüsselwörter mit der Option -c Oder direkt in Ihrer Konfigurationsdatei anzupassen. Wenn sich Ihr Bildschirm nach dem Färben auflöst, müssen Sie die Option -A Verwenden.

Bearbeiten:

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

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

\e[1;31m Gibt Ihnen die rote Farbe. Wenn Sie etwas Gelb möchten, verwenden Sie \e[1;33m Und für Grün \e[1;32m. Der \e[0m Stellt die normale Textfarbe wieder her.

52
uloBasEI

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

lnavlnav

Es kann auch verschiedene Formate hübsch drucken.

Vor:

lnav-before-pretty

Nach:

lnav-pretty

38
bagonyi

Sie können Rainbow verwenden, um Linien basierend auf regulären Ausdrücken einzufärben:

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

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

Rainbow --config=Tomcat tail -f my-file.log

(Haftungsausschluss: Ich bin der Autor)

25
nicoulaj

Sie können colortail verwenden:

colortail -f /var/log/messages
16
Kartik M

Beachten Sie auch, dass, wenn Sie nur nach eins übereinstimmendem regulären Ausdruck suchen möchten, GNU grep with --color wird funktionieren - leiten Sie einfach Ihre tail Ausgabe durch.

12
mattdm

Um eine farbige Ausgabe von Standardbefehlen wie grep zu erhalten, sollten Sie dieses alias in Ihrem .bashrc Festlegen.

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

wenn Sie etwas in Ihrer Datei suchen, sehen Sie so etwas (aber wahrscheinlich in Rot):

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

wenn Sie tail oder awk verwenden möchten und möchten, dass die Farbe in einer Pipe überlebt, reicht der Alias ​​nicht aus, und Sie sollten den Parameter --color=always verwenden, zum Beispiel:

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

Wenn Sie Farbtext mit awk möchten, ist die Geschichte etwas komplex, 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" drucken; sonst print $ 0} '
 Dieser Eintrag ist ein DIE INFOSEVERE dieser Eintrag ist eine Warnung!
 Dies ist ein weiterer EINTRAG 
dieser Eintrag ist ein INFO
 Dies ist ein weiterer EINTRAG 
dieser Eintrag ist ein INFOSEVERE dieser Eintrag ist eine Warnung!

mit jeder Linie in ihrer eigenen Farbe.

Es gibt viele andere Möglichkeiten, mit anderen Tools kolorierten Text von Shell zu erhalten, und sie werden von anderen Mitgliedern gut beschrieben.

9
tombolinux

Ich mag colorex . Einfach und doch befriedigend.

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

Basierend auf der Antwort von @uloBasEI habe ich versucht, ... | Perl ... | Perl ..., aber Linux Pipe wird ein bisschen verrückt und ist zu langsam. Wenn ich alle Regeln in nur einen Perl Befehl setze, funktioniert es einwandfrei.

Erstellen Sie beispielsweise eine Perl -Datei 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 einfach das Plugin Perl von der MobaXTerm Site herunter.

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

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

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

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

Zum Beispiel:

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

das heißt, die erste Regex-Gruppe (parens) entspricht dem Anfangsdatum in der Protokolldatei, die zweite Gruppe entspricht einem python Dateiname, Zeilennummer und Funktionsname) und die dritte Gruppe entspricht der nachfolgenden Protokollnachricht das sieht aus wie:

(logfile with colored formatting

Beachten Sie, dass Zeilen oder Teile von Zeilen, die keinem meiner regulären Ausdrücke entsprechen, immer noch wiedergegeben werden. Dies ist also nicht wie '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 zaubere ich jedes Mal, wenn ich etwas einfärben möchte, spontan einen neuen regulären Ausdruck. Aus diesem Grund bevorzuge ich Colout gegenüber jedem benutzerdefinierten Tool zum Ausmalen von Protokolldateien, da ich nur ein Tool lernen muss, unabhängig davon, was ich einfärbe: Protokollierung, Testausgabe, Syntax, die Codeausschnitte im Terminal hervorhebt usw.

3

grc sicher!

passen Sie Ihre Collors mit Regex in der Datei an: ~ .grc/conf.tail (oder wie auch immer Sie möchten)

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

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

2
Flavio

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

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

Sie können benannte Stile auch in der Konfigurationsdatei definieren (~/.txts.conf) und benutze es so:

ifconfig | txts --name ifconfig

(ifconfig style ist standardmäßig definiert)

2
armandino

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 Schwanzfunktion 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, wie man sie verbessern kann.

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 "[email protected]"
        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
Steve Warren

sicher !

Ich habe lange eine Funktion namens "egrepi" geschrieben, basierend auf den 8 Definitionen der Farbvariablen. Dies funktioniert NUR wie eine "tail-f" -Farbe.

1. setColors

zunächst müssen zunächst die Farbvariablen aufgerufen werden:


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 Anforderungen) 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
}

. Verwendung

befehl | egrepi Word1 .. wordN

1
scavenger

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"
1
Fabien Bouleau

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

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

1
Michael Krupp

Veröffentlicht vor einiger Zeit Node Js Dienstprogramm - Log-Color-Highlight

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