v0.2.3

laniakea/bot.go

@@ -106,11 +106,11 @@ func NewBot(settings *BotSettings) *Bot {
 		level = DEBUG
 	}
 
-	bot.logger = CreateLogger().Level(level).PrintTraceback(true)
+	bot.logger = CreateLogger().Level(level)
-	bot.logger.AddWriter(bot.logger.CreateStdoutWriter())
+	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 {

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 {
+type LoggerWriter interface {
-	writer  io.Writer
+	Close() error
-	writeFn LoggerWriterFn
+	Write(p []byte) (n int, err error)
-	logger  *Logger
+	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) {
+func (w *LoggerTextWriter) Write(p []byte) (n int, err error) {
-	w.writeFn = fn
+	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) {
+func (w *LoggerTextWriter) Print(level LogLevel, prefix string, tb []*MethodTraceback, messages ...any) error {
-	return w.writer.Write(p)
+	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
+	Package   string `json:"package"`
-	Method    string
+	Method    string `json:"method"`
 	fullPath  string
 	signature string
-	filename  string
+	Filename  string `json:"filename"`
-	line      int
+	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 := &LoggerTextWriter{
-		writer: file, logger: l,
+		writer: file, printTraceback: l.printTraceback, printTime: l.printTime,
-	}
-	writer.writeFn = func(level LogLevel, prefix, traceback string, message []any) error {
-		_, err = writer.Write([]byte(writer.logger.buildString(level, message) + "\n"))
-		return err
 	}
 	return writer, nil
 }
-func (l *Logger) CreateStdoutWriter() *LoggerWriter {
+func (l *Logger) CreateTextStdoutWriter() *LoggerTextWriter {
-	writer := &LoggerWriter{
+	writer := &LoggerTextWriter{
-		writer: os.Stdout, logger: l,
+		writer: os.Stdout, printTraceback: l.printTraceback, printTime: l.printTime,
 	}
-	writer.writeFn = func(level LogLevel, prefix, traceback string, message []any) error {
+	return writer
-		_, err := color.New(level.c).Fprint(writer.writer, writer.logger.buildString(level, message))
+}
-		return err
+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) {
+func (l *Logger) Infof(format string, args ...any) {
-	l.print(INFO, []any{fmt.Sprintf(format, m...)})
+	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 {
+func getFullTraceback(skip int) []*MethodTraceback {
-	return fmt.Sprintf("%s:%s:%d", mt.filename, mt.Method, mt.line)
-}
-
-func (l *Logger) 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 {
+	if printTraceback {
-		args = append(args, fmt.Sprintf("[%s]", l.formatTraceback(l.getTraceback())))
+		args = append(args, fmt.Sprintf("[%s]", formatTraceback(getTraceback())))
 	}
 
-	if l.printTime {
+	if printTime {
-		args = append(args, fmt.Sprintf("[%s]", l.formatTime(time.Now())))
+		args = append(args, fmt.Sprintf("[%s]", formatTime(time.Now())))
 	}
 
 	msg := Map(m, func(el any) string {
 		return fmt.Sprintf("%v", el)
 	})
-
+	s := fmt.Sprintf("%s %s", strings.Join(args, " "), strings.Join(msg, " "))
-	return fmt.Sprintf("%s %v", 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)
 		}