Improve logging wrapper

Author: MacroPower

cmd/go_template/main.go

@@ -40,8 +40,10 @@ func main() {
 
 	err := log.Info(logger).Log("msg", fmt.Sprintf("Starting %s", appName))
 	cliCtx.FatalIfErrorf(err)
-	version.LogInfo(logger)
-	version.LogBuildContext(logger)
+	err = version.LogInfo(logger)
+	cliCtx.FatalIfErrorf(err)
+	err = version.LogBuildContext(logger)
+	cliCtx.FatalIfErrorf(err)
 
 	sb := strings.Builder{}
 	Hello(&sb)

internal/log/log.go

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package log defines standardized ways to initialize Go kit loggers.
-// It should typically only ever be imported by main packages.
 package log
 
 import (
@@ -40,6 +38,10 @@ var timestampFormat = log.TimestampFormat(
 	"2006-01-02T15:04:05.000Z07:00",
 )
 
+type Logger interface {
+	Log(keyvals ...interface{}) error
+}
+
 // AllowedLevel is a settable identifier for the minimum level a log entry
 // must be have.
 type AllowedLevel struct {
@@ -121,15 +123,20 @@ type Config struct {
 	Format *AllowedFormat
 }
 
+type SimpleLogger struct {
+	Base    log.Logger
+	Leveled log.Logger
+}
+
 // New returns a new leveled logger. Each logged line will be annotated
-// with a timestamp. The output always goes to stderr.
-func New(config *Config) log.Logger {
+// with a timestamp. The output always goes to stdout.
+func New(config *Config) *SimpleLogger {
 	var l log.Logger
 
 	if config.Format != nil && config.Format.s == jsonFormat {
-		l = log.NewJSONLogger(log.NewSyncWriter(os.Stderr))
+		l = log.NewJSONLogger(log.NewSyncWriter(os.Stdout))
 	} else {
-		l = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr))
+		l = log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout))
 	}
 
 	if config.Level != nil {
@@ -139,22 +146,36 @@ func New(config *Config) log.Logger {
 		l = log.With(l, "ts", timestampFormat, "caller", log.DefaultCaller)
 	}
 
-	return l
+	lo := &SimpleLogger{
+		Base:    l,
+		Leveled: l,
+	}
+
+	return lo
+}
+
+// Log implements [log.Logger].
+func (l *SimpleLogger) Log(keyvals ...interface{}) error {
+	if err := l.Leveled.Log(keyvals...); err != nil {
+		return fmt.Errorf("log error: %w", err)
+	}
+
+	return nil
 }
 
 // NewDynamic returns a new leveled logger. Each logged line will be annotated
-// with a timestamp. The output always goes to stderr. Some properties can be
+// with a timestamp. The output always goes to stdout. Some properties can be
 // changed, like the level.
-func NewDynamic(config *Config) *Logger {
+func NewDynamic(config *Config) *DynamicLogger {
 	var l log.Logger
 
 	if config.Format != nil && config.Format.s == jsonFormat {
-		l = log.NewJSONLogger(log.NewSyncWriter(os.Stderr))
+		l = log.NewJSONLogger(log.NewSyncWriter(os.Stdout))
 	} else {
-		l = log.NewLogfmtLogger(log.NewSyncWriter(os.Stderr))
+		l = log.NewLogfmtLogger(log.NewSyncWriter(os.Stdout))
 	}
 
-	lo := &Logger{
+	lo := &DynamicLogger{
 		Base:    l,
 		Leveled: l,
 	}
@@ -166,16 +187,16 @@ func NewDynamic(config *Config) *Logger {
 	return lo
 }
 
-type Logger struct {
+type DynamicLogger struct {
 	Base         log.Logger
 	Leveled      log.Logger
 	CurrentLevel *AllowedLevel
 
 	mtx sync.Mutex
 }
 
-// Log implements logger.Log.
-func (l *Logger) Log(keyvals ...interface{}) error {
+// Log implements [log.Logger].
+func (l *DynamicLogger) Log(keyvals ...interface{}) error {
 	l.mtx.Lock()
 	defer l.mtx.Unlock()
 
@@ -187,7 +208,7 @@ func (l *Logger) Log(keyvals ...interface{}) error {
 }
 
 // SetLevel changes the log level.
-func (l *Logger) SetLevel(lvl *AllowedLevel) {
+func (l *DynamicLogger) SetLevel(lvl *AllowedLevel) {
 	l.mtx.Lock()
 	defer l.mtx.Unlock()
 
@@ -207,21 +228,36 @@ func (l *Logger) SetLevel(lvl *AllowedLevel) {
 }
 
 // Error returns a logger that includes a Key/ErrorValue pair.
-func Error(logger log.Logger) log.Logger {
-	return log.WithPrefix(logger, level.Key(), level.ErrorValue())
+func Error(logger Logger) Logger {
+	return WithPrefix(logger, level.Key(), level.ErrorValue())
 }
 
 // Warn returns a logger that includes a Key/WarnValue pair.
-func Warn(logger log.Logger) log.Logger {
-	return log.WithPrefix(logger, level.Key(), level.WarnValue())
+func Warn(logger Logger) Logger {
+	return WithPrefix(logger, level.Key(), level.WarnValue())
 }
 
 // Info returns a logger that includes a Key/InfoValue pair.
-func Info(logger log.Logger) log.Logger {
-	return log.WithPrefix(logger, level.Key(), level.InfoValue())
+func Info(logger Logger) Logger {
+	return WithPrefix(logger, level.Key(), level.InfoValue())
 }
 
 // Debug returns a logger that includes a Key/DebugValue pair.
-func Debug(logger log.Logger) log.Logger {
-	return log.WithPrefix(logger, level.Key(), level.DebugValue())
+func Debug(logger Logger) Logger {
+	return WithPrefix(logger, level.Key(), level.DebugValue())
+}
+
+// WithPrefix wraps [log.WithPrefix].
+func WithPrefix(logger Logger, keyvals ...interface{}) Logger {
+	return log.WithPrefix(logger, keyvals...)
+}
+
+// With wraps [log.With].
+func With(logger Logger, keyvals ...interface{}) Logger {
+	return log.With(logger, keyvals...)
+}
+
+// WithSuffix wraps [log.WithSuffix].
+func WithSuffix(logger Logger, keyvals ...interface{}) Logger {
+	return log.WithSuffix(logger, keyvals...)
 }

internal/version/version.go

@@ -1,12 +1,11 @@
 package version
 
 import (
+	"fmt"
 	"runtime"
 	"runtime/debug"
 
 	"github.com/MacroPower/go_template/internal/log"
-
-	kitlog "github.com/go-kit/log"
 )
 
 var (
@@ -22,28 +21,32 @@ var (
 )
 
 // LogInfo logs version, branch and revision.
-func LogInfo(logger kitlog.Logger) {
+func LogInfo(logger log.Logger) error {
 	if err := log.Info(logger).Log(
 		"msg", "info",
 		"version", Version,
 		"branch", Branch,
 		"revision", Revision,
 	); err != nil {
-		panic(err)
+		return fmt.Errorf("log error: %w", err)
 	}
+
+	return nil
 }
 
 // LogBuildContext logs goVersion, platform, buildUser and buildDate.
-func LogBuildContext(logger kitlog.Logger) {
+func LogBuildContext(logger log.Logger) error {
 	if err := log.Info(logger).Log(
 		"msg", "build context",
 		"go", GoVersion,
 		"platform", GoOS+"/"+GoArch,
-		"user", BuildUser,
-		"date", BuildDate,
+		"buildUser", BuildUser,
+		"buildDate", BuildDate,
 	); err != nil {
-		panic(err)
+		return fmt.Errorf("log error: %w", err)
 	}
+
+	return nil
 }
 
 func getRevision() string {