2PC released
This commit is contained in:
518
internal/log/logger.go
Normal file
518
internal/log/logger.go
Normal file
@@ -0,0 +1,518 @@
|
||||
/*
|
||||
* Copyright 2026 Safronov Grigorii
|
||||
*
|
||||
* Licensed under the CDDL, Version 1.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
*
|
||||
* You may obtain a copy of the License at
|
||||
* https://opensource.org/licenses/CDDL-1.0
|
||||
*/
|
||||
|
||||
package log
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
"time"
|
||||
)
|
||||
|
||||
// LogLevel представляет уровень логирования
|
||||
type LogLevel int32
|
||||
|
||||
const (
|
||||
DebugLevel LogLevel = iota
|
||||
InfoLevel
|
||||
WarnLevel
|
||||
ErrorLevel
|
||||
FatalLevel
|
||||
)
|
||||
|
||||
// String возвращает строковое представление уровня
|
||||
func (l LogLevel) String() string {
|
||||
switch l {
|
||||
case DebugLevel:
|
||||
return "DEBUG"
|
||||
case InfoLevel:
|
||||
return "INFO"
|
||||
case WarnLevel:
|
||||
return "WARN"
|
||||
case ErrorLevel:
|
||||
return "ERROR"
|
||||
case FatalLevel:
|
||||
return "FATAL"
|
||||
default:
|
||||
return "UNKNOWN"
|
||||
}
|
||||
}
|
||||
|
||||
// ParseLogLevel парсит уровень логирования из строки
|
||||
func ParseLogLevel(levelStr string) LogLevel {
|
||||
switch levelStr {
|
||||
case "debug":
|
||||
return DebugLevel
|
||||
case "info":
|
||||
return InfoLevel
|
||||
case "warn", "warning":
|
||||
return WarnLevel
|
||||
case "error":
|
||||
return ErrorLevel
|
||||
case "fatal":
|
||||
return FatalLevel
|
||||
default:
|
||||
return InfoLevel
|
||||
}
|
||||
}
|
||||
|
||||
// LogEntry представляет одну запись в логе
|
||||
type LogEntry struct {
|
||||
Timestamp int64 `json:"timestamp"`
|
||||
Level string `json:"level"`
|
||||
Message string `json:"message"`
|
||||
Source string `json:"source,omitempty"`
|
||||
Line int `json:"line,omitempty"`
|
||||
Function string `json:"function,omitempty"`
|
||||
Fields map[string]interface{} `json:"fields,omitempty"`
|
||||
}
|
||||
|
||||
// Logger представляет асинхронный логгер с поддержкой уровней
|
||||
type Logger struct {
|
||||
file *os.File
|
||||
level atomic.Int32
|
||||
writeChan chan LogEntry
|
||||
done chan struct{}
|
||||
mu sync.Mutex
|
||||
path string
|
||||
maxSize int64
|
||||
currentSize int64
|
||||
rotateCount int
|
||||
formatter LogFormatter
|
||||
}
|
||||
|
||||
// LogFormatter определяет интерфейс для форматирования логов
|
||||
type LogFormatter interface {
|
||||
Format(entry LogEntry) string
|
||||
}
|
||||
|
||||
// TextFormatter форматирует логи в текстовом виде
|
||||
type TextFormatter struct {
|
||||
includeTimestamp bool
|
||||
includeLevel bool
|
||||
includeSource bool
|
||||
}
|
||||
|
||||
// NewTextFormatter создаёт новый текстовый форматтер
|
||||
func NewTextFormatter(includeTimestamp, includeLevel, includeSource bool) *TextFormatter {
|
||||
return &TextFormatter{
|
||||
includeTimestamp: includeTimestamp,
|
||||
includeLevel: includeLevel,
|
||||
includeSource: includeSource,
|
||||
}
|
||||
}
|
||||
|
||||
// Format форматирует запись лога
|
||||
func (f *TextFormatter) Format(entry LogEntry) string {
|
||||
var parts []string
|
||||
|
||||
if f.includeTimestamp {
|
||||
parts = append(parts, time.UnixMilli(entry.Timestamp).Format("2006-01-02 15:04:05.000"))
|
||||
}
|
||||
|
||||
if f.includeLevel {
|
||||
parts = append(parts, fmt.Sprintf("[%s]", entry.Level))
|
||||
}
|
||||
|
||||
if f.includeSource && entry.Source != "" {
|
||||
parts = append(parts, fmt.Sprintf("[%s:%d]", entry.Source, entry.Line))
|
||||
}
|
||||
|
||||
parts = append(parts, entry.Message)
|
||||
|
||||
if len(entry.Fields) > 0 {
|
||||
parts = append(parts, fmt.Sprintf("%v", entry.Fields))
|
||||
}
|
||||
|
||||
return fmt.Sprintf("%s", parts)
|
||||
}
|
||||
|
||||
// JSONFormatter форматирует логи в JSON
|
||||
type JSONFormatter struct {
|
||||
pretty bool
|
||||
}
|
||||
|
||||
// NewJSONFormatter создаёт новый JSON форматтер
|
||||
func NewJSONFormatter(pretty bool) *JSONFormatter {
|
||||
return &JSONFormatter{pretty: pretty}
|
||||
}
|
||||
|
||||
// Format форматирует запись лога в JSON
|
||||
func (f *JSONFormatter) Format(entry LogEntry) string {
|
||||
type jsonLog struct {
|
||||
Timestamp int64 `json:"timestamp"`
|
||||
Level string `json:"level"`
|
||||
Message string `json:"message"`
|
||||
Source string `json:"source,omitempty"`
|
||||
Line int `json:"line,omitempty"`
|
||||
Function string `json:"function,omitempty"`
|
||||
Fields map[string]interface{} `json:"fields,omitempty"`
|
||||
}
|
||||
|
||||
logData := jsonLog{
|
||||
Timestamp: entry.Timestamp,
|
||||
Level: entry.Level,
|
||||
Message: entry.Message,
|
||||
Source: entry.Source,
|
||||
Line: entry.Line,
|
||||
Function: entry.Function,
|
||||
Fields: entry.Fields,
|
||||
}
|
||||
|
||||
if f.pretty {
|
||||
data, _ := json.MarshalIndent(logData, "", " ")
|
||||
return string(data)
|
||||
}
|
||||
data, _ := json.Marshal(logData)
|
||||
return string(data)
|
||||
}
|
||||
|
||||
// NewLogger создаёт новый экземпляр логгера
|
||||
func NewLogger(filename string, levelStr string) (*Logger, error) {
|
||||
dir := filepath.Dir(filename)
|
||||
if err := os.MkdirAll(dir, 0755); err != nil {
|
||||
return nil, fmt.Errorf("failed to create log directory: %v", err)
|
||||
}
|
||||
|
||||
file, err := os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
stat, _ := file.Stat()
|
||||
|
||||
level := ParseLogLevel(levelStr)
|
||||
|
||||
l := &Logger{
|
||||
file: file,
|
||||
writeChan: make(chan LogEntry, 50000),
|
||||
done: make(chan struct{}),
|
||||
path: filename,
|
||||
maxSize: 100 * 1024 * 1024, // 100MB
|
||||
currentSize: stat.Size(),
|
||||
rotateCount: 10,
|
||||
formatter: NewTextFormatter(true, true, false),
|
||||
}
|
||||
l.level.Store(int32(level))
|
||||
|
||||
go l.writerLoop()
|
||||
|
||||
return l, nil
|
||||
}
|
||||
|
||||
// SetFormatter устанавливает форматтер
|
||||
func (l *Logger) SetFormatter(formatter LogFormatter) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
l.formatter = formatter
|
||||
}
|
||||
|
||||
// writerLoop обрабатывает запись логов в файл
|
||||
func (l *Logger) writerLoop() {
|
||||
for entry := range l.writeChan {
|
||||
l.writeEntry(entry)
|
||||
}
|
||||
close(l.done)
|
||||
}
|
||||
|
||||
// writeEntry записывает одну запись в файл
|
||||
func (l *Logger) writeEntry(entry LogEntry) {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
|
||||
// Проверка ротации
|
||||
if l.currentSize >= l.maxSize {
|
||||
l.rotate()
|
||||
}
|
||||
|
||||
formatted := l.formatter.Format(entry)
|
||||
data := []byte(formatted + "\n")
|
||||
|
||||
if _, err := l.file.Write(data); err != nil {
|
||||
// Не можем залогировать ошибку, так как это приведёт к рекурсии
|
||||
return
|
||||
}
|
||||
|
||||
l.currentSize += int64(len(data))
|
||||
}
|
||||
|
||||
// rotate выполняет ротацию лог-файла
|
||||
func (l *Logger) rotate() {
|
||||
l.file.Sync()
|
||||
l.file.Close()
|
||||
|
||||
// Переименовываем существующий файл
|
||||
for i := l.rotateCount - 1; i >= 0; i-- {
|
||||
oldName := fmt.Sprintf("%s.%d", l.path, i)
|
||||
newName := fmt.Sprintf("%s.%d", l.path, i+1)
|
||||
|
||||
if i == 0 {
|
||||
oldName = l.path
|
||||
}
|
||||
|
||||
if _, err := os.Stat(oldName); err == nil {
|
||||
os.Rename(oldName, newName)
|
||||
}
|
||||
}
|
||||
|
||||
// Создаём новый файл
|
||||
file, err := os.OpenFile(l.path, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
l.file = file
|
||||
l.currentSize = 0
|
||||
}
|
||||
|
||||
// log внутренний метод для записи лога
|
||||
func (l *Logger) log(level LogLevel, msg string, fields map[string]interface{}) {
|
||||
if level < LogLevel(l.level.Load()) {
|
||||
return
|
||||
}
|
||||
|
||||
entry := LogEntry{
|
||||
Timestamp: time.Now().UnixMilli(),
|
||||
Level: level.String(),
|
||||
Message: msg,
|
||||
Fields: fields,
|
||||
}
|
||||
|
||||
select {
|
||||
case l.writeChan <- entry:
|
||||
default:
|
||||
// Неблокирующая запись, старый лог теряется - wait-free
|
||||
}
|
||||
}
|
||||
|
||||
// Debug записывает DEBUG сообщение
|
||||
func (l *Logger) Debug(msg string) {
|
||||
l.log(DebugLevel, msg, nil)
|
||||
}
|
||||
|
||||
// Debugf записывает форматированное DEBUG сообщение
|
||||
func (l *Logger) Debugf(format string, args ...interface{}) {
|
||||
l.log(DebugLevel, fmt.Sprintf(format, args...), nil)
|
||||
}
|
||||
|
||||
// DebugWithFields записывает DEBUG сообщение с полями
|
||||
func (l *Logger) DebugWithFields(msg string, fields map[string]interface{}) {
|
||||
l.log(DebugLevel, msg, fields)
|
||||
}
|
||||
|
||||
// Info записывает INFO сообщение
|
||||
func (l *Logger) Info(msg string) {
|
||||
l.log(InfoLevel, msg, nil)
|
||||
}
|
||||
|
||||
// Infof записывает форматированное INFO сообщение
|
||||
func (l *Logger) Infof(format string, args ...interface{}) {
|
||||
l.log(InfoLevel, fmt.Sprintf(format, args...), nil)
|
||||
}
|
||||
|
||||
// InfoWithFields записывает INFO сообщение с полями
|
||||
func (l *Logger) InfoWithFields(msg string, fields map[string]interface{}) {
|
||||
l.log(InfoLevel, msg, fields)
|
||||
}
|
||||
|
||||
// Warn записывает WARN сообщение
|
||||
func (l *Logger) Warn(msg string) {
|
||||
l.log(WarnLevel, msg, nil)
|
||||
}
|
||||
|
||||
// Warnf записывает форматированное WARN сообщение
|
||||
func (l *Logger) Warnf(format string, args ...interface{}) {
|
||||
l.log(WarnLevel, fmt.Sprintf(format, args...), nil)
|
||||
}
|
||||
|
||||
// WarnWithFields записывает WARN сообщение с полями
|
||||
func (l *Logger) WarnWithFields(msg string, fields map[string]interface{}) {
|
||||
l.log(WarnLevel, msg, fields)
|
||||
}
|
||||
|
||||
// Error записывает ERROR сообщение
|
||||
func (l *Logger) Error(msg string) {
|
||||
l.log(ErrorLevel, msg, nil)
|
||||
}
|
||||
|
||||
// Errorf записывает форматированное ERROR сообщение
|
||||
func (l *Logger) Errorf(format string, args ...interface{}) {
|
||||
l.log(ErrorLevel, fmt.Sprintf(format, args...), nil)
|
||||
}
|
||||
|
||||
// ErrorWithFields записывает ERROR сообщение с полями
|
||||
func (l *Logger) ErrorWithFields(msg string, fields map[string]interface{}) {
|
||||
l.log(ErrorLevel, msg, fields)
|
||||
}
|
||||
|
||||
// Fatal записывает FATAL сообщение и завершает программу
|
||||
func (l *Logger) Fatal(msg string) {
|
||||
l.log(FatalLevel, msg, nil)
|
||||
l.Close()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// Fatalf записывает форматированное FATAL сообщение и завершает программу
|
||||
func (l *Logger) Fatalf(format string, args ...interface{}) {
|
||||
l.log(FatalLevel, fmt.Sprintf(format, args...), nil)
|
||||
l.Close()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// FatalWithFields записывает FATAL сообщение с полями и завершает программу
|
||||
func (l *Logger) FatalWithFields(msg string, fields map[string]interface{}) {
|
||||
l.log(FatalLevel, msg, fields)
|
||||
l.Close()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
// SetLevel устанавливает уровень логирования
|
||||
func (l *Logger) SetLevel(level LogLevel) {
|
||||
l.level.Store(int32(level))
|
||||
}
|
||||
|
||||
// GetLevel возвращает текущий уровень логирования
|
||||
func (l *Logger) GetLevel() LogLevel {
|
||||
return LogLevel(l.level.Load())
|
||||
}
|
||||
|
||||
// Sync синхронизирует лог с диском
|
||||
func (l *Logger) Sync() error {
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
if l.file != nil {
|
||||
return l.file.Sync()
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Close закрывает логгер
|
||||
func (l *Logger) Close() {
|
||||
close(l.writeChan)
|
||||
<-l.done
|
||||
l.mu.Lock()
|
||||
defer l.mu.Unlock()
|
||||
if l.file != nil {
|
||||
l.file.Sync()
|
||||
l.file.Close()
|
||||
}
|
||||
}
|
||||
|
||||
// ========== Глобальные функции для удобства ==========
|
||||
|
||||
var defaultLogger *Logger
|
||||
var once sync.Once
|
||||
|
||||
// InitDefaultLogger инициализирует глобальный логгер
|
||||
func InitDefaultLogger(filename string, level string) error {
|
||||
var err error
|
||||
once.Do(func() {
|
||||
defaultLogger, err = NewLogger(filename, level)
|
||||
})
|
||||
return err
|
||||
}
|
||||
|
||||
// GetDefaultLogger возвращает глобальный логгер
|
||||
func GetDefaultLogger() *Logger {
|
||||
return defaultLogger
|
||||
}
|
||||
|
||||
// SetDefaultLogger устанавливает глобальный логгер
|
||||
func SetDefaultLogger(logger *Logger) {
|
||||
defaultLogger = logger
|
||||
}
|
||||
|
||||
// Debug глобальная функция DEBUG
|
||||
func Debug(msg string) {
|
||||
if defaultLogger != nil {
|
||||
defaultLogger.Debug(msg)
|
||||
}
|
||||
}
|
||||
|
||||
// Info глобальная функция INFO
|
||||
func Info(msg string) {
|
||||
if defaultLogger != nil {
|
||||
defaultLogger.Info(msg)
|
||||
}
|
||||
}
|
||||
|
||||
// Warn глобальная функция WARN
|
||||
func Warn(msg string) {
|
||||
if defaultLogger != nil {
|
||||
defaultLogger.Warn(msg)
|
||||
}
|
||||
}
|
||||
|
||||
// Error глобальная функция ERROR
|
||||
func Error(msg string) {
|
||||
if defaultLogger != nil {
|
||||
defaultLogger.Error(msg)
|
||||
}
|
||||
}
|
||||
|
||||
// Debugf глобальная функция форматированного DEBUG
|
||||
func Debugf(format string, args ...interface{}) {
|
||||
if defaultLogger != nil {
|
||||
defaultLogger.Debugf(format, args...)
|
||||
}
|
||||
}
|
||||
|
||||
// Infof глобальная функция форматированного INFO
|
||||
func Infof(format string, args ...interface{}) {
|
||||
if defaultLogger != nil {
|
||||
defaultLogger.Infof(format, args...)
|
||||
}
|
||||
}
|
||||
|
||||
// Warnf глобальная функция форматированного WARN
|
||||
func Warnf(format string, args ...interface{}) {
|
||||
if defaultLogger != nil {
|
||||
defaultLogger.Warnf(format, args...)
|
||||
}
|
||||
}
|
||||
|
||||
// Errorf глобальная функция форматированного ERROR
|
||||
func Errorf(format string, args ...interface{}) {
|
||||
if defaultLogger != nil {
|
||||
defaultLogger.Errorf(format, args...)
|
||||
}
|
||||
}
|
||||
|
||||
// DebugWithFields глобальная функция DEBUG с полями
|
||||
func DebugWithFields(msg string, fields map[string]interface{}) {
|
||||
if defaultLogger != nil {
|
||||
defaultLogger.DebugWithFields(msg, fields)
|
||||
}
|
||||
}
|
||||
|
||||
// InfoWithFields глобальная функция INFO с полями
|
||||
func InfoWithFields(msg string, fields map[string]interface{}) {
|
||||
if defaultLogger != nil {
|
||||
defaultLogger.InfoWithFields(msg, fields)
|
||||
}
|
||||
}
|
||||
|
||||
// WarnWithFields глобальная функция WARN с полями
|
||||
func WarnWithFields(msg string, fields map[string]interface{}) {
|
||||
if defaultLogger != nil {
|
||||
defaultLogger.WarnWithFields(msg, fields)
|
||||
}
|
||||
}
|
||||
|
||||
// ErrorWithFields глобальная функция ERROR с полями
|
||||
func ErrorWithFields(msg string, fields map[string]interface{}) {
|
||||
if defaultLogger != nil {
|
||||
defaultLogger.ErrorWithFields(msg, fields)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user