From 8b352c7982597555e2508ddc9620beb545983860 Mon Sep 17 00:00:00 2001 From: Xabier Larrakoetxea Date: Sun, 23 Sep 2018 18:56:14 +0200 Subject: [PATCH] Improve examples Signed-off-by: Xabier Larrakoetxea --- Readme.md | 81 +++++++++++++++++++++++++++++++++++++++++++++-- example/go.mod | 9 +++++- example/go.sum | 16 ++++++++++ example/main.go | 84 ++++++++++++++++++++++++++++++++++++------------- 4 files changed, 165 insertions(+), 25 deletions(-) diff --git a/Readme.md b/Readme.md index e2bdb99..974e779 100644 --- a/Readme.md +++ b/Readme.md @@ -70,10 +70,87 @@ func main() { ``` For security reasons if you don't set a logger, it will use a dummy logger that will disable Kubernetes logs. Sometimes this is useful also. - Your custom logger needs to satisfy `noglog.Logger` interface. +You have a helper if you want to create a logger using functions instead of creating a new type, `noglog.LoggerFunc`. + +This helper gives a lot of power to set up loggers easily. Some examples... + +Logrus: + +```golang +import ( + "github.com/google/glog" + "github.com/sirupsen/logrus" +) -You have a helper if you want to create a logger using functions instead of creating a new type, `noglog.LoggerFunc` +func main() { + // Our app logger. + logger := logrus.New() + logger.SetLevel(logrus.DebugLevel) + + // Set our glog replacement. + glog.SetLogger(&glog.LoggerFunc{ + DebugfFunc: func(f string, a ...interface{}) { logger.Debugf(f, a...) }, + InfofFunc: func(f string, a ...interface{}) { logger.Infof(f, a...) }, + WarnfFunc: func(f string, a ...interface{}) { logger.Warnf(f, a...) }, + ErrorfFunc: func(f string, a ...interface{}) { logger.Errorf(f, a...) }, + }) + + glog.Info("I'm batman!") +} +``` + +Example for zap: + +```golang +import ( + "github.com/google/glog" + "go.uber.org/zap" +) + +func main() { + // Our app logger. + logger, _ := zap.NewProduction() + slogger := logger.Sugar() + + // Set our glog replacement. + glog.SetLogger(&glog.LoggerFunc{ + DebugfFunc: func(f string, a ...interface{}) { slogger.Debugf(f, a...) }, + InfofFunc: func(f string, a ...interface{}) { slogger.Infof(f, a...) }, + WarnfFunc: func(f string, a ...interface{}) { slogger.Warnf(f, a...) }, + ErrorfFunc: func(f string, a ...interface{}) { slogger.Errorf(f, a...) }, + }) + + glog.Info("I'm batman!") +} +``` + +Example for zerolog: + +```golang +import ( + "os" + + "github.com/google/glog" + "github.com/rs/zerolog" +) + +func main() { + // Our app logger. + w := zerolog.ConsoleWriter{Out: os.Stderr} + logger := zerolog.New(w).With().Timestamp().Logger() + + // Set our glog replacement. + glog.SetLogger(&glog.LoggerFunc{ + DebugfFunc: func(f string, a ...interface{}) { logger.Debug().Msgf(f, a...) }, + InfofFunc: func(f string, a ...interface{}) { logger.Info().Msgf(f, a...) }, + WarnfFunc: func(f string, a ...interface{}) { logger.Warn().Msgf(f, a...) }, + ErrorfFunc: func(f string, a ...interface{}) { logger.Error().Msgf(f, a...) }, + }) + + glog.Info("I'm batman!") +} +``` ## Why diff --git a/example/go.mod b/example/go.mod index bde2bd2..be7617d 100644 --- a/example/go.mod +++ b/example/go.mod @@ -2,7 +2,14 @@ module example require ( github.com/google/glog v0.3.5-0.20180716071806-8d7a107d68c1 + github.com/rs/zerolog v1.9.1 + github.com/sirupsen/logrus v1.0.6 github.com/slok/noglog v0.0.0-20180922095634-ef0d52ebfd8d // indirect + go.uber.org/atomic v1.3.2 // indirect + go.uber.org/multierr v1.1.0 // indirect + go.uber.org/zap v1.9.1 + golang.org/x/crypto v0.0.0-20180910181607-0e37d006457b // indirect + golang.org/x/sys v0.0.0-20180921163948-d47a0f339242 // indirect ) -replace github.com/google/glog => github.com/slok/noglog v0.0.0-20180922095634-ef0d52ebfd8d +replace github.com/google/glog => github.com/slok/noglog v0.1.1-0.20180923161859-ccca7a662ba9 diff --git a/example/go.sum b/example/go.sum index fed533f..ed423e7 100644 --- a/example/go.sum +++ b/example/go.sum @@ -1,2 +1,18 @@ +github.com/rs/zerolog v1.9.1 h1:AjV/SFRF0+gEa6rSjkh0Eji/DnkrJKVpPho6SW5g4mU= +github.com/rs/zerolog v1.9.1/go.mod h1:YbFCdg8HfsridGWAh22vktObvhZbQsZXe4/zB0OKkWU= +github.com/sirupsen/logrus v1.0.6 h1:hcP1GmhGigz/O7h1WVUM5KklBp1JoNS9FggWKdj/j3s= +github.com/sirupsen/logrus v1.0.6/go.mod h1:pMByvHTf9Beacp5x1UXfOR9xyW/9antXMhjMPG0dEzc= github.com/slok/noglog v0.0.0-20180922095634-ef0d52ebfd8d h1:v1vMg5M78Texj0QVKb5HKoGYD30U1RL55vQbHGXhIEs= github.com/slok/noglog v0.0.0-20180922095634-ef0d52ebfd8d/go.mod h1:TfKxwpEZPT+UA83bQ6RME146k0MM4e8mwHLf6bhcGDI= +github.com/slok/noglog v0.1.1-0.20180923161859-ccca7a662ba9 h1:l+Xl3lbidQJCnQTi5278YVCEAYIpb9NPSocoYypYdd4= +github.com/slok/noglog v0.1.1-0.20180923161859-ccca7a662ba9/go.mod h1:TfKxwpEZPT+UA83bQ6RME146k0MM4e8mwHLf6bhcGDI= +go.uber.org/atomic v1.3.2 h1:2Oa65PReHzfn29GpvgsYwloV9AVFHPDk8tYxt2c2tr4= +go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= +go.uber.org/multierr v1.1.0 h1:HoEmRHQPVSqub6w2z2d2EOVs2fjyFRGyofhKuyDq0QI= +go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= +go.uber.org/zap v1.9.1 h1:XCJQEf3W6eZaVwhRBof6ImoYGJSITeKWsyeh3HFu/5o= +go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= +golang.org/x/crypto v0.0.0-20180910181607-0e37d006457b h1:2b9XGzhjiYsYPnKXoEfL7klWZQIt8IfyRCz62gCqqlQ= +golang.org/x/crypto v0.0.0-20180910181607-0e37d006457b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/sys v0.0.0-20180921163948-d47a0f339242 h1:5DYsa+ZAwcJHjuY0Qet390sUr7qwkpnRsUNjddyc0b8= +golang.org/x/sys v0.0.0-20180921163948-d47a0f339242/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= diff --git a/example/main.go b/example/main.go index 69b4fea..9e13df0 100644 --- a/example/main.go +++ b/example/main.go @@ -2,45 +2,92 @@ package main import ( "fmt" + "os" "github.com/google/glog" + "github.com/rs/zerolog" + "github.com/sirupsen/logrus" + "go.uber.org/zap" ) -// GlogReplacement is the replacement for glog using our own +// stdLogger is the replacement for glog using our own // logging system. -type GlogReplacement struct { - Debug bool -} - -// DebugEnabled satisfies glog.Logger interface. -func (g *GlogReplacement) DebugEnabled() bool { - return g.Debug +type stdLogger struct { + debug bool } // Debugf satisfies glog.Logger interface. -func (g *GlogReplacement) Debugf(format string, args ...interface{}) { - fmt.Printf("[DEBUG] "+format, args...) +func (s *stdLogger) Debugf(format string, args ...interface{}) { + if s.debug { + fmt.Printf("[DEBUG] "+format, args...) + } } // Infof satisfies glog.Logger interface. -func (g *GlogReplacement) Infof(format string, args ...interface{}) { +func (*stdLogger) Infof(format string, args ...interface{}) { fmt.Printf("[INFO] "+format, args...) } // Warnf satisfies glog.Logger interface. -func (g *GlogReplacement) Warnf(format string, args ...interface{}) { +func (*stdLogger) Warnf(format string, args ...interface{}) { fmt.Printf("[WARN] "+format, args...) } // Errorf satisfies glog.Logger interface. -func (g *GlogReplacement) Errorf(format string, args ...interface{}) { +func (*stdLogger) Errorf(format string, args ...interface{}) { fmt.Printf("[ERROR] "+format, args...) } func main() { - logger := &GlogReplacement{} - glog.SetLogger(logger) + loggerSetters := map[string]func() glog.Logger{ + "std": func() glog.Logger { + // Example using a type. + return &stdLogger{debug: true} + }, + "logrus": func() glog.Logger { + // Example using LoggerFunc. + logger := logrus.New() + logger.SetLevel(logrus.DebugLevel) + return &glog.LoggerFunc{ + DebugfFunc: func(f string, a ...interface{}) { logger.Debugf(f, a...) }, + InfofFunc: func(f string, a ...interface{}) { logger.Infof(f, a...) }, + WarnfFunc: func(f string, a ...interface{}) { logger.Warnf(f, a...) }, + ErrorfFunc: func(f string, a ...interface{}) { logger.Errorf(f, a...) }, + } + }, + "zap": func() glog.Logger { + // Example using LoggerFunc. + logger, _ := zap.NewProduction() + slogger := logger.Sugar() + return &glog.LoggerFunc{ + DebugfFunc: func(f string, a ...interface{}) { slogger.Debugf(f, a...) }, + InfofFunc: func(f string, a ...interface{}) { slogger.Infof(f, a...) }, + WarnfFunc: func(f string, a ...interface{}) { slogger.Warnf(f, a...) }, + ErrorfFunc: func(f string, a ...interface{}) { slogger.Errorf(f, a...) }, + } + }, + "zerolog": func() glog.Logger { + // Example using LoggerFunc. + w := zerolog.ConsoleWriter{Out: os.Stderr} + logger := zerolog.New(w).With().Timestamp().Logger() + return &glog.LoggerFunc{ + DebugfFunc: func(f string, a ...interface{}) { logger.Debug().Msgf(f, a...) }, + InfofFunc: func(f string, a ...interface{}) { logger.Info().Msgf(f, a...) }, + WarnfFunc: func(f string, a ...interface{}) { logger.Warn().Msgf(f, a...) }, + ErrorfFunc: func(f string, a ...interface{}) { logger.Error().Msgf(f, a...) }, + } + }, + } + + for name, f := range loggerSetters { + fmt.Printf("\n---------%s----------\n\n", name) + glog.SetLogger(f()) + logWithGlog() + fmt.Println() + } +} +func logWithGlog() { glog.Info("I'm batman!") glog.InfoDepth(1, "I'm batman!") glog.Infoln("I'm batman!") @@ -56,13 +103,6 @@ func main() { glog.Errorln("I'm batman!") glog.Errorf("%s - %s", "I'm", "batman!") - // Without debug. - glog.V(2).Info("I'm batman!") - glog.V(2).Infoln("I'm batman!") - glog.V(2).Infof("%s - %s", "I'm", "batman!") - - // With debug. - logger.Debug = true glog.V(2).Info("I'm batman!") glog.V(2).Infoln("I'm batman!") glog.V(2).Infof("%s - %s", "I'm", "batman!")