core

type Destructurer interface {
	// TryDestructure attempts to destructure a value into a log event property.
	// Returns the property and true if successful, nil and false otherwise.
	TryDestructure(value interface{}, propertyFactory LogEventPropertyFactory) (*LogEventProperty, bool)
}

type LogEvent struct {
	// Timestamp is when the event occurred.
	Timestamp time.Time

	// Level is the severity of the event.
	Level LogEventLevel

	// MessageTemplate is the original message template with placeholders.
	MessageTemplate string

	// Properties contains the event's properties extracted from the template.
	Properties map[string]interface{}

	// Exception associated with the event, if any.
	Exception error
}

type LogEventEnricher interface {
	// Enrich adds properties to the provided log event.
	Enrich(event *LogEvent, propertyFactory LogEventPropertyFactory)
}

type LogEventFilter interface {
	// IsEnabled returns true if the event should be logged.
	IsEnabled(event *LogEvent) bool
}

type LogEventLevel int

type LogEventProperty struct {
	// Name is the property name.
	Name string

	// Value is the property value.
	Value interface{}
}

type LogEventPropertyFactory interface {
	// CreateProperty creates a new log event property.
	CreateProperty(name string, value interface{}) *LogEventProperty
}

type LogEventSink interface {
	// Emit writes the log event to the sink's destination.
	Emit(event *LogEvent)

	// Close releases any resources held by the sink.
	Close() error
}

type LogValue interface {
	// LogValue returns the value to be logged. This can be a simple type
	// (string, number, bool) or a complex type (struct, map, slice).
	// The returned value may itself be destructured if it's complex.
	LogValue() interface{}
}

type Logger interface {
	// Verbose writes a verbose-level log event.
	Verbose(messageTemplate string, args ...interface{})

	// Debug writes a debug-level log event.
	Debug(messageTemplate string, args ...interface{})

	// Information writes an information-level log event.
	Information(messageTemplate string, args ...interface{})

	// Warning writes a warning-level log event.
	Warning(messageTemplate string, args ...interface{})

	// Error writes an error-level log event.
	Error(messageTemplate string, args ...interface{})

	// Fatal writes a fatal-level log event.
	Fatal(messageTemplate string, args ...interface{})

	// Write writes a log event at the specified level.
	Write(level LogEventLevel, messageTemplate string, args ...interface{})

	// ForContext creates a logger that enriches events with the specified property.
	ForContext(propertyName string, value interface{}) Logger

	// WithContext creates a logger that enriches events with context values.
	WithContext(ctx context.Context) Logger

	// IsEnabled returns true if events at the specified level would be processed.
	IsEnabled(level LogEventLevel) bool

	// Info writes an information-level log event (alias for Information).
	Info(messageTemplate string, args ...interface{})

	// Warn writes a warning-level log event (alias for Warning).
	Warn(messageTemplate string, args ...interface{})
}

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

type PropertyValue[T any] struct {
	// contains filtered or unexported fields
}

type SimpleSink interface {
	LogEventSink

	// EmitSimple writes a simple log message without allocations.
	EmitSimple(timestamp time.Time, level LogEventLevel, message string)
}