GitHub-Mirror/go-logadapter
2
0
Fork 0
mirror of https://github.com/Fishwaldo/go-logadapter.git synced 2025-03-15 19:31:25 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add Tests (#3)

Browse source 
* Update Tests
This commit is contained in:
Justin Hammond 2021-09-22 18:57:15 +08:00 • committed by GitHub
parent dcaa74a6f2
commit bcd5299814
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 549 additions and 235 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
logadapter.go
View file

@ -53,8 +53,24 @@ type Logger interface {
SetPrefix(name string) SetPrefix(name string)
// Get the Log Prefix // Get the Log Prefix
GetPrefix() (string) GetPrefix() (string)
// Set Logging Level
SetLevel(Log_Level)
// Get Logging Level
GetLevel() (Log_Level)
// Sync/Flush the Log Buffers // Sync/Flush the Log Buffers
Sync() Sync()
} }
type Log_Level int
const (
LOG_TRACE Log_Level = iota
LOG_DEBUG
LOG_INFO
LOG_WARN
LOG_ERROR
LOG_FATAL
LOG_PANIC
LOG_UNKNOWN
)

2
logadapter_test.go
View file

@ -35,7 +35,7 @@ type TestStruct struct {
func (t *TestStruct) Init() { func (t *TestStruct) Init() {
temp := stdlogger.DefaultLogger() temp := stdlogger.DefaultLogger()
temp.SetLevel(stdlogger.LOG_TRACE) temp.SetLevel(logadapter.LOG_TRACE)
t.Logger = temp t.Logger = temp
} }

42
loggers/logrus/logrus.go
View file

@ -67,6 +67,7 @@ func (l *LruLogger) Sync() {
} }
func (l *LruLogger) New(name string) logadapter.Logger { func (l *LruLogger) New(name string) logadapter.Logger {
nl := &LruLogger{Lru: logrus.NewEntry(l.Lru.Logger)} nl := &LruLogger{Lru: logrus.NewEntry(l.Lru.Logger)}
nl.SetPrefix(name)
return nl return nl
} }
func (l *LruLogger) SetPrefix(name string) { func (l *LruLogger) SetPrefix(name string) {
@ -80,9 +81,48 @@ func (l *LruLogger) GetPrefix() (string) {
} }
return "" return ""
} }
func (l *LruLogger) SetLevel(level logadapter.Log_Level) {
switch level {
case logadapter.LOG_TRACE:
l.Lru.Logger.SetLevel(logrus.TraceLevel)
case logadapter.LOG_DEBUG:
l.Lru.Logger.SetLevel(logrus.DebugLevel)
case logadapter.LOG_INFO:
l.Lru.Logger.SetLevel(logrus.InfoLevel)
case logadapter.LOG_WARN:
l.Lru.Logger.SetLevel(logrus.WarnLevel)
case logadapter.LOG_ERROR:
l.Lru.Logger.SetLevel(logrus.ErrorLevel)
case logadapter.LOG_FATAL:
l.Lru.Logger.SetLevel(logrus.FatalLevel)
case logadapter.LOG_PANIC:
l.Lru.Logger.SetLevel(logrus.PanicLevel)
}
}
func (l *LruLogger) GetLevel() (logadapter.Log_Level) {
switch l.Lru.Logger.GetLevel() {
case logrus.TraceLevel:
return logadapter.LOG_TRACE
case logrus.DebugLevel:
return logadapter.LOG_DEBUG
case logrus.InfoLevel:
return logadapter.LOG_INFO
case logrus.WarnLevel:
return logadapter.LOG_WARN
case logrus.ErrorLevel:
return logadapter.LOG_ERROR
case logrus.FatalLevel:
return logadapter.LOG_FATAL
case logrus.PanicLevel:
return logadapter.LOG_PANIC
}
return logadapter.LOG_UNKNOWN
}
//LogrusDefaultLogger Return Logger based on logrus with new instance //LogrusDefaultLogger Return Logger based on logrus with new instance
func LogrusDefaultLogger() logadapter.Logger { func LogrusDefaultLogger() (*LruLogger) {
// TODO control verbosity // TODO control verbosity
l := &LruLogger{Lru: logrus.NewEntry(logrus.New())} l := &LruLogger{Lru: logrus.NewEntry(logrus.New())}
return l return l
} }

269
loggers/logrus/logrus_test.go
View file

@ -25,114 +25,197 @@ SOFTWARE.
package logrus_test package logrus_test
import ( import (
// "bytes" "bytes"
// "os" "os"
// "regexp" "regexp"
"testing" "testing"
// "github.com/Fishwaldo/go-logadapter/loggers/zap" "github.com/Fishwaldo/go-logadapter"
"github.com/Fishwaldo/go-logadapter/loggers/logrus"
) )
func TestDefaultLogger(t *testing.T) { func TestLogRusRusLogger(t *testing.T) {
//_ := zaplog.ZapLogger{} logger := logrus.LogrusDefaultLogger()
//logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
//if logger.GetLevel() != stdlogger.LOG_TRACE { if logger.GetLevel() != logadapter.LOG_TRACE {
// t.Errorf("Can't Set Logging Level") t.Errorf("Can't Set Logging Level")
//} }
} }
// func captureOutput(l *zaplog.ZapLogger, f func()) string { func captureOutput(l *logrus.LruLogger, f func()) string {
// // var buf bytes.Buffer var buf bytes.Buffer
// // l.Log.SetOutput(&buf) l.Lru.Logger.SetOutput(&buf)
// // f() f()
// // l.Log.SetOutput(os.Stderr) l.Lru.Logger.SetOutput(os.Stderr)
// // return buf.String() return buf.String()
// }
func TestLogTrace(t *testing.T) {
// logger := stdlogger.DefaultLogger()
// logger.SetLevel(stdlogger.LOG_TRACE)
// output := captureOutput(logger, func() {
// logger.Trace("Hello %s", "world")
// })
// validmsg := regexp.MustCompile(`^.* TRACE: Hello world \- {}`)
// if !validmsg.MatchString(output) {
// t.Errorf("Log Trace Failed: %s", output)
// }
} }
func TestLogDebug(t *testing.T) { func TestLogRusTrace(t *testing.T) {
// logger := stdlogger.DefaultLogger() logger := logrus.LogrusDefaultLogger()
// logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
// output := captureOutput(logger, func() { output := captureOutput(logger, func() {
// logger.Debug("Hello %s", "world") logger.Trace("Hello %s", "world")
// }) })
// validmsg := regexp.MustCompile(`^.* DEBUG: Hello world \- {}`) validmsg := regexp.MustCompile(`^.* level=trace msg=\"Hello world\"`)
// if !validmsg.MatchString(output) { if !validmsg.MatchString(output) {
// t.Errorf("Log Debug Failed: %s", output) t.Errorf("Log Trace Failed: %s - %s", output, validmsg)
// } }
}
func TestLogRusDebug(t *testing.T) {
logger := logrus.LogrusDefaultLogger()
logger.SetLevel(logadapter.LOG_TRACE)
output := captureOutput(logger, func() {
logger.Debug("Hello %s", "world")
})
validmsg := regexp.MustCompile(`^.* level=debug msg=\"Hello world"`)
if !validmsg.MatchString(output) {
t.Errorf("Log Debug Failed: %s", output)
}
} }
func TestLogInfo(t *testing.T) { func TestLogRusInfo(t *testing.T) {
// logger := stdlogger.DefaultLogger() logger := logrus.LogrusDefaultLogger()
// logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
// output := captureOutput(logger, func() { output := captureOutput(logger, func() {
// logger.Info("Hello %s", "world") logger.Info("Hello %s", "world")
// }) })
// validmsg := regexp.MustCompile(`^.* INFO: Hello world \- {}`) validmsg := regexp.MustCompile(`^.* level=info msg=\"Hello world\"`)
// if !validmsg.MatchString(output) { if !validmsg.MatchString(output) {
// t.Errorf("Log Info Failed: %s", output) t.Errorf("Log Info Failed: %s", output)
// } }
} }
func TestLogWarn(t *testing.T) { func TestLogRusWarn(t *testing.T) {
// logger := stdlogger.DefaultLogger() logger := logrus.LogrusDefaultLogger()
// logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
// output := captureOutput(logger, func() { output := captureOutput(logger, func() {
// logger.Warn("Hello %s", "world") logger.Warn("Hello %s", "world")
// }) })
// validmsg := regexp.MustCompile(`^.* WARN: Hello world \- {}`) validmsg := regexp.MustCompile(`^.* level=warning msg=\"Hello world\"`)
// if !validmsg.MatchString(output) { if !validmsg.MatchString(output) {
// t.Errorf("Log Warn Failed: %s", output) t.Errorf("Log Warn Failed: %s", output)
// } }
} }
func TestLogError(t *testing.T) { func TestLogRusError(t *testing.T) {
// logger := stdlogger.DefaultLogger() logger := logrus.LogrusDefaultLogger()
// logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
// output := captureOutput(logger, func() { output := captureOutput(logger, func() {
// logger.Error("Hello %s", "world") logger.Error("Hello %s", "world")
// }) })
// validmsg := regexp.MustCompile(`^.* ERROR: Hello world \- {}`) validmsg := regexp.MustCompile(`^.* level=error msg=\"Hello world\"`)
// if !validmsg.MatchString(output) { if !validmsg.MatchString(output) {
// t.Errorf("Log Error Failed: %s", output) t.Errorf("Log Error Failed: %s", output)
// } }
} }
func TestLogFatal(t *testing.T) { func fakeExit(int) {
//logger := DefaultLogger() /* do nothing */
//logger.SetLevel(LOG_TRACE) }
//output := captureOutput(logger, func() { func TestLogRusFatal(t *testing.T) {
// logger.Fatal("Hello %s", "world") logger := logrus.LogrusDefaultLogger()
//}) logger.SetLevel(logadapter.LOG_TRACE)
//validmsg := regexp.MustCompile(`^.* FATAL: Hello world \- {}`) logger.Lru.Logger.ExitFunc = fakeExit
//if !validmsg.MatchString(output) { output := captureOutput(logger, func() {
// t.Errorf("Log Fatal Failed: %s", output) logger.Fatal("Hello %s", "world")
//} })
validmsg := regexp.MustCompile(`^.* level=fatal msg=\"Hello world\"`)
if !validmsg.MatchString(output) {
t.Errorf("Log Fatal Failed: %s", output)
}
} }
func TestLogPanic(t *testing.T) { func TestLogRusPanic(t *testing.T) {
// logger := stdlogger.DefaultLogger() logger := logrus.LogrusDefaultLogger()
// logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
// defer func() { defer func() {
// if err := recover(); err == nil { if err := recover(); err == nil {
// t.Errorf("Log Panic Recovery Failed") t.Errorf("Log Panic Recovery Failed")
// } }
// }() }()
// output := captureOutput(logger, func() { output := captureOutput(logger, func() {
// logger.Panic("Hello %s", "world") logger.Panic("Hello %s", "world")
// }) })
validmsg := regexp.MustCompile(`^.* PANIC: Hello world \- {}`)
// validmsg := regexp.MustCompile(`^.* PANIC: Hello world \- {}`) if !validmsg.MatchString(output) {
// if !validmsg.MatchString(output) { t.Errorf("Log Panic Failed: %s", output)
// t.Errorf("Log Panic Failed: %s", output) }
// } }
func TestLogRusWith(t *testing.T) {
logger := logrus.LogrusDefaultLogger()
logger.SetLevel(logadapter.LOG_TRACE)
logger2 := logger.With("Test", "Message")
output := captureOutput(logger, func() {
logger2.Info("Hello %s", "world")
})
validmsg := regexp.MustCompile(`^.* level=info msg=\"Hello world\" Test=Message`)
if !validmsg.MatchString(output) {
t.Errorf("Log With Failed: %s", output)
}
}
func TestLogRusPrefix(t *testing.T) {
logger := logrus.LogrusDefaultLogger()
logger.SetLevel(logadapter.LOG_TRACE)
if logger.GetPrefix() != "" {
t.Errorf("Empty Log Prefix Failed: %s", logger.GetPrefix())
}
logger.SetPrefix("TestLogRus")
output := captureOutput(logger, func() {
logger.Info("Hello %s", "world")
})
validmsg := regexp.MustCompile(`^.* level=info msg=\"Hello world\" Prefix=TestLogRus`)
if !validmsg.MatchString(output) {
t.Errorf("Log Prefix Failed: %s", output)
}
if logger.GetPrefix() != "TestLogRus" {
t.Errorf("Log Prefix Failed: %s", logger.GetPrefix())
}
}
func TestLogRusLevel(t *testing.T) {
logger := logrus.LogrusDefaultLogger()
logger.SetLevel(logadapter.LOG_TRACE)
if logger.GetLevel() != logadapter.LOG_TRACE {
t.Errorf("Log SetLevel to Trace Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_DEBUG)
if logger.GetLevel() != logadapter.LOG_DEBUG {
t.Errorf("Log SetLevel to Debug Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_INFO)
if logger.GetLevel() != logadapter.LOG_INFO {
t.Errorf("Log SetLevel to Info Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_WARN)
if logger.GetLevel() != logadapter.LOG_WARN {
t.Errorf("Log SetLevel to Trace Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_ERROR)
if logger.GetLevel() != logadapter.LOG_ERROR {
t.Errorf("Log SetLevel to Error Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_FATAL)
if logger.GetLevel() != logadapter.LOG_FATAL {
t.Errorf("Log SetLevel to Fatal Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_PANIC)
if logger.GetLevel() != logadapter.LOG_PANIC {
t.Errorf("Log SetLevel to Panic Failed: %d", logger.GetLevel())
}
}
func TestLogRusNewLog(t *testing.T) {
logger := logrus.LogrusDefaultLogger()
logger.SetLevel(logadapter.LOG_TRACE)
logger2 := logger.New("Blah")
output := captureOutput(logger, func() {
logger2.Error("Hello %s", "world")
})
validmsg := regexp.MustCompile(`^.* level=error msg=\"Hello world\" Prefix=Blah`)
if !validmsg.MatchString(output) {
t.Errorf("Log Error Failed: %s", output)
}
} }

40
loggers/std/std.go
View file

@ -36,6 +36,8 @@ import (
"github.com/Fishwaldo/go-logadapter/internal/utils" "github.com/Fishwaldo/go-logadapter/internal/utils"
) )
var _ logadapter.Logger = (*StdLogger)(nil)
//DefaultLogger uses Golang Standard Logging Libary //DefaultLogger uses Golang Standard Logging Libary
func DefaultLogger() (l *StdLogger) { func DefaultLogger() (l *StdLogger) {
stdlogger := log.New(os.Stderr, "log - ", log.LstdFlags) stdlogger := log.New(os.Stderr, "log - ", log.LstdFlags)
@ -47,56 +49,48 @@ type StdLogger struct {
Log log.Logger Log log.Logger
keys map[string]interface{} keys map[string]interface{}
mx sync.Mutex mx sync.Mutex
level Log_Level level logadapter.Log_Level
} }
type Log_Level int
const (
LOG_TRACE Log_Level = iota
LOG_DEBUG
LOG_INFO
LOG_WARN
LOG_ERROR
LOG_FATAL
LOG_PANIC
)
func (l *StdLogger) Trace(message string, params ...interface{}) { func (l *StdLogger) Trace(message string, params ...interface{}) {
if l.level <= LOG_TRACE { if l.level <= logadapter.LOG_TRACE {
l.Log.Printf("TRACE: %s - %s", fmt.Sprintf(message, params...), l.getKeys()) l.Log.Printf("TRACE: %s - %s", fmt.Sprintf(message, params...), l.getKeys())
} }
} }
func (l *StdLogger) Debug(message string, params ...interface{}) { func (l *StdLogger) Debug(message string, params ...interface{}) {
if l.level <= LOG_DEBUG { if l.level <= logadapter.LOG_DEBUG {
l.Log.Printf("DEBUG: %s - %s", fmt.Sprintf(message, params...), l.getKeys()) l.Log.Printf("DEBUG: %s - %s", fmt.Sprintf(message, params...), l.getKeys())
} }
} }
func (l *StdLogger) Info(message string, params ...interface{}) { func (l *StdLogger) Info(message string, params ...interface{}) {
if l.level <= LOG_INFO { if l.level <= logadapter.LOG_INFO {
l.Log.Printf("INFO: %s - %s", fmt.Sprintf(message, params...), l.getKeys()) l.Log.Printf("INFO: %s - %s", fmt.Sprintf(message, params...), l.getKeys())
} }
} }
func (l *StdLogger) Warn(message string, params ...interface{}) { func (l *StdLogger) Warn(message string, params ...interface{}) {
if l.level <= LOG_WARN { if l.level <= logadapter.LOG_WARN {
l.Log.Printf("WARN: %s - %s", fmt.Sprintf(message, params...), l.getKeys()) l.Log.Printf("WARN: %s - %s", fmt.Sprintf(message, params...), l.getKeys())
} }
} }
func (l *StdLogger) Error(message string, params ...interface{}) { func (l *StdLogger) Error(message string, params ...interface{}) {
if l.level <= LOG_ERROR { if l.level <= logadapter.LOG_ERROR {
l.Log.Printf("ERROR: %s - %s", fmt.Sprintf(message, params...), l.getKeys()) l.Log.Printf("ERROR: %s - %s", fmt.Sprintf(message, params...), l.getKeys())
} }
} }
func (l *StdLogger) Fatal(message string, params ...interface{}) { func (l *StdLogger) Fatal(message string, params ...interface{}) {
if l.level <= logadapter.LOG_FATAL {
l.Log.Fatal(fmt.Printf("FATAL: %s - %s", fmt.Sprintf(message, params...), l.getKeys())) l.Log.Fatal(fmt.Printf("FATAL: %s - %s", fmt.Sprintf(message, params...), l.getKeys()))
}
} }
func (l *StdLogger) Panic(message string, params ...interface{}) { func (l *StdLogger) Panic(message string, params ...interface{}) {
if l.level <= logadapter.LOG_PANIC {
l.Log.Panic(fmt.Printf("PANIC: %s - %s", fmt.Sprintf(message, params...), l.getKeys())) l.Log.Panic(fmt.Printf("PANIC: %s - %s", fmt.Sprintf(message, params...), l.getKeys()))
}
} }
func (l *StdLogger) New(name string) logadapter.Logger { func (l *StdLogger) New(name string) logadapter.Logger {
//nl := &StdLogger{keys: l.keys} //nl := &StdLogger{keys: l.keys}
nl := &StdLogger{level: l.level} nl := &StdLogger{level: l.level, keys: make(map[string]interface{})}
nl.Log.SetPrefix(fmt.Sprintf("%s.%s", l.Log.Prefix(), name)) nl.SetPrefix(name)
nl.Log.SetFlags(l.Log.Flags()) nl.Log.SetFlags(l.Log.Flags())
nl.Log.SetOutput(l.Log.Writer()) nl.Log.SetOutput(l.Log.Writer())
return nl return nl
@ -105,7 +99,7 @@ func (l *StdLogger) With(key string, value interface{}) logadapter.Logger {
l.mx.Lock() l.mx.Lock()
defer l.mx.Unlock() defer l.mx.Unlock()
stdlog := &StdLogger{level: l.level, keys: utils.CopyableMap(l.keys).DeepCopy()} stdlog := &StdLogger{level: l.level, keys: utils.CopyableMap(l.keys).DeepCopy()}
stdlog.Log.SetPrefix(l.Log.Prefix()) stdlog.SetPrefix(l.GetPrefix())
stdlog.Log.SetFlags(l.Log.Flags()) stdlog.Log.SetFlags(l.Log.Flags())
stdlog.Log.SetOutput(l.Log.Writer()) stdlog.Log.SetOutput(l.Log.Writer())
stdlog.keys[key] = value stdlog.keys[key] = value
@ -125,11 +119,11 @@ func (l *StdLogger) getKeys() (message string) {
return err.Error() return err.Error()
} }
func (l *StdLogger) SetLevel(level Log_Level) { func (l *StdLogger) SetLevel(level logadapter.Log_Level) {
l.level = level l.level = level
} }
func (l *StdLogger) GetLevel() (level Log_Level) { func (l *StdLogger) GetLevel() (logadapter.Log_Level) {
return l.level return l.level
} }

111
loggers/std/std_test.go
View file

@ -30,13 +30,14 @@ import (
"regexp" "regexp"
"testing" "testing"
"github.com/Fishwaldo/go-logadapter"
"github.com/Fishwaldo/go-logadapter/loggers/std" "github.com/Fishwaldo/go-logadapter/loggers/std"
) )
func TestDefaultLogger(t *testing.T) { func TestStdLogger(t *testing.T) {
logger := stdlogger.DefaultLogger() logger := stdlogger.DefaultLogger()
logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
if logger.GetLevel() != stdlogger.LOG_TRACE { if logger.GetLevel() != logadapter.LOG_TRACE {
t.Errorf("Can't Set Logging Level") t.Errorf("Can't Set Logging Level")
} }
} }
@ -48,9 +49,9 @@ func captureOutput(l *stdlogger.StdLogger, f func()) string {
l.Log.SetOutput(os.Stderr) l.Log.SetOutput(os.Stderr)
return buf.String() return buf.String()
} }
func TestLogTrace(t *testing.T) { func TestStdTrace(t *testing.T) {
logger := stdlogger.DefaultLogger() logger := stdlogger.DefaultLogger()
logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
output := captureOutput(logger, func() { output := captureOutput(logger, func() {
logger.Trace("Hello %s", "world") logger.Trace("Hello %s", "world")
}) })
@ -59,9 +60,9 @@ func TestLogTrace(t *testing.T) {
t.Errorf("Log Trace Failed: %s", output) t.Errorf("Log Trace Failed: %s", output)
} }
} }
func TestLogDebug(t *testing.T) { func TestStdDebug(t *testing.T) {
logger := stdlogger.DefaultLogger() logger := stdlogger.DefaultLogger()
logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
output := captureOutput(logger, func() { output := captureOutput(logger, func() {
logger.Debug("Hello %s", "world") logger.Debug("Hello %s", "world")
}) })
@ -71,9 +72,9 @@ func TestLogDebug(t *testing.T) {
} }
} }
func TestLogInfo(t *testing.T) { func TestStdInfo(t *testing.T) {
logger := stdlogger.DefaultLogger() logger := stdlogger.DefaultLogger()
logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
output := captureOutput(logger, func() { output := captureOutput(logger, func() {
logger.Info("Hello %s", "world") logger.Info("Hello %s", "world")
}) })
@ -83,9 +84,9 @@ func TestLogInfo(t *testing.T) {
} }
} }
func TestLogWarn(t *testing.T) { func TestStdWarn(t *testing.T) {
logger := stdlogger.DefaultLogger() logger := stdlogger.DefaultLogger()
logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
output := captureOutput(logger, func() { output := captureOutput(logger, func() {
logger.Warn("Hello %s", "world") logger.Warn("Hello %s", "world")
}) })
@ -95,9 +96,9 @@ func TestLogWarn(t *testing.T) {
} }
} }
func TestLogError(t *testing.T) { func TestStdError(t *testing.T) {
logger := stdlogger.DefaultLogger() logger := stdlogger.DefaultLogger()
logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
output := captureOutput(logger, func() { output := captureOutput(logger, func() {
logger.Error("Hello %s", "world") logger.Error("Hello %s", "world")
}) })
@ -107,7 +108,7 @@ func TestLogError(t *testing.T) {
} }
} }
func TestLogFatal(t *testing.T) { func TestStdFatal(t *testing.T) {
//logger := DefaultLogger() //logger := DefaultLogger()
//logger.SetLevel(LOG_TRACE) //logger.SetLevel(LOG_TRACE)
//output := captureOutput(logger, func() { //output := captureOutput(logger, func() {
@ -119,9 +120,9 @@ func TestLogFatal(t *testing.T) {
//} //}
} }
func TestLogPanic(t *testing.T) { func TestStdPanic(t *testing.T) {
logger := stdlogger.DefaultLogger() logger := stdlogger.DefaultLogger()
logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
defer func() { defer func() {
if err := recover(); err == nil { if err := recover(); err == nil {
t.Errorf("Log Panic Recovery Failed") t.Errorf("Log Panic Recovery Failed")
@ -136,3 +137,81 @@ func TestLogPanic(t *testing.T) {
t.Errorf("Log Panic Failed: %s", output) t.Errorf("Log Panic Failed: %s", output)
} }
} }
func TestStdPrefix(t *testing.T) {
logger := stdlogger.DefaultLogger()
logger.SetLevel(logadapter.LOG_TRACE)
if logger.GetPrefix() != "log" {
t.Errorf("Empty Log Prefix Failed: %s", logger.GetPrefix())
}
logger.SetPrefix("TestStd")
output := captureOutput(logger, func() {
logger.Info("Hello %s", "world")
})
validmsg := regexp.MustCompile(`^TestStd .* INFO: Hello world \- {}`)
if !validmsg.MatchString(output) {
t.Errorf("Log Prefix Failed: %s", output)
}
if logger.GetPrefix() != "TestStd" {
t.Errorf("Log Prefix Failed: %s", logger.GetPrefix())
}
}
func TestStdLevel(t *testing.T) {
logger := stdlogger.DefaultLogger()
logger.SetLevel(logadapter.LOG_TRACE)
if logger.GetLevel() != logadapter.LOG_TRACE {
t.Errorf("Log SetLevel to Trace Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_DEBUG)
if logger.GetLevel() != logadapter.LOG_DEBUG {
t.Errorf("Log SetLevel to Debug Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_INFO)
if logger.GetLevel() != logadapter.LOG_INFO {
t.Errorf("Log SetLevel to Info Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_WARN)
if logger.GetLevel() != logadapter.LOG_WARN {
t.Errorf("Log SetLevel to Trace Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_ERROR)
if logger.GetLevel() != logadapter.LOG_ERROR {
t.Errorf("Log SetLevel to Error Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_FATAL)
if logger.GetLevel() != logadapter.LOG_FATAL {
t.Errorf("Log SetLevel to Fatal Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_PANIC)
if logger.GetLevel() != logadapter.LOG_PANIC {
t.Errorf("Log SetLevel to Panic Failed: %d", logger.GetLevel())
}
}
func TestStdNewLog(t *testing.T) {
logger := stdlogger.DefaultLogger()
logger.SetLevel(logadapter.LOG_TRACE)
logger2 := logger.New("Blah")
output := captureOutput(logger2.(*stdlogger.StdLogger), func() {
logger2.Error("Hello %s", "world")
})
validmsg := regexp.MustCompile(`^Blah .* ERROR: Hello world \- {}`)
if !validmsg.MatchString(output) {
t.Errorf("Log Error Failed: %s", output)
}
}
func TestStdWith(t *testing.T) {
logger := stdlogger.DefaultLogger()
logger.SetLevel(logadapter.LOG_TRACE)
logger2 := logger.With("Test", "Message")
output := captureOutput(logger2.(*stdlogger.StdLogger), func() {
logger2.Info("Hello %s", "world")
})
validmsg := regexp.MustCompile(`^.* INFO: Hello world \- {\"Test\":\"Message\"}`)
if !validmsg.MatchString(output) {
t.Errorf("Log With Failed: %s", output)
}
}

32
loggers/zap/zap.go
View file

@ -33,6 +33,7 @@ var _ logadapter.Logger = (*ZapLogger)(nil)
type ZapLogger struct { type ZapLogger struct {
Zap *zap.SugaredLogger Zap *zap.SugaredLogger
lvl logadapter.Log_Level
} }
func (l *ZapLogger) With(key string, value interface{}) logadapter.Logger { func (l *ZapLogger) With(key string, value interface{}) logadapter.Logger {
@ -41,25 +42,39 @@ func (l *ZapLogger) With(key string, value interface{}) logadapter.Logger {
} }
func (l *ZapLogger) Trace(message string, params ...interface{}) { func (l *ZapLogger) Trace(message string, params ...interface{}) {
if l.lvl <= logadapter.LOG_TRACE {
l.Zap.Debugf(message, params...) l.Zap.Debugf(message, params...)
}
} }
func (l *ZapLogger) Debug(message string, params ...interface{}) { func (l *ZapLogger) Debug(message string, params ...interface{}) {
l.Zap.Debugf(message, params...) if l.lvl <= logadapter.LOG_DEBUG {
l.Zap.Debugf(message, params...)
}
} }
func (l *ZapLogger) Info(message string, params ...interface{}) { func (l *ZapLogger) Info(message string, params ...interface{}) {
if l.lvl <= logadapter.LOG_INFO {
l.Zap.Infof(message, params...) l.Zap.Infof(message, params...)
}
} }
func (l *ZapLogger) Warn(message string, params ...interface{}) { func (l *ZapLogger) Warn(message string, params ...interface{}) {
l.Zap.Warnf(message, params...) if l.lvl <= logadapter.LOG_WARN {
l.Zap.Warnf(message, params...)
}
} }
func (l *ZapLogger) Error(message string, params ...interface{}) { func (l *ZapLogger) Error(message string, params ...interface{}) {
l.Zap.Errorf(message, params...) if l.lvl <= logadapter.LOG_ERROR {
l.Zap.Errorf(message, params...)
}
} }
func (l *ZapLogger) Fatal(message string, params ...interface{}) { func (l *ZapLogger) Fatal(message string, params ...interface{}) {
l.Zap.Fatalf(message, params...) if l.lvl <= logadapter.LOG_FATAL {
l.Zap.Fatalf(message, params...)
}
} }
func (l *ZapLogger) Panic(message string, params ...interface{}) { func (l *ZapLogger) Panic(message string, params ...interface{}) {
l.Zap.Panicf(message, params...) if l.lvl <= logadapter.LOG_PANIC {
l.Zap.Panicf(message, params...)
}
} }
func (l *ZapLogger) New(name string) (nl logadapter.Logger) { func (l *ZapLogger) New(name string) (nl logadapter.Logger) {
zl := &ZapLogger{Zap: l.Zap} zl := &ZapLogger{Zap: l.Zap}
@ -78,6 +93,13 @@ func (l ZapLogger) GetPrefix() (string) {
return "" return ""
} }
func (l *ZapLogger) GetLevel() (logadapter.Log_Level) {
return l.lvl
}
func (l *ZapLogger) SetLevel(lvl logadapter.Log_Level) {
l.lvl = lvl
}
//DefaultLogger Return Default Sched Logger based on Zap's sugared logger //DefaultLogger Return Default Sched Logger based on Zap's sugared logger
func NewZapLogger() *ZapLogger { func NewZapLogger() *ZapLogger {
// TODO control verbosity // TODO control verbosity

272
loggers/zap/zap_test.go
View file

@ -30,109 +30,189 @@ import (
// "regexp" // "regexp"
"testing" "testing"
// "github.com/Fishwaldo/go-logadapter/loggers/zap" "github.com/Fishwaldo/go-logadapter"
"github.com/Fishwaldo/go-logadapter/loggers/zap"
) )
func TestDefaultLogger(t *testing.T) { func TestZapLogger(t *testing.T) {
//_ := zaplog.ZapLogger{} logger := zaplog.NewZapLogger()
//logger.SetLevel(stdlogger.LOG_TRACE) logger.SetLevel(logadapter.LOG_TRACE)
//if logger.GetLevel() != stdlogger.LOG_TRACE { if logger.GetLevel() != logadapter.LOG_TRACE {
// t.Errorf("Can't Set Logging Level") t.Errorf("Can't Set Logging Level")
//} }
} }
// func captureOutput(l *zaplog.ZapLogger, f func()) string { // func captureOutput(l *zaplog.ZapLogger, f func()) string {
// // var buf bytes.Buffer // var buf bytes.Buffer
// // l.Log.SetOutput(&buf) // l.Log.SetOutput(&buf)
// // f() // f()
// // l.Log.SetOutput(os.Stderr) // l.Log.SetOutput(os.Stderr)
// // return buf.String() // return buf.String()
// } // }
func TestLogTrace(t *testing.T) { // func TestLogTrace(t *testing.T) {
// logger := stdlogger.DefaultLogger() // logger := zaplog.NewZapLogger()
// logger.SetLevel(stdlogger.LOG_TRACE) // logger.SetLevel(logadapter.LOG_TRACE)
// output := captureOutput(logger, func() { // output := captureOutput(logger, func() {
// logger.Trace("Hello %s", "world") // logger.Trace("Hello %s", "world")
// }) // })
// validmsg := regexp.MustCompile(`^.* TRACE: Hello world \- {}`) // validmsg := regexp.MustCompile(`^.* TRACE: Hello world \- {}`)
// if !validmsg.MatchString(output) { // if !validmsg.MatchString(output) {
// t.Errorf("Log Trace Failed: %s", output) // t.Errorf("Log Trace Failed: %s", output)
// } // }
} // }
func TestLogDebug(t *testing.T) { // func TestLogDebug(t *testing.T) {
// logger := stdlogger.DefaultLogger() // logger := zaplog.NewZapLogger()
// logger.SetLevel(stdlogger.LOG_TRACE) // logger.SetLevel(logadapter.LOG_TRACE)
// output := captureOutput(logger, func() { // output := captureOutput(logger, func() {
// logger.Debug("Hello %s", "world") // logger.Debug("Hello %s", "world")
// }) // })
// validmsg := regexp.MustCompile(`^.* DEBUG: Hello world \- {}`) // validmsg := regexp.MustCompile(`^.* DEBUG: Hello world \- {}`)
// if !validmsg.MatchString(output) { // if !validmsg.MatchString(output) {
// t.Errorf("Log Debug Failed: %s", output) // t.Errorf("Log Debug Failed: %s", output)
// } // }
// }
// func TestLogInfo(t *testing.T) {
// logger := zaplog.NewZapLogger()
// logger.SetLevel(logadapter.LOG_TRACE)
// output := captureOutput(logger, func() {
// logger.Info("Hello %s", "world")
// })
// validmsg := regexp.MustCompile(`^.* INFO: Hello world \- {}`)
// if !validmsg.MatchString(output) {
// t.Errorf("Log Info Failed: %s", output)
// }
// }
// func TestLogWarn(t *testing.T) {
// logger := zaplog.NewZapLogger()
// logger.SetLevel(logadapter.LOG_TRACE)
// output := captureOutput(logger, func() {
// logger.Warn("Hello %s", "world")
// })
// validmsg := regexp.MustCompile(`^.* WARN: Hello world \- {}`)
// if !validmsg.MatchString(output) {
// t.Errorf("Log Warn Failed: %s", output)
// }
// }
// func TestLogError(t *testing.T) {
// logger := zaplog.NewZapLogger()
// logger.SetLevel(logadapter.LOG_TRACE)
// output := captureOutput(logger, func() {
// logger.Error("Hello %s", "world")
// })
// validmsg := regexp.MustCompile(`^.* ERROR: Hello world \- {}`)
// if !validmsg.MatchString(output) {
// t.Errorf("Log Error Failed: %s", output)
// }
// }
// func TestLogFatal(t *testing.T) {
// logger := DefaultLogger()
// logger.SetLevel(LOG_TRACE)
// output := captureOutput(logger, func() {
// logger.Fatal("Hello %s", "world")
// })
// validmsg := regexp.MustCompile(`^.* FATAL: Hello world \- {}`)
// if !validmsg.MatchString(output) {
// t.Errorf("Log Fatal Failed: %s", output)
// }
// }
// func TestLogPanic(t *testing.T) {
// logger := zaplog.NewZapLogger()
// logger.SetLevel(logadapter.LOG_TRACE)
// defer func() {
// if err := recover(); err == nil {
// t.Errorf("Log Panic Recovery Failed")
// }
// }()
// output := captureOutput(logger, func() {
// logger.Panic("Hello %s", "world")
// })
// validmsg := regexp.MustCompile(`^.* PANIC: Hello world \- {}`)
// if !validmsg.MatchString(output) {
// t.Errorf("Log Panic Failed: %s", output)
// }
// }
// func TestLogPrefix(t *testing.T) {
// logger := zaplog.NewZapLogger()
// logger.SetLevel(logadapter.LOG_TRACE)
// if logger.GetPrefix() != "log" {
// t.Errorf("Empty Log Prefix Failed: %s", logger.GetPrefix())
// }
// logger.SetPrefix("TestLog")
// output := captureOutput(logger, func() {
// logger.Info("Hello %s", "world")
// })
// validmsg := regexp.MustCompile(`^TestLog .* INFO: Hello world \- {}`)
// if !validmsg.MatchString(output) {
// t.Errorf("Log Prefix Failed: %s", output)
// }
// if logger.GetPrefix() != "TestLog" {
// t.Errorf("Log Prefix Failed: %s", logger.GetPrefix())
// }
// }
func TestZapLevel(t *testing.T) {
logger := zaplog.NewZapLogger()
logger.SetLevel(logadapter.LOG_TRACE)
if logger.GetLevel() != logadapter.LOG_TRACE {
t.Errorf("Log SetLevel to Trace Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_DEBUG)
if logger.GetLevel() != logadapter.LOG_DEBUG {
t.Errorf("Log SetLevel to Debug Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_INFO)
if logger.GetLevel() != logadapter.LOG_INFO {
t.Errorf("Log SetLevel to Info Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_WARN)
if logger.GetLevel() != logadapter.LOG_WARN {
t.Errorf("Log SetLevel to Trace Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_ERROR)
if logger.GetLevel() != logadapter.LOG_ERROR {
t.Errorf("Log SetLevel to Error Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_FATAL)
if logger.GetLevel() != logadapter.LOG_FATAL {
t.Errorf("Log SetLevel to Fatal Failed: %d", logger.GetLevel())
}
logger.SetLevel(logadapter.LOG_PANIC)
if logger.GetLevel() != logadapter.LOG_PANIC {
t.Errorf("Log SetLevel to Panic Failed: %d", logger.GetLevel())
}
} }
func TestLogInfo(t *testing.T) { // func TestNewLog(t *testing.T) {
// logger := stdlogger.DefaultLogger() // logger := zaplog.NewZapLogger()
// logger.SetLevel(stdlogger.LOG_TRACE) // logger.SetLevel(logadapter.LOG_TRACE)
// output := captureOutput(logger, func() { // logger2 := logger.New("Blah")
// logger.Info("Hello %s", "world") // output := captureOutput(logger2.(*stdlogger.StdLogger), func() {
// }) // logger2.Error("Hello %s", "world")
// validmsg := regexp.MustCompile(`^.* INFO: Hello world \- {}`) // })
// if !validmsg.MatchString(output) { // validmsg := regexp.MustCompile(`^Blah .* ERROR: Hello world \- {}`)
// t.Errorf("Log Info Failed: %s", output) // t.Logf("%+v", logger2)
// } // if !validmsg.MatchString(output) {
} // t.Errorf("Log Error Failed: %s", output)
// }
// }
func TestLogWarn(t *testing.T) { // func TestLogWith(t *testing.T) {
// logger := stdlogger.DefaultLogger() // logger := zaplog.NewZapLogger()
// logger.SetLevel(stdlogger.LOG_TRACE) // logger.SetLevel(logadapter.LOG_TRACE)
// output := captureOutput(logger, func() { // logger2 := logger.With("Test", "Message")
// logger.Warn("Hello %s", "world")
// })
// validmsg := regexp.MustCompile(`^.* WARN: Hello world \- {}`)
// if !validmsg.MatchString(output) {
// t.Errorf("Log Warn Failed: %s", output)
// }
}
func TestLogError(t *testing.T) { // output := captureOutput(logger2.(*stdlogger.StdLogger), func() {
// logger := stdlogger.DefaultLogger() // logger2.Info("Hello %s", "world")
// logger.SetLevel(stdlogger.LOG_TRACE) // })
// output := captureOutput(logger, func() { // validmsg := regexp.MustCompile(`^.* INFO: Hello world \- {\"Test\":\"Message\"}`)
// logger.Error("Hello %s", "world") // if !validmsg.MatchString(output) {
// }) // t.Errorf("Log With Failed: %s", output)
// validmsg := regexp.MustCompile(`^.* ERROR: Hello world \- {}`) // }
// if !validmsg.MatchString(output) { // }
// t.Errorf("Log Error Failed: %s", output)
// }
}
func TestLogFatal(t *testing.T) {
//logger := DefaultLogger()
//logger.SetLevel(LOG_TRACE)
//output := captureOutput(logger, func() {
// logger.Fatal("Hello %s", "world")
//})
//validmsg := regexp.MustCompile(`^.* FATAL: Hello world \- {}`)
//if !validmsg.MatchString(output) {
// t.Errorf("Log Fatal Failed: %s", output)
//}
}
func TestLogPanic(t *testing.T) {
// logger := stdlogger.DefaultLogger()
// logger.SetLevel(stdlogger.LOG_TRACE)
// defer func() {
// if err := recover(); err == nil {
// t.Errorf("Log Panic Recovery Failed")
// }
// }()
// output := captureOutput(logger, func() {
// logger.Panic("Hello %s", "world")
// })
// validmsg := regexp.MustCompile(`^.* PANIC: Hello world \- {}`)
// if !validmsg.MatchString(output) {
// t.Errorf("Log Panic Failed: %s", output)
// }
}