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ć?
Odpowiedzi:
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.
sed? (Przepraszam, że jestem leniwy i sam tego nie rozumiem!) Ale czy mógłbyś również dodać sedprzykład.
tail -fz awkkodem, jeśli ciąg nie zawiera INFO i SEVERE , łańcuch nie jest drukowany. Jak mogę wydrukować pozostałe ciągi? (Sznurek nie musi być zabarwiony)
; nextprzed nawiasami zamykającymi, aby pominąć dalsze przetwarzanie, i nową linię przetwarzania 1 {print}na końcu ( 1zawsze oznacza).
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/'
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.
\007do końca regex, tak: perl -pe 's/(ERROR)/\033[31m$1\033[0m\007/g;'. Działa to niesamowicie, jeśli używasz tmux z set -g bell-action any, w którym to przypadku, jeśli masz logowanie do dziennika w innym oknie, nazwa tego okna będzie ostrzegać, gdy wyrażenie regularne znajdzie dopasowanie.
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)
rainbowjest niesamowite. Czy jesteś autorem? Jeśli tak, edytuj swoją odpowiedź za pomocą tego atrybucji.
Możesz użyć colortail :
colortail -f /var/log/messages
apt install colortaili powinien on działać bez edycji ~ / .colortail /.
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.
grep -A9999 -B9999 regex, pokaże wszystkie linie, chyba że masz 10 000 niepasujących wierszy z rzędu. Użyj czegoś w rodzaju, GREP_COLORS="ms=31:sl=33:cx=32" grep -A9999 -B9999 SEVEREaby wyświetlić słowo SEVEREna czerwono, pozostałe ZNAKOMITE linie na żółto, a wszystkie inne (nie ZNAKOMIE) linie (do 9999) na zielono.
--color=alwaysdo grep zamiast po prostu --color, w zależności od kolejności twojej rury, ale tak, to działa ogon (GNU coreutils) 8.27 zainstalowany na moim urządzeniu.
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
source-highlightnie jest powszechnie instalowanym poleceniem, więc powinieneś przynajmniej podać link do strony projektu.
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
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
sed: stackoverflow.com/a/14691971/52074