any form of the "follow" options (e.g., "tail -f", "tail --follow", etc.) it never gives anything

Hm. It's possible you have a newer version that is fundementally broken and nobody has noticed, but I seriously doubt it. It is more likely to be how you are using it. The following two scripts demonstrate that it works:

A simulated high speed, rotating logger:

#! perl -slw
use strict;

my $logname = 'theLog';

while( 1 ) {
    open LOG, '>', $logname or die $!;
    for( 1 .. 1000 ) {
        print LOG "Line $_ of the log with some superfluous extra text
+ as filler";
    }
    close LOG;
    my $n = 0;
    $n++ while -e "$logname.$n";
    rename $logname, "$logname.$n";
}
[download]

A tail -F script:

#! perl -sw
use strict;

my $pid = open LOG, "tail -F theLog |" or die $!;

$SIG{ INT } = sub{
    close LOG;
    kill 3, $pid;
    exit;
};
$SIG{ BREAK } = $SIG{ INT };

while( <LOG> ) {
    print;
}
[download]

the tail.exe process needs to be maually killed.

Methinks you have unreal expectations. Any version of tail on any platform when used with -F (--follow=name) will have to be explicitly terminated, whether manually or programmically, by some external influence. It could not be any other way.

When following a rotating named file, there will always be a short but real period between the renaming of the old log and the creation of the new one. Sp tail has to be written to ignore any 'file not found' errors from open and retry. There is therefore, no reasonable condition for it to self terminate.

So your script would have to decide the conditions under which tail should be terminated and call kill to do so using the $pid returned by the open. (See the signal handler above.)

So then it falls to your script to decide when it should terminate. Whether because

• the user interrupted it from the keyboard or via some other action;
• or because (for example,) it is monitoring the program that is producing the log and detects that it has terminated.

If the latter, it will be necessary for you to detect the demise of the log producer in a timely manner, before re-entering the read state.

You appear to be under the impression that tail will be able to know when the program producing the logs isn't going to create another new one, and self-terminate, but that simply cannot be the case.

Perhaps that is the source of your problems with File::Tail and the POE solutions. Ie. Your expectations are wrong.