logger

func (*CLEFSink) Log(e Entry) error
{
	// Build a flat map so structured fields sit at the root level.
	m := make(map[string]any, len(e.Fields)+3)
	for k, v := range e.Fields {
		m[k] = v
	}

	m["@t"] = e.Time.UTC().Format(time.RFC3339Nano)
	m["@m"] = e.Msg

	// @l is omitted for Information per the CLEF spec.
	if lvl, ok := clefLevel[e.Level]; ok {
		m["@l"] = lvl
	}

	b, err := json.Marshal(m)
	if err != nil {
		return err
	}
	_, err = c.w.Write(append(b, '\n'))
	return err
}

func (*stdLogger) processAsync()
{
	defer l.wg.Done()
	for e := range l.ch {
		l.mu.RLock()
		sinks := l.sinks
		l.mu.RUnlock()
		for _, sink := range sinks {
			_ = sink.Log(e)
		}
	}
}

func (*stdLogger) With(fields ...Field) Logger
{
	l.mu.RLock()
	defer l.mu.RUnlock()

	nextFields := make(map[string]interface{}, len(l.fields)+len(fields))
	for k, v := range l.fields {
		nextFields[k] = v
	}
	for _, f := range fields {
		nextFields[f.Key] = f.Value
	}

	child := &stdLogger{
		sinks:  append([]Sink(nil), l.sinks...),
		level:  l.level,
		fields: nextFields,
		ctx:    l.ctx,
		async:  l.async,
		ch:     l.ch,
	}
	return child
}

func (*stdLogger) log(level Level, msg string, fields ...Field)
{
	if !l.shouldLog(level) {
		return
	}

	entry := Entry{
		Level: level.String(),
		Time:  time.Now().UTC(),
		Msg:   msg,
		Fields: map[string]interface{}{},
	}

	l.mu.RLock()
	for k, v := range l.fields {
		entry.Fields[k] = v
	}
	sinks := append([]Sink(nil), l.sinks...)
	ctx := l.ctx
	l.mu.RUnlock()

	if ctx != nil {
		if tid, ok := ctx.Value("trace_id").(string); ok {
			entry.TraceID = tid
		}
		if sid, ok := ctx.Value("span_id").(string); ok {
			entry.SpanID = sid
		}
	}

	for _, f := range fields {
		entry.Fields[f.Key] = f.Value
	}

	if l.async {
		select {
		case l.ch <- entry:
		default:
		}
		return
	}

	for _, sink := range sinks {
		_ = sink.Log(entry)
	}
}