added child logger and logger context method go-aah/aah#111

Author: jeevatkm

default.go

@@ -117,6 +117,12 @@ func Panicln(v ...interface{}) {
 	dl.Panicln(v...)
 }
 
+// AddContext method to add context values into default logger.
+// These context values gets logged with each log entry.
+func AddContext(fields Fields) {
+	dl.AddContext(fields)
+}
+
 // WithFields method to add multiple key-value pairs into log.
 func WithFields(fields Fields) *Entry {
 	return dl.WithFields(fields)
@@ -132,6 +138,11 @@ func Writer() io.Writer {
 	return dl.receiver.Writer()
 }
 
+// SetWriter method sets the given writer into logger instance.
+func SetWriter(w io.Writer) {
+	dl.SetWriter(w)
+}
+
 // ToGoLogger method wraps the current log writer into Go Logger instance.
 func ToGoLogger() *slog.Logger {
 	return dl.ToGoLogger()

default_test.go

@@ -70,6 +70,8 @@ func TestDefaultContextLogging(t *testing.T) {
 	_ = SetPattern("%utctime:2006-01-02 15:04:05.000 %level:-5 %longfile %line %custom:- %message %fields")
 	_ = SetLevel("trace")
 
+	AddContext(Fields{"myname": "default logger"})
+
 	Trace("I would like to see this message, trace is more fine grained for dev")
 	Tracef("I would like to see this message, trace is more fine grained for dev: %v", 4)
 
@@ -79,7 +81,7 @@ func TestDefaultContextLogging(t *testing.T) {
 	Info("Yes, I would love to see")
 	Infof("Yes, I would love to %v", "see")
 
-	Warn("Yes, yes it's an warning")
+	WithField("warnkey1", "warn value 1").WithField("warnkey2", "warn value 2").Warn("Yes, yes it's an warning")
 	Warnf("Yes, yes it's an %v", "warning")
 
 	Error("Yes, yes, yes - finally an error")
@@ -92,12 +94,15 @@ func TestDefaultContextLogging(t *testing.T) {
 	exit = os.Exit
 
 	// With Context
-	ctx := WithField("ctx1", "ctx1 value").WithFields(Fields{"ctx2": "ctx 2 value"})
+	ctx := dl.New(Fields{
+		"key1": "key 1 value",
+		"key2": "key 2 value",
+	})
 
 	ctx.Trace("I would like to see this message, trace is more fine grained for dev")
 	ctx.Tracef("I would like to see this message, trace is more fine grained for dev: %v", 4)
 
-	ctx.Debug("I would like to see this message, debug is useful for dev")
+	ctx.WithField("key3", "key 3 value").Debug("I would like to see this message, debug is useful for dev")
 	ctx.Debugf("I would like to see this message, debug is useful for %v", "dev")
 
 	ctx.Info("Yes, I would love to see")
@@ -119,6 +124,12 @@ func TestDefaultContextLogging(t *testing.T) {
 	ctx2.Print("hi fields")
 }
 
+func TestDefaultFieldsLogging(t *testing.T) {
+	_ = SetPattern("%time:2006-01-02 15:04:05.000 %level:-5 %appname %reqid %principal %message %fields")
+	WithField("appname", "value1").Info("Logging value 1")
+	WithFields(Fields{"appname": "value1", "key1": "key1value"}).Info("Logging value 1")
+}
+
 func testStdPanic(method, msg string) {
 	defer func() {
 		if r := recover(); r != nil {

entry.go

@@ -192,25 +192,8 @@ func (e *Entry) Panicln(v ...interface{}) {
 // WithFields method to add multiple key-value pairs into log.
 func (e *Entry) WithFields(fields Fields) *Entry {
 	ne := acquireEntry(e.logger)
-	for k, v := range e.Fields {
-		ne.Fields[k] = v
-	}
-	for k, v := range fields {
-		if k == "appname" {
-			ne.AppName = fmt.Sprint(v)
-			continue
-		}
-		if k == "reqid" {
-			ne.RequestID = fmt.Sprint(v)
-			continue
-		}
-		if k == "principal" {
-			ne.Principal = fmt.Sprint(v)
-			continue
-		}
-
-		ne.Fields[k] = v
-	}
+	ne.addFields(e.Fields)
+	ne.addFields(fields)
 	return ne
 }
 
@@ -219,35 +202,6 @@ func (e *Entry) WithField(key string, value interface{}) *Entry {
 	return e.WithFields(Fields{key: value})
 }
 
-//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
-// Entry level methods
-//___________________________________
-
-// IsLevelInfo method returns true if log level is INFO otherwise false.
-func (e *Entry) IsLevelInfo() bool {
-	return e.logger.level == LevelInfo
-}
-
-// IsLevelError method returns true if log level is ERROR otherwise false.
-func (e *Entry) IsLevelError() bool {
-	return e.logger.level == LevelError
-}
-
-// IsLevelWarn method returns true if log level is WARN otherwise false.
-func (e *Entry) IsLevelWarn() bool {
-	return e.logger.level == LevelWarn
-}
-
-// IsLevelDebug method returns true if log level is DEBUG otherwise false.
-func (e *Entry) IsLevelDebug() bool {
-	return e.logger.level == LevelDebug
-}
-
-// IsLevelTrace method returns true if log level is TRACE otherwise false.
-func (e *Entry) IsLevelTrace() bool {
-	return e.logger.level == LevelTrace
-}
-
 // Reset method resets the `Entry` values for reuse.
 func (e *Entry) Reset() {
 	e.AppName = ""
@@ -258,7 +212,7 @@ func (e *Entry) Reset() {
 	e.Message = ""
 	e.File = ""
 	e.Line = 0
-	e.Fields = make(map[string]interface{})
+	e.Fields = make(Fields)
 	e.logger = nil
 }
 
@@ -270,12 +224,28 @@ func (e *Entry) output(lvl level, msg string) {
 	e.Time = time.Now()
 	e.Level = lvl
 	e.Message = msg
+	e.addFields(e.logger.ctx)
 	e.logger.output(e)
 }
 
+func (e *Entry) addFields(fields Fields) {
+	for k, v := range fields {
+		switch k {
+		case "appname":
+			e.AppName = fmt.Sprint(v)
+		case "reqid":
+			e.RequestID = fmt.Sprint(v)
+		case "principal":
+			e.Principal = fmt.Sprint(v)
+		default:
+			e.Fields[k] = v
+		}
+	}
+}
+
 func newEntry() *Entry {
 	return &Entry{
-		Fields: make(map[string]interface{}),
+		Fields: make(Fields),
 	}
 }
 

formatter.go

@@ -59,7 +59,7 @@ var (
 	// Usage of flag order is up to format composition.
 	//    level     - outputs INFO, DEBUG, ERROR, so on
 	//    appname   - outputs Application Name (aka instance name)
-	//    reqid     - outputs Request ID HTTP header value
+	//    reqid     - outputs Request ID from HTTP header
 	//    principal - outputs Logged-In subject primary principal
 	//    level     - outputs INFO, DEBUG, ERROR, so on
 	//    time      - outputs local time as per format supplied
@@ -143,7 +143,7 @@ func textFormatter(flags []ess.FmtFlagPart, entry *Entry) []byte {
 				buf.WriteString("fields[")
 				for k, v := range entry.Fields {
 					cnt--
-					buf.WriteString(fmt.Sprintf("%v=%v", k, v))
+					buf.WriteString(fmt.Sprintf("%v: %v", k, v))
 					if cnt != 0 {
 						buf.WriteString(", ")
 					}

log.go

@@ -61,6 +61,17 @@ var (
 )
 
 type (
+	// Logger is the object which logs the given message into recevier as per deifned
+	// format flags. Logger can be used simultaneously from multiple goroutines;
+	// it guarantees to serialize access to the Receivers.
+	Logger struct {
+		cfg      *config.Config
+		m        *sync.Mutex
+		level    level
+		receiver Receiver
+		ctx      Fields
+	}
+
 	// Receiver is the interface for pluggable log receiver.
 	// For e.g: Console, File
 	Receiver interface {
@@ -72,16 +83,6 @@ type (
 		Log(e *Entry)
 	}
 
-	// Logger is the object which logs the given message into recevier as per deifned
-	// format flags. Logger can be used simultaneously from multiple goroutines;
-	// it guarantees to serialize access to the Receivers.
-	Logger struct {
-		cfg      *config.Config
-		m        *sync.Mutex
-		level    level
-		receiver Receiver
-	}
-
 	// Logger and Entry log method compliance.
 	loggerInterface interface {
 		Error(v ...interface{})
@@ -140,13 +141,34 @@ func New(cfg *config.Config) (*Logger, error) {
 		return nil, err
 	}
 
+	logger.ctx = make(Fields)
+
 	return logger, nil
 }
 
 //‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
 // Logger methods
 //___________________________________
 
+// New method creates a child logger and adds structured context to it. Child
+// logger inherits parent logger context value on creation. Fields added
+// to the child don't affect the parent logger and vice versa. These context
+// values gets logged with each log entry.
+//
+// Also you can use method `AddContext` to context to the current logger.
+func (l *Logger) New(fields Fields) *Logger {
+	nl := *l
+	nl.AddContext(fields)
+	return &nl
+}
+
+// AddContext method to add context values into current logger.
+func (l *Logger) AddContext(fields Fields) {
+	for k, v := range fields {
+		l.ctx[k] = v
+	}
+}
+
 // Level method returns currently enabled logging level.
 func (l *Logger) Level() string {
 	return levelToLevelName[l.level]
@@ -307,7 +329,9 @@ func (l *Logger) WithFields(fields Fields) *Entry {
 
 // WithField method to add single key-value into log
 func (l *Logger) WithField(key string, value interface{}) *Entry {
-	return l.WithFields(Fields{key: value})
+	e := acquireEntry(l)
+	defer releaseEntry(e)
+	return e.WithField(key, value)
 }
 
 //‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾