වලිගය -f පෙන්වන්නේ කෙසේද?

මෙවැනි පණිවිඩ ඇති සේවාදායක ලොග් ගොනුවක ප්‍රතිදානය වලිගය කිරීමට මම කැමතියි:

INFO
SEVERE

ආදිය, සහ එය නම් SEVERE, රේඛාව රතු පැහැයෙන් පෙන්වන්න; එය INFOකොළ පැහැයෙන් නම්. මෙය tailකිරීමට මට උපකාර වන විධානයක් සඳහා මට කුමන ආකාරයේ අන්වර්ථයක් සැකසිය හැකිද?

බහුකාර්ය අත්හදා බලන්න . මෙය සාමාන්‍යකරණය කිරීමකි tail -f. ඔබට වෙනම කවුළුවලින් බහුවිධ ගොනු නැරඹිය හැකිය, ඒවායේ අන්තර්ගතය මත පදනම්ව රේඛා ඉස්මතු කරන්න සහ තවත් දේ.

multitail -c /path/to/log

වර්ණ වින්‍යාසගත කළ හැකිය. පෙරනිමි වර්ණ පටිපාටිය ඔබ වෙනුවෙන් ක්‍රියා නොකරන්නේ නම්, වින්‍යාස ගොනුවේ ඔබේම දෑ ලියන්න. උදාහරණයක් ලෙස, multitail -cS amir_log /path/to/logපහත සඳහන් දෑ සමඟ අමතන්න ~/.multitailrc:

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

තවත් විසඳුමක් නම්, ඔබ සම්මත නොවන මෙවලම් ස්ථාපනය කිරීමට අපහසු සේවාදායකයක සිටී නම් , tail -fවර්ණ තේරීමේ පාලන අනුපිළිවෙල එකතු කිරීම සඳහා sed හෝ awk සමඟ ඒකාබද්ධ වීමයි. මේ සඳහා tail -fඑහි සම්මත නිමැවුම පයිප්පයක් වුවද ප්‍රමාදයකින් තොරව ගලායාම අවශ්‍ය වේ , සියලු ක්‍රියාත්මක කිරීම් මෙය කරන්නේ දැයි මම නොදනිමි.

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

හෝ sed සමඟ

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

ඔබේ sed එක GNU sed නොවේ \o033නම්, වචනානුසාරයෙන් ගැලවීමේ චරිතයක් ආදේශ කර ඉවත් කරන්න --unbuffered.

තවත් හැකියාවක් නම් ඉමාක්ස් ෂෙල් බෆරයක ධාවනය tail -fකර ඉමාක්ස්ගේ සින්ටැක්ස් වර්ණක හැකියාවන් භාවිතා කිරීමයි.

grc , සාමාන්‍ය වර්ණකය ලස්සනයි.

apt-get install grc

කරන්න

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

විනෝද වන්න!

ඔබ එය GitHub හි ද සොයා ගනු ඇත .

ඔබ ccze දෙස බැලුවද ? විකල්පය භාවිතා කරමින් -cහෝ ඔබේ වින්‍යාස ගොනුවේ කෙලින්ම සමහර වචනවල පෙරනිමි වර්ණ අභිරුචිකරණය කිරීමේ හැකියාව ඔබට ඇත . වර්ණ ගැන්වීමෙන් පසු ඔබේ තිරය පිරිසිදු වන්නේ නම් ඔබ විකල්පය භාවිතා කළ යුතුය -A.

සංස්කරණය කරන්න:

සම්පූර්ණ රේඛාව රතු පැහැයෙන් වර්ණ ගැන්වීමට ඔබ සැබවින්ම කැමති නම්, ඔබට පහත සඳහන් දෑ අත්හදා බැලිය හැකිය:

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

\e[1;31mඔබට රතු පැහැය ලබා දෙනු ඇත. ඔබ කහ ටිකක් කැමති නම්, භාවිතා කරන්න \e[1;33m, සහ හරිත භාවිතය සඳහා \e[1;32m. මෙම \e[0mසාමාන්ය පෙළ සඳහා වර්ණය සුමුදු.

උසස් ලොග් ගොනු නරඹන්නා වන lnav දෙස බලන්න .

එයට විවිධ ආකෘතීන් ද මුද්‍රණය කළ හැකිය.

පෙර:

පසු:

සාමාන්‍ය දේ මත පදනම්ව රේඛා වර්ණවත් කරන දේදුන්නක් ඔබට භාවිතා කළ හැකිය :

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

එය පෙර සැකසූ වින්‍යාසයන් සමඟ ද එකතු වේ , උදාහරණයක් ලෙස ටොම්කාට් ලොග් සඳහා:

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

(වියාචනය: මම කර්තෘ)

ඔබට colortail භාවිතා කළ හැකිය :

colortail -f /var/log/messages

ඔබට ගැලපෙන එක් රීජෙක්ස් එකක් සෙවීමට අවශ්‍ය නම් , ග්නූ ග්‍රෙප් සමඟ ක්‍රියා --colorකරනු ඇත - ඔබේ tailප්‍රතිදානය ඒ හරහා නල කරන්න .

වැනි සම්මත විධාන වලින් වර්ණ ප්‍රතිදානය ලබා ගැනීම සඳහා grep, ඔබ මෙය aliasඔබගේ තුළ සැකසිය යුතුය.bashrc

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

ඔබ ඔබේ ගොනුවේ යමක් ග්‍රහණය කර ගත් විට ඔබට මේ වගේ දෙයක් පෙනේ, (නමුත් බොහෝ විට රතු පැහැයෙන්):

[root @ linuxbox mydir] # grep "\ (INFO \ | SEVERE \)" / var / log / logname
මෙම ප්රවේශය සඳහා වන INFO  
මැන්ඩෙලා මෙම ප්රවේශය අනතුරු අඟවන්නේ වේ!
මෙම ප්‍රවේශය INFO වේ 
මෙම ප්‍රවේශය INFO 
SEVERE මෙම ප්‍රවේශය අනතුරු ඇඟවීමකි!

අගහිඟකම් භාවිතා කිරීම නම් tailහෝ awkසහ වර්ණ ජල නල ජීවත් අවශ්ය බව, පසුව හෙවත් ප්රමාණවත් නොවේ ඔබ භාවිතා කළ යුත්තේ --color=alwaysඋදාහරණයක් ලෙස, පරාමිතිය:

[root @ linubox mydir] # grep --color = සැමවිටම "\ (INFO \ | SEVERE \)" / var / log / logname | tail -f | awk '{මුද්‍රණය $ 1}'
මෙය 
SEVERE
මෙය
මෙය
SEVERE

ඔබට awkකතාව සමඟ වර්ණ පෙළ අවශ්‍ය නම් ටිකක් සංකීර්ණ නමුත් වඩා බලවත් ය, උදාහරණයක් ලෙස:

[root @ linubox mydir] # tail -f / var / log / messages | awk '{if ($ 5 ~ / INFO /) මුද්‍රණය කරන්න "\ 033 [1; 32m" $ 0 "\ 033 [0m"; වෙනත් නම් ($ 1 ~ / SEVERE /) "\ 033 [1; 31m" $ 0 "\ 033 [0m" මුද්‍රණය කරන්න; නැතිනම් print 0 print 'මුද්‍රණය කරන්න
මෙම ප්රවේශය සඳහා වන INFO  
මැන්ඩෙලා මෙම ප්රවේශය අනතුරු අඟවන්නේ වේ!
මෙය තවත් එන්ට්‍රයි එකක්
මෙම ප්‍රවේශය INFO එකකි
මෙය තවත් එන්ට්‍රයි එකක්
මෙම ප්‍රවේශය තොරතුරු 
සෙවීමකි මෙම ප්‍රවේශය අනතුරු ඇඟවීමකි!

එක් එක් පේළිය එහි වර්ණයෙන්.

වෙනත් මෙවලම් සමඟ කවචයෙන් වර්ණ ගැන්වූ පෙළ ලබා ගැනීමට තවත් බොහෝ ක්‍රම ඇති අතර ඒවා අනෙක් සාමාජිකයින් විසින් හොඳින් විස්තර කර ඇත.

මම කොලරෙක්ස් වලට කැමතියි . සරල, නමුත් තෘප්තිමත්.

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

@UloBasEI පිළිතුර මත පදනම්ව, මම භාවිතා කිරීමට උත්සාහ කර ඇත ... | perl ... | perl ..., නමුත් ලිනක්ස් පයිප්පයට ටිකක් පිස්සු වැටෙන අතර එය මන්දගාමී වේ. මම සියලු රීති එක් perlවිධානයකට පමණක් දැමුවහොත් එය හොඳින් ක්‍රියාත්මක වේ.

උදාහරණයක් ලෙස, colorTail.plperl ගොනුවක් පහත පරිදි සාදන්න :

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

එය භාවිතා කරන්න:

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

සටහන: ඔබට එය MobaXTerm හි ද භාවිතා කළ හැකිය ! MobaXTerm වෙබ් අඩවියෙන් perlප්ලග් ඉන් බාගන්න .

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

ලොග්ෆයිල් පමණක් නොව, සියලු වර්ගවල පෙළ වර්ණ ගැන්වීම සඳහා ක්‍රියා කරන එක් විසඳුමක් වන්නේ පයිතන් මෙවලමක් වන ' කොලූට් ' ය.

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

රීජෙක්ස් හි 1 වන කාණ්ඩයට ගැලපෙන 'මයිප්‍රොසෙස්' හි ප්‍රතිදානයේ ඕනෑම පෙළක් වර්ණ 1, 2 වන කාණ්ඩය වර්ණ 2 සමඟ වර්ණ ගැන්වේ.

උදාහරණයක් වශයෙන්:

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

එනම් පළමු රීජෙක්ස් කණ්ඩායම (පරෙන්ස්) ලොග්ෆයිල් හි ආරම්භක දිනයට අනුරූප වේ, දෙවන කණ්ඩායම පයිතන් ගොනු නාමයක්, රේඛා අංකය සහ ක්‍රියාකාරී නාමයට ගැලපේ, තෙවන කණ්ඩායම ඊට පසුව එන ලොග් පණිවිඩයට ගැලපේ. මෙය පෙනේ:

මගේ කිසිදු රීජෙක්ස් වලට නොගැලපෙන රේඛා හෝ කොටස් තවමත් ප්‍රතිරාවය වී ඇති බව සලකන්න, එබැවින් මෙය 'grep --color' මෙන් නොවේ - ප්‍රතිදානයෙන් කිසිවක් පෙරීම සිදු නොවේ.

නිසැකවම මෙය නම්යශීලී වන අතර ඔබට එය ඕනෑම ක්‍රියාවලියක් සමඟ භාවිතා කළ හැකිය. මම සාමාන්‍යයෙන් යමක් වර්ණ ගැන්වීමට අවශ්‍ය ඕනෑම වේලාවක මැස්ස මත නව රීජෙක්ස් එකක් ගසමි. මේ හේතුව නිසා, මම ඕනෑම අභිරුචි ලොග්ෆයිල් වර්ණ ගැන්වීමේ මෙවලමකට කොලූට් කිරීමට කැමැත්තෙමි, මන්ද මා වර්ණ ගැන්වූ දේ නොසලකා එක් මෙවලමක් පමණක් ඉගෙන ගත යුතුය: ල ging ු-සටහන්, පරීක්ෂණ ප්‍රතිදානය, ටර්මිනලයේ කේත ස්නිපෙට් ඉස්මතු කරන සින්ටැක්ස් ආදිය.

ලැජ්ජා විරහිත ප්ලග්: මම කලින් සඳහන් කළ විකල්පයන්ට සමාන දෙයක් කරන TxtStyle නමින් මෙවලමක් ලිවීය . ඔබට එය පහත පරිදි ක්‍රියාත්මක කළ හැකිය:

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

වින්‍යාස ගොනුවේ ( ~/.txts.conf) නම් කළ මෝස්තර නිර්වචනය කර එය එසේ භාවිතා කළ හැකිය:

ifconfig | txts --name ifconfig

( ifconfigවිලාසය කොටුවෙන් පිටත අර්ථ දක්වා ඇත)

grc නිසැකවම!

ගොනුවේ රීජෙක්ස් සමඟ ඔබේ කොලර් අභිරුචිකරණය කරන්න: ~ .grc / conf.tail (හෝ ඔබට අවශ්‍ය ඕනෑම නමක්)

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

විධාන රේඛාව:

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

ප්රතිපල:

grc වින්‍යාස කිරීම සඳහා තොරතුරු: https://github.com/manjuraj/config/blob/master/.grc/sample.conf

මම පරාමිති තුනක් දක්වා පිළිගෙන පා file ගොනුවක grep වැනි පෙරණයක් කරන අතර පා text ය තිරයට තිරයෙන් ප්‍රතිදානය කරයි.

මෙය සිදු කරන වලිග ශ්‍රිතයක් දැකීමට මා කැමතිය, නමුත් තවම එකක් සොයාගෙන නැත.

මෙම ක්‍රියාව ද වැඩිදියුණු කළ හැකිය - එය වඩා හොඳ කරන්නේ කෙසේද යන්න පිළිබඳ ඕනෑම උදව්වක් මම අගය කරමි.

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
}

විශ්වාසයි!

වර්ණ විචල්‍යතා අර්ථ දැක්වීම් 8 මත පදනම්ව මම "ඊග්‍රෙපි" නම් ශ්‍රිතයක් දිගු වේලාවක් ලියා තැබුවෙමි. මෙය "ටේල්-එෆ්" වර්ණ ශ්‍රිතයක් මෙන් පයිප්ප පමණක් ක්‍රියා කරයි.

1. setColors

පළමුව, වර්ණ විචල්‍යයන් මුලින් හැඳින්වීමට ක්‍රියා කරයි:

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 ශ්‍රිතය effective ලදායී හා අලංකාරය: වර්ණ 8 ක් හෝ වැඩි ගණනක් අතර වර්ණ පාපැදි කිරීම (ඔබේ අවශ්‍යතා) සහ විවිධ යුනික්ස් මෙහෙයුම් පද්ධති 3 ක් යටතේ පරීක්ෂා කර, අදහස් දැක්වීම් සමඟ:

# 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. භාවිතය

විධානය | egrepi word1 .. wordN

ඔබට lwatch දෙස බැලීමට අවශ්‍ය විය හැකිය :

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

වර්ණ කේත සම්බන්ධයෙන් ගත් කල, මම tput භාවිතා කරමි:

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

යොමුව සඳහා බලන්න: man tput

ඉන්පසු:

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

කලකට පෙර ප්‍රකාශයට පත් කරයි Node Js උපයෝගීතාව - ලොග්-වර්ණ-උද්දීපනය

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

සෙන්ටෝස් සඳහා

yum install -y ccze
tail -f /var/log/file.log | ccze -A