Как прочитать последние 10 строк файла log?

Как прочитать последние 10 строк файла log на Go

Для чтения последних строк файла в Go есть несколько эффективных подходов, каждый со своими преимуществами и сценариями использования. Основная сложность заключается в том, что файлы логов могут быть очень большими, и чтение всего файла в память будет неэффективно.

Основные подходы

1. Использование bufio.Scanner с кольцевым буфером

Наиболее прямой метод — сканировать файл с конца, сохраняя последние N строк:

package main

import (
    "bufio"
    "bytes"
    "fmt"
    "io"
    "os"
)

func readLastLines(filename string, numLines int) ([]string, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    // Используем кольцевой буфер для хранения последних строк
    lines := make([]string, 0, numLines)
    scanner := bufio.NewScanner(file)
    
    for scanner.Scan() {
        lines = append(lines, scanner.Text())
        if len(lines) > numLines {
            // Удаляем самую старую строку
            lines = lines[1:]
        }
    }
    
    if err := scanner.Err(); err != nil {
        return nil, err
    }
    
    return lines, nil
}

func main() {
    lines, err := readLastLines("app.log", 10)
    if err != nil {
        panic(err)
    }
    
    for _, line := range lines {
        fmt.Println(line)
    }
}

2. Оптимизированный подход с чтением с конца файла

Для очень больших файлов более эффективно читать файл с конца:

package main

import (
    "bufio"
    "bytes"
    "fmt"
    "io"
    "os"
)

func readLastLinesOptimized(filename string, numLines int) ([]string, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    defer file.Close()

    // Определяем размер файла
    stat, err := file.Stat()
    if err != nil {
        return nil, err
    }
    
    fileSize := stat.Size()
    bufSize := int64(4096) // Начальный размер буфера
    var buf []byte
    var lines []string
    
    // Читаем файл с конца
    for pos := fileSize; pos > 0 && len(lines) < numLines; {
        readSize := bufSize
        if pos < readSize {
            readSize = pos
        }
        pos -= readSize
        
        // Сдвигаемся к нужной позиции
        _, err = file.Seek(pos, io.SeekStart)
        if err != nil {
            return nil, err
        }
        
        // Читаем блок данных
        chunk := make([]byte, readSize)
        _, err = io.ReadFull(file, chunk)
        if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
            return nil, err
        }
        
        buf = append(chunk, buf...)
        
        // Ищем переводы строк в буфере
        lineSep := []byte{'\n'}
        linesCount := bytes.Count(buf, lineSep)
        
        if linesCount > numLines {
            // Нашли достаточно строк
            firstLineIndex := bytes.LastIndex(buf, lineSep)
            for i := 0; i < numLines; i++ {
                nextLineIndex := bytes.LastIndex(buf[:firstLineIndex], lineSep)
                if nextLineIndex == -1 {
                    break
                }
                firstLineIndex = nextLineIndex
            }
            buf = buf[firstLineIndex+1:]
            break
        }
        
        // Увеличиваем буфер для следующей итерации
        bufSize *= 2
    }
    
    // Разбиваем оставшийся буфер на строки
    scanner := bufio.NewScanner(bytes.NewReader(buf))
    for scanner.Scan() {
        lines = append(lines, scanner.Text())
    }
    
    // Возвращаем только последние numLines строк
    if len(lines) > numLines {
        lines = lines[len(lines)-numLines:]
    }
    
    return lines, nil
}

3. Использование пакета tail

Для production-решений часто используют специализированные библиотеки:

package main

import (
    "fmt"
    "github.com/hpcloud/tail"
)

func tailFile(filename string, lines int) error {
    config := tail.Config{
        Follow:    false,
        ReOpen:    false,
        MustExist: true,
        Poll:      true,
        Location: &tail.SeekInfo{
            Offset: 0,
            Whence: 2, // От конца файла
        },
    }
    
    t, err := tail.TailFile(filename, config)
    if err != nil {
        return err
    }
    
    var lastLines []string
    for line := range t.Lines {
        lastLines = append(lastLines, line.Text)
        if len(lastLines) > lines {
            lastLines = lastLines[1:]
        }
    }
    
    for _, line := range lastLines {
        fmt.Println(line)
    }
    
    return nil
}

Сравнение подходов

Подход 1 (Scanner с кольцевым буфером):

• ✅ Простота реализации
• ✅ Хорошо работает с файлами среднего размера
• ❌ Читает весь файл, что неэффективно для очень больших логов

Подход 2 (Чтение с конца):

• ✅ Оптимален для очень больших файлов
• ✅ Не загружает весь файл в память
• ❌ Более сложная реализация
• ❌ Требует точной обработки кодировок

Подход 3 (Использование библиотеки tail):

• ✅ Наиболее надежный вариант
• ✅ Поддержка реального time tracking
• ✅ Обработка ротации логов
• ❌ Добавляет внешнюю зависимость

Рекомендации для production

Для production-систем я рекомендую:

1. Для простых случаев использовать первый подход с ограничением по максимальному размеру файла
2. Для обработки больших логов реализовать или использовать оптимизированное чтение с конца
3. В критически важных системах использовать проверенные библиотеки типа hpcloud/tail
4. Всегда добавлять обработку ошибок и лимитирование по памяти
5. Учитывать кодировку файла (особенно для Windows, где используется \r\n)

Важные замечания

• При чтении бинарных файлов нужно быть осторожным с обработкой конца строк
• Для файлов с переменной длиной строки (unicode) требуется дополнительная обработка
• В высоконагруженных системах стоит кэшировать результат чтения
• Всегда проверяйте наличие файла и права доступа перед чтением

Выбор конкретного подхода зависит от размера файлов, требований к производительности и сложности логики обработки. Для большинства стандартных задач достаточно первого подхода с кольцевым буфером.