logger

type Controller ¶

type Controller interface {
	SetOutput(io.Writer)
	GetOutput() io.Writer
}

type DebugMessageLogger ¶

type DebugMessageLogger interface {
	Debugf(format string, args ...any)
	Debug(args ...any)
}

type ErrorMessageLogger ¶

type ErrorMessageLogger interface {
	Errorf(format string, args ...any)
	Error(args ...any)
}

type FieldLogger ¶

type FieldLogger interface {
	WithFields(fields ...any) MessageLogger
}

type Fields ¶

type Fields map[string]any

type InfoMessageLogger ¶

type InfoMessageLogger interface {
	Infof(format string, args ...any)
	Info(args ...any)
}

type Level ¶

type Level string

const (
	DisabledLevel Level = ""
	ErrorLevel    Level = "error"
	WarnLevel     Level = "warn"
	InfoLevel     Level = "info"
	DebugLevel    Level = "debug"
	TraceLevel    Level = "trace"
)

func LevelFromString(l string) (Level, error)

func LevelFromVerbosity(v int, levels ...Level) Level

func Levels() []Level

type Logger ¶

type Logger interface {
	MessageLogger
	FieldLogger
	NestedLogger
}

type MessageLogger ¶

type MessageLogger interface {
	ErrorMessageLogger
	WarnMessageLogger
	InfoMessageLogger
	DebugMessageLogger
	TraceMessageLogger
}

type NestedLogger ¶

type NestedLogger interface {
	Nested(fields ...any) Logger
}

type TerminalWriter ¶ added in v0.2.0

type TerminalWriter interface {
	io.Writer
	IsTerminal() bool
}

TerminalWriter is an output that is not a terminal file itself but whose contents are ultimately rendered to one (e.g. a buffer drawn by a TUI). Formatters use this to decide on terminal-only styling, such as colors.

IsTerminal is called for every entry while the logger holds its lock, so it must be cheap, safe for concurrent use, and must never log (doing so will deadlock). Only implement this when everything written ends up on a terminal; a tee that also writes to a file would get ANSI codes in that file. Wrappers such as io.MultiWriter and bufio.Writer do not forward IsTerminal, so wrapping a TerminalWriter drops the signal.

type TraceMessageLogger ¶

type TraceMessageLogger interface {
	Tracef(format string, args ...any)
	Trace(args ...any)
}

type WarnMessageLogger ¶

type WarnMessageLogger interface {
	Warnf(format string, args ...any)
	Warn(args ...any)
}