Unix tail command

News	Syntax	Recommended Links	Sorting algorithms	Recommended Papers	Rcut	Reference	Pipes
Perl re-implemenations	uniq	sort	tr	AWK	Tips	Humor	Etc

Unix tail tail command is a standard way of watching log files in Unix. By default the last 10 lines are displayed. tail has a special command line option -f (follow) that allows a file to be monitored. Instead of displaying the last few lines and exiting, tail displays the lines and then continue to monitors the file. As new lines are added tail updates the display. This is particularly useful for monitoring log files. For example:

tail -f /var/adm/messages

Using options the number of lines printed and the printing units (lines, blocks or bytes) may be changed. The syntax is:

tail [-f | -r] [-b number | -c number | -n number | -number | + number] [file ...]

The tail utility displays the contents of file or, by default, its standard input, to the standard output. The display begins at a byte, line, or 512-byte block location in the input. Default is lines but bytes count is possible

Typically tail is use with "minus" operation which means that the lines are counted from the end of the file. But in GNU version of tail this is actually only one of two possibilities and tail can count lines from the beginning too. Few people know about this. Still it is important to understand that:

Numbers having a leading minus (`-') sign or no explicit sign are relative to the end of the input, for example, -n 2 displays the last two lines of the input. The default starting location is -n 10, or the last 10 lines of the input. A number starting dash (-) is the synonym to that and also specifies a line offset relative to the end of the file.
So tail -10 file shows the last 10 lines of file
Numbers having a leading plus (`+') sign are relative to the beginning of the input, for example, -c +2 starts the display at the second line of the input and -c +2 fro the second byte. for example if you have a file that contain some kind of header in the first line follwing by data you need (this is often that case in tables where the first line contain names of columns). You can skip the header using tail +2 command:
```
	$ tail +2 lines
	Line 2
	Line 3
	Line 4
	Line 5
... ... ... 
```
Here a number starting with a plus (+) sign is an offset relative to the top of the file. BTW that means that tail +1 file gives you the entire file, the same as cat. +2 skips the first line, and so on

Other options are used less often include:

-b number The location is number 512-byte blocks.
-c number The location is number bytes.
-n number | -number The location is number lines.
-f This is actually a pretty important option. It means "Do not stop when end-of-file is reached, but rather to wait for additional data to be appended to the input and redisplay the tail data" If the file is replaced (i.e., the inode number changes), tail will reopen the file and continue. If the file is truncated, tail will reset its position to the beginning. This makes tail more useful for watching log files which may get rotated. The -f option is ignored if the standard input is a pipe, but not if it is a FIFO.
-r The -r option causes the input to be displayed in reverse order, by line. Additionally, this option changes the meaning of the -b, -c, and -n options. When the -r option is specified, these options specify the number of bytes, lines or 512-byte blocks to display, instead of the bytes, lines, or blocks from the beginning or end of the input from which to begin the display. The default for the -r option is to display all of the input.

If more than a single file is specified, each file is preceded by a header consisting of the string ``==> XXX <=='' where ``XXX'' is the name of the file.

The tail utility exits 0 on success or >0 if an error occurred.

Examples

To display the last 500 lines of the file foo:

$ tail -500 foo

Keep /var/log/messages open, displaying to the standard output anything appended to the file:

$ tail -f /var/log/messages

Frequently used variants often can be made into alias, for example:

alias mess='tail -100 /var/log/messages | more'

Standards

The tail utility is expected to be a superset of the IEEE Std1003.2-1992 (``POSIX.2'') specification. In particular, the -b and -r options are extensions to that standard.

The historic command line syntax of tail is supported by this implementation. The only difference between this implementation and historic versions of tail, once the command line syntax translation has been done, is that the -b, -c and -n options modify the -r option, i.e., -r -c 4 displays the last 4 characters of the last line of the input, while the historic tail (using the historic syntax -4cr) would ignore the -c option and display the last 4 lines of the input.

A tail command appeared in Version 7 AT&T UNIX.

Old News ;-)

PPT tail

#!/usr/bin/perl -w

#
# A Perl implementation of tail for the Perl Power Tools project by
# Thierry Bézecourt <thbz@worldnet.fr>. Includes an implementation
# of Chip Rosenthal's xtail.
#
# Please see the pod documentation at the end of this file.
#
# 99/12/24 : made tail -f work on VMS (thanks to Joe Kazimierczyk)
# fixed a bug when tailing small files
# 99/11/19 : important performance improvement for tail on big files
# (now usable for any file size)
# 99/03/07 : implemented xtail in the -f option
# 99/03/03 : fixed the -f option which was completely broken
# 99/03/02 : first version

PPT tail

This is the homepage for the Perl Power Tools implementation of the standard tail command.
Current Perl implementations are:

Here is a version and its manpage by Thierry Bezecourt (1999-03-07).
Supporting files: readme.thierry, mktest.thierry.

Baseline documentation:

Version 7

BSD (with POSIX.2 info, if relevant)

Perl Tail

#!/usr/bin/perl

use File::Tail;
$file=File::Tail->new( $file_to_tail );
while (defined($line=$file->read))
{
print $line;
}

The tail Command

The output from other commands can be piped (i.e., sent) to tail to use as its input. For example, the following sends the output from the ls command (which by default lists the names of the files and directories in the current directory) to tail, which, in turn, prints the final ten lines of the output that it receives from ls to the monitor screen:

ls | tail

This output could easily be redirected, for example to a file named last_filenames as follows:

ls | tail >> last_filenames

It could also be piped to one or more filters for additional processing. For example, the sort filter could be used with its -r option to sort the output in reverse alphabetic order prior to writing to a file:

ls | tail | sort -r >> last_filenames

The -q (i.e., quiet) option causes tail to not print the file name before each set of lines and to eliminate the vertical space between each set of lines when there are multiple input sources. The -v (i.e., verbose) option causes tail to print the file name even if there is just a single input file.

Tail could be viewed as a counterpart of the head command, which always starts reading from the beginning of files and which can continue until any specified distance from the beginning. However, there are a few differences. Perhaps the most useful of these is that tail is somewhat more flexible in that, in addition to being able to start reading any specified distance from the end of a file, it can also start at any specified distance from the beginning of a file.

Tail can be instructed to begin printing from some number of lines or bytes from the start of a file by preceding the number with a plus sign instead of a minus sign. For example, the following would print each of the designated files to the display monitor beginning with the seventh line and until the end:

tail +7 aardvark anteater armadillo

The c option could be used to tell tail to print each of the designated files beginning with the seventh byte instead of the seventh line:

tail +7c aardvark anteater armadillo

freshmeat.net Project details for inotail

inotail is a replacement for the 'tail' program found in the base installation of every Linux/Unix system. It makes use of the inotify infrastructure in recent versions of the Linux kernel to speed up tailing files in the follow mode (the '-f' option). Standard tail polls the file every second by default, while inotail listens to special events sent by the kernel through the inotify API to determine whether a file needs to be reread.

TTTT head and tail

Similarly, tail shows the last few lines (again, 10 by default) of a file or stream:
% ypcat passwd | tail
cal:*:1492:160:Calvin Hobbes:/home/cal:/bin/csh
adams:*:116:100:John Adams:/home/pkduck-b/adams:/bin/csh
gary:*:1177:20:Gary North:/home/pkduck-e/gary:/bin/csh
quincy:*:1092:20:Quincy Lizard:/home/triton-a/quincy:/bin/csh
talbot:*:1679:75:Bob Talbot:/home/enterprise-a/cadmec/talbot:/bin/csh
help:*:1034:31:Help Desk:/home/lewey-a/processor/help:/bin/csh
glen:*:1543:20:Glen Carpenter:/home/pkduck-e/glen:/bin/csh 
brent:*:1799:706:Brent Adams:/home/dogbert-a/brent:/bin/csh
lou:*:1701:30:Lou Grant:/home/pkduck-h/lou:/bin/csh 
adam:*:1124:317:Adam Baker:/home/lewey-d/adam:/bin/csh
As with head, you can specify the number of lines from the end of the file at which to start display by prefacing the number with a hyphen ("-"). You can also specify the location as a number of lines from the beginning by prefacing the number with a plus sign ("+"):
% wc -l /usr/man/man1/tail.1
     143 /usr/man/man1/tail.1
% tail +141 /usr/man/man1/tail.1
.LP
Various kinds of anomalous behavior may happen with character special
files.
% tail -3 /usr/man/man1/tail.1
.LP
Various kinds of anomalous behavior may happen with character special
files.
Since the tail man page has 143 lines, "tail +141" is equivalent to "tail -3" in this case.
Unlike with head, tail will operate on units other than lines. By adding the character "b" to the number, you can display the last blocks, and with "c" the last characters:
% tail -10c /usr/man/man1/tail.1
al
files.
Don't forget about newlines.
tail also has the unexpected function that it allows you to reverse the lines spewed. By default, with just the "-r" flag, tail displays the whole file in reverse order by line:
% cat > foo << END
this
is
a
test
END
% tail -r foo
test
a
is
this
A number of lines to reverse can be included, but it cannot be relative to the beginning of the file, only the end. ("+" acts just like "-")
tail also has the wildly useful feature that it can be told to wait around for further input to a file rather than stopping when it gets to the end. This is especially useful to monitor the progress of a process whose output you have redirected to a file:
% clearmake >& Transcript &
[1] 12688
% tail -f Transcript
[the output from the clearmake will be displayed here as it arrives in "Transcript"]
When called in this manner, the tail will continue to read lines from the file and wait for more until you kill it ("^C" is handy here ;-) even after the clearmake has completed and there is no longer output being appended to the file.
One final difference between head and tail: while head will operate on multiple files, tail will not, so don't expect something like "tail foo bar biff" to show anything more than the last 10 lines of "foo".

Unix tail command

Examples

See Also

Standards

Old News ;-)

PPT tail

PPT tail

Perl Tail

The tail Command

freshmeat.net Project details for inotail

TTTT head and tail

Recommended Links

PPT tail

tail (Unix) - Wikipedia, the free encyclopedia

docs.sun.com man pages section 1 User Commands

TTTT head and tail

freshmeat.net Project details for inotail