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) 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{
		fields: nextFields,
		ctx:    l.ctx,
		async:  l.async,
		shared: l.shared,
		owner:  false,
	}
	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
	}
	ctx := l.ctx
	l.mu.RUnlock()
	l.shared.mu.RLock()
	sinks := append([]Sink(nil), l.shared.sinks...)
	l.shared.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 != nil {
		l.async.submit(asyncItem{entry: entry, sinks: sinks})
		return
	}

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

func (*stdLogger) Shutdown(ctx context.Context) error
{
	if l.async == nil || !l.owner {
		return nil
	}
	if ctx == nil {
		ctx = context.Background()
	}
	l.async.startClose()
	select {
	case <-l.async.done:
		return nil
	case <-ctx.Done():
		return ctx.Err()
	}
}

func (*asyncState) submit(item asyncItem)
{
	s.mu.Lock()
	if s.closed {
		s.mu.Unlock()
		return
	}
	s.submitWG.Add(1)
	s.mu.Unlock()

	send := func() {
		defer s.submitWG.Done()
		select {
		case s.ch <- item:
		default:
		}
	}
	send()
}

func (*asyncState) startClose()
{
	s.closeOnce.Do(func() {
		s.mu.Lock()
		s.closed = true
		s.mu.Unlock()

		go func() {
			s.submitWG.Wait()
			close(s.ch)
			s.workerWG.Wait()
			close(s.done)
		}()
	})
}