Add an option to tail the last N lines about node-tail

[schu34]

Any chance of this being added? It's exactly the functionality I was looking for.

[batjko]

I am experimenting with this package and was surprised to find that the "line" event fires for each line as expected, but it gets executed again and again for hundreds of pre-existing lines, even though I added only a single new line at the end of the file.

How can we just catch that last new line (or however many new lines have actually been added)?

[nicolas-goudry]

For what it’s worth, this package does this out of the box 😜

[hamen]

👍

[lucagrulla]

There's no way at the moment to tail only a certain number of lines. It's either from the beginning of the file or from the latest line. I can see the need of mirroring the tail -n behaviour; the problem is that I can't see a neat way to do this with the current params list; this means I'll have to do some refactoring in the constructor signature(adding yet another params is a no, the signature is getting too long).

[dated]

Is this feature planned @lucagrulla?

[lucagrulla]

Unfortunately no.

There's no clean way to idenitfy N lines from file's tail, you can only go via trial and error (read a large of past data, count all the lines, repeat if you missed the mark).

That makes it very inefficient and error prone.
Unless something new appears in the underlying Nodejs core API I'm not looking at doing this any time soon.

[wearhere]

Here's an implementation that appears to seek character-by-character backward from the end of the file, tracking newlines, until it locates enough lines https://github.com/alexbbt/read-last-lines/blob/master/src/index.js. So, inefficient, yes, error prone, unsure. In any case this doesn't do tailing, just retrieves the last N lines, unfortunately.

What I would be most curious about would be how to merge such an implementation with tailing, making sure that while you were progressively seeking from the end of the file, you also were keeping track of new data appended to the file. I personally would take the hit on efficiency so long as the implementation was correct (in that way), because I suspect that the implementation would overall be faster and more memory-efficient for long logfiles than what I am currently doing, which is

// The 'tail' module lacks a `-n`-like option to get the last `N` lines. So what we
// do is load the entire file, but wait to render only the last `N` lines, then
// start streaming.
const N = 100;
const logs = [];
let initialDataFlushed = false;
const tail = new Tail(logfile, { fromBeginning: true });
tail
  .on('line', (line) => {
    if (initialDataFlushed) {
      console.log(line);
    } else {
      logs.push(line);
      if (logs.length > N) logs.shift();
    }
  })
  .on('historicalDataEnd', () => {
    logs.forEach((line) => console.log(line));
    logs = [];
    initialDataFlushed = true;
  })
  .on('error', (err) => console.error(err));

[lucagrulla]

Available since v.2.2.0.