File::Tail

This module can be included in your own File subclasses or used to extend files you want to tail.

Methods

A

after_reopen

B

backward

F

forward

T

tail

Classes and Modules

Constants

VERSION	=	'1.0.6'
	File::Tail version

Attributes

[RW]	max_interval	The maximum interval File::Tail sleeps, before it tries to take some action like reading the next few lines or reopening the file.
[RW]	interval	The start value of the sleep interval. This value goes against `max_interval` if the tailed file is silent for a sufficient time.
[RW]	reopen_deleted	If this attribute is set to a true value, File::Tail persists on reopening a deleted file waiting `max_interval` seconds between the attempts. This is useful if logfiles are moved away while rotation occurs but are recreated at the same place after a while. It defaults to true.
[RW]	reopen_suspicious	If this attribute is set to a true value, File::Tail attempts to reopen it’s tailed file after `suspicious_interval` seconds of silence.
[RW]	suspicious_interval	This attribute is the invterval in seconds before File::Tail gets suspicious that something has happend to it’s tailed file and an attempt to reopen it is made. If the attribute `reopen_suspicious` is set to a non true value, suspicious_interval is meaningless. It defaults to 60 seconds.
[RW]	break_if_eof	If this attribute is set to a true value, File::Fail’s tail method raises a BreakException if the end of the file is reached.
[RW]	return_if_eof	If this attribute is set to a true value, File::Fail’s tail method just returns if the end of the file is reached.
[RW]	default_bufsize	Default buffer size, that is used while going backward from a file’s end. This defaults to nil, which means that File::Tail attempts to derive this value from the filesystem block size.

Instance Public methods

after_reopen(&block)

The callback is called with self as an argument after a reopen has occured. This allows a tailing script to find out, if a logfile has been rotated.

Source: show

# File lib/file/tail.rb, line 71
    def after_reopen(&block)
      @after_reopen = block
    end

backward(n = 0, bufsize = nil)

Rewind the last n lines of this file, starting from the end. The default is to start tailing directly from the end of the file.

The additional argument bufsize is used to determine the buffer size that is used to step through the file backwards. It defaults to the block size of the filesystem this file belongs to or 8192 bytes if this cannot be determined.

Source: show

# File lib/file/tail.rb, line 117
    def backward(n = 0, bufsize = nil)
      if n <= 0
        seek(0, File::SEEK_END)
        return self
      end
      bufsize ||= default_bufsize || stat.blksize || 8192
      size = stat.size
      begin
        if bufsize < size
          seek(0, File::SEEK_END)
          while n > 0 and tell > 0 do
            start = tell
            seek(-bufsize, File::SEEK_CUR)
            buffer = read(bufsize)
            n -= buffer.count("\n")
            seek(-bufsize, File::SEEK_CUR)
          end
        else
          seek(0, File::SEEK_SET)
          buffer = read(size)
          n -= buffer.count("\n")
          seek(0, File::SEEK_SET)
        end
      rescue Errno::EINVAL
        size = tell
        retry
      end
      pos = -1
      while n < 0  # forward if we are too far back
        pos = buffer.index("\n", pos + 1)
        n += 1
      end
      seek(pos + 1, File::SEEK_CUR)
      self
    end

forward(n = 0)

Skip the first n lines of this file. The default is to don’t skip any lines at all and start at the beginning of this file.

Source: show

# File lib/file/tail.rb, line 99
    def forward(n = 0)
      seek(0, File::SEEK_SET)
      while n > 0 and not eof?
        readline
        n -= 1
      end
      self
    end

tail(n = nil)

This method tails this file and yields to the given block for every new line that is read. If no block is given an array of those lines is returned instead. (In this case it’s better to use a reasonable value for n or set the return_if_eof or break_if_eof attribute to a true value to stop the method call from blocking.)

If the argument n is given, only the next n lines are read and the method call returns. Otherwise this method call doesn’t return, but yields to block for every new line read from this file for ever.

Source: show

# File lib/file/tail.rb, line 165
    def tail(n = nil, &block) # :yields: line
      @n = n
      result = []
      array_result = false
      unless block
        block = lambda { |line| result << line }
        array_result = true
      end
      preset_attributes unless @lines
      loop do
        begin
          restat
          read_line(&block)
          redo
        rescue ReopenException => e
          until eof? || @n == 0
            block.call readline
            @n -= 1 if @n
          end
          reopen_file(e.mode)
          @after_reopen.call self if @after_reopen
        rescue ReturnException
          return array_result ? result : nil
        end
      end
    end

Module File::Tail