From ecf44c15e02d9243ae08bdf00a55a832ceca1120 Mon Sep 17 00:00:00 2001
From: Thomas Boerger <thomas@webhippie.de>
Date: Fri, 6 Dec 2019 09:33:03 +0100
Subject: [PATCH] Better log level handling within micro

Currently every log message from the micro internals are logged with the info
level, we really need to respect the proper defined log level within our log
wrapper package.
---
 changelog/unreleased/log-level-handling.md |  7 ++
 log/log.go                                 | 84 ++++++++++++++++++----
 2 files changed, 76 insertions(+), 15 deletions(-)
 create mode 100644 changelog/unreleased/log-level-handling.md

diff --git a/changelog/unreleased/log-level-handling.md b/changelog/unreleased/log-level-handling.md
new file mode 100644
index 000000000..69aefe0c7
--- /dev/null
+++ b/changelog/unreleased/log-level-handling.md
@@ -0,0 +1,7 @@
+Change: Better log level handling within micro
+
+Currently every log message from the micro internals are logged with the info
+level, we really need to respect the proper defined log level within our log
+wrapper package.
+
+https://github.com/owncloud/ocis-pkg/issues/2
diff --git a/log/log.go b/log/log.go
index 475c7120a..fee5c5745 100644
--- a/log/log.go
+++ b/log/log.go
@@ -1,7 +1,9 @@
 package log
 
 import (
+	"fmt"
 	"os"
+	"runtime"
 	"strings"
 	"time"
 
@@ -22,18 +24,28 @@ func NewLogger(opts ...Option) Logger {
 	switch strings.ToLower(options.Level) {
 	case "panic":
 		zerolog.SetGlobalLevel(zerolog.PanicLevel)
+		mlog.SetLevel(mlog.LevelFatal)
 	case "fatal":
 		zerolog.SetGlobalLevel(zerolog.FatalLevel)
+		mlog.SetLevel(mlog.LevelFatal)
 	case "error":
 		zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+		mlog.SetLevel(mlog.LevelError)
 	case "warn":
 		zerolog.SetGlobalLevel(zerolog.WarnLevel)
+		mlog.SetLevel(mlog.LevelWarn)
 	case "info":
 		zerolog.SetGlobalLevel(zerolog.InfoLevel)
+		mlog.SetLevel(mlog.LevelInfo)
 	case "debug":
 		zerolog.SetGlobalLevel(zerolog.DebugLevel)
+		mlog.SetLevel(mlog.LevelDebug)
+	case "trace":
+		zerolog.SetGlobalLevel(zerolog.DebugLevel)
+		mlog.SetLevel(mlog.LevelTrace)
 	default:
 		zerolog.SetGlobalLevel(zerolog.InfoLevel)
+		mlog.SetLevel(mlog.LevelInfo)
 	}
 
 	var logger zerolog.Logger
@@ -58,8 +70,8 @@ func NewLogger(opts ...Option) Logger {
 		Logger()
 
 	mlog.SetLogger(
-		logWrapper{
-			logger,
+		microZerolog{
+			logger: logger,
 		},
 	)
 
@@ -68,23 +80,65 @@ func NewLogger(opts ...Option) Logger {
 	}
 }
 
-// logWrapper implements the required interface for the go-micro logger.
-type logWrapper struct {
+// microZerolog implements the required interface for the go-micro logger.
+type microZerolog struct {
 	logger zerolog.Logger
 }
 
-// Log makes use of github.com/go-log/log.Log
-func (w logWrapper) Log(v ...interface{}) {
-	tmp := make([]string, len(v))
+// Log makes use of github.com/go-log/log.Log.
+func (mz microZerolog) Log(v ...interface{}) {
+	pc := parentCaller()
+	msg := fmt.Sprint(v...)
 
-	for _, row := range v {
-		tmp = append(tmp, row.(string))
+	switch {
+	case strings.HasSuffix(pc, "Fatal"):
+		mz.logger.Fatal().Msg(msg)
+	case strings.HasSuffix(pc, "Error"):
+		mz.logger.Error().Msg(msg)
+	case strings.HasSuffix(pc, "Info"):
+		mz.logger.Info().Msg(msg)
+	case strings.HasSuffix(pc, "Warn"):
+		mz.logger.Warn().Msg(msg)
+	case strings.HasSuffix(pc, "Debug"):
+		mz.logger.Debug().Msg(msg)
+	case strings.HasSuffix(pc, "Trace"):
+		mz.logger.Debug().Msg(msg)
+	default:
+		mz.logger.Info().Msg(msg)
+	}
+}
+
+// Logf makes use of github.com/go-log/log.Logf.
+func (mz microZerolog) Logf(format string, v ...interface{}) {
+	pc := parentCaller()
+	msg := fmt.Sprintf(strings.TrimRight(format, "\n"), v...)
+
+	switch {
+	case strings.HasSuffix(pc, "Fatalf"):
+		mz.logger.Fatal().Msg(msg)
+	case strings.HasSuffix(pc, "Errorf"):
+		mz.logger.Error().Msg(msg)
+	case strings.HasSuffix(pc, "Infof"):
+		mz.logger.Info().Msg(msg)
+	case strings.HasSuffix(pc, "Warnf"):
+		mz.logger.Warn().Msg(msg)
+	case strings.HasSuffix(pc, "Debugf"):
+		mz.logger.Debug().Msg(msg)
+	case strings.HasSuffix(pc, "Tracef"):
+		mz.logger.Debug().Msg(msg)
+	default:
+		mz.logger.Info().Msg(msg)
+	}
+}
+
+// parentCaller tries to detect which log method had been invoked.
+func parentCaller() string {
+	pc, _, _, ok := runtime.Caller(4)
+	fn := runtime.FuncForPC(pc)
+
+	if ok && fn != nil {
+		return fn.Name()
 	}
 
-	w.logger.Info().Msg(strings.Join(tmp, " "))
-}
-
-// Logf makes use of github.com/go-log/log.Logf
-func (w logWrapper) Logf(format string, v ...interface{}) {
-	w.logger.Info().Msgf(strings.TrimRight(format, "\n"), v...)
+	return ""
 }