logger

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

type Config map[string]Level

type Labels map[string]string

type Level uint32

type LogRecord struct {
	Time time.Time

	// origin fields
	ModelUUID string
	Entity    string

	// logging-specific fields
	Level    Level
	Module   string
	Location string
	Message  string
	Labels   map[string]string
}

type LogSink interface {
	LogWriter
}

type LogWriter interface {
	// Log writes the given log records to the logger's storage.
	Log([]LogRecord) error
}

type Logger interface {
	// Criticalf logs a message at the critical level.
	Criticalf(ctx context.Context, msg string, args ...any)

	// Errorf logs a message at the error level.
	Errorf(ctx context.Context, msg string, args ...any)

	// Warningf logs a message at the warning level.
	Warningf(ctx context.Context, msg string, args ...any)

	// Infof logs a message at the info level.
	Infof(ctx context.Context, msg string, args ...any)

	// Debugf logs a message at the debug level.
	Debugf(ctx context.Context, msg string, args ...any)

	// Tracef logs a message at the trace level.
	Tracef(ctx context.Context, msg string, args ...any)

	// Logf logs information at the given level.
	// The provided arguments are assembled together into a string with
	// fmt.Sprintf.
	Logf(ctx context.Context, level Level, labels Labels, format string, args ...any)

	// IsLevelEnabled returns true if the given level is enabled for the logger.
	IsLevelEnabled(Level) bool

	// Child returns a new logger with the given name.
	Child(name string, tags ...string) Logger

	// GetChildByName returns a child logger with the given name.
	GetChildByName(name string) Logger

	// Helper marks the caller as a helper function.
	Helper()
}

type LoggerContext interface {
	// GetLogger returns a logger with the given name and tags.
	GetLogger(name string, tags ...string) Logger

	// ConfigureLoggers configures loggers according to the given string
	// specification, which specifies a set of modules and their associated
	// logging levels. Loggers are colon- or semicolon-separated; each module is
	// specified as <modulename>=<level>.  White space outside of module names
	// and levels is ignored. The root module is specified with the name
	// "<root>".
	//
	// An example specification:
	//
	//  <root>=ERROR; foo.bar=WARNING
	//
	// Label matching can be applied to the loggers by providing a set of labels
	// to the function. If a logger has a label that matches the provided
	// labels, then the logger will be configured with the provided level. If
	// the logger does not have a label that matches the provided labels, then
	// the logger will not be configured. No labels will configure all loggers
	// in the specification.
	ConfigureLoggers(specification string) error

	// ResetLoggerLevels iterates through the known logging modules and sets the
	// levels of all to UNSPECIFIED, except for <root> which is set to WARNING.
	// If labels are provided, then only loggers that have the provided labels
	// will be reset.
	ResetLoggerLevels()

	// Config returns the current configuration of the Loggers. Loggers
	// with UNSPECIFIED level will not be included.
	Config() Config
}

type LoggerContextGetter interface {
	// GetLoggerContext returns a LoggerContext for the given name.
	GetLoggerContext(ctx context.Context, modelUUID model.UUID) (LoggerContext, error)
}

type LoggerKey struct {
	ModelUUID string
}

type ModelLogSinkGetter interface {
	ModelLogger
	LoggerContextGetter
}

type ModelLogger interface {
	// GetLogWriter returns a log writer for the given model and keeps
	// track of it, returning the same one if called again.
	GetLogWriter(ctx context.Context, modelUUID model.UUID) (LogWriter, error)
}

type Tag = string

type TaggedRedirectWriter struct {
	LogSink   LogSink
	Tag       string
	ModelUUID string
}