golog

type LocationFlag int

type LocationLogger interface {
	Logger
	LogDepth(level int, closure func() string, depth int)
}

type LogMessage struct {
	Level       int
	Nanoseconds time.Time
	Message     string
	// A map from the type of metadata to the metadata, if present.
	// By convention, fields in this map will be entirely lowercase and
	// single word.
	Metadata map[string]string
}

type LogOuter interface {
	// Output a LogMessage (to a file, to stderr, to a tester, etc). Output
	// must be safe to call from multiple threads.
	Output(*LogMessage)
}

type Logger interface {
	// If the message is to be logged, evaluates the closure and outputs
	// the result.
	Log(level int, closure func() *LogMessage)
	// Fail and halt standard control flow.
	FailNow()
	// All future calls to log with log only if the message is at
	// level or higher.
	// TODO(awreece) Put in different interface to keep Logger agnostic?
	SetMinLogLevel(level int)
}

type LoggerFlag interface {
	Logger
	flag.Value
}

type MetadataFunc func(skip int) map[string]string

type MultiLogOuter interface {
	LogOuter
	// Add the LogOuter, associating it with the key.
	AddLogOuter(key string, outer LogOuter)
	// Remove the LogOuter associated with the key.
	RemoveLogOuter(key string)
}

type MultiLogOuterFlag interface {
	MultiLogOuter
	flag.Value
}

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

type StringLogger interface {
	// Log the message at the level provided, formatting the message as if
	// via a call to fmt.Sprint (only rendering string if the message will
	// be logged).
	Log(level int, msg ...interface{})
	// Log the message at the level provided, formatting the message as if
	// via a call to fmt.Sprintf (only rendering the string if the message
	// will be logged).
	Logf(level int, fmt string, val ...interface{})
	// Log the message at the level provided. Only evaluates the closure if
	// the message will be logged.
	Logc(int, func() string)
	// Log the message at the INFO level, formatting the message as if via
	// a call to fmt.Sprint and only rendering the string if the message
	// will be logged.
	Info(msg ...interface{})
	// Log the message at the INFO level, formatting the message as if via
	// a call to fmt.Sprintf and only rendering the string if the message
	// will be logged.
	Infof(string, ...interface{})
	// Log the message at the INFO level, only evaluating the closure and
	// rendering the string if the message will be logged.
	Infoc(func() string)
	// Log the message at the WARNING level, formatting the message as if via
	// a call to fmt.Sprint and only rendering the string if the message
	// will be logged.
	Warning(...interface{})
	// Log the message at the WARNING level, formatting the message as if via
	// a call to fmt.Sprintf and only rendering the string if the message
	// will be logged.
	Warningf(string, ...interface{})
	// Log the message at the WARNING level, only evaluating the closure and
	// rendering the string if the message will be logged.
	Warningc(func() string)
	// Log the message at the ERROR level, formatting the message as if via
	// a call to fmt.Sprint and only rendering the string if the message
	// will be logged.
	Error(...interface{})
	// Log the message at the ERROR level, formatting the message as if via
	// a call to fmt.Sprintf and only rendering the string if the message
	// will be logged.
	Errorf(string, ...interface{})
	// Log the message at the ERROR level, only evaluating the closure and
	// rendering the string if the message will be logged.
	Errorc(func() string)
	// Log the message at the FATAL level, formatting the message as if via
	// a call to fmt.Sprint and only rendering the string if the message
	// will be logged. Afterwards, calls a LogOuter.FailNow().
	Fatal(...interface{})
	// Log the message at the FATAL level, formatting the message as if via
	// a call to fmt.Sprintf and only rendering the string if the message
	// will be logged. Afterwards, calls a LogOuter.FailNow()
	Fatalf(string, ...interface{})
	// Log the message at the FATAL level, only evaluating the closure and
	// rendering the string if the message will be logged. Afterwards,
	// calls a LogOuter.FailNow().
	Fatalc(func() string)
}

type TestController interface {
	// We will assume that testers insert newlines in manner similar to
	// the FEATURE of testing.T where it inserts extra newlines. >.<
	Log(...interface{})
	FailNow()
}