I'd like to be able to tail the output of a server log file that has messages like:


etc, and if it's SEVERE, show the line in red; if it's INFO, in green. What kind of alias can I setup for a tail command that would help me do this?


23 Answers 23


Try out multitail¹. This is an übergeneralization of tail -f. You can watch multiple files in separate windows, highlight lines based on their content, and more.

multitail -c /path/to/log

The colors are configurable. If the default color scheme doesn't work for you, write your own in the config file. For example, call multitail -cS amir_log /path/to/log with the following ~/.multitailrc:


Another solution, if you're on a server where it's inconvenient to install non-standard tools, is to combine tail -f with sed or awk to add color selection control sequences. This requires tail -f to flush its standard output without delay even when its standard output is a pipe, I don't know if all implementations do this.

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

or with sed

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

If your sed isn't GNU sed, replace \o033 by a literal escape character and remove --unbuffered.

Yet another possibility is to run tail -f in an Emacs shell buffer and use Emacs's syntax coloring abilities.

¹ The historical website vanished in early 2021. The latest version is still available in many distributions, e.g. Arch, Debian.

  • how can you do this with sed? (sorry for being lazy and not figuring it out myself!) But would you please add a sed example as well.
    – Ali
    Nov 28, 2011 at 16:41
  • 6
    @Ali Sed is less convenient because it doesn't have a syntax for the escape character, you need to have it literally in the script or use a shell quoting method to work it in. I recommend that you use awk. Nov 28, 2011 at 17:18
  • 9
    @Gilles In your tail -f with awk code, if a string doesn't have INFO and SEVERE, the string isn't be printed. How can I print the remain strings either? (The string doesn't need to be colored)
    – Benjamin
    Jun 29, 2012 at 10:32
  • 9
    @Benjamin Add ; next before the closing braces to skip further processing, and a new processing line 1 {print} at the end (1 means always). Jun 29, 2012 at 11:58
  • 7
    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/' Sep 7, 2018 at 15:07

grc, the generic colourizer is pretty cool.

apt-get install grc

Just do

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

and enjoy!

You’ll also find it on GitHub.

  • 6
    This is exactly what I needed: lightweight and simple. The coloring isn't exactly right for my log types (custom logs) but any coloring makes it easier for me to follow a log.
    – rennat
    Oct 21, 2011 at 19:49
  • For me 'grc' on Debian errors out with: OSError: [Errno 13] Permission denied. Also it depends on Python being installed so it's not relaly lightweight unless you already have it. I have found 'ccze' to work much better, ex. 'tail -f -n 50 /var/log/starbound-server.log | ccze -A'. Dec 9, 2013 at 3:56
  • 1
    grc default settings in Ubuntu didn't display nice for syslogs or mail.log. It is not easy to understand how to customize it.
    – lepe
    Jan 27, 2014 at 3:34
  • 2
    I found it quicker and easier way to colorize than multitail. Just did a quick install via source on my CentOS system and upgraded my life. Will install on my other systems too.
    – zeeshan
    Jul 12, 2014 at 9:51
  • 5
    This looks pretty terrible on nginx logs i.imgur.com/aJbIOfL.png
    – mpen
    Sep 3, 2014 at 2:34

Have you had a look at ccze? You have the possibility to customize the default colors of some keywords using the option -c or directly in your configuration file. If your screen is clearing after colorizing you must use option -A.


If you really would like to have the complete line colored in red, you could also have a try at the following:

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

\e[1;31m will give you the red color. If you would like some yellow, use \e[1;33m, and for green use \e[1;32m. The \e[0m restores the normal text color.

  • 1
    This doesn't work on Mac - I'm upvoting it because it works on Linux. Mar 1, 2011 at 21:33
  • Upvoting because while the perl/ansi trick might not, ccze does.
    – Shadur
    Nov 13, 2011 at 16:02
  • 1
    You can also make your terminal send an alert or "beep" by adding \007 to the end of the regex, like so: perl -pe 's/(ERROR)/\033[31m$1\033[0m\007/g;'. This works awesome if you are using tmux with set -g bell-action any, in which case if you have your log tailing in another window, that window name will alert whenever the regex finds a match. Nov 13, 2012 at 4:15
  • @AmirAfghani This is a linux/unix SE site, therefore I am not sure why you thought it would work on mac. Jun 4, 2013 at 6:06
  • 2
    @BЈовић Mac is a Unix.
    – Chris Down
    Sep 12, 2013 at 19:16

Have a look at lnav, the advanced log file viewer.

lnav lnav

It can also pretty print various formats.





  • Thanks @bagonyi, it's a great tool indeed. It provide a query tool using SQL statements like select log_time, log_level, log_body from syslog_log where log_body like '%CPU%'
    – campisano
    Aug 29, 2020 at 17:49
  • Available in Fedora
    – Yetti99
    Jan 30, 2021 at 19:05
  • Amazing tool. The shortcuts to go to previous/next error and also to move 1h back and forth is incredibly useful.
    – qwertzguy
    Jun 9, 2021 at 5:50

You can use rainbow, which colorizes lines based on regular expressions:

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

It also comes bundled with predefined configs, for example for Tomcat logs:

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

(disclaimer: I am the author)

  • 5
    I tried most of the other solutions offered to this question, but rainbow was the only one that worked equally well on sun, aix, linux, termux, darwin, and cygwin -- the 6(!) environments I use on a daily basis. All the others involved difficult non-portable build processes for at least some platforms.
    – Stabledog
    May 17, 2017 at 15:15
  • It's my nearly-perfect tool but I don't get the "last line" of an ongoing tail -f. Particularly rainbow --red=CRITICAL tail -f var/log/dev.log works perfect but tail -f var/log/dev.log | rainbow --red=CRITICAL does the bug. Should I open an issue in github? Jan 2 at 11:37

You can use colortail:

colortail -f /var/log/messages
  • 2
    +1 available at Ubuntu repositories. What I like of colortail compared to ccze is that you can customize freely your patterns using RegEx. Available colors: black, brightblack, white, brightwhite, magenta, brightmagenta, cyan, brightcyan, green,‌​brightgreen, yellow, brightyellow, red,brightred, blue, brightblue. Unfortunately there is no way to set bold or other colors like orange.
    – lepe
    Jan 27, 2014 at 3:55
  • I would like to correct one point about my previous comment: "bright"+color includes "bold" (some colors will actually look brighter as well)
    – lepe
    Jan 27, 2014 at 4:25
  • I tried this on Ubuntu 18 and it did not work. The setup is multi-step and instructions are ambiguous. Still unsure that's the part I got wrong; the last part can get clearer "After that you may want to copy and edit the example config files to some other place. I have them in ~/.colortail/"
    – Dawoodjee
    May 5, 2019 at 11:19
  • Just install colortail with, apt install colortail and it should work without editing ~/.colortail/ too.
    – Kartik M
    May 6, 2019 at 12:05
  • Works like a charm on Ubuntu LTS 20.04 arm64 for Raspberry Pi 4 - apt install colortail gets the job done.
    – alphaGeek
    May 7, 2021 at 11:21

Also note that if you just want to look for one matching regex, GNU grep with --color will work — just pipe your tail output through that.

  • The OP only wanted to highlight the output, not filter it. Grep won't show non-matching lines...
    – Coderer
    Jun 30, 2014 at 12:36
  • 6
    If you say grep  -A9999  -B9999 regex, it will show all lines unless you have 10,000 non-matching lines in a row.  Use something like GREP_COLORS="ms=31:sl=33:cx=32" grep -A9999 -B9999 SEVERE to show the word SEVERE in red, the rest of SEVERE lines in yellow, and all other (non-SEVERE) lines (up to 9999) in green. Aug 7, 2015 at 2:45
  • You might need to pass --color=always to grep instead of just --color, depending on the order of your pipe, but yes, this works tail (GNU coreutils) 8.27 installed on my box. Jul 2, 2018 at 15:26

To get colored output from standard commands like grep, you should set this alias in your .bashrc

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

when you grep something in your file you see something like this, (but probably in red):

[root@linuxbox mydir]# grep "\(INFO\|SEVERE\)" /var/log/logname
this entry is an INFO 
SEVERE this entry is a warn!
this entry is an INFO
this entry is an INFO
SEVERE this entry is a warn!

if want to use tail or awk and want that the color survive to a pipe, then the alias is not enough and you should use the --color=always parameter, for example:

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

If you want color text with awk the story is a little bit complex but more powerfull, for example:

[root@linubox mydir]# tail -f /var/log/messages | awk '{if ($5 ~ /INFO/) print "\033[1;32m"$0"\033[0m"; else if ($1 ~ /SEVERE/) print "\033[1;31m"$0"\033[0m"; else print $0}'
this entry is an INFO 
SEVERE this entry is a warn!
this is another ENTRY
this entry is an INFO
this is another ENTRY
this entry is an INFO
SEVERE this entry is a warn!

with each line in its own color.

There are many other way to get colorized text from shell with other tools and they are well descripted by other members.


I quite like colorex. Simple, yet satisfying.

tail -f /var/log/syslog | colorex -G '[0-9]{2}:[0-9]{2}:[0-9]{2}' -b $(hostname)
  • 16
    how is that simple? Apr 13, 2015 at 10:40
  • 1
    @Asclepius fixed (I believe it's the same script) Aug 3 at 14:28

Based on @uloBasEI answer, I've tried to use ... | perl ... | perl ..., but Linux pipe gets a bit crazy and is too slow. If I put all rules in only one perl command, it works fine.

For example, create a perl file colorTail.pl as below:

#!/usr/bin/perl -w

while(<STDIN>) {
    my $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";

Use it as:

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

NOTE: you can use it on MobaXTerm too! Just download perl plug-in from MobaXTerm site.

tail -f /var/log/logname | source-highlight -f esc -s log
  • 7
    source-highlight isn't a widely installed command, so you should at least give a link to the project site. Mar 16, 2011 at 22:45
  • Available in Fedora 19.
    – sjas
    Sep 29, 2013 at 14:55
  • And Ubuntu 12.10.
    – sjas
    Sep 29, 2013 at 15:10
  • It looks nice. Its a big package compared to others in this list (26MB). It supports a huge list of languages. It can be customized modifying the config files located at: /usr/share/source-highlight/*.lang (Ubuntu). If you need something simple, go with ccze or colortail.
    – lepe
    Jan 27, 2014 at 3:46
  • looks like it depends on boost, which is around 462MB
    – ecsos
    May 29, 2014 at 21:34

One solution that works for coloring all sorts of text, not just logfiles, is a Python tool, 'colout'.

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

Where any text in the output of 'myprocess' which matches group 1 of the regex will be colored with color1, group 2 with color2, etc.

For example:

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

i.e. the first regex group (parens) matches the initial date in the logfile, the second group matches a python filename, line number and function name, and the third group matches the log message that comes after that. This looks like:

logfile with colored formatting

Note that lines or parts of lines which don't match any of my regex are still echoed, so this isn't like 'grep --color' - nothing is filtered out of the output.

Obviously this is flexible enough that you can use it with any process, not just tailing logfiles. I usually just whip up a new regex on the fly any time I want to colorize something. For this reason, I prefer colout to any custom logfile-coloring tool, because I only need to learn one tool, regardless of what I'm coloring: logging, test output, syntax highlighting snippets of code in the terminal, etc.


Shameless plug: I wrote a tool called TxtStyle that does something similar as the options mentioned earlier. You can run it as follows:

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

You can also define named styles in the config file (~/.txts.conf) and use it like so:

ifconfig | txts --name ifconfig

(ifconfig style is defined out of the box)


grc for sure!

customize your collors with regex in the file: ~.grc/conf.tail (or whatever name you want)

regexp=.*(select .*)$
regexp=.*(update .*)$
colours=unchanged,bold yellow
regexp=.*(insert .*)$
colours=unchanged,bold yellow
colours=unchanged,reverse green
colours=unchanged,underline green,underline magenta

command line:

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

results: screenshot

info for configuring grc: https://github.com/manjuraj/config/blob/master/.grc/sample.conf


As for the color codes, I would use tput:

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

See for reference: man tput


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

I wrote a bash function that accepts up to three parameters and does a grep-like filter on a text file, and outputs text to the screen in color.

I would also like to see a tail function that would do this, but haven't found one yet.

This function can also be improved - I'd appreciate any help on how to make it better.

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";

    for element in "$@"
            #echo $element;


    #CREATE SED EXPRESSION - '/($1)|($2)|(...)/p'

    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

        [[  $1 && ${1-x} ]] && 
            if grep -q $1 <<<$LINE; then
                echo "$(tput setaf 3)$LINE"

        [[  $2 && ${2-x} ]] && 
            if grep -q $2 <<<$LINE; then
                echo "$(tput setaf 7)$LINE"

        [[  $3 && ${3-x} ]] && 
            if grep -q $3 <<<$LINE; then
                echo "$(tput setaf 6)$LINE"


sure !

I wrote long a go a function called "egrepi", based on the 8 color variables definitions. This works ONLY piped like a "tail -f" colored function.

1. setColors

first, the color variables function to be called at first:

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
# 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)



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"'

set +a

2. egrepi

and the egrepi function, effective and elegant: color cycling between 8 or more colors (your needs) AND tested under 3 different unix OS, with comments :

# 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 ()
# 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
unset argsToGrep argsSedColor argsPerlColor

for arg in ${args}
    [ "${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
    # 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++"
# 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. Usage

command | egrepi word1 .. wordN


You might also want to take a look at lwatch:

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


for Centos

yum install -y ccze
tail -f /var/log/file.log | ccze -A
  • FYI, ccze package is removed from centos 8 epel repo.
    – Akhil
    Sep 1, 2020 at 15:57

Publishes some time ago 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

Based on the @this post, I've created a solution which shows dynamic tail output from the multiple logs files and returns coloured warning and error messages as below:

tail -f -n 5 application.log debug.log| perl -pe 's#WARNING#\x1b[33m$&#; s#ERROR#\x1b[31m$&#; s#foo#\x1b[32m$&#' 

No installation needed. Hope this helps someone.


Working solution on Mac

Colored logs on mac

Tried a bunch of things that just didn't work because of some escaping issue.

Eventually found a working solution:

tail -f example.log | sed \
-e "s/FATAL/"$'\e[31m'"&"$'\e[m'"/" \
-e "s/ERROR/"$'\e[31m'"&"$'\e[m'"/" \
-e "s/WARNING/"$'\e[33m'"&"$'\e[m'"/" \
-e "s/INFO/"$'\e[32m'"&"$'\e[m'"/" \
-e "s/DEBUG/"$'\e[34m'"&"$'\e[m'"/"

A quick way to show it working:

echo " [timestamp] production.FATAL Some Message\n" \
"[timestamp] production.ERROR Some Message\n" \
"[timestamp] production.WARNING Some Message\n" \
"[timestamp] production.INFO Some Message\n" \
"[timestamp] production.DEBUG Some Message\n"  | sed \
-e "s/FATAL/"$'\e[31m'"&"$'\e[m'"/" \
-e "s/ERROR/"$'\e[31m'"&"$'\e[m'"/" \
-e "s/WARNING/"$'\e[33m'"&"$'\e[m'"/" \
-e "s/INFO/"$'\e[32m'"&"$'\e[m'"/" \
-e "s/DEBUG/"$'\e[34m'"&"$'\e[m'"/"

Note: this won't hide any logs, just color the parts needed

  • Welcome to the site, and thank you for your contribution. Please note however that the approach of using sed to post-process the raw output and introduce color escape codes was already mentioned in the answer by @Gilles. Please review your answer and decide whether your approach is sufficiently distinct to warrant a post of its own, or if it should rather be an edit to add details to the mentioned answer.
    – AdminBee
    Nov 9, 2021 at 8:16
  • @AdminBee Thanks :) and hello. While the other question mentions using sed, it doesn't work on Mac, I've tried it. The start of the line gets replaced with o033[32m and end o033[39m, and its not coloured. I believe this is because the way unix escapes part of it. Ive searched high and wide for a solution to this, but nothing worked. Nov 9, 2021 at 9:40
sudo apt install grc
grc tail /var/log/syslog
alias tail='grc tail'

enter image description here

  • This is a duplicate of thias’ answer. Feb 22, 2022 at 13:56
  • It really should refer to the existing answer as a basis; I see the addition of alias tail='grc tail' here which seems unique among the existing answers. That does address the question "What kind of alias can I setup for a tail command...`". Perhaps a suggested edit would have been better?
    – Jeff Schaller
    Feb 22, 2022 at 19:35

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .