wlog

type AtomicLogLevel struct {
	// contains filtered or unexported fields
}

type LevelChecker interface {
	// Enabled determines whether the provided level should be logged.
	// If implemented with LeveledLogger or SetLevel, they must remain consistent with Enabled.
	Enabled(level LogLevel) bool
}

type LeveledLogger interface {
	Debug(msg string, params ...Param)
	Info(msg string, params ...Param)
	Warn(msg string, params ...Param)
	Error(msg string, params ...Param)
	SetLevel(level LogLevel)
}

type LeveledLoggerCreator func(w io.Writer, level LogLevel) LeveledLogger

type LogEntry interface {
	StringValue(k, v string)
	OptionalStringValue(k, v string)
	SafeLongValue(k string, v int64)
	IntValue(k string, v int32)
	StringListValue(k string, v []string)
	StringMapValue(k string, v map[string]string)
	AnyMapValue(k string, v map[string]interface{})

	// ObjectValue logs the provided value associated with the specified key. If marshalerType is non-nil, then if a
	// custom marshaler is registered for that type, it may be used to log the entry. If marshalerType is nil or no
	// marshaler is registered for the provided type, the entry should be logged using reflection.
	ObjectValue(k string, v interface{}, marshalerType reflect.Type)
}

type LogLevel string

type Logger interface {
	Log(params ...Param)
}

type LoggerCreator func(w io.Writer) Logger

type LoggerProvider interface {
	NewLogger(w io.Writer) Logger
	NewLeveledLogger(w io.Writer, level LogLevel) LeveledLogger
}

type MapLogEntry interface {
	LogEntry

	StringValues() map[string]string
	SafeLongValues() map[string]int64
	IntValues() map[string]int32
	StringListValues() map[string][]string
	StringMapValues() map[string]map[string]string
	AnyMapValues() map[string]map[string]interface{}
	ObjectValues() map[string]ObjectValue

	// Apply applies the values of all of the stored entries of this MapLogEntry to the provided LogEntry.
	Apply(logEntry LogEntry)
	// AllValues returns a single map that contains all of the keys and values stored in this entry.
	AllValues() map[string]interface{}
}

type MapValueEntries struct {
	// contains filtered or unexported fields
}

type ObjectValue struct {
	Value         interface{}
	MarshalerType reflect.Type
}

type Param interface {
	// contains filtered or unexported methods
}