logger enchancment

bot.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"log"
 	"net/http"
 	"os"
 	"sort"
@@ -104,15 +105,28 @@ func NewBot(settings *BotSettings) *Bot {
 	if settings.Debug {
 		level = DEBUG
 	}
-	bot.logger = CreateLogger().Level(level)
+
+	bot.logger = CreateLogger().Level(level).PrintTraceback(true)
+	bot.logger.AddWriter(bot.logger.CreateStdoutWriter())
 	if settings.WriteToFile {
-		bot.logger = bot.logger.OpenFile(fmt.Sprintf("%s/main.log", strings.TrimRight(settings.LoggerBasePath, "/")))
+		path := fmt.Sprintf("%s/main.log", strings.TrimRight(settings.LoggerBasePath, "/"))
+		fileWriter, err := bot.logger.CreateFileWriter(path)
+		if err != nil {
+			bot.logger.Fatal(err)
+		}
+		bot.logger.AddWriter(fileWriter)
 	}
-	bot.logger = bot.logger.PrintTraceback(true)
+
 	if settings.UseRequestLogger {
 		bot.requestLogger = CreateLogger().Level(level).Prefix("REQUESTS")
+		bot.requestLogger.AddWriter(bot.requestLogger.CreateStdoutWriter())
 		if settings.WriteToFile {
-			bot.requestLogger = bot.requestLogger.OpenFile(fmt.Sprintf("%s/requests.log", strings.TrimRight(settings.LoggerBasePath, "/")))
+			path := fmt.Sprintf("%s/requests.log", strings.TrimRight(settings.LoggerBasePath, "/"))
+			fileWriter, err := bot.requestLogger.CreateFileWriter(path)
+			if err != nil {
+				bot.logger.Fatal(err)
+			}
+			bot.requestLogger.AddWriter(fileWriter)
 		}
 	}
 
@@ -120,11 +134,11 @@ func NewBot(settings *BotSettings) *Bot {
 }
 
 func (b *Bot) Close() {
-	err := b.logger.f.Close()
+	for _, writer := range b.logger.writers {
-	if err != nil {
+		err := writer.Close()
-		fmt.Println(err)
+		if err != nil {
-	} else {
+			log.Println(err)
-		fmt.Println("log closed")
+		}
 	}
 }
 
@@ -132,11 +146,11 @@ 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 := []LoggerWriter{writer(b.dbContext)}
+	w := writer(b.dbContext)
-	b.logger.AddWriters(w)
+	b.logger.AddWriter(w)
 	if b.requestLogger != nil {
-		b.requestLogger.AddWriters(w)
+		b.requestLogger.AddWriter(w)
 	}
 	return b
 }
@@ -177,7 +191,7 @@ func (b *Bot) Debug(debug bool) *Bot {
 func (b *Bot) AddPlugins(plugin ...*Plugin) *Bot {
 	b.plugins = append(b.plugins, plugin...)
 	for _, p := range plugin {
-		b.logger.Debug(fmt.Sprintf("plugins with name \"%s\" was registered", p.Name))
+		b.logger.Debug(fmt.Sprintf("plugins with name \"%s\" registered", p.Name))
 	}
 	return b
 }
@@ -194,7 +208,7 @@ func (b *Bot) AddMiddleware(middleware ...*Middleware) *Bot {
 
 	b.middlewares = append(b.middlewares, middleware...)
 	for _, m := range middleware {
-		b.logger.Debug(fmt.Sprintf("middleware with name \"%s\" was registered", m.Name))
+		b.logger.Debug(fmt.Sprintf("middleware with name \"%s\" registered", m.Name))
 	}
 	return b
 }

logger.go

@@ -2,6 +2,7 @@ package laniakea
 
 import (
 	"fmt"
+	"io"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -12,16 +13,30 @@ import (
 	"github.com/fatih/color"
 )
 
-type LoggerWriter func(level LogLevel, prefix, traceback string, message []any)
+type LoggerWriter struct {
+	writer  io.Writer
+	writeFn LoggerWriterFn
+	logger  *Logger
+}
+
+func (w *LoggerWriter) SetFn(fn LoggerWriterFn) {
+	w.writeFn = fn
+}
+func (w *LoggerWriter) Write(p []byte) (n int, err error) {
+	return w.writer.Write(p)
+}
+func (w *LoggerWriter) Close() error {
+	return w.writer.(io.Closer).Close()
+}
+
+type LoggerWriterFn func(level LogLevel, prefix, traceback string, message []any) error
 
 type Logger struct {
 	prefix         string
 	level          LogLevel
 	printTraceback bool
 	printTime      bool
-	writers        []LoggerWriter
+	writers        []*LoggerWriter
-
-	f *os.File
 }
 
 type LogLevel struct {
@@ -60,16 +75,34 @@ func CreateLogger() *Logger {
 	}
 }
 
-func (l *Logger) OpenFile(name string) *Logger {
+func (l *Logger) CreateFileWriter(path string) (*LoggerWriter, error) {
-	err := os.MkdirAll(filepath.Dir(name), os.ModePerm)
+	err := os.MkdirAll(filepath.Dir(path), os.ModePerm)
 	if err != nil {
-		l.Fatal(err)
+		return nil, err
 	}
-	l.f, err = os.OpenFile(name, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	file, err := os.OpenFile(path, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
 	if err != nil {
-		l.Fatal(err)
+		return nil, err
 	}
-	return l
+
+	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
+	}
+	return writer, nil
+}
+func (l *Logger) CreateStdoutWriter() *LoggerWriter {
+	writer := &LoggerWriter{
+		writer: os.Stdout, logger: l,
+	}
+	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) Prefix(prefix string) *Logger {
@@ -88,11 +121,18 @@ func (l *Logger) PrintTime(b bool) *Logger {
 	l.printTime = b
 	return l
 }
-func (l *Logger) AddWriters(writers []LoggerWriter) *Logger {
+func (l *Logger) AddWriters(writers ...*LoggerWriter) *Logger {
 	l.writers = append(l.writers, writers...)
 	return l
 }
+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) Info(m ...any) {
 	l.print(INFO, m)
 }
@@ -209,19 +249,11 @@ func (l *Logger) print(level LogLevel, m []any) {
 	if l.level.n < level.n {
 		return
 	}
-	_, err := color.New(level.c).Println(l.buildString(level, m))
-	if err != nil {
-		l.Fatal(err)
-		return
-	}
 
 	for _, writer := range l.writers {
-		writer(level, l.prefix, l.formatFullTraceback(l.getFullTraceback(4)), m)
+		err := writer.writeFn(level, l.prefix, l.formatFullTraceback(l.getFullTraceback(0)), m)
-	}
+		if err != nil {
-
+			l.Error(err)
-	if l.f != nil {
-		if _, err := l.f.Write([]byte(l.buildString(level, m) + "\n")); err != nil {
-			l.Fatal(err)
 		}
 	}
 }

plugins.go

@@ -1,5 +1,7 @@
 package laniakea
 
+import "log"
+
 type CommandExecutor func(ctx *MsgContext, dbContext *DatabaseContext)
 
 type PluginBuilder struct {
@@ -44,8 +46,8 @@ func (p *PluginBuilder) UpdateListener(listener CommandExecutor) *PluginBuilder
 }
 
 func (p *PluginBuilder) Build() *Plugin {
-	if len(p.commands) == 0 {
+	if len(p.commands) == 0 && len(p.payloads) == 0 {
-		return nil
+		log.Println("no command or payloads")
 	}
 	plugin := &Plugin{
 		Name:           p.name,