Only output most recent 10 (or n) lines of a lengthy command output

Question

I have a command that outputs thousands of lines. I actually need these lines in order to see the progress of the command. But I do not need to see more than the 10 most recent lines.

How can I do that?

I already tried using a pipe and tail. But it did not work. I just got the last ten lines after the original command finished:

whatever command that has too much output | tail -f

It is important that the console does not get cleared or something like this because there is some important infomation that gets printed right before the command with the lengthy output.
An example:

echo "Very important information. MUST BE VISIBLE!"

# This gives me about 10,000 lines of output pretty fast!
# This output should be shrinked down to the most recent 10
tar -cvf "Bckup.tar" "folder to backup/"

# More code

I hope this clears it up.

EDIT:

The problem with multitail is that it takes up the entire screen. So if I had more than just one output (which I have. Multiple commands with important information are run before this. And I need to use it multiple times).

Something like running this in screen with just 10 lines to display would be perfect. (I know that does not work).

You could imagine that like there is some output from other commands. Then I call the command with the lengthy output. This output stays in a screen that only can display something like 10 lines. After the command is finished more output goes to the console and this should be right beneth it like normal output.

Output
Important Information
Other commands output
----------------------------------------
some lines for the tar command





----------------------------------------
More output
....
....

(Just without the lines)

Answer 1

There is an escape sequence for ECMA-48 (vt100-ish) terminals that restricts scrolling to a subset of lines:

CSI top ; bottom r

Here's a demonstration

# Start with the screen clean and cursor on line 1
clear

# print the non-scrolling banner line
echo Hello world

# set up the scrolling region to lines 2 through 11 and position the
# cursor at line 2
echo -n '^[[2;11r^[[2H'

# Run a command that will produce more than 10 lines, with a slight delay
# so it doesn't happen so fast you can't see it scrolling
perl -MTime::HiRes=sleep -le 'for(1..100) { print; sleep 0.05; }'

# Restore normal scrolling and put cursor on line 12
echo -n '^[[r^[[12H'

Note: All instances of ^[ in the above must be actual escape characters in the script. In vi, for example, they are entered in inset mode with CtrlV followed by Esc.

Answer 2

Multitail is a tail -f on steroids. Its abilities include splitting the screen and showing multiple files or commands.

If the important lines come from a file:

tar -cvf "Bckup.tar" "folder to backup/" | multitail important.txt -j

If the important lines are the output of a command:

tar -cvf "Bckup.tar" "folder to backup/" | multitail -l 'show-stuff --important' -j

Answer 3

If I understand correctly BrainStone is asking for a "scrolling window".

You can achieve that with Curses and perl:

#! /usr/bin/perl

use strict;
use warnings;
use Curses;

$SIG{INT} = sub { endwin; exit(0); };

initscr();

my $w = newwin(11, COLS(), 10, 1);
$w->scrollok(1);

my $a=0;
while(<>) {
    $a++ if($a < 10);
    $w->addstr($a, 0, $_);
    $w->refresh();
}
endwin;

This will create a "scrolling window" at line 10, 10 lines long which will display the output of a piped command. You will have to alter it to suit your needs, but the basic premise is there. You might want to handle all your shell commands inside perl, and have it all in one script. Or you could, for example, use the command arguments to pass the Very important information. MUST BE VISIBLE! string, or may be a file name that contains the important information. And display that before the scrolling window is created.

I've done a more in depth version on pastebin, which handles a few command options (such as size of scroll window, number of lines in the terminal to offset the window and a "header file" to display before the output). Details of the command options and some additional comments are provided.

Example

Using the code above as is, if you put it into a file named scroller.pl, just set the files permissions so it's executable:

$ chmod +x scroller.pl

You can then use it to show the output from a long running command like so:

$ seq 10000 | scroller.pl

                       

This version will then exit when the output being piped into scroller.pl is complete, and return you to your normal shell setup.

Answer 4

Here's a simple bash script you can use to monitor the output of your command (the command in this example is rpm -qa) line by line with a manually define sleep timer. It also appends your output to a temp file for reference following script completion. As for cycling through a 10 line buffer, I'm unable to think of a solution at this point.

#!/bin/bash

syntax="rpm -qa"
command=( $($syntax) )
echo "Using: $syntax"
for line in "${command[@]}"
 do
  echo "$line" >> /tmp/temp.file
  echo -ne "OUTPUT: $line\033[0K\r"
  sleep 0.2
done
echo

Answer 5

If you always want to see just the last N lines, I don't think you can avoid using a temporary file. Something like this:

while true; do sleep 1; date +%s >> temp_file; done

Then, in another terminal, run

while true; do clear; tail -n 10 temp_file;sleep 1; done

That last command will i) clear the terminal, ii) print the last 10 lines of the temp file and iii) wait for one second. The result will be a continuously updating dump of the current last 10 lines of the temp file.

As far as I know, there is no way of doing this while keeping the original command in sight in a single terminal.

---

I can't seem to get this to work for multiple lines, but this works for single lines:

#!/bin/bash

echo "Very important information. MUST BE VISIBLE!"
while tar -cvf "Bckup.tar" lmde_backup/www/lycabettus/ >tmp_file 2>&1 & do 
    output=$(tail -n 1 aa); 
    echo -ne "$output\r";
done

It does result in artifacts when the current line is shorter than the last one so it really is not perfect but you might be able to improve on it.