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?


24 Answers 24


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
    Commented 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. Commented 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
    Commented Jun 29, 2012 at 10:32
  • 10
    @Benjamin Add ; next before the closing braces to skip further processing, and a new processing line 1 {print} at the end (1 means always). Commented 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/' Commented 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
    Commented 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'. Commented 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
    Commented 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
    Commented Jul 12, 2014 at 9:51
  • 5
    This looks pretty terrible on nginx logs i.imgur.com/aJbIOfL.png
    – mpen
    Commented 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. Commented Mar 1, 2011 at 21:33
  • Upvoting because while the perl/ansi trick might not, ccze does. Commented 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. Commented 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. Commented Jun 4, 2013 at 6:06
  • 2
    @BЈовић Mac is a Unix.
    – Chris Down
    Commented 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
    Commented Aug 29, 2020 at 17:49
  • Available in Fedora
    – Yetti99
    Commented 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
    Commented 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
    Commented 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? Commented Jan 2, 2023 at 11:37

You can use colortail:

colortail -f /var/log/messages
  • 3
    +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
    Commented 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
    Commented 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
    Commented May 5, 2019 at 11:19
  • Just install colortail with, apt install colortail and it should work without editing ~/.colortail/ too.
    – Kartik M
    Commented 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
    Commented 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
    Commented 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. Commented 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. Commented 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? Commented Apr 13, 2015 at 10:40
  • 1
    @Asclepius fixed (I believe it's the same script) Commented Aug 3, 2023 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. Commented Mar 16, 2011 at 22:45
  • Available in Fedora 19.
    – sjas
    Commented Sep 29, 2013 at 14:55
  • And Ubuntu 12.10.
    – sjas
    Commented 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
    Commented Jan 27, 2014 at 3:46
  • looks like it depends on boost, which is around 462MB
    – ecsos
    Commented 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
    Commented 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
    Commented 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. Commented 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. Commented 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
    Commented Feb 22, 2022 at 19:35

There is a new open source tool (Logdy.dev) that satisfies the need. You can use TypeScript to parse and transform the content of log messages. All of that in a web UI that comes filters/facets.

Update: you can style each individual row or cell by applying a style in a Message or CellHandler handler.

For example, here is a code that makes the background of a column with an error level cell row red. The code is applied for a level column.

(line: Message): CellHandler => {
    return {
        text: line.json_content.level,
        style: {
            background: line.json_content.level === 'error' ? "red" : ""
        facets: [
            { name: "Level", value: line.json_content.level }

enter image description here

  • 1
    (1) What does your image illustrate?  I don’t see any color (except for a tiny bit of decorative trim), so it doesn’t look like either an example of colorized output or configuration / setup.  (2) It looks like this tool produces HTML output for a web browser.  The question is tagged “command-line”.  I don’t know whether the fact that this tool is invoked via the command line is enough to qualify it as a valid answer.  Can it output to a terminal?      Please do not respond in comments; edit your answer to make it clearer and more complete. Commented Mar 25 at 16:36
  • In fact, I don't see anything on the website for this tool that suggests that it can even do what this question asks for, namely to colorize (some of) the output. Commented Mar 26 at 19:34
  • thanks, that's a fair call out, I've updated the original message.
    – spinache
    Commented Mar 27 at 22:26

You must log in to answer this question.

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