From 50c507c8f4d6939d0feda2a5148800e4c9fc5d19 Mon Sep 17 00:00:00 2001 From: Tai Groot Date: Wed, 29 Mar 2023 14:02:57 -0700 Subject: [PATCH] add ability to embed other loggers of varying functionality --- go.mod | 2 +- log/gaplogger.go | 136 +++++++++++++++++++++++++++++++++++++++++++++++ log/logger.go | 90 ++++++++++++++++++++++++++++++- log/types.go | 60 ++++++++++++++++++++- main.go | 5 ++ 5 files changed, 289 insertions(+), 4 deletions(-) create mode 100644 log/gaplogger.go diff --git a/go.mod b/go.mod index aa2a445..f5b0b1d 100644 --- a/go.mod +++ b/go.mod @@ -1,5 +1,5 @@ module github.com/taigrr/log-socket -go 1.16 +go 1.18 require github.com/gorilla/websocket v1.5.0 diff --git a/log/gaplogger.go b/log/gaplogger.go new file mode 100644 index 0000000..090ea6b --- /dev/null +++ b/log/gaplogger.go @@ -0,0 +1,136 @@ +package log + +// Trace prints out logs on trace level +func (l gapLogger) Trace(args ...interface{}) { + l.subLogger.Print(args...) +} + +// Formatted print for Trace +func (l gapLogger) Tracef(format string, args ...interface{}) { + l.subLogger.Printf(format, args...) +} + +// Trace prints out logs on trace level with newline +func (l gapLogger) Traceln(args ...interface{}) { + l.subLogger.Println(args...) +} + +// Debug prints out logs on debug level +func (l gapLogger) Debug(args ...interface{}) { + l.subLogger.Print(args...) +} + +// Formatted print for Debug +func (l gapLogger) Debugf(format string, args ...interface{}) { + l.subLogger.Printf(format, args...) +} + +// Formatted print for Debug +func (l gapLogger) Debugln(args ...interface{}) { + l.subLogger.Println(args...) +} + +// Info prints out logs on info level +func (l gapLogger) Info(args ...interface{}) { + l.subLogger.Print(args...) +} + +// Formatted print for Info +func (l gapLogger) Infof(format string, args ...interface{}) { + l.subLogger.Printf(format, args...) +} + +// Info prints out logs on info level with newline +func (l gapLogger) Infoln(args ...interface{}) { + l.subLogger.Println(args...) +} + +// Notice prints out logs on notice level +func (l gapLogger) Notice(args ...interface{}) { + l.subLogger.Print(args...) +} + +// Formatted print for Notice +func (l gapLogger) Noticef(format string, args ...interface{}) { + l.subLogger.Printf(format, args...) +} + +// Notice prints out logs on notice level with newline +func (l gapLogger) Noticeln(args ...interface{}) { + l.subLogger.Println(args...) +} + +// Warn prints out logs on warn level +func (l gapLogger) Warn(args ...interface{}) { + l.subLogger.Print(args...) +} + +// Formatted print for Warn +func (l gapLogger) Warnf(format string, args ...interface{}) { + l.subLogger.Printf(format, args...) +} + +// Warn prints out logs on warn level with a newline +func (l gapLogger) Warnln(args ...interface{}) { + l.subLogger.Println(args...) +} + +// Error prints out logs on error level +func (l gapLogger) Error(args ...interface{}) { + l.subLogger.Print(args...) +} + +// Formatted print for error +func (l gapLogger) Errorf(format string, args ...interface{}) { + l.subLogger.Printf(format, args...) +} + +// Error prints out logs on error level with a new line +func (l gapLogger) Errorln(args ...interface{}) { + l.subLogger.Println(args...) +} + +// Panic prints out logs on panic level +func (l gapLogger) Panic(args ...interface{}) { + l.subLogger.Panic(args...) +} + +// Formatted print for panic +func (l gapLogger) Panicf(format string, args ...interface{}) { + l.subLogger.Panicf(format, args...) +} + +// Panic prints out logs on panic level with a newline +func (l gapLogger) Panicln(args ...interface{}) { + l.subLogger.Panicln(args...) +} + +// Fatal prints out logs on fatal level +func (l gapLogger) Fatal(args ...interface{}) { + l.subLogger.Fatal(args...) +} + +// Formatted print for fatal +func (l gapLogger) Fatalf(format string, args ...interface{}) { + l.subLogger.Fatalf(format, args...) +} + +// Fatal prints fatal level with a new line +func (l gapLogger) Fatalln(args ...interface{}) { + l.subLogger.Fatalln(args...) +} + +// Handles print to info +func (l gapLogger) Print(args ...interface{}) { + l.subLogger.Print(args...) +} + +// Handles formatted print to info +func (l gapLogger) Printf(format string, args ...interface{}) { + l.subLogger.Printf(format, args...) +} + +// Handles print to info with new line +func (l gapLogger) Println(args ...interface{}) { + l.subLogger.Println(args...) +} diff --git a/log/logger.go b/log/logger.go index 8c6045c..8a6bd97 100644 --- a/log/logger.go +++ b/log/logger.go @@ -22,6 +22,9 @@ func (l Logger) Trace(args ...interface{}) { level: LTrace, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Trace(args...) + } } // Formatted print for Trace @@ -35,6 +38,9 @@ func (l Logger) Tracef(format string, args ...interface{}) { level: LTrace, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Tracef(format, args...) + } } // Trace prints out logs on trace level with newline @@ -48,6 +54,9 @@ func (l Logger) Traceln(args ...interface{}) { level: LTrace, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Traceln(args...) + } } // Debug prints out logs on debug level @@ -61,6 +70,9 @@ func (l Logger) Debug(args ...interface{}) { level: LDebug, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Debug(args...) + } } // Formatted print for Debug @@ -74,6 +86,9 @@ func (l Logger) Debugf(format string, args ...interface{}) { level: LDebug, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Debugf(format, args...) + } } // Info prints out logs on info level @@ -87,6 +102,9 @@ func (l Logger) Info(args ...interface{}) { level: LInfo, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Info(args...) + } } // Formatted print for Info @@ -100,6 +118,9 @@ func (l Logger) Infof(format string, args ...interface{}) { level: LInfo, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Infof(format, args...) + } } // Info prints out logs on info level with newline @@ -113,6 +134,9 @@ func (l Logger) Infoln(args ...interface{}) { level: LInfo, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Infoln(args...) + } } // Notice prints out logs on notice level @@ -126,6 +150,9 @@ func (l Logger) Notice(args ...interface{}) { level: LNotice, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Notice(args...) + } } // Formatted print for Notice @@ -139,6 +166,9 @@ func (l Logger) Noticef(format string, args ...interface{}) { level: LNotice, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Noticef(format, args...) + } } // Notice prints out logs on notice level with newline @@ -152,6 +182,9 @@ func (l Logger) Noticeln(args ...interface{}) { level: LNotice, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Noticeln(args...) + } } // Warn prints out logs on warn level @@ -165,6 +198,9 @@ func (l Logger) Warn(args ...interface{}) { level: LWarn, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Warn(args...) + } } // Formatted print for Warn @@ -178,6 +214,9 @@ func (l Logger) Warnf(format string, args ...interface{}) { level: LWarn, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Warnf(format, args...) + } } // Warn prints out logs on warn level with a newline @@ -191,6 +230,9 @@ func (l Logger) Warnln(args ...interface{}) { level: LWarn, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Warnln(args...) + } } // Error prints out logs on error level @@ -204,6 +246,9 @@ func (l Logger) Error(args ...interface{}) { level: LError, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Error(args...) + } } // Formatted print for error @@ -217,6 +262,10 @@ func (l Logger) Errorf(format string, args ...interface{}) { level: LError, } createLog(e) + + for _, sl := range l.SubLoggers { + sl.Errorf(format, args...) + } } // Error prints out logs on error level with a new line @@ -230,6 +279,9 @@ func (l Logger) Errorln(args ...interface{}) { level: LError, } createLog(e) + for _, sl := range l.SubLoggers { + sl.Errorln(args...) + } } // Panic prints out logs on panic level @@ -252,6 +304,9 @@ func (l Logger) Panic(args ...interface{}) { } } Flush() + for _, sl := range l.SubLoggers { + sl.Panic(args...) + } panic(errors.New(output)) } @@ -275,6 +330,9 @@ func (l Logger) Panicf(format string, args ...interface{}) { } } Flush() + for _, sl := range l.SubLoggers { + sl.Panicf(format, args...) + } panic(errors.New(output)) } @@ -298,6 +356,10 @@ func (l Logger) Panicln(args ...interface{}) { } } Flush() + + for _, sl := range l.SubLoggers { + sl.Panicln(args...) + } panic(errors.New(output)) } @@ -313,6 +375,9 @@ func (l Logger) Fatal(args ...interface{}) { } createLog(e) Flush() + for _, sl := range l.SubLoggers { + sl.Fatal(args...) + } os.Exit(1) } @@ -328,6 +393,9 @@ func (l Logger) Fatalf(format string, args ...interface{}) { } createLog(e) Flush() + for _, sl := range l.SubLoggers { + sl.Fatalf(format, args...) + } os.Exit(1) } @@ -343,20 +411,40 @@ func (l Logger) Fatalln(args ...interface{}) { } createLog(e) Flush() + for _, sl := range l.SubLoggers { + sl.Fatalln(args...) + } os.Exit(1) } // Handles print to info func (l Logger) Print(args ...interface{}) { l.Info(args...) + for _, sl := range l.SubLoggers { + sl.Print(args...) + } } // Handles formatted print to info func (l Logger) Printf(format string, args ...interface{}) { l.Infof(format, args...) + for _, sl := range l.SubLoggers { + sl.Printf(format, args...) + } } // Handles print to info with new line func (l Logger) Println(args ...interface{}) { - l.Infoln(args...) + output := fmt.Sprintln(args...) + e := Entry{ + Timestamp: time.Now(), + Output: output, + File: fileInfo(l.FileInfoDepth), + Level: "INFO", + level: LInfo, + } + createLog(e) + for _, sl := range l.SubLoggers { + sl.Println(args...) + } } diff --git a/log/types.go b/log/types.go index fed2ff1..8678cb8 100644 --- a/log/types.go +++ b/log/types.go @@ -2,8 +2,10 @@ package log import "time" -type LogWriter chan Entry -type Level int +type ( + LogWriter chan Entry + Level int +) const ( LTrace Level = iota @@ -30,6 +32,60 @@ type Entry struct { level Level } +func Default() *Logger { + l := Logger{FileInfoDepth: 0, SubLoggers: []LevelLogger{}} + return &l +} + +func EnrichLogger(weak StdLogger) gapLogger { + return gapLogger{subLogger: weak} +} + type Logger struct { FileInfoDepth int + SubLoggers []LevelLogger } +type gapLogger struct { + subLogger StdLogger +} +type ( + StdLogger interface { + Println(v ...any) + Printf(format string, v ...any) + Print(v ...any) + Panic(v ...any) + Panicf(format string, v ...any) + Panicln(v ...any) + Fatal(v ...any) + Fatalf(format string, v ...any) + Fatalln(v ...any) + } + LevelLogger interface { + Debug(v ...any) + Debugf(format string, v ...any) + Error(v ...any) + Errorf(format string, v ...any) + Errorln(v ...any) + Fatal(v ...any) + Fatalf(format string, v ...any) + Fatalln(v ...any) + Info(v ...any) + Infof(format string, v ...any) + Infoln(v ...any) + Notice(v ...any) + Noticef(format string, v ...any) + Noticeln(v ...any) + Panic(v ...any) + Panicf(format string, v ...any) + Panicln(v ...any) + Print(v ...any) + Printf(format string, v ...any) + Println(v ...any) + Trace(v ...any) + Tracef(format string, v ...any) + Traceln(v ...any) + Warn(v ...any) + Warnf(format string, v ...any) + Warnln(v ...any) + } +) diff --git a/main.go b/main.go index 51e07a2..78edffe 100644 --- a/main.go +++ b/main.go @@ -2,6 +2,7 @@ package main import ( "flag" + "log" "net/http" "time" @@ -29,5 +30,9 @@ func main() { http.HandleFunc("/ws", ws.LogSocketHandler) http.HandleFunc("/", browser.LogSocketViewHandler) go generateLogs() + dLogger := log.Default() + lsLogger := logger.Default() + lsLogger.SubLoggers = append(lsLogger.SubLoggers, logger.EnrichLogger(dLogger)) + lsLogger.Println("This should be printed out twice!") logger.Fatal(http.ListenAndServe(*addr, nil)) }