default.go

package logging

import (
	"context"
	"sync/atomic"
)

// Logger implemented by Default.
var _ Logger = (*Default)(nil)

// defaultInner is a pair of loggers made for a backend.
type defaultInner struct {
	backend *Backend
	plain   Logger     // to derive new loggers
	direct  *zapLogger // to write records, skips Default method frame in caller detection
}

// Default logger provides logging methods with default setting in case customisation is not required.
// Zero value is ready to use, so it fits package level variable: var log logging.Default.
// It follows Init: after the backend is replaced it logs through the new one.
// It still allows to make descendant fully-functional loggers when required.
type Default struct {
	inner atomic.Value // *defaultInner
}

// get returns loggers for the active backend.
func (l *Default) get() *defaultInner {
	backend := activeBackend()

	if cur, ok := l.inner.Load().(*defaultInner); ok && cur.backend == backend {
		return cur
	}

	plain := backend.newLogger()
	cur := &defaultInner{backend: backend, plain: plain, direct: plain.addCallerSkip(1)}
	l.inner.Store(cur)

	return cur
}

// Level returns current logger level, which is the configured global level.
func (l *Default) Level() Level {
	return l.get().plain.Level()
}

// IsEnabledForLevel detects if internal logging level suitable to produce messages with specified logging.Level.
func (l *Default) IsEnabledForLevel(level Level) bool {
	return l.get().plain.IsEnabledForLevel(level)
}

// WithKeys provides a new logger instance having specified key-value set.
func (l *Default) WithKeys(fields Keys) Logger {
	return l.get().plain.WithKeys(fields)
}

// WithKey provides a new logger instance having specified key-value pair set.
func (l *Default) WithKey(key string, value any) Logger {
	return l.get().plain.WithKey(key, value)
}

// WithError provides a new logger instance having specified error key.
func (l *Default) WithError(err error) Logger {
	return l.get().plain.WithError(err)
}

// WithLevel provides a new logger instance inherit settings from parent except specified logging level.
func (l *Default) WithLevel(level Level) Logger {
	return l.get().plain.WithLevel(level)
}

// WithName provides a new named logger instance. Its level is chosen like NewNamedLogger does.
func (l *Default) WithName(name string) Logger {
	return l.get().backend.NewNamedLogger(name)
}

// WithContext provides a new logger instance with context data attached.
func (l *Default) WithContext(ctx context.Context) Logger {
	return l.get().plain.WithContext(ctx)
}

// Sync flushes any buffered log entries.
func (l *Default) Sync() error {
	return l.get().direct.Sync()
}

// Panic writes a record of level panic and panics with the message regardless of the logger level.
func (l *Default) Panic(args ...interface{}) { l.get().direct.Panic(args...) }

// Panicf writes a formatted record of level panic and panics with the message regardless of the logger level.
func (l *Default) Panicf(fmt string, args ...interface{}) { l.get().direct.Panicf(fmt, args...) }

// Trace sends trace level data onto logging.
func (l *Default) Trace(args ...interface{}) { l.get().direct.Trace(args...) }

// Tracef sends trace level message template formatted with specified arguments.
func (l *Default) Tracef(fmt string, args ...interface{}) { l.get().direct.Tracef(fmt, args...) }

// Debug sends debug level data onto logging.
func (l *Default) Debug(args ...interface{}) { l.get().direct.Debug(args...) }

// Debugf sends debug level message template formatted with specified arguments.
func (l *Default) Debugf(fmt string, args ...interface{}) { l.get().direct.Debugf(fmt, args...) }

// Info sends info level data onto logging.
func (l *Default) Info(args ...interface{}) { l.get().direct.Info(args...) }

// Infof sends info level message template formatted with specified arguments.
func (l *Default) Infof(fmt string, args ...interface{}) { l.get().direct.Infof(fmt, args...) }

// Warn sends warning level data onto logging.
func (l *Default) Warn(args ...interface{}) { l.get().direct.Warn(args...) }

// Warnf sends warning level message template formatted with specified arguments.
func (l *Default) Warnf(fmt string, args ...interface{}) { l.get().direct.Warnf(fmt, args...) }

// Error sends error level data onto logging.
func (l *Default) Error(args ...interface{}) { l.get().direct.Error(args...) }

// Errorf sends error level message template formatted with specified arguments.
func (l *Default) Errorf(fmt string, args ...interface{}) { l.get().direct.Errorf(fmt, args...) }

// Fatal sends fatal level data onto logging and terminates the process.
func (l *Default) Fatal(args ...interface{}) { l.get().direct.Fatal(args...) }

// Fatalf sends fatal level message template formatted with specified arguments and terminates the process.
func (l *Default) Fatalf(fmt string, args ...interface{}) { l.get().direct.Fatalf(fmt, args...) }