From d1c75ac0a68005fe139e6fe44a82152834d9778b Mon Sep 17 00:00:00 2001 From: ScuroNeko Date: Wed, 28 Jan 2026 16:44:11 +0300 Subject: [PATCH] v0.2.3 --- laniakea/bot.go | 12 +-- laniakea/logger.go | 243 +++++++++++++++++++++++++++++++++------------ 2 files changed, 184 insertions(+), 71 deletions(-) diff --git a/laniakea/bot.go b/laniakea/bot.go index dce1d24..8901e7e 100644 --- a/laniakea/bot.go +++ b/laniakea/bot.go @@ -106,11 +106,11 @@ func NewBot(settings *BotSettings) *Bot { level = DEBUG } - bot.logger = CreateLogger().Level(level).PrintTraceback(true) - bot.logger.AddWriter(bot.logger.CreateStdoutWriter()) + bot.logger = CreateLogger().Level(level) + bot.logger.AddWriter(bot.logger.CreateJsonStdoutWriter()) if settings.WriteToFile { path := fmt.Sprintf("%s/main.log", strings.TrimRight(settings.LoggerBasePath, "/")) - fileWriter, err := bot.logger.CreateFileWriter(path) + fileWriter, err := bot.logger.CreateTextFileWriter(path) if err != nil { bot.logger.Fatal(err) } @@ -119,10 +119,10 @@ func NewBot(settings *BotSettings) *Bot { if settings.UseRequestLogger { bot.requestLogger = CreateLogger().Level(level).Prefix("REQUESTS") - bot.requestLogger.AddWriter(bot.requestLogger.CreateStdoutWriter()) + bot.requestLogger.AddWriter(bot.requestLogger.CreateJsonStdoutWriter()) if settings.WriteToFile { path := fmt.Sprintf("%s/requests.log", strings.TrimRight(settings.LoggerBasePath, "/")) - fileWriter, err := bot.requestLogger.CreateFileWriter(path) + fileWriter, err := bot.requestLogger.CreateTextFileWriter(path) if err != nil { bot.logger.Fatal(err) } @@ -146,7 +146,7 @@ func (b *Bot) InitDatabaseContext(ctx *DatabaseContext) *Bot { b.dbContext = ctx return b } -func (b *Bot) AddDatabaseLogger(writer func(db *DatabaseContext) *LoggerWriter) *Bot { +func (b *Bot) AddDatabaseLogger(writer func(db *DatabaseContext) LoggerWriter) *Bot { w := writer(b.dbContext) b.logger.AddWriter(w) if b.requestLogger != nil { diff --git a/laniakea/logger.go b/laniakea/logger.go index 483c514..b4ae674 100644 --- a/laniakea/logger.go +++ b/laniakea/logger.go @@ -1,6 +1,8 @@ package laniakea import ( + "bufio" + "encoding/json" "fmt" "io" "os" @@ -13,30 +15,91 @@ import ( "github.com/fatih/color" ) -type LoggerWriter struct { - writer io.Writer - writeFn LoggerWriterFn - logger *Logger +type LoggerWriter interface { + Close() error + Write(p []byte) (n int, err error) + Print(level LogLevel, prefix string, traceback []*MethodTraceback, messages ...any) error +} +type LoggerTextWriter struct { + LoggerWriter + writer io.Writer + printTraceback bool + printTime bool } -func (w *LoggerWriter) SetFn(fn LoggerWriterFn) { - w.writeFn = fn +func (w *LoggerTextWriter) Write(p []byte) (n int, err error) { + n, err = w.writer.Write(p) + if err != nil { + return n, err + } + err = bufio.NewWriter(w.writer).Flush() + return n, err } -func (w *LoggerWriter) Write(p []byte) (n int, err error) { - return w.writer.Write(p) +func (w *LoggerTextWriter) Print(level LogLevel, prefix string, tb []*MethodTraceback, messages ...any) error { + s := buildString(level, prefix, true, w.printTraceback, w.printTime, messages...) + _, err := w.Write([]byte(s)) + return err } -func (w *LoggerWriter) Close() error { +func (w *LoggerTextWriter) Close() error { return w.writer.(io.Closer).Close() } -type LoggerWriterFn func(level LogLevel, prefix, traceback string, message []any) error +type LoggerJsonWriter struct { + LoggerWriter + writer io.Writer + pretty bool +} +type LoggerJsonMessage struct { + Time time.Time `json:"time"` + Level string `json:"level"` + Prefix string `json:"prefix"` + Message string `json:"message"` + Traceback []*MethodTraceback `json:"traceback"` +} + +func (w *LoggerJsonWriter) Write(data []byte) (int, error) { + n, err := w.writer.Write(data) + if err != nil { + return n, err + } + err = bufio.NewWriter(w.writer).Flush() + return n, err +} +func (w *LoggerJsonWriter) Print(level LogLevel, prefix string, traceback []*MethodTraceback, messages ...any) error { + msg := Map(messages, func(el any) string { + return fmt.Sprintf("%v", el) + }) + m := LoggerJsonMessage{ + Time: time.Now(), + Level: level.GetName(), + Prefix: prefix, + Message: strings.Join(msg, " "), + Traceback: traceback, + } + var data []byte + var err error + if w.pretty { + data, err = json.MarshalIndent(m, "", " ") + } else { + data, err = json.Marshal(m) + } + if err != nil { + return err + } + _, err = w.Write(append(data, []byte("\n")...)) + return err +} +func (w *LoggerJsonWriter) Close() error { + return w.writer.(io.Closer).Close() +} type Logger struct { prefix string level LogLevel printTraceback bool printTime bool - writers []*LoggerWriter + jsonPretty bool + writers []LoggerWriter } type LogLevel struct { @@ -50,12 +113,12 @@ func (l *LogLevel) GetName() string { } type MethodTraceback struct { - Package string - Method string + Package string `json:"package"` + Method string `json:"method"` fullPath string signature string - filename string - line int + Filename string `json:"filename"` + Line int `json:"line"` } var ( @@ -75,7 +138,7 @@ func CreateLogger() *Logger { } } -func (l *Logger) CreateFileWriter(path string) (*LoggerWriter, error) { +func (l *Logger) CreateTextFileWriter(path string) (*LoggerTextWriter, error) { err := os.MkdirAll(filepath.Dir(path), os.ModePerm) if err != nil { return nil, err @@ -85,22 +148,46 @@ func (l *Logger) CreateFileWriter(path string) (*LoggerWriter, error) { return nil, err } - writer := &LoggerWriter{ - writer: file, logger: l, - } - writer.writeFn = func(level LogLevel, prefix, traceback string, message []any) error { - _, err = writer.Write([]byte(writer.logger.buildString(level, message) + "\n")) - return err + writer := &LoggerTextWriter{ + writer: file, printTraceback: l.printTraceback, printTime: l.printTime, } return writer, nil } -func (l *Logger) CreateStdoutWriter() *LoggerWriter { - writer := &LoggerWriter{ - writer: os.Stdout, logger: l, +func (l *Logger) CreateTextStdoutWriter() *LoggerTextWriter { + writer := &LoggerTextWriter{ + writer: os.Stdout, printTraceback: l.printTraceback, printTime: l.printTime, } - writer.writeFn = func(level LogLevel, prefix, traceback string, message []any) error { - _, err := color.New(level.c).Fprint(writer.writer, writer.logger.buildString(level, message)) - return err + return writer +} +func (l *Logger) CreateJsonStdoutWriter() *LoggerJsonWriter { + writer := &LoggerJsonWriter{ + writer: os.Stdout, pretty: l.jsonPretty, + } + return writer +} +func (l *Logger) CreateJsonFileWriter(path string) (*LoggerJsonWriter, error) { + err := os.MkdirAll(filepath.Dir(path), os.ModePerm) + if err != nil { + return nil, err + } + file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644) + if err != nil { + return nil, err + } + writer := &LoggerJsonWriter{ + writer: file, pretty: l.jsonPretty, + } + return writer, nil +} +func (l *Logger) CreateTextWriter(w io.Writer) *LoggerTextWriter { + writer := &LoggerTextWriter{ + writer: w, printTraceback: l.printTraceback, printTime: l.printTime, + } + return writer +} +func (l *Logger) CreateJsonWriter(w io.Writer) *LoggerJsonWriter { + writer := &LoggerJsonWriter{ + writer: w, pretty: l.jsonPretty, } return writer } @@ -121,44 +208,61 @@ func (l *Logger) PrintTime(b bool) *Logger { l.printTime = b return l } -func (l *Logger) AddWriters(writers ...*LoggerWriter) *Logger { +func (l *Logger) JsonPretty(b bool) *Logger { + l.jsonPretty = b + return l +} +func (l *Logger) AddWriters(writers ...LoggerWriter) *Logger { l.writers = append(l.writers, writers...) return l } -func (l *Logger) AddWriter(writer *LoggerWriter) *Logger { +func (l *Logger) AddWriter(writer LoggerWriter) *Logger { l.writers = append(l.writers, writer) return l } -func (l *Logger) Infof(format string, m ...any) { - l.print(INFO, []any{fmt.Sprintf(format, m...)}) +func (l *Logger) Infof(format string, args ...any) { + l.print(INFO, fmt.Sprintf(format, args...)) } func (l *Logger) Info(m ...any) { - l.print(INFO, m) + l.println(INFO, m...) } +func (l *Logger) Warnf(format string, args ...any) { + l.print(WARN, fmt.Sprintf(format, args...)) +} func (l *Logger) Warn(m ...any) { - l.print(WARN, m) + l.println(WARN, m...) } func (l *Logger) Error(m ...any) { - l.print(ERROR, m) + l.println(ERROR, m...) } func (l *Logger) Fatal(m ...any) { - l.print(FATAL, m) + l.println(FATAL, m...) os.Exit(1) } func (l *Logger) Debug(m ...any) { - l.print(DEBUG, m) + l.println(DEBUG, m...) } -func (l *Logger) formatTime(t time.Time) string { +func formatTime(t time.Time) string { return fmt.Sprintf("%02d.%02d.%02d %02d:%02d:%02d", t.Day(), t.Month(), t.Year(), t.Hour(), t.Minute(), t.Second()) } +func formatTraceback(mt *MethodTraceback) string { + return fmt.Sprintf("%s:%s:%d", mt.Filename, mt.Method, mt.Line) +} +func FormatFullTraceback(tracebacks []*MethodTraceback) string { + formatted := make([]string, 0) + for _, tb := range tracebacks { + formatted = append(formatted, formatTraceback(tb)) + } + return strings.Join(formatted, "->") +} -func (l *Logger) getTraceback() *MethodTraceback { +func getTraceback() *MethodTraceback { caller, _, _, _ := runtime.Caller(4) details := runtime.FuncForPC(caller) signature := details.Name() @@ -169,9 +273,9 @@ func (l *Logger) getTraceback() *MethodTraceback { pkg, method := splitSignature[0], splitSignature[len(splitSignature)-1] tb := &MethodTraceback{ - filename: splitPath[len(splitPath)-1], + Filename: splitPath[len(splitPath)-1], fullPath: path, - line: line, + Line: line, signature: signature, Package: pkg, Method: method, @@ -179,11 +283,7 @@ func (l *Logger) getTraceback() *MethodTraceback { return tb } -func (l *Logger) formatTraceback(mt *MethodTraceback) string { - return fmt.Sprintf("%s:%s:%d", mt.filename, mt.Method, mt.line) -} - -func (l *Logger) getFullTraceback(skip int) []*MethodTraceback { +func getFullTraceback(skip int) []*MethodTraceback { pc := make([]uintptr, 15) runtime.Callers(skip, pc) list := make([]*MethodTraceback, 0) @@ -202,9 +302,9 @@ func (l *Logger) getFullTraceback(skip int) []*MethodTraceback { pkg, method := splitSignature[0], splitSignature[len(splitSignature)-1] tb := &MethodTraceback{ - filename: splitPath[len(splitPath)-1], + Filename: splitPath[len(splitPath)-1], fullPath: path, - line: line, + Line: line, signature: signature, Package: pkg, Method: method, @@ -216,42 +316,55 @@ func (l *Logger) getFullTraceback(skip int) []*MethodTraceback { }) return list } -func (l *Logger) formatFullTraceback(tracebacks []*MethodTraceback) string { - formatted := make([]string, 0) - for _, tb := range tracebacks { - formatted = append(formatted, l.formatTraceback(tb)) - } - return strings.Join(formatted, "->") -} -func (l *Logger) buildString(level LogLevel, m []any) string { +func buildString(level LogLevel, prefix string, newline, printTime, printTraceback bool, m ...any) string { args := []string{ - fmt.Sprintf("[%s]", l.prefix), + fmt.Sprintf("[%s]", prefix), fmt.Sprintf("[%s]", strings.ToUpper(level.t)), } - if l.printTraceback { - args = append(args, fmt.Sprintf("[%s]", l.formatTraceback(l.getTraceback()))) + if printTraceback { + args = append(args, fmt.Sprintf("[%s]", formatTraceback(getTraceback()))) } - if l.printTime { - args = append(args, fmt.Sprintf("[%s]", l.formatTime(time.Now()))) + if printTime { + args = append(args, fmt.Sprintf("[%s]", formatTime(time.Now()))) } msg := Map(m, func(el any) string { return fmt.Sprintf("%v", el) }) - - return fmt.Sprintf("%s %v", strings.Join(args, " "), strings.Join(msg, " ")) + s := fmt.Sprintf("%s %s", strings.Join(args, " "), strings.Join(msg, " ")) + if newline { + s += "\n" + } + return s } -func (l *Logger) print(level LogLevel, m []any) { +func (l *Logger) print(level LogLevel, m ...any) { if l.level.n < level.n { return } + tb := getFullTraceback(0) for _, writer := range l.writers { - err := writer.writeFn(level, l.prefix, l.formatFullTraceback(l.getFullTraceback(0)), m) + err := writer.Print(level, l.prefix, tb, m...) + if err != nil { + l.Error(err) + } + } +} + +// Docker requires "\n" at end to write to log. +// print not work for docker, otherwise it will work and write into stdout +func (l *Logger) println(level LogLevel, m ...any) { + if l.level.n < level.n { + return + } + + tb := getFullTraceback(0) + for _, writer := range l.writers { + err := writer.Print(level, l.prefix, tb, m...) if err != nil { l.Error(err) }