mediocre-go-lib/mlog/cmp.go

package mlog

import (
	"github.com/mediocregopher/mediocre-go-lib/mcmp"
	"github.com/mediocregopher/mediocre-go-lib/mctx"
)

type cmpKey int

const (
	cmpKeyLogger cmpKey = iota
	cmpKeyCachedLogger
)

// SetLogger sets the given logger onto the Component. The logger can later be
// retrieved from the Component, or any of its children, using From.
//
// NOTE that if a Logger is set onto a Component and then changed, even though
// the Logger is a pointer and so is changed within the Component, SetLogger
// should still be called. This is due to some caching that From does for
// performance.
func SetLogger(cmp *mcmp.Component, l *Logger) {
	cmp.SetValue(cmpKeyLogger, l)

	// If the base Logger on this Component gets changed, then the cached Logger
	// from From on this Component, and all of its Children, ought to be reset,
	// so that any changes can be reflected in their loggers.
	var resetFromLogger func(*mcmp.Component)
	resetFromLogger = func(cmp *mcmp.Component) {
		cmp.SetValue(cmpKeyCachedLogger, nil)
		for _, childCmp := range cmp.Children() {
			resetFromLogger(childCmp)
		}
	}
	resetFromLogger(cmp)
}

// DefaultLogger is an instance of Logger which is returned by From when a
// Logger hasn't been previously set with SetLogger on the passed in Component.
var DefaultLogger = NewLogger()

// GetLogger returns the Logger which was set on the Component, or on of its
// ancestors, using SetLogger. If no Logger was ever set then DefaultLogger is
// returned.
func GetLogger(cmp *mcmp.Component) *Logger {
	if l, ok := mcmp.InheritedValue(cmp, cmpKeyLogger); ok {
		return l.(*Logger)
	}
	return DefaultLogger
}

// From returns the result from GetLogger, modified so as to automatically add
// some annotations related to the Component itself to all Messages being
// logged.
func From(cmp *mcmp.Component) *Logger {
	if l, _ := cmp.Value(cmpKeyCachedLogger).(*Logger); l != nil {
		return l
	}

	// if we're here it means a modified Logger wasn't set on this particular
	// Component, and therefore the current one must be modified.
	l := GetLogger(cmp).Clone()
	oldHandler := l.Handler()
	l.SetHandler(func(msg Message) error {
		ctx := mctx.MergeAnnotationsInto(cmp.Context(), msg.Contexts...)
		msg.Contexts = append(msg.Contexts[:0], ctx)
		return oldHandler(msg)
	})
	cmp.SetValue(cmpKeyCachedLogger, l)

	return l
}